Spring Date JPA - Hibernate与JPA

心动ヾ

已于 2022-05-19 15:20:49 修改

阅读量218

点赞数

分类专栏： java 文章标签： hibernate spring java

于 2022-05-17 08:00:00 首次发布

本文链接：https://blog.youkuaiyun.com/guoguo0717/article/details/124801013

版权

java 专栏收录该内容

64 篇文章

订阅专栏

本文探讨了Hibernate作为JPA实现的ORM框架，与MyBatis的优缺点，以及通过实际例子展示了Hibernate的配置和基本操作，包括实体类定义、持久化、查询等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Hibernate与JPA

所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。
也就是说： JPA是一套ORM规范，Hibernate实现了JPA规范！
在这里插入图片描述
mybatis：小巧、方便？、高效、简单、直接、半自动半自动的ORM框架，
小巧： mybatis就是jdbc封装在国内更流行。
场景：在业务比较复杂系统进行使用，

hibernate：强大、方便、高效、（简单）复杂、绕弯子、全自动全自动的ORM框架，
强大：根据ORM映射生成不同SQL 在国外更流。
场景：在业务相对简单的系统进行使用，随着微服务的流行。

Hibernate示例 https://docs.jboss.org/hibernate/orm/5.5/userguide/html_single/Hibernate_User_Guide.html#hql
我们来实现一个Hibernate来示例感受下：
pom.xml

1  <!‐‐ junit4 ‐‐>
2	<dependency>
3	<groupId>junit</groupId>
4	<artifactId>junit</artifactId>
5	<version>4.13</version>
6	<scope>test</scope>
7	</dependency>
8	<!‐‐ hibernate对jpa的支持包 ‐‐>
9	<dependency>
10	<groupId>org.hibernate</groupId>
11	<artifactId>hibernate‐entitymanager</artifactId>
12	<version>5.4.32.Final</version>
13	</dependency>
14	<!‐‐ Mysql and MariaDB ‐‐>
15	<dependency>
16	<groupId>mysql</groupId>
17	<artifactId>mysql‐connector‐java</artifactId>
18	<version>5.1.22</version>
19	</dependency>

实体类

  package com.xushu.pojo;

  import javax.persistence.*;

@Entity
@Table(name = "cst_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 = "cust_id")
private Long custId; //客户的主键

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

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

public Long getCustId() {
return custId;
   }

public void setCustId(Long custId) {
this.custId = custId;
   }

public String getCustName() {
return custName;
   }

public void setCustName(String custName) {
this.custName = custName;
   }


public String getCustAddress() {
return custAddress;
   }

   public void setCustAddress(String custAddress) {
	this.custAddress = custAddress;
   }

@Override
public String toString() { return "Customer{" + "custId=" + custId +
", custName='" + custName + '\'' +
", custAddress='" + custAddress + '\'' + "}\n";
}
}

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>
<!‐‐ 允许显示sql语句 ‐‐>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<!‐‐ 配置方言：选择数据库类型 ‐‐>
<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!‐‐映射方式‐‐>
<mapping class="com.xushu.pojo.Customer"></mapping>
<mapping class="com.xushu.pojo.User"></mapping>
<mapping class="com.xushu.pojo.Wife"></mapping>
<mapping class="com.xushu.pojo.Hobby"></mapping>
</session‐factory>
</hibernate‐configuration>

测试

public class HibernateTest {
private SessionFactory sf
@Before
public void init() {
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate.cfg.xml").build();
//2. 根据服务注册类创建一个元数据资源集，同时构建元数据并生成应用一般唯一的的session工厂

sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();
}
public void testC() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();
   // 创建消息实例
Customer customer = new Customer();
customer.setCustName("张三");
  // 保存消息
   sess.save(customer);
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }


@Test
public void testC_HQL() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();
   // 保存消息
   String sql = "insert into Customer (custName) select custName from Customer where custId=1";

sess.createQuery(sql).executeUpdate();
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }


   // 延迟查询
@Test
public void testR1() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();

   Customer customer = sess.load(Customer.class, 1L);
  System.out.println("=============================");
   System.out.println(customer);

   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }


@Test
public void testR_HQL_list() {
// 创建Session
Session sess = sf.openSession();
  // 开始事务
   Transaction tx = sess.beginTransaction();

List<Customer> list = sess.createQuery("SELECT c FROM Customer c", Customer.class).getResultList();

   System.out.println(list);
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }


@Test
public void testR_HQL_single() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();

Customer customer = sess.createQuery("SELECT c FROM Customer c where c.custId=:id", Customer.class).setParameter("id", 1L).getSingleResult();

   System.out.println(customer);
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }

@Test
public void testU() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();

Customer customer = new Customer();
customer.setCustId(1L);
customer.setCustAddress("123456");

   sess.update(customer);

   System.out.println(customer);
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }


@Test
public void testU_HQL() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
Transaction tx = sess.beginTransaction();

String sql = "Update Customer set custName=:custName where custId=:id";
sess.createQuery(sql).setParameter("custName", "徐庶").setParameter("id", 1L).executeUpdate();
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
  }
@Test
public void testD() {
// 创建Session
Session sess = sf.openSession();
  // 开始事务
  tx = sess.beginTransaction();

Customer customer = new Customer();
customer.setCustId(4L);
sess.delete(customer);
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
   }

@Test
public void testD_HQL() {
// 创建Session
Session sess = sf.openSession();
   // 开始事务
   Transaction tx = sess.beginTransaction();

String sql = "DELETE FROM Customer WHERE custId=:id";
sess.createQuery(sql).setParameter("id", 1L).executeUpdate();
   // 提交事务
tx.commit();
// 关闭Session
sess.close();
sf.close();
  }

如果单独使用hibernate的API来进行持久化操作，则不能随意切换其他ORM框架

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

在这里插入图片描述

public void persist(Object entity)
persist方法可以将实例转换为managed(托管)状态。在调用flush()方法或提交事物后，实

例将会被
插入

到数据库中。

对不同状态下的实例A，persist会产生以下操作:

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

public void merge(Object entity)
merge方法的主要作用是将用户对一个detached状态实体的
修改

进行归档，归档后将产生

一个新的managed状态对象。

对不同状态下的实例A，merge会产生以下操作:

如果A是一个detached状态的实体，该方法会将A的修改提交到数据库，并返回一个新的managed状态的实例A2；
如果A是一个new状态的实体，该方法会产生一个根据A产生的managed状态实体A2;
如果A是一个managed状态的实体，它的状态不会发生任何改变。但是系统仍会在数据库执行UPDATE操作；
如果A是一个removed状态的实体，该方法会抛出IllegalArgumentException异常。
public void refresh(Object entity)
refresh方法可以保证当前的实例与数据库中的实例的内容一致。
对不同状态下的实例A，refresh会产生以下操作:
如果A是一个new状态的实例，不会发生任何操作，但有可能会抛出异常，具体情况根据不同JPA实现有关；
如果A是一个managed状态的实例，它的属性将会和数据库中的数据同步；
3.如果A是一个removed状态的实例，该方法将会抛出异常: Entity not managed 4. 如果A是一个detached状态的实体，该方法将会抛出异常。

public void remove(Object entity)
remove方法可以将实体转换为removed状态，并且在调用flush()方法或提交事物后删除数据库中的数据。

对不同状态下的实例A，remove会产生以下操作: