Spring Data Jpa 学习

参考 哔哩哔哩 - Spring Data Jpa(2019_idea版)

引入

传统的jdbc

ORM思想

操作实体类就相当于操作数据库表，通过orm思想就可以不用重点关注sql语句

ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射

简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的

实现orm思想要建立两个映射关系：​

• 实体类和表的映射关系
• 实体类中属性和字段的映射关系

为什么使用ORM

当实现一个应用程序时（不使用O/R Mapping），我们可能会写特别多数据访问层的代码，从数据库保存数据、修改数据、删除数据，而这些代码都是重复的。而使用**ORM则会大大减少重复性代码。

实现orm思想的框架：mybatis，hibernate，TopLink

hibernate与JPA的概述

hibernate概述

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

主流持久层框架：mybatis和hibernate

MyBatis:
1、jar只有1个。简单、轻量级（体积小）–》功能比较单一
2、通过直接编写sQL语句sQL转对象
3、由于直接编写sQL语句，所以灵活多变，代码维护性好。mybatis如果发生数据库变更，需要编写多套sql语句，移值性不好。
4、可以通过手动编写时进行sQL语句的优化。
5、需要编写结果映射

Hibernate:
1、JAR包有10个。难度、重量级（体积大）–》功能就强大。
2、典型ORM映射框架。对象生成sQL语句。基于对象模型数据ORM映射管理。程序员无需编写sQL语句
3、移值性好。兼容不同的数据库。具有良好的数据库无关性、即数据库发生变化。代码无需再次修改、或编写。SQL语句是Hibernate通过对象生成的。根据数据的方言生成sQL语句。oracle-》sql mysql-》sql
4、学习门槛高（需要有很深的对象关系映射的基础、而且在设置ORM映射的时候，需要考虑好性能和对象模型的创建。(生成的SQL语句可能达不到我们优化的sQL目标)

应用场景:
MyBatis:
	需求多变的互联网项目。(功能需求的不断变更、sQL语句优化的方式来解决)
Hibernate:
	需求明确、业务固定的项目。例如:OA项目、ERP/CRM/HIS系统

总结:

• 如果需求明确、此时为了节省大量的重复代码，就需要学习hiberante->JPA SpringData提高开发效率。在之前企业中，
  主要用的持久层的技术：JPA+SpringData。
  JPA+SpringData主要特点：让数据的访问变得更简单、更容易。
• 有些企业的架构:两者的优点都需要。
  Spring+MyBatis+(Jpa+SpringData )+SpringBoot完成常规操作。
  复杂业务流程且自由灵活的功能选择MyBatis

JPA概述

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

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

JPA的优势

• 标准化-------------Jpa是JCP组织发布的java EE 标准之一，因此任何生成符合JPA标准的框架都遵循同样的框架，提供相同的API，保证基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行
• 容错级特性的支持-------------JPA框架中支持大数据集、事务、并发等容器级别的事务，这使得JPA超越了简单持久化框架的局限，在企业应用中发挥更大的作用
• 简单方便-------------JPA的主要目标之一就是提供更加简单的编程模型，在JPA框架下创建实体和创建Java类一样简单，没有任何的约束和限制，只需要使用javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握，JPA基于非侵入式原则设计，因此可以很容易和其他框架或者容器集成
• 查询能力-------------JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是 Hibernate HQL 的等价物，JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有SQL才能提供的高级查询特性，甚至还能够支持子查询
• 高级特性-------------支持面向对象的高级特性，类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系型数据库的持久化

JPA与hibernate的关系

JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现

当需要修改底层的实现框架，比如从hibernate到toplink，只需要更改一下配置，而不用把代码都更改

干活的是底层的框架，Jpa是一个规范，干活的不是Jpa

JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作

JPA常用注解

• @Entity
  @Entity 标注用于实体类声明语句之前，指出该Java类为实体类，将映射到指定的数据库表。如声明一个实体类Users，它将映射到数据库中的users表上。
• @Table
  当实体类与其映射的数据库表名不同名时需要使用@Table标注说明，该标注与@Entity标注并列使用。置于实体类声明语句之前，可写于单独语句行，也可与声明语句同行。
  @Table标注的常用选项是name，用于指明数据库的表名。
  @Table标注还有一个两个选项catalog 和 schema用于设置表所属的数据库目录或模式，通常为数据库名。uniqueConstraints选项用于设置约束条件，通常不须设置。
• @ld
  @Id标注用于声明一个实体类的属性映射为数据库的主键列。该属性通常置于属性声明语句之前，可与声明语句同行，也可写在单独行上。也可以放在属性的get方法上，但是为了代码规范，放在属性声明上方。
• @GeneratedValue.
  @GeneratedValue 用于标注主键的生成策略，通过strategy 属性指定。默认情况下，JPA自动选择一个最适合底层数据库的主键生成策略
  在 javax.persistence.GenerationType中定义了以下几种可供选择的策略:
  -----------IDENTITY : 采用数据库ID自增长的方式来自增主键字段(MYSQL).Oracle不支持这种方式;
  -----------AUTO : JPA自动选择合适的策略，是默认选项,由程序控制
  -----------SEQUENCE : 通过序列产生主键,通过@SequenceGenerator 注解指定序列名．Mysql不支持这种方式
  -----------TABLE : 通过表产生主键,框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植
• @Basic
  @Basic表示一个简单的属性到数据库表的字段的映射，对于没有任何标注的getXxxx()方法，默认jpa为每个属性上方加一个@Basic
  fetch : 表示该属性的读取策略,有 EAGER和 LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER
  optional : 表示该属性是否允许为null，默认为 true
• @Column
  当实体的属性与其映射的数据库表的列不同名时，需要使用@Column标注说明，该属性通常置于实体的属性声明语句之前，还可与@Id标注一起使用。
  @Column标注的常用属性是name，用于设置映射数据库表的列名。不设置name，默认会将属性名映射为表字段名。此外，该标注还包含其它多个属性，如: unique . nullable、 length等。
  @Column标注的 columnDefinition属性：表示该字段在数据库中的实际类型。通常ORM 框架可以根据属性类型自动判断数据库中字段的类型，但是对于Date类型仍无法确定数据库中字段类型究竟是DATETIME 还是 TIMESTAMP。此外, String 的默认映射类型为VARCHAR，如果要将String 类型映射到特定数据库的BLOB或TEXT字段类型。
• @Transient
  表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性。
  如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则，ORM框架默认其注解为@Basic

JPA入门案例

我们是实现的功能是保存一个客户到数据库的客户表中

环境搭建

1. 创建客户的数据库表

 /*创建客户表*/
    CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2. 导入依赖

	<properties>
    <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>

3. 创建客户的实体类 & 编写实体类和数据库表的映射配置 （重点）

/**
 * 客户的实体类
 *      配置映射关系
 *
 *   1.实体类和表的映射关系
 *      @Entity:声明实体类
 *      @Table : 配置实体类和表的映射关系
 *           name : 配置数据库表的名称
 *   2.实体类中属性和表中字段的映射关系
 */
@Data
@NoArgsConstructor
@AllArgsConstructor

@Entity
@Table(name = "cst_customer")
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;//客户地址
  }

配置JPA的核心配置文件

在java工程的src路径下创建一个名为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">
<!--配置1-----jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--可选配置：配置jpa实现方式的配置信息-->
        <properties>
<!--配置2------- --数据库信息
                用户名，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://localhost:3306/HeimaSpringData?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>


<!--配置3---------配置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>

测试

@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("教育");
    // 保存
    em.persist(customer);
    // 5.提交事务
    tx.commit();
    // 6.释放资源
    em.close();
    factory.close();
}

JPA主键生成策略

JPA提供的四种标准用法为TABLE，SEQUENCE，IDENTITY，AUTO。建议mysql用identity，oracle就用sequence

• IDENTITY : 主键由数据库自动生成（主要是自动增长型），底层数据库必须支持自动增长

  @Id  
  @GeneratedValue(strategy = GenerationType.IDENTITY) 
  private Long custId;
  

• SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列

  @Id  
  @GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
  @SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
  private Long custId;
  

  //	@SequenceGenerator源码中的定义
  
      @Target({TYPE, METHOD, FIELD})   
      @Retention(RUNTIME)  
      public @interface SequenceGenerator {  
         //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
         String name();  
         //属性表示生成策略用到的数据库序列名称。
         String sequenceName() default "";  
         //表示主键初识值，默认为0
         int initialValue() default 0;  
         //表示每次主键值增加的大小，例如设置1，则表示每次插入新记录后自动加1，默认为50
         int allocationSize() default 50;  
      }
  

• AUTO：主键由程序自动控制

  @Id  
  @GeneratedValue(strategy = GenerationType.AUTO)  
  private Long custId;
  

• TABLE：jpa提供的一种机制，使用一个特定的数据库表格来保存主键

JPA的API介绍

Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory

//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例，线程安全，只加载一次，加载核心配置文件

//创建实体管理类
EntityManager em = factory.createEntityManager();
factory.isOpen();  检查实体管理器工厂是否处于打开状态，创建后一直处于打开状态，除非调用close()方法关闭
factory.close();		关闭实体管理器工厂，关闭后将释放所有资源 

由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题），并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可

EntityManager

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

不安全线程，每次都要创建一个会话，用完需要及时关闭

我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作

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

EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单

et.begin()：开启事务
et.commit()：提交事务
et.rollback()：回滚事务

JPA操作步骤

封	|	1.加载配置文件创建实体管理器工厂
装	|		Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
到	|			createEntityMnagerFactory（持久化单元名称）
工	|		作用：创建实体管理器工厂
具	|		
类	|	2.根据实体管理器工厂，创建实体管理器
直	|		EntityManagerFactory ：获取EntityManager对象
接	|		方法：createEntityManager
获	|		* 内部维护的很多的内容
取	|			内部维护了数据库信息，
实	|			维护了缓存信息
体	|			维护了所有的实体管理器对象
管	|			再创建EntityManagerFactory的过程中会根据配置创建数据库表
理	|		* EntityManagerFactory的创建过程比较浪费资源
器	|		特点：线程安全的对象
	|			多个线程访问同一个EntityManagerFactory不会有线程安全问题
	|		* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
	|			思路：创建一个公共的EntityManagerFactory的对象
	|		* 静态代码块的形式创建EntityManagerFactory
			
3.创建事务对象，开启事务  em.getTransaction();  tx.begin();
	EntityManager对象：实体类管理器
		beginTransaction : 创建事务对象
		presist ： 保存
		merge  ： 更新
		remove ： 删除
		find/getRefrence ： 根据id查询
		
	Transaction 对象 ： 事务
		begin：开启事务
		commit：提交事务
		rollback：回滚
4.增删改查操作
5.提交事务 tx.commit();
6.释放资源 em.close();

抽取JPAUtil工具类

解决实体管理器工厂的浪费资源和耗时问题，通过静态代码块的形式，当程序员第一次访问该工具类时，创建一个公共的实体管理器工厂对象

  public final class JPAUtil {
	// 第一次访问getEntityManager方法，经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
	// 第二次访问getEntityManager方法，直接通过一个已经创建好的factory对象，创建EntityManger对象
    // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
    private static EntityManagerFactory em;
    // 使用静态代码块赋值
    static {
      // 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
      em = Persistence.createEntityManagerFactory("myPersistUnit");
    }

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

使用JPA完成CURD

保存

  @Test
  @Transaction
  @Rollback(false)
  public void testSave2(){
  	//1.通过工具类获取entityManager
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
  	//2.开启事务   
    tx.begin();
    //3.业务代码
    Customer customer = new Customer();
    customer.setCustName("博学谷");
    em.persist(customer);
	//4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
    // factory.close();  不用关闭工厂了，关闭之后其他线程访问的时候就刚访问不到公用的工厂了
  }

修改

  @Test
  @Transaction
  @Rollback(false)
  // 更新
  public void testUpdate(){
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //更新删除数据都要先查询到数据
	// EntityManager.getReference(xxx.class,primarykey)
    Customer customer = em.getReference(Customer.class, 3L);
    customer.setCustIndustry("餐饮");
    //更新方法
    // merge方法，先会根据id去查询，id存在是修改，不存在是新增
    em.merge(customer);

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

merge方法流程图

删除

  @Test
  @Transaction
  @Rollback(false)
  // 删除
  public void testRemove(){
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();
	//删除用户先根据id查询对象
    Customer customer = em.getReference(Customer.class, 2L);

    em.remove(customer);

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

根据id查询

优先使用延迟加载

• 立即加载 find，查询的对象就是当前客户对象本身，调用find方法时，就会发送sql语句查询数据

• 延迟加载 getReference（懒加载），getReference得到的是一个动态代理对象，当调用查询结果对象的时候，才会发送查询的语句，什么时候用，什么时候发送sql语句查询数据库

  常考面试
  

  @Test
  // 立即加载
  public void testFind(){
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

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

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

  @Test
  // 延迟加载
  public void testReference(){
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    Customer customer = em.getReference(Customer.class, 1L);
    System.out.println(customer);

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

JPA中的复杂查询（JPQL）

JPQL全称Java Persistence Query Language

​ 基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL

查询步骤

• 创建query查询对象
• 对参数进行赋值
• 查询，并得到返回结果

JPQL编码规范：

• SQL常用的关键字全部大写
• 不支持 *
• 占位符参数，从1开始；在SQL中占位符参数从0开始

查询全部

  /**
       * 查询全部
       *      jqpl：from cn.itcast.domain.Customer
       *      sql：update cst_customer set xx=xx where xx=xx
       */
  @Test
  public void testFindAll() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.查询全部
    String jpql = "from Customer ";
    Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象
	
	/**
	* 如果知道返回类型可以
	* 	Query query = em.createQuery(jpql,User.class);
	* 	List<User> list = query.getResultList();
	* 	for (User user : list) {
    * 	 System.out.print(user);
    *	}
	*/
	
	//发送查询，并封装结果集
    List list = query.getResultList();

    for (Object obj : list) {
      System.out.print(obj);
    }

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
  }

查询部分属性

如果只查询实体的部分属性而不需要返回整个实体，执行该查询返回的不再是实体集合，而是一个对象数据的集合（ Object[] ），集合的每个成员为一个对象数组，可以通过数组元素访问各个属性（投影）

不使用投影返回Object[] 数组

使用投影

创建需要查询字段的有参构造方法

使用 select new Users(uname,upass) from Users

修改和删除

  /**
       * 查询全部
       *      jqpl：update Customer set name=? where id=?
       *      sql：update cst_customer set cst_name=? where cst_id=?
       */
  @Test
  public void testFindAll() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.更新
    //String jpql = "delete from Users where id=:id";
    String jpql = "update Customer set name=? where id=?";
    Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

    //设置参数
    query.setParameter(1,name);
    query.setParameter(2,id);
    
    //执行更新语句
    int num = query.executeUpdate();
    System.out.println(num);

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
  }

排序查询

/**
     * 排序查询： 倒序查询全部客户（根据id倒序）
     *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
     *      jpql：from Customer order by custId desc
     */
@Test
public void testOrders() {
  //1.获取entityManager对象
  EntityManager em = JpaUtils.getEntityManager();
  //2.开启事务
  EntityTransaction tx = em.getTransaction();
  tx.begin();
  //3.查询全部
  String jpql = "from Customer order by custId desc";
  Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

  //发送查询，并封装结果集
  List list = query.getResultList();

  for (Object obj : list) {
    System.out.println(obj);
  }

  //4.提交事务
  tx.commit();
  //5.释放资源
  em.close();
}

统计总数

	/**
     * 使用jpql查询，统计客户的总数
     *      sql：SELECT COUNT(cust_id) FROM cst_customer
     *      jpql：select count(custId) from Customer
     */
     @Test
public void testCount() {
  //1.获取entityManager对象
  EntityManager em = JpaUtils.getEntityManager();
  //2.开启事务
  EntityTransaction tx = em.getTransaction();
  tx.begin();
  //3.查询总数
  String jpql = "select count(custId) from Customer";
  Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

  //发送查询，并封装结果集
  // getResultList  :将查询结果封装为list集合
  // getSingleResult  :得到唯一的结果集
  Object result = query.getSingleResult();

  System.out.println(result);

  //4.提交事务
  tx.commit();
  //5.释放资源
  em.close();
}

分页查询

    /**
     * 分页查询
     *      sql：select * from cst_customer limit 0,2
     *      jqpl : from Customer
     */
    @Test
    public void testPaged() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 分页参数
        //起始索引
        query.setFirstResult(0);
        //每页查询的条数
        query.setMaxResults(2);

        //iii.发送查询，并封装结果
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

条件查询

    /**
     * 条件查询
     *     案例：查询客户名称以‘传智播客’开头的客户
     *          sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
     *          jpql : from Customer where custName like ?
     */
     @Test
    public void testCondition() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer where custName like ?";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 占位符参数
        //第一个参数，占位符的索引位置（从1开始）；第二个参数：取值
        query.setParameter(1,"餐饮%");    //餐饮开头
        //iii.发送查询，并封装结果
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

原生sql查询

JPA中实体类的状态

  @Test
  public void testSave2(){
    EntityManager em = JpaUtils.getEntityManager();
    EntityTransaction tx = em.getTransaction();
  	tx.begin();
    Customer customer = new Customer();	//新建状态，实例化创建的对象，尚未拥有持久性主键
    customer.setCustName("博学谷");
    em.persist(customer); //持久化状态，已经拥有持久性主键并和持久化建立了上下文环境
    tx.commit();
    em.close();
    //游离状态，拥有持久化主键，但是没有和持久化建立上下文关系
  }

Spring Data 和 Spring Data JPA

Spring Data

是spring的一个子项目，用于简化数据库访问，支持NoSQL和关系型数据库，主要目标是使数据库的访问变得方便快捷

SpringData支持的NoSQL存储：

• MongoDB（文档数据库）
• Neo4j（图形数据库）
• Redis（键值存储）
• Hbase（列族数据库）

SpringData支持的关系型数据库存储技术：JPA 和 JDBC

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层中只需要写接口，就自动具有了增删改查、分页查询等方法。

Spring Data JPA 与 JPA和hibernate之间的关系

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

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

Spring-JPA-SpringMVC

环境搭建

引入Spring Data JPA的坐标

使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等

主要分为三步：创建工程导入坐标；配置spring的配置文件；编写实体类，使用jpa注解配置映射关系

<properties>
    <spring.version>4.2.4.RELEASE</spring.version>
    <hibernate.version>5.0.7.Final</hibernate.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <c3p0.version>0.9.1.2</c3p0.version>
    <mysql.version>5.1.6</mysql.version>
</properties>

<dependencies>
    <!-- junit单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.9</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>log4j</groupId>
        <artifactId>log4j</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>4.2.4.RELEASE</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 -->
</dependencies>

整合Spring Data JPA与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 和 spring data jpa 的配置-->

    <!--1.创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <!--
    	LocalEntityManagerFactoryBean根据JPAPersistenceProvider自动检测配置文件进行工作
    		一般从META-INF/persistence.xml中读取配置信息，但是不能配置Spring定义的DataSource，不支持spring管理的全局事务
    	LocalContainerEntityManagerFactoryBean适用于所有环境的FactoryBean，能全面控制EntityManagerFactory配置
    		比如指定Spring定义的DataSource，事务等
    -->
        <property name="dataSource" ref="dataSource"/>
        <!--packagesToScan表示配置扫描的实体类所在的包-->
        <property name="packagesToScan" value="cn.itcast.domain"/>
        <!--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" />
                <!--
				  注入jpa的配置信息
				    加载jpa的基本配置信息和jpa实现方式(hibernate)的配置信息
				    hibernate.hbm2ddl.auto：自动创建数据库表
				        create：每次都会重新创建数据库表，正向工程
				        update：有表就不会重新创建，没有表就会重新创建
				-->
				<property name="jpaProperties">
				    <props>
				        <prop key="hibernate.hbm2ddl.auto">update</prop>
				    </props>
				</property>
            </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://localhost:3306/HeimaSpringData?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-->
    <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>

编写实体类，使用jpa注解配置映射关系

/**
 *  所有的注解都是使用JPA的规范提供的注解，
 *  所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
    
    @Id//声明当前私有属性为主键
    @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略为自增长
    @Column(name="cust_id") //指定和表中cust_id字段的映射关系
    private Long custId;
    
    @Column(name="cust_name") //指定和表中cust_name字段的映射关系
    private String custName;
    
    @Column(name="cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;
    
    @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;
    
    @Column(name="cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;
    
    @Column(name="cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;
    
    @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
    private String custPhone;
}

编写符合Spring Data JPA规范的Dao层接口

Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程

在Spring Data JPA中，对于定义符合规范的Dao层接口，我们只需要遵循以下几点就可以了：

1. 创建一个Dao层接口，并继承JpaRepository和JpaSpecificationExecutor

2. 提供相应的泛型
   JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作

   JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）

   public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {}
   

完成基本CRUD操作

DML语句执行需要添加事务，在测试类中对于事务的提交方式默认是回滚的，如果有业务层，事务注解应该是加到业务层，更多看最后注意

@Transactional 
@Rollback(false)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class CustomerDaoTest {

    @Autowired
    private CustomerDao customerDao;
    
    /**
     * 保存客户：调用save(obj)方法
     */
    @Test
    public void testSave() {
        Customer c = new Customer();
        c.setCustName("传智播客");
        customerDao.save(c);
    }
    
    /**
     * 修改客户：调用save(obj)方法
     *      对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新    
     *                      如果执行此方法中对象中不存在id属性，即为保存操作
     *          
     */
	@Test
    public void testUpdate() {
        Customer customer  = new Customer();
        customer.setCustId(4l);
        customer.setCustName("黑马程序员很厉害");
        customerDao.save(customer);
    }
    
  	@Test
    public void testUpdate() {
        //根据id查询id为1的客户
        Customer customer = customerDao.findOne(1l);
        //修改客户名称
        customer.setCustName("传智播客顺义校区");
        //更新
        //没有这条save语句也可以执行成功，但是要加@Trasactional和@Rollback(false)注解
        //save不用加因为save方法本身实现了事务
        customerDao.save(customer);
    }
    
    /**
     * 根据id删除：调用delete(id)方法
     * 底层先根据ID查询数据，如果有数据在删除数据
     */
    @Test
    public void testDelete() {
        customerDao.delete(1l);
    }
    
    /**
     * 根据id查询：调用findOne(id)方法
     */
    @Test
    public void testFindById() {
        Customer customer = customerDao.findOne(2l);
        System.out.println(customer);
    }
    
	/**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        List<Customer> list = customerDao.findAll();
        for(Customer customer : list) {
            System.out.println(customer);
        }
    }

分析

Jpa 的继承结构

• JpaRepository接口是开发中使用最多的接口，特点是可以帮我们将更高层的接口方法返回值做适配处理，可以使得我们在开发中更方便的使用这些方法
• JpaSpecificationExecutor接口不能单独使用，需要配合jpa中其他接口一同使用，单独使用无法实现给dao注入SimpleJpaRepository代理对象

Spring Data JPA的实现过程

以debug断点调试的方式，通过分析Spring Data JPA的原来来分析程序的执行过程
我们以findOne方法为例进行分析

• 代理子类的实现过程
  断点执行到方法上时，我们可以发现注入的customerDao对象，本质上是通过JdkDynamicAopProxy生成的一个代理对象
  

• 代理对象中方法调用的分析
  当程序执行的时候，会通过JdkDynamicAopProxy的invoke方法，对customerDao对象生成动态代理对象。根据对Spring Data JPA介绍而知，要想进行findOne查询方法，最终还是会出现JPA规范的API完成操作，那么这些底层代码存在于何处呢？答案很简单，都隐藏在通过JdkDynamicAopProxy生成的动态代理对象当中，而这个动态代理对象就是SimpleJpaRepository

  
  通过SimpleJpaRepository的源码分析，定位到了findOne方法，在此方法中，返回em.find()的返回结果，那么em又是什么呢

  带着问题继续查找em对象，我们发现em就是EntityManager对象，而他是JPA原生的实现方式，所以我们得到结论Spring Data JPA只是对标准JPA操作进行了进一步封装，简化了Dao层代码的开发

  

Spring Data JPA完整的调用过程

1. 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象（SimpleJpaRepository的动态代理对象）
2. SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CURD）
3. 通过hibernate完成数据库操作（封装了jdbc）

Spring Data JPA的查询方式

使用Spring Data JPA中接口定义的方法进行查询

在继承JpaRepository，和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询，继承JpaRepository后的方法列表

继承JpaSpecificationExecutor的方法列表

注意

 /**
	* findOne
	*   调用的是em.find()    立即加载
	*
	* getOne
	*   调用的是em.getReference()    延迟加载
	*   * 返回的是一个客户的动态代理对象
	*   * 什么时候用，什么时候查询数据库
	*
	* 注意：
	*    getOne方法要加@Transaction注解，或者实体类加@Proxy(lazy=false)，取消懒加载
	*    否则报错   org.hibernate.LazyInitializationException: could not initialize proxy - no Session
*/
	
	@Test
	public void testFindOne(){
	  System.out.println(customerDao.findOne(1L));
	}
	
	@Test
	@Transactional
	public void testGetOne(){
	  System.out.println(customerDao.getOne(1L));
	}

使用@Query注解和JPQL（jpa query language）的方式查询和新增修改

使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL的语句方式完成查询

@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可

JPQL编码规范：SQL常用的关键字全部大写

JPQL查询的是类和类中的属性

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {    
    //@Query 使用jpql的方式查询，查询所有
    @Query(value="from Customer")
    public List<Customer> findAllCustomer();
    
	//对于多个 ? 占位符，赋值的时候，默认情况下，占位符和参数是根据位置匹配的，而不是名称，但是命名时最好还是一致
    @Query(value="from Customer where custName = ? and custId = ?")
    public Customer findCustomer(String custName,Long custId);

    //@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
    @Query(value="from Customer where custName = ?1")
    public Customer findCustomer(String custName);

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

 @Query(value="update Customer set custName = ?1 where custId = ?2")
 @Modifying		//表示当前query是一个更新操作
 //主要参数名是根据1，2位置进行填充，而不是名称，但是命名时最好还是一致
 public void updateCustomer(String name,Long id);

 @Query(value="insert into cst_custName(custName) values(:custName)",nativeQuery=true)
 @Modifying		//新增操作也要加此注解
 public void updateCustomer(String custName);

DML语句 测试方法需要增加事务支持，DML语句方法命名上加@Modifying注解，同时调用DML方法的方法上面加事务注解，或者直接在DML语句方法命名上加@Modifying和@Transactional

/*
  * springDataJpa中使用jpql完成 更新/删除操作
  *   需要手动添加事务的支持
  *   默认会执行结束之后，回滚事务，所以要设置回滚为false取消自动回滚
  * */
  @Test
  @Transactional
  @Rollback(false)
  public void testUpdate(){
      customerDao.updateCustNameById(5L,"尚硅谷");
  }

SQL语句查询和更新

新增和删除DML语句要加@Modifying和@Transactional注解

JPQL语句和SQL语句的区别：
	JPQL语句查询的是类和类中的属性
		比如：@Query(value="from Customer where custName = ?1")
			 @Query(value="update Customer set custName = ?1 where custId = ?2")
			 
	SQL查询的是表和表中的字段
		比如：@Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)		
		@Query(value="update cst_customer set cust_name = ?1 where cust_id = ?2",nativeQuery = true)

• 特有的查询：需要在dao接口上配置方法
• 在新添加的方法上，使用注解的形式配置sql查询语句
• 注解 ：@Query
• value : jpql语句 | sql语句
• ​ nativeQuery : false（使用jpql查询，默认是false） | true（使用本地查询 - sql查询），false的本质是表示不开启sql查询，对value中语句做转义

 /**
  * 使用sql的形式查询：
  *     查询全部的客户
  *  sql ： select * from cst_customer;
  *  Query : 配置sql查询
  *      value ： sql语句
  *      nativeQuery ： 查询方式
  *          true ： sql查询
  *          false：jpql查询，默认是false
  *
  */
 //@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);

方法命名规则查询

根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询

按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析

原理

规则

以下 find 也可以为 get 、read

示例

/**
 * 方法名的约定：
 *      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);

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

模糊查询
findBy + 属性名称 + “查询方式（Like | isnull）”
注意测试传参时要自定义模糊规则，自己加%位置	customerDao.findByCustNameLike("李%")
public List<Customer> findByCustNameLike(String custName);

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

Specifications动态查询

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

/**
 *	JpaSpecificationExecutor中定义的方法
 **/
 public interface JpaSpecificationExecutor<T> {
   	//根据条件查询一个对象
 	T findOne(Specification<T> spec);	
   	//根据条件查询集合
 	List<T> findAll(Specification<T> spec);
   	//根据条件分页查询全部，page是分页参数，返回一个pageBean
 	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接口中只定义了如下一个方法

 //构造查询条件
 /**
 *	root	：Root接口，代表查询的根对象，可以通过root获取实体中的属性
 *	query	：代表一个顶层查询对象，用来自定义查询
 *	cb		：用来构建查询，此对象里有很多条件方法
 **/
 public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);

使用Specifications完成条件查询

单个条件查询

/**
  * 根据条件，查询单个对象
  *
  */
 @Test
 public void testSpec() {
     //匿名内部类
     /**
      * 自定义查询条件
      *      1.实现Specification接口（提供泛型：查询的对象类型）
      *      2.重写toPredicate方法（构造查询条件）
      *      3.需要借助方法参数中的两个参数（
      *          root：获取需要查询的对象属性
      * 		 CriteriaQuer：实现了一个基本的select * from 表，可以调用一些语句方法，一般不使用
      *          CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
      *       ）
      * 
      * 以上三步  使用匿名内部类的方式，创建一个Specification的实现类，并实现toPredicate方法
      * 
      *  案例：根据客户名称查询，查询客户名为传智播客的客户
      *          查询条件
      *              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);
 }

方式二

相比方式一，优势就是，条件过多时，一行代码不会参数太多太长

 /**
  * 多条件查询
  *      案例：根据客户名（传智播客）和客户所属行业查询（it教育）
  *
  */
 @Test
 public void testSpec1() {

     Specification<Customer> spec = new Specification<Customer>() {
         @Override
         public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
         	 //创建一个存储Predicate的数组，存放条件
         	 List<Predicate> list = new ArrayList<>();
         	 list.add(cb.equal(root.get("custName"), "传智播客");
         	 list.add(cb.equal(root.get("custIndustry"), "it教育");
         	 //将条件关联起来
         	 Predicate[] pre = new Predicate[list.size()];
         	 return cb.add(list.toArray(pre));
         	 
	/**注意
	*  List.toArry() 返回的是一个Object类型的数组，不能强转成其他类型
	*  List.toArry(T[]a) 返回值是一个T 类型（指定类型）的数组，将list转化为array的时候，这种方法更方便更常用
	*/
	
         }
     };
     Customer customer = customerDao.findOne(spec);
     System.out.println(customer);
 }

模糊查询和顺序查询

/**
  * 案例：完成根据客户名称的模糊匹配，返回客户列表
  *      客户名称以 ’传智播客‘ 开头
  *
  * equal ：直接得到path对象（属性），然后进行比较即可
  * gt，lt,ge,le,like : 不能直接用path对象比较，需要得到path对象，根据path指定比较的参数类型，再去进行比较
  *      指定参数类型：path.as(类型的字节码对象)
  */
 @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对象
     //		第一个参数：排序的顺序（倒序，正序），默认升序new Sort("custId");
     // 		  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);
     }

	//以下为按照多个属性排序，不同属性不同排序规则
	//第一个属性相同的时候，第二个排序属性才有作用
	//默认升序    Order o1 = new Order("userId");
	Order o1 = new Order(Direction.DESC,"userId");
	Order o2 = new Order(Direction.ASC,"userAge");
	Sort sort = new Sort(o1,o2);
	
	//不同属性相同排序规则
	//Sort sort = new Sort(Direction.DESC,"userId","userAge");
	List<Customer> list = customerDao.findAll(sort);
 }

分页查询

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

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

条件、顺序和分页同时实现

排序对象整合到分页对象中实现，分页和排序同时

 @Test
 public void testSpec4() {

     Specification spec = null;
     //PageRequest对象是Pageable接口的实现类
     /**
      * 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
      *      第一个参数：当前查询的页数（从0开始，0表示第一页）
      *      第二个参数：每页查询的数量
      *    	 第三个参数：排序对象
      */
     Sort sort = new Sort(Sort.Direction.DESC,"custId");
     Pageable pageable = new PageRequest(0,2,sort);
     
     //spec对象条件、sort对象、pageable对象分页 同时满足
     Page<Customer> page = customerDao.findAll(spec, pageable);
     List<Customer> list = page.getContent(); //得到数据集合列表
     for(Customer c : list){
     	System.out.println(c);
     }

 }

多表之间的关系和操作

表之间关系的划分

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

实体类中的关系
	包含关系：可以通过实体类中的包含关系描述表关系
	继承关系
	
分析步骤
	明确表关系
	在数据库中实现两张表的关系（外键--描述一对多 | 中间表--描述多对多）
	编写实体类，在实体类中使用实体类关系描述表关系（包含关系）
	配置出实体类和数据库表的关系映射（重点）

映射的注解说明

@OneToMany:
   	作用：建立一对多的关系映射
    属性：
    	targetEntityClass：指定多的多方的类的字节码
    	mappedBy：指定从表实体类中引用主表对象的名称
    	cascade：指定要使用的级联操作
    	fetch：指定是否采用延迟加载
    	orphanRemoval：是否使用孤儿删除

@ManyToOne
    作用：建立多对一的关系
    属性：
    	targetEntityClass：指定一的一方实体类字节码
    	cascade：指定要使用的级联操作
    	fetch：指定是否采用延迟加载
    	optional：关联是否可选。如果设置为false，则必须始终存在非空关系

@JoinColumn
     作用：用于定义主键字段和外键字段的对应关系。
     属性：
    	name：指定外键字段的名称
    	referencedColumnName：指定引用主表的主键字段名称
    	unique：是否唯一。默认值不唯一
    	nullable：是否允许为空。默认值允许
    	insertable：是否允许插入。默认值允许
    	updatable：是否允许更新。默认值允许
    	columnDefinition：列的定义信息

一对一

案例：特殊情况，一个用户一个角色

分析步骤
	1.明确表关系
		一对一关系
	2.确定表关系（描述 外键|中间表）
		一对一两者都可以做主表，在附表或主表中加外键都可
	3.编写实体类，再实体类中描述表关系（包含关系）
		用户：用户实体类中包含一个角色对象
		角色：角色实体类中包含一个用户对象
	4.配置映射关系
		* 使用jpa注解配置一对一映射关系

用户实体类

/*
 * 客户的实体类
 * 明确使用的注解都是JPA规范的
 * 所以导包都要导入javax.persistence包下的

* 1.实体类和表的映射关系
*   @Entity
*   @Table
* 2.类中属性和表中字段的映射关系
*   @Id
*   @GeneratedValue
*   @Column
*
* */
@Data
@AllArgsConstructor
@NoArgsConstructor

@Entity
@Table(name = "t_user")
public class User{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="userid")
    private Long userId;
    @Column(name="username")
    private String userName;
    @Column(name="userage")
    private String userAge;
    /**
    * 也可以自定义外键
    * @Transient	//自定义要加这个注解，因为@JoinColumn(name = "rid")和private Integer rid会产生映射冲突，@Transient是不让他做映射
    * private Integer rid;
	* 
	* 对应 @JoinColumn(name = "rid")	
    */

    //配置用户和角色之间的关系（一对一关系）
    /**
     * 使用注解的形式配置多表关系
     *      1.声明关系
     *          @OneToOne : 配置一对一关系
     * 					一对一配置一方的mappedBy属性即可
     *      2.配置外键（中间表）
     * 					一对一关联关系，外键建立在哪一侧都可以
     *              @JoinColumn : 配置外键
     *                  name：外键字段名称
     *
     */

    @OneToOne
    @JoinColumn(name = "role_id")	//在user表中会通过正向工程建立和role表主键关联的外键
    private Role role;
}

角色实体类

@Data
@NoArgsConstructor
@AllArgsConstructor

@Entity
@Table(name = "t_role")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "roleid")
    private Long roleId; //联系人编号(主键)
    @Column(name = "rolename")
    private String roleName;//联系人姓名
 
    /**
     * 配置角色到用户的一对一关系
     *     使用注解的形式配置一对一关系
     *      1.配置表关系
     *          @OneToOne : 配置多对一关系
     *              mappedBy：关联的对象中关联的我自己的名字
     *      2.配置外键（中间表）
     *
     * * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     */
    @OneToOne(mappedBy="role")
    //配置mappedBy的一端为被维护端
    private User user;
}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class OneToOneTest {

	@Autowired
	private UserDao userDao;
	
	@Autowired
	private RoleDao roleDao;
	
	
	/**
	 * 创建角色，创建用户，建立关系，保存数据
	 */
	@Test
	public void testAdd() {
		User user = new User();
		user.setUserName("张三");
		
		Role role = new Role();
		role.setRoleName("管理员");
		//建立关系
		user.setRole(role);
		role.setUser(user);
		
		userDao.save(role);
		/**
		*  在User实体类中@OneToOne(cascade=CascadeType.ALL)
		*  即可实现只保存用户，就可以同时保存角色的级联操作
		*  如果不设置级联操作，则还需要用角色Dao保存一下数据
		*/
		roleDao.save(user); 
	}
	
	@Test
    public void testFind() {
        //通过用户查询角色
       User user = userDao.findOne(1L);
       System.out.println("用户" + user);
       Role role = user.getRole();
       System.out.println("角色" + role);       
    }

    /**
     * 会有一条多余的update语句
     *      * 由于一的一方可以维护外键：会发送update语句
     *      * 解决此问题：只需要在一的一方放弃维护权即可
     *
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd2() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");


        linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
        customer.getLinkMans().add(linkMan);//由于配置了一的一方到多的一方的关联关系（发送一条update语句）

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }
}

一对多

案例：客户和联系人的案例（一对多关系）
	客户：一家公司
	联系人：这家公司的员工

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

配置文件中添加

<!--
  注入jpa的配置信息
    加载jpa的基本配置信息和jpa实现方式(hibernate)的配置信息
    hibernate.hbm2ddl.auto：自动创建数据库表
        create：每次都会重新创建数据库表
        update：有表就不会重新创建，没有表就会重新创建
-->
<property name="jpaProperties">
    <props>
        <prop key="hibernate.hbm2ddl.auto">update</prop>
    </props>
</property>

客户实体类

/*
 * 客户的实体类
 * 明确使用的注解都是JPA规范的
 * 所以导包都要导入javax.persistence包下的

* 1.实体类和表的映射关系
*   @Entity
*   @Table
* 2.类中属性和表中字段的映射关系
*   @Id
*   @GeneratedValue
*   @Column
*
* */
@Data
@AllArgsConstructor
@NoArgsConstructor

@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;

    //配置客户和联系人之间的关系（一对多关系）
    /**
     * 使用注解的形式配置多表关系
     *      1.声明关系
     *          @OneToMany : 配置一对多关系
     *              targetEntity ：对方对象的字节码对象
     *      2.配置外键（中间表）
     *              @JoinColumn : 配置外键
     *                  name：外键字段名称
     *                  referencedColumnName：参照的主表的主键字段名称
     *
     *  * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
     *
     */

    @OneToMany(targetEntity = LinkMan.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    //由于联系人是多的一方，在实体类中要体现出，一个客户对应多个联系人
    private Set<LinkMan> linkMans = new HashSet<>();

	/**
	* 也可以如下操作
	* 	@OneToMany(mappedBy = "customer")
	* 	private Set<LinkMan> linkMans = new HashSet<>();
	*/
}

联系人实体类

@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;//联系人备注

    /**
     * 配置联系人到客户的多对一关系
     *     使用注解的形式配置多对一关系
     *      1.配置表关系
     *          @ManyToOne : 配置多对一关系
     *              targetEntity：对方的实体类字节码
     *      2.配置外键（中间表）
     *
     * * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     */
    @ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    //由于联系人是多的一方，在实体类中要体现出，一个客户对应多个联系人
    private Customer customer;

	/**
	* 对应客户类中这种方式
	* 也可以如下操作
	* 	@ManyToOne()	或者 @ManyToOne(targetEntity = Customer.class)
	* 	@JoinColumn(name="lkm_cust_id")
	* 	private Customer customer;
	*/
}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class OneToManyTest {

	@Autowired
	private CustomerDao customerDao;
	
	@Autowired
	private LinkManDao linkManDao;
	
	
	/**
	 * 保存操作
	 * 需求:
	 * 	保存一个客户和一个联系人
	 * 要求：
	 * 	创建一个客户对象和一个联系人对象
	 *  建立客户和联系人之间关联关系（双向一对多的关联关系）
	 *  先保存客户，再保存联系人
	 * 问题：
	 *		当我们建立了双向的关联关系之后，先保存主表，再保存从表时：
	 *		会产生2条insert和1条update.
	 * 		而实际开发中我们只需要2条insert。
	 *  
	 */
	@Test
	@Transactional  //开启事务
	@Rollback(false)//设置为不回滚
	public void testAdd() {
		Customer c = new Customer();
		c.setCustName("TBD云集中心");
		c.setCustLevel("VIP客户");
		c.setCustSource("网络");
		c.setCustIndustry("商业办公");
		c.setCustAddress("昌平区北七家镇");
		c.setCustPhone("010-84389340");
		
		LinkMan l = new LinkMan();
		l.setLkmName("TBD联系人");
		l.setLkmGender("male");
		l.setLkmMobile("13811111111");
		l.setLkmPhone("010-34785348");
		l.setLkmEmail("98354834@qq.com");
		l.setLkmPosition("老师");
		l.setLkmMemo("还行吧");
		
 		/**
        * 配置了客户到联系人的关系
        *      从客户的角度上：发送两条insert语句，发送一条更新语句更新数据库（更新外键）
        * 由于我们配置了客户到联系人的关系：客户可以对外键进行维护
        */
		c.getLinkMans().add(l);
		//先保存主表，再保存子表
		customerDao.save(c);
		linkManDao.save(l);
	}
	
	@Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd1() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        /**
         * 配置联系人到客户的关系（多对一）
         *    只发送了两条insert语句
         * 由于配置了联系人到客户的映射关系（多对一）
         *
         */
        linkMan.setCustomer(customer);

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

    /**
     * 会有一条多余的update语句
     *      * 由于一的一方可以维护外键：会发送update语句
     *      * 解决此问题：只需要在一的一方放弃维护权即可
     *
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd2() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");


        linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
        customer.getLinkMans().add(linkMan);//由于配置了一的一方到多的一方的关联关系（发送一条update语句）

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }
}

删除操作：

• 删除从表数据：可以随时任意删除。
• 删除主表数据：

  • 有从表数据

    1、在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表， 结构上，外键字段有非空约束，默认情况就会报错了。
    2、如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null，没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
    3、如果还想删除，使用级联删除引用
    

  • 没有从表数据引用：随便删

在实际开发中，级联删除请慎用！(在一对多的情况下)

级联操作

级联操作：操作一个对象同时操作它的关联对象
使用方法：只需要在操作主体的注解上配置cascade

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

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

   /**
    * 级联添加：保存一个客户的同时，保存客户的所有联系人
    *      需要在操作主体的实体类上，配置casacde属性
    */
   @Test
   @Transactional //配置事务
   @Rollback(false) //不自动回滚
   public void testCascadeAdd() {
       Customer customer = new Customer();
       customer.setCustName("百度1");

       LinkMan linkMan = new LinkMan();
       linkMan.setLkmName("小李1");

       linkMan.setCustomer(customer);
       customer.getLinkMans().add(linkMan);
		//使用级联操作时，就可以只保存主体，底层自动保存他关联的内容
		//只保存
       customerDao.save(customer);
   }

  /**
    * 级联删除：
    *      删除1号客户的同时，删除1号客户的所有联系人
    */
   @Test
   @Transactional //配置事务
   @Rollback(false) //不自动回滚
   public void testCascadeRemove() {
       //1.查询1号客户
       Customer customer = customerDao.findOne(1l);
       //2.删除1号客户
       //只删除LinkMan会报错，因为不是主体
       customerDao.delete(customer);
   }

多对多

案例：用户和角色（多对多关系）
	用户：指的是咱们班的每一个同学
	角色：指的是咱们班同学的身份信息
	
		比如A同学，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。
		同时B同学，它也具有学生和子女的身份。
		那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有

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

用户

@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="age")
    private Integer age;

    /**
     * 配置用户到角色的多对多关系
     *      配置多对多的映射关系
     *          1.声明表关系的配置
     *              @ManyToMany(targetEntity = Role.class)  //多对多
     *                  targetEntity：代表对方的实体类字节码
     *          2.配置中间表（包含两个外键）
     *                @JoinTable，在两侧中的一侧配置此注解即可
     *                  name : 中间表的名称
     *                  joinColumns：配置当前对象在中间表的外键
     *                      @JoinColumn的数组
     *                          name：外键名
     *                          referencedColumnName：参照的主表的主键名
     *                  inverseJoinColumns：配置对方对象在中间表的外键
     */
    @ManyToMany(targetEntity = Role.class)
    //也可以直接 @ManyToMany()，角色表中配置mappedBy即可
    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表中的外键
            joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
            //inverseJoinColumns，对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
    )
    private Set<Role> roles = new HashSet<>();
}

角色

@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;

	//在多对多（保存）中
	//如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据
	//中间表的2个字段又作为联合主键，所以报错，主键重复
	//解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃，配置如下

    //放弃对中间表的维护权，解决保存中主键冲突的问题
    //配置mappedBy的一端为被维护端 
    @ManyToMany(mappedBy = "roles")  //配置多表关系(对方配置映射关系的属性名称)
    private Set<User> users = new HashSet<>();

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {

    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;

    /*
    * 保存一个用户，保存一个角色
    *
    * 多对多放弃维护权，被动的一方放弃
    * */
    @Test
    @Transactional
    @Rollback(false)
    public void testAdd(){
        User user = new User();
        user.setUserName("小刘");

        Role role = new Role();
        role.setRoleName("程序员");

        //配置用户到角色关系，可以对中间表中的数据进行维护
        user.getRoles().add(role);
        //以下内容不注释，同时双方都有维护权，会导致主键冲突
        //所以，注释以下内容，或者取消被动方role的维护权
        //role.getRoles().add(user);

		//如果只有role.getRoles().add(user);没有user.getRoles().add(role);
		//会导致两张表都能插入数据，但是中间表没有关系数据
		//因为role取消了维护权，就不能对中间表进行插入数据等操作
        userDao.save(user);
        roleDao.save(role);
    }
}

级联操作

级联操作：操作一个对象同时操作它的关联对象
使用方法：只需要在操作主体的注解上配置cascade

注解中加入cascade = CascadeType.ALL
我们放弃了被动对象的维护权，所以这里只设置主动方的级联配置即可
如果没有放弃被动对象的维护权，被动和主动都设置级联配置也可以正常操作


@ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
@JoinTable(name = "sys_user_role",
          //joinColumns,当前对象在中间表中的外键
          joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
          //inverseJoinColumns，对方对象在中间表的外键
          inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
  )
  private Set<Role> roles = new HashSet<>();

级联添加
 @Test
 @Transactional
 @Rollback(false)
 public void testAdd(){
     User user = new User();
     user.setUserName("小刘");

     Role role = new Role();
     role.setRoleName("程序员");

     //配置用户到角色关系，可以对中间表中的数据进行维护
     user.getRoles().add(role);

     //设置级联配置后，只需要主体user进行操作即可操作关联对象和中间表
     userDao.save(user);
//   roleDao.save(role);
    }
    
级联删除
@Autowired
private UserDao userDao;
/**
 * 删除操作
 * 	在多对多的删除时，双向级联删除根本不能配置
 * 禁用
 *	如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据
 */
@Test
@Transactional
@Rollback(false)//设置为不回滚
public void testDelete() {
	userDao.delete(1l);
 }

Spring Data JPA中的多表查询

对象导航查询

对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。例如：我们通过ID查询方式查出一个客户，可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人

对象导航查询的使用要求是：两个对象之间必须存在关联关系

客户

/**
 * 1.实体类和表的映射关系
 *      @Eitity
 *      @Table
 * 2.类中属性和表中字段的映射关系
 *      @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;

    //配置客户和联系人之间的关系（一对多关系）
    /**
     * 使用注解的形式配置多表关系
     *      1.声明关系
     *          @OneToMany : 配置一对多关系
     *              targetEntity ：对方对象的字节码对象
     *      2.配置外键（中间表）
     *              @JoinColumn : 配置外键
     *                  name：外键字段名称
     *                  referencedColumnName：参照的主表的主键字段名称
     *
     *  * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
     *
     */

//    @OneToMany(targetEntity = LinkMan.class)
//    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    /**
     * 放弃外键维护权
     *      mappedBy：对方配置关系的属性名称\
     * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
     *      CascadeType.all         : 所有
     *                  MERGE       ：更新
     *                  PERSIST     ：保存
     *                  REMOVE      ：删除
     *
     * fetch : 配置关联对象的加载方式
     *          EAGER   ：立即加载
     *          LAZY    ：延迟加载

      */
    @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
    private Set<LinkMan> linkMans = new HashSet<>();

联系人

@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;//联系人备注

    /**
     * 配置联系人到客户的多对一关系
     *     使用注解的形式配置多对一关系
     *      1.配置表关系
     *          @ManyToOne : 配置多对一关系
     *              targetEntity：对方的实体类字节码
     *      2.配置外键（中间表）
     *
     * * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     *
     */
    @ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")

测试

查询一个客户，获取该客户下的所有联系人
	@Autowired
	private CustomerDao customerDao;
	
	@Test
	//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中
	@Transactional 
	public void testFind() {
		//先查找一个客户
		//通过一方（主表/客户）查询多方（从表/联系人）：实体类配置中默认是延迟加载
		//使用延迟加载的方式getOne
		Customer customer = customerDao.getOne(5l);
		//通过客户找到联系人
		Set<LinkMan> linkMans = customer.getLinkMans();//对象导航查询
		for(LinkMan linkMan : linkMans) {
  			System.out.println(linkMan);
		}
		
	}
	
查询一个联系人，获取该联系人的所有客户
	@Autowired
	private LinkManDao linkManDao;
	
	@Test
	public void testFind() {
		//先查找一个联系人
		//通过多方（从表/联系人）查询一方（主表/客户）：实体类配置中默认是立即加载
		//使用立即加载的方式findOne
		LinkMan linkMan = linkManDao.findOne(4l);
		//通过联系人找到客户	
		Customer customer = linkMan.getCustomer(); //对象导航查询
		System.out.println(customer);
	}

分析

通过一方（主表/客户）查询多方（从表/联系人）：默认是延迟加载

如果我们不查的话，在用的时候还要自己写代码，调用方法去查询。如果我们查出来的，不使用时又会白白的浪费了服务器内存

/**
	 * 在客户对象的@OneToMany注解中添加fetch属性
	 * 		FetchType.EAGER	：立即加载
	 * 		FetchType.LAZY	：延迟加载-- 默认
	 */
	@OneToMany(mappedBy="customer",fetch=FetchType.LAZY)
	private Set<LinkMan> linkMans = new HashSet<>();

通过多方（从表/联系人）查询一方（主表/客户）：默认是立即加载

查询联系人详情时，肯定会看看该联系人的所属客户。如果我们不查的话，在用的时候还要自己写代码，调用方法去查询。如果我们查出来的话，一个对象不会消耗太多的内存。而且多数情况下我们都是要使用的

/**
	 * 在联系人对象的@ManyToOne注解中添加fetch属性
	 * 		FetchType.EAGER	：立即加载-- 默认
	 * 		FetchType.LAZY	：延迟加载
	 */
	@ManyToOne(targetEntity=Customer.class,fetch=FetchType.EAGER)
	@JoinColumn(name="cst_lkm_id",referencedColumnName="cust_id")
	private Customer customer;

注意

• 执行DML语句时用不用加事务@Transactional 和 @Rollback(false) 注解看dao继承的接口的实现类，有没有对调用方法实现了事务，比如SimpleJpaRepository中的方法实现了事务
  

• 被维护端@OneToOne等其他注解中指定mappedBy，mappedBy=维护端中定义的被维护端的属性名；维护端中定义@JoinColumn(name=维护端中外键)，@OneToOne(懒加载等)

  维护外键的一方为维护端

• 真删除和假删除