Spring Data JPA
Spring Data JPA概述
- Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦
Spring Data JPA的特性
- 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 Data JPA的快速入门
需求
- Spring Data JPA完成客户的基本CRUD操作
搭建Spring Data JPA的开发环境
引入Spring Data JPA的坐标
- 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等
整合Spring Data JPA与Spring
- applicationContext.xml
<!--spring 和 spring data jpa的配置-->
<!-- 1.创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--配置的扫描的包（实体类所在的包） -->
<property name="packagesToScan" value="cn.itcast.domain" />
<!-- 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的方言 ：高级的特性(hibernate的一级缓存二级缓存等) -->
<property name="jpaDialect" >
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<!--2.创建数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="111111"></property>
<property name="jdbcUrl" value="jdbc:mysql:///jpa" ></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3.整合spring dataJpa-->
<jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
<!--4.配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactoty"></property>
</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" ></context:component-scan>
使用JPA注解配置映射关系(编写一个实体类使用注解)
- 所有注解使用jpa的规范提供的注解（都在javax下的引用）
使用Spring Data JPA完成需求
编写符合Spring Data JPA规范的Dao层接口
- Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程
- 在Spring Data JPA中，对于定义符合规范的Dao层接口，我们只需要遵循以下几点就可以了：
- 创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor
- 提供相应的泛型
package cn.itcast.dao;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import cn.itcast.entity.Customer;
/**
* JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
* JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}
完成基本CRUD操作
方法
- findOne（id） ：根据id查询
- save(customer):保存或者更新（依据：传递的实体类对象中，是否包含id属性）
- delete（id） ：根据id删除
- findAll() : 查询全部
使用
- 完成了Spring Data JPA的环境搭建，并且编写了符合Spring Data JPA 规范的Dao层接口之后，就可以使用定义好的Dao层接口进行客户的基本CRUD操作
(SpringJUnit4ClassRunner.class). //声明spring提供的单元测试环境
@ContextConfiguration(locations="classpath:applicationContext.xml") //指定spring容器的配置信息
public class CustomerDaoTest {
private CustomerDao customerDao;
/**
* 保存客户：调用save(obj)方法
*/
public void testSave() {
Customer c = new Customer();
c.setCustName("传智");
customerDao.save(c);
}
/**
* 修改客户：调用save(obj)方法
* 对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新
* 如果执行此方法中对象中不存在id属性，即为保存操作
*
*/
public void testUpdate() {
//根据id查询id为1的客户
Customer customer = customerDao.findOne(1l);
//修改客户名称
customer.setCustName("aa");
//更新
customerDao.save(customer);
}
/**
* 根据id删除：调用delete(id)方法
*/
public void testDelete() {
customerDao.delete(1l);
}
/**
* 根据id从数据库查询
* @Transactional : 保证getOne正常运行
*
* findOne：
* em.find() :立即加载
* getOne：
* em.getReference :延迟加载
* * 返回的是一个客户的动态代理对象
* * 什么时候用，什么时候查询
*/
public void testGetOne() {
Customer customer = customerDao.getOne(4l);
System.out.println(customer);
}
/**
* 查询所有
*/
public void testFindAll() {
List<Customer> list = customerDao.findAll();
for(Customer customer : list) {
System.out.println(customer);
}
}
/**
* 测试统计查询：查询客户的总数量
* count:统计总条数
*/
public void testCount() {
long count = customerDao.count();//查询全部的客户数量
System.out.println(count);
}
/**
* 测试：判断id为4的客户是否存在
* 1. 可以查询以下id为4的客户
* 如果值为空，代表不存在，如果不为空，代表存在
* 2. 判断数据库中id为4的客户的数量
* 如果数量为0，代表不存在，如果大于0，代表存在
*/
public void testExists() {
boolean exists = customerDao.exists(4l);
System.out.println("id为4的客户 是否存在："+exists);
}
}
springDataJpa的运行过程和原理剖析
- 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
- SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CRUD）
- 通过hibernate完成数据库操作（封装了jdbc）
复杂查询
借助接口中的定义好的方法完成查询
- 在继承JpaRepository，和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询
继承JpaRepository后的方法列表
继承JpaSpecificationExecutor的方法列表
jpql的查询方式
- 使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL的语句方式完成查询
- @Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可
public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {
//@Query 使用jpql的方式查询。
(value="from Customer")
public List<Customer> findAllCustomer();
//@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
(value="from Customer where custName = ?1")
public Customer findCustomer(String custName);
}
- 此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询
(value="update Customer set custName = ?1 where custId = ?2")
public void updateCustomer(String custName,Long custId);"
使用SQL语句查询
/**
* nativeQuery : 使用本地sql的方式查询
*/
(value="select * from cst_customer",nativeQuery=true)
public void findSql();
方法命名规则查询
- 方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询
- 按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
//方法命名方式查询（根据客户名称查询客户）
public Customer findByCustName(String custName);
具体的关键字，使用方法和生产成SQL如下表所示
总代码
dao
public interface CustomerDao extends JpaRepository<Customer,Long> ,JpaSpecificationExecutor<Customer> {
/**
* 案例：根据客户名称查询客户
* 使用jpql的形式查询
* jpql：from Customer where custName = ?
*
* 配置jpql语句，使用的@Query注解
*/
(value="from Customer where custName = ?")
public Customer findJpql(String custName);
/**
* 案例：根据客户名称和客户id查询客户
* jpql： from Customer where custName = ? and custId = ?
*
* 对于多个占位符参数
* 赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
*
* 可以指定占位符参数的位置
* ? 索引的方式，指定此占位的取值来源
*/
(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id,String name);
/**
* 使用jpql完成更新操作
* 案例 ： 根据id更新，客户的名称
* 更新4号客户的名称，将名称改为“aaa”
*
* sql ：update cst_customer set cust_name = ? where cust_id = ?
* jpql : update Customer set custName = ? where custId = ?
*
* @Query : 代表的是进行查询
* * 声明此方法是用来进行更新操作
* @Modifying
* * 当前执行的是一个更新操作
*
*/
(value = " update Customer set custName = ?2 where custId = ?1 ")
public void updateCustomer(long custId,String custName);
/**
* 使用sql的形式查询：
* 查询全部的客户
* sql ： select * from cst_customer;
* Query : 配置sql查询
* value ： sql语句
* nativeQuery ： 查询方式
* true ： sql查询
* false：jpql查询
*
*/
//@Query(value = " select * from cst_customer" ,nativeQuery = true)
(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
public List<Object [] > findSql(String name);
/**
* 方法名的约定：
* findBy : 查询
* 对象中的属性名（首字母大写） ： 查询的条件
* CustName
* * 默认情况 ： 使用 等于的方式查询
* 特殊的查询方式
*
* findByCustName -- 根据客户名称查询
*
* 再springdataJpa的运行阶段
* 会根据方法名称进行解析 findBy from xxx(实体类)
* 属性名称 where custName =
*
* 1.findBy + 属性名称 （根据属性名称进行完成匹配的查询=）
* 2.findBy + 属性名称 + “查询方式（Like | isnull）”
* findByCustNameLike
* 3.多条件查询
* findBy + 属性名 + “查询方式” + “多条件的连接符（and|or）” + 属性名 + “查询方式”
*/
public Customer findByCustName(String custName);
public List<Customer> findByCustNameLike(String custName);
//使用客户名称模糊匹配和客户所属行业精准匹配的查询
public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
}
test
(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
private CustomerDao customerDao;
public void testFindJPQL() {
Customer customer = customerDao.findJpql("aaa");
System.out.println(customer);
}
public void testFindCustNameAndId() {
// Customer customer = customerDao.findCustNameAndId("aaa",1l);
Customer customer = customerDao.findCustNameAndId(1l,"aaa");
System.out.println(customer);
}
/**
* 测试jpql的更新操作
* * springDataJpa中使用jpql完成 更新/删除操作
* * 需要手动添加事务的支持
* * 默认会执行结束之后，回滚事务
* @Rollback : 设置是否自动回滚
* false | true
*/
//添加事务的支持
(value = false)
public void testUpdateCustomer() {
customerDao.updateCustomer(4l,"aaa");
}
//测试sql查询
public void testFindSql() {
List<Object[]> list = customerDao.findSql("aaa%");
for(Object [] obj : list) {
System.out.println(Arrays.toString(obj));
}
}
//测试方法命名规则的查询
public void testNaming() {
Customer customer = customerDao.findByCustName("aaa");
System.out.println(customer);
}
//测试方法命名规则的查询
public void testFindByCustNameLike() {
List<Customer> list = customerDao.findByCustNameLike("aaa%");
for (Customer customer : list) {
System.out.println(customer);
}
}
//测试方法命名规则的查询
public void testFindByCustNameLikeAndCustIndustry() {
Customer customer = customerDao.findByCustNameLikeAndCustIndustry("aaa1%", "it");
System.out.println(customer);
}
}
Specifications动态查询
- 有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在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> {
//根据条件查询一个对象
T findOne(Specification<T> spec);
//根据条件查询集合
List<T> findAll(Specification<T> spec);
//根据条件分页查询
//Pageable:分页参数对象
Page<T> findAll(Specification<T> spec, Pageable pageable);
//排序查询查询
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完成条件查询
(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {
private CustomerDao customerDao;
/**
* 根据条件，查询单个对象
*
*/
public void testSpec() {
//匿名内部类
/**
* 自定义查询条件
* 1.实现Specification接口（提供泛型：查询的对象类型）
* 2.实现toPredicate方法（构造查询条件）
* 3.需要借助方法参数中的两个参数（
* root：获取需要查询的对象属性
* CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
* ）
* 案例：根据客户名称查询，查询客户名为传智播客的客户
* 查询条件
* 1.查询方式
* cb对象
* 2.比较的属性名称
* root对象
*
*/
Specification<Customer> spec = new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//1.获取比较的属性
Path<Object> custName = root.get("custId");
//2.构造查询条件 ： select * from cst_customer where cust_name = '传智播客'
/**
* 第一个参数：需要比较的属性（path对象）
* 第二个参数：当前需要比较的取值
*/
Predicate predicate = cb.equal(custName, "aaa");//进行精准的匹配 （比较的属性，比较的属性的取值）
return predicate;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
/**
* 多条件查询
* 案例：根据客户名（aaa）和客户所属行业查询（it）
*
*/
public void testSpec1() {
/**
* root:获取属性
* 客户名
* 所属行业
* cb：构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*/
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");//所属行业
//构造查询
//1.构造客户名的精准匹配查询
Predicate p1 = cb.equal(custName, "aaa");//第一个参数，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);
}
/**
* 案例：完成根据客户名称的模糊匹配，返回客户列表
* 客户名称以 ’aaa‘ 开头
*
* equal ：直接得到path对象（属性），然后进行比较即可
* gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
* 指定参数类型：path.as(类型的字节码对象)
*/
public void testSpec3() {
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//查询属性：客户名
Path<Object> custName = root.get("custName");
//查询方式：模糊匹配
Predicate like = cb.like(custName.as(String.class), "aaa%");
return like;
}
};
// List<Customer> list = customerDao.findAll(spec);
// for (Customer customer : list) {
// System.out.println(customer);
// }
//添加排序
//创建排序对象,需要调用构造方法实例化sort对象
//第一个参数：排序的顺序（倒序，正序）
// Sort.Direction.DESC:倒序
// Sort.Direction.ASC ： 升序
//第二个参数：排序的属性名称
Sort sort = new Sort(Sort.Direction.DESC,"custId");
List<Customer> list = customerDao.findAll(spec, sort);
for (Customer customer : list) {
System.out.println(customer);
}
}
/**
* 分页查询
* Specification: 查询条件
* Pageable：分页参数
* 分页参数：查询的页码，每页查询的条数
* findAll(Specification,Pageable)：带有条件的分页
* findAll(Pageable)：没有条件的分页
* 返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，总条数）
*/
public void testSpec4() {
Specification spec = null;
//PageRequest对象是Pageable接口的实现类
/**
* 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
* 第一个参数：当前查询的页数（从0开始）
* 第二个参数：每页查询的数量
*/
Pageable pageable = new PageRequest(0,2);
//分页查询
Page<Customer> page = customerDao.findAll(null, pageable);
System.out.println(page.getContent()); //得到数据集合列表
System.out.println(page.getTotalElements());//得到总条数
System.out.println(page.getTotalPages());//得到总页数
}
}
基于Specifications的分页查询
public void testPage() {
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.like(root.get("custName").as(String.class), "a%");
}
};
/**
* 构造分页参数
* Pageable : 接口
* PageRequest实现了Pageable接口，调用构造方法的形式构造
* 第一个参数：页码（从0开始）
* 第二个参数：每页查询条数
*/
Pageable pageable = new PageRequest(0, 5);
/**
* 分页查询，封装为Spring Data Jpa 内部的page bean
* 此重载的findAll方法为分页方法需要两个参数
* 第一个参数：查询条件Specification
* 第二个参数：分页参数
*/
Page<Customer> page = customerDao.findAll(spec,pageable);
}
- 对于Spring Data JPA中的分页查询，是其内部自动实现的封装过程，返回的是一个Spring Data JPA提供的pageBean对象
//获取总页数
int getTotalPages();
//获取总记录数
long getTotalElements();
//获取列表数据
List<T> getContent();
方法对应关系
| 方法名称 | Sql对应关系 |
| equle | filed = value |
| gt（greaterThan ） | filed > value |
| lt（lessThan ） | filed < value |
| ge（greaterThanOrEqualTo ） | filed >= value |
| le（ lessThanOrEqualTo） | filed <= value |
| notEqule | filed != value |
| like | filed like value |
| notLike | filed not like value |
JPA中的一对多
在JPA框架中表关系的分析步骤
- 第一步：首先确定两张表之间的关系。
- 如果关系确定错了，后面做的所有操作就都不可能正确。
- 第二步：在数据库中实现两张表的关系（外键｜中间表）
- 第三步：在实体类中描述出两个实体的关系（包含关系）
- 第四步：配置出实体类和数据库表的关系映射
实体类关系建立以及映射配置
- 例如：在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类要体现出客户中有多个联系人的信息，代码如下：
domain和dao
### customer.java
(name="cst_customer")
public class Customer {
(strategy = GenerationType.IDENTITY)
(name="cust_id")
private Long custId;
(name="cust_address")
private String custAddress;
...
//配置客户和联系人之间的关系（一对多关系）
/**
* 使用注解的形式配置多表关系
* 1.声明关系
* @OneToMany : 配置一对多关系
* targetEntity ：对方对象的字节码对象
* 2.配置外键（中间表）
* @JoinColumn : 配置外键
* name：外键字段名称
* referencedColumnName：参照的主表的主键字段名称
*
* * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
*
*/
(targetEntity = LinkMan.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
(mappedBy = "customer",cascade = CascadeType.ALL)
private Set<LinkMan> linkMans = new HashSet<>();
### linkman.java
(name = "cst_linkman")
public class LinkMan {
(strategy = GenerationType.IDENTITY)
(name = "lkm_id")
private Long lkmId; //联系人编号(主键)
(name = "lkm_name")
private String lkmName;//联系人姓名
...
/**
* 配置联系人到客户的多对一关系
* 使用注解的形式配置多对一关系
* 1.配置表关系
* @ManyToOne : 配置多对一关系
* targetEntity：对方的实体类字节码
* 2.配置外键（中间表）
*
* * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
*
*/
(targetEntity = Customer.class,fetch = FetchType.LAZY)
(name = "lkm_cust_id",referencedColumnName = "cust_id")
private Customer customer;
/**
* 联系人的dao接口
*/
public interface LinkManDao extends JpaRepository<LinkMan,Long>, JpaSpecificationExecutor<LinkMan> {
}
...
application.xml添加代码
<!--注入jpa的配置信息
加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
hibernate.hbm2ddl.auto : 自动创建数据库表
create ： 每次都会重新创建数据库表
update：有表不会重新创建，没有表会重新创建表
-->
<property name="jpaProperties" >
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
映射的注解说明
@OneToMany:
- 作用：建立一对多的关系映射
- 属性：
- targetEntityClass：指定多的多方的类的字节码
- mappedBy：指定从表实体类中引用主表对象的名称。
- cascade：指定要使用的级联操作
- fetch：指定是否采用延迟加载
- orphanRemoval：是否使用孤儿删除
@ManyToOne
- 作用：建立多对一的关系
- 属性：
- targetEntityClass：指定一的一方实体类字节码
- cascade：指定要使用的级联操作
- fetch：指定是否采用延迟加载
- optional：关联是否可选。如果设置为false，则必须始终存在非空关系。
@JoinColumn
- 作用：用于定义主键字段和外键字段的对应关系。
- 属性：
- name：指定外键字段的名称
- referencedColumnName：指定引用主表的主键字段名称
- unique：是否唯一。默认值不唯一
- nullable：是否允许为空。默认值允许。
- insertable：是否允许插入。默认值允许。
- updatable：是否允许更新。默认值允许。
- columnDefinition：列的定义信息。
删除
从表数据：可以随时任意删除。
主表数据：
有从表数据
- 在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表 结构上，外键字段有非空约束，默认情况就会报错了。
- 如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null,没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
- 如果还想删除，使用级联删除引用
没有从表数据引用：随便删
test
(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {
private CustomerDao customerDao;
private LinkManDao linkManDao;
/**
* 保存一个客户，保存一个联系人
* 效果：客户和联系人作为独立的数据保存到数据库中
* 联系人的外键为空
* 原因？
* 实体类中没有配置关系
*/
//配置事务
(false) //不自动回滚
public void testAdd() {
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("百度");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("小李");
/**
* 配置了客户到联系人的关系
* 从客户的角度上：发送两条insert语句，发送一条更新语句更新数据库（更新外键）
* 由于我们配置了客户到联系人的关系：客户可以对外键进行维护
*/
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
linkManDao.save(linkMan);
}
//配置事务
(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语句
* * 解决此问题：只需要在一的一方放弃维护权即可
*
*/
//配置事务
(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);
}
级联操作
级联操作：指操作一个对象同时操作它的关联对象
使用方法：只需要在操作主体的注解上配置cascade
/**
* cascade:配置级联操作
* CascadeType.MERGE 级联更新
* CascadeType.PERSIST 级联保存：
* CascadeType.REFRESH 级联刷新：
* CascadeType.REMOVE 级联删除：
* CascadeType.ALL 包含所有
*/
(mappedBy="customer",cascade=CascadeType.ALL)
private Set<LinkMan> linkMans = new HashSet<>();
JPA中的多对多
映射的注解说明
@ManyToMany
- 作用：用于映射多对多关系
- 属性：
- cascade：配置级联操作。
- fetch：配置是否采用延迟加载。
- targetEntity：配置目标的实体类。映射多对多的时候不用写。
@JoinTable
- 作用：针对中间表的配置
- 属性：
- nam：配置中间表的名称
- joinColumns：中间表的外键字段关联当前实体类所对应表的主键
- inverseJoinColumn：中间表的外键字段关联对方表的主键字段
@JoinColumn
- 作用：用于定义主键字段和外键字段的对应关系。
- 属性：
- name：指定外键字段的名称
- referencedColumnName：指定引用主表的主键字段名称
- unique：是否唯一。默认值不唯一
- nullable：是否允许为空。默认值允许。
- insertable：是否允许插入。默认值允许。
- updatable：是否允许更新。默认值允许。
- columnDefinition：列的定义信息。
示例代码
domain
### user.java
(name = "sys_user")
public class User {
(strategy = GenerationType.IDENTITY)
(name="user_id")
private Long userId;
(name="user_name")
private String userName;
(name="age")
private Integer age;
/**
* 配置用户到角色的多对多关系
* 配置多对多的映射关系
* 1.声明表关系的配置
* @ManyToMany(targetEntity = Role.class) //多对多
* targetEntity：代表对方的实体类字节码
* 2.配置中间表（包含两个外键）
* @JoinTable
* name : 中间表的名称
* joinColumns：配置当前对象在中间表的外键
* @JoinColumn的数组
* name：外键名
* referencedColumnName：参照的主表的主键名
* inverseJoinColumns：配置对方对象在中间表的外键
*/
(targetEntity = Role.class,cascade = CascadeType.ALL)
(name = "sys_user_role",
//joinColumns,当前对象在中间表中的外键
joinColumns = {(name = "sys_user_id",referencedColumnName = "user_id")},
//inverseJoinColumns，对方对象在中间表的外键
inverseJoinColumns = {(name = "sys_role_id",referencedColumnName = "role_id")}
)
private Set<Role> roles = new HashSet<>();
### role.java
(name = "sys_role")
public class Role {
(strategy = GenerationType.IDENTITY)
(name = "role_id")
private Long roleId;
(name = "role_name")
private String roleName;
(name = "sys_user_role",
//joinColumns,当前对象在中间表中的外键
joinColumns = {(name = "sys_role_id",referencedColumnName = "role_id")},
//inverseJoinColumns，对方对象在中间表的外键
inverseJoinColumns = {(name = "sys_user_id",referencedColumnName = "user_id")}
private Set<User> users = new HashSet<>();
test
(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {
private UserDao userDao;
private RoleDao roleDao;
/**
* 保存一个用户，保存一个角色
*
* 多对多放弃维护权：被动的一方放弃
*/
(false)
public void testAdd() {
User user = new User();
user.setUserName("小李");
Role role = new Role();
role.setRoleName("java程序员");
//配置用户到角色关系，可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);
//配置角色到用户的关系，可以对中间表的数据进行维护 1-1
role.getUsers().add(user);
userDao.save(user);
roleDao.save(role);
}
//测试级联添加（保存一个用户的同时保存用户的关联角色）
(false)
public void testCasCadeAdd() {
User user = new User();
user.setUserName("小李");
Role role = new Role();
role.setRoleName("java程序员");
//配置用户到角色关系，可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);
//配置角色到用户的关系，可以对中间表的数据进行维护 1-1
role.getUsers().add(user);
userDao.save(user);
}
/**
* 案例：删除id为1的用户，同时删除他的关联对象
*/
(false)
public void testCasCadeRemove() {
//查询1号用户
User user = userDao.findOne(1l);
//删除1号用户
userDao.delete(user);
}
}
- 在多对多（保存）中，如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的2个字段又作为联合主键，所以报错，主键重复，解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃
//放弃对中间表的维护权，解决保存中主键冲突的问题
(mappedBy="roles")
private Set<SysUser> users = new HashSet<SysUser>(0);
- 删除
private UserDao userDao;
/**
* 删除操作
* 在多对多的删除时，双向级联删除根本不能配置
* 禁用
* 如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据
*/
(false)//设置为不回滚
public void testDelete() {
userDao.delete(1l);
}
Spring Data JPA中的多表查询
对象导航查询
对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。例如：我们通过ID查询方式查出一个客户，可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人。对象导航查询的使用要求是：两个对象之间必须存在关联关系
查询一个客户，获取该客户下的所有联系人
private CustomerDao customerDao;
//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中
public void testFind() {
Customer customer = customerDao.findOne(5l);
Set<LinkMan> linkMans = customer.getLinkMans();//对象导航查询
for(LinkMan linkMan : linkMans) {
System.out.println(linkMan);
}
}
- 查询一个联系人，获取该联系人的所有客户
private LinkManDao linkManDao;
public void testFind() {
LinkMan linkMan = linkManDao.findOne(4l);
Customer customer = linkMan.getCustomer(); //对象导航查询
System.out.println(customer);
}
延迟加载
- 延迟加载的思想。通过配置的方式来设定当我们在需要使用时，发起真正的查询。
- 对象导航查询默认使用的是延迟加载的形式查询的
/**
* 在客户对象的@OneToMany注解中添加fetch属性
* FetchType.EAGER ：立即加载
* FetchType.LAZY ：延迟加载
*/
(mappedBy="customer",fetch=FetchType.EAGER)
private Set<LinkMan> linkMans = new HashSet<>(0);
使用Specification查询
/**
* Specification的多表查询
*/
public void testFind() {
Specification<LinkMan> spec = new Specification<LinkMan>() {
public Predicate toPredicate(Root<LinkMan> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//Join代表链接查询，通过root对象获取
//创建的过程中，第一个参数为关联对象的属性名称，第二个参数为连接查询的方式（left，inner，right）
//JoinType.LEFT : 左外连接,JoinType.INNER：内连接,JoinType.RIGHT：右外连接
Join<LinkMan, Customer> join = root.join("customer",JoinType.INNER);
return cb.like(join.get("custName").as(String.class),"传智播客1");
}
};
List<LinkMan> list = linkManDao.findAll(spec);
for (LinkMan linkMan : list) {
System.out.println(linkMan);
}
}
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
