JPA

注解

类级别注解

• @Entity

@Entity(name="EntityName")

必须 ,name 为可选 , 对应数据库中一的个表

• @Table

@Table(name="",catalog="",schema="")

可选 , 通常和 @Entity 配合使用 , 只能标注在实体的 class 定义处 , 表示实体对应的数据库表的信息

name: 可选 , 表示表的名称 . 默认地 , 表名和实体名称一致 , 只有在不一致的情况下才需要指定表名

catalog: 可选 , 表示 Catalog 名称 , 默认为 Catalog("").

schema: 可选 , 表示 Schema 名称 , 默认为 Schema("").

• @Embeddable

可选

表示一个非@Entity类可以嵌入另一个@Entity类中作为属性而存在。

属性级别注解

• @id

必须

@id 定义了映射到数据库表的主键的属性 , 一个实体只能有一个属性被映射为主键 . 置于 getXxxx() 前 .

• @GeneratedValue

@GeneratedValue(strategy=GenerationType,generator="")

可选

strategy: 表示主键生成策略 , 有 AUTO,INDENTITY,SEQUENCE 和 TABLE 4 种 , 分别表示让 ORM 框架自动选择,

根据数据库的 Identity 字段生成 , 根据数据库表的 Sequence 字段生成 , 以有根据一个额外的表生成主键 , 默认为AUTO

generator: 表示主键生成器的名称 , 这个属性通常和 ORM 框架相关 , 例如 ,Hibernate 可以指定 uuid 等主键生成方式 .

示例 :

@Id@GeneratedValues(strategy=StrategyType.SEQUENCE)public int getPk() {    return pk;}

• @Basic

@Basic(fetch=FetchType,optional=true)

可选

@Basic 表示一个简单的属性到数据库表的字段的映射 , 对于没有任何标注的 getXxxx() 方法 , 默认即为 @Basic

fetch: 表示该属性的读取策略 , 有 EAGER 和 LAZY 两种 , 分别表示主支抓取和延迟加载 , 默认为 EAGER.

optional: 表示该属性是否允许为 null, 默认为 true

示例 :

@Basic(optional=false)public String getAddress() {    return address;}

• @Column

可选

@Column 描述了数据库表中该字段的详细定义 , 这对于根据 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 字段类型 , 该属性非常有用 .

示例 :

@Column(name="BIRTH",nullable="false",columnDefinition="DATE")public String getBithday() {    return birthday;}

• @Embedded

可选

注释实体类的属性，表示该属性的类是嵌入类。

注意：嵌入类必须有@Embeddable注解

• @EmbeddedId

可选

使用嵌入式主键类实现复合主键。

注意：嵌入式主键类必须实现Serializable接口、必须有默认的public无参构造方法、必须覆盖equals()和hashCode()。

• @Transient

可选

@Transient 表示该属性并非一个到数据库表的字段的映射 ,ORM 框架将忽略该属性 .

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

示例 :

// 根据 birth 计算出 age 属性@Transientpublic int getAge() {    return getYear(new Date()) - getYear(birth);}

关联映射注解

• @ManyToOne

@ManyToOne(fetch=FetchType,cascade=CascadeType )

可选

@ManyToOne 表示一个多对一的映射 , 该注解标注的属性通常是数据库表的外键

optional: 是否允许该字段为 null, 该属性应该根据数据库表的外键约束来确定 , 默认为 true

fetch: 表示抓取策略 , 默认为 FetchType.EAGER

cascade: 表示默认的级联操作策略 , 可以指定为 ALL,PERSIST,MERGE,REFRESH 和 REMOVE 中的若干组合 , 默认为无级联操作

targetEntity: 表示该属性关联的实体类型 . 该属性通常不必指定 ,ORM 框架根据属性类型自动判断targetEntity.

示例 :

// 订单 Order 和用户 User 是一个 ManyToOne 的关系// 在 Order 类中定义@ManyToOne()@JoinColumn(name="USER")public User getUser() {    return user;}

• @JoinColumn

可选

@JoinColumn 和 @Column 类似 , 介量描述的不是一个简单字段 , 而一一个关联字段 , 例如 . 描述一个@ManyToOne 的字段 .

name: 该字段的名称 . 由于 @JoinColumn 描述的是一个关联字段 , 如 ManyToOne, 则默认的名称由其关联的实体决定 .

例如 , 实体 Order 有一个 user 属性来关联实体 User, 则 Order 的 user 属性为一个外键 ,

其默认的名称为实体 User 的名称 + 下划线 + 实体 User 的主键名称

示例 :

见 @ManyToOne

• @OneToMany

@OneToMany(fetch=FetchType,cascade=CascadeType)

可选

@OneToMany 描述一个一对多的关联 , 该属性应该为集体类型 , 在数据库中并没有实际字段 .

fetch: 表示抓取策略 , 默认为 FetchType.LAZY, 因为关联的多个对象通常不必从数据库预先读取到内存

cascade: 表示级联操作策略 , 对于 OneToMany 类型的关联非常重要 , 通常该实体更新或删除时 , 其关联的实体也应当被更新或删除

例如 : 实体 User 和 Order 是 OneToMany 的关系 , 则实体 User 被删除时 , 其关联的实体 Order 也应该被全部删除

示例 :

@OneTyMany(cascade=ALL)public List getOrders() {    return orders;}

• @OneToOne

@OneToOne(fetch=FetchType,cascade=CascadeType)

可选

@OneToOne 描述一个一对一的关联

fetch: 表示抓取策略 , 默认为 FetchType.LAZY

cascade: 表示级联操作策略

示例 :

@OneToOne(fetch=FetchType.LAZY)public Blog getBlog() {    return blog;}

• @ManyToMany

可选

@ManyToMany 描述一个多对多的关联 . 多对多关联上是两个一对多关联 , 但是在 ManyToMany 描述中 , 中间表是由ORM 框架自动处理

targetEntity: 表示多对多关联的另一个实体类的全名 , 例如 :package.Book.class

mappedBy: 表示多对多关联的另一个实体类的对应集合属性名称

示例 :

User 实体表示用户 ,Book 实体表示书籍 , 为了描述用户收藏的书籍 , 可以在 User 和 Book 之间建立ManyToMany 关联

@Entitypublic class User {    private List books;    @ManyToMany(targetEntity=package.Book.class)    public List getBooks() {        return books;    }    public void setBooks(List books) {        this.books=books;    }}@Entitypublic 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 属性

事务

• @TransactionAttribute

事务管理服务

最有用的容器服务可能就是事务管理服务，当应用出现失败或异常时，它保证了数据库的完整性。你可以简单地将为一个 POJO方法申明它的事务属性。这样容器就可以在合适的上下文中运行这个方法。最常见的事务是定义在 session bean 的方法上，方法中所有的数据库操作只有在方法正常退出时才会提交，如果方法抛出未捕获的异常，事务管理将回滚所有的变更。

@TransactionAttribute 注释用作定义一个需要事务的方法。例如：

@TransactionAttribute(TransactionAttributeType.REQUIRED)public void insertProduct(String name, Float price, boolean error) {    …    …}

它可以有以下参数：

a. REQUIRED : 方法在一个事务中执行，如果调用的方法已经在一个事务中，则使用该事务，否则将创建一个新的事务。

b. MANDATORY : 方法必须在一个事务中执行，也就是说调用的方法必须已经有一个事务，否则新抛出一个错误（ERROR ）。

c. REQUIRESNEW : 方法将在一个新的事务中执行，如果调用的方法已经在一个事务中，则暂停旧的事务。

d. SUPPORTS : 如果方法在一个事务中被调用，则使用该事务，否则不使用事务。

e. NOT_SUPPORTED ：如果方法在一个事务中被调用，将抛出一个错误（ ERROR ）

如果没有指定参数， @TransactionAttribute 注释使用 REQUIRED 作为默认参数。

• @PersistenceContextType

PersistenceContextType.EXTENDED。在默认情况下，EntityManagers用TRANSACTION的 PersistenceContextType来创建。这样做也就表示，只有当有活动的事务处理在进行时，实体才是可托管的。事务处理一结束，实体就与实 体管理程序脱离，这样我们就可以丢弃它。EXTENDED上下文类型表示这种脱离不会发生，即使在事务处理结束后实体仍然是可托管的。这就意味着你不需要 担心集合是否被暂缓取回，因为实体管理程序可以用来完成所需要的取回操作。当我们想要保持和更新／合并实体，或者从数据库里删除实体的时候，我们仍然需要 获得EntityTransaction，例如我们想要保存一个新的Application实体：

public void saveApplication(Application a) {     EntityTransaction tx = em.getTransaction();     tx.begin();     em.persist(a);     tx.commit(); }

---

JPA（Java Persistence API）是Java EE 5.0 平台标准的ORM规范，是对各种ORM框架的规范。

优势：

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

JPA技术

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

JPA写入数据库

创建persistence.xml，在这个文件中配置持久化单元
—需要指定跟哪个数据库进行交互；
—需要指定JPA使用哪个持久化的框架及配置该框架的基本属性。

创建实体类，使用annotation来描述实体类跟数据库表之间的映射关系

使用JPA API完成数据CRUD操作
—创建EntityManagerFactory（对应hibernate的SessionFactory）
—创建EntityManager（对应hibernate的Session）

1-所需jar包

2-创建persistence.xml文件

注意：

此文件位置必须在META-INF目录下，文件名不能变！

<?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" transaction-type="RESOURCE_LOCAL">        <!-- 配置使用什么ORM产品来作为JPA的实现             1、实际上配置的是javax.persistence.spi.PersistenceProvider接口的实现类            2、若JPA项目中只有一个JPA的实现产品，则可以不配置该节点-->        <provider>org.hibernate.ejb.HibernatePersistence</provider>        <!-- 添加 持久化类-->        <class>com.lee.jpa.entity.Customer</class>        <properties>            <!-- 连接数据库的基本信息 -->            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1/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>

3-创建持久化类

package com.lee.jpa.entity;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_CUSTOMERS")    //对应数据库表，若不写，表名则与类名相同@Entity //声明是持久化类的实体public class Customer {    private Integer id;    private String lastName;    private String email;    private int age;    /* 表字段名和实体属性一样可以不写：getId 中的id，此处可省略。     * 表字段的各种约束在此设置     */    @Column(name="ID")    @GeneratedValue(strategy=GenerationType.AUTO)   //标注主键生成策略，默认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;    }    @Column(name="EMAIL")   //此处可省略，若省略，自动添加@Basic    public String getEmail() {        return email;    }    public void setEmail(String email) {        this.email = email;    }    @Column(name="AGE") //此处可省略    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

4-测试

package com.lee.jpa.entity;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class CustomerTest {    public static void main(String[] args) {        //1、创建EntityManagerFactory        String persistenceUnitName = "jpa"; //注意：persistence-unit name="jpa"        EntityManagerFactory emf =                 Persistence.createEntityManagerFactory(persistenceUnitName);        //2、创建EntityManager        EntityManager em = emf.createEntityManager();        //3、开启事务        EntityTransaction tx = em.getTransaction();        tx.begin();        //4、进行持久化操作        Customer customer = new Customer();        customer.setAge(33);        customer.setEmail("[e-mail]");        customer.setLastName("tom");        em.persist(customer);        //5、提交事务        tx.commit();        //6、关闭EntityManager        em.close();        //7、关闭EntityManagerFactory        emf.close();    }}

执行Test之后

数据库变化

表变化