【JAVA】-【JPA】-orm思想及jpa配置

orm思想

建立实体类和数据库表的映射，通过操作实例类对象达到操作数据库的目的

实现了orm思想的框架：mybatis,hibernate,

hibernate框架介绍

hibernate是一个全自动的orm框架，对jdbc进行了轻量级封装，叫pojo与数据库表建立映射关系，可以自动生成sql语句自动执行。

JPA规范

JPA全称：JAVA Persistence API,级Java持久化API，有sun公司推出的基于orm的规范，内部由接口和抽象类组成。

由hibernate实现，由toplink实现，及其它实现

jpa基本操作

搭建环境

1、创建maven-导入工程

   <dependencies>
        <!-- 导入junit -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
        <!-- 导入hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>6.0.0.Alpha6</version>
            <type>pom</type>
        </dependency>

        <!-- mysql and mariaDB-mysql聚合包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>

        <!-- log4j日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- 导入c3p0-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>6.0.0.Alpha6</version>
            <type>pom</type>
        </dependency>

    </dependencies>

2、配置核心配置文件

1>新建配置文件

配置路径：配置到类路径下的META-INF的文件夹下

命名：persistence.xml

2>在文件中添加约束

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
</persistence>

3>配置jpa核心配置文件，配置如下

3、创建数据库和实体类实体

建立一个jpa数据库

//建表语句
CREATE TABLE `cst_customer` (
    `cust_id` BIGINT ( 32 ) NOT NULL 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;

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

        <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="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <!-- value中：mysql:///代表本地mysql数据库-3306端口。jpa代表数据库名            -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

            <!--  可选配置，配置jpa实现方的配置信息
                    显示sql:          false|true  true为显示数据库表，false为不显示数据库表
                    自动创建数据库表:   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、在实体类中配置-实例类和表、类中数据和表中字段的映射关系

package com.dmsd.jpa;

import javax.persistence.*;
import java.lang.reflect.GenericArrayType;

/**
 * 客户实体类
 * 配置映射关系：1、实体类和表的映射关系   2、实体类中属性和表中字段的映射关系
 */
@Entity  //声明实体类
@Table(name="cst_customer")  //配置实体类和表的映射关系，name是数据表名称
public class Customer {
    /**
     * @Id：声明主键的配置
     * @GeneratedValue:  GenerationType.IDENTITY---自增
     * @Column:配置属性和字段的映射关系：name代表字段名称
     */
    @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_industry")
    private String custLevel;//客户级别
    @Column(name="cust_level")
    private String custINdustry;//客户所属行业
    @Column(name="cust_address")
    private String custPhone;//客户联系方式
    @Column(name="cust_phone")
    private String custAddress;//客户地址

    public long getCustId() {
        return custId;
    }

    public void setCustId(long custId) {
        this.custId = custId;
    }

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

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

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

    public void setCustINdustry(String custINdustry) {
        this.custINdustry = custINdustry;
    }

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

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

    public String getCustName() {
        return custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public String getCustINdustry() {
        return custINdustry;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public String getCustAddress() {
        return custAddress;
    }

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

5、执行数据库操作

在测试类中执行插入操作

package com.dmsd.test;

import com.dmsd.jpa.Customer;
import org.junit.jupiter.api.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class jpaTest1 {
    /**
     * 测试jpa保存
     * jpa操作步骤
     * 1、加载配置文件创建工程对象
     * 2、通过实体管理类工程获取实体管理器
     * 3、开启事务
     * 4、完成CRUD
     * 5、提交事务-回滚事务
     * 6、释放资源
     */
    @Test
    public void testSave(){
        //加载配置文件
        EntityManagerFactory factory= Persistence.createEntityManagerFactory("myjpa");//参数为配置文件中的持久化单元名称
        //通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        //获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();//获取事务对象
        tx.begin();//开始事务
        //完成增删改查操作
        Customer customer=new Customer();
        customer.setCustName("test201127");
        customer.setCustINdustry("beijing");
        customer.setCustAddress("111");
        customer.setCustLevel("1");
        customer.setCustPhone("029833904");
        customer.setCustSource("333");

        //保存
        em.persist(customer);//将实体保存到数据表中

        //提交事务
        tx.commit();
        //释放资源
        em.close();//释放实体管理器
        factory.close();//释放工厂
    }
}

6、分页查询和条件查询

/**
     * jpql查询操作:分页查询，使用limit  和条件查询
     * jpql语法：from Customer
     */
    @Test
    public void JPQLLimit(){
        //获取entityManager对象
        EntityManager em = jpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx =em.getTransaction();
        tx.begin();
//        分页查询
        //利用count函数查询数量
        String jpqlCount ="from com.dmsd.jpa.Customer";
        //穿件query查询对象
        Query queryCount =em.createQuery(jpqlCount);//创建query查询对象，query对象是执行jpql的对象
        //定义分页参数-起始索引和每页查询条数
        queryCount.setFirstResult(3);//起始索引为0
        queryCount.setMaxResults(3);//查询条数为3条
        List listCount= queryCount.getResultList();//使用list接收
        //遍历获取到的数据
        for(Object obj:listCount){
            System.out.println(obj);
        }
        // 条件查询
        String jpql ="from com.dmsd.jpa.Customer where custName like ?";//使用where进行条件查询，使用？当做占位符
        Query query =em.createQuery(jpql);//创建query查询对象，query对象是执行jpql的对象
        query.setParameter(1,"test%");//第一个参数是占位符的索引位置，第二个参数是占位符的取值
        //遍历获取到的数据
        List list= query.getResultList();//使用list接收
        for(Object obj:list){
            System.out.println(obj);
        }
        Object result=query.getSingleResult();//得到object类型数据
        System.out.println(result);
        //提交事务
        tx.commit();
        //释放资源
        em.close();
    }