什么是 simplest

simplest 追求存粹简单和极致。

旨在为项目快速开发提供一系列的基础能力，方便用户根据项目需求快速进行功能拓展

不在去关心一些繁琐。重复工作，而是把重点聚焦到业务。

前言

程序 10 年。作为一个多年程序。深知每个项目和程序，都有很多重复性工作要做。

入行近 10 年,我写过很多程序,也写死过很多程序。。。。。

见证互联网黄金时代，到如今的萎靡。幸运是我还在程序员大军中。和你们一起奋斗！

我的故事 <<程序员三时>> 公众号 期待与你交流。希望给迷茫你一点启发和帮助。

相关仓库

项目 简介 gitee 地址 github 地址
simplest-api 前后端分离项目基于 simplest-api 可以快速构建基于 Web Json API 格式的统一通讯交互 https://gitee.com/daTouY/simplest-api/tree/main/ https://github.com/coder-amiao/simplest-api
simplest-jpa 基于 QueryDSL 语法灵活强大的 QueryWrapper,链式 QueryChain 强大自由组合查询器,像写原生 SQL 一样基于 Java API 查询数据,优雅极致。 https://gitee.com/daTouY/simplest-jpa https://github.com/coder-amiao/simplest-jpa
simplest-admin 基于 RABC 权限模型,功能丰富最新技术栈 Vue3.3 + Vite4 + TS + Pinia + Element-Plus 管理后台脚手架。开箱即用，可定制的代码生成模板，让你只需专注于业务开发。 https://gitee.com/daTouY/simplest-admin.git https://github.com/coder-amiao/simplest-admin
simplest-boot 业务通用生态核心组件 https://gitee.com/daTouY/simplest-boot.git https://github.com/coder-amiao/simplest-boot

Simplest开发文档

这里主要介绍simplest-jpa 使用

快速开始

项目 pom 中引入依赖

  1. <dependency>
  2.     <groupId>cn.soboys</groupId>
  3.     <artifactId>simplest-jpa-spring-boot-starter</artifactId>
  4.     <version>1.0.1</version>
  5. </dependency>
  7. <!-- MySQL -->
  8. <dependency>
  9.     <groupId>mysql</groupId>
  10.     <artifactId>mysql-connector-java</artifactId>
  11.     <version>8.0.28</version>
  12. </dependency>

在 SpringBoot 启动类或者配置类上通过 @EnableJPAQuery注解开启 simplest-jpa

  1. @SpringBootApplication
  2. @EnableJPAQuery
  3. public class SpringbootJpaApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SpringbootJpaApplication.class, args);
  7.     }
  9. }

到此你项目中就可以使用所有的功能了。

数据库配置

在项目中配置对应数据库连接

  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://127.0.0.1:3306/rest-admin?useUnicode=true&characterEncoding=UTF-8&rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai
  4.     username: root
  5.     password: root
  6.     driver-class-name: com.mysql.cj.jdbc.Driver
  7.     type: com.zaxxer.hikari.HikariDataSource
  8.     hikari:
  9.       minimum-idle: 10
  10.       maximum-pool-size: 20
  11.       idle-timeout: 600000
  12.       max-life-time: 1800000
  14.   jpa:
  15.     hibernate:
  16.       naming:
  17.         implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
  18.       ddl-auto: update # 控制是否可以基于程序中Entity的定义自动创建或者修改DB中表结构
  19.     show-sql: true #控制是否打印运行时的SQL语句与参数信息
  20.     database-platform: org.hibernate.dialect.MySQLDialect #数据库方言
  21.     open-in-view: true
  22.     properties:
  23.       hibernate:
  24.         enable_lazy_load_no_trans: true

定义对应entity 对应数据库表。JPA 会自动帮你生成数据库。

  1. package cn.soboys.springbootjpa.entity;
  3. import cn.soboys.springbootjpa.entity.base.BaseEntity;
  4. import cn.soboys.springbootjpa.entity.dto.TitleVo;
  5. import io.swagger.v3.oas.annotations.media.Schema;
  6. import lombok.Data;
  8. import javax.persistence.*;
  9. import java.util.HashSet;
  10. import java.util.Set;
  12. /**
  13.  * @author 公众号 程序员三时
  14.  * @version 1.0
  15.  * @date 2023/7/19 10:44
  16.  * @webSite https://github.com/coder-amiao
  17.  * 内容分类
  18.  */
  19. @Data
  20. @Entity
  21. @Table(name = "cms_category")
  22. public class Category extends BaseEntity {
  24.     @Id
  25.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  26.     private Long id;
  28.     /**
  29.      * 标题
  30.      */
  31.     @Column(nullable = false, length = 64)
  32.     @Schema(description = "标题")
  33.     private String title;
  35.     /**
  36.      * @Embedded 用户映射数据库表到一个实体vo。
  37.      */
  38.     @Embedded
  39.     @Schema(description = "标题信息")
  40.     private TitleVo titleVo;
  42.     /**
  43.      * 描述
  44.      */
  45.     @Schema(description = "描述")
  46.     private String described;
  48.     /**
  49.      * 图标
  50.      */
  51.     @Column( length = 32)
  52.     @Schema(description = "图标",maxLength = 32)
  53.     private String icon;
  55.     /**
  56.      * 图片
  57.      */
  58.     @Column( length = 32)
  59.     @Schema(description = "图片",maxLength = 32)
  60.     private String pic;
  62.     /***
  63.      * 引用关系不填写。默认对应主键。
  64.      */
  65.     @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE},fetch = FetchType.LAZY)
  66.     @JoinTable(name = "cms_module_relation",
  67.             joinColumns = @JoinColumn(name = "resource_id"),
  68.             inverseJoinColumns = @JoinColumn(name = "module_id"))
  69.     private Set<Module> modules=new HashSet<>();
  71.     /**
  72.      * 额外其他属性
  73.      * @Transient 解绑和数据联系。属于实体类属性
  74.      */
  75.     @Transient
  76.     private String other;
  78. }

生成对应查询EntityPath

基于 QueryDSL 的APT 技术 在 maven 的 pom.xml 中引入对应的插件

  1. <plugin>
  2.     <!--因为QueryDsl是类型安全的，所以还需要加上Maven APT plugin，使用 APT 自动生成Q类:-->
  3.     <groupId>com.mysema.maven</groupId>
  4.     <artifactId>apt-maven-plugin</artifactId>
  5.     <version>1.1.3</version>
  6.     <executions>
  7.         <execution>
  8.             <phase>generate-sources</phase>
  9.             <goals>
  10.                 <goal>process</goal>
  11.             </goals>
  12.             <configuration>
  13.                 <outputDirectory>target/generated-sources/java</outputDirectory>
  14.                 <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
  15.             </configuration>
  16.         </execution>
  17.     </executions>
  18. </plugin>

然后通过 maven 编译项目。

会在你指定目录生成对应查询EntityPaht实体

简单查询

  1. 编写自己的Repository 继承通用BaseRepository
  1. package cn.soboys.springbootjpa.repository;
  3. import cn.soboys.simplestjpa.BaseRepository;
  4. import cn.soboys.springbootjpa.entity.Category;
  5. import org.springframework.stereotype.Repository;
  7. /**
  8.  * @author 公众号 程序员三时
  9.  * @version 1.0
  10.  * @date 2023/7/19 12:02
  11.  * @webSite https://github.com/coder-amiao
  12.  * 数据库 dao层。
  13.  */
  14. @Repository
  15. public interface CategoryRepository extends BaseRepository<Category, Long{
  17. }
  1. 编写自己的Service 继承通用Service层
  1. package cn.soboys.springbootjpa.service;
  3. import cn.soboys.simplestjpa.IService;
  4. import cn.soboys.springbootjpa.entity.Category;
  5. import org.springframework.data.jpa.repository.Query;
  7. /**
  8.  * @author 公众号 程序员三时
  9.  * @version 1.0
  10.  * @date 2023/7/19 17:08
  11.  * @webSite https://github.com/coder-amiao
  12.  */
  13. public interface ICategoryService extends IService<Category,Long> {
  15. }

实现类

  1. package cn.soboys.springbootjpa.service.impl;
  3. import cn.soboys.simplestjpa.ServiceImpl;
  4. import cn.soboys.springbootjpa.entity.Category;
  5. import cn.soboys.springbootjpa.repository.CategoryRepository;
  6. import cn.soboys.springbootjpa.service.ICategoryService;
  7. import org.springframework.stereotype.Service;
  9. /**
  10.  * @author 公众号 程序员三时
  11.  * @version 1.0
  12.  * @date 2023/7/20 14:46
  13.  * @webSite https://github.com/coder-amiao
  14.  */
  15. @Service
  16. public class CategoryServerImpl extends ServiceImpl<CategoryRepository, Category, Long> implements ICategoryService {
  18. }

这样你 service 有基础所有操作数据增删改查的方法

  1. package cn.soboys.springbootjpa;
  3. import cn.soboys.simplestjpa.UpdateWrapper;
  4. import cn.soboys.springbootjpa.entity.Category;
  5. import cn.soboys.springbootjpa.entity.QCategory;
  6. import cn.soboys.springbootjpa.entity.dto.QTitleVo;
  7. import cn.soboys.springbootjpa.service.ICategoryService;
  8. import com.querydsl.core.BooleanBuilder;
  9. import com.querydsl.core.types.Predicate;
  10. import com.querydsl.jpa.impl.JPAUpdateClause;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.dromara.hutool.core.text.StrUtil;
  13. import org.junit.jupiter.api.Test;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.boot.test.context.SpringBootTest;
  16. import org.springframework.data.domain.Example;
  17. import org.springframework.data.domain.Page;
  18. import org.springframework.data.domain.PageRequest;
  19. import org.springframework.test.annotation.Rollback;
  20. import org.springframework.transaction.annotation.Transactional;
  22. import java.util.ArrayList;
  23. import java.util.List;
  24. import java.util.Optional;
  26. /**
  27.  * @author 公众号 程序员三时
  28.  * @version 1.0
  29.  * @date 2023/7/26 21:54
  30.  * @webSite https://github.com/coder-amiao
  31.  */
  32. @SpringBootTest
  33. @Slf4j
  34. public class ServiceTest {
  35.     @Autowired
  36.     private ICategoryService categoryService;
  38.     @Test
  39.     void countByExample() {
  40.         Category category = new Category();
  41.         //category.setTitle("测试");
  42.         long count = categoryService.count(Example.of(category));
  43.         log.info("条件count{}", count);
  44.     }
  46.     @Test
  47.     void getById() {
  48.         Optional<Category> category = categoryService.getByIdOpt(6l);
  49.         if (category.isPresent()) {
  50.             log.info(category.get().toString());
  51.         }
  52.     }
  54.     @Test
  55.     void getOne() {
  56.         QCategory qCategory = QCategory.category;
  57.         QTitleVo vo=QTitleVo.titleVo;
  58.         Predicate query=vo.subTitle.eq("batch1");
  59.         Category category = categoryService.getOne(query);
  60.         log.info(category.toString());
  61.     }
  63.     @Test
  64.     void getPageQuery() {
  65.         QCategory qCategory = QCategory.category;
  66.         PageRequest pageRequest = PageRequest.of(0, 20); //第一页从零开始
  67.         Predicate query = qCategory.title.like("%" + "batch" + "%");
  68.         Page<Category> categoryList = categoryService.page(pageRequest, query);
  69.         log.info("数量{}", categoryList.getContent().size());
  70.     }
  72.     @Test
  73.     void getPage() {
  74.         QCategory qCategory = QCategory.category;
  76.       // categoryService.getJPAQueryFactory().select().where(qCategory.)
  77.     }
  79.     @Test
  80.     void save() {
  81.         Category c = new Category();
  82.        // c.setTitle("保存");
  83.         categoryService.save(c);
  84.     }
  86.     @Test
  87.     void deleteById() {
  88.         categoryService.removeById(6l);
  89.     }
  91.     @Test
  92.     void deleteAll() {
  93.         List<Long> ids = new ArrayList<>();
  94.         ids.add(6l);
  95.         ids.add(7l);
  96.         Boolean flag = categoryService.removeByIds(ids);
  97.     }
  99.     /**
  100.      * 实体ID对应存在更新否则添加
  101.      */
  102.     @Test
  103.     void saveOrUpdate() {
  104.         Category c = new Category();
  105.        // c.setTitle("保存");
  106.         categoryService.saveOrUpdate(c);
  107.     }
  109.     @Test
  110.     @Rollback(value = false)
  111.     @Transactional
  112.     void updateChain() {
  113.         QCategory qCategory = QCategory.category;
  114.         categoryService.updateChain(qCategory)
  115.                 .set(qCategory.title, "测试jpa")
  116.                 .where(qCategory.id.eq(6l)).execute();
  117.     }
  119.     @Test
  120.     @Rollback(value = false)
  121.     @Transactional
  122.     void update() {
  123.         QCategory qCategory = QCategory.category;
  124.         JPAUpdateClause updateWrapper = UpdateWrapper.of(qCategory);
  125.         updateWrapper.set(qCategory.title, "bh").where(qCategory.id.eq(6l));
  127.         Boolean flag = categoryService.update(updateWrapper);
  129.         log.info("更新{}", flag);
  130.     }
  132.     @Test
  133.     @Rollback(value = false)
  134.     @Transactional
  135.     void updateIgnoreNull() {
  136.         Category category = new Category();
  137.         category.setId(6l);
  138.        // category.setSubTitle("忽略");
  139.         //Category category1 = categoryService.update(category, true);  //会自动忽略实体空属性。
  141.         //category.setTitle("");
  142.         Category category1 = categoryService.update(category, true, new String[]{"title"});  //自定义不忽略字段，
  143.         log.info("更新{}", category1);
  144.     }
  146.     @Test
  147.     void selectQueryChain() {
  148.         QCategory qCategory = QCategory.category;
  149.         List<String> categoryList = categoryService.queryChain()
  150.                 .select(qCategory.title)
  151.                 .from(qCategory).fetch();
  152.         log.info("返回条数{}", categoryList.size());
  153.     }
  155.     @Test
  156.     void selectQuery() {
  157.         QCategory qCategory = QCategory.category;
  158.         BooleanBuilder booleanBuilder = new BooleanBuilder();
  160.         String subTitle = "88";
  161.         if (StrUtil.isNotEmpty(subTitle)) {
  162.             booleanBuilder.and(qCategory.described.eq("88"));
  163.         }
  164.         long id = 6l;
  165.         if (!StrUtil.isBlankIfStr(id)) {
  166.             booleanBuilder.and(qCategory.id.eq(6l));
  167.         }
  168.         List<Category> categories = categoryService.list(booleanBuilder);
  169.         log.info("返回条数{}", categories.size());
  170.     }
  172. }

Simplest-JPA

simplest-jpa内置名为 BaseRepository 接口，它实现了基本的增删改查功能以及分页查询功能。 和对应Service

新增数据

Service 提供了save,saveBatch,saveOrUpdate 方法

  • save(T entity)插入实体类数据，不忽略 null 值。
  • saveBatch(Collection<T> entities) 批量插入实体类数据
  • saveOrUpdate(T entity) 插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。
  • saveOrUpdateSelective(T entity)插入或者更新，若主键有值，则更新，若没有主键值，则插入，更新会忽略 null 值。

删除数据

Service 提供了remove,removeAll,removeById,removeByIds 方法

  • removeById(ID id) 根据主键删除数据
  • removeById(Collection<? extends ID> ids) 根据多个主键批量删除数据
  • remove(Collection<T> entities) 根据多个实体(实体需要有主键)进行批量删除
  • remove(T entity) 根据实体条件进行删除

更新数据

Service 提供了update 多个重载方法

  • update(T entity) 查询条件 根据实体 ID 更新。不会忽略 null 值
  • update(T entity, Boolean ignore) 查询条件根据实体 ID 更新。自定义忽略 nul 值
  • update(T entity, Boolean ignore, String[] ignoreProperties) 自定义忽略实体字段属性
  • update(JPAUpdateClause query) 根据查询条件来更新数据。
  1. @Test
  2. @Rollback(value = false)
  3. @Transactional
  4. void update() {
  5.     QCategory qCategory = QCategory.category;
  6.     JPAUpdateClause updateWrapper = UpdateWrapper.of(qCategory);
  7.     updateWrapper.set(qCategory.title, "bh").where(qCategory.id.eq(6l));
  8.     Boolean flag = categoryService.update(updateWrapper);
  9.     log.info("更新{}", flag);
  10. }

updateChain

updateChain是一个对 UpdateWrapper 等进行封装的一个工具类，方便用户用于进行链式操作。

  1. @Test
  2. @Rollback(value = false)
  3. @Transactional
  4. void updateChain() {
  5.     QCategory qCategory = QCategory.category;
  6.     categoryService.updateChain(qCategory)
  7.             .set(qCategory.title, "测试jpa")
  8.             .where(qCategory.id.eq(6l)).execute();
  9. }

Simplest-JPA 查询和分页查询

基础查询

simplest-jpa的Service提供了如下的功能用于查询数据库的数据

  • getById(ID id) 根据主键查询数据。
  • getByIdOpt(ID id)根据主键查询数据。返回Optional类型
  • getOne(Example<T> example) 根据查询条件来查询 1 条数据。
  • getOne(Predicate query) 根据查询条件来查询 1 条数据。
  • getOneOpt(Example<T> example)根据查询条件来查询 1 条数据。返回Optional类型查询到多条匹配数据时，会抛 NonUniqueResultException
  • listByIds(Collection<ID> ids) 根据数据主键查询数据集合。
  • list(Predicate query)根据查询条件查询数据集合。
  • list(Example query) 根据查询条件查询数据集合。
  • list()查询所有数据。
  • count(Predicate query) 根据查询条件查询数据数量。
  • count(Example<T> example) 根据查询条件查询数据数量。
  • exists(Predicate query) 根据查询条件判断数据是否存在。
  • existsById(ID id) 根据 ID 判断是否存在

分页查询

  • page(Pageable page)分页查询所有数据。
  • page(Pageable page, Predicate query) 根据查询条件分页查询数据。

链式查询

在 simplest-jpa 中，内置了 queryChain 和 updateChain 用于对数据进行链式查询操作和链式数据操作（修改和删除）。

  • queryChain：链式查询
  • updateChain：链式更新

queryChain 示列

  1. @Test
  2. void selectQueryChain() {
  3.     QCategory qCategory = QCategory.category;
  4.     List<String> categoryList = categoryService.queryChain()
  5.             .select(qCategory.title)
  6.             .from(qCategory)
  7.             .fetch();
  8.     log.info("返回条数{}", categoryList.size());
  9. }

条件查询

  1. @Test
  2. void selectQueryChainWhere() {
  3.     QCategory qCategory = QCategory.category;
  4.     List<String> categoryList=  categoryService.queryChain()
  5.             .select(qCategory.title)
  6.             .from(qCategory)
  7.             .where(qCategory.id.eq(1l))
  8.             .fetch();
  9.         log.info("返回条数{}", categoryList.size());
  10. }

分页查询

  1. @Test
  2. void selectQueryChainWhere() {
  3.     QCategory qCategory = QCategory.category;
  4.     List<String> categoryList = categoryService.queryChain()
  5.             .select(qCategory.title)
  6.             .from(qCategory)
  7.             .where(qCategory.id.eq(1l))
  8.             .limit(1)
  9.             .fetch();
  10.     log.info("返回条数{}", categoryList.size());
  11. }

updateChain 示例

  1. @Test
  2. @Rollback(value = false)
  3. @Transactional
  4. void updateChain() {
  5.     QCategory qCategory = QCategory.category;
  6.     categoryService.updateChain(qCategory)
  7.             .set(qCategory.title, "测试jpa")
  8.             .where(qCategory.id.eq(6l)).execute();
  9. }

queryChain 的方法

  • fetch() 获取多条数据 懒加载模式
  • fetchAll() 获取多条数据 忽略懒加载
  • fetchOne() 获取一条数据 多条会报错
  • fetchFirst() 查询第一条数据
  • fetchCount() 查询数据条数

灵活的 QueryWrapper

在 增删改 和 查询和分页 章节中，我们随时能看到 QueryWrapper 的身影，QueryWrapper 是用于构造 Sql 的 强有力工具，也是 simplest-jpa 的亮点和特色。

QueryWrapper 的使用

  1. @SpringBootTest
  2. @Slf4j
  3. public class JpaQueryDSLTest {
  5.     @Autowired
  6.     private ICategoryService categoryService;
  8.     @Autowired
  9.     private JPAQueryFactory queryWrapper;
  11.     /**
  12.      * select() 和 fetch() 的常用写法
  13.      * 使用fetch()查询时，数据库没有符合该条件的数据时，返回的是空集合，而不是null
  14.      */
  16.     /**
  17.      * 查询字段-select()
  18.      */
  19.     @Test
  20.     public void fetchColum() {
  21.         QCategory qCategory = QCategory.category;
  22.         List<String> a = queryWrapper
  23.                 .select(qCategory.title)
  24.                 .from(qCategory)
  25.                 .fetch();
  26.         log.info("返回数量{}", a.size());
  27.     }
  29.     /**
  30.      * 查询实体-selectFrom()
  31.      */
  32.     @Test
  33.     public void fetchEntity() {
  34.         QCategory qCategory = QCategory.category;
  35.         List<Category> categories = queryWrapper.selectFrom(qCategory).fetch();
  36.         log.info("返回数量{}", categories.size());
  38.     }
  40.     /**
  41.      * 查询并将结果封装至dto中
  42.      */
  43.     @Test
  44.     public void fetchDto() {
  45.         QCategory qCategory = QCategory.category;
  46.         List<CategoryDto> categoryDtos = queryWrapper.select(
  47.                         Projections.bean(CategoryDto.class, qCategory.title)
  48.                 )
  49.                 .from(qCategory).fetch();
  50.         log.info("返回数量{}", categoryDtos.size());
  52.     }
  54.     /**
  55.      * 去重查询-selectDistinct()
  56.      */
  57.     @Test
  58.     public void fetchDistinct() {
  59.         QCategory qCategory = QCategory.category;
  60.         List<String> c = queryWrapper
  61.                 .selectDistinct(qCategory.title)
  62.                 .from(qCategory)
  63.                 .fetch();
  64.         log.info("返回数量{}", c.size());
  65.     }
  67.     /**
  68.      * 获取首个查询结果-fetchFirst() 单条记录 limit 1
  69.      */
  70.     @Test
  71.     public void fetchFirst() {
  72.         QCategory qCategory = QCategory.category;
  73.         Category category = queryWrapper
  74.                 .selectFrom(qCategory)
  75.                 .fetchFirst();
  76.         log.info("返回数量{}", category.toString());
  77.     }
  79.     /**
  80.      * 获取唯一查询结果-fetchOne()
  81.      * 当fetchOne()根据查询条件从数据库中查询到多条匹配数据时，会抛`NonUniqueResultException`
  82.      */
  83.     @Test
  84.     public void fetchOne() {
  85.         QCategory qCategory = QCategory.category;
  86.         Category category = queryWrapper
  87.                 .selectFrom(qCategory)
  88.                 .fetchOne();
  89.         log.info("返回数量{}", category.toString());
  90.     }
  92.     /**
  93.      * where 子句查询条件的常用写法
  94.      */
  95.     @Test
  96.     public void fetchWhere() {
  97.         QCategory qCategory = QCategory.category;
  98.         List<Category> categories = queryWrapper
  99.                 .selectFrom(qCategory)
  100.                 .where(qCategory.title.eq("更新")
  101.                         .and(qCategory.subTitle.like('%' + "测试" + '%')))
  102.                 .fetch();
  103.         log.info("返回数量{}", categories.size());
  105.     }
  107.     /**
  108.      * where 动态条件查询
  109.      */
  111.     /**
  112.      * 使用QueryDSL提供的BooleanBuilder来进行查询条件管理。
  113.      */
  114.     @Test
  115.     public void fetchWhereDynamic() {
  116.         QCategory qCategory = QCategory.category;
  117.         BooleanBuilder builder = new BooleanBuilder();
  118.         String title = "a";
  119.         if (StrUtil.isNotEmpty(title)) {
  120.             builder.and(qCategory.title.eq(title));
  121.         }
  122.         String subTitle = "";
  123.         if (StrUtil.isNotEmpty(subTitle)) {
  124.             builder.and(qCategory.subTitle.eq(subTitle));
  125.         }
  126.         List<Category> categories = queryWrapper
  127.                 .selectFrom(qCategory)
  128.                 .where(builder)
  129.                 .fetch();
  130.         log.info("返回数量{}", categories.size());
  132.     }
  134.     /**
  135.      * 复杂的查询关系
  136.      */
  137.     @Test
  138.     public void fetchWhereDynamicComplex() {
  139.         QCategory qCategory = QCategory.category;
  141.         BooleanBuilder builder = new BooleanBuilder();
  142.         builder.or(qCategory.id.eq(1l));
  144.         String title = "a";
  145.         if (StrUtil.isNotEmpty(title)) {
  146.             builder.and(qCategory.title.eq(title));
  147.         }
  148.         String subTitle = "";
  149.         if (StrUtil.isNotEmpty(subTitle)) {
  150.             builder.and(qCategory.subTitle.eq(subTitle));
  151.         }
  153.         List<Category> categories = queryWrapper
  154.                 .selectFrom(qCategory)
  155.                 .where(builder)
  156.                 .fetch();
  157.         log.info("返回数量{}", categories.size());
  158.     }
  160.     /**
  161.      * 自定义封装查询的结果集
  162.      * JPAQueryFactory查询工厂的select方法可以将Projections方法返回的QBean作为参数，通过Projections的bean方法来构建返回的结果集映射到实体内，有点像Mybatis内的ResultMap的形式，不过内部处理机制肯定是有着巨大差别的！
  163.      * <p>
  164.      * bean方法第一个参数需要传递一个实体的泛型类型作为返回集合内的单个对象类型，如果QueryDSL查询实体内的字段与DTO实体的字段名字不一样时，可以采用as方法来处理，为查询的结果集指定的字段添加别名，这样就会自动映射到DTO实体内。
  165.      */
  167.     /**
  168.      * 使用Projections的Bean方法
  169.      */
  170.     @Test
  171.     public void fetchBean() {
  172.         QCategory qCategory = QCategory.category;
  173.         QModule qModule = QModule.module;
  175.         List<CategoryDto> categoryDtos = queryWrapper
  176.                 .select(
  177.                         Projections.bean(CategoryDto.class
  178.                                 , qCategory.title, qModule.code)
  179.                 ).from(qCategory, qModule).fetch();
  180.         log.info("返回数量{}", categoryDtos.size());
  181.     }
  183.     /**
  184.      * 使用Projections的fields方法
  185.      */
  186.     @Test
  187.     public void fetchFields() {
  188.         QCategory qCategory = QCategory.category;
  189.         List<CategoryDto> categoryDtos = queryWrapper
  190.                 .select(
  191.                         Projections.fields(CategoryDto.class
  192.                                 , qCategory.title)
  193.                 ).from(qCategory).fetch();
  194.         log.info("返回数量{}", categoryDtos.size());
  195.     }
  197.     /**
  198.      * 使用集合的stream转换
  199.      * 从方法开始到fetch()结束完全跟QueryDSL没有任何区别，采用了最原始的方式进行返回结果集，但是从fetch()获取到结果集后处理的方式就有所改变了。
  200.      * <p>
  201.      * fetch()方法返回的类型是泛型List（List），List继承了Collection，完全存在使用Collection内非私有方法的权限，通过调用stream方法可以将集合转换成Stream泛型对象，该对象的map方法可以操作集合内单个对象的转换，具体的转换代码可以根据业务逻辑进行编写。
  202.      * <p>
  203.      * 在map方法内有个lambda表达式参数tuple，通过tuple对象get方法就可以获取对应select方法内的查询字段。
  204.      * ————————————————
  205.      */
  206.     @Test
  207.     public void selectWithStream() {
  208.         QCategory qCategory = QCategory.category;
  209.         List<CategoryDto> categoryDtos = queryWrapper
  210.                 .select(qCategory.title, qCategory.subTitle)
  211.                 .from(qCategory)
  212.                 .fetch().stream().map(tuple -> {
  213.                     CategoryDto c = new CategoryDto();
  214.                     c.setTitle(tuple.get(qCategory.title));
  215.                     return c;
  216.                 }).collect(Collectors.toList());
  218.         log.info("返回数量{}", categoryDtos.size());
  219.     }
  221.     @Test
  222.     public void findByQuery() {
  223.         QCategory qCategory = QCategory.category;
  224.         //该Predicate为querydsl下的类,支持嵌套组装复杂查询条件
  225.         BooleanBuilder builder = new BooleanBuilder();
  226.         String title = "a";
  227.         if (StrUtil.isNotEmpty(title)) {
  228.             builder.and(qCategory.title.eq(title));
  229.         }
  230.         String subTitle = "";
  231.         if (StrUtil.isNotEmpty(subTitle)) {
  232.             builder.and(qCategory.subTitle.eq(subTitle));
  233.         }
  234.         List<Category> c = categoryService.list(builder);
  235.        log.info("条数{}",c.size());
  236.     }
  238.     @Test
  239.     public void findByQueryWrapper(){
  240.         QCategory qCategory = QCategory.category;
  241.         JPAQueryFactory queryWrapper=QueryWrapper.of();
  242.         List<String> c = queryWrapper
  243.                 .selectDistinct(qCategory.title)
  244.                 .from(qCategory)
  245.                 .fetch();
  246.         log.info("返回数量{}", c.size());
  247.     }
  249. }

实例

  1. 单表查询
  1. @Service
  2. @Transactional
  3. public class UserService {
  5. 	@Autowired
  6.     private JPAQueryFactory queryFactory;
  8. 	/**
  9. 	 * attention:
  10. 	 * Details：查询user表中的所有记录
  11. 	 */
  12. 	public List<User> findAll(){
  13. 		QUser quser = QUser.user;
  14. 		return queryFactory.selectFrom(quser)
  15. 					.fetch();
  16. 	}
  18. 	/**
  19. 	 * Details：单条件查询
  20. 	 */
  21. 	public User findOneByUserName(final String userName){
  22. 		QUser quser = QUser.user;
  23. 		return queryFactory.selectFrom(quser)
  24. 			.where(quser.name.eq(userName))
  25. 			.fetchOne();
  26. 	}
  28. 	/**
  29. 	 * Details：单表多条件查询
  30. 	 */
  31. 	public User findOneByUserNameAndAddress(final String userName, final String address){
  32. 		QUser quser = QUser.user;
  33. 		return queryFactory.select(quser)
  34. 			.from(quser) // 上面两句代码等价与selectFrom
  35. 			.where(quser.name.eq(userName).and(quser.address.eq(address)))// 这句代码等同于where(quser.name.eq(userName), quser.address.eq(address))
  36. 			.fetchOne();
  37. 	}
  39. 	/**
  40. 	 * Details：使用join查询
  41. 	 */
  42. 	public List<User> findUsersByJoin(){
  43. 		QUser quser = QUser.user;
  44. 		QUser userName = new QUser("name");
  45. 		return queryFactory.selectFrom(quser)
  46. 			.innerJoin(quser)
  47. 			.on(quser.id.intValue().eq(userName.id.intValue()))
  48. 			.fetch();
  49. 	}
  51. 	/**
  52. 	 * Details：将查询结果排序
  53. 	 */
  54. 	public List<User> findUserAndOrder(){
  55. 		QUser quser = QUser.user;
  56. 		return queryFactory.selectFrom(quser)
  57. 			.orderBy(quser.id.desc())
  58. 			.fetch();
  59. 	}
  61. 	/**
  62. 	 * Details：Group By使用
  63. 	 */
  64. 	public List<String> findUserByGroup(){
  65. 		QUser quser = QUser.user;
  66. 		return queryFactory.select(quser.name)
  67. 					.from(quser)
  68. 					.groupBy(quser.name)
  69. 					.fetch();
  70. 	}
  72. 	/**
  73. 	 * Details：删除用户
  74. 	 */
  75. 	public long deleteUser(String userName){
  76. 		QUser quser = QUser.user;
  77. 		return queryFactory.delete(quser).where(quser.name.eq(userName)).execute();
  78. 	}
  80. 	/**
  81. 	 * Details：更新记录
  82. 	 */
  83. 	public long updateUser(final User u, final String userName){
  84. 		QUser quser = QUser.user;
  85. 		return queryFactory.update(quser).where(quser.name.eq(userName))
  86. 			.set(quser.name, u.getName())
  87. 			.set(quser.age, u.getAge())
  88. 			.set(quser.address, u.getAddress())
  89. 			.execute();
  90. 	}
  92. 	/**
  93. 	 * Details：使用原生Query
  94. 	 */
  95. 	public User findOneUserByOriginalSql(final String userName){
  96. 		QUser quser = QUser.user;
  97. 		Query query = queryFactory.selectFrom(quser)
  98. 				.where(quser.name.eq(userName)).createQuery();
  99. 		return (User) query.getSingleResult();
  100. 	}
  102.     /**
  103.      *分页查询所有的实体,根据uIndex字段排序
  104.      *
  105.      * @return
  106.      */
  107.     public QueryResults<User> findAllPage(Pageable pageable) {
  108.         QUser user = QUser.user;
  109.         return jpaQueryFactory
  110.                 .selectFrom(user)
  111.                 .orderBy(user.uIndex.asc())
  112.                 .offset(pageable.getOffset())   //偏移量，计算：offset = ( 当前页 - 1) * 每页条数，这里直接使用的是Pageable中的Offset
  113.                 .limit(pageable.getPageSize())  //每页大小
  114.                 .fetchResults();    //获取结果，该结果封装了实体集合、分页的信息，需要这些信息直接从该对象里面拿取即可
  115.     }
  117.     /**
  118.      * 部分字段映射查询
  119.      * 投影为UserRes,lambda方式(灵活，类型可以在lambda中修改)
  120.      *
  121.      * @return
  122.      */
  123.     public List<UserDTO> findAllUserDto(Pageable pageable) {
  124.         QUser user = QUser.user;
  125.         List<UserDTO> dtoList = jpaQueryFactory
  126.                 .select(
  127.                         user.username,
  128.                         user.userId,
  129.                         user.nickName,
  130.                         user.birthday
  131.                 )
  132.                 .from(user)
  133.                 .offset(pageable.getOffset())
  134.                 .limit(pageable.getPageSize())
  135.                 .fetch()
  136.                 .stream()
  137.                 .map(tuple -> UserDTO.builder()
  138.                         .username(tuple.get(user.username))
  139.                         .nickname(tuple.get(user.nickName))
  140.                         .userId(tuple.get(user.userId).toString())
  141.                         .birthday(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(tuple.get(user.birthday)))
  142.                         .build()
  143.                 )
  144.                 .collect(Collectors.toList());
  145.         return dtoList;
  146.     }
  148.     /**
  149.      * 部分字段映射查询
  150.      * 投影为UserRes，自带的Projections方式，不能转换类型，但是可以使用as转换名字
  151.      *
  152.      * @return
  153.      */
  154.     public List<UserDTO> findAllDto2() {
  155.         QUser user = QUser.user;
  156.         List<UserDTO> dtoList = jpaQueryFactory
  157.                 .select(
  158.                         Projections.bean(
  159.                                 UserDTO.class,
  160.                                 user.username,
  161.                                 user.userId,
  162.                                 user.nickName,
  163.                                 user.birthday
  164.                         )
  165.                 )
  166.                 .from(user)
  167.                 .fetch();
  168.         return dtoList;
  169.     }
  171. }
  1. 多表查询
  3. /**
  4.  * @Description 查询全部
  5.  * @Author 程序员三时
  6.  * @Date  10:53
  7.  * @return java.util.List<com.cs.querydsl.model.Loc>
  8.  **/
  9. @Override
  10. public List<Loc> findAll(Loc loc) {
  11.     // 使用 QueryDSL 进行查询
  12.     QLoc qLoc = QLoc.loc1;
  13.     QUser qUser = QUser.user;
  14.     // 定于获取条件
  15.     BooleanBuilder booleanBuilder = new BooleanBuilder();
  16.     // 要查询的条件
  17.     if(!StringUtils.isEmpty(loc.getLoc())){
  18.         // 放入要查询的条件信息
  19.         booleanBuilder.and(qLoc.loc.contains(loc.getLoc()));
  20.     }
  21.     //连接查询条件（Loc.id = User.id ）
  22.     booleanBuilder.and(qLoc.id.eq(qUser.id));
  23.     // 使用 QueryDSL 进行多表联合查询
  24.     QueryResults<Tuple> listResult = queryFactory
  25.             .select(QLoc.loc1,QUser.user)
  26.             .from(qLoc, qUser)//查询两表
  27.             .where(booleanBuilder)
  28.             .fetchResults();
  29.     //遍历 java8 自带流转换成集合
  30.     List<Loc> collect = listResult.getResults().stream().map(tuple -> {
  31.         Loc lcs = tuple.get(qLoc);
  32.         return lcs;
  33.     }).collect(Collectors.toList());
  34.     return collect;
  35. }
  37. 部分字段映射的投影查询：
  39. 当使用`@ManyToOne`、`@ManyToMany`建立关联时：
  41. /**
  42.  * 根据部门的id查询用户的基本信息+用户所属部门信息，并且使用UserDeptDTO进行封装返回给前端展示
  43.  * @param departmentId
  44.  * @return
  45.  */
  46. public List<UserDeptDTO> findByDepatmentIdDTO(int departmentId) {
  47.     QUser user = QUser.user;
  48.     QDepartment department = QDepartment.department;
  49.     //直接返回
  50.     return jpaQueryFactory
  51.             //投影只去部分字段
  52.             .select(
  53.                     user.username,
  54.                     user.nickName,
  55.                     user.birthday,
  56.                     department.deptName,
  57.                     department.createDate
  59.             )
  60.             .from(user)
  61.             //联合查询
  62.             .join(user.department, department)
  63.             .where(department.deptId.eq(departmentId))
  64.             .fetch()
  65.             //lambda开始
  66.             .stream()
  67.             .map(tuple ->
  68.                     //需要做类型转换，所以使用map函数非常适合
  69.                     UserDeptDTO.builder()
  70.                             .username(tuple.get(user.username))
  71.                             .nickname(tuple.get(user.nickName))
  72.                             .birthday(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(tuple.get(user.birthday)))
  73.                             .deptName(tuple.get(department.deptName))
  74.                             .deptBirth(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(tuple.get(department.createDate)))
  75.                             .build()
  76.             )
  77.             .collect(Collectors.toList());
  78. }
  80. 当使用id建立关联时：
  81. /**
  82.  * 根据部门的id查询用户的基本信息+用户所属部门信息，并且使用UserDeptDTO进行封装返回给前端展示
  83.  *
  84.  * @param departmentId
  85.  * @return
  86.  */
  87. public List<UserDeptDTO> findByDepatmentIdDTO(int departmentId) {
  88.     QUser user = QUser.user;
  89.     QDepartment department = QDepartment.department;
  90.     //直接返回
  91.     return jpaQueryFactory
  92.             //投影只去部分字段
  93.             .select(
  94.                     user.username,
  95.                     user.nickName,
  96.                     user.birthday,
  97.                     department.deptName,
  98.                     department.createDate
  100.             )
  101.             .from(user, department)
  102.             //联合查询
  103.             .where(
  104.                     user.departmentId.eq(department.deptId).and(department.deptId.eq(departmentId))
  105.             )
  106.             .fetch()
  107.             //lambda开始
  108.             .stream()
  109.             .map(tuple ->
  110.                     //需要做类型转换，所以使用map函数非常适合
  111.                     UserDeptDTO.builder()
  112.                             .username(tuple.get(user.username))
  113.                             .nickname(tuple.get(user.nickName))
  114.                             .birthday(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(tuple.get(user.birthday)))
  115.                             .deptName(tuple.get(department.deptName))
  116.                             .deptBirth(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(tuple.get(department.createDate)))
  117.                             .build()
  118.             )
  119.             .collect(Collectors.toList());
  120. }
  122. 使用 Projections 自定义返回 Bean：
  124. /**
  125.  * Details：方式一：使用Bean投影
  126.  */
  127. public List<PersonIDCardDto> findByDTOUseBean(){
  128.     Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  129.     return queryFactory.select(
  130.             Projections.bean(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  131.             .from(QIDCard.iDCard, QPerson.person)
  132.             .where(predicate)
  133.             .fetch();
  134. }
  136. /**
  137.  * Details：方式二：使用fields来代替setter
  138.  */
  139. public List<PersonIDCardDto> findByDTOUseFields(){
  140.     Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  141.     return queryFactory.select(
  142.             Projections.fields(PersonIDCardDto.class, QIDCard.iDCard.idNo, QPerson.person.address, QPerson.person.name))
  143.             .from(QIDCard.iDCard, QPerson.person)
  144.             .where(predicate)
  145.             .fetch();
  146. }
  148. /**
  149.  * Details：方式三：使用构造方法，注意构造方法中属性的顺序必须和构造器中的顺序一致
  150.  */
  151. public List<PersonIDCardDto> findByDTOUseConstructor(){
  152.     Predicate predicate = (QPerson.person.id.intValue()).eq(QIDCard.iDCard.person.id.intValue());
  153.     return queryFactory.select(
  154.             Projections.constructor(PersonIDCardDto.class, QPerson.person.name, QPerson.person.address, QIDCard.iDCard.idNo))
  155.             .from(QIDCard.iDCard, QPerson.person)
  156.             .where(predicate)
  157.             .fetch();
  158. }

rest-apiV2.0.0升级为simplest-api开源框架生态之simplest-jpa发布的更多相关文章

  1. 【实践】如何利用tensorflow的object_detection api开源框架训练基于自己数据集的模型（Windows10系统）

    如何利用tensorflow的object_detection api开源框架训练基于自己数据集的模型(Windows10系统) 一.环境配置 1. Python3.7.x(注:我用的是3.7.3.安 ...

  2. NetCore 3.0 中使用Swagger生成Api说明文档及升级报错原因

    认识Swagger Swagger 是一个规范和完整的框架,用于生成.描述.调用和可视化 RESTful 风格的 Web 服务.总体目标是使客户端和文件系统作为服务器以同样的速度来更新.文件的方法,参 ...

  3. Linux下Oracle 10.2.0.1升级到10.2.0.4总结

    最近部署测试环境时,将测试环境ORACLE数据库从10.2.0.1升级到了10.2.0.4,顺便整理记录一下升级过程. 实验环境: 操作系统:Oracle Linux Server release 5 ...

  4. WPF NET5 Prism8.0的升级指南

    前言 ​ 曾经我以学习的目的写了关于在.NET Core3.1使用Prism的系列文章.NET Core 3 WPF MVVM框架 Prism系列文章索引,也谢谢大家的支持,事实上当初的版本则是Pri ...

  5. NGINX Ingress控制器1.0.0升级迁移文档(翻译)

    Ingress 是什么 Ingress 是对k8s集群中服务的外部访问进行管理的 API 对象,典型的访问方式是 HTTP. Ingress 可以提供负载均衡.SSL 终结和基于名称的虚拟托管. 最近 ...

  6. Apache ShardingSphere 5.0.0 内核优化及升级指南

    经过近两年时间的优化和打磨,Apache ShardingSphere 5.0.0 GA 版终于在本月正式发布,相比于 4.1.1 GA 版,5.0.0 GA 版在内核层面进行了大量的优化.首先,基于 ...

  7. MVC3.0 项目升级到 MVC4.0

    按照 http://www.asp.net/whitepapers/mvc4-release-notes#_Toc303253806 的步骤 第一步:修改web.config 注意,默认的MVC3网站 ...

  8. 系统补丁更新导致MVC3.0.0升级到3.0.1的问题解决

    在更新了系统补丁之后,会不知觉的将MVC3.0.0升级到MVC3.0.1的问题,解决的思路如下: 1.全部MVC引用使用NuGet进行包的管理. 2.单独把MVC库抽离出来,然后放在单独的项目文件夹, ...

  9. Asp.net Core 1.0.1升级到Asp.net Core 1.1.0 Preview版本发布到Windows Server2008 R2 IIS中的各种坑

    Asp.net Core 1.0.1升级到Asp.net Core 1.1.0后,程序无法运行了 解决方案:在project.json中加入runtime节点 "runtimes" ...

  10. web2.0最全的国外API应用集合

    web2.0最全的国外API应用集合 原文地址:http://www.buguat.com/post/98.html 2.0时代,越来越多的API被大家广泛应用,如果你还不了解API是何物,请看这里的 ...

随机推荐

  1. MySQL百万数据深度分页优化思路分析

    业务场景 一般在项目开发中会有很多的统计数据需要进行上报分析,一般在分析过后会在后台展示出来给运营和产品进行分页查看,最常见的一种就是根据日期进行筛选.这种统计数据随着时间的推移数据量会慢慢的变大,达 ...

  2. 2023-04-12：使用 Go 重写 FFmpeg 的 extract_mvs.c 工具程序，提取视频中的运动矢量信息。

    2023-04-12:使用 Go 重写 FFmpeg 的 extract_mvs.c 工具程序,提取视频中的运动矢量信息. 答案2023-04-12: 主要的过程包括: 打开输入视频文件并查找视频流信 ...

  3. 2020-09-10：java里Object类有哪些方法？

    福哥答案2020-09-10: registerNatives:private+static.getClass:返回此 Object 的运行时类. hashCode:返回该对象的哈希码值.equals ...

  4. 2021-05-01：给定一个有序数组arr，代表坐落在X轴上的点。给定一个正数K，代表绳子的长度。返回绳子最多压中几个点？即使绳子边缘处盖住点也算盖住。

    2021-05-01:给定一个有序数组arr,代表坐落在X轴上的点.给定一个正数K,代表绳子的长度.返回绳子最多压中几个点?即使绳子边缘处盖住点也算盖住. 福大大 答案2021-05-01: 滑动窗口 ...

  5. Alist云盘视频加密助手：支持云盘视频文件加密与在线播放，不用再担心视频文件被和谐了！

    在当前娱乐资源丰富的时代,人们每天都在接触各种视频资源.然而,网盘限速.版权审核.视频分级.少儿不宜等问题经常让人感到困扰.如何在保护隐私的前提下,让视频存储和分享变得更加便捷.安全呢?分享一款实用的 ...

  6. yaml的读写

    yaml文件的读写是真的快,也很简单.代码如下:from ruamel.yaml import YAMLimport os # 读取yaml配置文件def read_yaml(yaml_path): ...

  7. Taurus.mvc .Net Core 微服务开源框架发布V3.1.7：让分布式应用更高效。

    前言: 自首个带微服务版本的框架发布:Taurus.MVC V3.0.3 微服务开源框架发布:让.NET 架构在大并发的演进过程更简单 已经过去快1年了,在这近一年的时间里,版本经历了N个版本的迭代. ...

  8. 聊聊Cola-StateMachine轻量级状态机的实现

    背景 在分析Seata的saga模式实现时,实在是被其复杂的 json 状态语言定义文件劝退,我是有点没想明白为啥要用这么来实现状态机:盲猜可能是基于可视化的状态机设计器来定制化流程,更方便快捷且上手 ...

  9. 搭建自动化 Web 页面性能检测系统 —— 实现篇

    我们是袋鼠云数栈 UED 团队,致力于打造优秀的一站式数据中台产品.我们始终保持工匠精神,探索前端道路,为社区积累并传播经验价值.. 本文作者:琉易 liuxianyu.cn 前段时间分享了<搭 ...

  10. ElasticSearch的使用和介绍

    1.概述 功能 Elasticsearch 是一个分布式的 RESTful 搜索和分析引擎,可用来集中存储您的数据,以便您对形形色色.规模不一的数据进行搜索.索引和分析. 例如: 在电商网站搜索商品 ...