开始操作实体类

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

@Entity

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

@Table

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

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

标注用于声明一个实体类的属性映射为数据库的主键列，可以使用在属性上，也可以使用在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放弃维护关系，所以删除一的一方会出错（存在外键约束），解决办法我知道的有：
不要设置mappedBy属性，但是不注意保存先后顺序级就会出现多余的update
mappedBy和cascade= {CascadeType.REMOVE}属性配合使用,但是就只能级联删除了
手工将多方的外键改为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了。
类似于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>