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-INFpersistence.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 ：

    4.0.0

    com.tuling.springdata
    springdata
    pom
    1.0-SNAPSHOT
    
        01-jpa-hibernate
        02-springdata-jpa
        03-springdata-jpa
        04-springdata-jpa
    


    
        8
        8
    


    
    
        
            
                org.springframework.data
                spring-data-bom
                2021.1.0
                import
                pom
            
        
    

01-jpa-hibernate→pom.xml ：

    
        springdata
        com.tuling.springdata
        1.0-SNAPSHOT
    
    4.0.0

    01-jpa-hibernate

    
        8
        8
    

    
        
        
            junit
            junit
            4.13
            test
        
        
        
            org.hibernate
            hibernate-entitymanager
            5.4.32.Final
        

        
        
            mysql
            mysql-connector-java
            5.1.22
        
        
        
            org.apache.openjpa
            openjpa-all
            3.2.0
        

    

pojo→Customer实体类：

package com.tuling.pojo;

import javax.persistence.*;


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

    
    @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 文件：

    
        
        com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/springdata_jpa?characterEncoding=UTF-8
        root
        123456

        
        true
        
        true
        
        update
        
        org.hibernate.dialect.MySQL57InnoDBDialect

        
        
    

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 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 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 ：

    4.0.0

    com.tuling.springdata
    springdata
    pom
    1.0-SNAPSHOT
    
        01-jpa-hibernate
        02-springdata-jpa
        03-springdata-jpa
        04-springdata-jpa
    


    
        8
        8
    


    
    
        
            
                org.springframework.data
                spring-data-bom
                2021.1.0
                import
                pom
            
        
    

01-jpa-hibernate→pom.xml ：

    
        springdata
        com.tuling.springdata
        1.0-SNAPSHOT
    
    4.0.0

    01-jpa-hibernate

    
        8
        8
    

    
        
        
            junit
            junit
            4.13
            test
        
        
        
            org.hibernate
            hibernate-entitymanager
            5.4.32.Final
        

        
        
            mysql
            mysql-connector-java
            5.1.22
        
        
        
            org.apache.openjpa
            openjpa-all
            3.2.0
        

    

pojo→Customer实体类：

package com.tuling.pojo;

import javax.persistence.*;


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

    
    @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-INFpersistence.xml

    
    
        
        org.hibernate.jpa.HibernatePersistenceProvider
        
        com.tuling.pojo.Customer

        
        
            
            
            
            
            

            
            
            
            

        
    



    
        
        org.apache.openjpa.persistence.PersistenceProviderImpl

        
        com.tuling.pojo.Customer
        
        
            
            
            
            
            

            
            
            
        
    

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("王五");

        
        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();
    }
}

---