OpenJPA (2)
3 Metadata
通过javax.persistence 包中定义的Annotation或者XML mapping files来指定Persistence metadata。当混合使用Annotation 和XML mapping file 的时候，如果发生冲突，那么以XML mapping file为准。
3．1 Class Metadata
3．1．1 Entity
Entity annotation用来指定entity class。它有一个属性name用来在Query中引用entity。如果不指定name，那么缺省是entity class的名字（unqualified）。
以下是个使用Entity annotation的例子：
@Entity
public class Company {
@Id
private int id;
@Basic
private String name;
}
@Entity
public class Address {
@Basic
private String province;
@Basic
private String city;
@Basic
private String street;
@Basic
private String zip;
}
如果使用MySQL数据库，那么用MappingTool生成的SQL如下：
CREATE TABLE Company (id INTEGER NOT NULL, name VARCHAR(255), PRIMARY KEY (id)) TYPE = innodb; CREATE TABLE Address (id BIGINT NOT NULL, city VARCHAR(255), province VARCHAR(255), street VARCHAR(255), zip VARCHAR(255), PRIMARY KEY (id)) TYPE = innodb; CREATE TABLE OPENJPA_SEQUENCE_TABLE (ID TINYINT NOT NULL, SEQUENCE_VALUE BIGINT, PRIMARY KEY (ID)) TYPE = innodb;
JPA要求每个persistent class都必须至少声明一个identity字段，但是OpenJPA允许不声明identity字段。如果persistent class没有声明identity字段，那么OpenJPA会缺省增加id列作为数据库表的主键，同时采用Table Generator的方式为id赋值，Table Generator缺省使用OPENJPA_SEQUENCE_TABLE。
3．1．2 IdClass
当某个entity class中包含多个identity 字段的时候，必须使用identity class（例如之前提到的MagazineId类）。IdClass annotation用来指定identity class，它的value属性是java.lang.Class 型。
3．1．3 MappedSuperclass
Mapped superclass不是entity class，但是它可以为entity class定义persistent state和mapping information。Mapped superclass通常是抽象类。Mapped superclass不能用于Query，或者被运用到任何EntityManager或者Query中。Mapped superclass通过 MappedSuperclass annotation指定。
以下是个使用MappedSuperclass annotation的例子：
@MappedSuperclass
public abstract class Document {
@Id
protected int id;
@Version
protected int version;
}
@Entity
public class Contract extends Document {
@Basic
private String name;
}
如果使用MySQL数据库，那么用MappingTool生成的SQL如下：
CREATE TABLE Contract (id INTEGER NOT NULL, name VARCHAR(255), version INTEGER, PRIMARY KEY (id)) TYPE = innodb;
3．1．4 Embeddable
Embeddable annotation指定embeddable persistent class。Embeddable instances被映射到datastore record的一部分。JPA要求Persistent class只能是entity class或embeddable class之一。OpenJPA允许Persistent class既是entity class，也是embeddable class。只要同时使用@Entity和@ Embeddable即可。
以下是个使用Embeddable annotation的例子：
@Entity
public class Company {
@Id
private int id;
@Basic
private String name;
@Embedded
private Address address;
}
@Embeddable
public class Address {
@Basic
private String province;
@Basic
private String city;
@Basic
private String street;
@Basic
private String zip;
}
如果使用MySQL数据库，那么用MappingTool生成的SQL如下：
CREATE TABLE Company (id INTEGER NOT NULL, name VARCHAR(255), city VARCHAR(255), province VARCHAR(255), street VARCHAR(255), zip VARCHAR(255), PRIMARY KEY (id)) TYPE = innodb;
从以上SQL可以看出，OpenJPA并没有为Address embeddable class生成一个表，而是在Company表中包含了Address信息。
3．1．5 EntityListeners
EntityListeners annotation用来指定entity listeners，它的value属性是java.lang.Class数组型。
3．1．6 Table
Table annotation 用来指定entity class对应的数据库表名。它有以下几个属性：
- String name: 表名，缺省使用unqualified class name。
- String schema: schema名。缺省使用数据库连接的缺省schema。
- String catalog: catalog名. 缺省使用数据库连接的缺省catalog。
- UniqueConstraint[] uniqueConstraints: Unique constraints 用来确保一个或多个列的值在表中唯一。它只有一个属性columnNames。
以下是个简单的例子：
@Entity
@Table(name="ART", uniqueConstraints=@Unique(columnNames="TITLE"))
public class Article {
...
}
3．1．7 SecondaryTable
有时候一个逻辑上的记录被分散在多个数据库表中。通过SecondaryTable annotation可以指定entity class的secondary tables。通过column annotation的table属性来引用这些secondary tables。例如：
@Entity
@Table(name="ART")
@SecondaryTable(name="ART_DATA", pkJoinColumns=@PrimaryKeyJoinColumn(name="ART_ID", referencedColumnName="ID"))
public class Article {
@Id
private long id;
@Column(table="ART_DATA")
private byte[] content;
...
}
3．2 Field and Property Metadata
JPA提供了两种访问persistent state的方法：field access和property access。每个entity只能使用field access或property access之一来访问同一个persistence state，子类和父类必须使用相同的访问方式来访问同一个persistence state。
如果使用field access，那么JPA会直接把persistent state注入到filed中，并直接从filed上得到persistent state的改变。Annotation直接标记在field上，例如：
@ManyToOne private Company publisher;
如果使用property access，那么JPA会通过Java Bean的"getter" 和 "setter" 方法访问persistent state。Annotation标记在"getter"方法上，例如：
@ManyToOne
private Company getPublisher() { ... }
private void setPublisher(Company publisher) { ... }
当使用property access 的时候，你应该只通过"getter"和"setter"方法访问persistence state。这个类中其它的方法（例如业务逻辑方法），也应该只通过"getter"和"setter"方法来访问persistence state。当你需要在"getter"和"setter"方法内添加其它业务逻辑的时候，你应该认识到，"getter"和"setter"方法也会被JPA调用。
3．2．1 Transient
Transient annotation指定一个字段为non-persistent。
3．2．2 Id
Id annotation用来指定identity字段。
3．2．3 Generated Value
GeneratedValue 用来为identity字段生成唯一值，它有两个属性，分别是strategy和generator。
Strategy有以下可选值：
- GeneratorType.AUTO: 缺省值，生成策略取决于JPA的实现。
- GenerationType.IDENTITY: 在插入的时候由database设置。
- GenerationType.SEQUENCE: 根据数据库中序列生成。
- GenerationType.TABLE: 根据数据库中某个表的某个字段的值生成。
JPA支持以下两种generator，分别是Sequence Generator和Table Generator。Sequence Generator有以下属性：
- String name: 指定generator的名字。
- String sequenceName: 指定数据库中序列名。
- int initialValue: 指定序列的初始值。
- int allocationSize: 有些数据库支持预分配一定数量的序列值，来减少访问次数以提高性能。allocationSize的缺省值是50。
Table Generator有以下属性：
- String name: 指定generator的名字。
- String table: 指定数据库中表名。
- String pkColumnName: 指定数据库表的主键名。
- String valueColumnName: 指定数据库表的保存序列值的列名。
- String pkColumnValue: 指定数据库表的某个主键值。如果用同一个表来生成多个序列值，那么需要指定pkColumnValue。
- int allocationSize: 每一次访问数据库的时候，预分配序列值的数目，缺省值是50。
除了identity字段之外，OpenJPA 支持在任何字段上使用 GeneratedValue annotation。 OpenJPA额外提供了两种generator，如下：
- uuid-string: OpenJPA会生成128位的UUID，用16-character string表示。
- uuid-hex: 跟uuid-string一样，OpenJPA会生成128位的UUID，但是用32-character hexadecimal string 表示。
以下是使用GeneratedValue的一个例子：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.TableGenerator;
@Entity
public class GenerationStrategy {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int identity;
@GeneratedValue(strategy = GenerationType.AUTO, generator="uuid-string")
private String uuidString;
@GeneratedValue(strategy = GenerationType.AUTO, generator="uuid-hex")
private String uuidHex;
@GeneratedValue(strategy = GenerationType.TABLE, generator="tg1")
@TableGenerator(name="tg1", table="GenerationStrategyTable", pkColumnName="id", valueColumnName="sequence", allocationSize=1)
private long tableGeneratorValue;
}
以上例子中，声明了一个named generator："tg1"。在运行时可以通过OpenJPAEntityManager. getNamedGenerator("tg1")方法来访问它。笔者通过MappingTool生成以上例子相关SQL的代码如下（也可以通过命令行生成），如果generateSql是false，那么MappingTool会直接更改数据库。
boolean generateSql = true;
String java = "./src/com/example/jpa/GenerationStrategy.java";
if(!generateSql) {
MappingTool.main(new String[]{java});
System.out.println("the table successfully generated");
} else {
String sql = java.replace("java", "sql");
MappingTool.main(new String[]{"-sql", sql, java});
System.out.println("the sql file was successfully generated: " + sql);
}
如果使用MySql数据库，那么用MappingTool生成的SQL如下：
CREATE TABLE GenerationStrategy (identity INTEGER NOT NULL AUTO_INCREMENT, tableGeneratorValue BIGINT, uuidHex VARCHAR(255), uuidString VARCHAR(255), PRIMARY KEY (identity)) TYPE = innodb; CREATE TABLE GenerationStrategyTable (ID VARCHAR(255) NOT NULL, SEQUENCE BIGINT, PRIMARY KEY (ID)) TYPE = innodb;
3．2．4 Embedded Id
如果一个entity class有多个identity字段，那么你可以声明多个@Id 字段，或者声明一个@EmbeddedId字段。@EmbeddedId字段必须是一个embeddable entity class。
3．2．5 Version
Version annotation用来指定version字段。
3．2．6 Basic
跟Transient annotation不同，basic annotation指定一个字段为persistent。可以在以下类型的字段上使用basic annotation：primitives, primitive wrappers, java.lang.String, byte[], Byte[], char[], Character[], java.math.BigDecimal, java.math.BigInteger, java.util.Date, java.util.Calendar, java.sql.Date, java.sql.Timestamp, Enums, 和 Serializable types.
Basic annotation有以下两个属性：
- FetchType fetch: 指定加载方式，可选值FetchType.EAGER（缺省值）和 FetchType.LAZY。
- boolean optional: datastore 中相关字段是否允许为null，缺省值是true。
OpenJPA 可以在任何字段上进行延迟加载（lazy-load），也允许在运行时动态修改某个字段的加载方式。
3．2．7 Embedded
@Embedded字段必须是字段必须是一个embeddable entity class，它用来映射datastore record的一部分。
3．2．8 Many To One
如果多个entity A引用entity B，而且其它entity A也可能引用相同的entity B，那么称A和B之间的关系是Many To One。JPA使用ManyToOne annotation来指定这种关系。它有以下属性：
- Class targetEntity: 关联entity的Class。
- CascadeType[] cascade: 指定级连行为，缺省是空数组。
- FetchType fetch: 指定加载方式，可选值FetchType.EAGER（缺省值）和 FetchType.LAZY。
- boolean optional: 关联的entity是否必须存在。如果是false，那么这个字段不能是null，缺省值是true。
关于Cascade Type，有以下可选值：CascadeType.PERSIST、CascadeType.REMOVE、CascadeType.REFRESH和CascadeType.MERGE。CascadeType.ALL用来指定以上所有CascadeType，以下两种写法是等价的：
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.REFRESH,CascadeType.MERGE})
private Company publisher;
@ManyToOne(cascade=CascadeType.ALL)
private Company publisher;
以下是个使用ManyToOne annotation的例子：
@Entity
public class Publisher {
@Id
private int publisherId;
}
@Entity
public class Magazine {
@Id
private int magazineId;
@ManyToOne
private Publisher publisher;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Magazine (magazineId INTEGER NOT NULL, publisher_publisherId INTEGER, PRIMARY KEY (magazineId)) TYPE = innodb; CREATE TABLE Publisher (publisherId INTEGER NOT NULL, PRIMARY KEY (publisherId)) TYPE = innodb; CREATE INDEX I_MGAZINE_PUBLISHER ON Magazine (publisher_publisherId);
如果不希望使用OpenJPA缺省的关联字段名（例如publisher_publisherId），那么可以使用JoinColumn annotation，例如：
@Entity
public class Publisher {
@Id
private int publisherId;
}
@Entity
public class Magazine {
@Id
private int magazineId;
@ManyToOne
@JoinColumn(name = "publisherId", referencedColumnName = "publisherId")
private Publisher publisher;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Magazine (magazineId INTEGER NOT NULL, publisherId INTEGER, PRIMARY KEY (magazineId)) TYPE = innodb; CREATE TABLE Publisher (publisherId INTEGER NOT NULL, PRIMARY KEY (publisherId)) TYPE = innodb; CREATE INDEX I_MGAZINE_PUBLISHER ON Magazine (publisherId);
3．2．9 One To Many
如果entity A引用多个entity B，而且没有两个entity A引用相同的entity B，那么称A和B之间的关系是One To Many。JPA使用OneToMany annotation来指定这种关系。它有以下属性：
- Class targetEntity: 关联entity的Class。通常使用在parameterized 集合类上，如果集合类不是parameterized 类型，那么必须指定这个属性。
- String mappedBy: 用来之指定双向关系另一端的entity name。如果没有指定这个属性，那么认为是标准的单向关系。
- CascadeType[] cascade: A指定级连行为，缺省是空数组。
- FetchType fetch: 指定load方式，可选值FetchType.EAGER和 FetchType.LAZY（缺省值）。
如果使用OneToMany关系，那么缺省情况下JPA将会生成中间表来进行关联，例如：
@Entity
public class Publisher {
@Id
private int publisherId;
@OneToMany
private List<Magazine> magazines;
}
@Entity
public class Magazine {
@Id
private int magazineId;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Magazine (magazineId INTEGER NOT NULL, PRIMARY KEY (magazineId)) TYPE = innodb; CREATE TABLE Publisher (publisherId INTEGER NOT NULL, PRIMARY KEY (publisherId)) TYPE = innodb; CREATE TABLE Publisher_Magazine (Publisher_publisherId INTEGER, magazines_magazineId INTEGER) TYPE = innodb; CREATE INDEX I_PBLSGZN_ELEMENT ON Publisher_Magazine (magazines_magazineId); CREATE INDEX I_PBLSGZN_PUBLISHER_PUBLISHERID ON Publisher_Magazine (Publisher_publisherId);
如果不希望使用OpenJPA缺省的关联表名和字段名（例如Publisher_Magazine，Publisher_publisherId），那么可以使用JoinTable annotation，例如：
@Entity
public class Publisher {
@Id
private int publisherId;
@OneToMany
@JoinTable(name="PublisherMagazine",
joinColumns=@JoinColumn(name="publisherId", referencedColumnName="publisherId"),
inverseJoinColumns=@JoinColumn(name="magazineId", referencedColumnName="magazineId"))
private List<Magazine> magazines;
}
@Entity
public class Magazine {
@Id
private int magazineId;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Magazine (magazineId INTEGER NOT NULL, PRIMARY KEY (magazineId)) TYPE = innodb; CREATE TABLE Publisher (publisherId INTEGER NOT NULL, PRIMARY KEY (publisherId)) TYPE = innodb; CREATE TABLE PublisherMagazine (publisherId INTEGER, magazineId INTEGER) TYPE = innodb; CREATE INDEX I_PBLSGZN_ELEMENT ON PublisherMagazine (magazineId); CREATE INDEX I_PBLSGZN_PUBLISHERID ON PublisherMagazine (publisherId);
考虑下面这种情况：
@Entity
public class Publisher {
@Id
private int publisherId;
@OneToMany()
private List<Magazine> magazines;
}
@Entity
public class Magazine {
@Id
private int magazineId;
@ManyToOne()
private Publisher publisher;
}
在这种情况下，JPA会根据Publisher上的OneToMany关系生成关联表，同时根据Magazine上的ManyToOne关系在Magazine表上生成关联字段。如果希望避免这种冗余，那么可以通过OneToMany上的mappedBy属性来告知JPA：谁拥有这个双向关系。 例如：
@Entity
public class Publisher {
@Id
private int publisherId;
@OneToMany(mappedBy="publisher")
private List<Magazine> magazines;
}
@Entity
public class Magazine {
@Id
private int magazineId;
@ManyToOne()
private Publisher publisher;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Magazine (magazineId INTEGER NOT NULL, publisher_publisherId INTEGER, PRIMARY KEY (magazineId)) TYPE = innodb; CREATE TABLE Publisher (publisherId INTEGER NOT NULL, PRIMARY KEY (publisherId)) TYPE = innodb; CREATE INDEX I_MGAZINE_PUBLISHER ON Magazine (publisher_publisherId);
3．2．10 One To One
如果entity A引用唯一的entity B，而且没有其它entity A引用相同的entity B，那么称A和B之间的关系是One To One。JPA使用OneToOne annotation来指定这种关系。它有以下属性：
- Class targetEntity: 关联entity的Class。通常也可以从字段类型上得到这个信息。
- String mappedBy: 用来之指定双向关系另一端的entity name。如果没有指定这个属性，那么认为是标准的单向关系。
- CascadeType[] cascade: A指定级连行为，缺省是空数组。
- FetchType fetch: 指定load方式，可选值FetchType.EAGER（缺省值）和 FetchType.LAZY。
- boolean optional: 关联的entity是否必须存在。如果是false，那么这个字段不能是null，缺省值是true。
以下是几个使用OneToOne关系的例子：
@Entity
public class Company {
@Id
private int id;
@OneToOne
private Address address;
}
@Entity
public class Address {
@Id
private int id;
@OneToOne
private Company company;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下（两个表都生成了跟对方表主键类型相同的字段及其索引，但是并没有显式的外键关联）：
CREATE TABLE Address (id INTEGER NOT NULL, company_id INTEGER, PRIMARY KEY (id)) TYPE = innodb; CREATE TABLE Company (id INTEGER NOT NULL, address_id INTEGER, PRIMARY KEY (id)) TYPE = innodb; CREATE INDEX I_ADDRESS_COMPANY ON Address (company_id); CREATE INDEX I_COMPANY_ADDRESS ON Company (address_id);
如果将Address类中company属性的annotation改成@OneToOne(mappedBy = "address")，那么用MappingTool生成的SQL（MySQL数据库）如下（只有Company表生成了跟Address表主键类型相同的字段及其索引，但是并没有显式的外键关联）：
CREATE TABLE Address (id INTEGER NOT NULL, PRIMARY KEY (id)) TYPE = innodb; CREATE TABLE Company (id INTEGER NOT NULL, address_id INTEGER, PRIMARY KEY (id)) TYPE = innodb; CREATE INDEX I_COMPANY_ADDRESS ON Company (address_id);
如果不希望使用OpenJPA缺省的关联字段名（例如address_id），那么可以使用JoinColumn annotation，例如：
@Entity
public class Company {
@Id
private int id;
@OneToOne
@JoinColumn(name = "AddressId", referencedColumnName = "id")
private Address address;
}
@Entity
public class Address {
@Id
private int id;
@OneToOne(mappedBy = "address")
private Company company;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Address (id INTEGER NOT NULL, PRIMARY KEY (id)) TYPE = innodb; CREATE TABLE Company (id INTEGER NOT NULL, AddressId INTEGER, PRIMARY KEY (id)) TYPE = innodb; CREATE INDEX I_COMPANY_ADDRESS ON Company (AddressId);
3．2．11 Many To Many
如果entity A引用多个entity B，而且其它的entity A也可能引用其中某些entity B，那么称A和B之间的关系是Many To Many。JPA使用ManyToMany annotation来指定这种关系。它有以下属性：
- Class targetEntity: 关联entity的Class。通常使用在parameterized 集合类上，如果集合类不是parameterized 类型，那么必须指定这个属性。
- String mappedBy: 用来之指定双向关系另一端的entity name。如果没有指定这个属性，那么认为是标准的单向关系。
- CascadeType[] cascade: A指定级连行为，缺省是空数组。
- FetchType fetch: 指定load方式，可选值FetchType.EAGER和 FetchType.LAZY（缺省值）。
如果使用ManyToMany关系，那么JPA将会生成中间表来进行关联，例如：
@Entity
public class Author {
@Id
private int authorId;
@ManyToMany(cascade=CascadeType.ALL)
private List<Article> articles;
}
@Entity
public class Article {
@Id
private int articleId;
@ManyToMany(cascade=CascadeType.ALL)
private List<Author> authors;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Article (articleId INTEGER NOT NULL, PRIMARY KEY (articleId)) TYPE = innodb; CREATE TABLE Article_Author (Article_articleId INTEGER, authors_authorId INTEGER) TYPE = innodb; CREATE TABLE Author (authorId INTEGER NOT NULL, PRIMARY KEY (authorId)) TYPE = innodb; CREATE TABLE Author_Article (Author_authorId INTEGER, articles_articleId INTEGER) TYPE = innodb; CREATE INDEX I_RTCLTHR_ARTICLE_ARTICLEID ON Article_Author (Article_articleId); CREATE INDEX I_RTCLTHR_ELEMENT ON Article_Author (authors_authorId); CREATE INDEX I_THR_TCL_AUTHOR_AUTHORID ON Author_Article (Author_authorId); CREATE INDEX I_THR_TCL_ELEMENT ON Author_Article (articles_articleId);
如果将Article类中authors属性的annotation改成@ManyToMany(cascade=CascadeType.ALL, mappedBy="articles")，那么用MappingTool生成的SQL（MySQL数据库）如下：
CREATE TABLE Article (articleId INTEGER NOT NULL, PRIMARY KEY (articleId)) TYPE = innodb; CREATE TABLE Author (authorId INTEGER NOT NULL, PRIMARY KEY (authorId)) TYPE = innodb; CREATE TABLE Author_Article (authors_authorId INTEGER, articles_articleId INTEGER) TYPE = innodb; CREATE INDEX I_THR_TCL_AUTHORS_AUTHORID ON Author_Article (authors_authorId); CREATE INDEX I_THR_TCL_ELEMENT ON Author_Article (articles_articleId);
如果不希望使用OpenJPA缺省的关联表名和字段名（例如Author_Article，authors_authorId），那么可以使用JoinTable annotation，例如：
@Entity
public class Author {
@Id
private int authorId;
@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name="AuthorArticle",
joinColumns=@JoinColumn(name="AuthorId", referencedColumnName="AuthorId"),
inverseJoinColumns=@JoinColumn(name="ArticleId", referencedColumnName="ArticleId"))
private List<Article> articles;
}
@Entity
public class Article {
@Id
private int articleId;
@ManyToMany(cascade=CascadeType.ALL, mappedBy="articles")
private List<Author> authors;
}
用MappingTool生成以上两个entity class的SQL（MySQL数据库）如下：
CREATE TABLE Article (articleId INTEGER NOT NULL, PRIMARY KEY (articleId)) TYPE = innodb; CREATE TABLE Author (authorId INTEGER NOT NULL, PRIMARY KEY (authorId)) TYPE = innodb; CREATE TABLE AuthorArticle (AuthorId INTEGER, ArticleId INTEGER) TYPE = innodb; CREATE INDEX I_THRRTCL_AUTHORID ON AuthorArticle (AuthorId); CREATE INDEX I_THRRTCL_ELEMENT ON AuthorArticle (ArticleId);
3．2．12 Order By
由于关系型数据库并不保存records的顺序，因此为了保证集合类型的字段有一致的顺序，必须使用OrderBy annotation。缺省是采用identity values的升序。以下是个简单的例子：
@OrderBy("lastName, firstName")
private Collection<Author> authors;
3．2．13 Map Key
JPA在OneToMany或者ManyToMany关系中支持Map类型的字段，关联的entities组成了Map的value。JPA在每个entity中挑选一个字段作为Map的key。MapKey annotation有一个name属性，用来指定被挑选作为key的字段名。如果没有指定name，那么会使用关联entity的identity字段。
3．2．14 Persistent Field Defaults
当某个字段没有使用以上介绍的annotations时，JPA对该字段采取以下的缺省行为：
- 被声明成static, transient, final的字段缺省是non-persistent。
- 以下类型的字段：primitive type, primitive wrapper type, java.lang.String, byte[], Byte[], char[], Character[], java.math.BigDecimal, java.math.BigInteger, java.util.Date, java.util.Calendar, java.sql.Date, java.sql.Timestamp, Serializable type 缺省时persistent，就像使用了Basic annotation一样。
- Embeddable type缺省是persistent，就像使用了Embedded annotation一样。
- 以上以外的字段缺省是non-persistent。
3．2．15 Column
Column annotation 用来指定列的属性，它有以下可选属性：
- String name: 列名，缺省是属性名。
- String columnDefinition: 数据库中列的数据类型。只有当JPA vendor支持通过metadata创建表的时候，这个属性才被使用。
- int length: 列的长度，这个属性通常也是在创建表的时候使用。也有的JPA vendor在flush之前通过这个属性验证数据。
- int precision: 列的精度。
- int scale: 列的小数范围。
- boolean nullable: 列是否允许为null。缺省是true。
- boolean insertable: 如果false，那么SQL 的insert语句中会忽略这个列。缺省是true。
- boolean updatable: 如果false，那么SQL 的update语句中会忽略这个列。缺省是true。
- String table: 指定secondary table的表名。