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

    }

}

巴特西

<Spring Data JPA>一 JPA原生

1.pom依赖

2.写配置文件默认路径 resources/META-INF/persistence.xml

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

4.创建工厂工具类

5.测试（CRUD）

6.jpa操作的操作步骤

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

最新文章

热门文章

巴特西

<Spring Data JPA>一 JPA原生

1.pom依赖

2.写配置文件 默认路径 resources/META-INF/persistence.xml

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

4.创建工厂工具类

5.测试（CRUD）

6.jpa操作的操作步骤

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

最新文章

热门文章

2.写配置文件默认路径 resources/META-INF/persistence.xml