OpenJPA (2)

最新推荐文章于 2021-02-16 05:19:36 发布
最新推荐文章于 2021-02-16 05:19:36 发布
阅读量252 收藏
点赞数
分类专栏： EE 文章标签： Apache OpenJPA

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的表名。
iteye_19132
关注
专栏目录
单向关联java_openJPA定义单向关联
weixin_30145205的博客
02-25 161
其实在定义单向关系中只有三情况:一对多一对一多对多OneToOne@OneToOne(fetch = FetchType.LAZY)@JoinColumn(name="当前对象的关联id")使用如:1.直接使用JPQL:select o.id, o.name,o.relaObj.id,o.relaObj.name from User o where o.id=?1,此种方式生成的SQL:selec...
使用 Apache OpenJPA 开发 EJB 3.0 应用，第 5 部分: 实体标识的自动生成
weixin_34044273的博客
01-23 179
数据的唯一性是所有应用程序非常基本的要求，由开发者或者用户来维护这种唯一性存在着较大的风险，因此，由系统自动产生唯一标识是一种常见的做法。OpenJPA 中支持四种不同的实体标识自动生成策略： 容器自动生成的实体标识； 使用数据库的自动增长字段生成实体标识； 根据数据库序列号（Sequence）技术生成实体标识； 使用数据库表的字段生成实体标识； 这四种方式各有优缺点，开发者可以...
在Karaf上实现数据持久化（OpenJPA）
heguangyong的专栏
02-27 1399
花了些时间，了解了网上相关的示例；比较少，大部分比较旧； 借助 Christian Schneider的例子，对支持库进行了一些调整，提供一个可用版本的实例； 自动化测试使用嵌入式数据库derby，运行使用mysql； 目前OpenJPA2.3.0使用时有些问题。Achim Nierbeck的配置进行修改。 Karaf3.0.0相对于Karaf2.*.*有了很大的改动，包括新增了一下常用特
springData Jpa 错误： java.sql.SQLSyntaxErrorException: Table 'demojpa.hibernate_sequence' doesn't exis
马雨寒的博客
12-17 8625
本人在测试的时候，数据库已经设置成主键自动增长，但是保存数据的时候还是报错，查过之后说实体没有设置主键自动增长，然后给实体设置主键自动增长了 设置成auto之后还是报错，这就尴尬了，最后解决办法如下： 这个是主键自增长策略问题。 将ID生成略组改成@GeneratedValue(strategy = GenerationType.IDENTITY). 关于主键策略: @GeneratedVal...
Open JPA2 employee 简单例子
08-02
OpenJPA2是一个开源的对象关系映射（ORM）框架，它是Java Persistence API（JPA）规范的实现。在这个“Open JPA2 employee简单例子”中，我们将深入理解如何使用OpenJPA2来处理数据库中的员工数据。这个示例将帮助...
openjpa:Apache OpenJPA
04-03
Apache OpenJPA-自述文件 前言 感谢您下载此版本的Apache OpenJPA。 Apache OpenJPA是Java Persistence API规范的实现。 执照 此存储库的内容已根据Apache License 2.0 许可 更多信息 可以在openjpa-project子目录...
openjpa
03-26
Apache OpenJPA是Apache软件基金会的Java持久性项目，可以用作独立的POJO持久性层，也可以集成到任何符合Java EE的容器和许多其他轻量级框架中，例如Tomcat和Spring。 1.x发行版是JSR-220 Enterprise Java Beans 3.0...
gradle-openjpa:使用 OpenJPA 代码增强实体类的 gradle-plugin
06-12
gradle-openjpa 使用 OpenJPA 代码增强实体类的 gradle-plugin 用法 buildscript { repositories { mavenCentral() } dependencies { classpath 'at.schmutterer.oss.gradle:gradle-openjpa:0.2.0' } } ...
Spring和openJPA集成
08-06
2. **配置 OpenJPA**：创建一个 `persistence.xml` 文件，定义持久化单元（Persistence Unit），包括数据库连接信息、实体类等。 ```xml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:...
JPA的主键产生策略
捌元钱
06-01 1132
@GeneratedValue:主键的产生策略，通过strategy属性指定。 　　主键产生策略通过GenerationType来指定。GenerationType是一个枚举，它定义了主键产生策略的类型。 　　1、AUTO　自动选择一个最适合底层数据库的主键生成策略。如MySQL会自动对应auto increment。这个是默认选项，即如果只写@GeneratedValue，等价于@Gen
java jpa openjpa_JPA 教程（一） . | 学步园
weixin_39850920的博客
02-16 1425
1.JPA概述JPA(Java Persistence API)作为Java EE 5.0平台标准的ORM规范，将得到所有Java EE服务器的支持。Sun这次吸取了之前EJB规范惨痛失败的经历，在充分吸收现有ORM框架的基础上，得到了一个易于使用、伸缩性强的ORM规范。从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，JPA作为ORM领域标准化整合者的目标应该不难实现。JPA通过JDK ...
5.3.3 表生成器@ TableGenerator
05-09 5853
将当前主键的值单独保存到一个数据库的表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式也是很常用的。这种方法生成主键的策略可以适用于任何的数据库，不必担心不同数据库不兼容造成的问题。使用以下SQL脚本创建一个表“tb_generator”，并插入两条数据，SQL脚本如下所示。CREATE TABLE  tb_generator (  id int(20) unsign
openjpa 一对一例子
Dean_Deng的专栏
08-10 1819
demo目录结构如下图：
openjpa 实现新增列设置默认值
newton21012915
03-10 276
[code="java"] @Column(name = "col_tier", nullable = false, columnDefinition="int not null default 1") private int tier; [/code]
hibernate几个 OneToMany.异常总结
coffeehot的专栏
09-30 280
hibernate几个 OneToMany.错误总结http://alinazh.blog.51cto.com/5459270/1279354错误一org.hibernate.AnnotationException: Collection has neither generic type or OneToMany.targetEntity() defined: com.hibernate.Sub...
跟我学OpenJPA之三（更快、更高、更强）
simen_net
04-06 532
上节跟我学OpenJPA之二（Hello OpenJPA）   昨天打开ITEYE，发现我的两篇文章上了首页兴奋ing.... 上ITEYE不短时间，同时上两篇还是第一次，感谢大家的支持，谢谢！   本来昨天考虑好了第三节的题目和内容，可惜出了趟差，回来的时候又冒雨开了两个多小时的车，高速上精神太紧张回来直接倒头睡觉，今天虽然晚上时间也不多，但是有大家的支持再累也得补上。嘿嘿 废话多...
spring data jpa 多表UNION ALL查询按条件排序分页处理：未搜到方法，解决后记录：2018年11月13日15:22:00
Sigod
11-13 7884
需求：Mysql数据库 有不同属性的两张表，需要进行按某个条件查询，结果合并排序分页。 让产品把两个表分成两段展示各查各的，分开来。 产品经理说能实现：产品写sql 联合查询， A UNION ALL B 。 那开发就处理后续排序分页了。 dao层 @Query(nativeQuery = true,value = "SELECT re.id,re.i_amount,re.i_shar...
JPA入门（openJPA）
yan_dev的专栏
03-24 667
1.环境搭建：   1.1 JDK 1.6.0.22的下载地址：http://java.sun.com   1.2 Eclipse IDE for Java EE Developers 3.6.2的下载地址：http://www.eclipse.org/downloads/   1.3 OpenJPA 2.1.0的下载地址：http://openjpa.apache.org/downloa...
Apache OpenJPA 2.1 教程：Java持久化API详解
"Apache OpenJPA 2.1 User's Guide" Apache OpenJPA 是一个开源的、Apache 软件基金会开发的Java持久化规范（Java Persistence API, JPA 2.0）实现，该规范定义了如何在Java应用程序中透明地持久化对象。这个用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值