什么是 Spring Data JPA
Spring Data JPA 概述
Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套 JPA 应用框架,可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能,且易于扩展!学习并使用 Spring Data JPA 可以极大提高开发效率!
Spring Data JPA 让我们解脱了 DAO 层的操作,基本上所有 CRUD 都可以依赖于它来实现,在实际的工作工程中,推荐使用 Spring Data JPA + ORM(如:hibernate)完成操作,这样在切换不同的 ORM 框架时提供了极大的方便,同时也使数据库层操作更加简单,方便解耦
Spring Data JPA 与 JPA 和 Hibernate 之间的关系
JPA 是一套规范,内部是有接口和抽象类组成的。hibernate 是一套成熟的 ORM 框架,而且 Hibernate 实现了 JPA 规范,所以也可以称 hibernate 为 JPA 的一种实现方式,我们使用 JPA 的 API 编程,意味着站在更高的角度上看待问题(面向接口编程)
Spring Data JPA 是 Spring 提供的一套对 JPA 操作更加高级的封装,是在 JPA 规范下的专门用来进行数据持久化的解决方案。
Spring Data JPA 最佳实践
创建 maven 项目,添加项目依赖
<properties>
<spring.version>5.2.6.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>8.0.19</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>
<!-- spring对orm框架的支持包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- spring data jpa 的坐标-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>2.3.4
.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 -->
</dependencies>
复制代码
2.创建配置文件,进行 applicationContext.xml 配置,所有的类由 Spring 管理
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa的配置-->
<!-- 配置包扫描-->
<context:component-scan base-package="com.citi" ></context:component-scan>
<!-- 1.创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--配置的扫描的包(实体类所在的包) -->
<property name="packagesToScan" value="com.citi.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>
<!--2.创建数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&serverTimezone=Asia/Shanghai" ></property>
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
</bean>
<!--3.整合spring dataJpa-->
<jpa:repositories base-package="com.citi.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(* com.citi.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
</beans>
复制代码
3.在 entity 包中新建实体类 Customer,配置实体类与表,属性与字段映射关系
@Entity //表示是一个实体类
@Table(name = "customer") //映射的表明
public class Customer {
@Id//声明主键
@GeneratedValue(strategy = GenerationType.IDENTITY)//声明主键生成策略
@Column(name = "cust_id") //属性和字段映射
private Long custId;
@Column(name = "cust_name")
private String custName;
@Column(name = "cust_source")
private String custSource;
@Column(name = "cust_level")
private String custLevel;
@Column(name = "cust_industry")
private String custIndustry;
@Column(name = "cust_phone")
private String custPhone;
@Column(name = "cust_address")
private String custAddress;
// 此处省略getter/setter/toString方法
}
复制代码
4.在 dao 层创建 CustomerDao 接口类,并继承 JpaRepository 及 JpaSpecificationExecutor
/**
* JpaRepository泛型第一个是操作的实体类,第二个泛型是主键的类型
*/
public interface CustomerDao extends JpaRepository<Customer,Long>,JpaSpecificationExecutor<Customer> {
}
复制代码
5.在 test 包创建 CustomerDaoTest 测试类,创建 testFindById 方法
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
/**
* 根据ID查询
*/
@Test
public void testFindById(){
Customer customer = customerDao.findOne(2l);
System.out.println(customer);
}
}
复制代码
save()保存或者更新操作
@Test
public void testSave(){
// 保存或更新,数据存在就更新,不存在就新建
Customer customer = new Customer();
customer.setCustName("Thor");
customer.setCustSource("Asgard");
customer.setCustLevel("VIP");
customer.setCustIndustry("God of Thunder");
customerDao.save(customer);
}
@Test
public void testUpdate(){
// 保存或更新,数据存在就更新,不存在就新建
Customer customer = customerDao.findOne(3l);
customer.setCustSource("INS");
customerDao.save(customer);
}
复制代码
delete()删除操作
@Test
public void testDelete(){
customerDao.delete(3l);
}
复制代码
findAll()查询所有操作
@Test
public void testFindAll(){
List<Customer> customerList = customerDao.findAll();
for (Customer customer : customerList) {
System.out.println(customer);
}
}
复制代码
执行过程
I:实例化的 customerDao 是一个动态代理对象 SimpleJpaRepository
II:SimpleJpaRepository 调用 findOne()方法,findOne()会通过实体类管理器 em 调用 find()方法完成查询
Spring Data JPA 完成复杂查询
统计查询 count()
@Test
public void testCount(){
long count = customerDao.count();
System.out.println(count);
}
复制代码
是否存在 exists()
@Test
public void testExists(){
boolean isExists = customerDao.exists(1l);
System.out.println(isExists);
}
复制代码
根据 ID 查询 getOne()
@Test
@Transactional
public void testGetOne(){
Customer one = customerDao.getOne(1l);
System.out.println(one);
}
复制代码
底层调用的是 EntityManager 的 getReference(),延迟加载,find()是立即加载
JPA 中的查询方法:
使用 JPQL 完成复杂查询
JPQL:JPA Query Language
特点:语法或关键字与 sql 语句类似,查询的是类和类中的属性
需要将 JPQL 语句配置到接口方法上
在 CustomerDao 接口中新增方法,根据客户名称查询客户,使用 JPQL 语句
@Query(value = "from Customer where custName= ?")
Customer findByCustName(String custName);
复制代码
在 CustomerDao 中测试该方法
@Test
public void testFindByCustName(){
Customer thor = customerDao.findByCustName("Thor");
System.out.println(thor);
}
复制代码
输出结果
多条件(多占位符)查询
在 CustomerDao 接口中新增方法
// 根据客户名称和id查询客户
@Query(value = "from Customer where custName = ? and custId=?")
Customer findByCustNameAndCustId(String custName, Long custId);
复制代码
在 CustomerDaoTest 中测试该方法
@Test
public void testFindByCustNameAndCustId(){
Customer thor = customerDao.findByCustNameAndCustId("Thor",3L);
System.out.println(thor);
}
复制代码
通过 custId 更新 custName
CustomerDao 接口中新增方法 updateCustNameByCustId
// 要指定参数位置
// 声明为更新操作
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying
@Transactional
void updateCustNameByCustId(Long custId, String custName);
复制代码
在 CustomerDaoTest 中测试该方法
@Test
public void testUpdateCustName(){
customerDao.updateCustNameByCustId(3L,"Thor Odin");
}
复制代码
使用 SQL 语句完成复杂查询
特有的查询,需要在 dao 接口上配置方法
在新添加的方法上,使用注解的形式配置 SQL 查询语句
注解为 @Query(value=,nativeQuery=),value 表示 jpql 语句或者 sql 语句,nativeQuery 为 boolean,false 表示使用 jpql 查询,true 表示 sql 查询
SQL 语句查询全部
定义方法 selectAll()
@Query(value = "SELECT * FROM customer", nativeQuery = true)
List<Customer> selectAll();
复制代码
测试该方法
@Test
public void testSelectAll(){
List<Customer> customers = customerDao.selectAll();
for (Customer customer : customers) {
System.out.println(customer);
}
}
复制代码
输出结果
SQL 语句模糊查询
定义方法 selectByCustNameLike
@Query(value = "SELECT * FROM customer where cust_name like ?1", nativeQuery = true)
List<Customer> selectByCustNameLike(String like);
复制代码
测试该方法
@Test
public void testSelectByCustNameLike(){
List<Customer> customers = customerDao.selectByCustNameLike("Thor%");
for (Customer customer : customers) {
System.out.println(customer);
}
}
复制代码
输出结果
方法名称规则查询
是对 jpql 查询更加深入的一层封装,只需要按照 Spring Data JPA 提供的方法名规则定义方法,不需要在配置 jpql 语句即可完成查询
命名规则:查询使用 findBy,对象中的属性为查询的条件,如想要通过 custName 查询 Customer,方法名命名为 findByCustName,入参为 custName,翻译成 sql 语句就是 select * from customer where cust_name = ?,默认使用=,如果是模糊查询需要 Like 关键字
findByCustName
Customer findByCustName(String custName);
复制代码
@Test
public void testFindByCustName(){
Customer thor = customerDao.findByCustName("Thor Odin");
System.out.println(thor);
}
复制代码
输出结果
findByCustNameLike 模糊查询
List<Customer> findByCustNameLike(String custName);
复制代码
@Test
public void testFindByCustNameLike(){
List<Customer> customers = customerDao.findByCustNameLike("Thor%");
for (Customer customer : customers) {
System.out.println(customer);
}
}
复制代码
输出结果
findByCustNameAndCustId 多条件查询使用 And 关键字,查询的属性的顺序要与入参顺序一致
Customer findByCustNameLikeAndCustIndustry(String custName, String custIndustry);
复制代码
@Test
public void testFindByCustNameLikeAndCustIndustry(){
Customer stark_industry = customerDao.findByCustNameLikeAndCustIndustry("Iron%", "Military Industry");
System.out.println(stark_industry);
}
复制代码
评论