使用Spring data jpa 怎么实现全文检索_百度知道阅读(38361)
　　JPA全称Java Persistence API，即Java持久化API，它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据，结合其他ORM的使用，能达到简化开发流程的目的，使开发者能够专注于实现自己的业务逻辑上。
　　Spring Jpa 能够简化创建 JPA 数据访问层和跨存储的持久层功能，用户的持久层Dao接口只需要继承他自己定义好的（仓库）接口，无需再写实现类，就可以实现对象的CRUD操作，还有分页排序等功能。
&　　写本章之前本来想写一个SpringMVC的，后来发现Jpa的配置可以大大简化MVC框架的配置，就先研究研究Spring Data Jpa。
准备工作：
　jar包支持（不用说都知道，本章jar包待我会放在115网盘供下载）
&& web.xml配置（监听Spring容器的装载）
&& 本章采用的是阿里连接池（Druid），所以web.xml要有相关的配置
&& Spring容器的配置（主要为beans和jpa）
&& Jpa的主要配置（实体类管理、数据源、连接池、事务等）
&& 实体类、持久层接口、业务层的创建
&& 测试放在下一章节中（因为采用了SpringJunit单元测试，单独分出来讲解）
&先来看一下本章节用到的包结构--如下图：
实例代码演示：
****************最后我会把本章的项目打包供下载************注释部分我尽可能详细讲解****************
jar包导入.....（略）
web.xml配置
&?xml version="1.0" encoding="UTF-8"?&
&web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xmlns:web="/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0"&
&display-name&springMVC&/display-name&
&!-- 同时加载多个spring配置文件可用
&context-param&
&param-name&contextConfigLocation&/param-name&
&param-value&
classpath:spring-config/*.xml
&/param-value&
&/context-param&
&!-- spring全局监听 --&
&listener&
&listener-class&org.springframework.web.context.ContextLoaderListener&/listener-class&
&/listener&
&!-- 下面为Druid默认配置，过滤掉多余的url地址 --&
&filter-name&DruidWebStatFilter&/filter-name&
&filter-class&com.alibaba.druid.support.http.WebStatFilter&/filter-class&
&init-param&
&param-name&exclusions&/param-name&
&param-value&*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*&/param-value&
&/init-param&
&init-param&
&param-name&principalSessionName&/param-name&
&param-value&_dest_login_&/param-value&
&/init-param&
&filter-mapping&
&filter-name&DruidWebStatFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
&!-- StatViewServlet是一个标准的Servlet --&
&servlet-name&DruidStatView&/servlet-name&
&servlet-class&com.alibaba.druid.support.http.StatViewServlet&/servlet-class&
&/servlet&
&servlet-mapping&
&servlet-name&DruidStatView&/servlet-name&
&url-pattern&/druid/*&/url-pattern&
&/servlet-mapping&
&!-- Spring Servlet,由于把bean全部交给了SpringJap，所以Spring-mvc里面现在为空 --&
&servlet-name&springServlet&/servlet-name&
&servlet-class&org.springframework.web.servlet.DispatcherServlet&/servlet-class&
&init-param&
&param-name&contextConfigLocation&/param-name&
&param-value&/WEB-INF/spring-mvc.xml&/param-value&
&/init-param&
&load-on-startup&1&/load-on-startup&
&/servlet&
&servlet-mapping&
&servlet-name&springServlet&/servlet-name&
&url-pattern&/&/url-pattern&
&/servlet-mapping&
&!-- 首页 --&
&welcome-file-list&
&welcome-file&index.jsp&/welcome-file&
&/welcome-file-list&
&/web-app&
spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"&
&!-- bean配置在spring-jpa.xml里,所以这里暂为空，用来初始化spring容器--&
spring-jpa.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:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
default-lazy-init="true"&
&description&SpringJpa配置&/description&
&!-- 如果spring用了jpa，并且类型为LocalContainerEntityManagerFactoryBean，则组件注册在此配置文件出现即可，其余配置文件可忽略
使用component来替代annotation 自动注册bean, 并保证@Required、@Autowired的属性被注入\ --&
&context:component-scan base-package="com.spring.jpa"/&
&!-- spring启动时扫描项目路径下的properties文件,后续用${key }方式取出对应值,这样可以代码解耦和，后续只需修改properties文件即可 --&
&bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"&
&property name="locations"&
&!-- dataSourse连接池相关属性，代码不在此贴出，会放在打包好的项目里面 --&
&value&classpath:db.properties&/value&
&/property&
&!-- 定义实体管理器工厂
LocalContainerEntityManagerFactoryBean这个选项Spring扮演了容器的角色。完全掌管JPA --&
&bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"&
&!-- 指定数据源 --&
&property name="dataSource" ref="dataSource"/&
&!-- 指定Jpa持久化实现厂商类,这里以Hibernate为例 --&
&property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/&
&!-- 指定Entity实体类包路径 --&
&property name="packagesToScan" &
&value&com.spring.jpa&/value&
&/property&
&!-- 指定JPA属性；如Hibernate中指定是否显示SQL的是否显示、方言等 --&
&property name="jpaProperties"&
&prop key="hibernate.dialect"&org.hibernate.dialect.Oracle10gDialect&/prop&
&prop key="hibernate.ejb.naming_strategy"&org.hibernate.cfg.ImprovedNamingStrategy&/prop&
&prop key="hibernate.cache.provider_class"&org.hibernate.cache.NoCacheProvider&/prop&
&prop key="hibernate.show_sql"&true&/prop&
&prop key="hibernate.format_sql"&true&/prop&
&prop key="hibernate.hbm2ddl.auto"&validate&/prop&
&/property&
&!-- 重要配置：启用扫描并自动创建代理的功能
&jpa:repositories base-package="com.spring.jpa"
transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/&
&!-- Hibernate对Jpa的实现 --&
&bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/&
&!-- Jpa 事务管理器
&bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"&
&property name="entityManagerFactory" ref="entityManagerFactory"/&
&!-- 开启注解事务 --&
&tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /&
&!-- 数据源配置,使用应用内的DBCP数据库连接池 --&
&bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"&
&!--property name="driverClassName" value="${db.driverClass}"/--&
&property name="url" value="${db.jdbcUrl}" /&
&property name="username" value="${db.user}" /&
&property name="password" value="${db.password}" /&
&!-- 配置初始化大小、最小、最大 --&
&property name="initialSize" value="${db.initialSize}" /&
&property name="minIdle" value="${db.minIdle}" /&
&property name="maxActive" value="${db.maxActive}" /&
&!-- 配置获取连接等待超时的时间 --&
&property name="maxWait" value="${db.maxWait}" /&
&!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 --&
&property name="timeBetweenEvictionRunsMillis" value="${db.timeBetweenEvictionRunsMillis}" /&
&!-- 配置一个连接在池中最小生存的时间，单位是毫秒 --&
&property name="minEvictableIdleTimeMillis" value="${db.minEvictableIdleTimeMillis}" /&
&property name="validationQuery" value="SELECT 'x' from dual" /&
&property name="testWhileIdle" value="true" /&
&property name="testOnBorrow" value="false" /&
&property name="testOnReturn" value="false" /&
&!-- 打开PSCache，并且指定每个连接上PSCache的大小 --&
&property name="poolPreparedStatements" value="${db.poolPreparedStatements}" /&
&property name="maxPoolPreparedStatementPerConnectionSize" value="${db.maxPoolPreparedStatementPerConnectionSize}" /&
&!-- 启动对@AspectJ（面向切面）注解的支持 --&
&aop:aspectj-autoproxy /&
　　配置好了配置文件后，我们该来写对应的实体类，Dao，和service了，下面给出简单的3个类：
User 实体类
package com.spring.jpa.
import javax.persistence.C
import javax.persistence.E
import javax.persistence.GeneratedV
import javax.persistence.Id;
import javax.persistence.SequenceG
import javax.persistence.T
* User实体类
* @author liuyt
下午2:27:37
@Table(name="T_SPRINGJPA_USER")
public class User {
* 主键序列：DEFAULT_SUQUENCE 是我在oracle数据库中创建的一个序列
MY_SUQUENCE 是给自定义的序列创建一个引用名称
* 指我的主键生成策略 MY_SUQUENCE 使用的是 DEFAULT_SUQUENCE 这个序列。
@SequenceGenerator(name = "MY_SUQUENCE", sequenceName = "DEFAULT_SUQUENCE")
@GeneratedValue(generator="MY_SUQUENCE")
@Column(name="USER_NAME")
private String userN
@Column(name="USER_PASSWORD")
private String passW
/*************GET****************SET***************/
public Long getId() {
public void setId(Long id) {
public String getUserName() {
return userN
public void setUserName(String userName) {
this.userName = userN
public String getPassWord() {
return passW
public void setPassWord(String passWord) {
this.passWord = passW
public String toString() {
return "User [id=" + id + ", userName=" + userName + ", passWord="
+ passWord + "]";
User Entity
IUserDao 持久层（jpa对持久层简化的核心基础）
package com.spring.jpa.
import org.springframework.data.repository.PagingAndSortingR
import org.springframework.stereotype.R
* 持久层接口
* @author liuyt
下午2:09:48
@Repository
public interface IUserDao extends PagingAndSortingRepository&User, Long&{
* 通过前面的配置可以看出，Spring 对 JPA 的支持已经非常强大，开发者无需过多关注 EntityManager 的创建、事务处理等 JPA 相关的处理
* ***********************************************************************
* 然而spring对Jpa的支持不止于此，它要从根本上来简化我们的业务代码
* 在没用使用jpa支持的时候，我们的代码应该是这样的：
1、IUserDao
持久层接口
2、IUserDaoImpl
持久层实现类
3、IUserService
业务层接口.....后面不在列举
* 每写一个实体类，都要衍生出5、6个类来对他进行操作，即使有了注解，我们可以依赖注入方式来拿到实现类，
* 但是通用的CRUD等操作却不免在每个实现类里声明，你又说，我可以定义一个父类，利用泛型反射原理就可以了，
* 但那样你还需要为每个Dao声明自己的实现类来继承你的父类
* ***********************************************************************
* 那么问题来了...（不是挖掘机技术）对持久层的简化技术哪家强？
Spring Data Jpa
* 你唯一要做的就只是声明持久层的接口，来继承他自身已经封装好的持久层接口，正如本类IUserDao一样
* 可使用的接口有：
**********
Repository：是 Spring Data的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法。**
CrudRepository：继承Repository，提供增删改查方法，可以直接调用。
PagingAndSortingRepository：继承CrudRepository，具有分页查询和排序功能（本类实例）
JpaRepository：
继承PagingAndSortingRepository，针对JPA技术提供的接口
JpaSpecificationExecutor：
可以执行原生SQL查询
继承不同的接口，有两个不同的泛型参数，他们是该持久层操作的类对象和主键类型。
*********************************************************************************
　　这里为了方便演示，就不写业务层接口了，直接上业务层service代码
UserService 业务层
package com.spring.jpa.
import java.util.L
import javax.annotation.R
import org.springframework.data.domain.P
import org.springframework.data.domain.PageR
import org.springframework.stereotype.S
* User业务层，依赖持久层
* @author liuyt
下午2:37:21
public class UserService {
// 推荐用Resource来替代AutoWrite注解
private IUserDao userD
// 新增用户
public void saveUser(User user) {
userDao.save(user);
// 删除用户，参数也可以为一个含有id的User对象
public void deleteUser(Long id) {
userDao.delete(id);
// 查询所有user对象，findOne为查询单个
public List&User& findAllUsers() {
return (List&User&) userDao.findAll();
* 根据一个分页对象查询user集合（还可以添加一个Store排序属性）
* PageRequest
是spring自己封装的请求分页类，实现了Pageable接口，包涵从请求中获得的分页属性（当前页和大小）和获取方法
* 通过调用分页方法，返回一个Page&&一个泛型集合的分页对象，里面包涵了通过查询计算出的各个属性和结果集
* 详细类结构和属性请参阅源码
* @param page
public Page&User& findAllUserByPage(PageRequest page) {
return (Page&User&) userDao.findAll(page);
　　至此，整体SpringJpa框架就搭建好了，剩下的就是写页面和控制器进行测试了，这里不做演示，因为会在下一章节利用SpringUnit单元测试，通过注解的方式进行方法测试，详情请移步：待更新...
　　&项目war包下载：
　在学习期间可能jar包的导入会很头疼，因为各类框架的jar有时候会出现不兼容的情况（）到期请提醒
&& 本章节用到的Druid连接池配置，详细配置请异步度娘
&& spring-jpa.xml里面可以针对不同需求，可以选择不同的EntityManagerFactory实体类管理
&& 别忘记&jpa:repositories /&标签的配置，他用来声明Jpa涉及到的包路径
&& SpringJpa集成了声明式事务，记得开启注解事务即可
&& 持久层的实现接口有很多，根据需求灵活选择（本章演示有关分页的接口，因为网上对该接口的介绍都比较粗略）
&& 未涉及：其他功能：如Query查询，Dao接口方法的新增　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　&写作不易，难免有疏漏和错误，还请慷慨指正，觉得有帮助帮忙推荐哦
　　ps:欢迎转载，转载请注明出处：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　每天多学一点点&&&& 代码少敲一点点　　　　　　　　　　　　　　　　　原文链接:
阅读排行榜Spring（1）
Spring Boot（1）
基本使用方法
继承接口并声明查询方法
interface PersonRepository extends Repository&Person, Long& {
List&Person& findByLastname(String lastname);
Autowired注入
public class SomeClient {
@Autowired
private PersonR
public void doSomething() {
List&Person& persons = repository.findByLastname("Matthews");
自定义Repository
选择性暴露CURD方法
@NoRepositoryBean
interface MyBaseRepository&T, ID extends Serializable& extends Repository&T, ID& {
T findOne(ID id);
T save(T entity);
interface UserRepository extends MyBaseRepository&User, Long& {
User findByEmailAddress(EmailAddress emailAddress);
使用特定模块接口定义Repository
interface MyRepository extends JpaRepository&User, Long& { }
@NoRepositoryBean
interface MyBaseRepository&T, ID extends Serializable& extends JpaRepository&T, ID& {
interface UserRepository extends MyBaseRepository&User, Long& {
注意：中间层repository接口要使用注解@NoRepositoryBean，以确保Spring Data不会在运行时对其实例化。
定义查询方法
查询方法建立
distinct flag
ignoring case
public interface PersonRepository extends Repository&User, Long& {
List&Person& findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname);
List&Person& findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname);
List&Person& findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname);
List&Person& findByLastnameIgnoreCase(String lastname);
List&Person& findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname);
List&Person& findByLastnameOrderByFirstnameAsc(String lastname);
List&Person& findByLastnameOrderByFirstnameDesc(String lastname);
为了消除不确定性，可以在方法名内使用下划线“_”手动定义隔断点。
List&Person& findByAddress_ZipCode(ZipCode zipCode);
特殊参数处理
Page&User& findByLastname(String lastname, Pageable pageable);
Slice&User& findByLastname(String lastname, Pageable pageable);
List&User& findByLastname(String lastname, Sort sort);
List&User& findByLastname(String lastname, Pageable pageable);
限制查询结果数量
User findFirstByOrderByLastnameAsc();
User findTopByOrderByAgeDesc();
Page&User& queryFirst10ByLastname(String lastname, Pageable pageable);
Slice&User& findTop3ByLastname(String lastname, Pageable pageable);
List&User& findFirst10ByLastname(String lastname, Sort sort);
List&User& findTop10ByLastname(String lastname, Pageable pageable);
流式查询结果
@Query("select u from User u")
Stream&User& findAllByCustomQueryAndStream();
Stream&User& readAllByFirstnameNotNull();
@Query("select u from User u")
Stream&User& streamAllPaged(Pageable pageable);
流在使用结束后需要关闭以释放资源，可以用 close() 方法手动将其关闭或者使用 try-with-resources 块。
try-with-resources 块
try (Stream&User& stream = repository.findAllByCustomQueryAndStream()) {
stream.forEach(…);
异步查询结果
使用 java.util.concurrent.Future 作为返回类型
使用 a Java 8 java.pletableFuture 作为返回类型
使用 a org.springframework.util.concurrent.ListenableFuture 作为返回类型
Future&User& findByFirstname(String firstname);
CompletableFuture&User& findOneByFirstname(String firstname);
ListenableFuture&User& findOneByLastname(String lastname);
JPQL snippet
findByLastnameAndFirstname
… where x.lastname = ?1 and x.firstname = ?2
findByLastnameOrFirstname
… where x.lastname = ?1 or x.firstname = ?2
findByFirstname,findByFirstnameIs,findByFirstnameEquals
… where x.firstname = ?1
findByStartDateBetween
… where x.startDate between ?1 and ?2
findByAgeLessThan
… where x.age & ?1
LessThanEqual
findByAgeLessThanEqual
… where x.age &= ?1
GreaterThan
findByAgeGreaterThan
… where x.age & ?1
GreaterThanEqual
findByAgeGreaterThanEqual
… where x.age &= ?1
findByStartDateAfter
… where x.startDate & ?1
findByStartDateBefore
… where x.startDate & ?1
findByAgeIsNull
… where x.age is null
IsNotNull,NotNull
findByAge(Is)NotNull
… where x.age not null
findByFirstnameLike
… where x.firstname like ?1
findByFirstnameNotLike
… where x.firstname not like ?1
StartingWith
findByFirstnameStartingWith
… where x.firstname like ?1(parameter bound with appended %)
EndingWith
findByFirstnameEndingWith
… where x.firstname like ?1(parameter bound with prepended %)
Containing
findByFirstnameContaining
… where x.firstname like ?1(parameter bound wrapped in %)
findByAgeOrderByLastnameDesc
… where x.age = ?1 order by x.lastname desc
findByLastnameNot
… where x.lastname && ?1
findByAgeIn(Collection ages)
… where x.age in ?1
findByAgeNotIn(Collection age)
… where x.age not in ?1
findByActiveTrue()
… where x.active = true
findByActiveFalse()
… where x.active = false
IgnoreCase
findByFirstnameIgnoreCase
… where UPPER(x.firstame) = UPPER(?1)
使用 @Query
public interface UserRepository extends JpaRepository&User, Long& {
@Query("select u from User u where u.emailAddress = ?1")
User findByEmailAddress(String emailAddress);
使用 LIKE 表达式
public interface UserRepository extends JpaRepository&User, Long& {
@Query("select u from User u where u.firstname like %?1")
List&User& findByFirstnameEndsWith(String firstname);
使用原生SQL
public interface UserRepository extends JpaRepository&User, Long& {
@Query(value = "SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1", nativeQuery = true)
User findByEmailAddress(String emailAddress);
原生SQL分页
public interface UserRepository extends JpaRepository&User, Long& {
@Query(value = "SELECT * FROM USERS WHERE LASTNAME = ?1",
countQuery = "SELECT count(*) FROM USERS WHERE LASTNAME = ?1",
nativeQuery = true)
Page&User& findByLastname(String lastname, Pageable pageable);
使用 Sort 和 JpaSort
public interface UserRepository extends JpaRepository&User, Long& {
@Query("select u from User u where u.lastname like ?1%")
List&User& findByAndSort(String lastname, Sort sort);
@Query("select u.id, LENGTH(u.firstname) as fn_len from User u where u.lastname like ?1%")
List&Object[]& findByAsArrayAndSort(String lastname, Sort sort);
repo.findByAndSort("lannister", new Sort("firstname"));
repo.findByAndSort("stark", new Sort("LENGTH(firstname)"));
repo.findByAndSort("targaryen", JpaSort.unsafe("LENGTH(firstname)"));
repo.findByAsArrayAndSort("bolton", new Sort("fn_len"));
使用已命名参数
public interface UserRepository extends JpaRepository&User, Long& {
@Query("select u from User u where u.firstname = :firstname or u.lastname = :lastname")
User findByLastnameOrFirstname(@Param("lastname") String lastname,
@Param("firstname") String firstname);
@Modifying
@Query("update User u set u.firstname = ?1 where u.lastname = ?2")
int setFixedFirstnameFor(String firstname, String lastname);
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：74次
排名：千里之外