JPA注解详解-CSDN博客

来源：https://wenku.baidu.com/view/77f68edeee06eff9aff8071c.html

1 @Entity

@javax.persistence.Entity( name = "xxx" )

通过@Entity注解将一个类声明为一个实体Bean，任何 hibernte 映射对象都要有此注释解

name指定实体Bean的名称，默认值为bean class的非限定类名（不带包的短类名）

2 @Table

@javax.persistence.Table(catalog="xxx",name="xx",schema="xx",uniqueConstraints={@UniqueConstraint(columnNames={"xx","xx"})})

通过@Table注解可以为实体bean映射指定表

name：指定表的名称，默认值为实体的类名（不带包名）
catalog：指定数据库名称
schema：指定数据库用户名
uniqueConstraints：指定唯一性字段约束（字段值唯一不重复），如为personid和name字段指定唯一性约束：uniqueConstraints={@UniqueConstraint(columnNames={"personid","name"})}

3 @Id

@javax.persistence.Id

映射到数据库表的主键属性，一个实体只能有一个属性被映射为主键

4 @GeneratedValue

@javax.persistence.GeneratedValue(generator="xxx",strategy=GenerationType.xxx)

@GeneratedValue表示主键是自动生成策略，一般该注解和@Id一起使用

generator：表示主键生成器的名称，这个属性通常和ORM框架相关
- 例如Hibernate可以指定uuid等主键生成方式，
  @GeneratedValue(generator="system-uuid")
  @GenericGenerator(name="system-uuid",strategy="uuid")
- 指定“序列”策略，
  @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="seq_tbl_user")
  @SequenceGenerator(name="seq_tbl_user",sequenceName="seq_tbl_user",allocationSize=1)
strategy：表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4种
- GenerationType.AUTO：默认策略，生成方式取决于底层数据库；
- GenerationType.IDENTITY：指定“自动增长”策略，适用于MySQL；
- GenerationType.SEQUENCE：指定“序列”策略，适用于Oracle；
- GenerationType.TABLE：使用一个特定的数据库表格来保存主键。

5 @Column

@javax.persistence.Column(length=15,nullable=false,columnDefinition="",insertable=true,scale=10,table="",updatable=true)

表示持久化属性所映射表中的字段，如果属性名与表中的字段名相同，则可以省略@Column注解。其有两种方式标记，一是放在属性前，另一种是放在getter方法前

name：数据库字段的名称，默认与属性名称相同；
nullable：是否允许值为null，默认为true；
unique：是否唯一，默认为false；
length：字段的长度，仅对String类型的字段有效；
columnDefinition：表示该字段在数据库中的实际类型，通常orm框架根据属性类型自动判断数据库中字段的类型；
insertable：默认情况下，JPA假设所有列始终包含在SQL INSERT语句中。如果该列不应包含在这些语句中，请将insertable设置为false；
updatable：默认情况下，JPA假设所有列始终包含在SQL UPDATE语句中。如果该列不应包含在这些语句中，请将updatable设置为false；
table：当实体类使用@SecondaryTable注解时会保存于多张表中，该字段指定实体类中的某个属性保存到哪张表中，不设置时，默认保存到与类名相同的默认表中。

6 @Transient

@javax.persistence.Transient

@Transient表示该属性并非一个到数据库表的字段的映射，不会被orm框架初始化，orm框架将会忽略该属性。

7 @Temporal

@javax.persistence.Temporal(TemporalType.xxx)

@Temporal做日期类型转换，如果bean的成员属性是时间类型，因为数据表对时间类型有更严格的划分，所以必须指定具体时间类型。
通过 @Temporal 定义映射到数据库的时间精度：

TemporalType.DATE：日期
TemporalType.TIME：时间
TemporalType.TIMESTAMP：两者兼具

    @Temporal(TemporalType.TIMESTAMP) //这个是日期加时分秒的类型  
    private Date date;

8 @Enumerated

@javax.persistence.Enumerated(EnumType.xxx)

枚举类型成员属性映射

EnumType.STRING：指定属性映射为字符串
EnumType.ORDINAL：指定属性映射为数据序

9 @Lob

@javax.persistence.Lob

@Lob 声明字段为 Clob 或 Blob 类型（大数据类型）。
Clob（Character Large Ojects），类型是长字符串类型，实体的类型可为char[]、Character[]、或者String类型。
Blob（Binary Large Objects），类型是字节类型，实体的类型可为byte[]、Byte[]、或者实现了Seriazable接口的类。
大数据类型通常使用惰性加载的方式,@Basic(fetch=FetchType.LAZY)

10 @Basic

@javax.persistence.Basic(fetch=FetchType.LAZY,optional=true)

fetch：抓取策略,延时加载与立即加载
- FetchType.EAGER：即时加载（默认值，即不写Basic注解的默认值）
- FetchType.LAZY：惰性加载
optional：指定在生成数据库结构时字段是否允许为 null，默认为true，允许为空

11 @SecondaryTables和@SecondaryTable

@javax.persistence.SecondaryTables({@SecondaryTable(name="xxx1"),@SecondaryTable(name="xxx2")})

将一个实体映射到多个数据库表中，例如：

@Entity
@SecondaryTables({@SecondaryTable(name="Comments"),@SecondaryTable(name="Address")})
public class Forum implements Serializable{
    //table属性的值指定被注解属性存储在哪张数据库表中，默认保存在和类名相同的Forum表中
    @Column(table="Address")
    private String street;
    @Column(table="Address")
    private String city;
    @Column(table="Comments")
    private String title;
    @Column(table="Comments")
    private String Comments;
}

12 @OneToOne

@javax.persistence.OneToOne(fetch=FetchType.xxx,cascade=CascadeType.xxx,optional=trueOrFalse,mappedBy="xxx",targetEntity=xx.class)

描述一个单向一对一的关联关系

fetch：表示抓取策略。
- FetchType.EAGER：表示关系类(本例是OrderItem类)在主类加载的时候同时加载
- FetchType.LAZY：表示关系类在被访问时才加载（默认值）。
cascade：该属性定义类和类之间的级联关系。定义的级联关系将容器视为对当前类对象及其关联类对象采取相同的操作。cascade的值只能从以下选项中选择一个或多个，不定义则对关系表不产生任何影响。
- CascadeType.PERSIST：级联新建
- CascadeType.REMOVE：级联删除
- CascadeType.REFRESH：级联刷新
- CascadeType.MERGE：级联更新
- CascadeType.ALL：表示选择全部四项
targetEntity：Class类型的属性，定义关系类的类型，默认是该成员属性对应的类类型，所有通常不需要提供定义；
optional：是否允许关系类属性为null。
mappedBy：指明关联关系维护端，属性用于双向关联实体时使用

双向一对一关联关系举例：
Person类与IDCard类一对一关联
来源：http://blog.csdn.net/liuzhenwen/article/details/4445228

/**
 * Person类与IDCard类一对一关联
 * 在Person类中添加@OneToOne注解
 * optional=true,表示person关联的IDCard类属性值可以为空
 * cascade=CascadeType.ALL，表示Person类对象的增删改更新等操作，关联的IDCard类对象同样执行此操作
 * mappedBy="person"，由person类对象作为一对一关系的维护端
 */
@OneToOne(optional=true,cascade=CascadeType.ALL,mappedBy="person")
public IDCard getIdcard() {
    return idcard;
}

/**
 *在IDCard类中添加@OneToOne注解
 *optional=false，表示关联的Person对象不能为空
 *cascade=CascadeType.REFRESH，表示IDCard类对象刷新时，关联的Person类对象也要刷新
 *@JoinColumn注解表明所保存关联关系的外键的字段，指明IDCard对应表的Person_ID列作为外键与Person对应表的personid列进行关联,unique=true指明Person_ID列的值不可重复
 */
@OneToOne(optional=false,cascade=CascadeType.REFRESH)
@JoinColumn(name="Person_ID", referencedColumnName="personid",unique=true)
public Person getPerson() {
  return person;
}

13 @OneToMany

来源：http://blog.sina.com.cn/s/blog_49fd52cf0100scql.html

@javax.persistence.OneToMany(fetch=FetchType.xxx,cascade=CascadeType.xxx,targetEntity=xx.class,mappedBy="xxx")

描述一个单向一对多的关联，该属性应该为集体类型，在数据库中并没有实际字段。

fetch：表示抓取策略，值说明参考第12点@OneToOne
- FetchType.LAZY（默认值）
- FetchType.EAGER
cascade：表示级联操作策略，对于OneToMany类型的关联非常重要，通常该实体更新或删除时，其关联的实体也应当被更新或删除。其值参考第12点@OneToOne。
targetEntity：表示默认关联的实体类型，默认为当前标注的实体类。因为一对多的实体集合时保存在集合类中，因此必须指明集合类中保存的具体类型。
- 指定集合泛型的具体类型，如public Collection<Address> getAddress(){...}
- 指定targetEntity属性类型，如：@OneToMany(targetEntity=Address.class)
mappedBy：指明关联关系维护端，属性用于双向关联实体时使用

注：OneToMany（一对多）单向：会产生中间表，此时可以用@onetoMany @Joincolumn（name=” “）避免产生中间表，并且指定了外键的名字（别看@joincolumn在一中写着，但它存在在多的那个表中）。
来源：http://www.xuebuyuan.com/1658995.html

单向一对多举例：
一个客户对应多个地址，通过客户可以获得该客户的多个地址的信息。客户和地址是一对多的关系，并且客户与地址是单向关联的关系。
映射策略：
外键关联：两个表的关系定义在一个表中；
表关联：两个表的关系单独定义一个表中通过一个中间表来关联。

/**
 * 映射策略：外键关联
 * 在Customer类中使用@OneToMany注解
 * 表结构：
 * 1. TABLE customer(id int, name varcher, PRIMARY KEY id)
 * 2. TABLE address(id int, address_name varcher, zipcode varcher, city varcher, customer_id int, PRIMARY KEY id)
 */
 @OneToMany(casade={CascadeTypeType.ALL})
 //通过customer_id外键关联，customer的主键id决定customer_id
 @JoinColumn(name="customer_id")
 public Collection<Address> getAddress() {
     return address;
 }

/**
 * 映射策略：表关联
 * 在Customer类中使用@OneToMany注解
 * 表结构：
 * 1. TABLE customer(id int, name varcher, PRIMARY KEY id)
 * 2. TABLE address(id int, address_name varcher, zipcode varcher, city varcher, PRIMARY KEY id)
 * 3. TABLE ref_customer_address(customer_id int not null, address_id int not null unique)
 */
 @OneToMany(casade={CascadeTypeType.ALL})
 @JoinTable(name="ref_customer_address"
     ,joinColumn={@JoinColumns(name="customer_id",referencedColumnName="id")}
     ,inverseJoinColumn={@JoinColumns(name="address_id",referencedColumnName="id")})
public Collection<Address> getAddress() {
    return address;
}

/**
 * 如果使用了表关联，并且该表又设置了外键，则在映射的实体关系时可以使用默认的映射关系设置
 * 表结构：
 * 1. TABLE customer(id int, name varcher, PRIMARY KEY id)
 * 2. TABLE address(id int, address_name varcher, zipcode varcher, city varcher, PRIMARY KEY id)
 * 3. TABLE ref_customer_address(customer_id int not null, address_id int not null unique)
 * 4. ALTER TABLE ref_customer_address ADD CONSTRAINT fk_ref_customer FOREIGN KEY (customer_id) REFERENCES customer (id);
 * 5.  ALTER TABLE ref_customer_address ADD CONSTRAINT fk_ref_address FOREIGN KEY (address_id) REFERENCES address(id);
 */ 
  @OneToMany
  public Collection<AddressEO> getAddress() {
      return address;
  }

14 @ManyToOne

@javax.persistence.ManyToOne(fetch=FetchType.xxx,cascade=CascadeType.xxx,targetEntity=xx.class,optional=trueOrFalse)

表示一个单向多对一的映射，该注解标注的属性通常是数据库表的外键

fetch：具体说明见第12点@OneToOne，默认值为FetchType.EAGER
cascade：具体说明见第12点@OneToOne，默认为无级联操作
targetEntity：具体说明见第12点@OneToOne
optional：是定义该关联类是否必须存在，值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null。optional属性的默认值是true。optional 属性实际上指定关联类与被关联类的join 查询关系，如optional=false 时join 查询关系为inner join, optional=true 时join 查询关系为left join。

注：ManyToOne（多对一）单向：不产生中间表，但可以用@Joincolumn（name=” “）来指定生成外键的名字，外键在多的一方表中产生！

单向多对一举例：
一个客户Customer有多个地址Address

/** 
 * 一个客户Customer有多个地址Address
 * 在Address类中
 */
@Entity
@Table(name="address")
public class AddressEO implements java.io.Serializable {

  @ManyToOne(cascade = { CascadeType.ALL })
  @JoinColumn(name="customer_id")
  private CustomerEO customer;

  // ...
}

双向关联关系，OneToMany和ManyToOne：
来源：http://blog.csdn.net/lxl_family/article/details/26523757
双向一对多关系，一是关系维护端（owner side），多是关系被维护端（inverse side）。在关系被维护端需要通过@JoinColumn建立外键列指向关系维护端的主键列。

 publicclass Order implements Serializable {
    privateSet<OrderItem> orderItems = new HashSet<OrderItem>();
         。。。。
    @OneToMany(mappedBy="order",cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @OrderBy(value = "id ASC")//指明加载OrderItem 时按id 的升序排序
    public Set<OrderItem> getOrderItems() {
        returnorderItems;
     }
}

publicclass OrderItem implements Serializable {
    private Order order;
    。。。。
    @ManyToOne(cascade=CascadeType.REFRESH,optional=false)
    //指定OrderItem映射表的order_id列作为外键与Order 映射表的主键列关联。
    @JoinColumn(name = "order_id")
    public Order getOrder() {
        returnorder;
     }
}

注：OneToMany ,ManyToOne 双向（两个注解一起用的）：如果不在@OneToMany中加mappedy属性就会产生中间表，此时通常在@ManyToOne的注解下再添上注解@Joincolumn(name=” “)来指定外键的名字(说明：多的一方为关系维护端，关系维护端负责外键记录的更新，关系被维护端没有权利更新外键记录)！（@OneToMany(mappedBy=”一对多中，多中一的属性”)出现mapby为被维护端|||默认为延迟加载)
来源：http://www.xuebuyuan.com/1658995.html

15 @ManyToMany

@javax.persistence.ManyToMany(targetEntity=xx.class,fetch=FetchType.xxx,cascade=CascadeType.xxx,mappedBy="xxx")

参数说明见第12、13、14点。

16 @JoinTable

@javax.persistence.JoinTable(name="tableName",catalog="cataLogName",schema="schemaName"
    ,joinColumns={@JoinColumn(name="fkName",referencedColumnName="columnName")}
    ,inverseJoinColumns={@JoinColumn(name="otherFKName",referencedColumnName="otherColumnName")}})