1、Spring Data Jpa

概述

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

SpringDataJpa、JPA和Hibernate的关系

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

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

案例说明

创建maven工程并导入坐标

<properties><spring.version>4.2.4.RELEASE</spring.version><hibernate.version>5.0.7.Final</hibernate.version><slf4j.version>1.7.30</slf4j.version><log4j.version>2.12.1</log4j.version><c3p0.version>0.9.1.2</c3p0.version><mysql.version>8.0.16</mysql.version>
</properties><dependencies><!-- junit单元测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!-- spring beg --><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.6.8</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version></dependency><!-- spring end --><!-- hibernate beg --><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>${hibernate.version}</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-entitymanager</artifactId><version>${hibernate.version}</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-validator</artifactId><version>5.2.1.Final</version></dependency><!-- hibernate end --><!-- c3p0 beg --><dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>${c3p0.version}</version></dependency><!-- c3p0 end --><!-- log end --><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>${log4j.version}</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>${slf4j.version}</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j.version}</version></dependency><!-- log end --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-jpa</artifactId><version>1.9.0.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>${spring.version}</version></dependency><!-- el beg 使用spring data jpa 必须引入 --><dependency><groupId>javax.el</groupId><artifactId>javax.el-api</artifactId><version>2.2.4</version></dependency><dependency><groupId>org.glassfish.web</groupId><artifactId>javax.el</artifactId><version>2.2.4</version></dependency><!-- el end --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.12</version></dependency>
</dependencies>

编写Spring的配置文件

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

创建实体类

package com.hzp.entity;import javax.persistence.*;/*** 配置实体类和表的映射关系* @Entity：表明这是一个实体类* @Table：映射的数据库表* 配置属性和字段的映射关系* @Id：配置主键* @GeneratedValue：配置主键的生成策略* @Column：映射的字段*/
@Entity
@Table(name = "cst_customer")
public class Customer {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name = "cust_id")private Long custId;@Column(name = "cust_address")private String custAddress;@Column(name = "cust_industry")private String custIndustry;@Column(name = "cust_level")private String custLevel;@Column(name = "cust_name")private String custName;@Column(name = "cust_phone")private String custPhone;@Column(name = "cust_source")private String custSource;public Customer() {}public Customer(String custAddress, String custIndustry, String custLevel, String custName, String custPhone, String custSource) {this.custAddress = custAddress;this.custIndustry = custIndustry;this.custLevel = custLevel;this.custName = custName;this.custPhone = custPhone;this.custSource = custSource;}public Long getCustId() {return custId;}public void setCustId(Long custId) {this.custId = custId;}public String getCustAddress() {return custAddress;}public void setCustAddress(String custAddress) {this.custAddress = custAddress;}public String getCustIndustry() {return custIndustry;}public void setCustIndustry(String custIndustry) {this.custIndustry = custIndustry;}public String getCustLevel() {return custLevel;}public void setCustLevel(String custLevel) {this.custLevel = custLevel;}public String getCustName() {return custName;}public void setCustName(String custName) {this.custName = custName;}public String getCustPhone() {return custPhone;}public void setCustPhone(String custPhone) {this.custPhone = custPhone;}public String getCustSource() {return custSource;}public void setCustSource(String custSource) {this.custSource = custSource;}@Overridepublic String toString() {return "Customer{" +"custId=" + custId +", custAddress='" + custAddress + '\'' +", custIndustry='" + custIndustry + '\'' +", custLevel='" + custLevel + '\'' +", custName='" + custName + '\'' +", custPhone='" + custPhone + '\'' +", custSource='" + custSource + '\'' +'}';}
}

编写符合Spring Data Jpa的dao接口

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

测试，查询单个客户

@RunWith(SpringJUnit4ClassRunner.class)  //spring提供的测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定spring的配置信息的位置
public class JpaTest {@Autowiredprivate CustomerDao customerDao;/*** 查询某个客户*/@Testpublic void testFindOne(){Customer customer = customerDao.findOne(1L);System.out.println(customer);}
}

测试，添加或修改用户

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

删除客户

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

查询所有

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

查询客户的数量

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

查询客户是否存在

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

根据id查询用户

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

2、执行流程分析

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

我们进入JdkDynamicAopProxy查看此类：

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object oldProxy = null;boolean setProxyContext = false;TargetSource targetSource = this.advised.targetSource;Class<?> targetClass = null;Object target = null;Boolean var10;try {if (this.equalsDefined || !AopUtils.isEqualsMethod(method)) {if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {Integer var18 = this.hashCode();return var18;}Object retVal;if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {retVal = AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);return retVal;}if (this.advised.exposeProxy) {oldProxy = AopContext.setCurrentProxy(proxy);setProxyContext = true;}target = targetSource.getTarget();if (target != null) {targetClass = target.getClass();}List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);if (chain.isEmpty()) {Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);} else {MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);retVal = invocation.proceed();}Class<?> returnType = method.getReturnType();if (retVal != null && retVal == target && returnType.isInstance(proxy) && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {retVal = proxy;} else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);}Object var13 = retVal;return var13;}var10 = this.equals(args[0]);} finally {if (target != null && !targetSource.isStatic()) {targetSource.releaseTarget(target);}if (setProxyContext) {AopContext.setCurrentProxy(oldProxy);}}return var10;}

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

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

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

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

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

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

3、JPQL查询

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

通过客户名称查询

   /*** 根据客户名称查询：* jpql:from Customer where custName=?*/@Query(value = "from Customer where custName=?")Customer findJpql(String custName);/*** 根据客户名称查询客户*/@Testpublic void testFindJpal(){Customer customer = customerDao.findJpql("天行者");System.out.println(customer);}

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

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

通过客户id修改客户

/*** 根据id进行更新*/@Query(value = "update Customer set custName=?2 where custId=?1")@Modifying  //表明这是一个更新操作void jpqlUpdate(Long id,String name);@Test@Transactional  //修改和删除需要提供事务的支持@Rollback(value = false)  //不设置默认回滚public void testUpdate(){customerDao.jpqlUpdate(1L, "天行者2号");}

4、sql查询

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

查询全部

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

模糊查询

/*** 模糊查询*/@Query(value = "select * from cst_customer where cust_name like ?",nativeQuery = true)List<Customer> findLike(String name);@Testpublic void testFindLike(){List<Customer> customers = customerDao.findLike("天行者%");for (Customer customer : customers) {System.out.println(customer);}}

5、方法命名规则查询

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

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

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

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

     /*** 基本查询*/Customer findByCustNameAndAndCustId(String custName,Long custId);@Testpublic void testFindByCustNameAndCustId(){Customer customer = customerDao.findByCustNameAndAndCustId("天行者2号", 1L);System.out.println(customer);}

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

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

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

 /*** 多条件查询*/Customer findByCustNameLikeAndCustId(String name,Long id);@Testpublic void testCondition(){Customer customer = customerDao.findByCustNameLikeAndCustId("天行者%", 1L);System.out.println(customer);}

6、Specification动态查询

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

public interface JpaSpecificationExecutor<T> {T findOne(Specification<T> var1);List<T> findAll(Specification<T> var1);Page<T> findAll(Specification<T> var1, Pageable var2);List<T> findAll(Specification<T> var1, Sort var2);long count(Specification<T> var1);
}

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

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

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

根据客户名称进行查询

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

多条件查询

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

模糊查询

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

排序

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

分页

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

7、多表查询

一对多

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

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

编写实体类

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

package com.hzp.entity;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;import javax.persistence.*;/*** @ClassName LinkMan* @Description* @Author HuangZhaoPeng* @Date 2020/10/13 15:02* @Version 1.0*/
@Data
@NoArgsConstructor
@AllArgsConstructor@Entity
@Table(name = "cst_linkman")
public class LinkMan {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name = "lkm_id")private Long lkmId; //联系人编号(主键)@Column(name = "lkm_name")private String lkmName;//联系人姓名@Column(name = "lkm_gender")private String lkmGender;//联系人性别@Column(name = "lkm_phone")private String lkmPhone;//联系人办公电话@Column(name = "lkm_mobile")private String lkmMobile;//联系人手机@Column(name = "lkm_email")private String lkmEmail;//联系人邮箱@Column(name = "lkm_position")private String lkmPosition;//联系人职位@Column(name = "lkm_memo")private String lkmMemo;//联系人备注/*** 配置多对一关系*/@ManyToOne(targetEntity = Customer.class)@JoinColumn(name = "cust_link_id",referencedColumnName = "cust_id")private Customer customer;
}

测试

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

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

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

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

级联

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

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

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

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

测试级联删除

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

我出现了如下问题：

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

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

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

再次测试

多对多

创建用户和角色实体类

@Entity
@Table(name = "sys_user")
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name = "user_id")private Long userId;@Column(name = "user_name")private String userName;@Column(name = "user_age")private Integer userAge;/***配置多对多的关系* @ManyToMany:配置多对多关系* @JoinTable：配置中间表*      name：中间表的名称*      joinColumns:配置当前对象在中间表的外键*      inverseJoinColumns：配置对方对象在中间表的位置*/@ManyToMany(targetEntity = Role.class)@JoinTable(name = "sys_user_role",joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")})private Set<Role> roles=new HashSet<Role>();public Set<Role> getRoles() {return roles;}public void setRoles(Set<Role> roles) {this.roles = roles;}public Long getUserId() {return userId;}public void setUserId(Long userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public Integer getUserAge() {return userAge;}public void setUserAge(Integer userAge) {this.userAge = userAge;}@Overridepublic String toString() {return "User{" +"userId=" + userId +", userName='" + userName + '\'' +", userAge=" + userAge +", roles=" + roles +'}';}
}

@Entity
@Table(name = "sys_role")
public class Role {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name = "role_id")private Long roleId;@Column(name = "role_name")private String roleName;@ManyToMany(targetEntity = User.class)@JoinTable(name = "sys_user_role",joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")})private Set<User> users=new HashSet<User>();public Set<User> getUsers() {return users;}public void setUsers(Set<User> users) {this.users = users;}public Long getRoleId() {return roleId;}public void setRoleId(Long roleId) {this.roleId = roleId;}public String getRoleName() {return roleName;}public void setRoleName(String roleName) {this.roleName = roleName;}@Overridepublic String toString() {return "Role{" +"roleId=" + roleId +", roleName='" + roleName + '\'' +", users=" + users +'}';}
}

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

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

测试级联

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

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

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

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

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

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

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

SpringDataJpa学习

SpringDataJPA学习笔记相关推荐

SpringDataJPA学习记录(干货较多)
SpringDataJPA学习笔记 0. 第零部分 (前言) 全文基于哔站图灵教育的SpringDataJpa课程的学习笔记,同时文章末尾会附有github上传的基于SpringBoot+Spring ...
PyTorch 学习笔记（六）：PyTorch hook 和关于 PyTorch backward 过程的理解 call
您的位置首页 PyTorch 学习笔记系列 PyTorch 学习笔记(六):PyTorch hook 和关于 PyTorch backward 过程的理解发布: 2017年8月4日 7,195阅读 ...
容器云原生DevOps学习笔记——第三期：从零搭建CI/CD系统标准化交付流程
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
容器云原生DevOps学习笔记——第二期：如何快速高质量的应用容器化迁移
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
2020年Yann Lecun深度学习笔记（下）
2020年Yann Lecun深度学习笔记(下)
2020年Yann Lecun深度学习笔记（上）
2020年Yann Lecun深度学习笔记(上)
知识图谱学习笔记（1）
知识图谱学习笔记第一部分,包含RDF介绍,以及Jena RDF API使用知识图谱的基石:RDF RDF(Resource Description Framework),即资源描述框架,其本质是一个 ...
计算机基础知识第十讲,计算机文化基础（第十讲）学习笔记
计算机文化基础(第十讲)学习笔记采样和量化PictureElement Pixel(像素)(链接: 采样的实质就是要用多少点(这个点我们叫像素)来描述一张图像,比如,一幅420x570的图像,就表示 ...
Go 学习推荐 —（Go by example 中文版、Go 构建 Web 应用、Go 学习笔记、Golang常见错误、Go 语言四十二章经、Go 语言高级编程）
Go by example 中文版 Go 构建 Web 应用 Go 学习笔记:无痕 Go 标准库中文文档 Golang开发新手常犯的50个错误 50 Shades of Go: Traps, Gotc ...
MongoDB学习笔记(入门)
MongoDB学习笔记(入门) 一.文档的注意事项: 1. 键值对是有序的,如:{ "name" : "stephen", "genda" ...

SpringDataJPA学习笔记