JPA-Hibernate快速入门图文教程

1、JPA 和JDBC 的相同处和不同处

2、什么是JPA

3、Hibernate与JPA

4、mybatis和hibernate

5、Hibernate的CRUD操作案例

主结构：编辑

springdata→pom.xml ：

01-jpa-hibernate→pom.xml ：

pojo→Customer实体类：

hibernate.cfg.xml 文件：

HibernateTest测试

6、JPA的CRUD操作案例

主结构：编辑

springdata→pom.xml ：

01-jpa-hibernate→pom.xml ：

pojo→Customer实体类：

添加META-INF\persistence.xml

JpaTest测试

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;}@Overridepublic 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;@Beforepublic void init() {StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate.cfg.xml").build();//2. 根据服务注册类创建一个元数据资源集，同时构建元数据并生成应用一般唯一的的session工厂sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();}//增@Testpublic 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();}}//查@Testpublic 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();}}//查询，懒加载方式@Testpublic 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();}}//更新@Testpublic 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();}}//删除@Testpublic 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查询全部@Testpublic 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查询单个@Testpublic 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;}@Overridepublic 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.autocreate      : 程序运行时创建数据库表（如果有表，先删除表再创建）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;@Beforepublic void before(){factory= Persistence.createEntityManagerFactory("hibernateJPA");//括号里面是持久化单元的名称}//增@Testpublic void testC(){EntityManager em = factory.createEntityManager();//这里生成的 em ，就相当于Hibernate里面生成的 sessionEntityTransaction tx = em.getTransaction();tx.begin();//开启事务Customer customer = new Customer();customer.setCustName("张三");em.persist(customer);//插入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(3L);customer.setCustName("王五");/**// 如果指定了主键：更新： 1.先查询  看是否有变化如果有变化 更新     如果没有变化就不更新**   如果没有指定了主键：*          插入* */em.merge(customer);tx.commit();}//JPQL更新语句@Testpublic 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更新语句@Testpublic 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();}//删除@Testpublic 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();}
}