springdatajpa学习-运行原理以及基本操作(2)

最新推荐文章于 2024-03-19 11:05:47 发布

边城jie

最新推荐文章于 2024-03-19 11:05:47 发布

阅读量242

点赞数

分类专栏： springboot 文章标签： springdatajpa学习-运行原理以及基本操作

本文链接：https://blog.csdn.net/weixin_39248420/article/details/103331414

版权

springboot 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

Spring Data JPA理解及特征

什么是Spring Data JPA？
是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现。
Spring Data 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的坐标

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

整合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">

 <!-- 1.dataSource 配置数据库连接池-->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 	<property name="driverClass" value="com.mysql.jdbc.Driver" />
 	<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test" />
 	<property name="user" value="root" />
 	<property name="password" value="111111" />
 </bean>

 <!-- 2.配置entityManagerFactory -->	
 <bean id="entityManagerFactory" 	
 	class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
 	<property name="dataSource" ref="dataSource" />
 	<property name="packagesToScan" value="cn.itcast.entity" />
 	<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" />
 		<property name="showSql" value="true" />
 	</bean>
 </property>
 <property name="jpaDialect">
 	<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
 </property>

使用JPA注解配置映射关系

 @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层接口

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

提供相应的泛型

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操作

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

     @Autowired
     private CustomerDao customerDao;
 
  /**
  *     对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新    
  *     如果执行此方法中对象中不存在id属性，即为保存操作          
  */
 @Test
 public void testUpdate() {
     //根据id查询id为1的客户
     Customer customer = customerDao.findOne(1l);
     //修改客户名称
     customer.setCustName("传智播客顺义校区");
     //更新
     customerDao.save(customer);
 }

 /**
  * 根据id删除：调用delete(id)方法
  */
 @Test
 public void testDelete() {
     customerDao.delete(1l);
 }

 /**
  * 根据id查询：调用findOne(id)方法
  */
 @Test
 public void testFindById() {
     Customer customer = customerDao.findOne(2l);
     System.out.println(customer);
 }
  /**
  * 测试统计查询：查询客户的总数量
  *      count:统计总条数
  */
 @Test
 public void testCount() {
     long count = customerDao.count();//查询全部的客户数量
     System.out.println(count);
 }
  /**
  * 查询所有
  */
 @Test
 public void testFindAll() {
     List<Customer> list = customerDao.findAll();
     for(Customer customer : list) {
         System.out.println(customer);
     }
 }
 /**
  * 测试：判断id为4的客户是否存在
  *      1. 可以查询以下id为4的客户
  *          如果值为空，代表不存在，如果不为空，代表存在
  *      2. 判断数据库中id为4的客户的数量
  *          如果数量为0，代表不存在，如果大于0，代表存在
  */
 @Test
 public void  testExists() {
     boolean exists = customerDao.exists(4l);
     System.out.println("id为4的客户 是否存在："+exists);
 }
 /**
 * 根据id从数据库查询
 *      @Transactional : 保证getOne正常运行
  *
  *  findOne：
  *      em.find()           :立即加载
  *  getOne：
  *      em.getReference     :延迟加载
  *      * 返回的是一个客户的动态代理对象
  *      * 什么时候用，什么时候查询
  */
 @Test
 @Transactional
 public void  testGetOne() {
     Customer customer = customerDao.getOne(4l);
     System.out.println(customer);
 	}
 }

Spring Data JPA内部原理剖析

对于我们自定义的Dao接口，由于继承了JpaRepository和JpaSpecificationExecutor，所以我们可以使用这两个接口的所有方法。
这些方法都只是一些声明，没有具体的实现方式，那么在 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层代码的开发
整个过程代码接口调用
整个流程分析

边城jie

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springdatajpa学习-运行原理以及基本操作(2)

Spring Data JPA理解及特征什么是Spring Data JPA？是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现。Spring Data JPA特征极大简化了数据库访问层代码。使用了SpringDataJpa，dao层中只需要写接口，就自动具有了增删改查、分页查询等方法Sp...
复制链接

扫一扫