介绍：
spirng data jpa是spring提供的一套简化JPA开发的框架，按照约定好的规则进行【方法命名】去写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。
Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。
SpringData Jpa 极大简化了数据库访问层代码。 如何简化的呢？ 使用了SpringDataJpa，我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法。
示例：
pom依赖：
依赖1：
最好在父maven项目中设置spring data统一版本管理依赖: 因为不同的spring data子项目发布时间版本不一样，你自己维护很麻烦， 这样不同的spring data子项目能保证是统一版本
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-bom</artifactId>
<version>2021.1.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>子项目依赖：
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
</dependency>
<!-- junit4 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<!-- hibernate对jpa的支持包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.32.Final</version>
</dependency>
<!-- Mysql and MariaDB -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.22</version>
</dependency>
<!--连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!--spring-test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.10</version>
<scope>test</scope>
</dependency>
javaconfig:
@Configuration // 标记当前类为配置类 =xml配文件
//@EnableJpaRepositories(basePackages="com.tuling.repositories") // 启动jpa <jpa:repositories
@EnableTransactionManagement // 开启事务
public class SpringDataJPAConfig {
/*
* <!--数据源-->
<bean class="com.alibaba.druid.pool.DruidDataSource" name="dataSource">
<property name="username" value="root"/>
<property name="password" value="123456"/>
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
</bean>
* */
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUsername("root");
dataSource.setPassword("123456");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8");
return dataSource;
}
/*
* <!--EntityManagerFactory-->
<bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaVendorAdapter">
<!--Hibernate实现-->
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--生成数据库表-->
<property name="generateDdl" value="true"></property>
<property name="showSql" value="true"></property>
</bean>
</property>
<!--设置实体类的包-->
<property name="packagesToScan" value="com.tuling.pojo"></property>
<property name="dataSource" ref="dataSource" ></property>
</bean>
* */
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
vendorAdapter.setGenerateDdl(true);
vendorAdapter.setShowSql(true);
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setJpaVendorAdapter(vendorAdapter);
factory.setPackagesToScan("com.tuling.pojo");
factory.setDataSource(dataSource());
return factory;
}
/*
* <bean class="org.springframework.orm.jpa.JpaTransactionManager" name="transactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
* */
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
JpaTransactionManager txManager = new JpaTransactionManager();
txManager.setEntityManagerFactory(entityManagerFactory);
return txManager;
}
}spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/jpa
https://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--用于整合jpa @EnableJpaRepositories -->
<jpa:repositories base-package="com.tuling.repositories"
entity-manager-factory-ref="entityManagerFactory"
transaction-manager-ref="transactionManager"
/>
<!--EntityManagerFactory-->
<bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaVendorAdapter">
<!--Hibernate实现-->
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--生成数据库表-->
<property name="generateDdl" value="true"></property>
<property name="showSql" value="true"></property>
</bean>
</property>
<!--设置实体类的包-->
<property name="packagesToScan" value="com.tuling.pojo"></property>
<property name="dataSource" ref="dataSource" ></property>
</bean>
<!--数据源-->
<bean class="com.alibaba.druid.pool.DruidDataSource" name="dataSource">
<property name="username" value="root"/>
<property name="password" value="123456"/>
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
</bean>
<!--声明式事务-->
<bean class="org.springframework.orm.jpa.JpaTransactionManager" name="transactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--启动注解方式的声明式事务-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
<context:component-scan base-package="com.tuling"></context:component-scan>
</beans>pojo实体类：
@Entity // 作为hibernate 实体类
@Table(name = "tb_customer") // 映射的表明
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long custId; //客户的主键
@Column(name = "cust_name")
private String custName;//客户名称
@Column(name="cust_address")
private String custAddress;//客户地址
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName='" + custName + '\'' +
", custAddress='" + custAddress + '\'' +
"}\n";
}
}customerRepository:
public interface CustomerRepository extends CrudRepository<Customer,Long>{
// public interface CustomerRepository extends PagingAndSortingRepository<Customer,Long>{
}测试：
//@ContextConfiguration("/spring.xml")
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringdataJpaTest {
// jdk动态代理的实例
@Autowired
CustomerRepository repository;
@Test
public void testR(){
Optional<Customer> byId = repository.findById(20L);
System.out.println(byId.orElse(null));
}
@Test
public void testC(){
Customer customer = new Customer();
customer.setCustName("李四");
System.out.println(repository.save(customer));
}
@Test
public void testD(){
Customer customer = new Customer();
customer.setCustId(3L);
customer.setCustName("李四");
repository.delete(customer);
}
@Test
public void testFindAll(){
Iterable<Customer> allById = repository.findAllById(Arrays.asList(1L, 7L, 8L));
System.out.println(allById);
}
}CrudRepository与PagingAndSortingRepository区别：
PagingAndSortingRepository更全，除了CrudRepository的东西，里面包含分页。
PagingAndSortingRepository的实例测试：
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringDataJpaPagingAndSortTest
{
// jdk动态代理的实例
@Autowired
CustomerRepository repository;
@Test
public void testPaging(){
Page<Customer> all = repository.findAll(PageRequest.of(0, 2));
System.out.println(all.getTotalPages());
System.out.println(all.getTotalElements());
System.out.println(all.getContent());
}
@Test
public void testSort(){
Sort sort = Sort.by("custId").descending();
Iterable<Customer> all = repository.findAll(sort);
System.out.println(all);
}
@Test
public void testSortTypeSafe(){
Sort.TypedSort<Customer> sortType = Sort.sort(Customer.class);
Sort sort = sortType.by(Customer::getCustId).descending();
Iterable<Customer> all = repository.findAll(sort);
System.out.println(all);
}
}自定义操作
jpql(原生sql)：
a. @Query
i. 查询如果返回单个实体 就用pojo接收 ， 如果是多个需要通过集合
ii. 参数设置方式1. 索引 ： ?数字2. 具名： :参数名 结合@Param注解指定参数名字
iii. 增删改：1. 要加上事务的支持：2. 如果是插入方法：一定只能在hibernate下才支持 （Insert into..select )
@Transactional
@Modifying // 通知springdatajpa 是增删改的操作
CustomerRepository:
public interface CustomerRepository extends PagingAndSortingRepository<Customer,Long>{
//public interface CustomerRepository extends CrudRepository<Customer,Long>{
// 增删查改
// 查询
@Query("FROM Customer where custName=:custName ")
List<Customer> findCustomerByCustName(@Param("custName") String custName);
// 修改
@Transactional
@Modifying // 通知springdatajpa 是增删改的操作
@Query("UPDATE Customer c set c.custName=:custName where c.custId=:id")
int updateCustomer(@Param("custName") String custName,@Param("id")Long id);
@Transactional
@Modifying // 通知springdatajpa 是增删改的操作
@Query("DELETE FROM Customer c where c.custId=?1")
int deleteCustomer(Long id);
// 新增 JPQL
@Transactional
@Modifying // 通知springdatajpa 是增删改的操作
@Query("INSERT INTO Customer (custName) SELECT c.custName FROM Customer c where c.custId=?1")
int insertCustomerBySelect(Long id);
@Query(value="select * FROM tb_customer where cust_name=:custName "
,nativeQuery = true)
List<Customer> findCustomerByCustNameBySql(@Param("custName") String custName);
}测试：
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class JpqlTest {
// jdk动态代理的实例
@Autowired
CustomerRepository repository;
@Test
public void testR(){
List<Customer> customer = repository.findCustomerByCustName("李四");
System.out.println(customer);
}
@Test
public void testU(){
int result = repository.updateCustomer("王五", 7L);
System.out.println(result);
}
@Test
public void testD(){
int result = repository.deleteCustomer(10L);
System.out.println(result);
}
@Test
public void testC(){
int result = repository.insertCustomerBySelect(7L);
System.out.println(result);
}
@Test
public void testR_sql(){
List<Customer> customer = repository.findCustomerByCustNameBySql("徐庶");
System.out.println(customer);
}
}规定方法名：
支持的查询方法主题关键字(前缀)
决定当前方法作用
只支持查询 和删除
支持的查询方法谓词关键字和修饰符
决定查询条件
CustomerMethodNameRepository：：
public interface CustomerMethodNameRepository extends PagingAndSortingRepository<Customer,Long> {
List<Customer> findByCustName(String custName);
boolean existsByCustName(String custName);
@Transactional
@Modifying
int deleteByCustId(Long custName);
List<Customer> findByCustNameLike(String custName);
}测试：
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class MethodNameTest {
// jdk动态代理的实例
@Autowired
CustomerMethodNameRepository repository;
@Test
public void test01() {
List<Customer> list = repository.findByCustName("李四");
System.out.println(list);
}
@Test
public void test02() {
boolean exists = repository.existsByCustName("xxx");
System.out.println(exists);
}
@Test
public void test03() {
int exists = repository.deleteByCustId(12L);
System.out.println(exists);
}
@Test
public void test04() {
List<Customer> list = repository.findByCustNameLike("徐%");
System.out.println(list);
}
}Query by Example:
只支持查询：
i. 不支持嵌套或分组的属性约束，如 firstname = ？0 or (firstname = ？1and lastname = ？2).
ii. 只支持字符串 start/contains/ends/regex 匹配和其他属性类型的精确匹配。
实现：将Repository继承QueryByExampleExecutor
实例：
CustomerQBERepository：
public interface CustomerQBERepository
extends PagingAndSortingRepository<Customer,Long>
, QueryByExampleExecutor<Customer> {
}测试：
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class QBETest {
// jdk动态代理的实例
@Autowired
CustomerQBERepository repository;
/**
* 简单实例 客户名称 客户地址动态查询
*/
@Test
public void test01(){
// 查询条件
Customer customer=new Customer();
customer.setCustName("徐庶");
customer.setCustAddress("BEIJING");
// 通过Example构建查询条件
Example<Customer> example = Example.of(customer);
List<Customer> list = (List<Customer>) repository.findAll(example);
System.out.println(list);
}
/**
* 通过匹配器 进行条件的限制
* 简单实例 客户名称 客户地址动态查询
*/
@Test
public void test02(){
// 查询条件
Customer customer=new Customer();
customer.setCustName("庶");
customer.setCustAddress("JING");
// 通过匹配器 对条件行为进行设置
ExampleMatcher matcher = ExampleMatcher.matching()
//.withIgnorePaths("custName") // 设置忽略的属性
//.withIgnoreCase("custAddress") // 设置忽略大小写
//.withStringMatcher(ExampleMatcher.StringMatcher.ENDING); // 对所有条件字符串进行了结尾匹配
.withMatcher("custAddress",m -> m.endsWith().ignoreCase()); // 针对单个条件进行限制, 会使withIgnoreCase失效，需要单独设置
//.withMatcher("custAddress", ExampleMatcher.GenericPropertyMatchers.endsWith().ignoreCase());
// 通过Example构建查询条件
Example<Customer> example = Example.of(customer,matcher);
List<Customer> list = (List<Customer>) repository.findAll(example);
System.out.println(list);
}
}Specifications:
在之前使用Query by Example只能针对字符串进行条件设置，那如果希望对所有类型支持，可以使用Specifications
实例：
实现：将Repository继承JpaSpecificationExecutor
CustomerSpecificationsRepository：
public interface CustomerSpecificationsRepository
extends PagingAndSortingRepository<Customer,Long>,
JpaSpecificationExecutor<Customer> {
}Root：查询哪个表（关联查询） = from
CriteriaQuery：查询哪些字段，排序是什么 =组合(order by . where )
CriteriaBuilder：条件之间是什么关系，如何生成一个查询条件，每一个查询条件都是什么类型（>between in...) = where
Predicate（Expression）： 每一条查询条件的详细描述
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpecificationTest {
// jdk动态代理的实例
@Autowired
CustomerSpecificationsRepository repository;
@Test
public void testR(){
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
return null;
}
});
System.out.println(customer);
}
/**
* 查询客户范围 (in)
* id >大于
* 地址 精确
*/
@Test
public void testR2(){
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
Path<Object> custId = root.get("custId");
Path<Object> custName = root.get("custName");
Path<Object> custAddress = root.get("custAddress");
// 参数1 ：为哪个字段设置条件 参数2：值
Predicate predicate = cb.equal(custAddress, "BEIJING");
return predicate;
}
});
System.out.println(customer);
}
/**
* 查询客户范围 (in)
* id >大于
* 地址 精确
*/
@Test
public void testR3(){
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
Path<Long> custId = root.get("custId");
Path<String> custName = root.get("custName");
Path<String> custAddress = root.get("custAddress");
// 参数1 ：为哪个字段设置条件 参数2：值
Predicate custAddressP = cb.equal(custAddress, "BEIJING");
Predicate custIdP = cb.greaterThan(custId, 0L);
CriteriaBuilder.In<String> in = cb.in(custName);
in.value("徐庶").value("王五");
Predicate and = cb.and(custAddressP, custIdP,in);
return and;
}
});
System.out.println(customer);
}
/**
* 查询客户范围 (in)
* id >大于
* 地址 精确
*/
@Test
public void testR4(){
Customer params=new Customer();
//params.setCustAddress("BEIJING");
params.setCustId(0L);
params.setCustName("徐庶,王五");
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
// 1. 通过root拿到需要设置条件的字段
Path<Long> custId = root.get("custId");
Path<String> custName = root.get("custName");
Path<String> custAddress = root.get("custAddress");
// 2. 通过CriteriaBuilder设置不同类型条件
List<Predicate> list=new ArrayList<>();
if(!StringUtils.isEmpty(params.getCustAddress())) {
// 参数1 ：为哪个字段设置条件 参数2：值
list.add(cb.equal(custAddress, "BEIJING")) ;
}
if(params.getCustId()>-1){
list.add(cb.greaterThan(custId, 0L));
}
if(!StringUtils.isEmpty(params.getCustName())) {
CriteriaBuilder.In<String> in = cb.in(custName);
in.value("徐庶").value("王五");
list.add(in);
}
// 组合条件
Predicate and = cb.and(list.toArray(new Predicate[list.size()]));
return and;
}
});
System.out.println(customer);
}
@Test
public void testR5(){
Customer params=new Customer();
//params.setCustAddress("BEIJING");
params.setCustId(0L);
params.setCustName("徐庶,王五");
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
Path<Long> custId = root.get("custId");
Path<String> custName = root.get("custName");
Path<String> custAddress = root.get("custAddress");
// 参数1 ：为哪个字段设置条件 参数2：值
List<Predicate> list=new ArrayList<>();
if(!StringUtils.isEmpty(params.getCustAddress())) {
list.add(cb.equal(custAddress, "BEIJING")) ;
}
if(params.getCustId()>-1){
list.add(cb.greaterThan(custId, 0L));
}
if(!StringUtils.isEmpty(params.getCustName())) {
CriteriaBuilder.In<String> in = cb.in(custName);
in.value("徐庶").value("王五");
list.add(in);
}
Predicate and = cb.and(list.toArray(new Predicate[list.size()]));
Order desc = cb.desc(custId);
return query.where(and).orderBy(desc).getRestriction();
}
});
System.out.println(customer);
}
}限制：不能分组、聚合函数， 需要自己通过entityManager玩
Querydsl:
QueryDSL是基于ORM框架或SQL平台上的一个通用查询框架。借助QueryDSL可以在任何支持的ORM框架或SQL平台上以通用API方式构建查询。
JPA是QueryDSL的主要集成技术，是JPQL和Criteria查询的代替方法。目前QueryDSL支持的平台包括JPA,JDO,SQL,Mongodb 等等。。。
Querydsl扩展能让我们以链式方式代码编写查询方法。该扩展需要一个接口QueryDslPredicateExecutor，它定义了很多查询方法。
实例：
引入依赖：
<properties>
<querydsl.version>4.4.0</querydsl.version>
<apt.version>1.1.3</apt.version>
</properties>
<!-- querydsl -->
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>${querydsl.version}</version>
</dependency>添加 maven 插件：
这个插件是为了让程序自动生成query type(查询实体，命名方式为："Q"+对应实体名)。
<build>
<plugins>
<plugin>
<groupId>com.mysema.maven</groupId>
<artifactId>apt-maven-plugin</artifactId>
<version>${apt.version}</version>
<dependencies>
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
<version>${querydsl.version}</version>
</dependency>
</dependencies>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>process</goal>
</goals>
<configuration>
<outputDirectory>target/generated-sources/queries</outputDirectory>
<processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
<logOnlyOnError>true</logOnlyOnError>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>执行mvn compile之后,可以找到该target/generated-sources/java,然后IDEA标示为源代码目录即可.
CustomerQueryDSLRepository：
public interface CustomerQueryDSLRepository extends
PagingAndSortingRepository<Customer,Long>
, QuerydslPredicateExecutor<Customer> {
}测试类：
@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class QueryDSLTest {
// jdk动态代理的实例
@Autowired
CustomerQueryDSLRepository repository;
@Test
public void test01() {
QCustomer customer = QCustomer.customer;
// 通过Id查找
BooleanExpression eq = customer.custId.eq(1L);
System.out.println(repository.findOne(eq));
}
/**
* 查询客户名称范围 (in)
* id >大于
* 地址 精确
*/
@Test
public void test02() {
QCustomer customer = QCustomer.customer;
// 通过Id查找
BooleanExpression and = customer.custName.in("徐庶", "王五")
.and(customer.custId.gt(0L)) //大于
.and(customer.custAddress.eq("BEIJING"));
System.out.println(repository.findOne(and));
}
/**
* 查询客户名称范围 (in)
* id >大于
* 地址 精确
*/
@Test
public void test03() {
Customer params=new Customer();
params.setCustAddress("BEIJING");
params.setCustId(0L);
params.setCustName("徐庶,王五");
QCustomer customer = QCustomer.customer;
// 初始条件 类似于1=1 永远都成立的条件
BooleanExpression expression = customer.isNotNull().or(customer.isNull());
expression=params.getCustId()>-1?
expression.and(customer.custId.gt(params.getCustId())):expression;
expression=!StringUtils.isEmpty( params.getCustName())?
expression.and(customer.custName.in(params.getCustName().split(","))):expression;
expression=!StringUtils.isEmpty( params.getCustAddress())?
expression.and(customer.custAddress.eq(params.getCustAddress())):expression;
System.out.println(repository.findAll(expression));
}
// 解决线程安全问题 autowire装配会有 线程安全问题
@PersistenceContext
EntityManager em;
/**
* 自定义列查询、分组
* 需要使用原生态的方式（Specification)
* 通过Repository进行查询， 列、表都是固定
*/
@Test
public void test04() {
JPAQueryFactory factory = new JPAQueryFactory(em);
QCustomer customer = QCustomer.customer;
// 构建基于QueryDSL的查询
JPAQuery<Tuple> tupleJPAQuery = factory.select(customer.custId, customer.custName)
.from(customer)
.where(customer.custId.eq(1L))
.orderBy(customer.custId.desc());
// 执行查询
List<Tuple> fetch = tupleJPAQuery.fetch();
// 处理返回数据
for (Tuple tuple : fetch) {
System.out.println(tuple.get(customer.custId));
System.out.println(tuple.get(customer.custName));
}
}
@Test
public void test05() {
JPAQueryFactory factory = new JPAQueryFactory(em);
QCustomer customer = QCustomer.customer;
// 构建基于QueryDSL的查询
JPAQuery<Long> longJPAQuery = factory.select(
customer.custId.sum())
.from(customer)
//.where(customer.custId.eq(1L))
.orderBy(customer.custId.desc());
// 执行查询
List<Long> fetch = longJPAQuery.fetch();
// 处理返回数据
for (Long sum : fetch) {
System.out.println(sum);
}
}
}
