企业网站改一下多少钱,网站加速免费,石家庄网站建设推广公司,百度网盘app下载前些天发现了一个巨牛的人工智能学习网站#xff0c;通俗易懂#xff0c;风趣幽默#xff0c;忍不住分享一下给大家。点击跳转到教程。
本篇进行Spring-data-jpa的介绍#xff0c;几乎涵盖该框架的所有方面#xff0c;在日常的开发当中#xff0c;基本上能满足所有需求。…前些天发现了一个巨牛的人工智能学习网站通俗易懂风趣幽默忍不住分享一下给大家。点击跳转到教程。
本篇进行Spring-data-jpa的介绍几乎涵盖该框架的所有方面在日常的开发当中基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门百度一下很多入门的介绍。在这篇文章的接下来一篇会有一个系列来讲解mybatis这个系列从mybatis的入门开始到基本使用和spring整合和第三方插件整合缓存插件最后会持续到mybatis的架构源码解释重点会介绍几个重要的设计模式这样一个体系。基本上讲完之后mybatis在你面前就没有了秘密你能解决mybatis的几乎所有问题并且在开发过程中相当的方便驾轻就熟。
这篇文章由于介绍的类容很全因此很长如果你需要那么可以耐心的看完本人经历了很长时间的学识使用研究的心血浓缩成为这么短短的一篇博客。
大致整理一个提纲 1、Spring-data-jpa的基本介绍 2、和Spring整合 3、基本的使用方式 4、复杂查询包括多表关联分页排序等
现在开始 1、Spring-data-jpa的基本介绍JPA诞生的缘由是为了整合第三方ORM框架建立一种标准的方式百度百科说是JDK为了实现ORM的天下归一目前也是在按照这个方向发展但是还没能完全实现。在ORM框架中Hibernate是一支很大的部队使用很广泛也很方便能力也很强同时Hibernate也是和JPA整合的比较良好我们可以认为JPA是标准事实上也是JPA几乎都是接口实现都是Hibernate在做宏观上面看在JPA的统一之下Hibernate很良好的运行。 上面阐述了JPA和Hibernate的关系那么Spring-data-jpa又是个什么东西呢这地方需要稍微解释一下我们做Java开发的都知道Spring的强大到目前为止企业级应用Spring几乎是无所不能无所不在已经是事实上的标准了企业级应用不使用Spring的几乎没有这样说没错吧。而Spring整合第三方框架的能力又很强他要做的不仅仅是个最早的IOC容器这么简单一回事现在Spring涉及的方面太广主要是体现在和第三方工具的整合上。而在与第三方整合这方面Spring做了持久化这一块的工作我个人的感觉是Spring希望把持久化这块内容也拿下。于是就有了Spring-data-**这一系列包。包括Spring-data-jpa,Spring-data-template,Spring-data-mongodb,Spring-data-redis还有个民间产品mybatis-spring和前面类似这是和mybatis整合的第三方包这些都是干的持久化工具干的事儿。 这里介绍Spring-data-jpa表示与jpa的整合。 2、我们都知道在使用持久化工具的时候一般都有一个对象来操作数据库在原生的Hibernate中叫做Session在JPA中叫做EntityManager在MyBatis中叫做SqlSession通过这个对象来操作数据库。我们一般按照三层结构来看的话Service层做业务逻辑处理Dao层和数据库打交道在Dao中就存在着上面的对象。那么ORM框架本身提供的功能有什么呢答案是基本的CRUD所有的基础CRUD框架都提供我们使用起来感觉很方便很给力业务逻辑层面的处理ORM是没有提供的如果使用原生的框架业务逻辑代码我们一般会自定义会自己去写SQL语句然后执行。在这个时候Spring-data-jpa的威力就体现出来了ORM提供的能力他都提供ORM框架没有提供的业务逻辑功能Spring-data-jpa也提供全方位的解决用户的需求。使用Spring-data-jpa进行开发的过程中常用的功能我们几乎不需要写一条sql语句至少在我看来企业级应用基本上可以不用写任何一条sql当然spring-data-jpa也提供自己写sql的方式这个就看个人怎么选择都可以。我觉得都行。 2.1与Spring整合我们从spring配置文件开始为了节省篇幅这里我只写出配置文件的结构。 ?xml version1.0 encodingUTF-8?
beans xmlnshttp://www.springframework.org/schema/beans xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xmlns:phttp://www.springframework.org/schema/p xmlns:aophttp://www.springframework.org/schema/aop xmlns:txhttp://www.springframework.org/schema/tx xmlns:contexthttp://www.springframework.org/schema/context xmlns:mongohttp://www.springframework.org/schema/data/mongoxmlns:jpahttp://www.springframework.org/schema/data/jpaxsi:schemaLocationhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsdhttp://www.springframework.org/schema/data/mongohttp://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsdhttp://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd!-- 数据库连接 --context:property-placeholder locationclasspath:your-config.properties ignore-unresolvabletrue /!-- service包 --context:component-scan base-packageyour service package /!-- 使用cglib进行动态代理 --aop:aspectj-autoproxy proxy-target-classtrue /!-- 支持注解方式声明式事务 --tx:annotation-driven transaction-managertransactionManager proxy-target-classtrue /!-- dao --jpa:repositories base-packageyour dao package repository-impl-postfixImpl entity-manager-factory-refentityManagerFactory transaction-manager-reftransactionManager /!-- 实体管理器 --bean identityManagerFactory classorg.springframework.orm.jpa.LocalContainerEntityManagerFactoryBeanproperty namedataSource refdataSource /property namepackagesToScan valueyour entity package /property namepersistenceProviderbean classorg.hibernate.ejb.HibernatePersistence //propertyproperty namejpaVendorAdapterbean classorg.springframework.orm.jpa.vendor.HibernateJpaVendorAdapterproperty namegenerateDdl valuefalse /property namedatabase valueMYSQL /property namedatabasePlatform valueorg.hibernate.dialect.MySQL5InnoDBDialect /!-- property nameshowSql valuetrue / --/bean/propertyproperty namejpaDialectbean classorg.springframework.orm.jpa.vendor.HibernateJpaDialect //propertyproperty namejpaPropertyMapmapentry keyhibernate.query.substitutions valuetrue 1, false 0 /entry keyhibernate.default_batch_fetch_size value16 /entry keyhibernate.max_fetch_depth value2 /entry keyhibernate.generate_statistics valuetrue /entry keyhibernate.bytecode.use_reflection_optimizer valuetrue /entry keyhibernate.cache.use_second_level_cache valuefalse /entry keyhibernate.cache.use_query_cache valuefalse //map/property/bean!-- 事务管理器 --bean idtransactionManager classorg.springframework.orm.jpa.JpaTransactionManagerproperty nameentityManagerFactory refentityManagerFactory//bean!-- 数据源 --bean iddataSource classcom.alibaba.druid.pool.DruidDataSource init-methodinit destroy-methodcloseproperty namedriverClassName value${driver} /property nameurl value${url} /property nameusername value${userName} /property namepassword value${password} /property nameinitialSize value${druid.initialSize} /property namemaxActive value${druid.maxActive} /property namemaxIdle value${druid.maxIdle} /property nameminIdle value${druid.minIdle} /property namemaxWait value${druid.maxWait} /property nameremoveAbandoned value${druid.removeAbandoned} /property nameremoveAbandonedTimeout value${druid.removeAbandonedTimeout} /property nametimeBetweenEvictionRunsMillis value${druid.timeBetweenEvictionRunsMillis} /property nameminEvictableIdleTimeMillis value${druid.minEvictableIdleTimeMillis} /property namevalidationQuery value${druid.validationQuery} /property nametestWhileIdle value${druid.testWhileIdle} /property nametestOnBorrow value${druid.testOnBorrow} /property nametestOnReturn value${druid.testOnReturn} /property namepoolPreparedStatements value${druid.poolPreparedStatements} /property namemaxPoolPreparedStatementPerConnectionSize value${druid.maxPoolPreparedStatementPerConnectionSize} /property namefilters value${druid.filters} //bean!-- 事务 --tx:advice idtxAdvice transaction-managertransactionManagertx:attributestx:method name* /tx:method nameget* read-onlytrue /tx:method namefind* read-onlytrue /tx:method nameselect* read-onlytrue /tx:method namedelete* propagationREQUIRED /tx:method nameupdate* propagationREQUIRED /tx:method nameadd* propagationREQUIRED /tx:method nameinsert* propagationREQUIRED //tx:attributes/tx:advice!-- 事务入口 --aop:configaop:pointcut idallServiceMethod expressionexecution(* your service implements package.*.*(..)) /aop:advisor pointcut-refallServiceMethod advice-reftxAdvice //aop:config/beans 2.2对上面的配置文件进行简单的解释只对“实体管理器”和“dao”进行解释其他的配置在任何地方都差不太多。 1.对“实体管理器”解释我们知道原生的jpa的配置信息是必须放在META-INF目录下面的并且名字必须叫做persistence.xml这个叫做persistence-unit就叫做持久化单元放在这下面我们感觉不方便不好于是Spring提供了
org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
这样一个类可以让你的随心所欲的起这个配置文件的名字也可以随心所欲的修改这个文件的位置只需要在这里指向这个位置就行。然而更加方便的做法是直接把配置信息就写在这里更好于是就有了这实体管理器这个bean。使用
property namepackagesToScan valueyour entity package /
这个属性来加载我们的entity。 2.3 解释“dao”这个bean。这里衍生一下进行一下名词解释我们知道dao这个层叫做Data Access Object数据库访问对象这是一个广泛的词语在jpa当中我们还有一个词语叫做Repository这里我们一般就用Repository结尾来表示这个dao比如UserDao这里我们使用UserRepository当然名字无所谓随意取你可以意会一下我的意思感受一下这里的含义和区别同理在mybatis中我们一般也不叫daomybatis由于使用xml映射文件当然也提供注解但是官方文档上面表示在有些地方比如多表的复杂查询方面注解还是无解只能xml我们一般使用mapper结尾比如我们也不叫UserDao而叫UserMapper。 上面拓展了一下关于dao的解释那么这里的这个配置信息是什么意思呢首先base-package属性代表你的Repository接口的位置repository-impl-postfix属性代表接口的实现类的后缀结尾字符比如我们的UserRepository那么他的实现类就叫做UserRepositoryImpl和我们平时的使用习惯完全一致于此同时spring-data-jpa的习惯是接口和实现类都需要放在同一个包里面不知道有没有其他方式能分开放这不是重点放在一起也无所谓影响不大再次的这里我们的UserRepositoryImpl这个类的定义的时候我们不需要去指定实现UserRepository接口根据spring-data-jpa自动就能判断二者的关系。 比如我们的UserRepository和UserRepositoryImpl这两个类就像下面这样来写。
public interface UserRepository extends JpaRepositoryUser, Integer{}
public class UserRepositoryImpl {} 那么这里为什么要这么做呢原因是spring-data-jpa提供基础的CRUD工作同时也提供业务逻辑的功能前面说了这是该框架的威力所在所以我们的Repository接口要做两项工作继承spring-data-jpa提供的基础CRUD功能的接口比如JpaRepository接口同时自己还需要在UserRepository这个接口中定义自己的方法那么导致的结局就是UserRepository这个接口中有很多的方法那么如果我们的UserRepositoryImpl实现了UserRepository接口导致的后果就是我们势必需要重写里面的所有方法这是Java语法的规定如此一来悲剧就产生了UserRepositoryImpl里面我们有很多的Override方法这显然是不行的结论就是这里我们不用去写implements部分。 spring-data-jpa实现了上面的能力那他是怎么实现的呢这里我们通过源代码的方式来呈现他的来龙去脉这个过程中cglib发挥了杰出的作用。 在spring-data-jpa内部有一个类叫做
public class SimpleJpaRepositoryT, ID extends Serializable implements JpaRepositoryT, ID,JpaSpecificationExecutorT
我们可以看到这个类是实现了JpaRepository接口的事实上如果我们按照上面的配置在同一个包下面有UserRepository但是没有UserRepositoryImpl这个类的话在运行时期UserRepository这个接口的实现就是上面的SimpleJpaRepository这个接口。而如果有UserRepositoryImpl这个文件的话那么UserRepository的实现类就是UserRepositoryImpl而UserRepositoryImpl这个类又是SimpleJpaRepository的子类如此一来就很好的解决了上面的这个不用写implements的问题。我们通过阅读这个类的源代码可以发现里面包装了entityManager底层的调用关系还是entityManager在进行CRUD。 3. 下面我们通过一个完整的项目来基本使用spring-data-jpa然后我们在介绍他的高级用法。 a.数据库建表user,主键自增 b.对应实体User Entity
Table(name user)
public class User {IdGeneratedValue(strategy GenerationType.IDENTITY)private Integer id;private String name;private String password;private String birthday;// getter,setter
} c.简历UserRepository接口
public interface UserRepository extends JpaRepositoryUser, Integer{} 通过上面3步所有的工作就做完了User的基础CRUD都能做了简约而不简单。 d.我们的测试类UserRepositoryTest public class UserRepositoryTest {Autowiredprivate UserRepository userRepository;Testpublic void baseTest() throws Exception {User user new User();user.setName(Jay);user.setPassword(123456);user.setBirthday(2008-08-08);userRepository.save(user);
// userRepository.delete(user);
// userRepository.findOne(1);}
} 测试通过。 说到这里和spring已经完成。接下来第三点基本使用。
4.前面把基础的东西说清楚了接下来就是spring-data-jpa的正餐了真正威力的地方。 4.1 我们的系统中一般都会有用户登录这个接口在不使用spring-data-jpa的时候我们怎么做首先在service层定义一个登录方法。如
User login(String name, String password);
然后在serviceImpl中写该方法的实现大致这样 Overridepublic User login(String name, String password) {return userDao.login(name, password);}
接下来UserDao大概是这么个样子
User getUserByNameAndPassword(String name, String password);
然后在UserDaoImpl中大概是这么个样子 public User getUserByNameAndPassword(String name, String password) {Query query em.createQuery(select * from User t where t.name ?1 and t.password ?2);query.setParameter(1, name);query.setParameter(2, password);return (User) query.getSingleResult();}
ok这个代码运行良好那么这样子大概有十来行代码我们感觉这个功能实现了很不错。然而这样子真正简捷么如果这样子就满足了那么spring-data-jpa就没有必要存在了前面提到spring-data-jpa能够帮助你完成业务逻辑代码的处理那他是怎么处理的呢这里我们根本不需要UserDaoImpl这个类只需要在UserRepository接口中定义一个方法
User findByNameAndPassword(String name, String password);
然后在service中调用这个方法就完事了所有的逻辑只需要这么一行代码一个没有实现的接口方法。通过debug信息我们看到输出的sql语句是
select * from user where name ? and password ?
跟上面的传统方式一模一样的结果。这简单到令人发指的程度那么这一能力是如何实现的呢原理是spring-data-jpa会根据方法的名字来自动生成sql语句我们只需要按照方法定义的规则即可上面的方法findByNameAndPasswordspring-data-jpa规定方法都以findBy开头sql的where部分就是NameAndPassword被spring-data-jpa翻译之后就编程了下面这种形态
where name ? and password ?
在举个例如果是其他的操作符呢比如like前端模糊查询很多都是以like的方式来查询。比如根据名字查询用户sql就是
select * from user where name like ?
这里spring-data-jpa规定在属性后面接关键字比如根据名字查询用户就成了
User findByNameLike(String name);
被翻译之后的sql就是
select * from user where name like ?
这也是简单到令人发指spring-data-jpa所有的语法规定如下图
通过上面基本CRUD和基本的业务逻辑操作都得到了解决我们要做的工作少到仅仅需要在UserRepository接口中定义几个方法其他所有的工作都由spring-data-jpa来完成。 接下来就是比较复杂的操作了比如动态查询分页下面详细介绍spring-data-jpa的第二大杀手锏强大的动态查询能力。
在上面的介绍中对于我们传统的企业级应用的基本操作已经能够基本上全部实现企业级应用一般都会有一个模糊查询的功能并且是多条的查询在有查询条件的时候我们需要在where后面接上一个 xxx yyy 或者 xxx like % yyy %类似这样的sql。那么我们传统的JDBC的做法是使用很多的if语句根据传过来的查询条件来拼sqlmybatis的做法也类似由于mybatis有强大的动态xml文件的标签在处理这种问题的时候显得非常的好但是二者的原理都一致那spring-data-jpa的原理也同样很类似这个道理也就说明了解决多表关联动态查询根儿上也就是这么回事。 那么spring-data-jpa的做法是怎么的呢有两种方式。可以选择其中一种也可以结合使用在一般的查询中使用其中一种就够了就是第二种但是有一类查询比较棘手比如报表相关的报表查询由于涉及的表很多这些表不一定就是两两之间有关系比如字典表就很独立在这种情况之下使用拼接sql的方式要容易一些。下面分别介绍这两种方式。 a.使用JPQL,和Hibernate的HQL很类似。 前面说道了在UserRepository接口的同一个包下面建立一个普通类UserRepositoryImpl来表示该类的实现类同时前面也介绍了完全不需要这个类的存在但是如果使用JPQL的方式就必须要有这个类。如下 public class StudentRepositoryImpl {PersistenceContextprivate EntityManager em;SuppressWarnings(unchecked)public PageStudent search(User user) {String dataSql select t from User t where 1 1;String countSql select count(t) from User t where 1 1;if(null ! user !StringUtils.isEmpty(user.getName())) {dataSql and t.name ?1;countSql and t.name ?1;}Query dataQuery em.createQuery(dataSql);Query countQuery em.createQuery(countSql);if(null ! user !StringUtils.isEmpty(user.getName())) {dataQuery.setParameter(1, user.getName());countQuery.setParameter(1, user.getName());}long totalSize (long) countQuery.getSingleResult();PageUser page new Page();page.setTotalSize(totalSize);ListUser data dataQuery.getResultList();page.setData(data);return page;}} 通过上面的方法我们查询并且封装了一个User对象的分页信息。代码能够良好的运行。这种做法也是我们传统的经典做法。那么spring-data-jpa还有另外一种更好的方式那就是所谓的类型检查的方式上面我们的sql是字符串没有进行类型检查而下面的方式就使用了类型检查的方式。这个道理在mybatis中也有体现mybatis可以使用字符串sql的方式也可以使用接口的方式而mybatis的官方推荐使用接口方式因为有类型检查会更安全。 b.使用JPA的动态接口下面的接口我把注释删了为了节省篇幅注释也没什么用看方法名字大概都能猜到是什么意思。 public interface JpaSpecificationExecutorT {T findOne(SpecificationT spec);ListT findAll(SpecificationT spec);PageT findAll(SpecificationT spec, Pageable pageable);ListT findAll(SpecificationT spec, Sort sort);long count(SpecificationT spec);
} 上面说了使用这种方式我们压根儿就不需要UserRepositoryImpl这个类说到这里仿佛我们就发现了spring-data-jpa为什么把Repository和RepositoryImpl文件放在同一个包下面因为我们的应用很可能根本就一个Impl文件都不存在那么在那个包下面就只有一堆接口即使把Repository和RepositoryImpl都放在同一个包下面也不会造成这个包下面有正常情况下2倍那么多的文件根本原因只有接口而没有实现类。
上面我们的UserRepository类继承了JpaRepository和JpaSpecificationExecutor类而我们的UserRepository这个对象都会注入到UserService里面于是如果使用这种方式我们的逻辑直接就写在service里面了下面的代码一个学生Student类一个班级Clazz类Student里面有一个对象Clazz在数据库中是clazz_id这是典型的多对一的关系。我们在配置好entity里面的关系之后。就可以在StudentServiceImpl类中做Student的模糊查询典型的前端grid的模糊查询。代码是这样子的 Service
public class StudentServiceImpl extends BaseServiceImplStudent implements StudentService {Autowiredprivate StudentRepository studentRepository;Overridepublic Student login(Student student) {return studentRepository.findByNameAndPassword(student.getName(), student.getPassword());}Overridepublic PageStudent search(final Student student, PageInfo page) {return studentRepository.findAll(new SpecificationStudent() {Overridepublic Predicate toPredicate(RootStudent root, CriteriaQuery? query, CriteriaBuilder cb) {Predicate stuNameLike null;if(null ! student !StringUtils.isEmpty(student.getName())) {// 这里也可以root.get(name).as(String.class)这种方式来强转泛型类型stuNameLike cb.like(root.String get(name), % student.getName() %);}Predicate clazzNameLike null;if(null ! student null ! student.getClazz() !StringUtils.isEmpty(student.getClazz().getName())) {clazzNameLike cb.like(root.String get(clazz).String get(name), % student.getClazz().getName() %);}if(null ! stuNameLike) query.where(stuNameLike);if(null ! clazzNameLike) query.where(clazzNameLike);return null;}}, new PageRequest(page.getPage() - 1, page.getLimit(), new Sort(Direction.DESC, page.getSortName())));}
} 先解释下这里的意思然后我们在结合框架的源码来深入分析。
这里我们是2个表关联查询查询条件包括Student表和Clazz表类似的2个以上的表方式差不多但是正如上面所说这种做法适合所有的表都是两两能够关联上的涉及的表太多或者是有一些字典表那就使用sql拼接的方式简单一些。
先简单解释一下代码的含义然后结合框架源码来详细分析。两个Predicate对象Predicate按照中文意思是判断断言的意思那么放在我们的sql中就是where后面的东西比如
name like % jay %;
下面的PageRequest代表分页信息PageRequest里面的Sort对象是排序信息。上面的代码事实上是在动态的组合最终的sql语句这里使用了一个策略模式或者callback就是
studentRepository.findAll(一个接口)
studentRepository接口方法调用的参数是一个接口而接口的实现类调用这个方法的时候在内部参数对象的实现类调用自己的toPredicate这个方法的实现内容可以体会一下这里的思路就是传一个接口然后接口的实现自己来定义这个思路在nettyJavaScript中体现的特别明显特别是JavaScript的框架中大量的这种方式JS框架很多的做法都是上来先闭包和浏览器的命名空间分开然后入口方法就是一个回调比如ExtJS
Ext.onReady(function() {// xxx
});
参数是一个function其实在框架内部就调用了这个参数于是这个这个方法执行了。这种模式还有一个JDK的排序集合上面也有体现我们的netty框架也采用这种方式来实现异步IO的能力。
接下来结合框架源码来详细介绍这种机制以及这种机制提供给我们的好处。 这里首先从JPA的动态查询开始说起在JPA提供的API中动态查询大概有这么一些方法
从名字大概可以看出这些方法的意义跟Hibernate或者一些其他的工具也都差不多这里我们介绍参数为CriteriaQuery类型的这个方法如果我们熟悉多种ORM框架的话不难发现都有一个Criteria类似的东西中文意思是“条件”的意思这就是各个框架构建动态查询的主体Hibernate甚至有两种在线和离线两种Criteriamybatis也能从Example中创建Criteria并且添加查询条件。
那么第一步就需要构建出这个参数CriteriaQuery类型的参数这里使用建造者模式
CriteriaBuilder builder em.getCriteriaBuilder();
CriteriaQueryStudent query builder.createQuery(Student.class);
接下来
RootStudent root query.from(Student.class);
在这里我们看方法名from意思是获取Student的Root其实也就是个Student的包装对象就代表这条sql语句里面的主体。接下来 Predicate p1 builder.like(root.String get(name), % student.getName() %);Predicate p2 builder.equal(root.String get(password), student.getPassword());
Predicate是判断的意思放在sql语句中就是where后面 xxx yyy, xxx like yyy这种也就是查询条件这里构造了2个查询条件分别是根据student的name属性进行like查询和根据student的password进行“”查询在sql中就是
name like ? and password ?
这种形式接下来
query.where(p1, p2);
这样子一个完整的动态查询就构建完成了接下来调用getSingleResult或者getResultList返回结果这里jpa的单个查询如果为空的话会报异常这点感觉框架设计的不好如果查询为空直接返回一个null或者一个空的List更好一点。
这是jpa原生的动态查询方式过程大致就是创建builder 创建Query 构造条件 查询。这么4个步骤这里代码运行良好如果不使用spring-data-jpa我们就需要这么来做但是spring-data-jpa帮我们做得更为彻底从上面的4个步骤中我们发现所有的查询除了第三步不一样其他几步都是一模一样的不使用spring-data-jpa的情况下我们要么4步骤写完要么自己写个工具类封装一下这里spring-data-jpa就是帮我们完成的这样一个动作那就是在JpaSpecificationT这个接口中的
PageT findAll(SpecificationT spec, Pageable pageable);
这个方法前面说了这是个策略模式参数spec是个接口前面也说了框架内部对于这个接口有默认的实现类
Repository
Transactional(readOnly true)
public class SimpleJpaRepositoryT, ID extends Serializable implements JpaRepositoryT, ID,JpaSpecificationExecutorT {}
我们的Repository接口就是继承这个接口而通过cglib的RepositoryImpl的代理类也是这个类的子类默认也就实现了该方法。这个方法的方法体是这样的 /** (non-Javadoc)* see org.springframework.data.jpa.repository.JpaSpecificationExecutor#findOne(org.springframework.data.jpa.domain.Specification)*/public T findOne(SpecificationT spec) {try {return getQuery(spec, (Sort) null).getSingleResult();} catch (NoResultException e) {return null;}} 这里的
getQuery(spec, (Sort) null)
返回类型是
TypedQueryT
进入这个getQuery方法 /*** Creates a {link TypedQuery} for the given {link Specification} and {link Sort}.* * param spec can be {literal null}.* param sort can be {literal null}.* return*/protected TypedQueryT getQuery(SpecificationT spec, Sort sort) {CriteriaBuilder builder em.getCriteriaBuilder();CriteriaQueryT query builder.createQuery(getDomainClass());RootT root applySpecificationToCriteria(spec, query);query.select(root);if (sort ! null) {query.orderBy(toOrders(sort, root, builder));}return applyRepositoryMethodMetadata(em.createQuery(query));} 一切玄机尽收眼底这个方法的内容和我们前面使用原生jpa的api的过程是一样的而再进入
RootT root applySpecificationToCriteria(spec, query);
这个方法 /*** Applies the given {link Specification} to the given {link CriteriaQuery}.* * param spec can be {literal null}.* param query must not be {literal null}.* return*/private S RootT applySpecificationToCriteria(SpecificationT spec, CriteriaQueryS query) {Assert.notNull(query);RootT root query.from(getDomainClass());if (spec null) {return root;}CriteriaBuilder builder em.getCriteriaBuilder();Predicate predicate spec.toPredicate(root, query, builder);if (predicate ! null) {query.where(predicate);}return root;} 我们可以发现spec参数调用了toPredicate方法也就是我们前面service里面匿名内部类的实现。
到这里spring-data-jpa的默认实现已经完全明了。总结一下使用动态查询前面说的原生api需要4步而使用spring-data-jpa只需要一步那就是重写匿名内部类的toPredicate方法。在重复一下上面的Student和Clazz的查询代码 1 Override2 public PageStudent search(final Student student, PageInfo page) {4 return studentRepository.findAll(new SpecificationStudent() {5 Override6 public Predicate toPredicate(RootStudent root, CriteriaQuery? query, CriteriaBuilder cb) {7 8 Predicate stuNameLike null;9 if(null ! student !StringUtils.isEmpty(student.getName())) {
10 stuNameLike cb.like(root.String get(name), % student.getName() %);
11 }
12
13 Predicate clazzNameLike null;
14 if(null ! student null ! student.getClazz() !StringUtils.isEmpty(student.getClazz().getName())) {
15 clazzNameLike cb.like(root.String get(clazz).String get(name), % student.getClazz().getName() %);
16 }
17
18 if(null ! stuNameLike) query.where(stuNameLike);
19 if(null ! clazzNameLike) query.where(clazzNameLike);
20 return null;
21 }
22 }, new PageRequest(page.getPage() - 1, page.getLimit(), new Sort(Direction.DESC, page.getSortName())));
23 } 到这里位置spring-data-jpa的介绍基本上就完成了涵盖了该框架使用的方方面面。接下来还有一块比较实用的东西我们看到上面第15行位置的条件查询这里使用了一个多级的get这个是spring-data-jpa支持的就是嵌套对象的属性这种做法一般我们叫方法的级联调用就是调用的时候返回自己本身这个在处理xml的工具中比较常见主要是为了代码的美观作用没什么其他的用途。
最后还有一个小问题我们上面说了使用动态查询和JPQL两种方式都可以在我们使用JPQL的时候他的语法和常规的sql有点不太一样以Student、Clazz关系为例比如
select * from student t left join clazz tt on t.clazz_id tt.id
这是一个很常规的sql但是JPQL是这么写
select t from Student t left join t.clazz tt
left join右边直接就是t的属性并且也没有了on t.clazz_id tt.id然而并不会出现笛卡尔积这里解释一下为什么没有这个条件在我们的实体中配置了属性的映射关系并且ORM框架的最核心的目的就是要让我们以面向对象的方式来操作数据库显然我们在使用这些框架的时候就不需要关心数据库了只需要关系对象而t.clazz_id tt.id这个是数据库的字段由于配置了字段映射框架内部自己就会去处理所以不需要on t.clazz_id tt.id就是合理的。 前面介绍了spring-data-jpa的使用还有一点忘了悲观所和乐观锁问题这里的乐观锁比较简单jpa有提供注解Version加上该注解自动实现乐观锁byId修改的时候sql自动变成update ... set ... where id ? and version ?比较方便。 in操作的查询 在日常手动写sql的时候有in这种查询是比较多的比如select * from user t where t.id in (1, 2, 3)有人说in的效率不高要少用但是其实只要in是主键或者说是带有索引的效率是很高的mysql中如果in是子查询貌似不会走索引不过我个人经验在我遇到的实际应用中in(ids)这种是比较多的所以一般来说是没有性能问题的。 那么sql里面比较好写但是如果使用spring-data-jpa的动态查询方式呢就和前面的稍微有点区别。大致上是这么一个思路 if(!CollectionUtils.isEmpty(ids)) {InLong in cb.in(root.Long get(id));for (Long id : parentIds) {in.value(id);}query.where(in);
} cb创建一个in的Predicate,然后给这个in赋值最后把in加到where条件中。
手动配置锁 spring-data-jpa支持注解方式的sql比如Query(xxx)另外关于锁的问题在实体中的某个字段配置Version是乐观锁有时候为了使用一个悲观锁或者手动配置一个乐观锁如果实体中没有version字段那么可以使用Lock这个注解它能够被解析成为相关的锁。
一对多、多对多查询查询条件在关联对象中时 1、在JPA中一个实体中如果存在多个关联对象那么不能同时eager获取只能有一个是eager获取其他只能lazy在Hibernate当中有几种独有的解决方法在JPA当中有2中方法i.就是前面的改成延时加载ii.把关联对象的List改成SetList允许重复在多层抓去的时候无法完成映射Hibernate默认抓去4层在第三层的时候如果是List就无法完成映射。 2、在多对多的查询中我们可以使用JPQL也可以使用原生SQL同时还可以使用动态查询这里介绍多对多的动态查询这里有一个条件比较苛刻那就是查询参数是关联对象的属性一对多类似多对一可以利用上面介绍的级联获取属性的方式。这里介绍这种方式的目的是为了更好的利用以面向对象的方式进行动态查询。 举例2张表分别是Employee(id, name)和Company(id, name)二者是多对多的关系那么当查询Employee的时候条件是更具公司名称。那么做法如下 Overridepublic ListEmployee findByCompanyName(final String companyName) {ListEmployee employeeList employeeRepository.findAll(new SpecificationEmployee() {public Predicate toPredicate(RootEmployee root, CriteriaQuery? query, CriteriaBuilder cb) {
// ListJoinEmployee, Company companyJoin root.join(root.getModel().getList(companyList, Company.class), JoinType.LEFT);JoinEmployee, Company companyJoin root.join(companyList, JoinType.LEFT);return cb.equal(companyJoin.get(name), companyName);}});return employeeList;} 我们可以使用上面注释掉的方式也可以使用下面这种比较简单的方式。因为我个人的习惯是尽量不去写DAO的实现类除非查询特别复杂万不得已的情况下采用否则我个人比较偏向于这种方式。 上面的情况如果更为极端的话关联多个对象可以按照下面的方式 Overridepublic ListEmployee findByCompanyName(final String companyName, final String wage) {ListEmployee employeeList employeeRepository.findAll(new SpecificationEmployee() {public Predicate toPredicate(RootEmployee root, CriteriaQuery? query, CriteriaBuilder cb) {
// ListJoinEmployee, Company companyJoin root.join(root.getModel().getList(companyList, Company.class), JoinType.LEFT);JoinEmployee, Company companyJoin root.join(companySet, JoinType.LEFT);JoinEmployee, Wage wageJoin root.join(wageSet, JoinType.LEFT);Predicate p1 cb.equal(companyJoin.get(name), companyName);Predicate p2 cb.equal(wageJoin.get(name), wage);
// return cb.and(p1, p2);根据spring-data-jpa的源码可以返回一个Predicate框架内部会自动做query.where(p)的操作也可以直接在这里处理然后返回null/// 也就是下面一段源码中的实现query.where(p1, p2);return null;}});return employeeList;} /*** Applies the given {link Specification} to the given {link CriteriaQuery}.* * param spec can be {literal null}.* param query must not be {literal null}.* return*/private S RootT applySpecificationToCriteria(SpecificationT spec, CriteriaQueryS query) {Assert.notNull(query);RootT root query.from(getDomainClass());if (spec null) {return root;}CriteriaBuilder builder em.getCriteriaBuilder();Predicate predicate spec.toPredicate(root, query, builder);// 这里如果我们重写的toPredicate方法的返回值predicate不为空那么调用query.where(predicate)if (predicate ! null) {query.where(predicate);}return root;} 说明虽然说JPA中这种方式查询会存在着多次级联查询的问题对性能有所影响但是在一般的企业级应用当中为了开发的便捷这种性能牺牲一般来说是可以接受的。 特别的在一对多中或者多对一中即便是fetch为eager也会先查询主对象再查询关联对象但是在eager的情况下虽然是有多次查询问题但是没有n1问题关联对象不会像n1那样多查询n次而仅仅是把关联对象一次性查询出来因此在企业级应用当中访问量不大的情况下一般来说没什么问题。 补充一段题外话关于Hibernate/JPA/Spring-Data-Jpa与MyBatis的区别联系这种话题很多讨论对于Hibernate/JPA/Spring-Data-Jpa我个人而言基本上能够熟练使用谈不上精通对于mybatis由于深入阅读过几次它的源码对mybatis的设计思想以及细化到具体的方法属性参数算是比较熟悉也开发过一些mybatis的相关插件。对于这两个持久化框架总体来说的区别是Hibernate系列的门槛相对较高配置比较多相对来说难度要大一些主要体现在各种关系的问题上据我所知很多人的理解其实并不深刻很多时候甚至配置得有一定的问题但是优势也很明显SQL自动生成改数据库表结构仅仅需要调整几个注解就行了在熟练使用的基础上相对来说要便捷一点。对于mybatis来说门槛很低真的很低低到分分钟就能入门的程度我个人最喜欢也是mybatis最吸引人的地方就是灵活特别的灵活但是修改数据库表结构之后需要调整的地方比较多但是利用目前比较优秀的插件对于单表操作也基本上能够达到和Hibernate差不多的境界会稍微牺牲一点点性能多表的情况下就要麻烦一点。性能方面的比较由于我没做过测试不太好比较不过应该mybatis要稍微高一些毕竟他的查询SQL可控一些当然Hibernate也支持原生sql但是对结果集的处理不够友好。 不知道最初的出处转自同样转载的http://blog.csdn.net/mendeliangyang/article/details/52366799
