JPA(java持久化API)的环境的搭建

因为我使用的是java工程

所以需要引入的依赖有:

  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</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>

2.创建客户的实体类和数据库表

    /*创建客户表*/
    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;

创建实体类

public class Customer implements Serializable {
 
    private Long custId;
    private String custName;
    private String custSource;
    private String custIndustry;
    private String custLevel;
    private String custAddress;
    private String custPhone;
 
    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 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;
    }
}    

3.编写实体类和数据库表的映射配置

　　　　在实体类上使用JPA注解的形式配置映射关系

/**
*        * 所有的注解都是使用JPA的规范提供的注解，
 *        * 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
 
    @Id//声明当前私有属性为主键
    @GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
    @Column(name="cust_id") //指定和表中cust_id字段的映射关系
    private Long custId;
 
    @Column(name="cust_name") //指定和表中cust_name字段的映射关系
    private String custName;
 
    @Column(name="cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;
 
    @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;
 
    @Column(name="cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;
 
    @Column(name="cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;
 
    @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
    private String custPhone;
 
    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 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;
    }
}

常用的注解的说名:

        @Entity
            作用：指定当前类是实体类。
        @Table
            作用：指定实体类和表之间的对应关系。
            属性：
                name：指定数据库表的名称
        @Id
            作用：指定当前字段是主键。
        @GeneratedValue
            作用：指定主键的生成方式。。
            属性：
                strategy ：指定主键生成策略。
        @Column
            作用：指定实体类属性和数据库表之间的对应关系
            属性：
                name：指定数据库表的列名称。
                unique：是否唯一
                nullable：是否可以为空
                inserttable：是否可以插入
                updateable：是否可以更新
                columnDefinition: 定义建表时创建此列的DDL
                secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

配置核心的配置文件:

在ajava工程的src路径下创建一个名为META-INF的文件夹,在此文件夹下创建一个名为persistence.xml的配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
    version="2.0">
    <!--配置持久化单元
        name：持久化单元名称
        transaction-type：事务类型
             RESOURCE_LOCAL：本地事务管理
             JTA：分布式事务管理 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--配置JPA规范的服务提供商 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- 数据库驱动 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/ssh" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="111111" />
 
            <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="create" />
        </properties>
    </persistence-unit>
</persistence>

实现curd操作

package com.qingmu;
 
import org.junit.Test;
 
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
 
/**
 * @Auther:qingmu
 * @Description:脚踏实地,只为出人头地
 * @Date:Created in 15:13 2019/5/14
 */
 
public class SpringDataJPATest {
    /**
     * 增
     */
    @Test
    public void insertIntoTest(){
        //创建一个实体管理工厂,借助于Persistence中的静态方法.
//        其中传递的参数为持久化单元名称，需要jpa配置文件中指定
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //创建实体管理类
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        Customer customer = new Customer();
        customer.setCustName("青木");
        //保存操作
        entityManager.persist(customer);
        //事务进行提交
        transaction.commit();
        //关闭资源
        entityManager.close();
        entityManagerFactory.close();
    }
    /**
     * 查
     */
    @Test
    public void find1(){
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //查找,不需要添加事务
        Customer customer = entityManager.find(Customer.class, 1L);
        System.out.println(customer);
        entityManager.close();
        entityManagerFactory.close();
 
    }
    @Test
    public void find2(){
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Customer customer = entityManager.getReference(Customer.class, 1L);
        System.out.println(customer);
 
        entityManager.close();
        entityManagerFactory.close();
    }
    /**
     * 更新
     */
    @Test
    public void update(){
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        Customer customer = new Customer();
        customer.setCustId(1L);
        customer.setCustName("青木川崎");
        Customer customer1 = entityManager.merge(customer);
        System.out.println(customer1);
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    /**
     * 删
     * 使用jpa进行删除的时候,需要先进行查询
     * 因为删除的时候,要删除的实体类没有被entityManagerFactory控制(也就是cache(缓存)中没有这个东西
     *所以不能进行删除
     */
    @Test
    public void delete(){
        /**
         * 创建实体类管理工厂,借助于Persistence来创建entityManagerFactory
         * 其中传递的参数为持久化单元名称，需要jpa配置文件中指定
         */
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //创建entityManager对象
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //创建事务
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        Customer customer = entityManager.find(Customer.class, 1L);
        entityManager.remove(customer);
        transaction.commit();
        entityManager.close();
 
    }
}