JPA(Java Persistence API)--JavaEE5.0标准ORM规范

目录：

1、JPA概述
2、JPA helloworld
3、JPA基本注解
4、用 table 来生成主键详解
5、JPA相关接口/类：Persistence、EntityManagerFactory
6、EntityManager
7、EntityTransaction
8、映射关联关系：映射单向多对一的关联关系
9、映射关联关系：映射单向一对多的关联关系
10、映射关联关系：映射双向一对多（多对一）的关联关系
11、映射关联关系：映射双向一对一的关联关系
12、映射关联关系：映射双向多对多的关联关系
13、二级缓存
14、JPQL
15、JPQL 查询缓存
16、order by和group by
17、JPQL 关联查询、聚合函数、子查询、having子句
18、JPA内建函数
19、Spring 整合 JPA

 

1、JPA概述    <--返回目录

　　JPA：Java Persistence API，用于对象持久化的 API。Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层

　　JPA和Hibernate的关系：JPA 是 hibernate 的一个抽象（就像JDBC和JDBC驱动的关系）。
　　　　- PA 是规范：JPA 本质上就是一种  ORM 规范，不是ORM 框架 —— 因为 JPA 并未提供 ORM 实现，它只是制订了一些规范，提供了一些编程的 API 接口，但具体实现则由 ORM 厂商提供实现
　　　　- Hibernate 是实现：Hibernate 除了作为 ORM 框架之外，它也是一种 JPA 实现
　　　　- 从功能上来说， JPA 是 Hibernate 功能的一个子集

　　JPA 的供应商，JPA 的目标之一是制定一个可以由很多供应商实现的 API，目前Hibernate 3.2+、TopLink 10.1+ 以及 OpenJPA 都提供了 JPA 的实现.
　　　　- Hibernate: JPA 的始作俑者就是 Hibernate 的作者.ibernate 从 3.2 开始兼容 JPA
　　　　- OpenJPA:  是 Apache 组织提供的开源项目
　　　　- TopLink: 以前需要收费，如今开源了

 

　　JPA的优势

　　　　- 标准化:  提供相同的 API，这保证了基于JPA 开发的企业应用能够经过少量的修改就能够在不同的 JPA 框架下运行。
　　　　- 简单易用，集成方便:  JPA 的主要目标之一就是提供更加简单的编程模型，在 JPA 框架下创建实体和创建 Java  类一样简单，只需要使用 javax.persistence.Entity 进行注释；JPA 的框架和接口也都非常简单，
　　　　- 可媲美JDBC的查询能力:  JPA的查询语言是面向对象的，JPA定义了独特的JPQL，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
　　　　- 支持面向对象的高级特性: JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，最大限度的使用面向对象的模型

　　JPA 包括 3方面的技术

　　　　- ORM  映射元数据：JPA 支持 XML 和  JDK 5.0 注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中。  
　　　　- JPA 的 API：用来操作实体对象，执行CRUD操作，框架在后台完成所有的事情，开发者从繁琐的 JDBC和 SQL代码中解脱出来。  
　　　　- 查询语言（JPQL）：这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序和具体的  SQL 紧密耦合。

 

2、JPA helloworld    <--返回目录

　　步骤

1)创建 persistence.xml, 在这个文件中配置持久化单元
    - 需要指定跟哪个数据库进行交互;
    - 需要指定 JPA 使用哪个持久化的框架以及配置该框架的基本属性
2)创建实体类, 使用 annotation 来描述实体类跟数据库表之间的映射关系.
3)使用 JPA  API 完成数据增加、删除、修改和查询操作
    - 创建 EntityManagerFactory (对应 Hibernate 中的 SessionFactory);
    - 创建 EntityManager (对应 Hibernate 中的Session);

　　eclipse创建jpa工程

 　　依赖

hibernate-release-4.2.4.Final\lib\required\*.jar
hibernate-release-4.2.4.Final\lib\jpa\*.jar
数据库驱动的 jar 包

　　最终项目结构（链接：https://pan.baidu.com/s/1M0PvLwjG2DEApM_Cey19oQ 提取码：q9ia ）

　　JPA 规范要求在类路径的 META-INF 目录下放置persistence.xml，文件的名称是固定的

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="jpa_helloworld">
        <!-- 
        配置使用什么 ORM 产品来作为 JPA 的实现 
        1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
        2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. 
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
    
        <!-- 添加持久化类 -->
        <class>com.oy.jpa.Customer</class>
        
        <!-- 
        配置二级缓存的策略 
        ALL：所有的实体类都被缓存
        NONE：所有的实体类都不被缓存. 
        ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存
        DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类
        UNSPECIFIED：默认值，JPA 产品默认值将被使用
        <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
        -->
        
        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <!-- <property name="javax.persistence.jdbc.password" value="1230"/> -->
            
            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            
            <!-- 二级缓存相关 
            <property name="hibernate.cache.use_second_level_cache" value="true"/>
            <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
            <property name="hibernate.cache.use_query_cache" value="true"/>-->
        </properties>
    </persistence-unit>
</persistence>

　　Customer

package com.oy.jpa;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="jpa_customer")
@Entity
public class Customer {
    private Integer id;
    private String lastName;
    private String email;
    private int age;
    
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    
    @Column(name = "last_name")
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + "]";
    }
}

　　JpaTest

package com.oy.jpa;

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

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class JpaTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    
    @Before
    public void init(){
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa_helloworld");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }
    
    @After
    public void destroy(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    @Test
    public void testHelloWorld() {
        Customer c = new Customer();
        c.setLastName("aaa");
        c.setEmail("aaa@163.com");
        c.setAge(10);
        entityManager.persist(c);
    }
}

 

3、JPA基本注解    <--返回目录

　　@Entity

　　- 标注用于实体类声明语句之前，指出该Java 类为实体类，将映射到指定的数据库表。如声明一个实体类 Customer，它将映射到数据库中的 customer 表上。

　　@Table

　　- 当实体类与其映射的数据库表名不同名时需要使用 @Table 标注说明，该标注与 @Entity 标注并列使用，置于实体类声明语句之前，可写于单独语句行，也可与声明语句同行。
　　- @Table 标注的常用选项是 name，用于指明数据库的表名
　　- @Table标注还有一个两个选项 catalog 和 schema 用于设置表所属的数据库目录或模式，通常为数据库名。uniqueConstraints 选项用于设置约束条件，通常不须设置。

　　@Id

　　- @Id 标注用于声明一个实体类的属性映射为数据库的主键列。该属性通常置于属性声明语句之前，可与声明语句同行，也可写在单独行上。
　　- @Id标注也可置于属性的getter方法之前。

 

　　@GeneratedValue

　　- @GeneratedValue  用于标注主键的生成策略，通过 strategy 属性指定。默认情况下，JPA 自动选择一个最适合底层数据库的主键生成策略：SqlServer 对应 identity，MySQL 对应 auto increment。
　　- 在 javax.persistence.GenerationType 中定义了以下几种可供选择的策略：
　　　　IDENTITY：采用数据库 ID自增长的方式来自增主键字段，Oracle 不支持这种方式；
　　　　AUTO： JPA自动选择合适的策略，是默认选项；
　　　　SEQUENCE：通过序列产生主键，通过 @SequenceGenerator 注解指定序列名，MySql 不支持这种方式
　　　　TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

　　@Basic

　　- @Basic 表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的 getXxxx() 方法,默认即为@Basic
　　- fetch: 表示该属性的读取策略,有 EAGER 和 LAZY 两种,分别表示主支抓取和延迟加载,默认为 EAGER.
　　- optional:表示该属性是否允许为null, 默认为true

 

　　@Column

　　- 当实体的属性与其映射的数据库表的列不同名时需要使用@Column 标注说明，该属性通常置于实体的属性声明语句之前，还可与 @Id 标注一起使用。
　　- @Column 标注的常用属性是 name，用于设置映射数据库表的列名。此外，该标注还包含其它多个属性，如：unique 、nullable、length 等。
　　- @Column 标注的 columnDefinition 属性: 表示该字段在数据库中的实际类型.通常 ORM 框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR, 如果要将 String 类型映射到特定数据库的 BLOB 或TEXT 字段类型.
　　- @Column标注也可置于属性的getter方法之前

　　@Transient

　　- 表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性.
　　- 如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic

　　@Temporal

　　- 在核心的 Java API 中并没有定义 Date 类型的精度(temporal precision).  而在数据库中,表示 Date 类型的数据有 DATE, TIME, 和 TIMESTAMP 三种精度(即单纯的日期,时间,或者两者 兼备). 在进行属性映射时可使用@Temporal注解来调整精度.

@Temporal(TemporalType.TIMESTAMP)
public Date getCreatedTime() {
    return createdTime;
}

@Temporal(TemporalType.DATE)
public Date getBirth() {
    return birth;
}

 

4、用 table 来生成主键详解    <--返回目录

　　将当前主键的值单独保存到一个数据库的表中，主键的值每次都是从指定的表中查询来获得
　　这种方法生成主键的策略可以适用于任何数据库，不必担心不同数据库不兼容造成的问题。

name 属性表示该主键生成策略的名称，它被引用在@GeneratedValue中设置的generator 值中
table 属性表示表生成策略所持久化的表名
pkColumnName 属性的值表示在持久化表中，该主键生成策略所对应键值的名称
valueColumnName 属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加
pkColumnValue 属性的值表示在持久化表中，该生成策略所对应的主键
allocationSize 表示每次主键值增加的大小, 默认值为 50

 

5、JPA相关接口/类：Persistence、EntityManagerFactory    <--返回目录

　　Persistence  类是用于获取 EntityManagerFactory 实例。该类包含一个名为 createEntityManagerFactory 的 静态方法 。

　　createEntityManagerFactory 方法有如下两个重载版本。
　　- 带有一个参数的方法以 JPA 配置文件 persistence.xml 中的持久化单元名为参数
　　- 带有两个参数的方法：前一个参数含义相同，后一个参数 Map类型，用于设置 JPA 的相关属性，这时将忽略其它地方设置的属性。Map 对象的属性名必须是 JPA 实现库提供商的名字空间约定的属性名。

　　EntityManagerFactory 接口主要用来创建 EntityManager 实例。该接口约定了如下4个方法：
　　- createEntityManager()：用于创建实体管理器对象实例。
　　- createEntityManager(Map map)：用于创建实体管理器对象实例的重载方法，Map 参数用于提供 EntityManager 的属性。
　　- isOpen()：检查 EntityManagerFactory 是否处于打开状态。实体管理器工厂创建后一直处于打开状态，除非调用close()方法将其关闭。
　　- close()：关闭 EntityManagerFactory 。 EntityManagerFactory 关闭后将释放所有资源，isOpen()方法测试将返回 false，其它方法将不能调用，否则将导致IllegalStateException异常。

6、EntityManager    <--返回目录

　　在 JPA 规范中, EntityManager 是完成持久化操作的核心对象。实体作为普通 Java 对象，只有在调用 EntityManager 将其持久化后才会变成持久化对象。　EntityManager 对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
　　实体的状态:

新建状态:   新创建的对象，尚未拥有持久性主键。
持久化状态：已经拥有持久性主键并和持久化建立了上下文环境
游离状态：拥有持久化主键，但是没有与持久化建立上下文环境
删除状态:  拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

　　5个方法：

　　- find (Class<T> entityClass,Object primaryKey)：返回指定的 OID 对应的实体类对象，如果这个实体存在于当前的持久化环境，则返回一个被缓存的对象；否则会创建一个新的 Entity, 并加载数据库中相关信息；若 OID 不存在于数据库中，则返回一个 null。第一个参数为被查询的实体类类型，第二个参数为待查找实体的主键值。
　　- getReference (Class<T> entityClass,Object primaryKey)：与find()方法类似，不同的是：如果缓存中不存在指定的 Entity, EntityManager 会创建一个 Entity 类的代理，但是不会立即加载数据库中的信息，只有第一次真正使用此 Entity 的属性才加载，所以如果此 OID 在数据库不存在，getReference() 不会返回 null 值, 而是抛出EntityNotFoundException
　　- persist (Object entity)：用于将新创建的 Entity 纳入到 EntityManager 的管理。该方法执行后，传入 persist() 方法的 Entity 对象转换成持久化状态。
如果传入 persist() 方法的 Entity 对象已经处于持久化状态，则 persist() 方法什么都不做。
如果对删除状态的 Entity 进行 persist() 操作，会转换为持久化状态。
如果对游离状态的实体执行 persist() 操作，可能会在 persist() 方法抛出 EntityExistException(也有可能是在flush或事务提交后抛出)。
　　- remove (Object entity)：删除实例。如果实例是被管理的，即与数据库实体记录关联，则同时会删除关联的数据库记录。
　　- merge (T entity)：merge() 用于处理 Entity 的同步。即数据库的插入和更新操作

　　其他方法

flush()：同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中。
setFlushMode (FlushModeType flushMode)：设置持久上下文环境的Flush模式。参数可以取2个枚举
　　FlushModeType.AUTO 为自动更新数据库实体，
　　FlushModeType.COMMIT 为直到提交事务时才更新数据库记录。
getFlushMode ()：获取持久上下文环境的Flush模式。返回FlushModeType类的枚举值。
refresh (Object entity)：用数据库实体记录的值更新实体对象的状态，即更新实例的属性值。
clear()：清除持久上下文环境，断开所有关联的实体。如果这时还有未提交的更新则会被撤消。
contains (Object entity)：判断一个实例是否属于当前持久上下文环境管理的实体。
isOpen ()：判断当前的实体管理器是否是打开状态。
getTransaction ()：返回资源层的事务对象。EntityTransaction实例可以用于开始和提交多个事务。
close()：关闭实体管理器。之后若调用实体管理器实例的方法或其派生的查询对象的方法都将抛出 IllegalstateException 异常，除了getTransaction 和 isOpen方法(返回 false)。不过，当与实体管理器关联的事务处于活动状态时，调用 close 方法后持久上下文将仍处于被管理状态，直到事务完成。

　　创建查询

createQuery (String qlString)：创建一个查询对象。
createNamedQuery (String name)：根据命名的查询语句块创建查询对象。参数为命名的查询语句。
createNativeQuery (String sqlString)：使用标准 SQL语句创建查询对象。参数为标准SQL语句字符串。
createNativeQuery (String sqls, String resultSetMapping)：使用标准SQL语句创建查询对象，并指定返回结果集 Map的 名称。

 

7、EntityTransaction    <--返回目录

　　EntityTransaction 接口用来管理资源层实体管理器的事务操作。通过调用实体管理器的getTransaction方法 获得其实例。

begin():用于启动一个事务，此后的多个数据库操作将作为整体被提交或撤消。若这时事务已启动则会抛出 IllegalStateException 异常。
commit():用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中。
rollback():撤消(回滚)当前事务。即撤消事务启动后的所有数据库更新操作，从而不对数据库产生影响。
setRollbackOnly():使当前事务只能被撤消。
getRollbackOnly():查看当前事务是否设置了只能撤消标志。
isActive ():查看当前事务是否是活动的。如果返回true则不能调用begin方法，否则将抛出 IllegalStateException 异常；
  如果返回 false 则不能调用 commit、rollback、setRollbackOnly 及 getRollbackOnly 方法，否则将抛出 IllegalStateException 异常。

 

8、映射关联关系：映射单向多对一的关联关系    <--返回目录

　　项目结构

　　Customer

package com.oy.jpa;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="jpa_customer")
@Entity
public class Customer {
    private Integer id;
    private String lastName;
    private String email;
    private int age;
    
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    
    @Column(name = "last_name")
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + "]";
    }
}

　　Order

package com.oy.jpa;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Table(name = "jpa_order")
@Entity
public class Order {
    private Integer id;
    private String orderName;
    private Customer customer;

    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "order_name")
    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    // 映射单向 n-1 的关联关系
    // 使用 @ManyToOne 来映射多对一的关联关系
    // 使用 @JoinColumn 来映射外键.
    // 可使用 @ManyToOne 的 fetch 属性来修改默认的关联属性的加载策略
    @JoinColumn(name = "customer_id")
    @ManyToOne(fetch = FetchType.LAZY)
    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

}

　　persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="jpa_helloworld">
        <!-- 
        配置使用什么 ORM 产品来作为 JPA 的实现 
        1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
        2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. 
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
    
        <!-- 添加持久化类 -->
        <class>com.oy.jpa.Customer</class>
        <class>com.oy.jpa.Order</class>
        
        <!-- 
        配置二级缓存的策略 
        ALL：所有的实体类都被缓存
        NONE：所有的实体类都不被缓存. 
        ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存
        DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类
        UNSPECIFIED：默认值，JPA 产品默认值将被使用
        <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
        -->
        
        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <!-- <property name="javax.persistence.jdbc.password" value="1230"/> -->
            
            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
            
            <!-- 二级缓存相关 
            <property name="hibernate.cache.use_second_level_cache" value="true"/>
            <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
            <property name="hibernate.cache.use_query_cache" value="true"/>-->
        </properties>
    </persistence-unit>
</persistence>

　　测试

package com.oy.jpa;

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

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class JpaTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    
    @Before
    public void init(){
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa_helloworld");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }
    
    @After
    public void destroy(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    @Test
    public void testManyToOnePersist() {
        Customer c = new Customer();
        c.setLastName("ccc");
        c.setEmail("ccc@163.com");
        c.setAge(20);
        entityManager.persist(c); // 先保存主表（n-1中1的一方）
        
        Order order = new Order();
        order.setCustomer(c);
        order.setOrderName("iphone12");
        entityManager.persist(order); // 后保存从表（n-1中n的一方, 即包含外键字段的表）
    }
}

　　控制台打印sql

Hibernate: 
    insert 
    into
        jpa_customer
        (age, email, last_name) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        jpa_order
        (customer_id, order_name) 
    values
        (?, ?)

　　删改查

@Test
public void testManyToOneUpdate(){
    Order order = entityManager.find(Order.class, 2);
    order.getCustomer().setLastName("FFF");
}

//不能直接删除 1 的一端, 因为有外键约束. 
@Test
public void testManyToOneRemove(){
//        Order order = entityManager.find(Order.class, 1);
//        entityManager.remove(order);
    
    Customer customer = entityManager.find(Customer.class, 7);
    entityManager.remove(customer);
}

//默认情况下, 使用左外连接的方式来获取 n 的一端的对象和其关联的 1 的一端的对象. 
//可使用 @ManyToOne 的 fetch 属性来修改默认的关联属性的加载策略
@Test
public void testManyToOneFind(){
    Order order = entityManager.find(Order.class, 1);
    System.out.println(order.getOrderName());
    
    System.out.println(order.getCustomer().getLastName());
}

 

9、映射关联关系：映射单向一对多的关联关系    <--返回目录

　　Order类

package com.oy.jpa;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "jpa_order")
@Entity
public class Order {
    private Integer id;
    private String orderName;

    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "order_name")
    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
}

　　Customer类

package com.oy.jpa;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Table(name="jpa_customer")
@Entity
public class Customer {
    private Integer id;
    private String lastName;
    private String email;
    private int age;
    private Set<Order> orders = new HashSet<>();
    
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    
    @Column(name = "last_name")
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    // 映射单向 1-n 的关联关系
    // 使用 @OneToMany 来映射 1-n 的关联关系; 使用 @JoinColumn 来映射外键列的名称
    // 可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略; 通过 @OneToMany 的 cascade 属性来修改默认的删除策略. 
    // 注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了. 
    @JoinColumn(name="customer_id")
    @OneToMany(fetch=FetchType.LAZY)
    //@OneToMany(fetch=FetchType.LAZY,cascade={CascadeType.REMOVE},mappedBy="customer")
    public Set<Order> getOrders() {
        return orders;
    }

    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
        
    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + "]";
    }
}

　　测试

@Test
public void testUpdate(){
    Customer customer = entityManager.find(Customer.class, 10);
    
    customer.getOrders().iterator().next().setOrderName("O-XXX-10");
}

//默认情况下, 若删除 1 的一端, 则会先把关联的 n 的一端的外键置空, 然后进行删除. 
//可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略. 
@Test
public void testOneToManyRemove(){
    Customer customer = entityManager.find(Customer.class, 8);
    entityManager.remove(customer);
}

//默认对关联的多的一方使用懒加载的加载策略. 
//可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
@Test
public void testOneToManyFind(){
    Customer customer = entityManager.find(Customer.class, 9);
    System.out.println(customer.getLastName());
    
    System.out.println(customer.getOrders().size());
}

//若是双向 1-n 的关联关系, 执行保存时
//若先保存 n 的一端, 再保存 1 的一端, 默认情况下, 会多出 n 条 UPDATE 语句.
//若先保存 1 的一端, 则会多出 n 条 UPDATE 语句
//在进行双向 1-n 关联关系时, 建议使用 n 的一方来维护关联关系, 而 1 的一方不维护关联系, 这样会有效的减少 SQL 语句. 
//注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了. 

//单向 1-n 关联关系执行保存时, 一定会多出 UPDATE 语句.
//因为 n 的一端在插入时不会同时插入外键列. 
@Test
public void testOneToManyPersist(){
    Customer customer = new Customer();
    customer.setAge(18);
    customer.setBirth(new Date());
    customer.setCreatedTime(new Date());
    customer.setEmail("mm@163.com");
    customer.setLastName("MM");
    
    Order order1 = new Order();
    order1.setOrderName("O-MM-1");
    
    Order order2 = new Order();
    order2.setOrderName("O-MM-2");
    
    //建立关联关系
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);
    
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    
    //执行保存操作
    entityManager.persist(customer);

    entityManager.persist(order1);
    entityManager.persist(order2);
}

 

10、映射关联关系：映射双向一对多（多对一）的关联关系    <--返回目录

　　在进行双向 1-n 关联关系时, 建议使用 n 的一方来维护关联关系, 而 1 的一方不维护关联系, 这样会有效的减少 SQL 语句. 
　　注意: 若在 1 的一端的 @OneToMany 中使用 mappedBy 属性, 则 @OneToMany 端就不能再使用 @JoinColumn 属性了. 

//@JoinColumn(name="customer_id")
// 1 的一方放弃维护关系
@OneToMany(fetch=FetchType.LAZY, mappedBy="customer")
public Set<Order> getOrders() {
    return orders;
}

 

11、映射关联关系：映射双向一对一的关联关系    <--返回目录

　　基于外键的 1-1 关联关系：在双向的一对一关联中，需要在关系被维护端(inverse side)中的 @OneToOne 注释中指定 mappedBy，以指定是这一关联中的被维护端。同时需要在关系维护端(owner side)建立外键列指向关系被维护端的主键列。

 

12、映射关联关系：映射双向多对多的关联关系    <--返回目录

　　在双向多对多关系中，我们必须指定一个关系维护端(owner side),可以通过 @ManyToMany 注释中指定 mappedBy 属性来标识其为关系维护端。

@ManyToMany
@JoinTable(name="中间表名称",
joinColumns=@joinColumn(name="本类的外键",
referencedColumnName="本类与外键对应的主键"),
inversejoinColumns=@JoinColumn(name="对方类的外键",
referencedColunName="对方类与外键对应的主键")
)

　　项目结构

　　Category

package com.oy.jpa;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Table(name = "jpa_category")
@Entity
public class Category {

    private Integer id;
    private String categoryName;

    private Set<Item> items = new HashSet<>();

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "category_name")
    public String getCategoryName() {
        return categoryName;
    }

    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }

    @ManyToMany(mappedBy = "categories")
    public Set<Item> getItems() {
        return items;
    }

    public void setItems(Set<Item> items) {
        this.items = items;
    }
}

　　Item

package com.oy.jpa;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Table(name = "jpa_item")
@Entity
public class Item {

    private Integer id;
    private String itemName;

    private Set<Category> categories = new HashSet<>();

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "item_name")
    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    // 使用 @ManyToMany 注解来映射多对多关联关系
    // 使用 @JoinTable 来映射中间表
    // 1. name 指向中间表的名字
    // 2. joinColumns 映射当前类所在的表在中间表中的外键
    // 2.1 name 指定外键列的列名
    // 2.2 referencedColumnName 指定外键列关联当前表的哪一列
    // 3. inverseJoinColumns 映射关联的类所在中间表的外键
    @JoinTable(name = "item_category", joinColumns = {
            @JoinColumn(name = "item_id", referencedColumnName = "id") }, inverseJoinColumns = {
                    @JoinColumn(name = "category_id", referencedColumnName = "id") })
    @ManyToMany
    public Set<Category> getCategories() {
        return categories;
    }

    public void setCategories(Set<Category> categories) {
        this.categories = categories;
    }
}

　　测试代码

package com.oy.jpa;

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

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class JpaTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

    @Before
    public void init() {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa_helloworld");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    @Test
    public void testManyToMany() {

    }
}

　　自动生成的表：

 

13、二级缓存    <--返回目录

　　加入ehcache的依赖包

　　实体类上添加@Cacheable

package com.oy.jpa;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Cacheable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Cacheable
@Table(name = "jpa_item")
@Entity
public class Item {

    private Integer id;
    private String itemName;

    private Set<Category> categories = new HashSet<>();

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "item_name")
    public String getItemName() {
        return itemName;
    }

    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    // 使用 @ManyToMany 注解来映射多对多关联关系
    // 使用 @JoinTable 来映射中间表
    // 1. name 指向中间表的名字
    // 2. joinColumns 映射当前类所在的表在中间表中的外键
    // 2.1 name 指定外键列的列名
    // 2.2 referencedColumnName 指定外键列关联当前表的哪一列
    // 3. inverseJoinColumns 映射关联的类所在中间表的外键
    @JoinTable(name = "item_category", joinColumns = {
            @JoinColumn(name = "item_id", referencedColumnName = "id") }, inverseJoinColumns = {
                    @JoinColumn(name = "category_id", referencedColumnName = "id") })
    @ManyToMany
    public Set<Category> getCategories() {
        return categories;
    }

    public void setCategories(Set<Category> categories) {
        this.categories = categories;
    }
}

　　persistence.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
    xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="jpa_helloworld">
        <!-- 配置使用什么 ORM 产品来作为 JPA 的实现 1. 实际上配置的是 javax.persistence.spi.PersistenceProvider 
            接口的实现类 2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>

        <!-- 添加持久化类 -->
        <class>com.oy.jpa.Category</class>
        <class>com.oy.jpa.Item</class>

        <!-- 配置二级缓存的策略 
            ALL：所有的实体类都被缓存 
            NONE：所有的实体类都不被缓存. 
            ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存 
            DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类 
            UNSPECIFIED：默认值，JPA 产品默认值将被使用 
        -->
         <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode> 

        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa" />
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- <property name="javax.persistence.jdbc.password" value="1230"/> -->

            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />

            <!-- 二级缓存相关 -->
            <property name="hibernate.cache.use_second_level_cache" value="true"/> 
            <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/> 
            <property name="hibernate.cache.use_query_cache" value="true"/> 
        </properties>
    </persistence-unit>
</persistence>

　　测试

package com.oy.jpa;

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

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class JpaTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

    @Before
    public void init() {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa_helloworld");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /**
     * 测试二级缓存。如果配置二级缓存成功，则只会发送一条查询SQL
     */
    @Test
    public void testSecondLevelCache(){
        Item item1 = entityManager.find(Item.class, 1);
        
        transaction.commit();
        entityManager.close();
        
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
        
        Item item2 = entityManager.find(Item.class, 1);
    }
}

 

14、JPQL    <--返回目录

　　JPQL语言，即 Java Persistence Query Language 的简称。JPQL 是一种和 SQL 非常类似的中间性和对象化查询语言，它最终会被编译成针对不同底层数据库的 SQL 查询，从而屏蔽不同数据库的差异。

　　Customer

package com.oy.jpa;

import java.util.Date;

import javax.persistence.Cacheable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@NamedQuery(name = "testNamedQuery", query = "FROM Customer c WHERE c.id = ?")
@Cacheable(true)
@Table(name = "JPA_CUTOMERS")
@Entity
public class Customer {
    private Integer id;
    private String lastName;
    private String email;
    private int age;
    private Date createdTime;
    private Date birth;

    public Customer() {
    }

    public Customer(String lastName, int age) {
        super();
        this.lastName = lastName;
        this.age = age;
    }

    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name = "LAST_NAME", length = 50, nullable = false)
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Temporal(TemporalType.TIMESTAMP)
    public Date getCreatedTime() {
        return createdTime;
    }

    public void setCreatedTime(Date createdTime) {
        this.createdTime = createdTime;
    }

    @Temporal(TemporalType.DATE)
    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", lastName=" + lastName + ", email=" + email + ", age=" + age + ", createdTime="
                + createdTime + ", birth=" + birth + "]";
    }
}

　　测试

package com.oy.jpa;

import java.util.Date;
import java.util.List;

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

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class JpaTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

    @Before
    public void init() {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa_helloworld");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    // createNativeQuery 适用于本地 SQL
    @Test
    public void testNativeQuery() {
        String sql = "SELECT age FROM jpa_cutomers WHERE id = ?";
        Query query = entityManager.createNativeQuery(sql).setParameter(1, 1);

        Object result = query.getSingleResult();
        System.out.println(result);
    }

    // createNamedQuery 适用于在实体类前使用 @NamedQuery 标记的查询语句
    @Test
    public void testNamedQuery() {
        Query query = entityManager.createNamedQuery("testNamedQuery").setParameter(1, 1);
        Customer customer = (Customer) query.getSingleResult();
        System.out.println(customer);
    }

    // 默认情况下, 若只查询部分属性, 则将返回 Object[] 类型的结果. 或者 Object[] 类型的 List.
    // 也可以在实体类中创建对应的构造器, 然后再 JPQL 语句中利用对应的构造器返回实体类的对象.
    @Test
    public void testPartlyProperties() {
        String jpql = "SELECT new Customer(c.lastName, c.age) FROM Customer c WHERE c.id > ?";
        List result = entityManager.createQuery(jpql).setParameter(1, 0).getResultList();
        System.out.println(result);
    }

    @Test
    public void testHelloJPQL() {
        String jpql = "FROM Customer c WHERE c.age > ?";
        Query query = entityManager.createQuery(jpql);

        // 占位符的索引是从 1 开始
        query.setParameter(1, 1);
        List<Customer> customers = query.getResultList();
        for (Customer c : customers) {
            System.out.println(c);
        }
    }

    /**
     * 生成 JPA_CUTOMERS 表, 并插入一条记录
     */
    @Test
    public void testCustomer() {
        Customer c = new Customer();
        c.setLastName("aaa");
        c.setEmail("aaa@163.com");
        c.setAge(10);
        c.setCreatedTime(new Date());
        c.setBirth(new Date());
        entityManager.persist(c);
    }
}

 

15、JPQL 查询缓存    <--返回目录

　　配置文件配置启用查询缓存

<property name="hibernate.cache.use_query_cache" value="true"/> 

　　测试

//使用 hibernate 的查询缓存. 
@Test
public void testQueryCache(){
    String jpql = "FROM Customer c WHERE c.age > ?";
    Query query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    
    //占位符的索引是从 1 开始
    query.setParameter(1, 1);
    List<Customer> customers = query.getResultList();
    System.out.println(customers.size());
    
    query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    
    //占位符的索引是从 1 开始
    query.setParameter(1, 1);
    customers = query.getResultList();
    System.out.println(customers.size());
}

 

16、order by和group by    <--返回目录

//查询 order 数量大于 2 的那些 Customer
@Test
public void testGroupBy(){
    String jpql = "SELECT o.customer FROM Order o "
            + "GROUP BY o.customer "
            + "HAVING count(o.id) >= 2";
    List<Customer> customers = entityManager.createQuery(jpql).getResultList();
    
    System.out.println(customers);
}

@Test
public void testOrderBy(){
    String jpql = "FROM Customer c WHERE c.age > ? ORDER BY c.age DESC";
    Query query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);
    
    //占位符的索引是从 1 开始
    query.setParameter(1, 1);
    List<Customer> customers = query.getResultList();
    System.out.println(customers.size());
}

 

17、JPQL 关联查询、聚合函数、子查询、having子句    <--返回目录

/**
 * 测试子查询
 */
@Test
public void testSubQuery(){
    //查询所有 Customer 的 lastName 为 YY 的 Order
    String jpql = "SELECT o FROM Order o WHERE o.customer = (SELECT c FROM Customer c WHERE c.lastName = ?)";
    
    Query query = entityManager.createQuery(jpql).setParameter(1, "YY");
    List<Order> orders = query.getResultList();
    System.out.println(orders.size());
}

/**
 * JPQL 的关联查询同 HQL 的关联查询. 
 */
@Test
public void testLeftOuterJoinFetch(){
    String jpql = "FROM Customer c LEFT OUTER JOIN FETCH c.orders WHERE c.id = ?";
    Customer customer = (Customer) entityManager.createQuery(jpql).setParameter(1, 12).getSingleResult();
    System.out.println(customer.getLastName());
    System.out.println(customer.getOrders().size());
}

Query query = entityManager.createQuery("select max(o.id) from Orders o");
Object result = query.getSingleResult();
Long max = (Long)result;

select o.seller, o.goodId, sum(o.amount) from Orders o group by 
o.seller, o.goodId having sum(o.amount) > 100

 

18、JPA内建函数    <--返回目录

　　JPQL提供了以下一些内建函数，包括字符串处理函数、算术函数和日期函数。
　　字符串处理函数主要有：

concat(String s1, String s2)：字符串合并/连接函数。
substring(String s, int start, int length)：取字串函数。
trim([leading|trailing|both,] [char c,] String s)：从字符串中去掉首/尾指定的字符或空格。
lower(String s)：将字符串转换成小写形式。
upper(String s)：将字符串转换成大写形式。
length(String s)：求字符串的长度。
locate(String s1, String s2[, int start])：从第一个字符串中查找第二个字符串(子串)出现的位置。若未找到则返回0。

　　算术函数主要有 abs、mod、sqrt、size 等。Size 用于求集合的元素个数。
　　日期函数主要为三个，即 current_date、current_time、current_timestamp，它们不需要参数，返回服务器上的当前日期、时间和时戳。

19、Spring 整合 JPA    <--返回目录

　　三种整合方式：
　　1) LocalEntityManagerFactoryBean：适用于那些仅使用 JPA 进行数据访问的项目，该 FactoryBean 将根据JPA PersistenceProvider 自动检测配置文件进行工作，一般从“META-INF/persistence.xml”读取配置信息，这种方式最简单，但不能设置 Spring 中定义的DataSource，且不支持 Spring 管理的全局事务。
　　2) 从JNDI中获取：用于从 Java EE 服务器获取指定的EntityManagerFactory，这种方式在进行 Spring 事务管理时一般要使用 JTA 事务管理。
　　3) LocalContainerEntityManagerFactoryBean：适用于所有环境的 FactoryBean，能全面控制 EntityManagerFactory 配置,如指定 Spring 定义的 DataSource 等等。
　　下面使用方式3进行整合。

　　项目结构（链接：https://pan.baidu.com/s/1Xf4N7LiLn9H1WhbLskDPrQ 提取码：08eg ）

　　依赖

 

 　　applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

    <!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.oy.jpa"></context:component-scan>

    <!-- 配置 C3P0 数据源 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>    
        
        <!-- 配置其他属性 -->
    </bean>
    
    <!-- 配置 EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置 JPA 提供商的适配器. 可以通过内部 bean 的方式来配置 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>    
        <!-- 配置实体类所在的包 -->
        <property name="packagesToScan" value="com.oy.jpa.spring.entities"></property>
        <!-- 配置 JPA 的基本属性. 例如 JPA 实现产品的属性 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
    
    <!-- 配置 JPA 使用的事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>    
    </bean>
    
    <!-- 配置支持基于注解是事务配置 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

　　数据库连接信息 db.properties

jdbc.user=root
jdbc.password=
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///jpa

　　实体类 Person

package com.oy.jpa.spring.entities;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="JPA_PERSONS")
@Entity
public class Person {

    private Integer id;
    private String lastName;

    private String email;
    private int age;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(name="LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

　　PersonDao

package com.oy.jpa.dao;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;

import com.oy.jpa.spring.entities.Person;

@Repository
public class PersonDao {

    //如何获取到和当前事务关联的 EntityManager 对象呢 ?
    //通过 @PersistenceContext 注解来标记成员变量!
    @PersistenceContext
    private EntityManager entityManager;
    
    public void save(Person person){
        entityManager.persist(person);
    }
    
}

　　PersonService

package com.oy.jpa.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.oy.jpa.dao.PersonDao;
import com.oy.jpa.spring.entities.Person;

@Service
public class PersonService {
    
    @Autowired
    private PersonDao personDao;
    
    @Transactional
    public void savePersons(Person p1, Person p2){
        personDao.save(p1);
        
        int i = 10 / 0;
        
        personDao.save(p2);
    }
    
}

　　JPATest

package com.oy.jpa.spring;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.oy.jpa.service.PersonService;
import com.oy.jpa.spring.entities.Person;

public class JPATest {
    
    private ApplicationContext ctx = null;
    private PersonService personService = null;
    
    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        personService = ctx.getBean(PersonService.class);
    }
    
    /**
     * 测试：1）是否发送了两条insert语句；2）事务是否配置成功；
     */
    @Test
    public void testPersonService(){
        Person p1 = new Person();
        p1.setAge(11);
        p1.setEmail("aa@163.com");
        p1.setLastName("AA");
        
        Person p2 = new Person();
        p2.setAge(12);
        p2.setEmail("bb@163.com");
        p2.setLastName("BB");
        
        System.out.println(personService.getClass().getName());
        personService.savePersons(p1, p2);
    }
    
    /**
     * 测试数据配置是否成功
     * 
     * @throws SQLException
     */
    @Test
    public void testDataSource() throws SQLException {
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());
    }

}

---