Hibernate SpringDataJpa 和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>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.32.Final</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>

<dependency>
<groupId>org.apache.openjpa</groupId>
<artifactId>openjpa-all</artifactId>
<version>3.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：数据库表中字段的名称
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long custId; //客户的主键

@Column(name = "cust_name")
private String custName;//客户名称

@Column(name="cust_address")
private String custAddress;//客户地址
}

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>

<property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8</property>
<property name="connection.username">root</property>
<property name="connection.password">123456</property>

<property name="show_sql">true</property>

<property name="format_sql">true</property>

<property name="hbm2ddl.auto">update</property>

<property name="dialect">org.hibernate.dialect.MySQL57InnoDBDialect</property>

<mapping class="com.tuling.pojo.Customer"></mapping>
</session-factory>
</hibernate-configuration>

测试

public class HibernateTest {

// Session工厂 Session:数据库会话代码和数据库的一个桥梁
private SessionFactory sf;
@Before
public 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 //自定义sql
public void testR_HQL(){
// session进行持久化操作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
String hql=" FROM Customer where custId=:id";
List<Customer> resultList = session.createQuery(hql, Customer.class)
.setParameter("id",1L)
.getResultList();
System.out.println(resultList);
tx.commit();
}
}
}

2.2Jpa示例
添加META-INF\persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">

<persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">

<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

<class>com.tuling.pojo.Customer</class>

<properties>

<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="123456"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>

<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />

</properties>
</persistence-unit>

<persistence-unit name="openJpa" transaction-type="RESOURCE_LOCAL">

<provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>

<class>com.tuling.pojo.Customer</class>

<properties>

<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="123456"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>

<property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
</properties>
</persistence-unit>
</persistence>

测试

提示：Hibernate中叫做Session，在JPA中叫做EntityManager

jpa的对象4种状态

临时状态：刚创建出来，∙没有与entityManager发生关系，没有被持久化，不处于entityManager中的对象
持久状态：∙与entityManager发生关系，已经被持久化，您可以把持久化状态当做实实在在的数据库记录。
删除状态：执行remove方法，事物提交之前
游离状态：游离状态就是提交到数据库后，事务commit后实体的状态，因事务已经提交了，此时实体的属
性任你如何改变，也不会同步到数据库，因为游离是没人管的孩子，不在持久化上下文中。
public void persist(Object entity)

persist方法可以将实例转换为managed(托管)状态。在调用flush()方法或提交事物后，实
例将会被插入到数据库中。

对不同状态下的实例A，persist会产生以下操作:
1. 如果A是一个new状态的实体，它将会转为managed状态；
2. 如果A是一个managed状态的实体，它的状态不会发生任何改变。但是系统仍会在数据库执行INSERT操作；
3. 如果A是一个removed(删除)状态的实体，它将会转换为受控状态；
4. 如果A是一个detached(分离)状态的实体，该方法会抛出IllegalArgumentException异常，具体异常根据不同的
JPA实现有关。

public class JpaTest {
EntityManagerFactory factory;
@Before
public void before(){
factory= Persistence.createEntityManagerFactory("hibernateJPA");
}

@Test
public void testC(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = new Customer();
customer.setCustName("张三");
em.persist(customer); // 保存并使得实体保持Managed状态
tx.commit();
}

// 立即查询
@Test
public 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();
}

// 延迟查询
@Test
public 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();
}

@Test
public 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//自定义sql
public void testU_JPQL(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String jpql="UPDATE Customer set custName=:name where custId=:id";
em.createQuery(jpql)
.setParameter("name","李四")
.setParameter("id",5L)
.executeUpdate();

tx.commit();
}

@Test
public void testU_SQL(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String sql="UPDATE tb_customer set cust_name=:name where id=:id";
em.createNativeQuery(sql)
.setParameter("name","王五")
.setParameter("id",5L)
.executeUpdate();

tx.commit();
}

@Test
public void testD(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = em.find(Customer.class,5L);
em.remove(customer);
tx.commit();
}
}

1
104
105
106
3.1Spring Data JPA实例
我们来实现一个基于Spring Data JPA的示例感受一下和之前单独使用的区别:
依赖：
父pom:

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-bom</artifactId>
<version>2021.1.0</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>

子pom:

<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.32.Final</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.10</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>${querydsl.version}</version>
</dependency>

42
SpringDataJPAConfig

@Configuration // 标记当前类为配置类 =xml配文件
@EnableJpaRepositories(basePackages="com.tuling.repositories") // 启动jpa <jpa:repositories
@EnableTransactionManagement // 开启事务
public class SpringDataJPAConfig {

/*
* 
<bean class="com.alibaba.druid.pool.DruidDataSource" name="dataSource">
<property name="username" value="root"/>
<property name="password" value="123456"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
</bean>
* */
@Bean
public 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?characterEncoding=UTF-8");

return dataSource;

}

/*
* 
<bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaVendorAdapter">

<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

<property name="generateDdl" value="true"></property>
<property name="showSql" value="true"></property>
</bean>
</property>

<property name="packagesToScan" value="com.tuling.pojo"></property>
<property name="dataSource" ref="dataSource" ></property>
</bean>
* */
@Bean
public 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 class="org.springframework.orm.jpa.JpaTransactionManager" name="transactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
* */
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

JpaTransactionManager txManager = new JpaTransactionManager();
txManager.setEntityManagerFactory(entityManagerFactory);
return txManager;
}
}

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:jpa="http://www.springframework.org/schema/data/jpa" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/jpa
https://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:repositories base-package="com.tuling.repositories"
entity-manager-factory-ref="entityManagerFactory"
transaction-manager-ref="transactionManager"
/>

<bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="jpaVendorAdapter">

<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

<property name="generateDdl" value="true"></property>
<property name="showSql" value="true"></property>
</bean>
</property>

<property name="packagesToScan" value="com.tuling.pojo"></property>
<property name="dataSource" ref="dataSource" ></property>
</bean>

<bean class="com.alibaba.druid.pool.DruidDataSource" name="dataSource">
<property name="username" value="root"/>
<property name="password" value="123456"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
</bean>

<bean class="org.springframework.orm.jpa.JpaTransactionManager" name="transactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>

<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>

pojo

@Data
@Entity // 作为hibernate 实体类
@Table(name = "tb_customer") // 映射的表明
public class Customer {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long custId; //客户的主键

@Column(name = "cust_name")
private String custName;//客户名称

@Column(name="cust_address")
private String custAddress;//客户地址
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CustomerRepository
使用 Spring Data Repositories抽象的目标是显着减少为各种持久性存储实现数据访问层所需的样板代码量。

CrudRepository
1
2 // 用来插入和修改有主键就是修改没有就是新增
3 // 获得插入后自增id，获得返回值
4 <S extends T> S save(S entity);
5
6 // 通过集合保存多个实体
7 <S extends T> Iterable<S> saveAll(Iterable<S> entities);
8 // 通过主键查询实体
9 Optional<T> findById(ID id);
10 // 通过主键查询是否存在返回boolean
11 boolean existsById(ID id);
12 // 查询所有
13 Iterable<T> findAll();
14 // 通过集合的主键查询多个实体，，返回集合
15 Iterable<T> findAllById(Iterable<ID> 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 PagingAndSortingRepository<Customer, Long> {
}
1
2
测试

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringdataJpaTest {

@Autowired
CustomerRepository repository;
@Test
public void testR(){
Optional<Customer> byId = repository.findById(1L);
System.out.println(byId.orElse(null));
}

@Test
public void testC(){
Customer customer = new Customer();
customer.setCustName("李四");
System.out.println(repository.save(customer));
}

@Test
public void testD(){
Customer customer = new Customer();
customer.setCustId(3L);
customer.setCustName("李四");
repository.delete(customer);
}
@Test
public void testFindAll(){
Iterable<Customer> allById = repository.findAllById(Arrays.asList(1L, 7L, 8L));
System.out.println(allById);
}

}

34
3.1.1分页
在之上CrudRepository，有一个PagingAndSortingRepository抽象，它添加了额外的方法来简化对实体的分页访问：

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringDataJpaPagingAndSortTest
{
// jdk动态代理的实例
@Autowired(required=false)
CustomerRepository repository;

@Test
public void insertCustomer() {
for (int i = 20; i < 50; i++) {
Customer customer = new Customer();
customer.setCustName("张三"+i);
customer.setCustAddress("北京");
repository.save(customer);
}

}

@Test
public void testPaging(){
Page<Customer> all = repository.findAll(PageRequest.of(0, 2));
System.out.println(all.getTotalPages());
System.out.println(all.getTotalElements());
System.out.println(all.getContent());

}

@Test
public void testSort(){
Sort sort = Sort.by("custId").descending();
Iterable<Customer> all = repository.findAll(sort);
System.out.println(all);
}

@Test
public void testSortTypeSafe(){
Sort.TypedSort<Customer> sortType = Sort.sort(Customer.class);
Sort sort = sortType.by(Customer::getCustId).descending();
Iterable<Customer> all = repository.findAll(sort);
System.out.println(all);

}
}

1
2
3

3.1.2自定义操作
1.jpql（原生SQL)： @Query

查询如果返回单个实体就用pojo接收，如果是多个需要通过集合

参数设置方式

索引： ?数字
具名： :参数名结合@Param注解指定参数名字
增删改：

要加上事务的支持：
如果是插入方法：一定只能在hibernate下才支持（Insert into
…select )
@Transactional // 通常会放在业务逻辑层上面去声明
@Modifying // 通知springdatajpa 是增删改的操作
1
2
2.规定方法名
支持的查询方法主题关键字（前缀）

决定当前方法作用
只支持查询和删除
详见官方文档

3.Query by Example

只支持查询

不支持嵌套或分组的属性约束，如 firstname = ？0 or (firstname = ？1
and lastname = ？2).
只支持字符串 start/contains/ends/regex 匹配和其他属性类型的精确匹
配。
实现：
1.将Repository继承QueryByExampleExecutor

public interface CustomerQBERepository
extends PagingAndSortingRepository<Customer, Long>
, QueryByExampleExecutor<Customer> {

}

2.测试代码

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class QBETest {

// jdk动态代理的实例
@Autowired
CustomerQBERepository repository;

/**
* 简单实例客户名称客户地址动态查询
*/
@Test
public void test01(){

// 查询条件
Customer customer=new Customer();
customer.setCustName("徐庶");
customer.setCustAddress("BEIJING");
// 通过Example构建查询条件
Example<Customer> example = Example.of(customer);
List<Customer> list = (List<Customer>) repository.findAll(example);
System.out.println(list);
}

/**
* 通过匹配器进行条件的限制
* 简单实例客户名称客户地址动态查询
*/
@Test
public void test02(){

// 查询条件
Customer customer=new 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构建查询条件
Example<Customer> example = Example.of(customer,matcher);
List<Customer> list = (List<Customer>) repository.findAll(example);
System.out.println(list);
}
}

4.Specifications
在之前使用Query by Example只能针对字符串进行条件设置，那如果希望对所有类型支持，可以使用Specifications
实现：

public interface CustomerRepository extends CrudRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}
1
2
2.传入Specification的实现：结合lambda表达式

repository.findAll((Specification<Customer>)
   (root, query, criteriaBuilder) ‐>
   {
       // Todo...
       return null;
   });
}
1
2
3
4
5
6
7
Root：查询哪个表（关联查询） = from
CriteriaQuery：查询哪些字段，排序是什么 =组合(order by . where )
CriteriaBuilder：条件之间是什么关系，如何生成一个查询条件，每一个查询条件都是什么类型（>
between in…) = where
Predicate（Expression）：每一条查询条件的详细描述

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class SpecificationTest {

// jdk动态代理的实例
@Autowired
CustomerSpecificationsRepository repository;
@Test
public void testR(){
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
return null;
}
});
System.out.println(customer);
}

@Test
public void testR5(){
Customer params=new Customer();
//params.setCustAddress("BEIJING");
params.setCustId(0L);
params.setCustName("徐庶,王五");
List<Customer> customer = repository.findAll(new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

// root from Customer , 获取列
// CriteriaBuilder where 设置各种条件 (> < in ..)
// query 组合（order by , where)
Path<Long> custId = root.get("custId");
Path<String> custName = root.get("custName");
Path<String> custAddress = root.get("custAddress");

// 参数1 ：为哪个字段设置条件参数2：值
List<Predicate> list=new 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.In<String> 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 QuerydslPredicateExecutor<T> {
Optional<T> findOne(Predicate predicate);

Iterable<T> findAll(Predicate predicate);

Iterable<T> findAll(Predicate predicate, Sort sort);

Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders);

Iterable<T> findAll(OrderSpecifier<?>... orders);

Page<T> findAll(Predicate predicate, Pageable pageable);

long count(Predicate predicate);

boolean exists(Predicate predicate);

<S extends T, R> R findBy(Predicate predicate, Function<FetchableFluentQuery<S>, R> queryFunction);
}

引入依赖

<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>${querydsl.version}</version>
</dependency>

添加插件
这个插件是为了让程序自动生成query type(查询实体，命名方式为：“Q”+对应实体名)。

<build>
<plugins>
<plugin>
<groupId>com.mysema.maven</groupId>
<artifactId>apt-maven-plugin</artifactId>
<version>${apt.version}</version>
<dependencies>
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
<version>${querydsl.version}</version>
</dependency>
</dependencies>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>process</goal>
</goals>
<configuration>
<outputDirectory>target/generated-sources/queries</outputDirectory>
<processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
<logOnlyOnError>true</logOnlyOnError>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

测试

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class QueryDSLTest {

@Autowired
CustomerQueryDSLRepository repository;

@Test
public void test01() {
QCustomer customer = QCustomer.customer;
// 通过Id查找
BooleanExpression eq = customer.custId.eq(1L);
System.out.println(repository.findOne(eq));

}

/**
* 查询客户名称范围 (in)
* id >大于
* 地址精确
*/
@Test
public 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 >大于
* 地址精确
*/
@Test
public void test03() {

Customer params=new Customer();
params.setCustAddress("BEIJING");
params.setCustId(0L);
params.setCustName("徐庶,王五");
QCustomer customer = QCustomer.customer;
// 初始条件类似于1=1 永远都成立的条件
BooleanExpression expression = customer.isNotNull().or(customer.isNull());

expression=params.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));

}

// 解决线程安全问题
@PersistenceContext
EntityManager em;
/**
* 自定义列查询、分组
* 需要使用原生态的方式（Specification)
* 通过Repository进行查询，列、表都是固定
*/
@Test
public void test04() {
JPAQueryFactory factory = new JPAQueryFactory(em);
QCustomer customer = QCustomer.customer;
// 构建基于QueryDSL的查询
JPAQuery<Tuple> tupleJPAQuery = factory.select(customer.custId, customer.custName)
.from(customer)
.where(customer.custId.eq(1L))
.orderBy(customer.custId.desc());

// 执行查询
List<Tuple> fetch = tupleJPAQuery.fetch();
// 处理返回数据
for (Tuple tuple : fetch) {
System.out.println(tuple.get(customer.custId));
System.out.println(tuple.get(customer.custName));
}
}

@Test
public void test05() {
JPAQueryFactory factory = new JPAQueryFactory(em);
QCustomer customer = QCustomer.customer;
// 构建基于QueryDSL的查询
JPAQuery<Long> longJPAQuery = factory.select(
customer.custId.sum())
.from(customer)
//.where(customer.custId.eq(1L))
.orderBy(customer.custId.desc());
// 执行查询
List<Long> fetch = longJPAQuery.fetch();
// 处理返回数据
for (Long sum : fetch) {
System.out.println(sum);
}
}
}

3.1.3多表关联操作
一对一
1、配置管理关系
@OneToOne
@JoinColumn(name=“外键字段名”)

@OneToOne
@JoinColumn(name="customer_id")
private Customer customer;
1
2
3
@Entity // 作为hibernate 实体类
@Table(name = "tb_customer") // 映射的表明
@Data
@EntityListeners(AuditingEntityListener.class)
public class Customer {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long custId; //客户的主键

@Column(name = "cust_name")
private String custName;//客户名称

@Column(name="cust_address")
private String custAddress;//客户地址

// 单向关联一对一
/*
* cascade 设置关联操作
* ALL, 所有持久化操作
PERSIST 只有插入才会执行关联操作
MERGE, 只有修改才会执行关联操作
REMOVE, 只有删除才会执行关联操作
fetch 设置是否懒加载
EAGER 立即加载（默认）
LAZY 懒加载（直到用到对象才会进行查询，因为不是所有的关联对象都需要用到）
orphanRemoval 关联移除（通常在修改的时候会用到）
一旦把关联的数据设置null ，或者修改为其他的关联数据，如果想删除关联数据，就可以设置true
optional 限制关联的对象不能为null
true 可以为null(默认 ) false 不能为null
mappedBy 将外键约束执行另一方维护(通常在双向关联关系中，会放弃一方的外键约束）
值= 另一方关联属性名
**/
@OneToOne(mappedBy = "customer",
cascade = CascadeType.ALL,fetch = FetchType.LAZY,orphanRemoval=true/*,optional=false*/)
// 设置外键的字段名
@JoinColumn(name="account_id")
private Account account;
}

测试

@ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class OneToOneTest {
@Autowired
CustomerRepository repository;

// 插入
@Test
public 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(){
Optional<Customer> customer = repository.findById(3L); // 只查询出客户， session关闭
System.out.println("=================");
System.out.println(customer.get()); // toString
}

@Test
public void testD(){
repository.deleteById(1L);
}

@Test
public 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(name="customer_id")
private List<Message> messages;

2、配置关联操作

/***
* 一（客户）对多（信息）
*/
@Entity
@Table(name="tb_message")
@Data
public class Message {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String info;

// 多对一
@ManyToOne(cascade = {CascadeType.PERSIST,CascadeType.REMOVE})
@JoinColumn(name="customer_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;
}

@Override
public 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(
name="tb_customer_role",
joinColumns = {@JoinColumn(name="c_id")},
inverseJoinColumns = {@JoinColumn(name="r_id")}
)
private List<Role> roles;

2、配置关联操作

/**
* 多（用户）对多（角色）
*/
@Entity
@Table(name="tb_role")
@Data
public class Role {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name="role_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 List<Role> roles;
}

测试

ContextConfiguration(classes = SpringDataJPAConfig.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class ManyToManyTest {
@Autowired
CustomerRepository repository;
@Autowired
RoleRepository roleRepository;

@Test
public void testSave(){
List<Role> 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 ，否则不能共用一个session
3. 在单元测试中用到了@Transactional , 如果有增删改的操作一定要加@Commit
4. 单元测试会认为你的事务方法@Transactional，只是测试而已，它不会为你提交事务，需要单独加上 @Commit
*/
@Test
@Transactional
@Commit
public void testC() {
List<Role> roles=new 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);
}

@Test
@Transactional(readOnly = true)
public void testR() {
System.out.println(repository.findById(14L));
//repository.save(customer);
}

/*
* 注意加上
* @Transactional
@Commit
多对多其实不适合删除，因为经常出现数据出现可能除了和当前这端关联还会关联另一端，此时删除就会： ConstraintViolationException。
* 要删除，要保证没有额外其他另一端数据关联
* */
@Test
@Transactional
@Commit
public void testD() {
Optional<Customer> customer = repository.findById(14L);
repository.delete(customer.get());
}
}

乐观锁
hibernate
防并发修改

private @Version Long version;
1
三、SpringBoot整合Spring-Data-Jpa
依赖

<dependencies>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

常用配置

# 数据库表的生成策略
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/springdata_jpa?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 是否显示sql在控制台
spring.jpa.show-sql= true
spring.jpa.properties.hibernate.format_sql=true
server.port=8088

可选配置
Hibernate官方文档
SpirngDataJpa官方文档

剩下就是正常开发流程，持久层、业务层、控制层

Hibernate SpringDataJpa 和Mybatis有什么区别？

猜你喜欢