一、ORM思想

ORM(Object Relational Mapping)，对象关系映射，是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。将实体类与数据库表做队形，实体类中的属性与数据库中的字段做对应。这样就不用直接操作数据库，写SQL语句了，直接使用面向对象的技术，对象名.方法（）,就可以实现对数据的增删改查等。

二、JPA规范

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

JPA （Java Persistence API） Java持久化API。是一套Java官方制定的ORM 方案。

JPA是一种规范，一种标准，具体的操作交给第三方框架去实现，比如说Hibernate，OpenJPA等。

jpa实现增删改查_hibernate入门案例

Sun引入新的JPA ORM规范出于两个原因：

其一，简化现有Java EE和Java SE应用开发工作；

其二，Sun希望整合ORM技术，实现天下归一。

三、搭建JPA的基础环境

1.创建数据库表

  CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2.创建Maven工程导入坐标

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <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>5.1.6</version>
        </dependency>
    </dependencies>

3.创建JPA的核心配置文件

位置：配置到类路径下的一个叫做 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="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--数据库信息-->
        <!--可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!--数据库信息-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa"/>

            <!--可选配置：配置jpa实现方的配置信息
                显示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>

4.编写实体类，配置映射关系

实体与表的映射和实体类属性与表字段的映射

 配置映射关系
    1.实体类和表的映射关系
           @Entity 声明是实体类
           @Table(name = "cst_customer")  实体类与表的映射关系，name配置表的名称

    2.实体类中属性和表字段的映射关系
           @Column(name = "cust_id") 
           @GeneratedValue:配置主键的生成策略
             strategy
                 GenerationType.IDENTITY ：自增，mysql
                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
                 GenerationType.SEQUENCE : 序列，oracle
                 * 底层数据库必须支持序列
                 GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
*                GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略

/**
 * @Author: Promsing(张有博)
 * @Date: 2021/10/13 - 17:29
 * @Description: 客户的实体类
 * @version： 1.0
 */
@Entity
@Table(name = "cst_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 = "cust_id")
    private Long id;//主键

    @Column(name="cust_name")
    private String custName;

    @Column(name="cust_source")
    private String custSource;

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

    @Column(name="cust_level")
    private String custLevel;

    @Column(name = "cust_address")
    private String custAddress;

    @Column(name = "cost_phone")
    private String custPhone;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custAddress='" + custAddress + '\'' +
                ", custPhone='" + custPhone + '\'' +
                '}';
    }
}

四、入门案例–增删改查

1.jpa的操作步骤

1.加载配置文件创建工厂（实体管理类工厂）对象

2.通过实体管理类工厂获取实体管理类

3.获取事务对象，开启事务

4.完成增删改查

5.提交事务（回滚事务）

6.释放资源

2.基本操作的详细介绍

1.加载配置文件创建实体管理器工厂

EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");

根据持久化单元名称创建实体管理器工厂，持久化单元名称就是配置文件中 persistence-unit的name属性

2.根据实体管理器工厂，创建实体管理器

//通过实体管理器工厂获取实体管理器
EntityManager em = myJpa.createEntityManager();

EntityManager内部维护的很多的内容

内部维护了数据库信息，

维护了缓存信息

维护了所有的实体管理器对象

EntityManagerFactory是一个线程安全的对象

3.创建事务对象，开启事务

//3.获取事务对象
EntityTransaction tx = em.getTransaction();

Transaction 对象：事务

begin：开启事务

commit：提交事务

rollback：回滚

4.增删改查操作

presist ：保存

merge ：更新

remove ：删除

find/getRefrence ：根据id查询

5.提交事务或者回滚事务

tx.commit();
tx.rollback();

6.释放资源

//先申请的后释放
//先释放实体管理器--EntityManager
//后释放实体管理器工厂--EntityManagerFactory

五、代码实战

使用JPA封装好的方法

/**
 * @Author: Promsing(张有博)
 * @Date: 2021/10/16 - 8:41
 * @Description: jpa的测试类，完成增删改查操作
 * @version： 1.0
 */
public class JpaTest {

     /**
     * 保存操作
     *   persist(Object)
     *
     */
    @Test
    public void testSave(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = myJpa.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        Customer customer=new Customer();
        customer.setCustName("小小张自由");
        customer.setCustAddress("廊坊");
        customer.setCustIndustry("教育");
        customer.setCustLevel("高级");
        customer.setCustPhone("1502800");
        customer.setCustSource("邯郸");
        //5.保存，提交事务
        em.persist(customer);
        tx.commit();
        //7.释放资源
        em.close();
        myJpa.close();
    }

     /**
     * 根据id查询
     *   find(需要封装实体类的字节码文件，主键值)
     *     立即加载，获取实体对象，立即执行SQL语句，查询数据库
     */
    @Test
    public void testFind(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = myJpa.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        /**
         * find(需要封装实体类的字节码文件，主键值)
         * 立即加载，获取实体对象，立即执行SQL语句，查询数据库
         */
        Customer customer = em.find(Customer.class, 2L);
        System.out.println(customer);

        //5.保存，提交事务
        tx.commit();
        //7.释放资源
        em.close();
        myJpa.close();
    }

    /**
     * 根据id查询
     *  getReference(需要封装实体类的字节码文件，主键值)
     *   延迟加载（懒加载），获取动态代理对象，延迟执行SQL语句，
     *   当使用到代理对象时，查询数据库
     */
    @Test
    public void testReference(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = myJpa.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        /**
         * getReference(需要封装实体类的字节码文件，主键值)
         * 延迟加载，获取动态代理对象，延迟执行SQL语句，
         * 当使用到代理对象时，查询数据库
         */
        Customer customer = em.getReference(Customer.class, 2L);
        System.out.println(customer);

        //5.保存，提交事务
        tx.commit();
        //7.释放资源
        em.close();
        myJpa.close();
    }

    /**
     * 删除客户的案例
     *  remove(Object)
     */
    @Test
    public void testRemove(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = myJpa.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
            //根据id先查询用户
        Customer customer = em.find(Customer.class, 2L);
            //调用remove方法，完成删除操作
        em.remove(customer);
        //5.保存，提交事务
        tx.commit();
        //7.释放资源
        em.close();
        myJpa.close();
    }


    /**
     * 更新客户的案例
     *   merge(Object)
     */
    @Test
    public void testUpdate(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = myJpa.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
             //根据id先查询用户
        Customer customer = em.find(Customer.class, 1L);
             //调用remove方法，完成删除操作
        customer.setCustIndustry("架构师");
        em.merge(customer);
        //5.保存，提交事务
        tx.commit();
        //7.释放资源
        em.close();
        myJpa.close();
    }

}

使用JPQL查询

JPQL(Java持久性查询语言)是一种面向对象的查询语言，用于对持久实体执行数据库操作。 JPQL不使用数据库表，而是使用实体对象模型来操作SQL查询。旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

package com.dynamic.test;

import org.junit.Before;
import org.junit.Test;

import javax.persistence.*;
import java.util.List;

/**
 * @Author: Promsing(张有博)
 * @Date: 2021/10/17 - 9:48
 * @Description: JPQL的测试类
 * @version： 1.0
 */
public class JpqlTest {

    private EntityManager em;

    @Before
    public void testBefore(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory myJpa = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
         em = myJpa.createEntityManager();
    }

    /**
     * 查询全部
     *  sql:SELECT * FROM `cst_customer`
     *  jqpl:from com.dynamic.domain.Customer 或者from Customer
     */
    @Test
    public void testFindAll(){
        //将第一第二步封装起来，
        //在@test执行之前执行Before

        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        String jqpl="from com.dynamic.domain.Customer";
        Query query = em.createQuery(jqpl);
        //发送查询，并封装结果集
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
            System.out.println();
        }
        //5.提交事务
        tx.commit();
        //7.释放资源
        em.close();
//        myJpa.close();
    }


    /**
     * 排序查询，根据id倒叙
     *  sql:SELECT * FROM `cst_customer` ORDER BY cust_id desc ;
     *  jqpl:from Customer order by custId desc
     */
    @Test
    public void testOrders(){
        //将第一第二步封装起来，
        //在@test执行之前执行Before

        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        String jqpl="from Customer order by id desc";
        Query query = em.createQuery(jqpl);
        //发送查询，并封装结果集
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
            System.out.println();
        }
        //5.提交事务
        tx.commit();
        //7.释放资源
        em.close();
//        myJpa.close();
    }

    /**
     * 统计查询，使用count
     *  sql:SELECT COUNT(cust_id) FROM `cst_customer`;
     *  jqpl:SELECT COUNT(id) FROM Customer
     */
    @Test
    public void testCount(){
        //将第一第二步封装起来，
        //在@test执行之前执行Before

        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        String jqpl="SELECT COUNT(id) FROM Customer";
        Query query = em.createQuery(jqpl);
        //发送查询，并封装结果集
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);
        //5.提交事务
        tx.commit();
        //7.释放资源
        em.close();
//        myJpa.close();
    }

    /**
     * 分页查询
     *   SQL语句：SELECT * FROM `cst_customer` LIMIT 0,2
     *   jpql语句：使用Query对象
     */
    @Test
    public void testPaged(){
        //将第一第二步封装起来，
        //在@test执行之前执行Before

        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        String jqpl="from Customer";
        Query query = em.createQuery(jqpl);
        //起始索引
        query.setFirstResult(0);
        //每次查询的长度
        query.setMaxResults(2);

        //发送查询，并封装结果集
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }
        //5.提交事务
        tx.commit();
        //7.释放资源
        em.close();
//        myJpa.close();
    }

    /**
     * 条件查询
     *   SQL语句：SELECT * FROM `cst_customer` where cust_name LIKE '%自由%'
     *   jpql语句：from Customer where custName like ?
     */
    @Test
    public void testCondition(){
        //将第一第二步封装起来，
        //在@test执行之前执行Before

        //3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //4.完成增删改查操作
        String jqpl="from Customer where custName like ?";
        Query query = em.createQuery(jqpl);

        //给占位符赋值，占位符从1开始
        query.setParameter(1,"%自由%");

        //发送查询，并封装结果集
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }
        //5.提交事务
        tx.commit();
        //7.释放资源
        em.close();
//        myJpa.close();
    }

}

如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏哦。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/179951.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

jpa实现增删改查_hibernate入门案例

一、ORM思想

二、JPA规范

三、搭建JPA的基础环境

1.创建数据库表

2.创建Maven工程导入坐标

3.创建JPA的核心配置文件

4.编写实体类，配置映射关系

四、入门案例–增删改查

1.jpa的操作步骤

2.基本操作的详细介绍

五、代码实战

使用JPA封装好的方法

使用JPQL查询

如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏哦。

相关推荐

django通用视图通俗讲解_django queryset合并

qt容器类_下面属于容器类的是

nginx转发https到http

系统架构与高可用

pycharm中的注释_java中单行注释

Pytest（6）重复运行用例pytest-repeat[通俗易懂]

发表回复