- 浏览: 484452 次
- 性别:
- 来自: 大连
文章分类
最新评论
-
龘龘龘:
TrueBrian 写道有个问题,Sample 1中,为了控制 ...
What's New on Java 7 Phaser -
龘龘龘:
楼主总结的不错。
What's New on Java 7 Phaser -
TrueBrian:
有个问题,Sample 1中,为了控制线程的启动时机,博主实际 ...
What's New on Java 7 Phaser -
liguanqun811:
不知道楼主是否对zookeeper实现的分布式锁进行过性能测试 ...
Distributed Lock -
hobitton:
mysql的get lock有版本限制,否则get lock可 ...
Distributed Lock
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的表名。
发表评论
-
Terracotta in Action (3)
2009-03-25 09:20 51763 Inside Terracotta 3.1 Core T ... -
Terracotta in Action (2)
2009-03-21 21:09 47292. Terracotta Eclipse Plugin ... -
Terracotta in Action (1)
2009-03-19 21:52 63051. Introduction Terraco ... -
OpenEJB (4)
2008-05-11 09:05 3202本文部分内容节选自Enterprise JavaBeans 3 ... -
OpenEJB (3)
2008-05-11 09:04 2737本文部分内容节选自Enterprise JavaBeans 3 ... -
OpenEJB (2)
2008-05-11 09:03 3331本文部分内容节选自Enterprise JavaBeans 3 ... -
OpenEJB (1)
2008-05-10 22:39 5116本文部分内容节选自Enterprise JavaBeans 3 ... -
OpenJPA (7)
2008-03-25 21:56 358210 Miscellaneous Features 10 ... -
OpenJPA (6)
2008-03-23 21:33 63768 Object Locking 8.1 Configu ... -
OpenJPA (5)
2008-03-18 22:38 50717 Inheritance 对象使用引用以便关联到其 ... -
OpenJPA (4)
2008-03-11 23:27 71426 Query 6.1 JPQL Queries 6.1. ... -
OpenJPA (3)
2008-03-09 23:09 52824 EntityManagerFactory 4.1 Ove ... -
OpenJPA (1)
2008-03-04 23:11 69131 Overview Apache OpenJPA是 ... -
ActiveMQ in Action (7)
2008-02-27 14:33 126882.6.7 Wildcards Wil ... -
ActiveMQ in Action (6)
2008-02-26 15:22 138322.6 Features ActiveMQ包含了很多 ... -
ActiveMQ in Action (5)
2008-02-26 00:35 136332.5 Clustering ActiveMQ从多种 ... -
ActiveMQ in Action (4)
2008-02-26 00:21 113082.4 Security ActiveMQ ... -
ActiveMQ in Action (3)
2008-02-26 00:16 106502.3 Persistence 2.3.1 AMQ Mess ... -
ActiveMQ in Action (2)
2008-02-25 23:58 133132.2 Transport ActiveMQ目前支持 ... -
ActiveMQ in Action (1)
2008-02-25 23:18 239101 JMS 在介绍ActiveMQ ...
相关推荐
OpenJPA2是一个开源的对象关系映射(ORM)框架,它是Java Persistence API(JPA)规范的实现。在这个“Open JPA2 employee简单例子”中,我们将深入理解如何使用OpenJPA2来处理数据库中的员工数据。这个示例将帮助...
OpenJPA,全称Open Java Persistence API,是Java平台上的一个开源对象关系映射(ORM)框架,它实现了Java Persistence API(JPA),用于管理Java应用程序中的持久化数据。在这个"openjpademo"示例中,我们将会探讨...
默认情况下,当应用程序第一次获取实体标识时,OpenJPA 框架从数据库中一次性获取 50 个连续的实体标识缓存起来,当下一次应用程序需要获取实体标识时,OpenJPA 将首先检测缓存中是否存在实体标识,如果存在,Open...
OpenJPA OpenJPA 是 Apache 组织提供的开源项目,它实现了 EJB 3.0 中的 JPA 标准,为开发者提供功能强大、使用简单的持久化数据管理框架。OpenJPA 封装了和关系型数据库交互的操作,让开发者把注意力集中在编写...
2. **实体管理**:OpenJPA提供了Entity Manager,它是处理实体对象的主要接口,负责对象的创建、查询、更新和删除等操作。 3. **事务管理**:支持JTA(Java Transaction API)和JPA事务管理,确保数据操作的一致性...
**Spring和OpenJPA集成详解** 在Java世界中,Spring框架和OpenJPA(Open Java Persistence)是两个非常重要的组件。Spring作为一个全面的轻量级应用框架,提供了大量的功能,包括依赖注入、AOP(面向切面编程)、...
2. **配置OpenJPA**:在Spring的配置文件(如`applicationContext.xml`)中,你需要配置OpenJPA的数据源、实体扫描路径以及JPA的属性: ```xml <!-- 数据库连接配置 --> ...
OpenJPA(Open Java Persistence API)是Apache软件基金会下的一个开源项目,它是Java持久层标准JPA(Java Persistence API)的一个实现。JPA是Java EE平台中的一个重要组件,用于管理和处理应用程序中的对象-关系...
**JSF与OpenJPA整合** 涉及到在JSF应用中使用OpenJPA进行数据访问。这通常包括配置OpenJPA的数据源、实体管理器工厂,以及在JSF Managed Beans中注入实体管理器,以便在处理用户请求时执行CRUD操作。JSF的事件驱动...
2. **查询语言**:OpenJPA支持使用JPQL(Java Persistence Query Language),这是一种面向对象的查询语言,类似于SQL,但用于处理持久化实体。此外,它还支持 Criteria API,允许动态构建查询,提供更强大的查询...
### OpenJPA官方手册知识点概览 #### 一、引言 - **OpenJPA**:作为Apache项目的一部分,OpenJPA是一个开源的Java持久化框架(Java Persistence Framework),它支持Java Persistence API (JPA) 的规范。OpenJPA...
安装OpenJPA的步骤通常包括下载OpenJPA的jar文件,将其添加到服务器的类路径中,并在服务器配置中指定OpenJPA作为默认的持久化提供者。 接下来,我们需要创建一个JPA项目。这涉及定义实体类,这些类代表数据库中的...
Spring MVC和OpenJPA是Java开发中常用的两个框架,它们分别在Web应用和持久层处理上发挥着重要作用。Spring MVC是Spring框架的一部分,用于构建高效、灵活的Web应用程序,而OpenJPA则是一个实现了Java Persistence ...
OpenJPA API 文档 chm格式
### Apache OpenJPA 2.1 用户指南:Java Persistence API 的深入解析 #### 一、简介 Apache OpenJPA 2.1 是基于 Sun Microsystems 的 Java Persistence 2.0 API (JSR-317 JPA 2.0) 规范实现的一种透明持久化 Java ...
Apache OpenJPA-自述文件 前言 感谢您下载此版本的Apache OpenJPA。 Apache OpenJPA是Java Persistence API规范的实现。 执照 此存储库的内容已根据Apache License 2.0 许可 更多信息 可以在openjpa-project子目录...
### OpenJPA-Manual 关键知识点解析 #### 一、OpenJPA介绍 **1.1 关于本文档** 本文档旨在提供一个全面且深入的指南,帮助开发人员理解和掌握Java Persistence API(JPA)的核心概念及其在Apache OpenJPA中的实现...
Openjpa2.2+Mysql+Maven+Servlet+JSP 博客源码: http://blog.csdn.net/shenhonglei1234/article/details/10394379
2. **懒加载(Lazy Loading)**:OpenJPA支持懒加载策略,即只有当真正需要某个关联的对象时,才会去数据库加载,从而提高程序的运行效率。 3. **缓存机制**:OpenJPA提供了一级缓存和二级缓存,一级缓存是事务级别...