• SpringData Hibernate JPA 使用案例 案例 （一）

    目录

    一、Hibernate的基本操作

    1、添加依赖

    2、添加建表实体类

    3、添加hibernate配置依赖

    4、测试类

     二、SpringData实现JPA的功能

    1、添加persistence.xml配置文件

     2、JPA测试

    3、切换持久化单元的演示

     4、*HibernateJPI常见操作，测试案例*

    一、Hibernate的基本操作

    1、添加依赖

    1. <parent>
    2.         <groupId>org.springframework.bootgroupId>
    3.         <version>2.3.2.RELEASEversion>
    4.         <artifactId>spring-boot-starter-parentartifactId>
    5.         <relativePath/>
    6.     parent>
    7.  
    8. <properties>
    9.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    10.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    11.         <java.version>1.8java.version>
    12.         <junit.version>4.13junit.version>
    13.         <hibernate.version>5.4.32.Finalhibernate.version>
    14.         <mysql.version>5.1.22mysql.version>
    15.     properties>
    16.  
    17. <dependencies>
    18.         
    19.         <dependency>
    20.             <groupId>org.hibernategroupId>
    21.             <artifactId>hibernate-entitymanagerartifactId>
    22.             <version>${hibernate.version}version>
    23.         dependency>
    24.         
    25.         <dependency>
    26.             <groupId>mysqlgroupId>
    27.             <artifactId>mysql-connector-javaartifactId>
    28.             <version>${mysql.version}version>
    29.         dependency>
    31.         <dependency>
    32.             <groupId>junitgroupId>
    33.             <artifactId>junitartifactId>
    34.             <version>${junit.version}version>
    35.             <scope>testscope>
    36.         dependency>
    37.     dependencies>

    2、添加建表实体类

    hibernate可以通过实体类自动生成对应的表

    1. package com.dragonwu.entity;
    2.  
    3.  
    4. import javax.persistence.Column;
    5. import javax.persistence.Entity;
    6. import javax.persistence.GeneratedValue;
    7. import javax.persistence.GenerationType;
    8. import javax.persistence.Id;
    9. import javax.persistence.Table;
    10.  
    11. /**
    12.  * @author DragonWu
    13.  * @date 2022-09-20 11:17
    14.  **/
    15. @Entity //作为hibernate的实体类
    16. @Table(name="tb_customer")//映射的表名
    17. public class Customer {
    18.  
    19.     /**
    20.      * @Id 主键声明
    21.      * @GeneratedValue: 配置主键的生成策略
    22.      *      strategy
    23.      *          GenerationType.IDENTITY: 自增，mysql
    24.      *              *底层数据库必须支持自动增长
    25.      *          GenerationType.SEQUENCE: 序列oracle
    26.      *              *底层数据库必须支持序列
    27.      *          GenerationType.TABLE: jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键
    28.      *          GenerationType.AUTO: 由程序自动地帮助我们选择主键生成策略
    29.      * @Cloumn 配置属性和表字段的映射关系
    30.      *      name: 数据库表中字段的名称
    31.      */
    32.     @Id
    33.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    34.     @Column(name="id",length = 20)
    35.     private Long id;
    36.  
    37.     @Column(name="cus_name",columnDefinition = "varchar(32) default null comment '客户名'")
    38.     private String name;//客户名
    39.  
    40.     @Column(name="cus_address",length = 200)
    41.     private String address;//客户地址
    42.  
    43.     public Long getId() {
    44.         return id;
    45.     }
    46.  
    47.     public void setId(Long id) {
    48.         this.id = id;
    49.     }
    50.  
    51.     public String getName() {
    52.         return name;
    53.     }
    54.  
    55.     public void setName(String name) {
    56.         this.name = name;
    57.     }
    58.  
    59.     public String getAddress() {
    60.         return address;
    61.     }
    62.  
    63.     public void setAddress(String address) {
    64.         this.address = address;
    65.     }
    66.  
    67.     @Override
    68.     public String toString() {
    69.         return "Customer{" +
    70.                 "id=" + id +
    71.                 ", name='" + name + '\'' +
    72.                 ", address='" + address + '\'' +
    73.                 '}';
    74.     }
    75. }

    3、添加hibernate配置依赖

    这里建议命名为hibernate.cfg.xml，我存放的目录在resource/hibernate/hibernate.cfg.xml

    2. hibernate-configuration PUBLIC
    3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    4.         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    5. <hibernate-configuration>
    6.     <session-factory>
    7.         
    8.         <property name="connection.url">jdbc:mysql://my-server:3306/testproperty>
    9.         <property name="connection.driver_class">com.mysql.jdbc.Driverproperty>
    10.         <property name="hibernate.connection.username">rootproperty>
    11.         
    12.         <property name="hibernate.connection.password">XXXproperty>
    13.         
    14.         <property name="connection.characterEncoding">utf8property>
    15.         
    16.         <property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialectproperty>
    17.         
    18.         <property name="show_sql">trueproperty>
    19.         
    20.         <property name="format_sql">trueproperty>
    21.         
    22.         <property name="hbm2ddl.auto">updateproperty>
    23.         
    24.         
    25.         <mapping class="com.dragonwu.entity.Customer"/>
    26.  
    27.         
    28.         
    29.     session-factory>
    30.  
    31. hibernate-configuration>
    32.

    4、测试类

    1. package com.dragonwu.test;
    2.  
    3. import com.dragonwu.entity.Customer;
    4. import org.hibernate.Session;
    5. import org.hibernate.SessionFactory;
    6. import org.hibernate.Transaction;
    7. import org.hibernate.boot.MetadataSources;
    8. import org.hibernate.boot.registry.StandardServiceRegistry;
    9. import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
    10. import org.junit.Before;
    11. import org.junit.Test;
    12.  
    13. import java.util.List;
    14.  
    15. /**
    16.  * @author DragonWu
    17.  * @date 2022-09-20 12:52
    18.  **/
    19. public class HibernateTest {
    20.  
    21.     //Session工厂 Session:数据库会话 代码持久化操作数据库的一个桥梁
    22.     private SessionFactory sf;
    23.  
    24.     @Before
    25.     public void init() {
    26.         StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure("/hibernate/hibernate.cfg.xml").build();
    27.  
    28.         //2、根据服务注册类持久一个元数据资源集，同时构建元数据并生成应用一般唯一的session工厂
    29.  
    30.         sf = new MetadataSources(registry).buildMetadata().buildSessionFactory();
    31.     }
    32.  
    33.     @Test
    34.     public void testC() {
    35.         //session进行持久化操作
    36.         try (Session session = sf.openSession()) {
    37.             Transaction tx = session.beginTransaction();
    38.  
    39.             Customer customer = new Customer();
    40.             customer.setName("DragonWu");
    41.  
    42.             session.save(customer);
    43.  
    44.             tx.commit();
    45.         }
    46.     }
    47.  
    48.     @Test
    49.     public void testR() {
    50.         //session进行持久化操作
    51.         try (Session session = sf.openSession()) {
    52.             Transaction tx = session.beginTransaction();
    53.  
    54.             Customer customer = session.find(Customer.class, 1L);
    55.             System.out.println("===================");
    56.             System.out.println(customer);
    57.  
    58.             tx.commit();
    59.         }
    60.     }
    61.  
    62.     @Test
    63.     public void testR_lazy() {
    64.         //session进行持久化操作
    65.         try (Session session = sf.openSession()) {
    66.             Transaction tx = session.beginTransaction();
    67.  
    68.             Customer customer = session.load(Customer.class, 1L);
    69.             System.out.println("===================");
    70.             System.out.println(customer);
    71.  
    72.             tx.commit();
    73.         }
    74.     }
    75.  
    76.     @Test
    77.     public void testU() {
    78.         //session进行持久化操作
    79.         try (Session session = sf.openSession()) {
    80.             Transaction tx = session.beginTransaction();
    81.  
    82.             Customer customer = new Customer();
    83.             customer.setId(1L);
    84.             customer.setAddress("杭州");
    85.  
    86.             //session.save()插入
    87.             //session.update()更新
    88.             session.saveOrUpdate(customer);//存在id时更新，不存在id时创建
    89.  
    90.             tx.commit();
    91.         }
    92.     }
    93.  
    94.     @Test
    95.     public void testD() {
    96.         //session进行持久化操作
    97.         try (Session session = sf.openSession()) {
    98.             Transaction tx = session.beginTransaction();
    99.  
    100.             Customer customer = new Customer();
    101.             customer.setId(1L);
    102.  
    103.             session.remove(customer);
    104.  
    105.             tx.commit();
    106.         }
    107.     }
    108.  
    109.     @Test
    110.     public void testR_HQL() {
    111.         //session进行持久化操作
    112.         try (Session session = sf.openSession()) {
    113.             Transaction tx = session.beginTransaction();
    114.  
    115.             String hql = " FROM Customer where id=:id";
    116.  
    117.             List resultList = session
    118.                     .createQuery(hql, Customer.class)
    119.                     .setParameter("id",2L)
    120.                     .getResultList();
    121.             System.out.println(resultList);
    122.  
    123.             tx.commit();
    124.         }
    125.     }
    126. }

    在对应连接里创建对应数据库，运行单元测试类testC

    表已自动生成。 

    单元测试testR

     单元测试testR_lazy懒加载，load懒加载当执行到对应查询时系统才会执行查询，而find会先执行查询。

     二、SpringData实现JPA的功能

    用之前的hibernate，如果我们需要修改持久化层，需要修改很多配置以及代码，由此SpringData推出了JPA的功能。JPA同样是钟规范，需要依赖于他的实现。

    1、添加persistence.xml配置文件

    目录结构如图：

    1. "1.0" encoding="UTF-8"?>
    2. <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    3.  
    4.     
    5.     <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
    6.  
    7.         
    8.         <provider>org.hibernate.jpa.HibernatePersistenceProviderprovider>
    9.  
    10.         
    11.         <class>com.dragonwu.entity.Customerclass>
    12.         
    13.         <properties>
    14.             
    15.             <property name="javax.persistence.jdbc.user" value="root"/>
    16.             <property name="javax.persistence.jdbc.password" value="XXX"/>
    17.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
    18.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>
    19.  
    20.             
    21.             <property name="hibernate.show_sql" value="true"/>
    22.             <property name="hibernate.format_sql" value="true"/>
    23.             <property name="hibernate.hbm2ddl.auto" value="update"/>
    24.         properties>
    25.     persistence-unit>
    26. persistence>

     2、JPA测试

    1. package com.dragonwu.test;
    2.  
    3. import com.dragonwu.entity.Customer;
    4. import org.junit.Before;
    5. import org.junit.Test;
    6.  
    7. import javax.persistence.EntityManager;
    8. import javax.persistence.EntityManagerFactory;
    9. import javax.persistence.EntityTransaction;
    10. import javax.persistence.Persistence;
    11.  
    12. /**
    13.  * @author DragonWu
    14.  * @date 2022-09-20 15:13
    15.  **/
    16. public class JPATest {
    17.  
    18.     EntityManagerFactory factory;
    19.  
    20.     @Before
    21.     public void before(){
    22.         factory= Persistence
    23.                 .createEntityManagerFactory("hibernateJPA");
    24.  
    25.     }
    26.  
    27.     @Test
    28.     public void testC(){
    29.         EntityManager em=factory.createEntityManager();
    30.         EntityTransaction tx=em.getTransaction();
    31.         tx.begin();
    32.  
    33.         Customer customer = new Customer();
    34.         customer.setName("龘龘");
    35.  
    36.         em.persist(customer);
    37.  
    38.         tx.commit();
    39.     }
    40. }

    3、切换持久化单元的演示

    添加另一种jpa的依赖

    2.         <dependency>
    3.             <groupId>org.apache.openjpagroupId>
    4.             <artifactId>openjpa-allartifactId>
    5.             <version>3.2.0version>
    6.         dependency>

    添加openjpa单元项后的persistence.xml文件

    1. "1.0" encoding="UTF-8"?>
    2. <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    3.  
    4.     
    5.     <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
    6.  
    7.         
    8.         <provider>org.hibernate.jpa.HibernatePersistenceProviderprovider>
    9.  
    10.         
    11.         <class>com.dragonwu.entity.Customerclass>
    12.         
    13.         <properties>
    14.             
    15.             <property name="javax.persistence.jdbc.user" value="root"/>
    16.             <property name="javax.persistence.jdbc.password" value="XXX"/>
    17.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
    18.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>
    19.  
    20.             
    21.             <property name="hibernate.show_sql" value="true"/>
    22.             <property name="hibernate.format_sql" value="true"/>
    23.             <property name="hibernate.hbm2ddl.auto" value="update"/>
    24.  
    25.         properties>
    26.     persistence-unit>
    27.  
    28.     <persistence-unit name="openJPA" transaction-type="RESOURCE_LOCAL">
    29.  
    30.         
    31.         <provider>org.apache.openjpa.persistence.PersistenceProviderImplprovider>
    32.  
    33.         
    34.         <class>com.dragonwu.entity.Customerclass>
    35.         
    36.         <properties>
    37.             
    38.             <property name="javax.persistence.jdbc.user" value="root"/>
    39.             <property name="javax.persistence.jdbc.password" value="XXX"/>
    40.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
    41.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://my-server:3306/test?characterEncoding=UTF-8"/>
    42.  
    43.             
    44.             
    45.             <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
    46.         properties>
    47.     persistence-unit>
    48. persistence>

    使用openJPA我们只需要改变单元项即可，代码耦合性很低，非常适合装配使用。

    1. package com.dragonwu.test;
    2.  
    3. import com.dragonwu.entity.Customer;
    4. import org.junit.Before;
    5. import org.junit.Test;
    6.  
    7. import javax.persistence.EntityManager;
    8. import javax.persistence.EntityManagerFactory;
    9. import javax.persistence.EntityTransaction;
    10. import javax.persistence.Persistence;
    11.  
    12. /**
    13.  * @author DragonWu
    14.  * @date 2022-09-20 15:13
    15.  **/
    16. public class JPATest {
    17.  
    18.     EntityManagerFactory factory;
    19.  
    20.     @Before
    21.     public void before(){
    22.         factory= Persistence
    23.                 .createEntityManagerFactory("openJPA");
    24.  
    25.     }
    26.  
    27.     @Test
    28.     public void testC(){
    29.         EntityManager em=factory.createEntityManager();
    30.         EntityTransaction tx=em.getTransaction();
    31.         tx.begin();
    32.  
    33.         Customer customer = new Customer();
    34.         customer.setName("DragonWu Master");
    35.  
    36.         em.persist(customer);
    37.  
    38.         tx.commit();
    39.     }
    40. }

    查看效果：可以看到两种不同的单元项都可以对数据库进行操作，而底层都是基于hibernate来实现的。

     4、*HibernateJPI常见操作，测试案例*

    1. package com.dragonwu.test;
    2.  
    3. import com.dragonwu.entity.Customer;
    4. import org.junit.Before;
    5. import org.junit.Test;
    6.  
    7. import javax.persistence.EntityManager;
    8. import javax.persistence.EntityManagerFactory;
    9. import javax.persistence.EntityTransaction;
    10. import javax.persistence.Persistence;
    11.  
    12. /**
    13.  * @author DragonWu
    14.  * @date 2022-09-20 15:13
    15.  **/
    16. public class JPATest {
    17.  
    18.     EntityManagerFactory factory;
    19.  
    20.     @Before
    21.     public void before(){
    22.         factory= Persistence
    23.                 .createEntityManagerFactory("hibernateJPA");
    24.  
    25.     }
    26.  
    27.     @Test
    28.     public void testC(){
    29.         EntityManager em=factory.createEntityManager();
    30.         EntityTransaction tx=em.getTransaction();
    31.         tx.begin();
    32.  
    33.         Customer customer = new Customer();
    34.         customer.setName("DragonWu Master");
    35.  
    36.         em.persist(customer);
    37.  
    38.         tx.commit();
    39.     }
    40.  
    41.     @Test
    42.     public void testR(){
    43.         EntityManager em=factory.createEntityManager();
    44.         EntityTransaction tx=em.getTransaction();
    45.         tx.begin();
    46.  
    47.         Customer customer = em.find(Customer.class,4L);
    48.         //find立即查询
    49.         System.out.println("==============================");
    50.         System.out.println(customer);
    51.  
    52.         tx.commit();
    53.     }
    54.  
    55.     @Test
    56.     public void testR_lazy(){
    57.         EntityManager em=factory.createEntityManager();
    58.         EntityTransaction tx=em.getTransaction();
    59.         tx.begin();
    60.  
    61.         Customer customer = em.getReference(Customer.class,4L);
    62.         //load延时查询
    63.         System.out.println("==============================");
    64.         System.out.println(customer);
    65.  
    66.         tx.commit();
    67.     }
    68.  
    69.     @Test
    70.     public void testU(){
    71.         EntityManager em=factory.createEntityManager();
    72.         EntityTransaction tx=em.getTransaction();
    73.         tx.begin();
    74.  
    75.         Customer customer=new Customer();
    76.         customer.setId(5L);
    77.         customer.setName("Jack");
    78.  
    79.         //如果该id对应的数据存在则更新，否则添加；更新时会先查询是否有变化，若有变化才会更新
    80.         em.merge(customer);
    81.  
    82.         tx.commit();
    83.     }
    84.  
    85.     @Test
    86.     public void testU_JPQL(){
    87.         EntityManager em=factory.createEntityManager();
    88.         EntityTransaction tx=em.getTransaction();
    89.         tx.begin();
    90.  
    91.         //注意这里是类名
    92.         String jpql="UPDATE Customer set name=:name where id=:id";
    93.         em.createQuery(jpql)
    94.                 .setParameter("name","好人")
    95.                 .setParameter("id",5L)
    96.                 .executeUpdate();
    97.  
    98.         tx.commit();
    99.     }
    100.  
    101.     @Test
    102.     public void testU_SQL(){
    103.         EntityManager em=factory.createEntityManager();
    104.         EntityTransaction tx=em.getTransaction();
    105.         tx.begin();
    106.  
    107.         //注意这里是表名
    108.         String sql="UPDATE tb_customer set cus_name=:name where id=:id";
    109.         em.createNativeQuery(sql)
    110.                 .setParameter("name","坏人")
    111.                 .setParameter("id",5L)
    112.                 .executeUpdate();
    113.  
    114.         tx.commit();
    115.     }
    116.  
    117.     @Test
    118.     public void testD(){
    119.         EntityManager em=factory.createEntityManager();
    120.         EntityTransaction tx=em.getTransaction();
    121.         tx.begin();
    122.  
    123.         Customer customer=em.find(Customer.class,5L);
    124.         //这里不支持删除游离态的对象
    125.         em.remove(customer);
    126.  
    127.         tx.commit();
    128.     }
    129. }
  • 相关阅读:
    Dynamsoft Barcode Reader新框架将医疗视觉提升到新水平
    《Head First HTML5 javascript》第10章 自定义对象
    大数据Flink（八十一）：SQL 时区问题
    JavaScript基础知识15——专业术语：语句和表达式
    未来展望：Starday供应链火力全开，为跨境电商再添动力！
    Linux下安装Mysql【详细】
    c＜8＞指针
    TOREX | 单功能充电IC的外置电流通路电路
    K8S容器持续Terminating无法正常关闭（sider-car容器异常，微服务容器正常）
    自媒体短视频运营常见的5个问题及解决方案
  • 原文地址：https://blog.csdn.net/qq_50909707/article/details/126951253