西宁中小企业网站建设,做公司网站需要,网页设计入门模板,wordpress 多次登录一、前言 ps: 大三下学期#xff0c;拿到了一份实习。进入公司后发现用到的技术栈有Spring Data Jpa\Hibernate,但对于持久层框架我只接触了Mybatis\Mybatis-Plus#xff0c;所以就来学习一下Spring Data Jpa。 1.回顾MyBatis
来自官方文档的介绍#xff1a;MyBatis 是一款…一、前言 ps: 大三下学期拿到了一份实习。进入公司后发现用到的技术栈有Spring Data Jpa\Hibernate,但对于持久层框架我只接触了Mybatis\Mybatis-Plus所以就来学习一下Spring Data Jpa。 1.回顾MyBatis
来自官方文档的介绍MyBatis 是一款优秀的持久层框架它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
2.Spring Data Jpa介绍
来自官方文档的介绍Spring Data JPA是更大的Spring Data家族的一部分可以轻松实现基于JPA的存储库。本模块处理对基于 JPA 的数据访问层的增强支持。它使构建使用数据访问技术的 Spring 驱动的应用程序变得更加容易。 详解JPA诞生的缘由是为了整合第三方ORM框架建立一种标准的方式是JDK为了实现ORM的天下归一目前也是在按照这个方向发展但是还没能完全实现。在ORM框架中Hibernate是一支很大的部队使用很广泛也很方便能力也很强同时Hibernate也是和JPA整合的比较良好我们可以认为JPA是标准事实上也是JPA几乎都是接口实现都是Hibernate在做宏观上面看在JPA的统一之下Hibernate很良好的运行。
上面阐述了JPA和Hibernate的关系那么Spring-data-jpa又是个什么东西呢Spring在与第三方整合这方面Spring做了持久化这一块的工作所以就有了Spring-Data这一系列包。包括Spring-Data-Jpa,Spring-Data-Template,Spring-Data-Mongodb,Spring-Data-Redis还有个民间产品mybatis-spring和前面类似这是和mybatis整合的第三方包这些都是干的持久化工具干的事儿。
这里介绍Spring-data-jpa表示与jpa的整合。
在使用持久化工具的时候一般都有一个对象来操作数据库在原生的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语句当然spring-data-jpa也提供自己写sql的方式。Mybatis-plus虽然也可以但是对于Spring-Data-Jpa全自动的ORM来看对于简单的业务显得没有Spring-Data-Jpa那么方便
3.Spring Data JPA与MyBatis对比
Spring Data JPA与MyBatis对比也就是hibernate与MyBatis对比。
从基本概念和框架目标上看两个框架差别还是很大的。hibernate是一个自动化更强、更高级的框架毕竟在java代码层面上省去了绝大部分sql编写取而代之的是用面向对象的方式操作关系型数据库的数据。而MyBatis则是一个能够灵活编写sql语句并将sql的入参和查询结果映射成POJO的一个持久层框架。所以从表面上看hibernate能方便、自动化更强而MyBatis 在Sql语句编写方面则更灵活自由。
如果更上一个抽象层次去看对于数据的操作hibernate是面向对象的而MyBatis是面向关系的。 当然用hibernate也可以写出面向关系代码和系统但却得不到面向关系的各种好处最大的便是编写sql的灵活性同时也失去面向对象意义和好处——一句话不伦不类。那么面向对象和关系型模型有什么不同体现在哪里呢实际上两者要面对的领域和要解决的问题是根本不同的面向对象致力于解决计算机逻辑问题而关系模型致力于解决数据的高效存取问题。 mybatis小巧、方便、高效、简单、直接、半自动 半自动的ORM框架 小巧 mybatis就是jdbc封装 在国内更流行。 场景 在业务比较复杂系统进行使用 hibernate强大、方便、高效、简单复杂、绕弯子、全自动 全自动的ORM框架 强大根据ORM映射生成不同SQL 在国外更流。 场景 在业务相对简单的系统进行使用随着微服务的流行。 介绍这么多来看一下Spring-Data-Jpa的具体用法吧
二、Spring-Data-Jpa的使用
JPA仅仅是一种规范也就是说JPA仅仅定义了一些接口而接口是需要实现才能工作的。所以底层需要某种实现而Hibernate就是实现了JPA接口的ORM框架。也就是说JPA是一套ORM规范Hibernate实现了JPA规范
2.1Hibernate示例
pom.xml
dependencies!-- junit4 --dependencygroupIdjunit/groupIdartifactIdjunit/artifactIdversion4.13/versionscopetest/scope/dependency!-- hibernate对jpa的支持包 --dependencygroupIdorg.hibernate/groupIdartifactIdhibernate-entitymanager/artifactIdversion5.4.32.Final/version/dependency!-- Mysql and MariaDB --dependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdversion8.0.26/version/dependency!--openjpa--dependencygroupIdorg.apache.openjpa/groupIdartifactIdopenjpa-all/artifactIdversion3.2.0/version/dependency/dependencies实体类
Data
Entity // 作为hibernate 实体类
Table(name tb_customer) // 映射的表明
public class Customer {/*** Id声明主键的配置* GeneratedValue:配置主键的生成策略* strategy* GenerationType.IDENTITY 自增mysql* * 底层数据库必须支持自动增长底层数据库支持的自动增长方式对id自增* GenerationType.SEQUENCE : 序列oracle* * 底层数据库必须支持序列* GenerationType.TABLE : jpa提供的一种机制通过一张数据库表的形式帮助我们完成主键自增* GenerationType.AUTO 由程序自动的帮助我们选择主键生成策略* Column:配置属性和字段的映射关系* name数据库表中字段的名称*/IdGeneratedValue(strategy GenerationType.IDENTITY)Column(name id)private Long custId; //客户的主键Column(name cust_name)private String custName;//客户名称Column(namecust_address)private String custAddress;//客户地址
}hibernate.cfg.xml
?xml version1.0 encodingUTF-8?
!DOCTYPE hibernate-configuration PUBLIC-//Hibernate/Hibernate Configuration DTD 3.0//ENhttp://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd
hibernate-configurationsession-factory!-- 配置数据库连接信息 --property nameconnection.driver_classcom.mysql.cj.jdbc.Driver/propertyproperty nameconnection.urljdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8/propertyproperty nameconnection.usernameroot/propertyproperty nameconnection.password123456/property!-- 会在日志中记录sql 默认false--property nameshow_sqltrue/property!--是否格式化sql 默认false--property nameformat_sqltrue/property!--表生成策略默认none 不自动生成update 如果没有表会创建有会检查更新create 创建--property namehbm2ddl.autoupdate/property!-- 配置方言选择数据库类型 --property namedialectorg.hibernate.dialect.MySQL57InnoDBDialect/property!--指定哪些pojo 需要进行ORM映射--mapping classcom.tuling.pojo.Customer/mapping/session-factory
/hibernate-configuration测试
public class HibernateTest {// Session工厂 Session:数据库会话 代码和数据库的一个桥梁private SessionFactory sf;Beforepublic void init() {StandardServiceRegistry registry new StandardServiceRegistryBuilder().configure(/hibernate.cfg.xml).build();//2. 根据服务注册类创建一个元数据资源集同时构建元数据并生成应用一般唯一的的session工厂sf new MetadataSources(registry).buildMetadata().buildSessionFactory();}Test //保存一个对象public void testC(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();Customer customer new Customer();customer.setCustName(徐庶);session.save(customer);tx.commit();}}Test //查找public void testR(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();Customer customer session.find(Customer.class, 1L);System.out.println();System.out.println(customer);tx.commit();}}Test //利用缓存查找对象public void testR_lazy(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();Customer customer session.load(Customer.class, 1L);System.out.println();System.out.println(customer);tx.commit();}}Test //更新public void testU(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();Customer customer new Customer();//customer.setCustId(1L);customer.setCustName(徐庶);// 插入session.save()// 更新session.update();session.saveOrUpdate(customer);tx.commit();}}Test //删除public void testD(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();Customer customer new Customer();customer.setCustId(2L);session.remove(customer);tx.commit();}}Test //自定义sqlpublic void testR_HQL(){// session进行持久化操作try(Session session sf.openSession()){Transaction tx session.beginTransaction();String hql FROM Customer where custId:id;ListCustomer resultList session.createQuery(hql, Customer.class).setParameter(id,1L).getResultList();System.out.println(resultList);tx.commit();}}
}2.2Jpa示例
添加META-INF\persistence.xml
?xml version1.0 encodingUTF-8?
persistence xmlnshttp://java.sun.com/xml/ns/persistence version2.0!--需要配置persistence-unit节点持久化单元name持久化单元名称transaction-type事务管理的方式JTA分布式事务管理RESOURCE_LOCAL本地事务管理--persistence-unit namehibernateJPA transaction-typeRESOURCE_LOCAL!--jpa的实现方式 --providerorg.hibernate.jpa.HibernatePersistenceProvider/provider!--需要进行ORM的POJO类--classcom.tuling.pojo.Customer/class!--可选配置配置jpa实现方的配置信息--properties!-- 数据库信息用户名javax.persistence.jdbc.user密码 javax.persistence.jdbc.password驱动 javax.persistence.jdbc.driver数据库地址 javax.persistence.jdbc.url--property namejavax.persistence.jdbc.user valueroot/property namejavax.persistence.jdbc.password value123456/property namejavax.persistence.jdbc.driver valuecom.mysql.cj.jdbc.Driver/property namejavax.persistence.jdbc.url valuejdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8/!--配置jpa实现方(hibernate)的配置信息显示sql false|true自动创建数据库表 hibernate.hbm2ddl.autocreate : 程序运行时创建数据库表如果有表先删除表再创建update 程序运行时创建表如果有表不会创建表none 不会创建表--property namehibernate.show_sql valuetrue /property namehibernate.hbm2ddl.auto valueupdate /property namehibernate.dialect valueorg.hibernate.dialect.MySQL5InnoDBDialect //properties/persistence-unitpersistence-unit nameopenJpa transaction-typeRESOURCE_LOCAL!--jpa的实现方式 --providerorg.apache.openjpa.persistence.PersistenceProviderImpl/provider!-- 指定哪些实体需要持久化 --classcom.tuling.pojo.Customer/class!--可选配置配置jpa实现方的配置信息--properties!-- 数据库信息用户名javax.persistence.jdbc.user密码 javax.persistence.jdbc.password驱动 javax.persistence.jdbc.driver数据库地址 javax.persistence.jdbc.url--property namejavax.persistence.jdbc.user valueroot/property namejavax.persistence.jdbc.password value123456/property namejavax.persistence.jdbc.driver valuecom.mysql.cj.jdbc.Driver/property namejavax.persistence.jdbc.url valuejdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8/!--配置jpa实现方(openjpa)的配置信息--!-- 可以自动生成数据库表 --property nameopenjpa.jdbc.SynchronizeMappings valuebuildSchema(ForeignKeystrue)//properties/persistence-unit
/persistence测试 提示Hibernate中叫做Session在JPA中叫做EntityManager jpa的对象4种状态
临时状态刚创建出来∙没有与entityManager发生关系没有被持久化不处于entityManager中的对象持久状态∙与entityManager发生关系已经被持久化您可以把持久化状态当做实实在在的数据库记录。删除状态执行remove方法事物提交之前游离状态游离状态就是提交到数据库后事务commit后实体的状态因事务已经提交了此时实体的属 性任你如何改变也不会同步到数据库因为游离是没人管的孩子不在持久化上下文中。
public void persist(Object entity)persist方法可以将实例转换为managed(托管)状态。在调用flush()方法或提交事物后实
例将会被插入到数据库中。对不同状态下的实例Apersist会产生以下操作:
1. 如果A是一个new状态的实体它将会转为managed状态
2. 如果A是一个managed状态的实体它的状态不会发生任何改变。但是系统仍会在数据库执行INSERT操作
3. 如果A是一个removed(删除)状态的实体它将会转换为受控状态
4. 如果A是一个detached(分离)状态的实体该方法会抛出IllegalArgumentException异常具体异常根据不同的
JPA实现有关。public class JpaTest {EntityManagerFactory factory;Beforepublic void before(){factory Persistence.createEntityManagerFactory(hibernateJPA);}Testpublic void testC(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();Customer customer new Customer();customer.setCustName(张三);em.persist(customer); // 保存并使得实体保持Managed状态tx.commit();}// 立即查询Testpublic void testR(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();Customer customer em.find(Customer.class, 1L);System.out.println();System.out.println(customer);tx.commit();}// 延迟查询Testpublic void testR_lazy(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();Customer customer em.getReference(Customer.class, 1L);System.out.println();System.out.println(customer);tx.commit();}Testpublic void testU(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();Customer customer new Customer();customer.setCustId(5L);customer.setCustName(王五);/**// 如果指定了主键更新 1.先查询 看是否有变化如果有变化 更新 如果没有变化就不更新* 如果没有指定了主键* 插入* */em.merge(customer);tx.commit();}Test//自定义sqlpublic void testU_JPQL(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();String jpqlUPDATE Customer set custName:name where custId:id;em.createQuery(jpql).setParameter(name,李四).setParameter(id,5L).executeUpdate();tx.commit();}Testpublic void testU_SQL(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();String sqlUPDATE tb_customer set cust_name:name where id:id;em.createNativeQuery(sql).setParameter(name,王五).setParameter(id,5L).executeUpdate();tx.commit();}Testpublic void testD(){EntityManager em factory.createEntityManager();EntityTransaction tx em.getTransaction();tx.begin();Customer customer em.find(Customer.class,5L);em.remove(customer);tx.commit();}
}
3.1Spring Data JPA实例
我们来实现一个基于Spring Data JPA的示例感受一下和之前单独使用的区别: 依赖 父pom: !--统一管理SpringData子项目的版本--dependencyManagementdependenciesdependencygroupIdorg.springframework.data/groupIdartifactIdspring-data-bom/artifactIdversion2021.1.0/versionscopeimport/scopetypepom/type/dependency/dependencies/dependencyManagement子pom: dependencygroupIdorg.springframework.data/groupIdartifactIdspring-data-jpa/artifactId/dependency!-- junit4 --dependencygroupIdjunit/groupIdartifactIdjunit/artifactIdversion4.13/versionscopetest/scope/dependency!-- hibernate对jpa的支持包 --dependencygroupIdorg.hibernate/groupIdartifactIdhibernate-entitymanager/artifactIdversion5.4.32.Final/version/dependency!-- Mysql and MariaDB --dependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdversion8.0.26/version/dependency!--连接池--dependencygroupIdcom.alibaba/groupIdartifactIddruid/artifactIdversion1.2.8/version/dependency!--spring-test --dependencygroupIdorg.springframework/groupIdartifactIdspring-test/artifactIdversion5.3.10/versionscopetest/scope/dependency!-- querydsl --dependencygroupIdcom.querydsl/groupIdartifactIdquerydsl-jpa/artifactIdversion${querydsl.version}/version/dependencySpringDataJPAConfig
Configuration // 标记当前类为配置类 xml配文件
EnableJpaRepositories(basePackagescom.tuling.repositories) // 启动jpa jpa:repositories
EnableTransactionManagement // 开启事务
public class SpringDataJPAConfig {/** !--数据源--bean classcom.alibaba.druid.pool.DruidDataSource namedataSourceproperty nameusername valueroot/property namepassword value123456/property namedriverClassName valuecom.mysql.cj.jdbc.Driver/property nameurl valuejdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8//bean* */Beanpublic DataSource dataSource() {DruidDataSource dataSource new DruidDataSource();dataSource.setUsername(root);dataSource.setPassword(123456);dataSource.setDriverClassName(com.mysql.cj.jdbc.Driver);dataSource.setUrl(jdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8);return dataSource;}/** !--EntityManagerFactory--bean nameentityManagerFactory classorg.springframework.orm.jpa.LocalContainerEntityManagerFactoryBeanproperty namejpaVendorAdapter!--Hibernate实现--bean classorg.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter!--生成数据库表--property namegenerateDdl valuetrue/propertyproperty nameshowSql valuetrue/property/bean/property!--设置实体类的包--property namepackagesToScan valuecom.tuling.pojo/propertyproperty namedataSource refdataSource /property/bean* */Beanpublic LocalContainerEntityManagerFactoryBean entityManagerFactory() {HibernateJpaVendorAdapter vendorAdapter new HibernateJpaVendorAdapter();vendorAdapter.setGenerateDdl(true);vendorAdapter.setShowSql(true);LocalContainerEntityManagerFactoryBean factory new LocalContainerEntityManagerFactoryBean();factory.setJpaVendorAdapter(vendorAdapter);factory.setPackagesToScan(com.tuling.pojo);factory.setDataSource(dataSource());return factory;}/** bean classorg.springframework.orm.jpa.JpaTransactionManager nametransactionManagerproperty nameentityManagerFactory refentityManagerFactory/property/bean* */Beanpublic PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {JpaTransactionManager txManager new JpaTransactionManager();txManager.setEntityManagerFactory(entityManagerFactory);return txManager;}
}XML
?xml version1.0 encodingUTF-8?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:jpahttp://www.springframework.org/schema/data/jpa xmlns:txhttp://www.springframework.org/schema/txxsi:schemaLocationhttp://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/data/jpahttps://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd!--用于整合jpa EnableJpaRepositories --jpa:repositories base-packagecom.tuling.repositoriesentity-manager-factory-refentityManagerFactorytransaction-manager-reftransactionManager/!--EntityManagerFactory--bean nameentityManagerFactory classorg.springframework.orm.jpa.LocalContainerEntityManagerFactoryBeanproperty namejpaVendorAdapter!--Hibernate实现--bean classorg.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter!--生成数据库表--property namegenerateDdl valuetrue/propertyproperty nameshowSql valuetrue/property/bean/property!--设置实体类的包--property namepackagesToScan valuecom.tuling.pojo/propertyproperty namedataSource refdataSource /property/bean!--数据源--bean classcom.alibaba.druid.pool.DruidDataSource namedataSourceproperty nameusername valueroot/property namepassword value123456/property namedriverClassName valuecom.mysql.cj.jdbc.Driver/property nameurl valuejdbc:mysql://localhost:3306/springdata_jpa?characterEncodingUTF-8//bean!--声明式事务--bean classorg.springframework.orm.jpa.JpaTransactionManager nametransactionManagerproperty nameentityManagerFactory refentityManagerFactory/property/bean!--启动注解方式的声明式事务--tx:annotation-driven transaction-managertransactionManager/tx:annotation-driven/beanspojo
Data
Entity // 作为hibernate 实体类
Table(name tb_customer) // 映射的表明
public class Customer {IdGeneratedValue(strategy GenerationType.IDENTITY)Column(name id)private Long custId; //客户的主键Column(name cust_name)private String custName;//客户名称Column(namecust_address)private String custAddress;//客户地址
}CustomerRepository 使用 Spring Data Repositories抽象的目标是显着减少为各种持久性存储实现数据访问层所需的样板代码量。
CrudRepository
1
2 // 用来插入和修改 有主键就是修改 没有就是新增
3 // 获得插入后自增id 获得返回值
4 S extends T S save(S entity);
5
6 // 通过集合保存多个实体
7 S extends T IterableS saveAll(IterableS entities);
8 // 通过主键查询实体
9 OptionalT findById(ID id);
10 // 通过主键查询是否存在 返回boolean
11 boolean existsById(ID id);
12 // 查询所有
13 IterableT findAll();
14 // 通过集合的主键 查询多个实体 返回集合
15 IterableT findAllById(IterableID ids);
16 // 查询总数量
17 long count();
18 // 根据id进行删除
19 void deleteById(ID id);
20 // 根据实体进行删除
21 void delete(T entity);
22 // 删除多个
23 void deleteAllById(Iterable? extends ID ids);
24 // 删除多个传入集合实体
25 void deleteAll(Iterable? extends T entities);
26 // 删除所有
27 void deleteAll();public interface CustomerRepository extends PagingAndSortingRepositoryCustomer, Long {
}测试
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class SpringdataJpaTest {AutowiredCustomerRepository repository;Testpublic void testR(){OptionalCustomer byId repository.findById(1L);System.out.println(byId.orElse(null));}Testpublic void testC(){Customer customer new Customer();customer.setCustName(李四);System.out.println(repository.save(customer));}Testpublic void testD(){Customer customer new Customer();customer.setCustId(3L);customer.setCustName(李四);repository.delete(customer);}Testpublic void testFindAll(){IterableCustomer allById repository.findAllById(Arrays.asList(1L, 7L, 8L));System.out.println(allById);}}
3.1.1分页
在 之上CrudRepository有一个PagingAndSortingRepository抽象它添加了额外的方法来简化对实体的分页访问
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class SpringDataJpaPagingAndSortTest
{// jdk动态代理的实例Autowired(requiredfalse)CustomerRepository repository;Testpublic void insertCustomer() {for (int i 20; i 50; i) {Customer customer new Customer();customer.setCustName(张三i);customer.setCustAddress(北京);repository.save(customer);}}Testpublic void testPaging(){PageCustomer all repository.findAll(PageRequest.of(0, 2));System.out.println(all.getTotalPages());System.out.println(all.getTotalElements());System.out.println(all.getContent());}Testpublic void testSort(){Sort sort Sort.by(custId).descending();IterableCustomer all repository.findAll(sort);System.out.println(all);}Testpublic void testSortTypeSafe(){Sort.TypedSortCustomer sortType Sort.sort(Customer.class);Sort sort sortType.by(Customer::getCustId).descending();IterableCustomer all repository.findAll(sort);System.out.println(all);}
}
3.1.2自定义操作
1.jpql原生SQL) Query 查询如果返回单个实体 就用pojo接收 如果是多个需要通过集合 参数设置方式 索引 ?数字具名 :参数名 结合Param注解指定参数名字 增删改 要加上事务的支持如果是插入方法一定只能在hibernate下才支持 Insert into …select )
Transactional // 通常会放在业务逻辑层上面去声明
Modifying // 通知springdatajpa 是增删改的操作2.规定方法名 支持的查询方法主题关键字前缀
决定当前方法作用只支持查询和删除
详见官方文档
3.Query by Example
只支持查询
不支持嵌套或分组的属性约束如 firstname 0 or (firstname 1 and lastname 2).只支持字符串 start/contains/ends/regex 匹配和其他属性类型的精确匹 配。
实现 1.将Repository继承QueryByExampleExecutor
public interface CustomerQBERepositoryextends PagingAndSortingRepositoryCustomer, Long, QueryByExampleExecutorCustomer {}2.测试代码
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class QBETest {// jdk动态代理的实例AutowiredCustomerQBERepository repository;/*** 简单实例 客户名称 客户地址动态查询*/Testpublic void test01(){// 查询条件Customer customernew Customer();customer.setCustName(徐庶);customer.setCustAddress(BEIJING);// 通过Example构建查询条件ExampleCustomer example Example.of(customer);ListCustomer list (ListCustomer) repository.findAll(example);System.out.println(list);}/*** 通过匹配器 进行条件的限制* 简单实例 客户名称 客户地址动态查询*/Testpublic void test02(){// 查询条件Customer customernew Customer();customer.setCustName(庶);customer.setCustAddress(JING);// 通过匹配器 对条件行为进行设置ExampleMatcher matcher ExampleMatcher.matching()//.withIgnorePaths(custName) // 设置忽略的属性//.withIgnoreCase(custAddress) // 设置忽略大小写//.withStringMatcher(ExampleMatcher.StringMatcher.ENDING); // 对所有条件字符串进行了结尾匹配.withMatcher(custAddress,m - m.endsWith().ignoreCase()); // 针对单个条件进行限制, 会使withIgnoreCase失效需要单独设置//.withMatcher(custAddress, ExampleMatcher.GenericPropertyMatchers.endsWith().ignoreCase());// 通过Example构建查询条件ExampleCustomer example Example.of(customer,matcher);ListCustomer list (ListCustomer) repository.findAll(example);System.out.println(list);}
}
4.Specifications 在之前使用Query by Example只能针对字符串进行条件设置那如果希望对所有类型支持可以使用Specifications 实现 public interface CustomerRepository extends CrudRepositoryCustomer, Long, JpaSpecificationExecutorCustomer {}2.传入Specification的实现 结合lambda表达式
repository.findAll((SpecificationCustomer)(root, query, criteriaBuilder) ‐{// Todo...return null;});
}Root查询哪个表关联查询 from CriteriaQuery查询哪些字段排序是什么 组合(order by . where ) CriteriaBuilder条件之间是什么关系如何生成一个查询条件每一个查询条件都是什么类型 between in…) where PredicateExpression 每一条查询条件的详细描述 ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class SpecificationTest {// jdk动态代理的实例AutowiredCustomerSpecificationsRepository repository;Testpublic void testR(){ListCustomer customer repository.findAll(new SpecificationCustomer() {Overridepublic Predicate toPredicate(RootCustomer root, CriteriaQuery? query, CriteriaBuilder cb) {// root from Customer , 获取列// CriteriaBuilder where 设置各种条件 ( in ..)// query 组合order by , where)return null;}});System.out.println(customer);}Testpublic void testR5(){Customer paramsnew Customer();//params.setCustAddress(BEIJING);params.setCustId(0L);params.setCustName(徐庶,王五);ListCustomer customer repository.findAll(new SpecificationCustomer() {Overridepublic Predicate toPredicate(RootCustomer root, CriteriaQuery? query, CriteriaBuilder cb) {// root from Customer , 获取列// CriteriaBuilder where 设置各种条件 ( in ..)// query 组合order by , where)PathLong custId root.get(custId);PathString custName root.get(custName);PathString custAddress root.get(custAddress);// 参数1 为哪个字段设置条件 参数2值ListPredicate listnew ArrayList();if(!StringUtils.isEmpty(params.getCustAddress())) {list.add(cb.equal(custAddress, BEIJING)) ;}if(params.getCustId()-1){list.add(cb.greaterThan(custId, 0L));}if(!StringUtils.isEmpty(params.getCustName())) {CriteriaBuilder.InString in cb.in(custName);in.value(徐庶).value(王五);list.add(in);}Predicate and cb.and(list.toArray(new Predicate[list.size()]));Order desc cb.desc(custId);return query.where(and).orderBy(desc).getRestriction();}});System.out.println(customer);}
}
5.Querydsl 官网网址 QueryDSL是基于ORM框架或SQL平台上的一个通用查询框架。借助QueryDSL可以在任何支持的ORM框架或SQL平台上以通用API方式构建查询。
JPA是QueryDSL的主要集成技术是JPQL和Criteria查询的代替方法。目前QueryDSL支持的平台包括JPA,JDO,SQL,Mongodb 等等
Querydsl扩展能让我们以链式方式代码编写查询方法。该扩展需要一个接口QueryDslPredicateExecutor它定义了很多查询方法。
接口继承了该接口就可以使用该接口提供的各种方法了
public interface QuerydslPredicateExecutorT {OptionalT findOne(Predicate predicate);IterableT findAll(Predicate predicate);IterableT findAll(Predicate predicate, Sort sort);IterableT findAll(Predicate predicate, OrderSpecifier?... orders);IterableT findAll(OrderSpecifier?... orders);PageT findAll(Predicate predicate, Pageable pageable);long count(Predicate predicate);boolean exists(Predicate predicate);S extends T, R R findBy(Predicate predicate, FunctionFetchableFluentQueryS, R queryFunction);
}引入依赖 !-- querydsl --dependencygroupIdcom.querydsl/groupIdartifactIdquerydsl-jpa/artifactIdversion${querydsl.version}/version/dependency添加插件 这个插件是为了让程序自动生成query type(查询实体命名方式为“Q”对应实体名)。
buildpluginsplugingroupIdcom.mysema.maven/groupIdartifactIdapt-maven-plugin/artifactIdversion${apt.version}/versiondependenciesdependencygroupIdcom.querydsl/groupIdartifactIdquerydsl-apt/artifactIdversion${querydsl.version}/version/dependency/dependenciesexecutionsexecutionphasegenerate-sources/phasegoalsgoalprocess/goal/goalsconfigurationoutputDirectorytarget/generated-sources/queries/outputDirectoryprocessorcom.querydsl.apt.jpa.JPAAnnotationProcessor/processorlogOnlyOnErrortrue/logOnlyOnError/configuration/execution/executions/plugin/plugins/build测试
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class QueryDSLTest {AutowiredCustomerQueryDSLRepository repository;Testpublic void test01() {QCustomer customer QCustomer.customer;// 通过Id查找BooleanExpression eq customer.custId.eq(1L);System.out.println(repository.findOne(eq));}/*** 查询客户名称范围 (in)* id 大于* 地址 精确*/Testpublic void test02() {QCustomer customer QCustomer.customer;// 通过Id查找BooleanExpression and customer.custName.in(徐庶, 王五).and(customer.custId.gt(0L)).and(customer.custAddress.eq(BEIJING));System.out.println(repository.findOne(and));}/*** 查询客户名称范围 (in)* id 大于* 地址 精确*/Testpublic void test03() {Customer paramsnew Customer();params.setCustAddress(BEIJING);params.setCustId(0L);params.setCustName(徐庶,王五);QCustomer customer QCustomer.customer;// 初始条件 类似于11 永远都成立的条件BooleanExpression expression customer.isNotNull().or(customer.isNull());expressionparams.getCustId()-1?expression.and(customer.custId.gt(params.getCustId())):expression;expression!StringUtils.isEmpty( params.getCustName())?expression.and(customer.custName.in(params.getCustName().split(,))):expression;expression!StringUtils.isEmpty( params.getCustAddress())?expression.and(customer.custAddress.eq(params.getCustAddress())):expression;System.out.println(repository.findAll(expression));}// 解决线程安全问题PersistenceContextEntityManager em;/*** 自定义列查询、分组* 需要使用原生态的方式Specification)* 通过Repository进行查询 列、表都是固定*/Testpublic void test04() {JPAQueryFactory factory new JPAQueryFactory(em);QCustomer customer QCustomer.customer;// 构建基于QueryDSL的查询JPAQueryTuple tupleJPAQuery factory.select(customer.custId, customer.custName).from(customer).where(customer.custId.eq(1L)).orderBy(customer.custId.desc());// 执行查询ListTuple fetch tupleJPAQuery.fetch();// 处理返回数据for (Tuple tuple : fetch) {System.out.println(tuple.get(customer.custId));System.out.println(tuple.get(customer.custName));}}Testpublic void test05() {JPAQueryFactory factory new JPAQueryFactory(em);QCustomer customer QCustomer.customer;// 构建基于QueryDSL的查询JPAQueryLong longJPAQuery factory.select(customer.custId.sum()).from(customer)//.where(customer.custId.eq(1L)).orderBy(customer.custId.desc());// 执行查询ListLong fetch longJPAQuery.fetch();// 处理返回数据for (Long sum : fetch) {System.out.println(sum);}}
}3.1.3多表关联操作
一对一 1、配置管理关系 OneToOne JoinColumn(name“外键字段名”)
OneToOne
JoinColumn(namecustomer_id)
private Customer customer;Entity // 作为hibernate 实体类
Table(name tb_customer) // 映射的表明
Data
EntityListeners(AuditingEntityListener.class)
public class Customer {IdGeneratedValue(strategy GenerationType.IDENTITY)Column(name id)private Long custId; //客户的主键Column(name cust_name)private String custName;//客户名称Column(namecust_address)private String custAddress;//客户地址// 单向关联 一对一/** cascade 设置关联操作* ALL, 所有持久化操作PERSIST 只有插入才会执行关联操作MERGE, 只有修改才会执行关联操作REMOVE, 只有删除才会执行关联操作fetch 设置是否懒加载EAGER 立即加载默认LAZY 懒加载 直到用到对象才会进行查询因为不是所有的关联对象 都需要用到orphanRemoval 关联移除通常在修改的时候会用到一旦把关联的数据设置null 或者修改为其他的关联数据 如果想删除关联数据 就可以设置trueoptional 限制关联的对象不能为nulltrue 可以为null(默认 ) false 不能为nullmappedBy 将外键约束执行另一方维护(通常在双向关联关系中会放弃一方的外键约束值 另一方关联属性名**/OneToOne(mappedBy customer,cascade CascadeType.ALL,fetch FetchType.LAZY,orphanRemovaltrue/*,optionalfalse*/)// 设置外键的字段名JoinColumn(nameaccount_id)private Account account;
}测试
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class OneToOneTest {AutowiredCustomerRepository repository;// 插入Testpublic void testC(){// 初始化数据Account account new Account();account.setUsername(xushu);Customer customer new Customer();customer.setCustName(徐庶);customer.setAccount(account);account.setCustomer(customer);repository.save(customer);}// 插入Test// 为什么懒加载要配置事务 // 当通过repository调用完查询方法session就会立即关闭 一旦session你就不能查询// 加了事务后 就能让session直到事务方法执行完毕后才会关闭Transactional(readOnly true)public void testR(){OptionalCustomer customer repository.findById(3L); // 只查询出客户 session关闭System.out.println();System.out.println(customer.get()); // toString}Testpublic void testD(){repository.deleteById(1L);}Testpublic void testU(){Customer customer new Customer();customer.setCustId(16L);customer.setCustName(徐庶);customer.setAccount(null);repository.save(customer);}
} 差异 这两个设置之间的区别在于对 断开关系.例如当设置 地址字段设置为null或另一个Address对象. 如果指定了 orphanRemoval true 则会自动删除断开连接的Address实例.这对于清理很有用 没有一个不应该存在的相关对象(例如地址) 来自所有者对象(例如员工)的引用. 如果仅指定 cascade CascadeType.REMOVE 则不会执行任何自动操作因为断开关系不是删除操作 一对多 1.、配置管理关系 OneToMany JoinColumn(name“customer_id”)
// 一对多
// fetch 默认是懒加载 懒加载的优点 提高查询性能
OneToMany(cascade CascadeType.ALL,fetch FetchType.LAZY)
JoinColumn(namecustomer_id)
private ListMessage messages;2、配置关联操作 /**** 一客户对多信息*/
Entity
Table(nametb_message)
Data
public class Message {IdGeneratedValue(strategy GenerationType.IDENTITY)private Long id;private String info;// 多对一ManyToOne(cascade {CascadeType.PERSIST,CascadeType.REMOVE})JoinColumn(namecustomer_id)private Customer customer;// 一定要有、否则查询就会有问题public Message() {}public Message(String info) {this.info info;}public Message(String info, Customer customer) {this.info info;this.customer customer;}Overridepublic String toString() {return Message{ id id , info info \ , customerId customer.getCustId() , customerName customer.getCustName() };}
}
多对一与一对多相似就不做演示 多对多 1、配置管理关系 ManyToMany JoinColumn(name“customer_id”) // 单向多对多
ManyToMany(cascade CascadeType.ALL)
/*中间表需要通过JoinTable来维护外键不设置也会自动生成
* name 指定中间表的名称
* joinColumns 设置本表的外键名称
* inverseJoinColumns 设置关联表的外键名称
* */
JoinTable(nametb_customer_role,joinColumns {JoinColumn(namec_id)},inverseJoinColumns {JoinColumn(namer_id)}
)
private ListRole roles;2、配置关联操作
/*** 多用户对多角色*/
Entity
Table(nametb_role)
Data
public class Role {IdGeneratedValue(strategy GenerationType.IDENTITY)private Long id;Column(namerole_name)private String rName;public Role(String rName) {this.rName rName;}public Role(Long id, String rName) {this.id id;this.rName rName;}public Role() {}ManyToMany(cascade CascadeType.ALL)private ListRole roles;
}
测试
ContextConfiguration(classes SpringDataJPAConfig.class)
RunWith(SpringJUnit4ClassRunner.class)
public class ManyToManyTest {AutowiredCustomerRepository repository;AutowiredRoleRepository roleRepository;Testpublic void testSave(){ListRole roles new ArrayList();roles.add(new Role(管理员));roles.add(new Role(普通用户));Customer customer new Customer();customer.setCustName(诸葛);customer.setRoles(roles);repository.save(customer);}// 保存/*1.如果保存的关联数据 希望使用已有的 就需要从数据库中查出来持久状态。否则 提示 游离状态不能持久化2.如果一个业务方法有多个持久化操作 记得加上Transactional 否则不能共用一个session3. 在单元测试中用到了Transactional , 如果有增删改的操作一定要加Commit4. 单元测试会认为你的事务方法Transactional 只是测试而已 它不会为你提交事务 需要单独加上 Commit*/TestTransactionalCommitpublic void testC() {ListRole rolesnew ArrayList();roles.add(roleRepository.findById(1L).get());roles.add(roleRepository.findById(2L).get());Customer customer new Customer();customer.setCustName(诸葛);customer.setRoles(roles);repository.save(customer);}TestTransactional(readOnly true)public void testR() {System.out.println(repository.findById(14L));//repository.save(customer);}/** 注意加上* TransactionalCommit多对多其实不适合删除 因为经常出现数据出现可能除了和当前这端关联还会关联另一端此时删除就会 ConstraintViolationException。* 要删除 要保证没有额外其他另一端数据关联* */TestTransactionalCommitpublic void testD() {OptionalCustomer customer repository.findById(14L);repository.delete(customer.get());}
}
乐观锁 hibernate 防并发修改
private Version Long version;三、SpringBoot整合Spring-Data-Jpa
依赖
dependencies!--data-jpa的场景启动器--dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-data-jpa/artifactId/dependencydependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactId/dependencydependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdscoperuntime/scope/dependencydependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-test/artifactIdscopetest/scope/dependency/dependenciesbuildpluginsplugingroupIdorg.springframework.boot/groupIdartifactIdspring-boot-maven-plugin/artifactId/plugin/plugins/build常用配置 # 数据库表的生成策略
spring.jpa.hibernate.ddl-autoupdate
spring.datasource.urljdbc:mysql://localhost:3306/springdata_jpa?serverTimezoneUTC
spring.datasource.usernameroot
spring.datasource.password123456
spring.datasource.driver-class-namecom.mysql.cj.jdbc.Driver
# 是否显示sql在控制台
spring.jpa.show-sql true
spring.jpa.properties.hibernate.format_sqltrue
server.port8088可选配置 Hibernate官方文档 SpirngDataJpa官方文档
剩下就是正常开发流程持久层、业务层、控制层 四、总结
Hibernate随着微服务的流行随着服务的拆分使得业务变得简单起来此时HIbernate这个全自动ORM框架深受各个企业的青睐。JPA则是为了整合第三方ORM框架建立一种标准的方式。Mybatis则是半自动的ORM框架在一些业务比较复杂系统进行使用。所以对于一个大型项目公司往往会采用SpringDataJpa\Hibernate\Mybatis等几者结合来解决不同的业务场景。
