<Spring Data JPA>一 JPA原生

1.pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.maple</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>jpa-01</module>
    </modules>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.写配置文件 默认路径 resources/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>
            <!-- 数据库信息
                用户名，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"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

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

3.写实体类，与表建立关联

package org.maple.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;

import javax.persistence.*;

/**
 * @author mapleins
 * @Date 2019-01-10 20:31
 * @Desc
 **/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Accessors(chain = true)
@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 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;//客户地址
}

4.创建工厂工具类

package org.maple.util;

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();
    }
}

5.测试（CRUD）

package org.maple.test;

import org.junit.Test;
import org.maple.domain.Customer;
import org.maple.util.JpaUtils;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

/**
 * @author mapleins
 * @Date 2019-01-10 20:34
 * @Desc
 **/
public class JPATest {

    /**
     * 测试保存  persist
     */
    @Test
    public void testSave(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        Customer customer = new Customer().setCustName("tom").setCustIndustry("抓猫公司");
        manager.persist(customer);
        transaction.commit();
        manager.close();
    }

    /**
     * 根据id查询  find
     */
    @Test
    public void testFind(){
        EntityManager manager = JpaUtils.getEntityManager();
        Customer customer = manager.find(Customer.class, 1l);
        System.out.println(customer);
    }

    /**
     * 根据id查询  getReference
     * 调用查询结果的属性才会发送，所以延迟查询
     */
    @Test
    public void testReference(){
        EntityManager manager = JpaUtils.getEntityManager();
        Customer customer = manager.getReference(Customer.class, 1l);
        System.out.println(customer);
    }

    /**
     * 删除  remove
     * 需要先查出来再删
     */
    @Test
    public void testRemove(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //先查后删
        Customer customer = manager.find(Customer.class, 1l);
        manager.remove(customer);
        transaction.commit();
        manager.close();
    }

    /**
     * 更新 merge
     */
    @Test
    public void testMerge(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //先查后更新
        Customer customer = manager.find(Customer.class, 2l);
        customer.setCustIndustry("抓老鼠公司");
        manager.merge(customer);
        transaction.commit();
        manager.close();
    }

}

6.jpa操作的操作步骤

1.加载配置文件创建实体管理器工厂
　　Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
　　createEntityMnagerFactory（持久化单元名称）
　　作用：创建实体管理器工厂

2.根据实体管理器工厂，创建实体管理器
　　EntityManagerFactory ：获取EntityManager对象
　　方法：createEntityManager
　　* 内部维护的很多的内容
　　内部维护了数据库信息，
　　维护了缓存信息
　　维护了所有的实体管理器对象
　　再创建EntityManagerFactory的过程中会根据配置创建数据库表
　　* EntityManagerFactory的创建过程比较浪费资源
　　特点：线程安全的对象
　　多个线程访问同一个EntityManagerFactory不会有线程安全问题
　　* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
　　思路：创建一个公共的EntityManagerFactory的对象
　　* 静态代码块的形式创建EntityManagerFactory

3.创建事务对象，开启事务
　　EntityManager对象：实体类管理器
　　beginTransaction : 创建事务对象
　　presist ： 保存
　　merge ： 更新
　　remove ： 删除
　　find/getRefrence ： 根据id查询

　　Transaction 对象 ： 事务
　　begin：开启事务
　　commit：提交事务
　　rollback：回滚

4.增删改查操作
5.提交事务
6.释放资源

7.查询全部、分页查询、统计查询、条件查询、排序

package org.maple.test;

import org.junit.Test;
import org.maple.util.JpaUtils;

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

/**
 * @author mapleins
 * @Date 2019-01-10 20:59
 * @Desc 查询全部、分页查询、统计查询、条件查询、排序
 **/
public class JPATest2 {

    /**
     * 查询全部
     */
    @Test
    public void findAll(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //jpql
        String jpql = "from Customer";
        Query query = manager.createQuery(jpql);
        List resultList = query.getResultList();
        System.out.println(resultList);

        transaction.commit();
        manager.close();
    }

    /**
     * 查询全部 根据id 倒序
     */
    @Test
    public void findAllOrderById(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //jpql
        String jpql = "from Customer order by custId desc ";
        Query query = manager.createQuery(jpql);
        List resultList = query.getResultList();
        System.out.println(resultList);

        transaction.commit();
        manager.close();
    }

    /**
     * 统计查询
     */
    @Test
    public void count(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //jpql
        String jpql = "select count(*) from Customer";
        Query query = manager.createQuery(jpql);
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);

        transaction.commit();
        manager.close();
    }

    /**
     * 分页查询
     */
    @Test
    public void limit(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //jpql
        String jpql = "from Customer";
        Query query = manager.createQuery(jpql);
        //分页
        query.setFirstResult(0); //从0开始查,包括0
        query.setMaxResults(2); //查询2条
        List resultList = query.getResultList();
        System.out.println(resultList);

        transaction.commit();
        manager.close();
    }

    /**
     * 条件查询
     * 查询名字带o的
     */
    @Test
    public void testCondition(){
        EntityManager manager = JpaUtils.getEntityManager();
        EntityTransaction transaction = manager.getTransaction();
        transaction.begin();
        //jpql
        String jpql = "from Customer where custName like ?";
        Query query = manager.createQuery(jpql);
        query.setParameter(1,"%o%");
        List resultList = query.getResultList();
        System.out.println(resultList);

        transaction.commit();
        manager.close();
    }
}