Metadata

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的例子：

Java代码
@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;
}

@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如下： 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;

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的例子：

Java代码
@MappedSuperclass
public abstract class Document {
@Id
protected int id;

@Version
protected int version;
}

@Entity
public class Contract extends Document {
@Basic
private String name;
}

@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如下： Sql代码
CREATE TABLE Contract (id INTEGER NOT NULL, name VARCHAR(255), version INTEGER, PRIMARY KEY (id)) TYPE = innodb;

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的例子：

Java代码
@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;
}

@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如下： 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;

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。
以下是个简单的例子：

Java代码
@Entity
@Table(name="ART", uniqueConstraints=@Unique(columnNames="TITLE"))
public class Article {
...
}

@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。例如：

Java代码
@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;

...
}

@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上，例如：

Java代码
@ManyToOne
private Company publisher;

@ManyToOne
private Company publisher; 如果使用property access，那么JPA会通过Java Bean的"getter" 和 "setter" 方法访问persistent state。Annotation标记在"getter"方法上，例如：

Java代码
@ManyToOne
private Company getPublisher() { ... }
private void setPublisher(Company publisher) { ... }

@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的一个例子：

Java代码
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;

}

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会直接更改数据库。

Java代码
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);
}

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如下：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;

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，以下两种写法是等价的：

Java代码
@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.REFRESH,CascadeType.MERGE})
private Company publisher;

@ManyToOne(cascade=CascadeType.ALL)
private Company publisher;

@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE, CascadeType.REFRESH,CascadeType.MERGE})
private Company publisher;

@ManyToOne(cascade=CascadeType.ALL)
private Company publisher;

以下是个使用ManyToOne annotation的例子：

Java代码
@Entity
public class Publisher {
@Id
private int publisherId;
}

@Entity
public class Magazine {
@Id
private int magazineId;

@ManyToOne
private Publisher publisher;
}

@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数据库）如下： Sql代码
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);

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，例如： Java代码
@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;
}

@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数据库）如下：
Sql代码
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);

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将会生成中间表来进行关联，例如：

Java代码
@Entity
public class Publisher {
@Id
private int publisherId;

@OneToMany
private List<Magazine> magazines;
}

@Entity
public class Magazine {
@Id
private int magazineId;
}

@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数据库）如下：

Sql代码
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);

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，例如： Java代码
@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;
}

@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数据库）如下： Sql代码
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);

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);

考虑下面这种情况：

Java代码
@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;
}

@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：谁拥有这个双向关系。 例如： Java代码
@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;
}

@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数据库）如下：
Sql代码
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);

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关系的例子：

Java代码
@Entity
public class Company {
@Id
private int id;

@OneToOne
private Address address;
}

@Entity
public class Address {
@Id
private int id;

@OneToOne
private Company company;
}

@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数据库）如下（两个表都生成了跟对方表主键类型相同的字段及其索引，但是并没有显式的外键关联）： Sql代码
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);

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表主键类型相同的字段及其索引，但是并没有显式的外键关联）：

Sql代码
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);

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，例如：

Java代码
@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;
}

@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数据库）如下： Sql代码
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);

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将会生成中间表来进行关联，例如：

Java代码
@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;
}

@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数据库）如下： Sql代码
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);

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数据库）如下：

Sql代码
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);

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，例如：

Java代码
@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;
}

@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数据库）如下： Sql代码
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);

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的升序。以下是个简单的例子：

Java代码
@OrderBy("lastName, firstName")
private Collection<Author> authors;

@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的表名。