JPA 与hibernate 基本使用

最新推荐文章于 2024-09-23 10:43:50 发布

YGR1123打SD

最新推荐文章于 2024-09-23 10:43:50 发布

阅读量687

点赞数

分类专栏： JPA与hibernate与Spring Data Jpa 文章标签： JPA 与hibernate 基本使用

本文链接：https://blog.csdn.net/qq_38620956/article/details/102521151

版权

JPA与hibernate与Spring Data Jpa 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 需要的pom.xml依赖

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>
    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>
        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>
        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
    </dependencies>

2.resources 下的WEB-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="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--可选配置：配置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="123"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///test"/>

            <!--配置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" />
        </properties>
    </persistence-unit>
</persistence>

3. 先由配置文件通过静态代码块的方式获取 EntityManagerFactory 对象由配置文件中配置的持久化单元名称获取

再由 EntityManagerFactory 创建 EntityManager 后可以由他获取事务管理器查询操作数据库

/**
 * 解决实体管理器工厂的浪费资源和耗时问题
 *      通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
 *
 * 第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
 * 第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
 */
public class JpaUtils {
    private static EntityManagerFactory entityManagerFactory;

    static{
        entityManagerFactory= Persistence.createEntityManagerFactory("myJpa");
    }
    /**
     * 获取EntityManager对象
     */
    public EntityManager getEntityManager(){
        return entityManagerFactory.createEntityManager();
    }
}

JAP基本操作

1.实体类和表的映射关系 : @Entity:声明实体类 @Table : 配置实体类和表的映射关系 name : 配置数据库表的名称
2.实体类中属性和表中字段的映射关系

1.主键 : @Id：声明主键的配置

@GeneratedValue:配置主键的生成策略属性 strategy

GenerationType.IDENTITY ：底层数据库必须支持自动增长列如 mysql
GenerationType.SEQUENCE : 序列，底层数据库必须支持序列列如 oracle
GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增,创建的表不会有自增的属性, 而是会在数据库多一张记录下一个id的值
GenerationType.AUTO ：由程序自动的帮助我们选择主键生成策略,以上三种中选择
@Column:配置属性和字段的映射关系属性 name：数据库表中字段的名称

@Entity
@Table(name = "cst_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址
}

增删改查操作

操作步骤 : 1. 获取实体管理器 2.获取事务对象开启事务 3.使用实体管理器操作 4.释放资源

1.保存操作 persist( domain)

2. 查询操作 find 与 getReference 区别 : getReference 使用才会执行查询操作延迟而find是立即

3.删除和更新操作都需要先查询出一个 domain实体类对象再操作 remove merge

    @Test
    public void testSave(){
        //获取 实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //获取事务对象开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        //使用实体管理器 操作
        Customer customer = new Customer();
        customer.setCustName("wyc");
        customer.setCustPhone("15614140557");
        em.persist(customer);   //保存操作

        //释放资源
        tx.commit();
        em.close();
    }

    @Test
    public void testFind(){
        //获取 实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //获取事务对象开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        //使用实体管理器 操作
        Customer customer = em.find(Customer.class, 1l);//使用find 查询立即加载
        System.out.println(customer);
        //释放资源
        tx.commit();
        em.close();
    }

    @Test
    public void testGetReference(){
        //获取 实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //获取事务对象开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        //使用实体管理器 操作
        Customer customer = em.getReference(Customer.class, 1l);//使用getReference查询 立延迟加载
        System.out.println(customer);
        //释放资源
        tx.commit();
        em.close();
    }

    @Test
    public void testRemove(){
        //获取 实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //获取事务对象开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        //使用实体管理器 操作
        //删除操作需要先查询,再删除查询出来的这个的对象
        Customer customer = em.find(Customer.class, 1L);
        em.remove(customer);

        //释放资源
        tx.commit();
        em.close();
    }

    @Test
    public void testMerge(){
        //获取 实体管理器
        EntityManager em = JpaUtils.getEntityManager();
        //获取事务对象开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        //使用实体管理器 操作
        //更新操作需要先查询,再更改查询出来的这个的对象
        Customer customer = em.find(Customer.class, 1L);
        customer.setCustAddress("重庆");
        em.merge(customer);

        //释放资源
        tx.commit();
        em.close();