JPA的学习

JPA是Java Persistence API的简称，中文名Java持久层API。是Java EE5.0平台中Sun为了统一持久层ORM框架而制定的一套标准，注意是一套标准，而不是具体实现，不可能单独存在，需要有其实现产品。Sun挺擅长制定标准的，例如JDBC就是为了统一连接数据库而制定的标准，而我们使用的数据库驱动就是其实现产品。JPA的实现产品有HIbernate，TopLink，OpenJPA等等。值得说一下的是Hibernate的作者直接参与了JPA的制定，所以JPA中的一些东西可以与Hibernate相对比。

JPA特点：

• JPA可以使用xml和注解映射源数据，JPA推荐使用注解来开发。
• 它有JPQL语言也是面向对象的查询语言，和hql比较类似。

环境搭建

我们使用Hibernate作为JPA的实现产品，需要导入的jar包有：

其实也就是Hibernate的required包下的jar，重点在于有Hibernate-jpa-api这个jar的存在

注意：不要忘了我们的数据库驱动jar

Persistence.xml文件的编写

JPA规范要求在内路径下META-INF目录下放置persistence.xml文件，文件名称是固定的。这个文件在于spring整合之后就可以取消了。

一个简单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-1" transaction-type="RESOURCE_LOCAL">
        <!-- 
        配置使用什么 ORM 产品来作为 JPA 的实现 
        1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
        2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. 
        -->
        <!-- <provider>org.hibernate.ejb.HibernatePersistence</provider> -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
    
        <!-- 添加持久化类 (推荐配置)-->
        <class>cn.lynu.model.User</class>
        

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


        </properties>
    </persistence-unit>
</persistence>

name：用于定义持久单元名称，必须。

transaction-type：指定JPA的事务处理策略，RESOURCE_LOCAL 是默认值，数据库级别的事务，只支持一种数据库，不支持分布式事务。如果要支持分布式事务，要使用JTA策略：transaction-type：“JTA”

开始操作实体类

我们可以使用注解来映射源数据了，而不用再编写如Hibernate中的*.hbm.xml文件了，Hibernate中其实就可以使用JPA的注解来映射数据，学习了JPA之后，通过使用JPA来增加Dao层的通用性。

@Entity

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

@Table

当实体类与其映射的数据库表名不同名时需要使用 @Table 标注说明，该标注与 @Entity 标注并列使用。

常用选项是 name，用于指明数据库的表名。

@Id

标注用于声明一个实体类的属性映射为数据库的主键列，可以使用在属性上，也可以使用在getter方法上

 @GeneratedValue  

用于标注主键的生成策略，通过 strategy 属性指定。默认情况下，JPA 自动选择一个最适合底层数据库的主键生成策略：

SqlServer 对应 identity，MySQL 对应 auto increment

在 javax.persistence.GenerationType 中定义了以下几种可供选择的策略（可以看到JPA没有Hibernate的主键生成策略多，因为其只是做一个抽象）：

• IDENTITY：采用数据库 ID自增长的方式来自增主键字段，Oracle 不支持这种方式；
• AUTO： JPA自动选择合适的策略，是默认选项；
• SEQUENCE：通过序列产生主键，通过 @SequenceGenerator 注解指定序列名，MySql 不支持这种方式；
• TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

在我的Mysql使用@GeneratedValue为默认值时，会识别为序列的方式，所以我都是自己指定为IDENTITY方式。

 

Sequence策略

在Oracle中没有主键自动增长，所以都是使用序列替代这一功能的，GeneratedValue如何通过序列产生主键呢？

首先我们的Oracle数据库中需要创建一个序列

将GeneratedValue的strategy设置为GenerationType.SEQUENCE

还需要使用一个@SequenceGenerator 注解来配置一些序列的信息

    @GeneratedValue(generator="seq",strategy=GenerationType.SEQUENCE)    
    @SequenceGenerator(name="seq",allocationSize=1,sequenceName="master_seq") 

@GeneratedValue的generator的值和@SequenceGenerator的name值需要保持一致；allocationSize 表明每次增长1，其实这个属性在数据库中创建序列的时候可以指定步长，所以可以不写；sequenceName需要指明在数据库中我们创建的序列名。

TABLE策略 

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

就不是只使用@GeneratedValue注解了，而是使用@TableGenerator和@GeneratedValue配合：

name ：表示该主键生成策略的名称，它被引用在@GeneratedValue中设置的generator 值中

table ：表示表生成策略所持久化的表名

pkColumnName ：表示在持久化表中，该主键生成策略所对应键值的名称(存主键的表中表示id的字段名)

pkColumnValue ：表示在持久化表中，该生成策略所对应的主键（也就是该实体类对应的表的主键字段名）

valueColumnName ：表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加（存主键的表中表示值的字段名）

所以生成的存主键的表结构为：

pk_name就是在pkColumnName 中设置的，对应需要使用table方式生成主键的表的id

pk_value就是在valueColumnName 中设置的，其值并非是在设置主键初始值

@Column 

当实体的属性与其映射的数据库表的列不同名时需要使用@Column 标注说明，该属性通常置于实体的属性声明语句之前，还可与 @Id 标注一起使用。

@Column 标注的常用属性是 name，用于设置映射数据库表的列名。此外，该标注还包含其它多个属性，如：unique 、nullable、length 等。

@Transient

表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性. 如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则，如果我们使用了自动建表，就会将不需要的属性映射为表的字段。

@Temporal

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

默认将时间类型映射为时间戳类型，也就是有日期有时间的，如果我们只需要日期，如生日字段，就需要使用Date类型，只需要时间，就使用Time类型

JPA  API

创建EntityManagerFactory和EntityManager

JPA也是需要先创建一个EntityManagerFactory（类似于Hibernate中的SessionFactory），通过这个工厂再来生成EntityManager（类似于Hibernate的Session）。

EntityManagerFactory是通过Persistence类的静态方法 createEntityManagerFactory生成，方法的参数指定JPA的持久单元名称，也就是我们在persistence.xml文件中写的name名。

EntityManager再通过EntityManagerFactory的createEntityManager方法创建。

开启事务使用的是：entityManager.getTransaction();得到一个EntityTransaction 对象，再通过这个对象的begin方法就可以开启事务了

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;
    
    @Before
    public void init() {
        entityManagerFactory=Persistence.createEntityManagerFactory("jpa-1");
        entityManager=entityManagerFactory.createEntityManager();
        transaction=entityManager.getTransaction();
        //开启事务
        transaction.begin();
    }

我们再来写一个关闭的方法，规范一下代码：

    @After
    public void destroy() {
        //提交事务
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

注意：我们使用的JAP的类和注解都是使用的javax.persistence包下的，不要导错了

EntityManager下的方法

find (Class<T> entityClass,Object primaryKey)：返回指定的 OID 对应的实体类对象，如果这个实体存在于缓存中，则返回一个被缓存的对象；否则会创建一个新的 Entity, 并加载数据库中相关信息；若 OID 不存在于数据库中，则返回一个 null。第一个参数为被查询的实体类类型，第二个参数为待查找实体的主键值。类似于Hibernate中的get方法。

getReference (Class<T> entityClass,Object primaryKey)：与find()方法类似，不同的是：如果缓存中不存在指定的 Entity, EntityManager 会创建一个 Entity 类的代理，但是不会立即加载数据库中的信息，只有第一次真正使用此 Entity 的属性才加载，所以如果此 OID 在数据库不存在，getReference() 不会返回 null 值, 而是抛出EntityNotFoundException，类似于Hibernate中的load方法。

    //类似于hibernate 中 session 的 get方法
    //调用find方法时就发sql
    @Test
    public void testFind() {
        User user = entityManager.find(User.class, 1);
        System.out.println("-------------------------");
        System.out.println(user);
    }
    
    //类似于Hibernate 中 session 的 load方法
    //使用的时候才发sql
    @Test
    public void testGetReference() {
        User user = entityManager.getReference(User.class, 1);
        System.out.println("-------------------------");
        System.out.println(user);
    }

persist (Object entity)：用于将新创建的 Entity 纳入到 EntityManager 的管理。该方法执行后，传入 persist() 方法的 Entity 对象转换成持久化状态。

如果传入 persist() 方法的 Entity 对象已经处于持久化状态，则 persist() 方法什么都不做。

如果对游离状态的实体执行 persist() 操作，可能会在 persist() 方法抛出 EntityExistException(也有可能是在flush或事务提交后抛出)，这一点也就是说persist方法不能保存游离态的实体，不同于Hibernate的是，HIbernate可以保存游离态的对象。

    //添加方法类似于hibernate 的 session 中的 save方法
    //不同点：但是不能添加存在id属性的实例(游离态), hibernate可以
    @Test
    public void testPersist() {
        
        User user=new User();
        user.setUserName("张三110");
        user.setEmail("110@qq.com");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        
        entityManager.persist(user);
        
    }

remove (Object entity)：删除实例。如果实例是被管理的，即与数据库实体记录关联，则同时会删除关联的数据库记录。

与HIbernate不同点在于JPA是不能删除在游离态的对象，HIbernate可以通过删除游离态的对象来影响到数据库中对应的数据，但是不推荐这样做。

    //类似于Hibernate 中session 的delete方法
    //不同点:remove不可以删除游离态的对象,
    //hibernate可以删除游离态的对象,并且会影响到数据库中的数据
    //hibernate可以操作(插入或删除)游离态的对象,而JPA不可以
    @Test
    public void testRemove() {
        User user = entityManager.find(User.class, 1);
        entityManager.remove(user);
    }

merge (T entity)：merge() 用于处理 Entity 的同步。即数据库的插入和更新操作，类似于HIbernate中的SaveOrUpdate方法。

/**
     * 总的来说: 类似于 hibernate Session 的 saveOrUpdate 方法.
     */
    //1. 若传入的是一个临时对象(没有id)
    //会创建一个新的对象, 把临时对象的属性复制到新的对象中, 然后对新的对象执行持久化操作(insert). 所以
    //新的对象中有 id, 但以前的临时对象中没有 id. 
    @Test
    public void testMerge1(){
        User user=new User();
        user.setUserName("张三123");
        user.setEmail("123@qq.com");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        
        User user2 = entityManager.merge(user);  // 返回持久化对象的引用
        System.out.println(user.getId());
        System.out.println(user2.getId());
    }
    
    //若传入的是一个游离对象, 即传入的对象有 OID. 
    //1. 若在 EntityManager 缓存中没有该对象
    //2. 若在数据库中也没有对应的记录(先进行select查询)
    //3. JPA 会创建一个新的对象, 然后把当前游离对象的属性复制到新创建的对象中
    //4. 对新创建的对象执行 insert 操作. (没查到对应id的对象)
    @Test
    public void testMerge2(){
        User user=new User();
        user.setUserName("张三222");
        user.setEmail("222@qq.com");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        user.setId(100);
        
        User user2 = entityManager.merge(user);
        System.out.println(user.getId());
        System.out.println(user2.getId());
    }
    
    //若传入的是一个游离对象, 即传入的对象有 OID. 
    //1. 若在 EntityManager 缓存中没有该对象
    //2. 若在数据库中有对应的记录(先进行select查询)
    //3. JPA 会查询对应的记录, 然后返回该记录对一个的对象, 再然后会把游离对象的属性复制到查询到的对象中.
    //4. 对查询到的对象执行 update 操作. (查到对应id的对象)
    @Test
    public void testMerge3(){
        User user=new User();
        user.setUserName("张三333");
        user.setEmail("333@qq.com");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        user.setId(2);
        
        User user2 = entityManager.merge(user);
        System.out.println(user==user2);  //false  游离态对象和返回的持久化对象不一致
    }
    
    //若传入的是一个游离对象, 即传入的对象有 OID. 
    //1. 若在 EntityManager 缓存中有对应的对象(使用find或者是getReference得到)
    //2. JPA 会把游离对象的属性复制到查询到EntityManager 缓存中的对象中.
    //3. EntityManager 缓存中的对象执行 UPDATE. 
    @Test
    public void testMerge4(){
        User user=new User();
        user.setUserName("张三444");
        user.setEmail("444@qq.com");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        user.setId(2);
        
        User user2 = entityManager.find(User.class, 2);  //缓存对象
        User user3 = entityManager.merge(user);         //返回的持久化对象
        System.out.println(user==user2);  //false 游离态对象和缓存中的对象不一致
        System.out.println(user==user3);  //false 游离态对象和持久化对象不一致
        System.out.println(user2==user3); //true user2和user3是同一个对象(缓存中已经存在)
    }
    

映射关联关系

双向一对多及多对一映射

双向一对多关系中，必须存在一个关系维护端，在 JPA 规范中，要求  many 的一方作为关系的维护端(owner side),可以少发update语句。 one 的一方作为被维护端(inverse side)。 可以在 one 方指定 @OneToMany 注释并设置 mappedBy 属性（类似于HIbernate中的inverse属性），以指定它是这一关联中的被维护端，many 为维护端。 在 many 方指定 @ManyToOne 注释，并使用 @JoinColumn 指定外键名称。

Order类(多)：

    //多的一方
    @ManyToOne
    @JoinColumn(name="user_id")    //外键名
    public User getUser() {
        return user;
    }

User类(一)：

//一的一方    
@OneToMany(mappedBy="user")  //使用mappedBy 放弃维护关系(一般都让一的一方放弃,多的一方维护关系)
    public Set<Order> getOrders() {
        return orders;
    }

保存一对多(没有设置级联,建议先保存一再保存多，可以减少update语句)

    //如果保存多对一关系时,如果没有设置级联,
    //建议先保存一的一方,再保存多的一方(与保存的顺序有关),就不会出现多余的update
    
    //设置级联为CascadeType.PERSIST(级联保存)  就可以通过保存Order来级联保存User
    @Test
    public void testPersistOrder() {
        Order order1=new Order();
        order1.setOrderName("FF1");
        
        User user=new User();
        user.setUserName("李四");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        user.setEmail("666@qq.com");
        order1.setUser(user);
        
        entityManager.persist(user);
        entityManager.persist(order1);
        
    }

我们也可以通过设置级联，来保存一方的时候同时保存另一方：

    @ManyToOne(cascade= {CascadeType.PERSIST})
    @JoinColumn(name="user_id")    //外键名
    public User getUser() {
        return user;
    }

    @Test
    public void testPersistOrder2() {
        Order order1=new Order();
        order1.setOrderName("GG1");
        
        User user=new User();
        user.setUserName("李四光");
        user.setBirth(new Date());
        user.setCreateTime(new Date());
        user.setEmail("666@qq.com");
        order1.setUser(user);

        
        entityManager.persist(order1);
        
    }

删除（没有设置级联删除）

    //删除时 删除关系维护端没有问题  删除被维护端报错(存在外键约束)
    //如果想删除,就不要设置放弃维护关系(这里是不要设置mappedBy)
    /**
    @OneToMany
    @JoinColumn(name="user_id") 
     */
    @Test
    public void testRemoveOrder() {
        //Order order = entityManager.find(Order.class, 3);
        //entityManager.remove(order);
        User user = entityManager.find(User.class, 16);
        entityManager.remove(user);
    }

因为我们在一的一方设置了mappedBy放弃维护关系，所以删除一的一方会出错（存在外键约束），解决办法我知道的有：

1. 不要设置mappedBy属性，但是不注意保存先后顺序级就会出现多余的update
2. mappedBy和cascade= {CascadeType.REMOVE}属性配合使用,但是就只能级联删除了
3. 手工将多方的外键改为null

还有没什么办法可以很好的解决这个放弃维护带来的删除问题？

其实仔细一想这个异常是存在一定道理的，因为我们都知道建表或插入数据的时候是先主表，后从表；而删除的时候想删除从表，再删除主表。如果我们不先处理多的一方，而直接删除一的一方，数据库是不允许的，因为外键字段的值必须在主表中存在，这个异常也在提示我们这样的操作存在问题

一对多双向关联查询

这里有一个规律：凡是以many结尾的都默认使用懒加载，而以one结尾的默认使用立即加载。如OneToMany 默认使用的就是延迟加载，而ManyToOne，OneToOne默认使用的是立即加载

我们可以在ManyToOne（以one结尾，默认使用立即加载）设置fetch属性：fetch=FetchType.LAZY  ，将其设置为懒加载

    //查询关系维护端(主控方)会发一条左外连接(left outer join)的查询sql
    //设置了fetch 为lazy 延迟加载就不会连接查询了
    @Test
    public void testFindOrder() {
        Order order = entityManager.find(Order.class, 3);
        System.out.println(order.getUser());
    }

双向多对多关联关系

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

Item类：

    @ManyToMany
    @JoinTable(name="item_category",
               joinColumns= {@JoinColumn(name="item_id")},
               inverseJoinColumns= {@JoinColumn(name="categroy_id")})
    public Set<Category> getCategories() {
        return categories;
    }

@JoinTable   设置中间表

name="中间表名称",

joinColumns={@joinColumn(name="本类的外键")}

inversejoinColumns={@JoinColumn(name="对方类的外键") }

Category类：

    @ManyToMany(mappedBy="categories")    //根据需求让一方放弃维护
    public Set<Item> getItems() {
        return items;
    }

多对多删除

        //多对多的删除
        @Test
        public void testManyToManyRemove(){
            Item item = entityManager.find(Item.class, 1);
            entityManager.remove(item);
        }

没有设置级联的时候，删除时先根据删除方的id去中间表查询，查询到之后，先删除中间表，然后删除删除方的记录

双向一对一映射

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

Dept和Manager是一对一关系，外键存在于Dept表中，所以然Manager放弃维护

Manager类：

    @OneToOne(mappedBy="mgr")  //放弃维护
    public Dept getDept() {
        return dept;
    }

Dept类：

    @OneToOne(fetch=FetchType.LAZY)   //一对一(维护端)
    @JoinColumn(name="mgr_id",unique=true)
    public Manager getMgr() {
        return mgr;
    }

这里设置了一对一延迟加载，在使用到被维护端的时候，再去查询，而不是直接发一条left outer join 左外连接

        //1.默认情况下, 若获取维护关联关系的一方, 则会通过左外连接获取其关联的对象. 
        //但可以通过 @OntToOne 的 fetch 属性(设置延迟加载)来修改加载策略.
        //必须设置在维护端(主控方)的fetch属性才有效,设置在被维护端没用
        @Test
        public void testOneToOneFind(){
            Dept dept = entityManager.find(Dept.class, 1);
            System.out.println(dept.getDeptName());
            System.out.println(dept.getMgr().getClass().getName());
        }

使用二级缓存

在Hibernate中一级缓存是session级别的缓存，是默认带的且开起的，而二级缓存是sessionFactory级别的缓存，是跨session的。同理，JPA中一级缓存是EntityManager级的缓存，而二级缓存是EntityManagerFactory级别的缓存。

使用二级缓存需要配置其实现产品，这里使用的是ehcache。

先在persistence.xml文件中配置：

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


            <!-- 二级缓存相关配置(使用的是hibernate二级缓存,缓存产品为ehcache) -->
            <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"/>

这里有个查询缓存，等到JPQL之后再说.

<shared-cache-mode> 节点：若 JPA 实现支持二级缓存，该节点可以配置在当前的持久化单元中是否启用二级缓存，可配置如下值：

• ALL：所有的实体类都被缓存
• NONE：所有的实体类都不被缓存.  
• ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存
• DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类
• UNSPECIFIED：默认值，JPA 产品默认值将被使用。

我们设置的配置是ENABLE_SELECTIVE，所以一定要在需要二级缓存的类上使用 @Cacheable(true) 注解标识

 我们还需要在src下放入一个ehcache的配置文件：ehcache.xml

<ehcache>

      <!--  
        指定一个目录：当 EHCache 把数据写到硬盘上时, 将把数据写到这个目录下.
                 如:<diskStore path="d:\tempDirectory"/>
    -->     
    <diskStore path="java.io.tmpdir"/>


    <!--默认的缓存配置-->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

       <!--  
           设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域
           缓存区域(region)：一个具有名称的缓存块，可以给每一个缓存块设置不同的缓存策略。
           如果没有设置任何的缓存区域，则所有被缓存的对象，都将使用默认的缓存策略。即：<defaultCache.../>
           Hibernate 在不同的缓存区域保存不同的类/集合。
            对于类而言，区域的名称是类名。如:cn.lynu.entity.Dept
            对于集合而言，区域的名称是类名加属性名。如cn.lynu.entity.Dept.emps
       -->
       <!--  
           name: 设置缓存的名字,它的取值为类的全限定名或类的集合的名字 
           
        maxElementsInMemory: 设置基于内存的缓存中可存放的对象最大数目 
        
        eternal: 设置对象是否为永久的, true表示永不过期,
        此时将忽略timeToIdleSeconds 和 timeToLiveSeconds属性; 默认值是false 
        
        timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。
        当对象过期时,EHCache会把它从缓存中清除。如果此值为0,表示对象可以无限期地处于空闲状态。 
        
        timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。
        如果此值为0,表示对象可以无限期地存在于缓存中. 该属性值必须大于或等于 timeToIdleSeconds 属性值 
        
        overflowToDisk:设置基于内存的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中 
       -->
    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> 
</ehcache>

开始测试吧：

        //开启二级缓存
        @Test
        public void testSecondLevelCache(){
            User user1 = entityManager.find(User.class, 2);
            
            //提交并关闭事务
            transaction.commit();
            entityManager.close();
            //开启新事务
            entityManager=entityManagerFactory.createEntityManager();
            transaction=entityManager.getTransaction();
            transaction.begin();
            
            User user2 = entityManager.find(User.class, 2);
        }

这里查询之后提交并关闭事务和EntityManager，用一个新的EntityManager和新的事务进行操作，在没有开二级缓存的时候，会发两条相同的select语句，成功开启二级缓存之后，就只有第一次的一条select了。

JPQL

类似于HQL，JPQL也是面向对象的查询语句，也可以完成CRUD操作，但是写法上有点不同，不同点在于查询上，来看一条JPQL语句：

SELECT u from User u

再来看HQL的写法：

from User

可以看到JPQL的查询需要将select关键字和需要得到的字段写出来（好在需要得到的字段可以是一个对象），运行这些语句的都是Query接口，只是要注意是不同的包下的。

Query接口的主要方法：

• int executeUpdate() 用于执行update或delete语句。
• List getResultList() 用于执行select语句并返回结果集实体列表。
• Object getSingleResult() 用于执行只返回单个结果实体的select语句。
• Query setFirstResult(int startPosition) 用于设置从哪个实体记录开始返回查询结果。
• Query setMaxResults(int maxResult)  用于设置返回结果实体的最大数。与setFirstResult结合使用可实现分页查询。
• setHint(String hintName, Object value)  设置与查询对象相关的特定供应商参数或提示信息。参数名及其取值需要参考特定 JPA 实现库提供商的文档。如果第二个参数无效将抛出IllegalArgumentException异常。
• setParameter(int position, Object value)  为查询语句的指定位置参数赋值。Position 指定参数序号，value 为赋给参数的值。
• setParameter(String name, Object value)  为查询语句的指定名称参数赋值。

        @Test
        public void testHelloJPQL(){
            String jpql="SELECT u from User u";
            Query query = entityManager.createQuery(jpql);
            List list = query.getResultList();  //对应Hibernate中Query接口的list()方法
            System.out.println(list.size());
        }

我还记得Hibernate的占位符是从0开始的，而JDBC是从1开始的，总是记这些东西很麻烦，所以在JPA中可以指定占位符从几开始：

        @Test
        public void testHelloJPQL2(){
            String jpql="select u from User u where id>?1";   
            Query query = entityManager.createQuery(jpql);
            //占位符的索引是从 0 开始,可以指定从几开始,如?1 就是从1开始
            query.setParameter(1, 3);
            List list = query.getResultList();
            System.out.println(list.get(3));
        }

还可以使用名称占位：

        @Test
        public void testHelloJPQL3(){
            String jpql="select u from User u where id>:id";
            Query query = entityManager.createQuery(jpql);
            //使用名称占位
            query.setParameter("id", 3);
            List list = query.getResultList();
            System.out.println(list.get(3));
        }

在JPQL中还可以使用Order by

Order by子句用于对查询结果集进行排序。和SQL的用法类似，可以用 “asc“ 和 "desc“ 指定升降序。如果不显式注明，默认为升序。

select o from Orders o order by o.id 
select o from Orders o order by o.address.streetNumber desc 
select o from Orders o order by o.customer asc, o.id desc

group by子句与聚合查询

        //分组查询(查询 order 数量等于 2 的那些 User)
        @Test
        public void testGroupBy(){
            String jpql="select o.user from Order o group by o.user having count(o.id)=?1";
            List list = entityManager.createQuery(jpql).setParameter(1, 2).getResultList();
            System.out.println(list);
        }

常用的聚合函数主要有 AVG、SUM、COUNT、MAX、MIN 等，它们的含义与SQL相同。

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

关联查询

JPQL 也支持和 SQL 中类似的关联语法。如： left out join fetch，  right out join fetch  。eft out join，如left out join fetch是以符合条件的表达式的左侧为主。

        /**
         * JPQL 的关联查询(left outer join fetch)同 HQL 的关联查询. 
         */
        @Test
        public void testLeftOuterJoinFetch(){
            String jpql="select u from User u left outer join fetch u.orders where u.id=?1";
            List<User> list = entityManager.createQuery(jpql).setParameter(1, 16).getResultList();
            System.out.println(list.get(0).getOrders());
        }

左外的右边使用的是User类中的orders属性表示另一张表，而且要加上fetch语句，才是一个真正左外连接，要不会报sql异常

子查询

JPQL也支持子查询，在 where 或 having 子句中可以包含另一个查询。当子查询返回多于 1 个结果集时，它常出现在 any、all、exists表达式中用于集合匹配查询。它们的用法与SQL语句基本相同。

        /**
         * JPQL子查询
         */
        @Test
        public void testSubQuery(){
            //查询所有 User 的 userName 为 赵六 的 Order
            String jpql="select o from Order o where o.user=(select u from User u where u.userName=?1)";
            List list = entityManager.createQuery(jpql).setParameter(1, "赵六").getResultList();
            System.out.println(list);
        }

JPQL函数

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。

        //使用 jpql 内建的函数
        @Test
        public void testJpqlFunction(){
            String jpql="select upper(o.orderName) from Order o";
            List list = entityManager.createQuery(jpql).getResultList();
            System.out.println(list);
        }

算术函数主要有 abs、mod、sqrt、size 等。Size 用于求集合的元素个数。

日期函数主要为三个，即 current_date、current_time、current_timestamp，它们不需要参数，返回服务器上的当前日期、时间和时戳。

查询缓存

刚才说了一个查询缓存的问题，是因为使用Query接口查询的结果并不会放入一级缓存中，因为其未与EntityManager关联，HIbernate中也如此，所以需要配置那个查询缓存，注意：查询缓存需要依赖于二级缓存。

需要在需要查询缓存的时候使用：   query.setHint(QueryHints.HINT_CACHEABLE, true);

        //使用 hibernate 的查询缓存.(query接口查询(hql)的结果不会放到缓存中,需要配置查询缓存) 
        @Test
        public void testQueryCache(){
            String jpql="SELECT u from User u";
            Query query = entityManager.createQuery(jpql);
            //查询缓存(org.hibernate.jpa.QueryHints;)
            query.setHint(QueryHints.HINT_CACHEABLE, true);
            List list = query.getResultList();
            System.out.println(list.size());
            
            //没有配置的时候多次相同的sql查询会发多条相同的sql
            //配置查询缓存之后,相同查询就发一条sql
            //(配置文件中要配置hibernate.cache.use_query_cache)
            
            //query = entityManager.createQuery(jpql);
            //查询缓存(只要给query使用jpql就需要setHint)
            //query.setHint(QueryHints.HINT_CACHEABLE, true);
            list = query.getResultList();
            System.out.println(list.size());
            
        }

整合Spring

Spring整合JPA之后，就不需要persistence.xml文件了，需要在applicationContext.xml文件中配置EntityManagerFactory和JPA的事务：

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">    

    <!-- 配置 C3P0 数据源 -->
    <context:property-placeholder location="classpath:jdbc.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="cn.lynu.model"></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"/>
    
    <!-- 配置自动扫描的包(组件扫描) -->
    <context:component-scan base-package="cn.lynu"></context:component-scan>

</beans>