SpringData入门学习笔记

最新推荐文章于 2021-07-17 22:55:45 发布

唯代码动人心

最新推荐文章于 2021-07-17 22:55:45 发布

阅读量882

点赞数 1

分类专栏： java进阶文章标签：数据库 spring mysql

本文链接：https://blog.youkuaiyun.com/qq_44154912/article/details/116020204

版权

java进阶专栏收录该内容

11 篇文章

订阅专栏

SpringData学习笔记

- - 传统的JDBC操作
JPA规范
Spring Data JPA
Specifications动态查询

传统的JDBC操作

在这里插入图片描述
传统的jdbc操作，操作比较繁琐还需要为占位符赋值
解决方案：将JDBC操作封装到一个工具类中，
将sql 语句相关操作封装到一个对象中。大部分的语句都是固定的，我们只需要将变动的地方作为参数传入
但是这个地方要注意，建立数据表与实体类的连接，建立列于字段的连接
在这里插入图片描述
ORM思想：
主要目的:操作实体类就相当于操作数据库表
建立两个映射关系:

实体类和表的映射关系
实体类中属性和表中字段的映射关系不再重点关注: sql语句

实现了ORM思想的框架: mybatis， hibernatel

hibernate是一个开放源代码的对象关系映射框架，它对JDBc进行了非常轻量级的对象封装，它将PoJo与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成sQL 语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

JPA规范

jpa规范,内部是由接口和抽象类组成

JPA不干活，真正干活的是根据这个规范实现的生产厂商

规范的好处， JPA提供了一个固定的接口，具体的实现交给各个厂家来实现。这样在切换数据库厂家的时候，就不用修改Java代码，只需要修改一下配置就可以。

JPA 通过注解描述实体类与数据库表之间的映射关系，并将运行期的实体对象持久化到数据库中

JPA基本操作

Maven项目案例
案例：客户的增删改查
搭建环境的过程
1.创建maven工程导入坐标
2.需要配置jpa的核心配置文件
3.编写客户的实体类
4.配置实体类和表,类中属性和表中字段的映射关系
5.保存客户到数据库中

1.创建maven工程导入坐标

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>


    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.12.1</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

2.需要配置jpa的核心配置文件

位置:配置到类路径下的一个叫做 META-INF的文件夹下*
命名: persistence. xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name:持久化单元名称
            transaction-type:事务管理的方式
                JTA:分布式事务管理	，如果不同的表分散到不同的数据库， 一个数据库就对应一个数据库连接，就必须使用分布式事务管理
                RESOURCE_LOCAL:本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 :  Hibernate实现-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--可选配置：配置jpa实现方式的配置信息-->
        <properties>
            <!-- 数据库信息
                用户名，javax.persistence.jdbc.user
                密码，  javax.persistence.jdbc.password
                驱动，  javax.persistence.jdbc.driver
                数据库地址   javax.persistence.jdbc.url
            -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://192.168.20.40/jpa?characterEncoding=utf8&amp;useSSL=false&amp;zeroDateTimeBehavior=convertToNull&amp;serverTimezone=GMT"/>

            <!--配置jpa实现方(hibernate)的配置信息
                显示sql           ：   false|true
                自动创建数据库表    ：  hibernate.hbm2ddl.auto
                        create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
                        update      ：程序运行时创建表（如果有表，不会创建表）
                        none        ：不会创建表
            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>

</persistence>

3.编写客户的实体类配置实体类和表,类中属性和表中字段的映射关系
没有 get / set 方法不影响表的创建

@Data
@NoArgsConstructor
@AllArgsConstructor

@Table(name = "cst_customer")
@Entity
public class Customer {
    /**
     * @Id：声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY ：自增，mysql
     *                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *          GenerationType.SEQUENCE : 序列，oracle
     *                  * 底层数据库必须支持序列
     *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
     *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
     * @Column:配置属性和字段的映射关系
     *      name：数据库表中字段的名称
     */

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址
}

4.保存客户到数据库中 , 测试

public class JpaTest {
    /**
     * 1.加载配置文件创建工厂（实体管理器工厂）对象2.通过实体管理器工厂获取实体管理器
     * 3.获取事务对象,开启事务
     * 4.完成增册改查操催
     * 5.提交事务（回滚事务)6.释放资源
     */
    @Test
    public void testSave(){
        // 1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        // 保存
        //Hibernate: insert into cst_customer (cust_address, cust_industry, cust_level, cust_name, cust_phone, cust_source) values (?, ?, ?, ?, ?, ?)
        em.persist(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
        factory.close();
    }
}

JPA的操作步骤

1. 加载配置文件创建实体管理工厂

Persistence对象:
作用: 用来根据持久化单元名称 , 创建实体管理器工厂 ,
里面有一个静态方法 : createEntityManagerFactory(持久化单元名称),

2. 根据实体管理工厂，创建实体管理器

EntityManagerFactory 接口 : 主要用来创建 EntityManager 实例,
方法: createEntityManager
内部维护了很多内容:

维护了数据库信息
维护了缓存信息
维护了所有的实体管理器对象
在创建 EntityManagerFactory 的过程中会根据配置创建数据库表

EntityManagerFactory 的创建过程比较浪费资源

特点: 是一个线程安全的对象
多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题

思考:如何解决EntityManagerFactory 创建过程浪费资源比较耗时的问题
解决方法 : 使用静态代码块的方式来创建 EntityManagerFactory 对象

创建事务对象，开启事务

EntityManager对象 : 实体管理器
EntityManager是完成持久化操作的核心对象
实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

getTransaction : 获取事务对象
persist ：保存操作
merge ：更新操作
remove ：删除操作
find/getReference ：根据id查询

通过 getTransaction 方法获取 EntityTransaction 对象

begin : 开启事务
commit : 提交事务
rollback : 事务回滚

增删改查操作
提交事务
释放资源

解决实体管理器工厂的浪费资源和耗时问题 ,静态代码块封装工具类

public final class JpaUtils {
    /**
     * 第一次访问 getEntityManager 方法 ,通过静态代码块创建一个 factory 对象,
     *     载调用方法创建一个 entityManager 对象
     * 第二次访问 getEntityManager 方法 ,直接通过已经创建好的 factory 对象,
     *     再创建 一个 entityManager 对象
     */
    // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
    //一个静态的成员变量 , 可以提取出来作为公有的属性
    private static EntityManagerFactory factory;

    // 使用静态代码块为公有属性赋值
    static {
        // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
        factory = Persistence.createEntityManagerFactory("myPersistUnit");
    }

    /**
     * 使用管理器工厂生产一个管理器对象
     * 获取EntityManager 对象
     * @return
     */
    public static EntityManager getEntityManager() {
//        EntityManager entityManager = factory.createEntityManager();
        return factory.createEntityManager();
    }
}

工具类的使用验证

    @Test
    public void testSave(){
        // 1.加载配置文件创建工厂（实体管理器工厂）对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        // 2.通过实体管理器工厂获取实体管理器
//        EntityManager em = factory.createEntityManager();
        
        //使用工具类创建 EntityManager 对象
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();// 开启事务
        // 4.完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        // 保存
        em.persist(customer);
        // 5.提交事务
        tx.commit();
        // 6.释放资源
        em.close();
        
        //因为 EntityManagerFactory 是公共的 , 所以不用关闭
        //factory.close();
    }

entityManager方法中简单的增删改查

persist 添加
find 立即查询 / getTransaction 延迟查询
remove 删除
merge 修改

persist 添加 : 创建实体对象 ,赋值 , 然后执行persist方法, 执行insert语句

    @Test
    public void testPersist(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        /**
         * 创建实体对象 ,赋值 , 然后执行persist方法, 执行insert语句
         */
        Customer customer = new Customer();
        customer.setCustName("黑马教育");
        customer.setCustIndustry("学院");
        em.persist(customer);
        
        tx.commit();
        em.close();
    }

find 立即查询 ：根据id 查询客户立即加载

    @Test
    public void testfind(){
         /**
         * find方法 : 立即查询
         * 获取的是当前对象本身
         * 在调用find方法的时候就会发送sql语句查询数据库
         */
        //获取entityManager, 和开启事务都是固定的
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();

        Customer customer = entityManager.find(Customer.class, 1L);
        System.out.println(customer);

        //提交事务, 关闭entityManager也是固定的
        transaction.commit();
        entityManager.close();
    }

getTransaction 延迟查询: 根据id 查询客户延迟加载
推荐使用延迟加载防止出现了定义但是没有使用浪费资源的情况

    @Test
    public void testGetReference(){
        /**
         * getReference 方法 : 延迟加载
         * 获取的是一个动态代理对象
         * 调用 getReference 方法不会立即发送sql语句查询数据库
         *   当要使用查询结果对象的时候才会发送sql查询语句
         */
        EntityManager entityManager = JpaUtils.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();

        Customer reference = entityManager.getReference(Customer.class, 1L);

        transaction.commit();
        entityManager.close();
    }

remove 删除 : 删除对象 , 先把对象查询出来 ,然后再删除对象
必须数据库中查询出来的的持久化对象

    @Test
    // 删除
    public void testRemove(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        /**
         * remove方法删除的是一个对象
         * 所以使用的时候要先根据id 将对象查询出来然后再进行删除
         */
        Customer customer = em.getReference(Customer.class, 1L); //先查出来对象
        em.remove(customer); //在删除对象

        tx.commit();
        em.close();
    }

merge 修改 : 先查询 , 然后修改对象属性, 最后执行merge方法

    @Test
    public void testUpdate(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        /**
         * merge方法 参数也是对象 
         * 要进行修改操作, 先查询出对象, 然后修改对象属性, 最后用merge方法执行update语句
         */
        Customer customer = em.getReference(Customer.class, 3L);
        customer.setCustIndustry("餐饮");
        em.merge(customer);

        tx.commit();
        em.close();
    }

JPA中的复杂查询（JPQL）

JPQL 与原生SQL语句类似 , 但是完全面向对象,通过类名和属性进行访问, 而不是表名和表的列名

sql : 查询表和表中的字段
jpql : 查询实体类和类中的属性
jpql 与 sql 语法相似

使用JPQL需要先用EntityManager 对象的createQuery方法获取Query 对象
然后用Query的对象去调用具体的执行方法

        //定于 jpql 语句
        String jpql = "from Customer";
        //获取query 对象
        Query query = em.createQuery(jpql);
        //调用 query 的具体方法
        List resultList = query.getResultList();

query对象方法

getResultList() 获取结果集
getSingleResult() 获取单一结果
setFirstResult(1); 设置分页起始索引 ,索引从0开始
setMaxResults(3); 设置分页查询的条数
setParameter(1,“黑马%”) 设置占位符的参数

1. 查询全部

    @Test
    public void testPersist(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        /**
         * 创建jpql 语句
         * 创建Query 对象, query才是执行jpql的
         * 调用query对象的 getResultList方法
         */
        
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        List resultList = query.getResultList();
        
        for (Object o : resultList) {
            System.out.println(o);
        }
        
        tx.commit();
        em.close();
    }

2. 排序,倒序

    @Test
    public void testOrderBy(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        String jpql = "from Customer order by custId desc";
        Query query = em.createQuery(jpql);
        List resultList = query.getResultList();

        for (Object o : resultList) {
            System.out.println(o);
        }

        tx.commit();
        em.close();
    }

3. 统计查询

JPQL中不能写select * 但是可以写 select 相关的函数

    @Test
    public void testCount(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        String jpql = "select count(custId) from Customer ";
        Query query = em.createQuery(jpql);
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);

        tx.commit();
        em.close();
    }

4. 分页查询

    @Test
    public void testPrage(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        /**
         * select * from cst_customer limit (0,2)
         * 先设置查询所有 , 然后 设置起始索引 和 查询条数
         */
        String jpql = "from Customer";  //查询所有
        Query query = em.createQuery(jpql);
        query.setFirstResult(1);    //设置起始索引 ,索引从0开始
        query.setMaxResults(3);     //设置查询的条数

        List resultList = query.getResultList();

        for (Object o : resultList) {
            System.out.println(o);
        }

        tx.commit();
        em.close();
    }

5. 条件查询

    @Test
    public void testWhere(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        String jpql = "from Customer where custName like ?";  //查询所有
        Query query = em.createQuery(jpql);
        query.setParameter(1,"黑马%");    //设置占位符参数


        List resultList = query.getResultList();

        for (Object o : resultList) {
            System.out.println(o);
        }

        tx.commit();
        em.close();
    }

Spring Data JPA

Spring Data JPA是Spring 基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展!学习并使用Spring Data JPA可以极大提高开发效率!

Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM(如: hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。

SpringData Jpa极大简化了数据库访问层代码。如何简化的呢?使用了 springDataJpa.我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法。

JPA是一套规范，内部是有接口和抽象类组成的。hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程）。

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

一、入门案例

案例:客户的基本cRUDi.
搭建环境

创建工程导入坐标
配置spring的配置文件

编写实体类(customer) ，使用jpa注解配置映射关系ii.编写一个符合springDataJpa的dao层接口

新建Maven项目

环境搭建

导入依赖 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <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>
</project>

SPringData 与 JPA 配置

在resources文件下 ,新建 applicationContext.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: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 和 spring data jpa 的配置-->

    <!--1.创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--        实体类所在包的路径-->
        <property name="packagesToScan" value="cn.itcast.domain"/>
        <!--jpa的供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--配置是否自动创建数据库表 -->
                <property name="generateDdl" value="true" />
                <!--指定数据库类型 -->
                <property name="database" value="MYSQL" />
                <!--数据库方言：支持的特有语法 -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <!--是否显示sql -->
                <property name="showSql" value="true" />
            </bean>
        </property>
    </bean>

    <!--2. 创建数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"/>
        <property name="password" value="root"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.20.40/jpa?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

    <!--3.整合spring dataJpa-->
    <!--    dao接口所在的路径-->
    <jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory" />

    <!--4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!-- 4.txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5.aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>
    <!--5.声明式事务 -->
    <!-- 6. 配置包扫描，使用注解开发 -->
    <context:component-scan base-package="cn.itcast" />
</beans>

遇到问题: applicationcontext配置文件数据库连接池爆红
在这里插入图片描述
解决方案:
maven导入依赖失败问题——最系统、最彻底的解决方案
暴力解决: 删除项目 ,从新建立项目

编写代码

编写实体类 添加get/ set方法重写tostring方法

@Table(name = "cst_customer")
@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址
}

编写Dao接口 Dao接口继承的接口中已经封装了许多数据库操作不用自己再写

/**
 * 符合SpringDataJpa的dao层接口规范
 *      JpaRepository < 操作的实体类类型，实体类中主键属性的类型>
 *          * 封装了基本CRUD操作
 *      JpaSpecificationExecutor< 操作的实体类类型 >
 *          * 封装了复杂查询（分页）
 */
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {

}

编写测试类
测试类上需要使用@ContextConfiguration注解,指定spring容器的配置信息

package cn.itcast.test;

import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息

public class CustomerDaoTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据id查询
     */
    @Test
    public void testFindOne() {
        Customer customer = customerDao.findOne(4l);
        System.out.println(customer);
    }

    /**
     * save : 保存或者更新
     *      根据传递的对象是否存在主键id，
     *      如果没有id主键属性：保存
     *      存在id主键属性，根据id查询数据，更新数据
     */
    @Test
    public void testSave() {
        Customer customer  = new Customer();
        customer.setCustName("黑马程序员");
        customer.setCustLevel("vip");
        customer.setCustIndustry("it教育");
        customerDao.save(customer);
    }

    @Test
    public void testUpdate() {
        Customer customer  = new Customer();
        customer.setCustId(4l);
        customer.setCustName("黑马程序员很厉害");
        customerDao.save(customer);
    }

    @Test
    public void testDelete () {
        customerDao.delete(3l);
    }

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

    /**
     * 测试统计查询：查询客户的总数量
     *      count:统计总条数
     */
    @Test
    public void testCount() {
        long count = customerDao.count();//查询全部的客户数量
        System.out.println(count);
    }

    /**
     * 测试：判断id为4的客户是否存在
     * 传统写法：
     *      1. 可以查询以下id为4的客户
     *          如果值为空，代表不存在，如果不为空，代表存在
     *      2. 判断数据库中id为4的客户的数量
     *          如果数量为0，代表不存在，如果大于0，代表存在
     */
    @Test
    public void  testExists() {
        boolean exists = customerDao.exists(4l);
        System.out.println("id为4的客户 是否存在："+exists);
    }


    /**
     * 根据id从数据库查询
     *      @Transactional : 保证getOne正常运行
     *
     *  findOne：
     *      em.find()           :立即加载
     *  getOne：
     *      em.getReference     :延迟加载
     *      * 返回的是一个客户的动态代理对象
     *      * 什么时候用，什么时候查询
     */
    @Test
    @Transactional
    public void  testGetOne() {
        Customer customer = customerDao.getOne(4l);
        System.out.println(customer);
    }
}

总结:
实体类 : 使用JPA注解配置映射关系
Dao接口 : 继承 extends JpaRepository<Customer,Long>与JpaSpecificationExecutor< Customer >
测试类:

findone id):根据id查询
save(customer):保存或者更新（依据:传递的实体类对象中，是否包含id属性)
delete (id):根据id删除
findAll():查询全部

二、SpringData运行过程及原理剖析

我们知道一个接口真正起作用的是接口的实现类，但是在入门案例的Dao接口中没有写接口的相关实现 ,
说明在程序的执行过程中， 自动帮我们生成了接口的实现类的对象——动态代理
在这里插入图片描述

客户接口开始
SpringData JPA创建动态代理对象 simpleJpaRepository
通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象（SimpleJpaRepository）
SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CURD）
通过hibernate完成数据库操作（封装了jdbc）

问题：系统怎么知道要为Dao生成动态代理对象?

在application Context.xml文件中有配置:
在这里插入图片描述

源码分析

通过debug进行调试
在这里插入图片描述
{$Proxy32@5834} 可以知道是一个动态代理对象

右击选择Jump To Type Source 可以跳转到对应的代理工具类： JdkDynamicAopProxy

InvocationHandLer是JDK动态代理的一个参数， InvocationHandLer里面定义了如何去创建动态代理对象的一个方法

当我们执行到invoke方法的时候就会去帮我们自动创建接口的实现类

Object target = null; 是生成的动态代理对象
在这里插入图片描述
对target 进行赋值： SimpleJpaRepository
SimpleJpaRepository 就是SpringDataJPA帮助我们生成的实现了 Dao接口的动态代理对象

右击选择Jump To Type Source跳转到 SimpleJpaRepository
SimpleJpaRepository 中实现了JpaRepository 接口与 JpaSpecificationExecutor 接口
而我们定义的Dao接口继承了这两个接口，就可以认为 SimpleJpaRepository 是Dao接口的实现类
在这里插入图片描述
SimpleJpaRepository 中实现了我们使用的 CRUD方法

当我们在测试类中使用 findOn() 方法的时候，就会调用 SimpleJpaRepository 中实现的SimpleJpaRepository 方法
注意 em.find ()

em 就是 EntityManager
EntityManager 是JPA 中的实体管理器在这里插入图片描述
在EntityManager 中有find方法来进行根据ID查询

三、复杂查询

Ⅰ、接口查询

继承JpaRepository的方法列表
在这里插入图片描述
使用JpaRepository 接口中的方法

//根据id查询
Customer customer = customerDao.findOne(4l);
    /**
     * 根据id从数据库查询
     * getone需要加上@Transactional注解 , 不加会报错 , 因为getone涉及到事务
     *      @Transactional : 保证getOne正常运行
     *
     *  findOne：
     *      em.find()           :立即加载
     *  getOne：
     *      em.getReference     :延迟加载
     *      * 返回的是一个客户的动态代理对象
     *      * 什么时候用，什么时候查询
     */
//根据id查询
 @Transactional
 @Test
Customer customer = customerDao.getOne(4l);

//customer没有id 就保存 , customer有 id 就更新
customerDao.save(customer);
//根据id删除
customerDao.delete(3l);
//查询所有数据
List<Customer> list = customerDao.findAll();
//统计数据
long count = customerDao.count();
//判断是否存在
boolean exists = customerDao.exists(4l);

继承JpaSpecificationExecutor方法列表

Ⅱ、 jpql查询方式

jpql：jpa query language (jpa查询语言)

特点:

语法或关键字和sql语句类似
*查询的是类和类中的属性

需要将JPQL语句配置到接口方法上
在Dao接口方法上添加@Query注解 : @Query(value=“要使用的JPQL语句”)

查询语句

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {    
    //@Query 使用jpql的方式查询。
    @Query(value="from Customer")
    public List<Customer> findAllCustomer();
    
    //@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
    //多个参数占位符 要和 参数位置对应
    @Query(value="from Customer where custName = ?1 and custId = ?2")
    public Customer findCustomer(String custName ,Long custId);
}

更新

此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询。

    @Query(value="update Customer set custName = ?1 where custId = ?2")
    @Modifying
    public void updateCustomer(String custName,Long custId);

.测试方法需要增加事务支持：

更新操作涉及到事务 ,所以在测试的时候需要为更新操作添加@Transactional注解

    @Test
    public void  testfindCustomer() {
        Customer customer = customerDao.findCustomer("传智播客",2L);
        System.out.println(customer);
    }



    /*
    * springDataJpa中使用jpql完成 更新/删除操作
    *   需要手动添加事务的支持
    *   默认会执行结束之后，回滚事务 ,不会提交事务
    * */
    @Test
    @Transactional  //添加事务支持
    @Rollback(false) //不进行事务回滚
    public void testUpdate1(){
        customerDao.updateCustomer("尚硅谷",5L);
    }

Ⅲ、sql查询方式

在Dao接口方法上添加@Query注解 : @Query(value=“要使用的SQL语句”,nativeQuery = true)

注意模糊查询，要在查询条件参数中添加 %

    /**
     * 使用sql的形式查询：
     *     查询全部的客户
     *  sql ： select * from cst_customer;
     *  Query : 配置sql查询
     *      value ： sql语句
     *      nativeQuery ： 查询方式
     *          true ： sql查询
     *          false：jpql查询
     *
     */
    //@Query(value = " select * from cst_customer" ,nativeQuery = true)
    @Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
    public List<Object [] > findSql(String name);

测试

    @Test
    public void testfindSql(){
        List<Object[]> sql = customerDao.findSql("黑马%");
        for (Object[] objects : sql) {
            System.out.println(Arrays.toString(objects));
        }
    }

Ⅳ、方法命名规则查询

是对jpql查询，更加深入的一层封装
我们只需要按照SpringDataJpa提供的方法名称规则来定义方法，不需要再去配置jpql语句，就能完成查询

只用写方法 , 不用写JPQL语句或SQL语句

举例

    /**
     * 方法名的约定：
     *      findBy : 查询
     *            对象中的属性名（首字母大写） ： 查询的条件
     *            CustName
     *            * 默认情况 ： 使用 等于的方式查询
     *                  特殊的查询方式
     *
     *  findByCustName   --   根据客户名称查询
     *
     *  再springdataJpa的运行阶段
     *          会根据方法名称进行解析  findBy    from  xxx(实体类)
     *                                      属性名称      where  custName =
     *
     *      1.findBy  + 属性名称 （根据属性名称进行完成匹配的查询=）
     *      2.findBy  + 属性名称 + “查询方式（Like | isnull）”
     *          findByCustNameLike
     *      3.多条件查询
     *          findBy + 属性名 + “查询方式”   + “多条件的连接符（and|or）”  + 属性名 + “查询方式”
     */
    public Customer findByCustName(String custName);

	//根据名字模糊匹配
    public List<Customer> findByCustNameLike(String custName);

	//多条件查询 ,//使用客户名称模糊匹配和客户所属行业精准匹配的查询
    public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);

测试

  //测试方法命名规则的查询
  @Test
  public void testNaming(){
    Customer customer = customerDao.findByCustName("博学谷");
    System.out.println(customer);
  }

  //根据名字模糊查询
    @Test
    public void testLike(){
        List<Customer> byCustNameLike = customerDao.findByCustNameLike("黑马%");
        for (Customer customer : byCustNameLike) {
            System.out.println(customer);
        }
    }

	//使用客户名称模糊匹配和客户所属行业精准匹配的查询
    @Test
    public void testFindByCustNameLikeAndCustIndustry(){
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("黑马%", "学院");
        System.out.println(customer);
    }

四、总结:

i.springDatajpa，jpa规范，hibernate三者之间的关系

code – > springDatajpa --> jpa规范的API --> hibernate

ii.符合springDataJpa规范的dao层接口的编写规则

需要实现两个接口（JpaRepository，JapSpecificationExecutor）
提供响应的泛型

iii.运行过程

动态代理的方式：动态代理对象

iiii.查询

Specifications动态查询

前面不管是JPQL 还是 SQL 还是方法命名规则查询，他们的查询条件都是固定的
但是在企业开发中很多查询条件都不是固定的，那么一个需求就需要写一个crud方法，比较麻烦

有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。

借助Specification参数实现，动态拼接 Specification参数条件，实现不同条件的动态查询
在这里插入图片描述

一、Specifications动态查询

JpaSpecificationExecutor 方法列表

		T findOne(Specification<T> spec);  //查询单个对象
		List<T> findAll(Specification<T> spec);  //查询列表
		
		//查询全部，分页
		//pageable：分页参数
		//返回值：分页pageBean（page：是springdatajpa提供的）
		Page<T> findAll(Specification<T> spec, Pageable pageable);

		//查询列表
		//Sort：排序参数
		List<T> findAll(Specification<T> spec, Sort sort);

		long count(Specification<T> spec);//统计查询

对于JpaSpecificationExecutor，这个接口基本是围绕着Specification接口来定义的。我们可以简单的理解为，Specification构造的就是查询条件。

Specification接口中只定义了如下一个方法：


	* Specification ：是查询条件
		自定义我们自己的Specification实现类
			实现 Specification 的  toPredicate 方法
		//root：查询的根对象（查询的任何属性都可以从根对象中获取）
		//CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
		//CriteriaBuilder：查询的构造器，封装了很多的查询条件
	Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件

单个条件查询

动态查询单个对象， Dao接口中不用写东西

    @Test
    public void testSpec() {
        //匿名内部类
        /**
         * 自定义查询条件
         *      1.实现Specification接口（提供泛型：查询的对象类型）
         *      2.实现toPredicate方法（构造查询条件）
         *      3.需要借助方法参数中的两个参数（
         *          root：获取需要查询的对象属性
         *          CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
         *       ）
         *  案例：根据客户名称查询，查询客户名为传智播客的客户
         *          查询条件
         *              1.查询方式
         *                  cb对象
         *              2.比较的属性名称
         *                  root对象
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //1.获取比较的属性
                Path<Object> custName = root.get("custName");
                //2.构造查询条件  ：    select * from cst_customer where cust_name = '传智播客'
                /**
                 * 第一个参数：需要比较的属性（path对象）
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate predicate = cb.equal(custName, "传智播客");//进行精准的匹配  （比较的属性，比较的属性的取值）
                return predicate;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }

多条件查询

    /**
     * 多条件查询
     *      案例：根据客户名（传智播客）和客户所属行业查询（it教育）
     *
     */
    @Test
    public void testSpec1() {
        /**
         *  root:获取属性
         *      客户名
         *      所属行业
         *  cb：构造查询
         *      1.构造客户名的精准匹配查询
         *      2.构造所属行业的精准匹配查询
         *      3.将以上两个查询联系起来
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> custName = root.get("custName");//客户名
                Path<Object> custIndustry = root.get("custIndustry");//所属行业

                //构造查询
                //1.构造客户名的精准匹配查询
                Predicate p1 = cb.equal(custName, "传智播客");//第一个参数，path（属性），第二个参数，属性的取值
                //2..构造所属行业的精准匹配查询
                Predicate p2 = cb.equal(custIndustry, "it教育");
                //3.将多个查询条件组合到一起：组合（满足条件一并且满足条件二：与关系，满足条件一或满足条件二即可：或关系）
                Predicate and = cb.and(p1, p2);//以与的形式拼接多个查询条件
                // cb.or();//以或的形式拼接多个查询条件
                return and;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }

模糊查询和排序查询

    /**
     * 案例：完成根据客户名称的模糊匹配，返回客户列表
     *      客户名称以 ’传智播客‘ 开头
     *
     * equal ：直接的到path对象（属性），然后进行比较即可
     *      Predicate p2 = cb.equal(custIndustry, "教育");
     *
     * gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
     *      指定参数类型：path.as(类型的字节码对象)
     *      Predicate like = cb.like(custName.as(String.class), "传智%");
     */
    @Test
    public void testSpec3() {
        //构造查询条件
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊匹配
                Predicate like = cb.like(custName.as(String.class), "传智%");
                return like;
            }
        };
//        List<Customer> list = customerDao.findAll(spec);
//        for (Customer customer : list) {
//            System.out.println(customer);
//        }
        //添加排序
        //创建排序对象,需要调用构造方法实例化sort对象
        //第一个参数：排序的顺序（倒序，正序）
        //   Sort.Direction.DESC:倒序
        //   Sort.Direction.ASC ： 升序
        //第二个参数：排序的属性名称
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(spec, sort);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

分页查询

 /**
     * 分页查询
     *      Specification: 查询条件
     *      Pageable：分页参数
     *          分页参数：查询的页码，每页查询的条数
     *          findAll(Specification,Pageable)：带有条件的分页
     *          findAll(Pageable)：没有条件的分页
     *  返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，共条数）
     */
    @Test
    public void testSpec4() {

        Specification spec = null;
        //PageRequest对象是Pageable接口的实现类
        /**
         * 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
         *      第一个参数：当前查询的页数（从0开始）
         *      第二个参数：每页查询的数量
         */
        Pageable pageable = new PageRequest(0,2);
        //分页查询
        Page<Customer> page = customerDao.findAll(null, pageable);
        System.out.println(page.getContent()); //得到数据集合列表
        System.out.println(page.getTotalElements());//得到总条数
        System.out.println(page.getTotalPages());//得到总页数
    }

方法对应的关系

在这里插入图片描述

二、多表之间的关系和操作多表的操作步骤

表关系
	一对一
	一对多：
		一的一方：主表
		多的一方：从表
		外键：需要再从表上新建一列作为外键，他的取值来源于主表的主键
	多对多：
		中间表：中间表中最少应该由两个字段组成，这两个字段做为外键指向两张表的主键，又组成了联合主键

讲师对学员：一对多关系

实体类中的关系
	包含关系：可以通过实体类中的包含关系描述表关系
	继承关系

分析步骤
	1.明确表关系
	2.确定表关系（描述 一对多： 外键  | 多对多： 中间表）
	3.编写实体类，再实体类中描述表关系（包含关系）
	4.配置映射关系

三、完成多表操作

i.一对多操作
	案例：客户和联系人的案例（一对多关系）
		客户：一家公司
		联系人：这家公司的员工  , 一家公司有多个员工
	
			一个客户可以具有多个联系人
			一个联系人从属于一家公司
		
	分析步骤
		1.明确表关系
			一对多关系
		2.确定表关系（描述 外键|中间表）
			主表：客户表
			从表：联系人表
				* 在从表（联系人）上添加外键
		3.编写实体类，在实体类中描述表关系（包含关系）
				客户：在客户的实体类中包含一个联系人的集合
				联系人：在联系人的实体类中包含一个客户的对象
		4.配置映射关系
			  	* 使用jpa注解配置一对多映射关系

	级联：
		操作一个对象的同时操作他的关联对象
		
		级联操作：
			1.需要区分操作主体
			2.需要在操作主体的实体类上，添加级联属性（需要添加到多表映射关系的注解上）
			3.cascade（配置级联）
		
		级联添加，
			案例：当我保存一个客户的同时保存联系人
		级联删除
			案例：当我删除一个客户的同时删除此客户的所有联系人
			
ii.多对多操作
	案例：用户和角色（多对多关系）
		用户：
		角色：

	分析步骤
		1.明确表关系
			多对多关系
		2.确定表关系（描述 外键|中间表）
			中间间表
		3.编写实体类，再实体类中描述表关系（包含关系）
			用户：包含角色的集合
			角色：包含用户的集合
		4.配置映射关系
		
iii.多表的查询
	1.对象导航查询
		查询一个对象的同时，通过此对象查询他的关联对象
		
		案例：客户和联系人
		
		从一方查询多方
			* 默认：使用延迟加载（****）
			
		从多方查询一方
			* 默认：使用立即加载

转自： https://blog.youkuaiyun.com/DDDDeng_/article/details/108197565