看Spring Data如何简化数据操作

拼搏现实的明天。 2022-02-24 14:44 127阅读 0赞

# Spring Data 概述 #

## Spring Data ##

用于简化数据库访问，支持NoSQL 和 关系数据存储，其主要目标是使数据库的访问变得方便快捷。  
SpringData 项目所支持 NoSQL 存储：  
MongoDB （文档数据库）  
Neo4j（图形数据库）  
Redis（键/值存储）  
Hbase（列族数据库）  
SpringData 项目所支持的关系数据存储技术：  
JDBC  
JPA

## Spring Data JPA ##

JPA Spring Data : 致力于减少数据访问层 (DAO) 的开发量. 开发者唯一要做的，就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！

## 开发步骤 ##

配置 Spring 整合 JPA

在 Spring 配置文件中配置 Spring Data，让 Spring 为声明的接口创建代理对象，配置了 \\<jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

声明持久层的接口，该接口继承 Repository，Repository 是一个标记型接口，它不包含任何方法，如必要，Spring Data 可实现 Repository 其他子接口，其中定义了一些常用的增删改查，以及分页相关的方法。

在接口中声明需要的方法，Spring Data 将根据给定的策略来为其生成实现代码。

## 搭建环境 ##

导包：

antlr-2.7.7.jar  
c3p0-0.9.2.1.jar  
com.springsource.net.sf.cglib-2.2.0.jar  
com.springsource.org.aopalliance-1.0.0.jar  
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar  
commons-logging-1.1.3.jar  
dom4j-1.6.1.jar  
hamcrest-core-1.3.jar  
hibernate-c3p0-4.2.4.Final.jar  
hibernate-commons-annotations-4.0.2.Final.jar  
hibernate-core-4.2.4.Final.jar  
hibernate-entitymanager-4.2.4.Final.jar  
hibernate-jpa-2.0-api-1.0.1.Final.jar  
javassist-3.15.0-GA.jar  
jboss-logging-3.1.0.GA.jar  
jboss-transaction-api\_1.1\_spec-1.0.1.Final.jar  
junit-4.12.jar  
mchange-commons-java-0.2.3.4.jar  
mysql-connector-java-5.1.7-bin.jar  
slf4j-api-1.6.1.jar  
spring-aop-4.0.0.RELEASE.jar  
spring-aspects-4.0.0.RELEASE.jar  
spring-beans-4.0.0.RELEASE.jar  
spring-context-4.0.0.RELEASE.jar  
spring-core-4.0.0.RELEASE.jar  
spring-data-commons-1.6.2.RELEASE.jar  
spring-data-jpa-1.4.2.RELEASE.jar  
spring-expression-4.0.0.RELEASE.jar  
spring-jdbc-4.0.0.RELEASE.jar  
spring-orm-4.0.0.RELEASE.jar  
spring-tx-4.0.0.RELEASE.jar  
spring-web-4.0.0.RELEASE.jar  
spring-webmvc-4.0.0.RELEASE.jar

applicationContext.xml

<?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:context="http://www.springframework.org/schema/context"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:jpa="http://www.springframework.org/schema/data/jpa"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
        <context:component-scan base-package="com.kernel.spring.data"/>
        
        <context:property-placeholder location="classpath:db.properties"/>
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="${jdbc.driverClass}"/>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
            <property name="user" value="${jdbc.user}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
        
        <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <property name="jpaVendorAdapter">
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
            </property>
            <property name="packagesToScan" value="com.kernel.spring.data"/>
            <property name="jpaProperties">
                <props>
                    
                    <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                    
                    <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                    <prop key="hibernate.show_sql">true</prop>
                    <prop key="hibernate.format_sql">true</prop>
                    <prop key="hibernate.hbm2ddl.auto">update</prop>
                </props>
            </property>
        </bean>
        
        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactory"/>
        </bean>
        
        <tx:annotation-driven transaction-manager="transactionManager"/>
        
        <jpa:repositories base-package="com.kernel.spring.data" entity-manager-factory-ref="entityManagerFactory"/>
    </beans>

# Repository 接口 #

Repository 接口是 Spring Data 的一个核心接口，不提供任何方法，只要遵循接口方法定义规范，就无需写实现类，与继承 Repository 接口等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定domainClass 和 idClass 属性。

## Repository 的子接口 ##

Repository： 仅仅是一个标识，表明任何继承它的均为仓库接口类。

CrudRepository： 继承 Repository，实现了一组 CRUD 相关的方法 。

PagingAndSortingRepository： 继承 CrudRepository，实现了一组分页排序相关的方法 。

JpaRepository： 继承 PagingAndSortingRepository，实现一组 JPA 规范相关的方法 。

自定义的 XxxxRepository 需要继承 JpaRepository，这样的 XxxxRepository 接口就具备了通用的数据访问控制层的能力。

JpaSpecificationExecutor： 不属于Repository体系，实现一组 JPA Criteria 查询相关的方法 。

## Spring Data 方法定义规范 ##

简单条件查询，查询某一个实体或者集合，查询方法以 get、find、read 开头，涉及条件查询时，条件的属性用关键字连接，条件属性以首字母大写。

例如

public interface PersonRepository extends Repository<Person, Integer> {
        Person getByLastName(String lastName);
    
        List<Person> getByLastNameStartingWithAndIdLessThan(String lastName, Integer id);
    
        List<Person> getByLastNameEndingWithAndIdLessThan(String lastName, Integer id);
    
        List<Person> getByEmailInAndAgeLessThan(List list, Integer id);
    
        List<Person> getByAddress_IdGreaterThan(Integer id);
    }

Spring Data 支持的关键字

<table> 
 <thead> 
  <tr> 
   <th>Keyword</th> 
   <th>Sample</th> 
   <th>JPQL snippet</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>And</td> 
   <td>findByLastnameAndFirstname</td> 
   <td>… where x.lastname = ?1 and x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td>Or</td> 
   <td>findByLastnameOrFirstname</td> 
   <td>… where x.lastname = ?1 or x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td>Is,Equals</td> 
   <td>findByFirstname,findByFirstnameIs,findByFirstnameEquals</td> 
   <td>… where x.firstname = 1?</td> 
  </tr> 
  <tr> 
   <td>Betwee</td> 
   <td>findByStartDateBetween</td> 
   <td>… where x.startDate between 1? and ?2</td> 
  </tr> 
  <tr> 
   <td>LessThan</td> 
   <td>findByAgeLessThan</td> 
   <td>… where x.age &lt; ?1</td> 
  </tr> 
  <tr> 
   <td>LessThanEqual</td> 
   <td>findByAgeLessThanEqual</td> 
   <td>… where x.age &lt;= ?1</td> 
  </tr> 
  <tr> 
   <td>GreaterThan</td> 
   <td>findByAgeGreaterThan</td> 
   <td>… where x.age &gt; ?1</td> 
  </tr> 
  <tr> 
   <td>GreaterThanEqual</td> 
   <td>findByAgeGreaterThanEqual</td> 
   <td>… where x.age &gt;= ?1</td> 
  </tr> 
  <tr> 
   <td>After</td> 
   <td>findByStartDateAfter</td> 
   <td>… where x.startDate &gt; ?1</td> 
  </tr> 
  <tr> 
   <td>Before</td> 
   <td>findByStartDateBefore</td> 
   <td>… where x.startDate &lt; ?1</td> 
  </tr> 
  <tr> 
   <td>IsNull</td> 
   <td>findByAgeIsNull</td> 
   <td>… where x.age is null</td> 
  </tr> 
  <tr> 
   <td>IsNotNull,NotNull</td> 
   <td>findByAge(Is)NotNull</td> 
   <td>… where x.age not null</td> 
  </tr> 
  <tr> 
   <td>Like</td> 
   <td>findByFirstnameLike</td> 
   <td>… where x.firstname like ?1</td> 
  </tr> 
  <tr> 
   <td>NotLike</td> 
   <td>findByFirstnameNotLike</td> 
   <td>… where x.firstname not like ?1</td> 
  </tr> 
  <tr> 
   <td>StartingWith</td> 
   <td>findByFirstnameStartingWith</td> 
   <td>… where x.firstname like ?1(parameter bound with appended %)</td> 
  </tr> 
  <tr> 
   <td>EndingWith</td> 
   <td>findByFirstnameEndingWith</td> 
   <td>… where x.firstname like ?1 (parameter bound with prepended %)</td> 
  </tr> 
  <tr> 
   <td>Containing</td> 
   <td>findByFirstnameContaining</td> 
   <td>… where x.firstname like ?1(parameter bound wrapped in %)</td> 
  </tr> 
  <tr> 
   <td>OrderBy</td> 
   <td>findByAgeOrderByLastnameDesc</td> 
   <td>… where x.age = ?1 order by x.lastname desc</td> 
  </tr> 
  <tr> 
   <td>Not</td> 
   <td>findByLastnameNot</td> 
   <td>… where x.lastname &lt;&gt; ?1</td> 
  </tr> 
  <tr> 
   <td>In</td> 
   <td>findByAgeIn(Collection&lt;Age&gt; ages)</td> 
   <td>… where x.age in ?1</td> 
  </tr> 
  <tr> 
   <td>NotIn</td> 
   <td>findByAgeNotIn(Collection&lt;Age&gt; age)</td> 
   <td>… where x.age not in ?1</td> 
  </tr> 
  <tr> 
   <td>True</td> 
   <td>findByActiveTrue()</td> 
   <td>… where x.active = true</td> 
  </tr> 
  <tr> 
   <td>False</td> 
   <td>findByActiveFalse()</td> 
   <td>… where x.active = false</td> 
  </tr> 
  <tr> 
   <td>IgnoreCase</td> 
   <td>findByFirstnameIgnoreCase</td> 
   <td>… where UPPER(x.firstame) = UPPER(?1)</td> 
  </tr> 
 </tbody> 
</table>

# @Query 注解 #

这种查询可以声明在 Repository 方法中，摆脱像命名查询那样的约束，将查询直接在相应的接口方法中声明，结构更为清晰，这是 Spring Data 的特有实现。

索引参数：

索引值从1开始，查询中 ?x 的个数需要与方法形参个数相等，并且顺序也要一致。

@Query("SELECT p FROM Person p WHERE p.lastName = ?1 and p.age = ?2")
    Person getByLastNameAndAge(String lastName, int age);

命名参数：

可以定义好参数名，赋值值采用 @Param(参数名)，而不用管顺序。

@Query("SELECT p FROM Person p WHERE p.lastName = :lastName and p.id = :id")
    Person getByLastNameAndId(@Param("id")int id, @Param("lastName")String lastName);

本地查询：

可以使用 @Query 执行本地查询，只要设置 nativeQuery 为 true。

@Query(value = "SELECT COUNT (id) FROM jpa_persons", nativeQuery = true)
    long getTotalCount();

# @Modifying 注解和事务 #

@Query 与 @Modifying 这两个注解一起使用，可以执行 UPDATE、DELETE 操作。

注意，UPDATE、DELETE 需要使用事务，因此需要定义在 Service 层。

事务：

Spring Data 提供了默认的事务处理方式，即所有的查询均为只读事务。

对于自定义的方法，如需改变 Spring Data 提供的事务方式，可以在方法上添加 @Transactional 注解。

进行多个 Repository 操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要在 Service 层实现对多个 Repository 的调用，并在相应的方法上声明事务。

# CrudRepository 接口 #

CrudRepository 接口提供了最基本的对实体类的添删改查操作   
T save(T entity) 保存单个实体   
Iterable<T> save(Iterable<? extends T> entities) 保存集合  
T findOne(ID id) 根据id查找实体  
boolean exists(ID id) 根据id判断实体是否存在  
Iterable<T> findAll() 查询所有实体,不用或慎用  
long count() 查询实体数量  
void delete(ID id) 根据Id删除实体  
void delete(T entity) 删除一个实体  
void delete(Iterable<? extends T> entities) 删除一个实体的集合  
void deleteAll() 删除所有实体,不用或慎用

# PagingAndSortingRepository 接口 #

该接口提供了分页与排序功能

Iterable<T> findAll(Sort sort) 排序

Page<T> findAll(Pageable pageable) 分页查询（含排序功能）

@Test
    public void testPagingAndSortingRespository(){
        int pageNo = 3;
        int pageSize = 5;
        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
        Sort.Order order1 = new Sort.Order(Sort.Direction.ASC, "email");
        Sort sort = new Sort(order,order1);
        PageRequest pageable = new PageRequest(pageNo, pageSize, sort);
        Page<Person> page = personRepository.findAll(pageable);
        System.out.println(page.getNumberOfElements());
        System.out.println(page.getContent());
    }

# JpaRepository 接口 #

该接口提供了JPA的相关功能

List<T> findAll() 查找所有实体

List<T> findAll(Sort sort) 排序、查找所有实体

List<T> save(Iterable<? extends T> entities) 保存集合

void flush() 执行缓存与数据库同步

T saveAndFlush(T entity) 强制执行持久化

void deleteInBatch(Iterable<T> entities) 删除一个实体集合

# JpaSpecificationExecutor 接口 #

不属于Repository体系，实现一组 JPA Criteria 查询相关的方法

Specification：封装 JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象

@Test
    public void testJpaSpecificationExecutor(){
        int pageNo = 3;
        int pageSize = 5;
        PageRequest pageable = new PageRequest(pageNo, pageSize);
        Specification<Person> specification = new Specification<Person>() {
            /**
                 * @param root 代表查询的实体类
                 * @param criteriaQuery 可以从中得到root对象，即告知 JPA Criteria 查询哪个实体类，
                 *                      还可以添加查询条件，还可以结合EntityManager对象得到最终查询的                                    TypedQuery
                 * @param criteriaBuilder 用于创建criteria工厂
                 * @return Predicate类型，代表一个查询条件
                 */
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Predicate predicate = criteriaBuilder.ge(root.get("id"),5);
                return predicate;
            }
        };
        Page<Person> page = personRepository.findAll(specification, pageable);
        System.out.println(page.getNumberOfElements());
        System.out.println(page.getContent());
    }

# 自定义 Repository 方法 #

## 为某一个 Repository 上添加自定义方法 ##

创建一个 XXXDAO 接口，声明接口方法。

创建一个 XXXRepository 接口，并继承 XXXDAO 接口。

提供 XXXRepository 的实现类 XXXRepositoryImpl，并实现 XXXDAO 定义的接口方法。

实际上在使用 XXXRepository 的自定义方法时会调用 XXXRepositoryImpl 中的实现。

## 为所有的 Repository 都添加自实现的方法 ##

创建一个 XXXRepository 接口，需要继承 创建一个 Repository 接口。

提供 XXXRepository 的实现类 XXXRepositoryImpl，且继承 SimpleJpaRepository，并提供方法的实现。

定义 JpaRepositoryFactoryBean 的实现类，使其生成 XXXRepository 的接口实现类的对象。

修改 \\<jpa:repositories/> 节点的 factory-class 属性指向 JpaRepositoryFactoryBean 的实现类的全类名。

注意：