SpringDataJpa学习一

阅读量：3922 次

发布时间：2019-05-23

本文共 33197 字，大约阅读时间需要 110 分钟。

学springdatajpa之前，我觉得非常有必要复习一下Jpa规范和orm思想。

JPA入门

orm概述

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

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

常见的orm框架：Mybatis（ibatis）、Hibernate、Jpa。

JPA规范

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

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

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

JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。java代码调用JPA规范中的接口和实现类，但是接口并不能实现功能，实际实现功能的还是hibernate框架，而hibernate还是对jdbc的封装，从而操作数据库。

JPA入门

目的：通过JPA规范实现对数据库中客户表的操作。

步骤一：创建maven工程，导入依赖；

步骤二：建立数据库表和实体类对象

步骤三：编写JPA的配置文件；

步骤四：进行单元测试。

步骤一：创建maven工程，导入依赖；


           
    
     UTF-8
    	    
    
     5.0.7.Final
        
       
           
                
     
      junit
                 
     
      junit
                 
     
      4.12
                 
     
      test
             
            
            
                
     
      org.projectlombok
                 
     
      lombok
                 
     
      1.16.10
             
            
            
                
     
      org.hibernate
                 
     
      hibernate-entitymanager
                 
     
      ${
   project.hibernate.version}
             
            
            
                
     
      org.hibernate
                 
     
      hibernate-c3p0
                 
     
      ${
   project.hibernate.version}
             
            
            
                
     
      log4j
                 
     
      log4j
                 
     
      1.2.17
             
            
            
                
     
      mysql
                 
     
      mysql-connector-java
                 
     
      5.1.6

步骤二：建立数据库表和实体类对象

创建数据库表：

CREATE DATABASE jpa;USE jpa;CREATE TABLE t_customer(	cst_id INT(10) PRIMARY KEY AUTO_INCREMENT COMMENT'顾客id(主键)',	cst_name VARCHAR(32) COMMENT'顾客姓名',	cst_age INT(2) COMMENT '顾客年龄')ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体类对象：

package top.youngyang.pojo;import lombok.Data;import javax.persistence.*;@Data//lombok为类添加了setter，getter，toString，hashcode和equal方法@Entity//说明当前是一个实体类@Table(name = "t_customer")//@Table指定该实体类对应的数据库表public class Customer {
       @Id//指明该字段为id主键    @GeneratedValue(strategy=GenerationType.IDENTITY)//设置主键生成策略为自增    private Integer id;    @Column(name = "cst_name")//@Column指明该属性对应的字段    private String name;    @Column(name = "cst_age")    private int age;    public Customer(String name, int age) {
           this.name = name;        this.age = age;    }}

步骤三：编写JPA的配置文件；

配置文件必须在META-INF文件夹下，并且名称为persistence.xml。


   
       
        
            
             
     
      org.hibernate.jpa.HibernatePersistenceProvider

步骤四：进行单元测试。

package top.youngyang;import org.junit.Test;import top.youngyang.pojo.Customer;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class JpaTest {
       @Test    public void testJpa(){
           //创建实体类管理器工厂，参数必须传入一个persistence-unit名称        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");        //利用实体类管理器工厂创建实体类管理器        EntityManager entityManager = entityManagerFactory.createEntityManager();        //获取事务，并且开启        EntityTransaction transaction = entityManager.getTransaction();        transaction.begin();        //保存操作        Customer c = new Customer("hahha", 11);        entityManager.persist(c);        //事务提交        transaction.commit();        //关闭资源        entityManager.close();        entityManagerFactory.close();    }}

EntityManagerFactory：由javax.persistence.Persistence通过静态方法获得，主要是用来创建EntityManager。

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

EntityManager：在 JPA 规范中, EntityManager是完成持久化操作的核心对象。

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

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

方法说明：

getTransaction : 获取事务对象	persist ： 保存操作	merge ： 更新操作	remove ： 删除操作	find/getReference ： 根据id查询。	注意：find为立即加载，getReference为延迟加载，即什么时候使用什么时候加载。

JPA的复杂查询

在JPA规范中也可使用JPQL完成复杂查询，JPQL全称Java Persistence Query Language。和sql相似，但是sql语句的查询来源和条件等等都是数据库表中的，而jpql语句则是从实体类中。

使用jpql完成查询所有操作，如下：

public void testJSPL() {
           EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");        EntityManager entityManager = factory.createEntityManager();        EntityTransaction tx = entityManager.getTransaction();        tx.begin();        //编写jpql语句        String jpql = "from Customer";        Query query = entityManager.createQuery(jpql);        List resultList = query.getResultList();        for(Object e:resultList){
               System.out.println(e);        }    }

如sql语句相似，也可使用带有占位符的jpql语句，如使用jpql完成条件查询：

@Testpublic void testJSPL2() {
           EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");        EntityManager entityManager = factory.createEntityManager();        EntityTransaction tx = entityManager.getTransaction();        tx.begin();        String jpql = "from Customer where name like ?";        Query query = entityManager.createQuery(jpql);        //占位符赋值从q开始        query.setParameter(1,"ha%");        List resultList = query.getResultList();        for(Object e:resultList){
               System.out.println(e);        }    }

SpringDataJpa

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

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

SpringDataJpa、Hibernate和Jpa之间的关系

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

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

三者之间的关系图：

springdatajpa是对jpa规范的更加高级的封装，我们不在需要重复调用JPA规范完成功能，springdatajpa已经替我们完成。springdatajpa调用JPA规范完成功能，而JPA之是一套规范，只是一套接口和抽象类，底层还是使用hibernate完成实现，而hibernate对jdbc进行了封装，从而访问数据库。

SpringDataJpa快速入门

步骤一：创建工程，导入坐标

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


           
    
     4.2.4.RELEASE
            
    
     5.0.7.Final
            
    
     1.6.6
            
    
     1.2.12
            
    
     0.9.1.2
            
    
     5.1.6
        
       
           
                
     
      junit
                 
     
      junit
                 
     
      4.9
                 
     
      test
             
                    
            
                
     
      org.aspectj
                 
     
      aspectjweaver
                 
     
      1.6.8
             
            
                
     
      org.springframework
                 
     
      spring-aop
                 
     
      ${
   spring.version}
             
            		
            
                
     
      org.springframework
                 
     
      spring-context
                 
     
      ${
   spring.version}
             
            
                
     
      org.springframework
                 
     
      spring-context-support
                 
     
      ${
   spring.version}
             
            
                
     
      org.springframework
                 
     
      spring-beans
                 
     
      ${
   spring.version}
             
            
                
     
      org.springframework
                 
     
      spring-core
                 
     
      ${
   spring.version}
             
          	 
            
                
     
      org.springframework
                 
     
      spring-orm
                 
     
      ${
   spring.version}
             
            
            
            
                
     
      org.hibernate
                 
     
      hibernate-core
                 
     
      ${
   hibernate.version}
             
            
                
     
      org.hibernate
                 
     
      hibernate-entitymanager
                 
     
      ${
   hibernate.version}
             
            
                
     
      org.hibernate
                 
     
      hibernate-validator
                 
     
      5.2.1.Final
             
            
            
            
                
     
      c3p0
                 
     
      c3p0
                 
     
      ${
   c3p0.version}
             
            
            
            
                
     
      log4j
                 
     
      log4j
                 
     
      ${
   log4j.version}
             
            
                
     
      org.slf4j
                 
     
      slf4j-api
                 
     
      ${
   slf4j.version}
             
            
                
     
      org.slf4j
                 
     
      slf4j-log4j12
                 
     
      ${
   slf4j.version}
             
            
            
                
     
      mysql
                 
     
      mysql-connector-java
                 
     
      ${
   mysql.version}
             
            
                
     
      org.springframework.data
                 
     
      spring-data-jpa
                 
     
      1.9.0.RELEASE
             
    		
            
                
     
      org.springframework
                 
     
      spring-test
                 
     
      4.2.4.RELEASE
             
                    
            
                  
     
      javax.el
                   
     
      javax.el-api
                   
     
      2.2.4
               
              
                  
     
      org.glassfish.web
                   
     
      javax.el
                   
     
      2.2.4

整合SpringDataJpa和spring

applicationContext.xml文件内容如下：

步骤三编写数据库表和实体类以及配置他们的关系

此部分内容与JPA入门相应的内容相同。

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

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

1.创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor

2.提供相应的泛型。

dao接口如下：

package top.youngyang.dao;import org.springframework.data.jpa.repository.JpaRepository;import org.springframework.data.jpa.repository.JpaSpecificationExecutor;import top.youngyang.pojo.Customer;/** * JpaRepository
   <实体类类型，主键类型>
    ：用来完成基本CRUD操作 * JpaSpecificationExecutor
    <实体类类型>
     ：用于复杂查询（分页等查询操作） */public interface CustomerDao extends JpaRepository
     
      , JpaSpecificationExecutor
      
        {
   }

步骤五单元测试

package top.youngyang;import org.junit.Assert;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.SpringRunner;import top.youngyang.dao.CustomerDao;import top.youngyang.pojo.Customer;@RunWith(SpringRunner.class)//声明spring提供的测试环境@ContextConfiguration("classpath:applicationContext.xml")//指定spring配置文件的地方public class SpringdataJpaTest {
       @Autowired    private CustomerDao customerDao;    @Test    public void testSave(){
           Customer customer = customerDao.save(new Customer("1234", 12));        Assert.assertNotNull(customer);    }    @Test    public void testFindOne(){
           Customer customer = customerDao.findOne(3);        Assert.assertNotNull(customer);    }}

SpringDataJpa的查询方式

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

1.继承JpaRepository后的方法列表

在这里插入图片描述

2.继承JpaSpecificationExecutor的方法列表

在这里插入图片描述

3.使用JPQL语句查询

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

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

public interface CustomerDao extends JpaRepository
   
    , JpaSpecificationExecutor
    
      {
   		//使用jpql定义自己的方法    @Query("from Customer where id > 2")    List
     
       myFind();}

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

若在jpql语句中使用到占位符，则方法中必须出现此参数，并且顺序不能改变，如要改变参数顺序，那么应该在占位符？后面加上索引(索引默认从1开始)，如?1。

注意：在进行更新/删除操作时，要使用事物的支持（@Transactional），否则汇报异常。

4.使用SQL语句查询

在SpringDataJpa中不仅可以使用jpql语句查询，也可以使用sql语句查询，与jpql查询略有不同。需要在@Query注解中加入nativeQuery属性并设置为true，表明为本地查询（SQL查询），如下：

/**     * nativeQuery : 使用本地sql的方式查询     */    @Query(value="select * from cst_customer",nativeQuery=true)    public void findSql();

5.方法命名规则查询

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

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

如下所示：

此处表示模糊查询。

SpringDataJpa动态查询

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

import java.util.List;import org.springframework.data.domain.Page;import org.springframework.data.domain.Pageable;import org.springframework.data.domain.Sort;import org.springframework.data.jpa.domain.Specification;/** *	JpaSpecificationExecutor中定义的方法 **/ public interface JpaSpecificationExecutor
   
     {
      	//根据条件查询一个对象 	T findOne(Specification
    
      spec);	   	//根据条件查询集合 	List
     
       findAll(Specification
      
        spec);   	//根据条件分页查询 	Page
       
         findAll(Specification
        
          spec, Pageable pageable); //排序查询查询 List
         
           findAll(Specification
          
            spec, Sort sort); //统计查询 long count(Specification
           
             spec);}

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

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

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

使用Specifications完成条件查询

注意：在使用精准查询（如name=zhangsan），可以直接进行查询，而其他的必须调用as()方法指定比较的对象，如as(String.class)。

//依赖注入customerDao	@Autowired	private CustomerDao customerDao;		@Test	public void testSpecifications() {
         	//使用匿名内部类的方式，创建一个Specification的实现类，并实现toPredicate方法		Specification 
   
     spec = new Specification
    
     () {
   			public Predicate toPredicate(Root
     
       root, CriteriaQuery
       query, CriteriaBuilder cb) {
   				//cb:构建查询，添加查询方式   like：模糊匹配				//root：从实体Customer对象中按照custName属性进行查询				return cb.like(root.get("custName").as(String.class), "传智播客%");			}		};		Customer customer = customerDao.findOne(spec);		System.out.println(customer);	}

若查询天条件存在多个，则需要调用CriteriaBuilder 中的and或者or方法进行合成。

如下：

@Test    public void testSpec2() {
           Specification
   
     specification = new Specification
    
     () {
               public Predicate toPredicate(Root
     
       root, CriteriaQuery
       query, CriteriaBuilder cb) {
                   Path

基于Specifications的分页查询

@Test	public void testPage() {
   		//构造查询条件		Specification
   
     spec = new Specification
    
     () {
   			public Predicate toPredicate(Root
     
       root, CriteriaQuery
       query, CriteriaBuilder cb) {
   				return cb.like(root.get("custName").as(String.class), "传智%");			}		};				/**		 * 构造分页参数		 * 		Pageable : 接口		 * 			PageRequest实现了Pageable接口，调用构造方法的形式构造		 * 				第一个参数：页码（从0开始）		 * 				第二个参数：每页查询条数		 */		Pageable pageable = new PageRequest(0, 5);				/**		 * 分页查询，封装为Spring Data Jpa 内部的page bean		 * 		此重载的findAll方法为分页方法需要两个参数		 * 			第一个参数：查询条件Specification		 * 			第二个参数：分页参数		 */		Page
      
        page = customerDao.findAll(spec,pageable);	}

对于Spring Data JPA中的分页查询，是其内部自动实现的封装过程，返回的是一个Spring Data JPA提供的pageBean对象。其中的方法说明如下：

//获取总页数	int getTotalPages();	 //获取总记录数		long getTotalElements();	//获取列表数据	List
   
     getContent();

CriteriaBuilder 中的比较方法对应关系

CriteriaBuilder 中的主要常用比较方法对应的关系如下所示：

SpringDataJpa中的多表操作

JPA中的一对多

我们采用的示例为客户和联系人。

客户：指的是一家公司，我们记为A。

联系人：指的是A公司中的员工。

在不考虑兼职的情况下，公司和员工的关系即为一对多。

表关系建立

在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。在数据库中建立一对多的关系，需要使用数据库的外键约束。

什么是外键？

指的是从表中有一列，取值参照主表的主键，这一列就是外键。

一对多数据库关系的建立，如下图所示：

实体类关系建立以及映射配置

两张表的sql语句如下：

/*创建客户表*/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=94 DEFAULT CHARSET=utf8;/*创建联系人表*/CREATE TABLE cst_linkman (  lkm_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',  lkm_name varchar(16) DEFAULT NULL COMMENT '联系人姓名',  lkm_gender char(1) DEFAULT NULL COMMENT '联系人性别',  lkm_phone varchar(16) DEFAULT NULL COMMENT '联系人办公电话',  lkm_mobile varchar(16) DEFAULT NULL COMMENT '联系人手机',  lkm_email varchar(64) DEFAULT NULL COMMENT '联系人邮箱',  lkm_position varchar(16) DEFAULT NULL COMMENT '联系人职位',  lkm_memo varchar(512) DEFAULT NULL COMMENT '联系人备注',  lkm_cust_id bigint(32) NOT NULL COMMENT '客户id(外键)',  PRIMARY KEY (`lkm_id`),  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类要体现出客户中有多个联系人的信息，代码如下：

/** * 客户的实体类 * 明确使用的注解都是JPA规范的 * 所以导包都要导入javax.persistence包下的 */@Entity//表示当前类是一个实体类@Table(name="cst_customer")//建立当前实体类和表之间的对应关系public class Customer implements Serializable {
   		@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;	    //配置客户和联系人的一对多关系  	@OneToMany(targetEntity=LinkMan.class)	@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")	private Set
   
     linkmans = new HashSet
    
     (0);		public Long getCustId() {
   		return custId;	}	public void setCustId(Long custId) {
   		this.custId = custId;	}	public String getCustName() {
   		return custName;	}	public void setCustName(String custName) {
   		this.custName = custName;	}	public String getCustSource() {
   		return custSource;	}	public void setCustSource(String custSource) {
   		this.custSource = custSource;	}	public String getCustIndustry() {
   		return custIndustry;	}	public void setCustIndustry(String custIndustry) {
   		this.custIndustry = custIndustry;	}	public String getCustLevel() {
   		return custLevel;	}	public void setCustLevel(String custLevel) {
   		this.custLevel = custLevel;	}	public String getCustAddress() {
   		return custAddress;	}	public void setCustAddress(String custAddress) {
   		this.custAddress = custAddress;	}	public String getCustPhone() {
   		return custPhone;	}	public void setCustPhone(String custPhone) {
   		this.custPhone = custPhone;	}	public Set
     
       getLinkmans() {
   		return linkmans;	}	public void setLinkmans(Set
      
        linkmans) {
   		this.linkmans = linkmans;	}	@Override	public String toString() {
   		return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource				+ ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress				+ ", custPhone=" + custPhone + "]";	}}

由于联系人是多的一方，在实体类中要体现出，每个联系人只能对应一个客户，代码如下：

/** * 联系人的实体类（数据模型） */@Entity@Table(name="cst_linkman")public class LinkMan implements Serializable {
   	@Id	@GeneratedValue(strategy=GenerationType.IDENTITY)	@Column(name="lkm_id")	private Long lkmId;	@Column(name="lkm_name")	private String lkmName;	@Column(name="lkm_gender")	private String lkmGender;	@Column(name="lkm_phone")	private String lkmPhone;	@Column(name="lkm_mobile")	private String lkmMobile;	@Column(name="lkm_email")	private String lkmEmail;	@Column(name="lkm_position")	private String lkmPosition;	@Column(name="lkm_memo")	private String lkmMemo;	//多对一关系映射：多个联系人对应客户	@ManyToOne(targetEntity=Customer.class)	@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")	private Customer customer;//用它的主键，对应联系人表中的外键		public Long getLkmId() {
   		return lkmId;	}	public void setLkmId(Long lkmId) {
   		this.lkmId = lkmId;	}	public String getLkmName() {
   		return lkmName;	}	public void setLkmName(String lkmName) {
   		this.lkmName = lkmName;	}	public String getLkmGender() {
   		return lkmGender;	}	public void setLkmGender(String lkmGender) {
   		this.lkmGender = lkmGender;	}	public String getLkmPhone() {
   		return lkmPhone;	}	public void setLkmPhone(String lkmPhone) {
   		this.lkmPhone = lkmPhone;	}	public String getLkmMobile() {
   		return lkmMobile;	}	public void setLkmMobile(String lkmMobile) {
   		this.lkmMobile = lkmMobile;	}	public String getLkmEmail() {
   		return lkmEmail;	}	public void setLkmEmail(String lkmEmail) {
   		this.lkmEmail = lkmEmail;	}	public String getLkmPosition() {
   		return lkmPosition;	}	public void setLkmPosition(String lkmPosition) {
   		this.lkmPosition = lkmPosition;	}	public String getLkmMemo() {
   		return lkmMemo;	}	public void setLkmMemo(String lkmMemo) {
   		this.lkmMemo = lkmMemo;	}		public Customer getCustomer() {
   		return customer;	}	public void setCustomer(Customer customer) {
   		this.customer = customer;	}	@Override	public String toString() {
   		return "LinkMan [lkmId=" + lkmId + ", lkmName=" + lkmName + ", lkmGender=" + lkmGender + ", lkmPhone="				+ lkmPhone + ", lkmMobile=" + lkmMobile + ", lkmEmail=" + lkmEmail + ", lkmPosition=" + lkmPosition				+ ", lkmMemo=" + lkmMemo + "]";	}}

映射的注解说明

@OneToMany:

作用：建立一对多的关系映射

属性：

targetEntityClass：指定多的多方的类的字节码

mappedBy：指定从表实体类中引用主表对象的名称。

cascade：指定要使用的级联操作

fetch：指定是否采用延迟加载

orphanRemoval：是否使用孤儿删除

@ManyToOne

作用：建立多对一的关系

属性：

targetEntityClass：指定一的一方实体类字节码

cascade：指定要使用的级联操作

fetch：指定是否采用延迟加载

optional：关联是否可选。如果设置为false，则必须始终存在非空关系。

@JoinColumn

作用：用于定义主键字段和外键字段的对应关系。

属性：

name：指定外键字段的名称

referencedColumnName：指定引用主表的主键字段名称

unique：是否唯一。默认值不唯一

nullable：是否允许为空。默认值允许。

insertable：是否允许插入。默认值允许。

updatable：是否允许更新。默认值允许。

columnDefinition：列的定义信息。

一对多的操作

添加

@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("还行吧");		c.getLinkMans().add(l);		l.setCustomer(c);		customerDao.save(c);		linkManDao.save(l);	}}

通过保存的案例，我们可以发现在设置了双向关系之后，会发送两条insert语句，一条多余的update语句，那我们的解决是思路很简单，就是一的一方放弃维护权。

所以，我们只需要在从表配置他们的映射关系即可，否则会出现多余的update语句。

/**	 *放弃外键维护权的配置将如下配置改为	 */    //@OneToMany(targetEntity=LinkMan.class)//@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")	//设置为	@OneToMany(mappedBy="customer")	private Set
   
     linkmans = new HashSet
    
     (0);

删除

@Autowired	private CustomerDao customerDao;		@Test	@Transactional	@Rollback(false)//设置为不回滚	public void testDelete() {
   		customerDao.delete(1l);	}

删除操作的说明如下：

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

删除主表数据：

若有从表数据

1、在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错了。

2、如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null，没有关系）因为在删除时，它根本不会去更新从表的外键字段了。

3、如果还想删除，使用级联删除引用

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

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

级联操作

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

使用方法：只需要在操作主体的注解上配置cascade

/**	 * cascade:配置级联操作	 * 		CascadeType.MERGE	级联更新	 * 		CascadeType.PERSIST	级联保存：	 * 		CascadeType.REFRESH 级联刷新：	 * 		CascadeType.REMOVE	级联删除：	 * 		CascadeType.ALL		包含所有	 */	@OneToMany(mappedBy="customer",cascade=CascadeType.ALL)

JPA中的多对多操作

我们采用的示例为用户和角色。

用户：指的是咱们班的每一个同学。

角色：指的是咱们班同学的身份信息。

比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。

同时B同学，它也具有学生和子女的身份。

那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。

所以我们说，用户和角色之间的关系是多对多。

表关系建立

多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示：

实体类关系建立以及映射配置

一个用户可以具有多个角色，所以在用户实体类中应该包含多个角色的信息，代码如下：

@Entity(targetEntity=Role.class)@Table(name="sys_user")public class SysUser implements Serializable {
   		@Id	@GeneratedValue(strategy=GenerationType.IDENTITY)	@Column(name="user_id")	private Long userId;	@Column(name="user_code")	private String userCode;	@Column(name="user_name")	private String userName;	@Column(name="user_password")	private String userPassword;	@Column(name="user_state")	private String userState;		//多对多关系映射	@ManyToMany(mappedBy="users")	private Set
   
     roles = new HashSet
    
     (0);		public Long getUserId() {
   		return userId;	}	public void setUserId(Long userId) {
   		this.userId = userId;	}	public String getUserCode() {
   		return userCode;	}	public void setUserCode(String userCode) {
   		this.userCode = userCode;	}	public String getUserName() {
   		return userName;	}	public void setUserName(String userName) {
   		this.userName = userName;	}	public String getUserPassword() {
   		return userPassword;	}	public void setUserPassword(String userPassword) {
   		this.userPassword = userPassword;	}	public String getUserState() {
   		return userState;	}	public void setUserState(String userState) {
   		this.userState = userState;	}	public Set
     
       getRoles() {
   		return roles;	}	public void setRoles(Set
      
        roles) {
   		this.roles = roles;	}	@Override	public String toString() {
   		return "SysUser [userId=" + userId + ", userCode=" + userCode + ", userName=" + userName + ", userPassword="				+ userPassword + ", userState=" + userState + "]";	}}

一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息，代码如下：

/** * 角色的数据模型 */@Entity@Table(name="sys_role")public class SysRole implements Serializable {
   		@Id	@GeneratedValue(strategy=GenerationType.IDENTITY)	@Column(name="role_id")	private Long roleId;	@Column(name="role_name")	private String roleName;	@Column(name="role_memo")	private String roleMemo;		//多对多关系映射	@ManyToMany(targetEntity = User.class)	@JoinTable(name="user_role_rel",//中间表的名称			  //中间表user_role_rel字段关联sys_role表的主键字段role_id			  joinColumns={
   @JoinColumn(name="role_id",referencedColumnName="role_id")},			  //中间表user_role_rel的字段关联sys_user表的主键user_id			  inverseJoinColumns={
   @JoinColumn(name="user_id",referencedColumnName="user_id")}	)	private Set
   
     users = new HashSet
    
     (0);			public Long getRoleId() {
   		return roleId;	}	public void setRoleId(Long roleId) {
   		this.roleId = roleId;	}	public String getRoleName() {
   		return roleName;	}	public void setRoleName(String roleName) {
   		this.roleName = roleName;	}	public String getRoleMemo() {
   		return roleMemo;	}	public void setRoleMemo(String roleMemo) {
   		this.roleMemo = roleMemo;	}	public Set
     
       getUsers() {
   		return users;	}	public void setUsers(Set
      
        users) {
   		this.users = users;	}	@Override	public String toString() {
   		return "SysRole [roleId=" + roleId + ", roleName=" + roleName + ", roleMemo=" + roleMemo + "]";	}}

映射注解说明

@ManyToMany

作用：用于映射多对多关系

属性：

cascade：配置级联操作。

fetch：配置是否采用延迟加载。

targetEntity：配置目标的实体类。映射多对多的时候不用写。

@JoinTable

作用：针对中间表的配置

属性：

nam：配置中间表的名称

joinColumns：中间表的外键字段关联当前实体类所对应表的主键字段

inverseJoinColumn：中间表的外键字段关联对方表的主键字段

@JoinColumn

作用：用于定义主键字段和外键字段的对应关系。

属性：

name：指定外键字段的名称

referencedColumnName：指定引用主表的主键字段名称

unique：是否唯一。默认值不唯一

nullable：是否允许为空。默认值允许。

insertable：是否允许插入。默认值允许。

updatable：是否允许更新。默认值允许。

columnDefinition：列的定义信息。

多对多的操作

保存

@Autowired	private UserDao userDao;	@Autowired	private RoleDao roleDao;	/**	 * 需求：	 * 	保存用户和角色	 * 要求：	 * 	创建2个用户和3个角色	 * 	让1号用户具有1号和2号角色(双向的)	 * 	让2号用户具有2号和3号角色(双向的)	 *  保存用户和角色	 * 问题：	 *  在保存时，会出现主键重复的错误，因为都是要往中间表中保存数据造成的。	 * 解决办法：	 * 	让任意一方放弃维护关联关系的权利	 */	@Test	@Transactional  //开启事务	@Rollback(false)//设置为不回滚	public void test1(){
   		//创建对象		SysUser u1 = new SysUser();		u1.setUserName("用户1");		SysRole r1 = new SysRole();		r1.setRoleName("角色1");		//建立关联关系		u1.getRoles().add(r1);		r1.getUsers().add(u1);		//保存		roleDao.save(r1);		userDao.save(u1);	}

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

//放弃对中间表的维护权，解决保存中主键冲突的问题	@ManyToMany(mappedBy="roles")	private Set
   
     users = new HashSet
    
     (0);

删除

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

对象导航查询

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

查询一个客户，获取该客户下的所有联系人

@Autowired	private CustomerDao customerDao;		@Test	//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中	@Transactional 	public void testFind() {
   		Customer customer = customerDao.findOne(5l);		Set
   
     linkMans = customer.getLinkMans();//对象导航查询		for(LinkMan linkMan : linkMans) {
     			System.out.println(linkMan);		}	}

查询一个联系人，获取该联系人的所有客户

@Autowired	private LinkManDao linkManDao;		@Test	public void testFind() {
   		LinkMan linkMan = linkManDao.findOne(4l);		Customer customer = linkMan.getCustomer(); //对象导航查询		System.out.println(customer);	}

对象导航查询的问题分析

问题1：我们查询客户时，要不要把联系人查询出来？

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

解决：采用延迟加载的思想。通过配置的方式来设定当我们在需要使用时，发起真正的查询。（并且在多的一方进行查询，默认会立即加载直接查出一的一方的数据，而在一的一方查询，则会采用延迟加载的方式对多的一方进行查询，即用的时候才会发送sql语句进行查询。）

配置方式：

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

问题2：我们查询联系人时，要不要把客户查询出来？

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

解决：采用立即加载的思想。通过配置的方式来设定，只要查询从表实体，就把主表实体对象同时查出来

配置方式：

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

specifiction的多表查询

/**	 * Specification的多表查询	 */	@Test	public void testFind() {
   		Specification
   
     spec = new Specification
    
     () {
   			public Predicate toPredicate(Root
     
       root, CriteriaQuery
       query, CriteriaBuilder cb) {
   				//Join代表链接查询，通过root对象获取				//创建的过程中，第一个参数为关联对象的属性名称，第二个参数为连接查询的方式（left，inner，right）				//JoinType.LEFT : 左外连接,JoinType.INNER：内连接,JoinType.RIGHT：右外连接				Join
      
        join = root.join("customer",JoinType.INNER);				return cb.like(join.get("custName").as(String.class),"传智播客1");			}		};		List
       
         list = linkManDao.findAll(spec);		for (LinkMan linkMan : list) {
   			System.out.println(linkMan);		}	}