SpringDataJPA学习笔记

1、Spring Data Jpa

概述

Spring Data Jpa是Spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码实现对数据库的访问和操作，推荐使用Spring Data JPA+ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作简单，方便解耦。

SpringDataJpa、JPA和Hibernate的关系

JPA是一种规范，内部由接口和抽象类构成。而我们的Hibernate是一套成熟的ORM框架，并且Hibernate实现了JPA规范，我们在使用JPA的API进行编程的时候，意味着站在更高的角度看待问题（面向接口编程）。

Spring Data Jpa是Spring提供的一套对于JPA操作的更加高级的封装，是在JPA规范下用来专门进行数据持久化的解决方案。

案例说明

创建maven工程并导入坐标

<properties>
    <spring.version>4.2.4.RELEASE</spring.version>
    <hibernate.version>5.0.7.Final</hibernate.version>
    <slf4j.version>1.7.30</slf4j.version>
    <log4j.version>2.12.1</log4j.version>
    <c3p0.version>0.9.1.2</c3p0.version>
    <mysql.version>8.0.16</mysql.version>
</properties>

<dependencies>
    <!-- junit单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- spring beg -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.6.8</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- spring end -->

    <!-- hibernate beg -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>5.2.1.Final</version>
    </dependency>
    <!-- hibernate end -->

    <!-- c3p0 beg -->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
    </dependency>
    <!-- c3p0 end -->

    <!-- log end -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>${log4j.version}</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->


    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>1.9.0.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- el beg 使用spring data jpa 必须引入 -->
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>javax.el-api</artifactId>
        <version>2.2.4</version>
    </dependency>

    <dependency>
        <groupId>org.glassfish.web</groupId>
        <artifactId>javax.el</artifactId>
        <version>2.2.4</version>
    </dependency>
    <!-- el end -->

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

编写Spring的配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
      http://www.springframework.org/schema/data/jpa
      http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    <!--spring data jpa的配置-->
    <!--创建EntityManagerFactory对象交给容器来管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置实体类的扫描包-->
        <property name="packagesToScan" value="com.hzp.entity"/>
        <!--Jpa的实现厂家-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--Jpa的供应商适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--配置是否自动创建数据库表-->
                <property name="generateDdl" value="false"/>
                <!--指定数据库的类型-->
                <property name="database" value="MYSQL"/>
                <!--指定方言，独有的语法-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <!--显示sql-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
        <!--Jpa的方言：高级特性-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>
    </bean>
    <!--数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    </bean>
    <!--整合Spring Data Jpa-->
  	<!-- 
			base-package指定dao接口所在的包
		-->
    <jpa:repositories base-package="com.hzp.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"/>
    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--声明式事务-->

    <!--包扫描-->
    <context:component-scan base-package="com.hzp"/>
</beans>

创建实体类

package com.hzp.entity;

import javax.persistence.*;

/**
 * 配置实体类和表的映射关系
 * @Entity：表明这是一个实体类
 * @Table：映射的数据库表
 * 配置属性和字段的映射关系
 * @Id：配置主键
 * @GeneratedValue：配置主键的生成策略
 * @Column：映射的字段
 */
@Entity
@Table(name = "cst_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_address")
    private String custAddress;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_phone")
    private String custPhone;
    @Column(name = "cust_source")
    private String custSource;

    public Customer() {
    }

    public Customer(String custAddress, String custIndustry, String custLevel, String custName, String custPhone, String custSource) {
        this.custAddress = custAddress;
        this.custIndustry = custIndustry;
        this.custLevel = custLevel;
        this.custName = custName;
        this.custPhone = custPhone;
        this.custSource = custSource;
    }

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custAddress='" + custAddress + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custName='" + custName + '\'' +
                ", custPhone='" + custPhone + '\'' +
                ", custSource='" + custSource + '\'' +
                '}';
    }
}

编写符合Spring Data Jpa的dao接口

/**
 * 符合Spring Data Jpa的接口
 * 1、继承JpaRepository接口，它需要两个泛型，第一个是实体类类型，第二个是实体类主键属性的类型
 *      封装了基本的CRUD
 * 2、继承JpaSpecificationExecutor接口，它需要一个泛型，表示实体类类型
 *       封装了复杂查询（分页）
 */
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
}

测试，查询单个客户

@RunWith(SpringJUnit4ClassRunner.class)  //spring提供的测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定spring的配置信息的位置
public class JpaTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 查询某个客户
     */
    @Test
    public void testFindOne(){
        Customer customer = customerDao.findOne(1L);
        System.out.println(customer);
    }
}

测试，添加或修改用户

		/**
     * 更新的话需要注意两个问题：
     * 1、假如要修改的行的某个字段有值，但是你传入的对象没有设置该字段
     * 对应的属性，那么这个字段会被更新为空
     * 2、执行更新操作之前会先根据id进行查询，如果查询出来的对象
     * 和我们要传入的对象的各个属性都没差别的话，那么就不会进行更新操作
     */
    @Test
    public void testInsert(){
        Customer customer=new Customer();
        customer.setCustName("逆天而行");
        customer.setCustAddress("地狱");
        customerDao.save(customer);
    }

    @Test
    public void testUpdate(){
        Customer customer=new Customer();
        customer.setCustId(5L);
        customer.setCustName("随风起舞");
        customerDao.save(customer);
    }

删除客户

    /**
     * 删除客户
     */
    @Test
    public void testDelete(){
        customerDao.delete(6L);
    }

查询所有

/**
     * 查询所有
     */
    @Test
    public void testFindAll(){
        List<Customer> customers = customerDao.findAll();
        for (Customer customer : customers) {
            System.out.println(customer);
        }
    }

查询客户的数量

/**
     * 查询客户数量
     */
    @Test
    public void testCount(){
        long count = customerDao.count();
        System.out.println("客户数量："+count);
    }

查询客户是否存在

/**
     * 查询客户是否存在
     */
    @Test
    public void testExist(){
        boolean exists = customerDao.exists(1L);
        System.out.println("1号客户是否存在："+exists);
    }

根据id查询用户

/**
     * 根据id查询用户
     * findOne():
     *      em.find()  立即加载
     * getOne():
     *      em.getReference()   延迟加载
     */
    @Test
    @Transactional //该注解保证getOne方法可以正常执行
    public void testGetOne(){
        Customer customer = customerDao.getOne(1L);
        System.out.println(customer);
    }

2、执行流程分析

我们在前面的案例中只编写了dao接口，该接口继承了JpaRepository和JpaSpecificationExecutor两个接口，可是我们并没有编写接口的实现类，为什么却能帮我们操作数据库呢？只有一种可能，程序在执行过程中必然动态生成了接口的实现类。那么我们接下来进行断点调试：

我们进入JdkDynamicAopProxy查看此类：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        TargetSource targetSource = this.advised.targetSource;
        Class<?> targetClass = null;
        Object target = null;

        Boolean var10;
        try {
            if (this.equalsDefined || !AopUtils.isEqualsMethod(method)) {
                if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                    Integer var18 = this.hashCode();
                    return var18;
                }

                Object retVal;
                if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                    retVal = AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
                    return retVal;
                }

                if (this.advised.exposeProxy) {
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }

                target = targetSource.getTarget();
                if (target != null) {
                    targetClass = target.getClass();
                }

                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                if (chain.isEmpty()) {
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
                } else {
                    MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                    retVal = invocation.proceed();
                }

                Class<?> returnType = method.getReturnType();
                if (retVal != null && retVal == target && returnType.isInstance(proxy) && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                    retVal = proxy;
                } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                    throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
                }

                Object var13 = retVal;
                return var13;
            }

            var10 = this.equals(args[0]);
        } finally {
            if (target != null && !targetSource.isStatic()) {
                targetSource.releaseTarget(target);
            }

            if (setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }

        }

        return var10;
    }

当我们调用方法时，必然会经过这个方法，我们在这个方法内部打断点再次调试：

可以看到，代理对象是SimpleJpaRepository类型的，我们进入此类查看：

@Repository
@Transactional(
    readOnly = true
)
public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>, JpaSpecificationExecutor<T> {
        public T findOne(ID id) {
            Assert.notNull(id, "The given id must not be null!");
            Class<T> domainType = this.getDomainClass();
            if (this.metadata == null) {
                return this.em.find(domainType, id);
            } else {
                LockModeType type = this.metadata.getLockModeType();
                Map<String, Object> hints = this.getQueryHints();
                return type == null ? this.em.find(domainType, id, hints) : this.em.find(domainType, id, type, hints);
            }
        }

可以看到，SimpleJpaRepository也实现了JpaRepository和JpaSpecificationExecutor，所以我们的接口继承的方法，它也必将继承了，我们在

findOne方法里面打断点，看是否会进入这里：

也就是说，最终调用的是SimpleJpaRepository中对应的方法，里面通过调用实体管理器的方法完成数据库操作。下面这张图是总体流程：

3、JPQL查询

如何在Spring Data Jpa中使用JPQL(jpa query language)进行数据库操作呢？我们可以通过@Query达到我们的目的。

通过客户名称查询

   /**
     * 根据客户名称查询：
     * jpql:from Customer where custName=?
     */
    @Query(value = "from Customer where custName=?")
    Customer findJpql(String custName);

    /**
     * 根据客户名称查询客户
     */
    @Test
    public void testFindJpal(){
        Customer customer = customerDao.findJpql("天行者");
        System.out.println(customer);
    }

通过客户名称和id进行查询

/**
     * 根据客户的名称和id进行查询
     * 当我们的jpql语句有多个占位符时，默认占位符的位置
     * 和我们的参数的位置是一一对应的，当然，我们也可以在占位符
     * 后面指定所需参数的位置
     */
    @Query(value = "from Customer where custName=?2 and custId=?1")
    Customer findNameId(Long id,String name);

通过客户id修改客户

/**
     * 根据id进行更新
     */
    @Query(value = "update Customer set custName=?2 where custId=?1")
    @Modifying  //表明这是一个更新操作
    void jpqlUpdate(Long id,String name);

		@Test
    @Transactional  //修改和删除需要提供事务的支持
    @Rollback(value = false)  //不设置默认回滚
    public void testUpdate(){
        customerDao.jpqlUpdate(1L, "天行者2号");
    }

4、sql查询

使用sql查询也是使用@Query注解，不过需要配合nativeQuery一起使用，nativeQuery默认为false，代表jpql查询，为true则表示sql查询

查询全部

/**
     * 查询全部
     */
    @Query(value = "select * from cst_customer",nativeQuery = true)
    List<Customer> findAll();

模糊查询

/**
     * 模糊查询
     */
    @Query(value = "select * from cst_customer where cust_name like ?",nativeQuery = true)
    List<Customer> findLike(String name);

		@Test
    public void testFindLike(){
        List<Customer> customers = customerDao.findLike("天行者%");
        for (Customer customer : customers) {
            System.out.println(customer);
        }
    }

5、方法命名规则查询

所谓的方法命名规则查询，是指**只要我们的方法命名符合特定的规则，那么不用使用@Query也可以进行查询。**那么这所谓的规则是什么呢？

规则：findBy+属性名+查询方式(like|isNull)+连接符(and|or)+属性名+查询方式(like|isNull)

举个例子，我们要根据客户名称和id进行查询，那么命名为：findByCustNameAndCustId，find表示查询，By后面跟条件，条件之间使用And分开，条件是属性名

根据客户名称和id进行查询

		/**
     * 基本查询
     */
    Customer findByCustNameAndAndCustId(String custName,Long custId);

@Test
    public void testFindByCustNameAndCustId(){
        Customer customer = customerDao.findByCustNameAndAndCustId("天行者2号", 1L);
        System.out.println(customer);
    }

模糊查询：模糊查询，条件后面跟查询方式（like|isNull）

		/**
     * 模糊查询
     */
    List<Customer> findByCustNameLike(String name);

		/**
     * 模糊查询
     */
    @Test
    public void testLike(){
        List<Customer> customers = customerDao.findByCustNameLike("天行者%");
        for (Customer customer : customers) {
            System.out.println(customer);
        }
    }

多条件查询：名称模糊和id精准

 /**
     * 多条件查询
     */
    Customer findByCustNameLikeAndCustId(String name,Long id);

		@Test
    public void testCondition(){
        Customer customer = customerDao.findByCustNameLikeAndCustId("天行者%", 1L);
        System.out.println(customer);
    }

6、Specification动态查询

我们在定义接口时继承了JpaSpecificationExecutor，这个接口用于进行复杂查询。我们来查看下该类：

public interface JpaSpecificationExecutor<T> {
    T findOne(Specification<T> var1);

    List<T> findAll(Specification<T> var1);

    Page<T> findAll(Specification<T> var1, Pageable var2);

    List<T> findAll(Specification<T> var1, Sort var2);

    long count(Specification<T> var1);
}

该接口的所有方法都需要一个Specification类型的参数，该参数用于封装条件，我们点进去看一下：

public interface Specification<T> {
	Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
}

• root：查询的根对象（查询的任何属性都可以从根对象获取）
• query：顶层查询对象，用于自定义查询方式（一般不用）
• cb：查询构造器，封装了很多的查询条件

根据客户名称进行查询

		/**
     * 根据客户名称进行查询
     */
    @Test
    public void test1(){
        Specification<Customer> spec=new Specification<Customer>() {
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //构造查询条件
                //1.获取要比较的属性
                Path<Object> custName = root.get("custName");
                //2.设置条件  cust_name='天行者2号'
                Predicate predicate = cb.equal(custName, "天行者2号");
                return predicate;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }

多条件查询

/**
     * 多条件查询
     * 根据客户的名称和客户所属行业查询
     */
    @Test
    public void test2(){
        Specification<Customer> spec = new Specification<Customer>() {
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //获取要比较的属性
                Path<Object> custName = root.get("custName");
                Path<Object> custIndustry = root.get("custIndustry");
                //构造查询条件
                Predicate p1 = cb.equal(custName, "天行者2号");
                Predicate p2 = cb.equal(custIndustry, "装逼");
                //将条件连接起来
                Predicate p3 = cb.and(p1, p2);
                return p3;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }

模糊查询

/**
     * 模糊查询
     * 查询名称中带有天行者的客户
     */
    @Test
    public void test3(){
        Specification<Customer> spec = new Specification<Customer>() {
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //获取要比较的属性
                Path<Object> custName = root.get("custName");
                //构建查询条件(使用like需要指定path的类型，也就是属性的类型)
                Predicate predicate = cb.like(custName.as(String.class), "%天行者%");
                return predicate;
            }
        };
        List<Customer> list = customerDao.findAll(spec);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

排序

/**
     * 排序
     */
    @Test
    public void test4(){
        Specification<Customer> spec = new Specification<Customer>() {
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //获取要比较的属性
                Path<Object> custName = root.get("custName");
                //构建查询条件(使用like需要指定path的类型，也就是属性的类型)
                Predicate predicate = cb.like(custName.as(String.class), "%%");
                return predicate;
            }
        };
        //第一个参数用于指定排序方式：Sort.Direction.DESC:倒序
        //第二个参数指定排序的属性，可指定多个
        Sort sort=new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(spec,sort);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

分页

    /**
     * 分页
     */
    @Test
    public void test5(){
        //PageRequest是Pageable的实现类
        //page：指定页码   size：指定每页条数
        Pageable pageable=new PageRequest(1, 2);
        Page<Customer> customers = customerDao.findAll(null, pageable);
        System.out.println(customers.getTotalElements());//获取总条数
        System.out.println(customers.getTotalPages());//获取总页数
        List<Customer> list = customers.getContent();
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

7、多表查询

一对多

配置文件修改，在entityManagerFactory中加入这一段代码

<!--注入jpa的配置信息-->
<property name="jpaProperties">
    <props>
        <prop key="hibernate.hbm2ddl.auto">create</prop>
     </props>
 </property>

编写实体类

package com.hzp.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Data
@NoArgsConstructor
@AllArgsConstructor
/**
 * 配置实体类和表的映射关系
 * @Entity：表明这是一个实体类
 * @Table：映射的数据库表
 * 配置属性和字段的映射关系
 * @Id：配置主键
 * @GeneratedValue：配置主键的生成策略
 * @Column：映射的字段
 */
@Entity
@Table(name = "cst_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_address")
    private String custAddress;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_phone")
    private String custPhone;
    @Column(name = "cust_source")
    private String custSource;
    /**
     * 配置一对多关系
     *@OneToMany：配置一对多关系
     *	targetEntity：指定对方的实体类类型
     *@JoinColumn：
     *	name:外键名
     *	referencedColumnName：外键对应的主键
     */
    @OneToMany(targetEntity=LinkMan.class)
    @JoinColumn(name = "cust_link_id",referencedColumnName = "cust_id")
    private Set<LinkMan> linkManSet=new HashSet<LinkMan>();
}

package com.hzp.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

/**
 * @ClassName LinkMan
 * @Description
 * @Author HuangZhaoPeng
 * @Date 2020/10/13 15:02
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor

@Entity
@Table(name = "cst_linkman")
public class LinkMan {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "lkm_id")
    private Long lkmId; //联系人编号(主键)
    @Column(name = "lkm_name")
    private String lkmName;//联系人姓名
    @Column(name = "lkm_gender")
    private String lkmGender;//联系人性别
    @Column(name = "lkm_phone")
    private String lkmPhone;//联系人办公电话
    @Column(name = "lkm_mobile")
    private String lkmMobile;//联系人手机
    @Column(name = "lkm_email")
    private String lkmEmail;//联系人邮箱
    @Column(name = "lkm_position")
    private String lkmPosition;//联系人职位
    @Column(name = "lkm_memo")
    private String lkmMemo;//联系人备注

    /**
     * 配置多对一关系
     */
    @ManyToOne(targetEntity = Customer.class)
    @JoinColumn(name = "cust_link_id",referencedColumnName = "cust_id")
    private Customer customer;
}

测试

/**
     * 添加一个客户，添加一个联系人
     */
    @Test
    @Transactional
    @Rollback(value = false)
    public void test1(){
        //创建一个客户和联系人
        Customer customer=new Customer();
        customer.setCustName("王舞");
        LinkMan linkMan=new LinkMan();
        linkMan.setLkmName("王陆");
        /**
         * 会发送两条插入语句和一条更新语句，也就是说我们
         * 在客户这一方修改了在联系人方的外键。
         * 原因：
         * 由于我们在实体类中配置了一对多关系
         * 所以我们的客户表也可以去维护联系人表的外键
         */
        customer.getLinkManSet().add(linkMan);
        //执行插入
        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void test2(){
        //创建一个客户和联系人
        Customer customer=new Customer();
        customer.setCustName("王舞");
        LinkMan linkMan=new LinkMan();
        linkMan.setLkmName("王陆");
        /**
         * 只发送了两条插入语句，没有更新语句
         * 原因：外键本身就在我们的联系人表中，
         * 所以维护的任务必然是在联系人这一方，
         * 并且我们还配置了多对一的关系
         */
        linkMan.setCustomer(customer);
        //执行插入
        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

我们发现，从客户这方去维护外键会多出一条更新语句，从联系人这方则没有，所以我们可以选择放弃客户方的维护权

@OneToMany(mappedBy = "customer")  //放弃外键维护权
private Set<LinkMan> linkManSet=new HashSet<LinkMan>();

我们再次执行test1，发现不会有更新语句了

级联

级联：操作一个对象的同时操作它的关联对象。

• 级联添加：添加一个客户的同时添加所有联系人
• 级联删除：删除一个客户的同时删除所有关联的联系人

如果要测试级联的话，我们需要对主体类Customer做如下修改：

    /**
     * 放弃外键维护权
     *      mappedBy：对方配置关系的属性名称\
     * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
     *      CascadeType.all         : 所有
     *                  MERGE       ：更新
     *                  PERSIST     ：保存
     *                  REMOVE      ：删除
     */
    @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
    private Set<LinkMan> linkMans = new HashSet<LinkMan>();

测试级联删除

    /**
     * 级联删除：
     *      删除1号客户的同时，删除1号客户的所有联系人
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testCascadeRemove() {
        //1.查询1号客户
        Customer customer = customerDao.findOne(4l);
        //2.删除1号客户
        if (customer!=null){
            customerDao.delete(customer);
        }
    }

我出现了如下问题：

Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (jpa.cst_linkman, CONSTRAINT FKpcyd4ttxs13y5iwevdmr7lv5h FOREIGN KEY (cust_link_id) REFERENCES cst_customer (cust_id))

最后我发现了一个问题，hibernate给我们自动创建的表中外键约束FKpcyd4ttxs13y5iwevdmr7lv5h缺少了on delete cascade之类的东西，然后我就把hibernate给我们创建的表删除并手动创建表，最后测试发现可以了：下面是需要添加外键约束的cst_linkman表，加上了on delete cascade

CREATE TABLE `cst_linkman` (
  `lkm_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `lkm_email` varchar(255) DEFAULT NULL,
  `lkm_gender` varchar(255) DEFAULT NULL,
  `lkm_memo` varchar(255) DEFAULT NULL,
  `lkm_mobile` varchar(255) DEFAULT NULL,
  `lkm_name` varchar(255) DEFAULT NULL,
  `lkm_phone` varchar(255) DEFAULT NULL,
  `lkm_position` varchar(255) DEFAULT NULL,
  `cust_link_id` bigint(20) DEFAULT NULL,
  `lkm_cust_id` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`lkm_id`),
  KEY `FKh9yp1nql5227xxcopuxqx2e7q` (`lkm_cust_id`),
  CONSTRAINT `FKh9yp1nql5227xxcopuxqx2e7q` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

再次测试

多对多

创建用户和角色实体类

@Entity
@Table(name = "sys_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private Long userId;
    @Column(name = "user_name")
    private String userName;
    @Column(name = "user_age")
    private Integer userAge;

    /**
     *配置多对多的关系
     * @ManyToMany:配置多对多关系
     * @JoinTable：配置中间表
     *      name：中间表的名称
     *      joinColumns:配置当前对象在中间表的外键
     *      inverseJoinColumns：配置对方对象在中间表的位置
     */
    @ManyToMany(targetEntity = Role.class)
    @JoinTable(
            name = "sys_user_role",
            joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
            inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
    )
    private Set<Role> roles=new HashSet<Role>();

    public Set<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getUserAge() {
        return userAge;
    }

    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAge=" + userAge +
                ", roles=" + roles +
                '}';
    }
}

@Entity
@Table(name = "sys_role")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "role_id")
    private Long roleId;
    @Column(name = "role_name")
    private String roleName;

    @ManyToMany(targetEntity = User.class)
    @JoinTable(
            name = "sys_user_role",
            joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},
            inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}
    )
    private Set<User> users=new HashSet<User>();

    public Set<User> getUsers() {
        return users;
    }

    public void setUsers(Set<User> users) {
        this.users = users;
    }

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", users=" + users +
                '}';
    }
}

测试一波，插入一个用户和一个角色

@Test
    @Transactional
    @Rollback(false)
    public void test1(){
        User user=new User();
        user.setUserName("张三");
        Role role=new Role();
        role.setRoleName("主管");
        //配置角色到用户的关系
        user.getRoles().add(role);
        userDao.save(user);
        roleDao.save(role);
    }

测试级联

@ManyToMany(targetEntity = User.class,cascade = CascadeType.ALL)

	@Test
    @Transactional
    @Rollback(false)
    public void test2(){
        //查询用户
        User user = userDao.findOne(1L);
        if (user!=null){
            userDao.delete(user);
        }
    }

对象导航查询：当我们查询出某个对象的时候，可以通过它查询他的关联对象

/**
     * 对象导航查询
     * 查询一个对象的同时，将它的关联对象也给查出来
     */
    @Test
    @Transactional  //不加报：could not initialize proxy - no Session
    public void test3(){
        User user = userDao.getOne(3L);
        Set<Role> roles = user.getRoles();
        for (Role role : roles) {
            System.out.println(role);
        }
    }

但是报了个堆栈溢出，然后把toString方法删除就好了，这里建议不要使用lombok的注解生成方法，感觉这东西有问题啊。

对象导航查讯默认是懒加载，也就是说，如果你不用，则不会发送sql语句

我们可以在多对多关系配置上设置fetch属性来改变加载方式

@ManyToMany(targetEntity = User.class,,fetch = FetchType.EAGER)  //eager是渴望的意思

SpringDataJpa学习