JPA（JavaPersistenceAPI）是Java平台上的ORM规范，旨在简化数据库操作，提供面向对象的方式来操作数据。它不是具体的实现，而是定义了一套接口。Hibernate是一个实现了JPA规范的ORM框架。相比之下，MyBatis是一个轻量级的ORM工具，更注重灵活性和直接性，是半自动的ORM框架。文章还介绍了如何在实际操作中配置和使用Hibernate，包括实体类的注解和配置文件的设置，以及CRUD操作的示例。
JPA
什么是JPA？
相同处：
1.都跟数据∙库操作有关，JPA 是JDBC 的升华，升级版。
2.JDBC和JPA都是一组规范接口3.都是由SUN官方推出的
不同处：
1.JDBC是由各个关系型数据库实现的， JPA 是由ORM框架实现
2.JDBC 使用SQL语句和数据库通信。 JPA用面向对象方式， 通过ORM框架来生成SQL，进行操作。
3.JPA在JDBC之上的， JPA也要依赖JDBC才能操作数据库。
作用
1.简化持久化操作的开发工作：让开发者从繁琐的 JDBC 和 SQL 代码中解脱出来，直接面向对象持久化操作。
2.Sun希望持久化技术能够统一，实现天下归一：如果你是基于JPA进行持久化你可以随意切换数据库。
该规范为我们提供了：
1）ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；如：@Entity 、 @Table 、@Id 与 @Column等注解。
2）JPA 的API：用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。如：entityManager.merge(T t)；
3）JPQL查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。如：from Student s where s.name = ?
So: JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的
Hibernate与JPA:
所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。
也就是说：JPA是一套ORM规范，Hibernate实现了JPA规范！
mybatis：小巧、方便？、高效、简单、直接、半自动
半自动的ORM框架，
小巧： mybatis就是jdbc封装在国内更流行。
场景： 在业务比较复杂系统进行使用，
hibernate：强大、方便、高效、（简单）复杂、绕弯子、全自动
全自动的ORM框架，
强大：根据ORM映射生成不同SQL在国外更流。
场景： 在业务相对简单的系统进行使用，随着微服务的流行。
实操：
pom文件
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<!-- hibernate对jpa的支持包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.32.Final</version>
</dependency>
<!-- Mysql and MariaDB -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.22</version>
</dependency>
<!--openjpa-->
<dependency>
<groupId>org.apache.openjpa</groupId>
<artifactId>openjpa-all</artifactId>
<version>3.2.0</version>
</dependency>
实体类
@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;//客户地址
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.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 默认false-->
<property name="show_sql">true</property>
<!--是否格式化sql 默认false-->
<property name="format_sql">true</property>
<!--表生成策略
默认none 不自动生成
update 如果没有表会创建，有会检查更新
create 创建-->
<property name="hbm2ddl.auto">update</property>
<!-- 配置方言：选择数据库类型 -->
<property name="dialect">org.hibernate.dialect.MySQL57InnoDBDialect</property>
<!--指定哪些pojo 需要进行ORM映射-->
<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
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();
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
