JPA初学笔记

一. jpa入门案列搭建环境

案列：对客户表进行相关操作

1.创建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>
    <build>
        <pluginManagement>
            <plugins>
                <!--jdk编译插件-->
                <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>
                        <encoding>utf-8</encoding>
                    </configuration>
                </plugin>
                <!--tomcat插件-->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <!-- tomcat7的插件， 不同tomcat版本这个也不一样 -->
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.1</version>
                    <configuration>
                        <!-- 通过maven tomcat7:run运行项目时，访问项目的端口号 -->
                        <port>80</port>
                        <!-- 项目访问路径  本例：localhost:9090,  如果配置的aa， 则访问路径为localhost:9090/aa-->
                        <path>/travel</path>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

2.配置jpa的核心配置文件

配置文件要求:
1.位置：配置到类路径resources下的一个叫做META-INF的文件夹下
2.命名：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>
<!--            数据库信息
                用户名：javax.persistence.jdbc.user
                密码：javax.persistence.jdbc.password
                驱动：javax.persistence.jdbc.driver
                数据库地址：javax.persistence.jdbc.url
                -->
        <properties>
            <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实现方的配置信息-->
<!--              显示sql:  false/true-->
            <property name="hibernate.show_sql" value="true"/>
<!--            自动创建数据库表: create:程序运行时创建表（如果存在，先删除再创建）（每次都只会保留最后一条记录）
                               update:程序运行时创建表（如果存在，则不创建）（常用）
                               none:不会创建表-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

3.编写客户实体类

根据数据库的字段对应建立即可

public class Customer {
    private long custId; //客户主键
    private String custName; //客户名称
    private String custSource; //客户来源
    private String custIndustry; //客户级别
    private String custLevel;  //客户所属行业
    private String custAddress; //客户地址
    private String custPhone; //客户联系方式

4.配置实体类和表，类中属性和表中字段的映射关系

/*
    客户的实体类
       配置映射关系
       1.实体类和表的映射关系
      2.实体类中属性和表中字段的映射关系
      @Entity:声明实体类
      @Table：配置实体类和表的映射关系(name：映射的表明)
      @Id：声明表的主键
      @GeneratedValue:配置主键的生成策略（strategy = GenerationType.IDENTITY：自增）
      @Column配置属性和字段的映射关系（name：指定数据库的字段名）
*/
import javax.persistence.*;

@Entity
@Table(name="cst_customer")
public class Customer {
    @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_industry")
    private String custIndustry; //客户级别
    @Column(name = "cust_level")
    private String custLevel;  //客户所属行业
    @Column(name = "cust_address")
    private String custAddress; //客户地址
    @Column(name = "cust_phone")
    private String custPhone; //客户联系方式

5.保存客户到数据库中

步骤：
测试jpa保存
Jpa操作步骤
1.加载配置文件创建工厂（尸体管理器工厂）对象
2.通过实体管理类工厂获取实体管理器
3.获取事务对象，开启事务
4.完成增删改查操作
5.提交事务（回滚事务）
6.释放资源

public class JpaTest {
    @Test
    public void testSave(){
//        1.加载配置文件创建工厂（尸体管理器工厂）对象
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
//        2.通过实体管理类工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
//         3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
//        4.完成增删改查操作(保存一个客户到数据库中)
        Customer customer = new Customer();
        customer.setCustName("xkm");
        customer.setCustIndustry("Boss");
//        保存操作
        em.persist(customer);
//         5.提交事务（回滚事务）
        tx.commit();
//        6.释放资源
        em.close();
        factory.close();
    }

6.注意事项

JDK9会报错
java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException
原因：
我使用JDK版本是JDK9.0，缺少JAXB API的jar包。JAXB API是java EE 的API，因此在java SE 9.0 中不再包含这个 Jar 包。 java 9 中引入了模块的概念，默认情况下，Java SE中将不再包含java EE 的Jar包
而在 java 6/7 / 8 时关于这个API 都是捆绑在一起的

解决方案：
一、降低JDK版本

二、导入相关的jar包或者maven依赖

		<dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
 

二.主键生成策略的说明

	@GeneratedValue(strategy = GenerationType.IDENTITY)

@GeneratedValue(strategy=GenerationType.IDENTITY)
strategy：
1） GenerationType.IDENTITY：自增 -> mysql
要求：底层数据必须支持自动增长（底层数据库支持自动增长方式，对id自增）
2）GenerationType.SEQUENCE：序列 ->oracle
要求：底层数据库必须支持序列
3) GenerationType.TABLE（了解）
jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
4) GenerationType.AUTO （了解）
由程序自动帮我们选择主键生成策略

三.抽取JpaUtil工具类

1.作用

解决实体管理器工厂的浪费资源和耗时问题
通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
静态代码块只会再第一次执行时执行一次

2.工具类代码

public class JpaUtil {
    private static EntityManagerFactory factory;

    static{
//        1.加载配置文件，床架鸟entityManagerFactory
         factory = Persistence.createEntityManagerFactory("myJpa");
    }
    //    第一次访问getEntityManager方法时，
    //    会经过静态代码块创建一个factory对象，再调用方法，
    //    因为EntityManagerFactory时线程安全的，所以可以公用一个
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

四.基本语句

1.find查询语句（立即加载）

find方式执行时立即获取结果对象
要用update方式，create会删除表
根据ID查询：

        Customer customer1 = em.find(Customer.class, 2l);
        System.out.println(customer1);

2.getReference查询语句（延迟加载）

只有调用查询结果时才会真的查询得到对象

        Customer customer1 = em.getReference(Customer.class, 2l);
        System.out.println(customer1);

3.remove删除语句

先查询再删除
根据ID删除：

        Customer customer1 = em.find(Customer.class, 2l);
        em.remove(customer1);

4.merge修改语句

先查询再修改再保存：

        Customer customer1 = em.find(Customer.class, 3l);
        customer1.setCustName("mgdz");
        em.merge(customer1);

五.JPQL复杂查询

sql: 查询的时表和表中的字段
jpql：查询的时实体类和类中的属性
jpql和sql语句的语法相似

1.查询全部

    String jpql = "from cn.xkm.domain.Customer";
    Query query = em.createQuery(jpql);
    List list = query.getResultList();
    for (Object o : list) {
        System.out.println(o);
    }

 @Test
    public void findAll(){
        EntityManager em = JpaUtil.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql = "from cn.xkm.domain.Customer";
        Query query = em.createQuery(jpql);
        List list = query.getResultList();
        for (Object o : list) {
            System.out.println(o);
        }
        tx.commit();
        em.close();
    }

注：不写全类名也可以执行

2.排序

倒序：

  String jpql = "from Customer order by custId desc";
  Query query = em.createQuery(jpql);

3.统计查询

 String jpql = "select count(custId) from Customer";
 Query query = em.createQuery(jpql);
 Object singleResult = query.getSingleResult();

4.分页查询

sql：select * from customer limit ?,?
jqpl:from Customer
jpql 先查询全部，再去设置分页参数，类似sql的limit后的参数
query.setFirstResult(0);
query.setMaxResults(2);

//        首先查询全部
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
//        设置起始索引
        query.setFirstResult(0);
//        设置结束索引
        query.setMaxResults(2);
        List resultList = query.getResultList();
       resultList.forEach(a-> System.out.println(a));

5.条件查询

//        条件查询
        String jpql = "from Customer where custName like ?";
        Query query = em.createQuery(jpql);
//        设置参数内容，名字以m开头的
        query.setParameter(1,"m%") ;
        List resultList = query.getResultList();
        resultList.forEach(a-> System.out.println(a));