在SpringData JPA 中实现对持久层的操作

1.导入依赖 hibernate 这个依赖自带实现JPA接口

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.32.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>

2.在resources目录下建立 META-INF文件夹 ，创建JPA? ?persistence.xml配置文件

?persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
   <!--  需要配置persistence-unit 节点
         持久化单元:
               name: 持久化单元名称  可随时切换， 若是OpenJPA的实现方式就 换成 OpenJPA 就可以了
               transaction-type: 事务管理方式
                       JTA:分布式事务管理
                       RESOURCE_LOCAL:本地事务管理
    -->
    <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">

        <!--JPA 的 实现方式    顺序别搞错，要放在class上面    -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--需要进行ORM 的POJO类 -->
        <class>com.kuang.pojo.Customer</class>


        <!-- 可选配置 :配置 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="2001"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springdata_jpa?useUnicode=true&amp;useSSL=false&amp;characterEncoding=UTF-8"/>

            <!-- 配置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"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL57InnoDBDialect"/>

        </properties>
    </persistence-unit>

</persistence>

3.创建测试类

package com.kuang.test;

import com.kuang.pojo.Customer;
import org.junit.Before;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.xml.soap.SAAJMetaFactory;

public class JpaTest {

    private EntityManagerFactory factory;

    @Before
    public void before() {
        //EntityManagerFactory 创建工厂 对应 sqlSessionFactory  用来创建 entityManager
        factory = Persistence.createEntityManagerFactory("hibernateJPA");
    }

    @Test
    public void insert() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启

            Customer customer = new Customer();
            customer.setCustName("刘备");
            customer.setCustAddress("锦州");
            entityManager.persist(customer);

            transaction.commit();//事务提交
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }

    @Test
    public void select() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启

            Customer customer = entityManager.find(Customer.class, 1L);
//            Customer customer = entityManager.getReference(Customer.class, 1L);//延迟查询
//            System.out.println("=======");
            System.out.println(customer);

            transaction.commit();//事务提交
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }
    @Test
    public void update() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启

            Customer customer = new Customer();
            customer.setCustId(9L);
            customer.setCustName("lzl");
            customer.setCustAddress("为鲁斯");


            /**
             * 如果指定了主键:
             *          更新 :1. 先查询 看是否有变化
             *         *如果有变化 更新  如果没有变化 就不更新
             * 如果没有指定主键:
             *         插入:
             */
            //存在即修改, 不存在就添加
            //注意： 修改是覆盖操作，你没给的值，就全给你覆盖为null
            // 如果你不想让他查一遍,你可以自己写JPQL语句进行添加或者修改
            Customer merge = entityManager.merge(customer);

            transaction.commit();//事务提交

        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }


    @Test
    public void update_JPQL() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启


            String jpql="update Customer set custName=:custName , custAddress=:custAddress where custId=:id";

           entityManager.createQuery(jpql)
                   .setParameter("custName","张杰")
                   .setParameter("custAddress","广东")
                   .setParameter("id",3L)
                   .executeUpdate();

            transaction.commit();//事务提交

        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }
    @Test
    public void test_SQL() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启


            String sql="update tb_customer set cust_name=:custName , cust_address=:custAddress where  cust_id=:id";

            entityManager.createNativeQuery(sql)
                    .setParameter("custName","谢娜")
                    .setParameter("custAddress","湖南")
                    .setParameter("id",3L)
                    .executeUpdate();

            transaction.commit();//事务提交
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }

    @Test
    public void delete() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启

            Customer customer = entityManager.find(Customer.class, 3L);
            entityManager.remove(customer);// 这样删除，是删除游离状态的，会抛异常不允许这样操作  IllegalArgumentException: Removing a detached instance com.kuang.pojo.Customer#3

            transaction.commit();//事务提交
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }

    @Test
    public void template() {
        //其实底层实现还是hibernate
        // entityManager 相当于 sqlSession 代码与数据库之间的桥梁
        EntityManager entityManager = null;
        EntityTransaction transaction=null;
        try {
            entityManager = factory.createEntityManager();
            transaction = entityManager.getTransaction();//获取事务对象
            transaction.begin();//事务开启



            transaction.commit();//事务提交
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();//事务回滚
        } finally {
            if (entityManager!=null){
                entityManager.close();//关闭连接
            }
        }

    }
}