目录
1、JPA 和JDBC 的相同处和不同处
相同处：
1.都跟数据∙库操作有关，JPA 是JDBC 的升华，升级版。
2.JDBC和JPA都是一组规范接口
3.都是由SUN官方推出的
不同处：
1.JDBC是由各个关系型数据库实现的， JPA 是由
ORM框架
实现
2.JDBC 使用SQL语句和数据库通信。 JPA用面向对象方式， 通过ORM框架来生成SQL，进行操作。
3.JPA在JDBC之上的， JPA也要依赖JDBC才能操作数据库。
2、什么是JPA
JPA全称Java Persistence API ，
是Sun官方提出的
一种ORM规范。
O:Object R: Relational M:mapping
作用
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仅仅定义了一些接口，而接口是需要实现才能工作的。
主结构：
3、Hibernate与JPA
JPA是一套ORM规范，Hibernate实现了JPA规范！
4、mybatis和hibernate
mybatis：小巧、方便？、高效、简单、直接、半自动
半自动的ORM框架，
小巧： mybatis就是jdbc封装
在国内更流行。
场景： 在业务比较复杂系统进行使用，
hibernate：强大、方便、高效、（简单）复杂、绕弯子、全自动
全自动的ORM框架，
强大：根据ORM映射生成不同SQL
在国外更流。
场景： 在业务相对简单的系统进行使用，随着微服务的流行。
主结构：
5、Hibernate的CRUD操作案例
主结构：
springdata→pom.xml ：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tuling.springdata</groupId>
<artifactId>springdata</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>01-jpa-hibernate</module>
<module>02-springdata-jpa</module>
<module>03-springdata-jpa</module>
<module>04-springdata-jpa</module>
</modules>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!--统一管理SpringData子项目的版本-->
<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>
</project>01-jpa-hibernate→pom.xml ：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springdata</artifactId>
<groupId>com.tuling.springdata</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>01-jpa-hibernate</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- junit4 -->
<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>
</dependencies>
</project>pojo→Customer实体类：
package com.tuling.pojo;
import javax.persistence.*;
@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")//配置属性和字段的映射关系 name：数据库表中字段的名称
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>HibernateTest测试
package com.tuling.test;
import com.tuling.pojo.Customer;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
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意思就是他会帮我们自动关闭
try(Session session = sf.openSession()){
//开启事务
Transaction tx = session.beginTransaction();
Customer customer = new Customer();
customer.setCustName("徐庶");
session.save(customer);
// session.remove(); //删除
// session.update(); //更新
// session.save(); //插入
// session.find(); //查找
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();
}
}
//HQL查询全部
@Test
public void testR_HQL(){
// session进行持久化操作
try(Session session = sf.openSession()){
Transaction tx = session.beginTransaction();
String hql=" FROM Customer";
List<Customer> resultList = session.createQuery(hql, Customer.class)
// .setParameter("id",1L)
.getResultList();//获取查询集合
System.out.println(resultList);
tx.commit();
}
}
//HQL查询单个
@Test
public void testR_HQL2(){
// 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)//查询id为1l的人的信息，与上面HQL语句：where custId=:id 对应
.getResultList();//获取查询集合
System.out.println(resultList);
tx.commit();
}
}
}
6、JPA的CRUD操作案例
（如果单独使用hibernate的API来进行持久化操作，则不能随意切换其他ORM框架 ）
主结构：
springdata→pom.xml ：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tuling.springdata</groupId>
<artifactId>springdata</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>01-jpa-hibernate</module>
<module>02-springdata-jpa</module>
<module>03-springdata-jpa</module>
<module>04-springdata-jpa</module>
</modules>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<!--统一管理SpringData子项目的版本-->
<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>
</project>01-jpa-hibernate→pom.xml ：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springdata</artifactId>
<groupId>com.tuling.springdata</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>01-jpa-hibernate</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- junit4 -->
<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>
</dependencies>
</project>pojo→Customer实体类：
package com.tuling.pojo;
import javax.persistence.*;
@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")//配置属性和字段的映射关系 name：数据库表中字段的名称
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";
}
}添加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：持久化单元名称
transaction-type：事务管理的方式
JTA：分布式事务管理
RESOURCE_LOCAL：本地事务管理
-->
<persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
<!--jpa的实现方式 -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<!--需要进行ORM的POJO类-->
<class>com.tuling.pojo.Customer</class>
<!--可选配置：配置jpa实现方的配置信息-->
<properties>
<!-- 数据库信息
用户名，javax.persistence.jdbc.user
密码， javax.persistence.jdbc.password
驱动， javax.persistence.jdbc.driver
数据库地址 javax.persistence.jdbc.url
-->
<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.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
<!--配置jpa实现方(hibernate)的配置信息
显示sql ： false|true
自动创建数据库表 ： hibernate.hbm2ddl.auto
create : 程序运行时创建数据库表（如果有表，先删除表再创建）
update ：程序运行时创建表（如果有表，不会创建表）
none ：不会创建表
-->
<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">
<!--jpa的实现方式 -->
<provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
<!-- 指定哪些实体需要持久化 -->
<class>com.tuling.pojo.Customer</class>
<!--可选配置：配置jpa实现方的配置信息-->
<properties>
<!-- 数据库信息
用户名，javax.persistence.jdbc.user
密码， javax.persistence.jdbc.password
驱动， javax.persistence.jdbc.driver
数据库地址 javax.persistence.jdbc.url
-->
<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.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8"/>
<!--配置jpa实现方(openjpa)的配置信息
-->
<!-- 可以自动生成数据库表 -->
<property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
</properties>
</persistence-unit>
</persistence>JpaTest测试
package com.tuling.test;
import com.tuling.pojo.Customer;
import org.junit.Before;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
public class JpaTest {
EntityManagerFactory factory;
@Before
public void before(){
factory= Persistence.createEntityManagerFactory("hibernateJPA");//括号里面是持久化单元的名称
}
//增
@Test
public void testC(){
EntityManager em = factory.createEntityManager();//这里生成的 em ，就相当于Hibernate里面生成的 session
EntityTransaction tx = em.getTransaction();
tx.begin();//开启事务
Customer customer = new Customer();
customer.setCustName("张三");
em.persist(customer);//插入
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(3L);
customer.setCustName("王五");
/*
*
// 如果指定了主键：
更新： 1.先查询 看是否有变化
如果有变化 更新 如果没有变化就不更新
*
* 如果没有指定了主键：
* 插入
* */
em.merge(customer);
tx.commit();
}
//JPQL更新语句
@Test
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",3L)
.executeUpdate();
tx.commit();
}
//使用SQL更新语句
@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",3L)
.executeUpdate();
tx.commit();
}
//删除
@Test
public void testD(){
EntityManager em = factory.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
Customer customer = em.find(Customer.class,3L);//先查持久化状态的，然后再删
// jpa的对象4种状态
// 临时状态：刚创建出来，∙没有与entityManager发生关系，没有被持久化，不处于entityManager中的对象
// 持久状态：∙与entityManager发生关系，已经被持久化，您可以把持久化状态当做实实在在的数据库记录。
// 删除状态：执行remove方法，事物提交之前
// 游离状态：游离状态就是提交到数据库后，事务commit后实体的状态，因为事务已经提交了，此时实体的属 性任你如何改变，也不会同步到数据库，
// 因为游离是没人管的孩子，不在持久化上下文中。
em.remove(customer);
tx.commit();
}
}
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
