JPA学习笔记

JPA( Java Persistence API )是 Sun 官方提出的 Java 持久化规范。 它为 Java 开发人员提供了一种对象/关联映射工具来管理 Java 应用中的关系数据。 他的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术，结束现在 Hibernate，TopLink，JDO 等 ORM 框架各自为营的局面。

注意：JPA 是规范，不是 ORM 框架；是 ORM 框架的规范，JPA 没有实现 ORM，具体实现由 ORM 厂商提供
JPA 其实和 Hibernate 使用并没有多少差别，采用的 JPQL 语句和 HQL 差不多呢，毕竟 Hibernate 的作者是主导的

组件构成与优势

标准化: 提供相同的 API，这保证了基于 JPA 开发的企业应用能够经过少量的修改就能够在不同的 JPA 框架下运行。

简单易用，集成方便: JPA 的主要目标之一就是提供更加简单的编程模型，在 JPA 框架下创建实体和创建 Java 类一样简单，只需要使用 javax.persistence.Entity 进行注释；JPA 的框架和接口也都非常简单

可媲美 JDBC 的查询能力: JPA 的查询语言是面向对象的，JPA 定义了独特的 JPQL，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

支持面向对象的高级特性: JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，最大限度的使用面向对象的模型
摘自：http://www.jianshu.com/p/afd588c8951c

JPA 由三个不同的组件构成：

• 实体（Entities）: 在当前版本的 JPA 中实体是普通 Java 对象（POJO）。老版本的 JPA 中实体类需要继承 JPA 提供的实体基类，但是这样的设计导致框架中存在了严重的依赖关系，测试变得更加困难；所以在新版 JPA 中不再要求实体类继承任何框架类。
• 对象-关系型元数据（Object-relational metadata）: 应用程序的开发者们必须正确设定 Java 类和它们的属性与数据库中的表和列的映射关系。有两种设定方式：通过特定的配置文件建立映射(XML)；或者使用在新版本中支持的注解。
• Java持久化查询语句（Java Persistence Query Language - JPQL): 因为 JPA 旨在建立不依赖于特定的数据库的抽象层，所以它也提供了一种专有查询语言来代替 SQL。 这种由 JPQL 到 SQL 语言的转换，为 JPA 提供了支持不同数据库方言的特性，使得开发者们在实现查询逻辑时不需要考虑特定的数据库类型。

PS：Hibernate 针对 JPA 实现的相关包在 required、jpa 下

初探JPA

这里还是以 hibernate 为栗子，要使用 JPA，首先要知道它必须的配置文件，按照规范是放在类路径的 META-INF 目录下 ，文件名也是固定的 persistence.xml 在这个文件中配置持久化单元需要指定跟哪个数据库进行交互；需要指定 JPA 使用哪个持久化的框架以及配置该框架的基本属性

下面的步骤可以总结为：创建实体类, 使用 annotation 来描述实体类跟数据库表之间的映射关系；使用 JPA API 完成数据增加、删除、修改和查询操作

创建 EntityManagerFactory (对应 Hibernate 中的 SessionFactory);
创建 EntityManager (对应 Hibernate 中的Session);

下面就展示一份 persistence 的配置文件，差不多是这样配的，transaction-type 事务类型一般都是本地事务吧，全局事务感觉用的很少

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">

    <persistence-unit name="jpaDemo" transaction-type="RESOURCE_LOCAL">
    	<!-- 配置 Hibernate JPA作为JPA的实现ORM框架 -->
        <!-- 若项目只有一个JPA实现产品，那么这个配置可以不写 -->
    	<provider>org.hibernate.ejb.HibernatePersistence</provider>

        <!-- 添加持久化类 -->
        <class>com.jpaDemo.entity.Customer</class>
        <class>com.jpaDemo.entity.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="root"/>
            <!-- 配置 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>

可以看出大部分的配置是在 persistence-unit 中，直译就是持久化单元，简单说就是一堆实体 bean 的集合
上面的配置中还开启了二级缓存，那么就需要配相关的信息，下面作为简单演示就不搞了，我只是配了 properties 标签的前两部分而已
那么下面就写几个实体吧，需要注意的是如果使用注解不要导错包，以 javax 开头的是 sun 公司定义的标准

@Entity
public class Person {
    private Integer id;
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

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

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

非常简单的一个 bean，下面就弄段测试代码来跑一下，记得导入相关的包比如 JPA 和 Hibernate 的

@Test
public void save() throws Exception {
    // 这句话执行后就会创建相应的表，前提是配置了相关配置;相当于 SessionFactory
    EntityManagerFactory factory = Persistence.createEntityManagerFactory("jpaDemo");
    EntityManager em = factory.createEntityManager();
    // 开启事务
    em.getTransaction().begin();
    // 和 save 是一样的，只不过这个名字更规范
    em.persist(new Person("佳芷"));
    em.getTransaction().commit();
    em.close();
    factory.close();
}

JPA注解

首先，看准包是 javax 开头的，其次，和 hibernate 的注解其实是差不多了

• @Table
  使用格式：@Table(name="",catalog="",schema="")
  只能标注在实体的 class 定义处 ，表示实体对应的数据库表的信息，当然这三个值都是可选的
• @Id
  必须，定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.
  标注在属性或者 getter 方法前
• @GeneratedValue
  使用格式：@GeneratedValue(strategy=GenerationType, generator="")
strategy：表示主键生成策略，有 AUTO、INDENTITY、SEQUENCE 和 TABLE 4 种，分别表示让 ORM 框架自动选择、根据数据库的 Identity 字段生成（差不多就是自增长）、根据数据库表的 Sequence 字段生成、以有根据一个额外的表生成主键，默认为AUTO
  generator：表示主键生成器的名称,这个属性通常和 ORM 框架相关，例如 Hibernate 可以指定 uuid 等主键生成方式.
• @Column
  同上，一般标注在 getter 方法前，当实体的属性与其映射的数据库表的列不同名时需要使用，一般可以省略不写
  描述了数据库表中该字段的详细定义，这对于根据 JPA 注解生成数据库表结构的工具非常有作用.
  name：表示数据库表中该字段的名称,默认情形属性名称一致
  nullable：表示该字段是否允许为 null，默认为 true
  unique：表示该字段是否是唯一标识，默认为 false
  length：表示该字段的大小，仅对 String 类型的字段有效
  insertable：表示在 ORM 框架执行插入操作时，该字段是否应出现 INSETRT 语句中，默认为 true
  updateable：表示在 ORM 框架执行更新操作时，该字段是否应该出现在 UPDATE 语句中，默认为 true；对于一经创建就不可以更改的字段，该属性非常有用，如对于 birthday 字段.
  columnDefinition：表示该字段在数据库中的实际类型，通常 ORM 框架可以根据属性类型自动判断数据库中字段的类型，但是对于 Date 类型仍无法确定数据库中字段类型究竟是 DATE,TIME 还是 TIMESTAMP，此外，String 的默认映射类型为 VARCHAR，如果要将 String 类型映射到特定数据库的 BLOB 或 TEXT 字段类型（或者使用 @Lob 注解），该属性非常有用
• @Lob
  用于标注字段类型为 Clob 和 Blob 类型，比如标注在 string 类型上就是长文本型
  Clob(Character Large Ojects) 类型是长字符串类型,实体的类型可为char[]、Character[]、或者 String 类型
  Blob(Binary Large Objects) 类型是字节类型,实体的类型可为 byte[]、Byte[]、或者实现了 Serializable 接口的类。
  通常使用惰性加载的方式,，@Basic(fetch=FetchType.LAZY)
• @Transient
  表示该属性并非一个到数据库表的字段的映射 ，ORM 框架将忽略该属性.
  如果一个属性并非数据库表的字段映射，就务必将其标示为 @Transient，否则，ORM 框架默认其注解为 @Basic.
• @Temporal
  在核心的 Java API 中并没有定义 Date 类型的精度(temporal precision)。而在数据库中表示 Date 类型的数据有 DATE, TIME 和 TIMESTAMP 三种精度(即单纯的日期,时间,或者两者兼备)。
  在进行属性映射时可使用 @Temporal 注解来调整精度，比如：@Temporal (TemporalType.TIMESTAMP)
• @Basic
  表示一个简单的属性到数据库表的字段的映射，对于没有任何标注的 getXxxx() 方法，默认即为 @Basic
  fetch：表示该属性的读取策略，有 EAGER 和 LAZY 两种，分别表示主支抓取和延迟加载，默认为 EAGER.
  optional：表示该属性是否允许为 null，默认为 true
• @Enumerated
  用来指定实体持久化属性的为枚举类型
  如果标记没有显性给出或者 EnumType 没有指定，那枚举类型默认为 ORDINAL 数字(索引)标识
  或者明确指定其 EnumType 为 STRING，采用的是字符串存到数据库，通常此字段配合 Column 来设置长度和非空

---

• @ManyToOne
  表示一个多对一的映射，该注解标注的属性通常是数据库表的外键
  optional：是否允许该字段为 null，该属性应该根据数据库表的外键约束来确定,默认为 true
  fetch：表示抓取策略，默认为 FetchType.EAGER
  cascade：表示默认的级联操作策略，可以指定为 ALL、PERSIST、MERGE、REFRESH 和 REMOVE 中的若干组合，默认为无级联操作
  targetEntity：表示该属性关联的实体类型，该属性通常不必指定，ORM 框架根据属性类型自动判断 targetEntity.
  此注解一般需要配合 @JoinColumn 来确定外键名（字段名）

• @JoinColumn
  @JoinColumn 和 @Column 类似，只不过它描述的不是一个简单字段，而一一个关联字段；例如.描述一个 @ManyToOne 的字段.
  name：该字段的名称，由于 @JoinColumn 描述的是一个关联字段，则默认的名称由其关联的实体决定.
  例如，实体 Order 有一个 user 属性来关联实体 User，则 Order 的 user 属性为一个外键
  其默认的名称为实体 User 的名称 + 下划线 + 实体 User 的主键名称

• @OneToMany
  描述一个一对多的关联，该属性应该为集体类型，在数据库中并没有实际字段.
  fetch：表示抓取策略，默认为 FetchType.LAZY，因为关联的多个对象通常不必从数据库预先读取到内存
  cascade：表示级联操作策略，对于 OneToMany 类型的关联非常重要，通常该实体更新或删除时，其关联的实体也应当被更新或删除
  mappedBy：拥有 mappedBy 注解的实体类为关系被维护端（One），值为维护端的属性名（当前实体在关联实体中的属性名称）；如果类之间是单向关系，不需要提供定义，在双向关系中是必须的，否则会引发数据一致性的问题
  例如：实体 User 和 Order 是 OneToMany 的关系，则实体 User 被删除时，其关联的实体 Order 也应该被全部删除

• @OneToOne
  描述一个一对一的关联
  fetch：表示抓取策略，默认为 FetchType.LAZY
  cascade：表示级联操作策略

• @ManyToMany
  描述一个多对多的关联，多对多关联上是两个一对多关联，但是在 ManyToMany 描述中中间表是由 ORM 框架自动处理
  targetEntity：表示多对多关联的另一个实体类的全名，例如：package.Book.class
  mappedBy：表示多对多关联的另一个实体类的对应集合属性名称
  示例：User 实体表示用户，Book 实体表示书籍，为了描述用户收藏的书籍，可以在 User 和 Book 之间建立 ManyToMany 关联

  @Entity
  public class User {
      private List books;
  
      @ManyToMany(targetEntity=package.Book.class)
      public List getBooks() {
          return books;
      }
  
      public void setBooks(List books) {
          this.books=books;
      }
  }
  
  @Entity
  public class Book {
      private List users;
  
      @ManyToMany(targetEntity=package.Users.class, mappedBy=”books”)
      public List getUsers() {
          return users;
      }
      public void setUsers(List users) {
          this.users=users;
      }
  }

  两个实体间相互关联的属性必须标记为 @ManyToMany ，并相互指定 targetEntity 属性
  需要注意的是，有且只有一个实体的 @ManyToMany 注解需要指定 mappedBy 属性，指向 targetEntity 的集合属性名称
  利用 ORM 工具自动生成的表除了 User 和 Book 表外，还自动生成了一个 User_Book 表，用于实现多对多关联

• @MappedSuperclass
  可以将超类的 JPA 注解传递给子类，使子类能够继承超类的 JPA 注解，所以说要写在超类的上面啊

• @Embedded
  将几个字段组合成一个类，并作为整个 Entity 的一个属性.
  例如 User 包括 id、name、city、street、zip 属性.
  我们希望 city、street、zip 属性映射为 Address 对象，这样 User 对象将具有 id、name 和 address 这三个属性.
  Address 对象必须定义为 @Embededable

  @Embeddable
  public class Address {city,street,zip}
  
  @Entity
  public class User {
      @Embedded
      public Address getAddress() {
      }
  }

Hibernate验证注解

注解	说明
@Null	被注释的元素必须为 null
@NotNull	被注释的元素必须不为 null
@AssertTrue	被注释的元素必须为 true
@AssertFalse	被注释的元素必须为 false
@Min(value)	被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)	被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value)	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max=, min=)	被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction)	被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past	被注释的元素必须是一个过去的日期
@Future	被注释的元素必须是一个将来的日期
@Pattern(regex=,flag=)	被注释的元素必须符合指定的正则表达式

Hibernate 验证器附加的约束

Validator 附加的 constraint

注解	说明
@NotBlank(message =)	验证字符串非null，且长度必须大于0
@Email	被注释的元素必须是电子邮箱地址
@Length(min=,max=)	被注释的字符串的大小必须在指定的范围内
@NotEmpty	被注释的字符串的必须非空
@Range(min=,max=,message=)	被注释的元素必须在合适的范围内

完整版参考：http://www.cnblogs.com/afeng7882999/p/4300032.html

参考

http://www.jianshu.com/p/07e8412d577a
http://blog.csdn.net/u010837612/article/details/47660205