JPA入门案例crud

创建数据库表

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;

创建一个空的maven工程，导入maven依赖坐标

<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>5.1.6</version>
        </dependency>
    </dependencies>

在resources中创建META-INF文件夹，里面创建persistence.xml配置文件

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


    <!--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="123456"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>

            <!--配置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>

编写实体类

package com.feng.pojo;

import org.hibernate.annotations.GeneratorType;

import javax.persistence.*;

/**
 * @Author weidaiyong
 * @Date 2020/4/8 20:27
 * @Version 1.0
 * 客户的实体类
 * 配置映射关系
 *     1.实体类和表的映射关系
 *     2.实体类中属性和表中字段的映射关系
 * @Entity:声明实体类
 * @Table: 配置实体类和表的映射关系
 *      name属性：配置数据库表的名称
 */
@Entity
@Table(name = "cst_customer")
public class Customer {

    /**
     * @Id:声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      GenerationType.IDENTITY : 自增,mysql
     *      GenerationType.SEQUENCE: 序列，Oracle
     *            *底层数据必须支持序列
     *      GenerationType.TABLE:jpa提供的一种机制，通过数据库表的形式帮助我们完成主键自增
     *      GenerationType.AUTO:由程序自动的帮助我们选择主键生成策略
     *
     * @Column:配置属性和字段的映射关系
     *      name: 数据库表中字段名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.TABLE)
    @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;

    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 getCustLevel() {
        return custLevel;
    }

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

    public String getCustIndustry() {
        return custIndustry;
    }

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

    public String getCustPhone() {
        return custPhone;
    }

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

    public String getCustAddress() {
        return custAddress;
    }

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

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

编写测试类

package com.feng.test;

import com.feng.pojo.Customer;
import org.junit.Test;

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

/**
 * @Author weidaiyong
 * @Date 2020/4/8 21:04
 * @Version 1.0
 */
public class JpaTest {
    /**
     * 测试jpa的保存
     * 案例：保存一个客户到数据库中
     * jpa的操作步骤：
     *     1.加载配置文件创建工厂对象
     *     2.通过实体管理器工厂获取实体管理器
     *     3.获取事务对象，开启事务
     *     4.完成crud操作
     *     5.提交事务
     *     6.释放资源
     */
    @Test
    public void testSave(){
        //1.加载配置文件创建工厂对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        
        //2.通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();

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

        //4.完成crud操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        em.persist(customer);//保存操作
        //5.提交事务
        tx.commit();
        //6.释放资源
        em.close();
        factory.close();
    }
}

可以提取一个公共的工具类

package com.feng.untils;

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

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

    private static EntityManagerFactory factory;

    static  {
        //1.加载配置文件，创建entityManagerFactory
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取EntityManager对象
     */
    public static EntityManager getEntityManager() {
       return factory.createEntityManager();
    }
}

用工具类编写我们的测试类

package com.feng.test;

import com.feng.pojo.Customer;
import com.feng.untils.JpaUtils;
import org.junit.Test;

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

/**
 * @Author weidaiyong
 * @Date 2020/4/8 21:04
 * @Version 1.0
 */
public class JpaTest {
    /**
     * 测试jpa的保存
     * 案例：保存一个客户到数据库中
     * jpa的操作步骤：
     *     1.加载配置文件创建工厂对象
     *     2.通过实体管理器工厂获取实体管理器
     *     3.获取事务对象，开启事务
     *     4.完成crud操作
     *     5.提交事务
     *     6.释放资源
     */
    @Test
    public void testSave(){
        //1.加载配置文件创建工厂对象
        //EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        
        //2.通过实体管理器工厂获取实体管理器
        //EntityManager em = factory.createEntityManager();
        EntityManager em = JpaUtils.getEntityManager();

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

        //4.完成crud操作
        Customer customer = new Customer();
        customer.setCustName("传智播客");
        customer.setCustIndustry("教育");
        em.persist(customer);//保存操作
        //5.提交事务
        tx.commit();
        //6.释放资源
        em.close();

    }

    /**
     * 根据id查询客户
     */
    @Test
    public void testFind(){

        //通过工具类获取EntityManager
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //增删改查 -- 根据id查询客户
        /**
         * find : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = em.find(Customer.class,1L);
        System.out.println(customer);
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

    /**
     * 根据id查询客户
     *      getReference方法
     *          1.获取的对象是一个动态代理对象
     *          2.调用getReference方法不会立即发送sql语句查询数据库
     *              * 当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库
     *
     * 延迟加载（懒加载）
     *      * 得到的是一个动态代理对象
     *      * 什么时候用，什么使用才会查询
     */
    @Test
    public  void testReference() {
        //1.通过工具类获取entityManager
        EntityManager entityManager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = entityManager.getTransaction();
        tx.begin();
        //3.增删改查 -- 根据id查询客户
        /**
         * getReference : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = entityManager.getReference(Customer.class, 1l);
        System.out.print(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        entityManager.close();
    }

    /**
     * 删除数据
     */
    @Test
    public void testRemove(){

        //通过工具类获取EntityManager
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //增删改查 -- 删除客户
        Customer customer = em.find(Customer.class,1L);
        //调用remove方法完成删除操作
        em.remove(customer);
        System.out.println(customer);
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

    /**
     * 更新客户的操作
     *      merge(Object)
     */
    @Test
    public void testUpdate(){

        //通过工具类获取EntityManager
        EntityManager em = JpaUtils.getEntityManager();
        //开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //增删改查 -- 更改客户
        Customer customer = em.find(Customer.class,1L);
        //调用merge方法完成更新操作
        customer.setCustIndustry("it尚硅谷");
        Customer customer1 = em.merge(customer);
        System.out.println(customer1);
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }
}

查询全部数据，新建一个测试类

package com.feng.test;

import com.feng.untils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;

/**
 * @Author weidaiyong
 * @Date 2020/4/9 13:47
 * @Version 1.0
 */
public class JpaSqlTest {


    /**
     * 查询全部
     *      jqpl：from cn.itcast.domain.Customer
     *      sql：SELECT * FROM cst_customer
     */
    @Test
    public void testQueryAll(){

        //1.获取entityManager对象
        EntityManager manager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = manager.getTransaction();
        tx.begin();
        //3.查询全部
        String jqpl="from Customer";
        Query query = manager.createQuery(jqpl);
        //发送查询，并封装结果集
        List resultList = query.getResultList();

        for (Object o : resultList) {

            System.out.println(o);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        manager.close();

    }


    /**
     * 排序查询： 倒序查询全部客户（根据id倒序）
     *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
     *      jpql：from Customer order by custId desc
     *
     * 进行jpql查询
     *      1.创建query查询对象
     *      2.对参数进行赋值
     *      3.查询，并得到返回结果
     */
    @Test
    public void testQueryOrders(){

        //1.获取entityManager对象
        EntityManager manager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = manager.getTransaction();
        tx.begin();
        //3.查询全部
        String jqpl="from Customer order by custId desc";
        Query query = manager.createQuery(jqpl);
        //发送查询，并封装结果集
        List resultList = query.getResultList();

        for (Object o : resultList) {

            System.out.println(o);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        manager.close();

    }


    /**
     * 使用jpql查询，统计客户的总数
     *      sql：SELECT COUNT(cust_id) FROM cst_customer
     *      jpql：select count(custId) from Customer
     */
    @Test
    public void testCount(){

        //1.获取entityManager对象
        EntityManager manager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = manager.getTransaction();
        tx.begin();
        //3.查询全部
        String jqpl="select count(custId) from Customer ";
        Query query = manager.createQuery(jqpl);
        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);

        //4.提交事务
        tx.commit();
        //5.释放资源
        manager.close();

    }


    /**
     * 分页查询
     *      sql：select * from cst_customer limit 0,2
     *      jqpl : from Customer
     */
    @Test
    public void testPaged(){

        //1.获取entityManager对象
        EntityManager manager = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = manager.getTransaction();
        tx.begin();
        //3.查询全部
        String jqpl="from Customer ";
        Query query = manager.createQuery(jqpl);
        //ii.对参数赋值 -- 分页参数
        //起始索引
       query.setFirstResult(0);
        //每页查询的条数
       query.setMaxResults(2);

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List resultList = query.getResultList();
        for (Object o : resultList) {
            System.out.println(o);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        manager.close();

    }


    /**
     * 条件查询
     *     案例：查询客户名称以‘传智播客’开头的客户
     *          sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
     *          jpql : from Customer where custName like ?
     */
    @Test
    public void testCondition() {
        //1.获取entityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer where custName like ? ";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 占位符参数
        //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
        query.setParameter(1,"传智播客%");

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }



}