Publicado por primera vez en el blog personal de Enaium
Los casos de uso oficialesJimmer
utilizados en este artículo se utilizan para presentar el método de uso y, al mismo tiempo, admiten y , este artículo se utiliza para presentar, de hecho, es más conveniente que usar, aquí para la conveniencia de que todos lo entiendan. , use para presentar, este artículo es solo una breve introducción, más Consulte el documento oficial para conocer el contenidoJimmer
Jimmer
Java
Kotlin
Java
Kotlin
Java
Java
Jimmer
No empecemos con la introducción de la clase de entidad, aquí hay una breve introducción a la relación entre las tres tablas utilizadas:
BookStore
Una librería puede tener múltiplesBook
Book
Los libros pueden pertenecer a múltiplesBookStore
, pueden tener múltiplesAuthor
Author
Los autores pueden tener variasBook
relaciones de muchos a muchos de libro a autor.
Preguntar
Jimmer
Se puede usar SpringData
(no SpringDataJPA
), pero aquí primero presentaremos SpringData
el uso del método de separación, pero aún en SpringBoot
el entorno, aquí usamos H2
la base de datos de memoria, Jimmer
soporte H2
, MySQL
, PostgreSQL
y Oracle
otras bases de datos, aquí usamos H2
la base de datos de memoria.
Las consultas aquí se usan Controller
para demostración.
Encuentra todas las librerías
createQuery
Es para crear una consulta, select
que es seleccionar el campo a consultar, y aquí se pasa directamente BookStoreTable
para representar todos los campos a consultar.
Lo que se utiliza aquí sql
es el objeto utilizado Jimmer
. Sql
Este objeto es Jimmer
el objeto central. Todas las consultas se realizan a través de este objeto, y Spring
el método de inyección utilizado se inyecta en JSqlClient
el objeto.
final BookStoreTable bookStore = BookStoreTable.$;//这里的$是一个静态方法,返回一个BookStoreTable对象
sql.createQuery(bookStore).select(bookStore).execute();
Los resultados de la consulta son los siguientes:
[
{
"createdTime": "2023-05-27 11:00:37",
"modifiedTime": "2023-05-27 11:00:37",
"id": 1,
"name": "O'REILLY",
"website": null
},
{
"createdTime": "2023-05-27 11:00:37",
"modifiedTime": "2023-05-27 11:00:37",
"id": 2,
"name": "MANNING",
"website": null
}
]
especificar campos de consulta
Así es como necesita consultar el campo especificado. Aquí name
hay BookStoreTable
un campo, pero aquí Controller
hay BookStore
un objeto, así que simplemente consulte todos los campos como se indicó anteriormente.
sql.createQuery(bookStore).select(bookStore.name()).execute();
Como en el ejemplo anterior, si insistimos en consultar el campo especificado y no queremos definir un nuevo DTO
objeto, entonces esto Jimmer
también se puede implementar de manera muy simple, es decir, el en Jimmer
usoFetchr
BookStore
Los campos utilizados Fetchr
para especificar la consulta
sql.createQuery(bookStore).select(bookStore.fetch(BookStoreFetcher.$.name())).execute();
Los resultados de la consulta son los siguientes:
[
{
"id": 2,
"name": "MANNING"
},
{
"id": 1,
"name": "O'REILLY"
}
]
Sorprendentemente, Controller
el tipo de devolución es , pero solo hay campos y BookStore
en los resultados de la consulta .id
name
Controller
Aquí publico el código completo , List
el tipo de es BookStore
la clase de entidad de, que es Jimmer
el poder de, sin definir DTO
el objeto, puede realizar la función de consultar el campo especificado.
@GetMapping("/simpleList")
public List<BookStore> findSimpleStores() {
final BookStoreTable bookStore = BookStoreTable.$;//这里的$是一个静态方法,返回一个BookStoreTable对象
return sql.createQuery(bookStore).select(bookStore.fetch(BookStoreFetcher.$.name())).execute();
}
Al igual que las clases de entidad Table
, Fetcher
también es posible declarar una constante estática.
private static final Fetcher<BookStore> SIMPLE_FETCHER = BookStoreFetcher.$.name();
Así es como se puede usar.
sql.createQuery(bookStore).select(bookStore.fetch(SIMPLE_FETCHER)).execute();
Fetcher
El uso descrito en detalle a continuación
Consulta todos los campos escalares, es decir, campos no relacionales.
private static final Fetcher<BookStore> DEFAULT_FETCHER = BookStoreFetcher.$.allScalarFields();//这里的allScalarFields()就是查询所有标量字段
Campos no BookStore
consultados encima de todos los campos escalaresname
private static final Fetcher<BookStore> DEFAULT_FETCHER = BookStoreFetcher.$.allScalarFields().name(false);//这里的name(false)就是不查询name字段
Especificar campos relacionados con la consulta
像这样查询所有书店的所有书籍,并且查询书籍的所有作者,这样就可以使用Fetcher
来实现,如果在使用传统ORM
框架时,这里就需要定义一个DTO
对象来接收查询结果,但是在Jimmer
中,不需要定义DTO
对象,就可以实现查询指定字段的功能,可能有读者会问了,没有DTO
前端怎么接收数据呢,这里先剧透一下,Jimmer
会根据后端写的Fetcher
来生成前端的DTO
,这里就不多说了,后面会详细介绍.
private static final Fetcher<BookStore> WITH_ALL_BOOKS_FETCHER =
BookStoreFetcher.$
.allScalarFields()//查询所有标量字段
.books(//查询关联字段
BookFetcher.$//书籍的Fetcher
.allScalarFields()//查询所有标量字段
.authors(//查询关联字段
AuthorFetcher.$//作者的Fetcher
.allScalarFields()//查询所有标量字段
)
);
稍剧透一点,这里如果使用Kotlin
来编写会更加简洁,因为Kotlin
中的DSL
特性
private val WITH_ALL_BOOKS_FETCHER = newFetcher(BookStore::class).by {
allScalarFields()//查询所有标量字段
books {//查询关联字段
allScalarFields()//查询所有标量字段
authors {//查询关联字段
allScalarFields()//查询所有标量字段
}
}
}
这么一看Kotlin
确实比Java
简洁很多,但本篇文章还是介绍的是Java
的使用方法.
指定查询条件和计算结果字段
如果需要查询书店中所有书籍的平均价格,那么就要查询书店中所有书籍的价格,然后计算平均值,这里先把查询的代码写出来,然后在介绍如何把计算结果字段添加到Fetcher
中.
sql.createQuery(bookStore)//这里的bookStore是一个BookStoreTable对象
.where(bookStore.id().in(ids))//要查询的书店的id集合,也可以直接指定id,比如.eq(1L)
.groupBy(bookStore.id())//按照书店的id分组
.select(
bookStore.id(),//查询书店的id
bookStore.asTableEx().books(JoinType.LEFT).price().avg().coalesce(BigDecimal.ZERO)//查询书店中所有书籍的平均价格
)
.execute();//这样执行查询后,返回的结果就是书店的id和书店中所有书籍的平均价格,在Jimmer中会返回一个List<Tuple2<...>>类型的结果,其中Tuple元组的数量和查询的字段数量一致,这里就是2个字段,所以就是Tuple2
这里最后的select
是查出了书店的 id 和书店中所有书籍的平均价格,asTableEx()
是为了突破Jimmer
的限制,Jimmer
中的Table
只能查询标量字段,而不能查询关联字段,这里的asTableEx()
就是为了查询关联字段,asTableEx()
的参数是JoinType
,这里的JoinType
是LEFT
,表示左连接,如果不指定JoinType
,默认是INNER
,表示内连接.
这里的avg()
是计算平均值的意思,coalesce(BigDecimal.ZERO)
是为了防止计算结果为null
,如果计算结果为null
,那么就返回BigDecimal.ZERO
.
这里介绍如何把计算结果字段添加到Fetcher
中,这样就又引出了一个Jimmer
的功能计算属性
计算属性
在Jimmer
中如果要添加计算属性,那么就要实现TransientResolver
接口,这里先把代码贴出来,然后再详细介绍.
@Component
public class BookStoreAvgPriceResolver implements TransientResolver<Long, BigDecimal> {
@Override
public Map<Long, BigDecimal> resolve(Collection<Long> ids) {
return null;
}
}
这里的ids
就是书店的 id 集合,这里的resolve
方法就是计算书店中所有书籍的平均价格,这里的Long
是书店的 id,BigDecimal
是书店中所有书籍的平均价格,这里的resolve
方法返回的Map
的key
就是书店的 id,value
就是书店中所有书籍的平均价格.
接着配合上面写的查询代码,完成计算的代码
BookStoreTable bookStore = BookStoreTable.$;
return sql.createQuery(bookStore)
.where(bookStore.id().in(ids))
.groupBy(bookStore.id())
.select(
bookStore.id(),
bookStore.asTableEx().books(JoinType.LEFT).price().avg().coalesce(BigDecimal.ZERO)
)
.execute()//这里的execute()返回的结果是List<Tuple2<Long, BigDecimal>>类型的
.stream()//这里把List转换成Stream
.collect(
Collectors.toMap(Tuple2::get_1, Tuple2::get_2)//这里把List<Tuple2<Long, BigDecimal>>转换成Map<Long, BigDecimal>
);
这样一个TransientResolver
的实现就完成了,接着就是把TransientResolver
添加到实体类中
Jimmer
中定义实体类是在接口中定义的
@Transient(BookStoreAvgPriceResolver.class)//这里的BookStoreAvgPriceResolver.class就是上面写的计算属性的实现
BigDecimal avgPrice();//这里的avgPrice()就是计算属性,这里的BigDecimal就是计算属性的类型
这样就可以直接在Fetcher
中查询计算属性了
private static final Fetcher<BookStore> WITH_ALL_BOOKS_FETCHER =
BookStoreFetcher.$
.allScalarFields()
.avgPrice()//这里就是查询计算属性
//...省略
接着看戏生成的SQL
代码和查询结果,这里照样省略其他查询只关注标量字段和计算属性
select
tb_1_.ID,
coalesce(
avg(tb_2_.PRICE), ? /* 0 */
)
from BOOK_STORE tb_1_
left join BOOK tb_2_
on tb_1_.ID = tb_2_.STORE_ID
where
tb_1_.ID in (
? /* 1 */
)
group by
tb_1_.ID
{
"createdTime": "2023-05-27 12:04:39",
"modifiedTime": "2023-05-27 12:04:39",
"id": 1,
"name": "O'REILLY",
"website": null,
"avgPrice": 58.5
}
定义实体类
在Jimmer
中定义实体类是在接口中定义的,这里先把代码贴出来,然后再详细介绍.
BookStore
@Entity//这里的@Entity就是实体类
public interface BookStore extends BaseEntity {
@Id//这里的@Id就是主键
@GeneratedValue(strategy = GenerationType.IDENTITY)//这里的strategy = GenerationType.IDENTITY就是自增长
long id();//这里的id()就是实体类的id
@Key
String name();//业务主键
@Null//这里的@Null就是可以为null,建议使用Jetbrains的@Nullable
String website();
@OneToMany(mappedBy = "store", orderedProps = {
@OrderedProp("name"),
@OrderedProp(value = "edition", desc = true)
})//这里的@OneToMany就是一对多,这里的mappedBy = "store"就是Book中的store字段,这里的orderedProps就是排序字段
List<Book> books();
@Transient(BookStoreAvgPriceResolver.class)//这里的BookStoreAvgPriceResolver.class就是上面写的计算属性的实现
BigDecimal avgPrice();//这里的avgPrice()就是计算属性,这里的BigDecimal就是计算属性的类型
}
Book
@Entity
public interface Book extends TenantAware {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
long id();
@Key//这里的@Key就是业务主键
String name();
@Key//和上面的name()一样,这里的@Key就是业务主键,表示name和edition的组合是唯一的
int edition();
BigDecimal price();
@Nullable
@ManyToOne
BookStore store();
@ManyToMany(orderedProps = {
@OrderedProp("firstName"),
@OrderedProp("lastName")
})//这里的@ManyToMany就是多对多,这里的orderedProps就是排序字段
@JoinTable(
name = "BOOK_AUTHOR_MAPPING",//这里的name就是中间表的表名
joinColumnName = "BOOK_ID",//这里的joinColumnName就是中间表的外键
inverseJoinColumnName = "AUTHOR_ID"//这里的inverseJoinColumnName就是中间表的外键
)
List<Author> authors();
}
Author
@Entity
public interface Author extends BaseEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
long id();
@Key
String firstName();
@Key
String lastName();
Gender gender();//这里的Gender就是枚举类型
@ManyToMany(mappedBy = "authors", orderedProps = {
@OrderedProp("name"),
@OrderedProp(value = "edition", desc = true)
})//这里的@ManyToMany就是多对多,这里的mappedBy = "authors"就是Book中的authors字段,这里的orderedProps就是排序字段
List<Book> books();
}
public enum Gender {
@EnumItem(name = "M")//这里的name表示在数据库中存储的值
MALE,
@EnumItem(name = "F")
FEMALE
}
如果使用过Spring Data JPA
的话,这里的代码应该很熟悉,Jimmer
中的实体类的关联关系和Spring Data JPA
中的关联关系是一样的.
生成前端代码
还记得前面的剧透吗,现在开始正式介绍如何生成前端代码,这里先把生成的代码贴出来,然后再详细介绍.
DTO
Aquí se generan muchos en función Controller
del tipo de retorno , por lo que no lo publicaré aquí, solo publicaré un código.Fetcher
DTO
BookStoreDto
export type BookStoreDto = {
//只有查询书店的name
"BookStoreService/SIMPLE_FETCHER": {
readonly id: number
readonly name: string
}
//查询书店的所有字段
"BookStoreService/DEFAULT_FETCHER": {
readonly id: number
readonly createdTime: string
readonly modifiedTime: string
readonly name: string
readonly website?: string
}
//查询书店的所有字段和书店中所有书籍的所有字段还有书籍的所有作者的所有字段
"BookStoreService/WITH_ALL_BOOKS_FETCHER": {
readonly id: number
readonly createdTime: string
readonly modifiedTime: string
readonly name: string
readonly website?: string
readonly avgPrice: number //这里的avgPrice就是计算属性
readonly books: ReadonlyArray<{
readonly id: number
readonly createdTime: string
readonly modifiedTime: string
readonly name: string
readonly edition: number
readonly price: number
readonly authors: ReadonlyArray<{
readonly id: number
readonly createdTime: string
readonly modifiedTime: string
readonly firstName: string
readonly lastName: string
readonly gender: Gender
}>
}>
}
}
Controlador
BookStoreController
Solo mire la solicitud principal aquí
Aquí Jimmer
todas Controller
las solicitudes se ponen en una Controller
, aquí Controller
está BookStoreController
, aquí BookStoreController
está BookStore
la clase de entidad , el código Controller
aquí es el siguienteBookStoreController
async findComplexStoreWithAllBooks(options: BookStoreServiceOptions['findComplexStoreWithAllBooks']): Promise<
BookStoreDto['BookStoreService/WITH_ALL_BOOKS_FETCHER'] | undefined
> {
let _uri = '/bookStore/';
_uri += encodeURIComponent(options.id);
_uri += '/withAllBooks';
return (await this.executor({uri: _uri, method: 'GET'})) as BookStoreDto['BookStoreService/WITH_ALL_BOOKS_FETCHER'] | undefined
}
async findSimpleStores(): Promise<
ReadonlyArray<BookStoreDto['BookStoreService/SIMPLE_FETCHER']>
> {
let _uri = '/bookStore/simpleList';
return (await this.executor({uri: _uri, method: 'GET'})) as ReadonlyArray<BookStoreDto['BookStoreService/SIMPLE_FETCHER']>
}
async findStores(): Promise<
ReadonlyArray<BookStoreDto['BookStoreService/DEFAULT_FETCHER']>
> {
let _uri = '/bookStore/list';
return (await this.executor({uri: _uri, method: 'GET'})) as ReadonlyArray<BookStoreDto['BookStoreService/DEFAULT_FETCHER']>
}
Configurar la generación de código
Debe especificar la dirección de acceso del código generado en la configuración, ya que Jimmer
el código front-end generado es un paquete comprimido, puede descargar el código fuente generado visitando esta dirección
jimmer:
client:
ts:
path: /ts.zip #这里的path就是访问地址
Luego configure Controller
el tipo de retorno
@GetMapping("/simpleList")
public List<@FetchBy("SIMPLE_FETCHER") BookStore> findSimpleStores() {
final BookStoreTable bookStore = BookStoreTable.$;
return sql.createQuery(bookStore).select(bookStore.fetch(SIMPLE_FETCHER)).execute();
}
Aquí se utilizan anotaciones FetchBy
, donde el valor es Fetcher
la constante de la clase actual. Si Fetcher
no está bajo la clase actual, puede especificar la clase en la anotación ownerType
para especificarla .Fetcher
Bueno, el uso básico de deautorel video tutorial grabado por elo verdocumentaciónlaJimmer
Jimmer ha terminado, si quieres saber más sobre cómo usarlo, puedes consultarJimmer
Jimmer