Spring注解之实体类常用注解
Posted 持.之.以.恒
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring注解之实体类常用注解相关的知识，希望对你有一定的参考价值。
import org.hibernate.annotations.AccessType;
import org.hibernate.annotations.*;
import javax.persistence.*;
import javax.persistence.Entity;
@SelectBeforeUpdate(value = true) //指明Hibernate从不运行SQL Update，除非能确定对象已经被修改
@DynamicInsert(value = true) //allow dynamic SQL for inserts 用动态SQL新增
@DynamicUpdate(value = true) //allow dynamic SQL forupdates 用动态SQL更新
@Entity
@javax.persistence.Table(name = "Table_Test")
@AccessType("field")
@GenericGenerator(name = "sysuuid", strategy = "uuid")
public class TestEntity
@Id
@GeneratedValue(generator = "system_uuid")
private String id;
@Column(name = "Name", length = 1)
private String state;
@Transient 表示此数据不在数据库表里建立属性
@Dict(dicType = "STATUS", dicKeyFiled = "state")
private String stateTxt;
@SuppressWarnings("serial")
@Entity
@Table(name="T_A")
public class A implements Serializable
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "a", fetch = FetchType.EAGER)
private List<B> b = new ArrayList<B>();
@OneToOne()
@JoinColumn(name = "x_Id") //加这句后就会双方共同维护关系
private X x;
一、实体Entity
每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用 @Entity 注解来进行声明。
1、声明实体Bean
@Entitypublic class Flightimplements Serializable Long id; @Id public Long getId() return id; public void setId(Long id) this.id = id;
@Entity 注解将一个类声明为实体Bean, @Id 注解声明了该实体Bean的标识属性。
hibernate 可以对类的属性或者方法进行注解。属性对应field类别，方法的getXxx()对应property类别。
2、定义表
通过 @Table 为实体Bean指定对应数据库表，目录和schema的名字。
@Entity@Table(name="tbl_sky")public class Skyimplements Serializable
...
@Table 注解包含一个schema和一个catelog属性，使用@UniqueConstraints 可以定义表的唯一约束。
@Table(name="tbl_sky", uniqueConstraints =@UniqueConstraint(columnNames="month", "day"))
上述代码在 "month" 和 "day" 两个 field 上加上unique constrainst.
@Version 注解用于支持乐观锁版本控制。
@Entitypublic class Flightimplements Serializable ... @Version @Column(name="OPTLOCK") public Integer getVersion() ...
version属性映射到 "OPTLOCK" 列，entity manager 使用这个字段来检测冲突。一般可以用数字或者 timestamp类型来支持 version.
实体Bean中所有非static 非 transient 属性都可以被持久化，除非用@Transient注解。
默认情况下，所有属性都用 @Basic 注解。
public transient intcounter; //transient property
private Stringfirstname; //persistent property@TransientStringgetLengthInMeter() ... //transient propertyString getName() ... // persistent property@Basicint
getLength() ... // persistent property@Basic(fetch =FetchType.LAZY)StringgetDetailedComment() ... // persistent property@Temporal(TemporalType.TIME)
Java.util.DategetDepartureTime() ... // persistent property@Enumerated(EnumType.STRING)Starred getNote() ... //enum persisted as String in database
上述代码中counter, lengthInMeter 属性将忽略不被持久化，而firstname, name, length 被定义为可持久化和可获取的。
@TemporalType.(DATE,TIME,TIMESTAMP)分别Map java.sql.(Date,Time, Timestamp).
@Lob注解属性将被持久化为 Blog 或 Clob 类型。具体的java.sql.Clob, Character[], char[] 和 java.lang.String 将被持久化为 Clob 类型. java.sql.Blob,Byte[], byte[] 和
serializable type 将被持久化为 Blob 类型。
@Lobpublic StringgetFullText() return fullText; // clob type
@Lobpublic byte[]getFullCode() return fullCode; // blog type
@Column 注解将属性映射到列。
@Entitypublic class Flightimplements Serializable ... @Column(updatable = false, name ="flight_name", nullable = false, length=50) public String getName()
...
定义 name 属性映射到 flight_name column, not null, can't update, length equal 50
@Column( name="columnName"; (1) 列名 boolean unique() default false; (2) 是否在该列上设置唯一约束 boolean nullable() default true; (3) 列可空？ boolean
insertable() default true; (4) 该列是否作为生成 insert语句的一个列 boolean updatable() default true; (5) 该列是否作为生成 update语句的一个列 String
columnDefinition() default""; (6) 默认值 String table() default "";(7) 定义对应的表（deault 是主表） int length() default 255; (8) 列
长度 int precision() default 0; // decimalprecision (9) decimal精度 int scale() default 0; // decimal scale (10) decimal长度
3、嵌入式对象（又称组件）也就是别的对象定义的属性
组件类必须在类一级定义 @Embeddable 注解。在特定的实体关联属性上使用 @Embeddable 和@AttributeOverride 注解可以覆盖该属性对应的嵌入式对象的列映射。
@Entitypublic class Personimplements Serializable // Persistent component using defaults Address homeAddress; @Embedded @AttributeOverrides(
@AttributeOverride(name="iso2",column = @Column(name="bornIso2") ), @AttributeOverride(name="name",column = @Column(name="bornCountryName") ) ) Country
bornIn; ...
@Embeddablepublic class Addressimplements Serializable String city; Country nationality; //no overriding here
@Embeddablepublic class Countryimplements Serializable private String iso2; @Column(name="countryName")private String name; public String getIso2() return
iso2; public void setIso2(String iso2) this.iso2= iso2; public String getName() return name; public void setName(String name) this.name= name;
...
Person 类定义了 Address 和 Country 对象，具体两个类实现见上。
4、无注解属性默认值：
•属性为简单类型，则映射为@Basic
•属性对应的类型定义了@Embeddable 注解，则映射为@Embedded
•属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。
•属性的类型为java.sql.Clob or java.sql.Blob, 则映射到 @Lob 对应的类型。
5、映射主键属性
@Id 注解可将实体Bean中某个属性定义为主键，使用@GenerateValue注解可以定义该标识符的生成策略。
• AUTO - 可以是 identity column, sequence 或者 table 类型，取决于不同底层的数据库• TABLE - 使用table保存id值• IDENTITY - identity column• SEQUENCE - seque
nce
@Id@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")public Integer getId() ...
@Id@GeneratedValue(strategy=GenerationType.IDENTITY)public Long getId() ...
6、AUTO 生成器，适用与可移值的应用，多个@Id可以共享同一个identifier生成器，只要把generator属性设成相同的值就可以。通过@SequenceGenerator和@TableGenerator 可以配置不
同的identifier 生成器。
<table-generatorname="EMP_GEN" table="GENERATOR_TABLE" pk-column-name="key" value-column-name="hi" pk-column-value="EMP" allocation-
size="20"/>//and the annotationequivalent@javax.persistence.TableGenerator( name="EMP_GEN", table="GENERATOR_TABLE", pkColumnName = "key",
valueColumnName = "hi" pkColumnValue="EMP", allocationSize=20)<sequence-generatorname="SEQ_GEN" sequence-name="my_sequence" allocation-
size="20"/>//and the annotationequivalent@javax.persistence.SequenceGenerator( name="SEQ_GEN", sequenceName="my_sequence", allocationSize=20)
The next example showsthe definition of a sequence generator in a class scope:
@Entity@javax.persistence.SequenceGenerator( name="SEQ_STORE", sequenceName="my_sequence")public class Storeimplements Serializable private Long id;
@Id@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_STORE") public Long getId() return id;
Store类使用名为my_sequence的sequence，并且SEQ_STORE生成器对于其他类是不可见的。
7、通过下面语法，你可以定义组合键。
•将组件类注解为@Embeddable，并将组件的属性注解为 @Id•将组件的属性注解为@EmbeddedId•将类注解为@IdClass，并将该实体中所有主键的属性都注解为 @Id
@Entity@IdClass(FootballerPk.class)public classFootballer //part of the id key @Id public String getFirstname() return firstname; public void
setFirstname(String firstname) this.firstname = firstname; //part of the id key @Id public String getLastname() return lastname; public void
setLastname(String lastname) this.lastname = lastname; public String getClub() return club; public void setClub(String club) this.club = club;
//appropriate equals() and hashCode()implementation
@Embeddablepublic classFootballerPk implements Serializable //same name and type as in Footballer public String getFirstname() return firstname; public
void setFirstname(String firstname) this.firstname = firstname; //same name and type as in Footballer public String getLastname() return lastname;
public void setLastname(String lastname) this.lastname = lastname; //appropriate equals() and hashCode()implementation
@Entity@AssociationOverride(name="id.channel", joinColumns =@JoinColumn(name="chan_id") )public class TvMagazin @EmbeddedId public TvMagazinPk id; @Temporal
(TemporalType.TIME) Date time;
@Embeddablepublic class TvMagazinPkimplements Serializable @ManyToOne public Channel channel; public String name; @ManyToOne public Presenter
presenter;
8、映射继承关系
EJB支持3种类型的继承。
• Table per Class Strategy: the <union-class> element inHibernate 每个类一张表• Single Table per Class Hierarchy Strategy: the<subclass> element in Hibernate 每个类
层次结构一张表• Joined Subclass Strategy: the <joined-subclass>element in Hibernate 连接的子类策略
@Inheritance 注解来定义所选的之类策略。
每个类一张表
@Entity@Inheritance(strategy= InheritanceType.TABLE_PER_CLASS)public class Flightimplements Serializable
有缺点，如多态查询或关联。Hibernate使用 SQL Union 查询来实现这种策略。这种策略支持双向的一对多关联，但不支持IDENTIFY 生成器策略，因为ID必须在多个表间共享。一旦使用
就不能使用AUTO和IDENTIFY生成器。
每个类层次结构一张表
@Entity@Inheritance(strategy=InheritanceType.SINGLE_TABLE)@DiscriminatorColumn( name="planetype", discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("Plane")public class Plane ...
@Entity@DiscriminatorValue("A320")public class A320extends Plane ...
整个层次结构中的所有父类和子类属性都映射到同一个表中，他们的实例通过一个辨别符列（discriminator）来区分。
Plane 是父类。@DiscriminatorColumn注解定义了辨别符列。对于继承层次结构中的每个类,@DiscriminatorValue 注解指定了用来辨别该类的值。辨别符列名字默认为DTYPE，其默认值为
实体名。其类型为DiscriminatorType.STRING。
连接的子类
@Entity@Inheritance(strategy=InheritanceType.JOINED)public class Boatimplements Serializable ...
@Entitypublic class Ferryextends Boat ...
@Entity@PrimaryKeyJoinColumn(name="BOAT_ID")public classAmericaCupClass extends Boat ...
以上所有实体使用JOINED 策略 Ferry和Boat class使用同名的主键关联(eg:Boat.id = Ferry.id)， AmericaCupClass和 Boat 关联的条件为Boat.id = AmericaCupClass.BOAT_ID.
从父类继承的属性
@MappedSuperclasspublic classBaseEntity @Basic @Temporal(TemporalType.TIMESTAMP) public Date getLastUpdate() ... public String getLastUpdater() ...
...
@Entity class Orderextends BaseEntity @Id public Integer getId() ... ...
继承父类的一些属性，但不用父类作为映射实体，这时候需要 @MappedSuperclass 注解。上述实体映射到数据库中的时候对应Order 实体Bean, 其具有 id, lastUpdate, lastUpdater 三
个属性。如果没有@MappedSuperclass 注解,则父类中属性忽略，这是Order 实体 Bean 只有 id 一个属性。
映射实体Bean的关联关系
一对一
使用 @OneToOne 注解可以建立实体Bean之间的一对一关系。一对一关系有3种情况。
•关联的实体都共享同样的主键。
@Entitypublic class Body @Id public Long getId() return id; @OneToOne(cascade = CascadeType.ALL) @PrimaryKeyJoinColumn public Heart getHeart()
return heart; ...
@Entitypublic class Heart @Id public Long getId() ...
通过@PrimaryKeyJoinColumn 注解定义了一对一的关联关系。
•其中一个实体通过外键关联到另一个实体的主键。注：一对一，则外键必须为唯一约束。
@Entitypublic class Customerimplements Serializable @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name="passport_fk") public Passport getPassport()
...
@Entitypublic class Passportimplements Serializable @OneToOne(mappedBy = "passport") public Customer getOwner() ...
通过@JoinColumn注解定义一对一的关联关系。如果没有@JoinColumn注解，则系统自动处理，在主表中将创建连接列，列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。上例
为 passport_id, 因为Customer 中关联属性为passport, Passport 的主键为 id.
•通过关联表来保存两个实体之间的关联关系。注：一对一，则关联表每个外键都必须是唯一约束。
@Entitypublic class Customerimplements Serializable @OneToOne(cascade = CascadeType.ALL) @JoinTable(name= "CustomerPassports", joinColumns=
@JoinColumn(name="customer_fk"), inverseJoinColumns= @JoinColumn(name="passport_fk") ) public Passport getPassport() ...
@Entity public classPassport implements Serializable @OneToOne(mappedBy = "passport") public Customer getOwner() ...
Customer 通过 CustomerPassports 关联表和 Passport 关联。该关联表通过passport_fk 外键指向Passport 表，该信心定义为inverseJoinColumns 的属性值。通过 customer_fk 外键
指向Customer 表，该信息定义为joinColumns 属性值。
多对一
使用 @ManyToOne 注解定义多对一关系。
@Entity()public class Flightimplements Serializable @ManyToOne( cascade = CascadeType.PERSIST,CascadeType.MERGE ) @JoinColumn(name="COMP_ID") public Company
getCompany() return company; ...
其中@JoinColumn 注解是可选的，关键字段默认值和一对一关联的情况相似。列名为：主题的关联属性名 + 下划线 + 被关联端的主键列名。本例中为company_id,因为关联的属性是
company,Company的主键为 id.
@ManyToOne 注解有个targetEntity属性，该参数定义了目标实体名。通常不需要定义，大部分情况为默认值。但下面这种情况则需要 targetEntity 定义（使用接口作为返回值，而不是
常用的实体）。
@Entity()public class Flightimplements Serializable @ManyToOne(cascade= CascadeType.PERSIST,CascadeType.MERGE,targetEntity= CompanyImpl.class) @JoinColumn
(name="COMP_ID") public Company getCompany() return company; ...
public interfaceCompany ...
多对一也可以通过关联表的方式来映射，通过 @JoinTable 注解可定义关联表。该关联表包含指回实体的外键（通过@JoinTable.joinColumns）以及指向目标实体表的外键（通过
@JoinTable.inverseJoinColumns）.
@Entity()public class Flightimplements Serializable
@ManyToOne( cascade = CascadeType.PERSIST,CascadeType.MERGE ) @JoinTable(name="Flight_Company", joinColumns =@JoinColumn(name="FLIGHT_ID"),
inverseJoinColumns =@JoinColumn(name="COMP_ID") ) public Company getCompany() return company; ...
集合类型
一对多
@OneToMany 注解可定义一对多关联。一对多关联可以是双向的。
双向
规范中多对一端几乎总是双向关联中的主体（owner）端，而一对多的关联注解为 @OneToMany(mappedBy=)
@Entitypublic class Troop @OneToMany(mappedBy="troop") public Set<Soldier> getSoldiers() ...
@Entitypublic class Soldier @ManyToOne @JoinColumn(name="troop_fk") public Troop getTroop() ...
Troop 通过troop属性和Soldier建立了一对多的双向关联。在 mappedBy 端不必也不能定义任何物理映射。
单向
@Entitypublic class Customerimplements Serializable @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER) @JoinColumn(name="CUST_ID") public Set<Ticket>
getTickets() ...
@Entitypublic class Ticketimplements Serializable ... //no bidir
一般通过连接表来实现这种关联，可以通过@JoinColumn注解来描述这种单向关联关系。上例 Customer 通过CUST_ID列和 Ticket 建立了单向关联关系。
通过关联表来处理单向关联
@Entitypublic class Trainer @OneToMany @JoinTable( name="TrainedMonkeys", joinColumns = @JoinColumn(name="trainer_id"), inverseJoinColumns =
@JoinColumn(name="monkey_id") ) public Set<Monkey> getTrainedMonkeys() ...
@Entitypublic class Monkey ... //no bidir
通过关联表来处理单向一对多关系是首选，这种关联通过 @JoinTable 注解来进行描述。上例子中Trainer 通过TrainedMonkeys表和Monkey建立了单向关联关系。其中外键trainer_id关联
到Trainer(joinColumns)而外键monkey_id关联到Monkey(inverseJoinColumns).
默认处理机制
通过连接表来建立单向一对多关联不需要描述任何物理映射，表名由一下3个部分组成，主表(ownertable)表名 + 下划线 + 从表(the other side table)表名。指向主表的外键名:主表表
名+下划线+主表主键列名指向从表的外键定义为唯一约束，用来表示一对多的关联关系。
@Entitypublic class Trainer @OneToMany public Set<Tiger> getTrainedTigers() ...
@Entitypublic class Tiger ... //no bidir
上述例子中Trainer 和 Tiger 通过 Trainer_Tiger 连接表建立单向关联关系。其中外键 trainer_id 关联到Trainer表，而外键 trainedTigers_id 关联到Tiger 表。
多对多
通过 @ManyToMany 注解定义多对多关系，同时通过 @JoinTable 注解描述关联表和关联条件。其中一端定义为owner, 另一段定义为inverse(对关联表进行更新操作，这段被忽略)。
@Entitypublic class Employerimplements Serializable @ManyToMany( targetEntity=org.hibernate.test.metadata.manytomany.Employee.class, cascade=
CascadeType.PERSIST,CascadeType.MERGE ) @JoinTable( name="EMPLOYER_EMPLOYEE", joinColumns=@JoinColumn(name="EMPER_ID"), inverseJoinColumns=@JoinColumn
(name="EMPEE_ID") ) public Collection getEmployees() return employees; ...
@Entitypublic class Employeeimplements Serializable @ManyToMany( cascade = CascadeType.PERSIST,CascadeType.MERGE, mappedBy = "employees", targetEntity
= Employer.class ) public Collection getEmployers() return employers;
默认值：
关联表名：主表表名 + 下划线 + 从表表名；关联表到主表的外键：主表表名 + 下划线 + 主表中主键列名；关联表到从表的外键名：主表中用于关联的属性名 + 下划线 + 从表的主键列
名。
用cascading 实现传播持久化（Transitivepersistence）
cascade 属性接受值为 CascadeType 数组，其类型如下：
• CascadeType.PERSIST:cascades the persist (create) operation to associated entities persist() iscalled or if the entity is managed 如果一个实体是受管状态，或者当
persist() 函数被调用时，触发级联创建(create)操作。
• CascadeType.MERGE:cascades the merge operation to associated entities if merge() is called or ifthe entity is managed 如果一个实体是受管状态，或者当merge() 函数被
调用时，触发级联合并(merge)操作。
• CascadeType.REMOVE:cascades the remove operation to associated entities if delete() is called 当 delete()函数被调用时，触发级联删除(remove)操作。
• CascadeType.REFRESH:cascades the refresh operation to associated entities if refresh() iscalled 当refresh() 函数被调用时，出发级联更新(refresh)操作。
• CascadeType.ALL:all of the above 以上全部
映射二级列表
使用类一级的 @SecondaryTable 和 @SecondaryTables 注解可以实现单个实体到多个表的映射。使用@Column或者@JoinColumn 注解中的table 参数可以指定某个列所属的特定表。
@Entity@Table(name="MainCat")@SecondaryTables( @SecondaryTable(name="Cat1",pkJoinColumns= @PrimaryKeyJoinColumn
(name="cat_id",referencedColumnName="id")), @SecondaryTable(name="Cat2",uniqueConstraints= @UniqueConstraint(columnNames="storyPart2")) )public
class Catimplements Serializable private Integer id; private String name;
private String storyPart1; private String storyPart2; @Id @GeneratedValue public Integer getId() return id; public String getName() return name;
@Column(table="Cat1") public String getStoryPart1() return storyPart1; @Column(table="Cat2") public String getStoryPart2() return storyPart2;
上述例子中，name 保存在MainCat 表中，storyPart1保存在 Cat1 表中，storyPart2保存在Cat2 表中。Cat1 表通过外键cat_id 和 MainCat 表关联， Cat2 表通过 id 列和 MainCat 表
关联。对storyPart2列还定义了唯一约束。
映射查询
使用注解可以映射EJBQL/HQL 查询，@NamedQuery和 @NamedQueries 是可以使用在类级别或者JPA的XML文件中的注解。
<entity-mappings> <named-queryname="plane.getAll"> <query>select p from Planep</query> </named-query> ...</entity-mappings>...@Entity@NamedQuery
(name="night.moreRecentThan",query="select n from Night n where n.date >= :date")public class Night ...public class MyDao doStuff() Query q
=s.getNamedQuery("night.moreRecentThan"); q.setDate( "date", aMonthAgo ); List results = q.list(); ... ...
可以通过定义QueryHint 数组的hints 属性为查询提供一些hint 信息。下图是一些Hibernate hints:
映射本地化查询
通过@SqlResultSetMapping 注解来描述 SQL 的 resultset 结构。如果定义多个结果集映射，则用@SqlResultSetMappings。
@NamedNativeQuery(name="night&area",query="select night.id nid, night.night_duration, " + " night.night_date, area.id aid,night.area_id, area.name " + "from
Night night, Area area wherenight.area_id = area.id", resultSetMapping="joinMapping")
@SqlResultSetMapping(name="joinMapping", entities= @EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class,fields = @FieldResult
(name="id",column="nid"), @FieldResult(name="duration",column="night_duration"), @FieldResult(name="date",column="night_date"), @FieldResult
(name="area",column="area_id"), discriminatorColumn="disc" ), @EntityResult(entityClass=org.hibernate.test.annotations.query.Area.class,fields =
@FieldResult(name="id",column="aid"), @FieldResult(name="name",column="name") ) )
上面的例子，名为“night&area”的查询和 "joinMapping"结果集映射对应，该映射返回两个实体，分别为 Night 和Area, 其中每个属性都和一个列关联，列名通过查询获取。
@Entity@SqlResultSetMapping(name="implicit", entities=@EntityResult( entityClass=org.hibernate.test.annotations.@NamedNativeQuery(
name="implicitSample",query="select * from SpaceShip", resultSetMapping="implicit")public class SpaceShip private String name; private String model; private
double speed; @Id public String getName() return name; public void setName(String name) this.name = name; @Column(name="model_txt") public String
getModel() return model; public void setModel(String model) this.model = model; public double getSpeed() return speed; public void setSpeed(double
speed) this.speed = speed;
上例中model1 属性绑定到model_txt 列，如果和相关实体关联设计到组合主键，那么应该使用 @FieldResult 注解来定义每个外键列。@FieldResult的名字组成：定义这种关系的属性名
字 +"." + 主键名或主键列或主键属性。
@Entity@SqlResultSetMapping(name="compositekey", entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class, fields =
@FieldResult(name="name", column ="name"), @FieldResult(name="model", column= "model"), @FieldResult(name="speed", column= "speed"), @FieldResult
(name="captain.firstname",column = "firstn"), @FieldResult(name="captain.lastname", column ="lastn"), @FieldResult(name="dimensions.length", column ="length"),
@FieldResult(name="dimensions.width", column ="width") ), columns = @ColumnResult(name ="surface"), @ColumnResult(name ="volume") ) @NamedNativeQuery
(name="compositekey", query="select name, model, speed, lnameas lastn, fname as firstn, length, width, length * width asresultSetMapping="compositekey"))
如果查询返回的是单个实体，或者打算用系统默认的映射，这种情况下可以不使用 resultSetMapping，而使用resultClass属性，例如：
@NamedNativeQuery(name="implicitSample", query="select * fromSpaceShip", resultClass=SpaceShip.class)public class
SpaceShip
Hibernate 独有的注解扩展
Hibernate 提供了与其自身特性想吻合的注解，org.hibernate.annotations package包含了这些注解。
实体
org.hibernate.annotations.Entity定义了 Hibernate 实体需要的信息。
• mutable: whetherthis entity is mutable or not 此实体是否可变
• dynamicInsert:allow dynamic SQL for inserts 用动态SQL新增
• dynamicUpdate: allow dynamic SQL forupdates 用动态SQL更新
• selectBeforeUpdate: Specifies thatHibernate should never perform an SQL UPDATE unless it is certain that anobject is actually modified.指明Hibernate从不运行SQL
Update，除非能确定对象已经被修改
• polymorphism:whether the entity polymorphism is of PolymorphismType.IMPLICIT (default) orPolymorphismType.EXPLICIT 指出实体多态是PolymorphismType.IMPLICIT(默认)还
是PolymorphismType.EXPLICIT
• optimisticLock:optimistic locking strategy (OptimisticLockType.VERSION, OptimisticLockType.NONE,OptimisticLockType.DIRTY or OptimisticLockType.ALL) 乐观锁策略
标识符
@org.hibernate.annotations.GenericGenerator和@org.hibernate.annotations.GenericGenerators允许你定义hibernate特有的标识符。
@Id@GeneratedValue(generator="system-uuid")@GenericGenerator(name="system-uuid",strategy = "uuid")public String getId()@Id@GeneratedValue(generator="hibseq")
@GenericGenerator(name="hibseq",strategy = "seqhilo", parameters = @Parameter(name="max_lo", value= "5"), @Parameter(name="sequence",value="heybabyhey")
)public Integer getId()
新例子
@GenericGenerators( @GenericGenerator( name="hibseq", strategy = "seqhilo", parameters = @Parameter(name="max_lo", value ="5"), @Parameter
(name="sequence", value="heybabyhey") ), @GenericGenerator(...) )
自然ID
用 @NaturalId 注解标识
公式
让数据库而不是JVM进行计算。
@Formula("obj_length* obj_height * obj_width")public longgetObjectVolume()
索引
通过在列属性(property)上使用@Index注解，可以指定特定列的索引，columnNames属性(attribute)将随之被忽略。
@Column(secondaryTable="Cat1")@Index(name="story1index")public StringgetStoryPart1() return storyPart1;
辨别符
@Entity@DiscriminatorFormula("casewhen forest_type is null then 0 else forest_type end")public class Forest ...
9、Hibernate验证注解
注解
适用类型
说明
示例
@Pattern
String
通过正则表达式来验证字符串
@attern(regex=”[a-z]6”)
@Length
String
验证字符串的长度
@length(min=3,max=20)
@Email
String
验证一个Email地址是否有效
@email
@Range
Long
验证一个整型是否在有效的范围内
@Range(min=0,max=100)
@Min
Long
验证一个整型必须不小于指定值
@Min(value=10)
@Max
Long
验证一个整型必须不大于指定值
@Max(value=20)
@Size
集合或数组
集合或数组的大小是否在指定范围内
@Size(min=1,max=255)
以上每个注解都可能性有一个message属性，用于在验证失败后向用户返回的消息，还可以三个属性上使用多个注解
10、 @Transiten表示此属性与表没有映射关系，是一个暂时的属性
11、@Cache(usage= CacheConcurrencyStrategy.READ_WRITE)表示此对象应用缓存
12、@Temporal(TemporalType.DATE)：
如果属性是时间类型，因为数据表对时间类型有更严格的划分，所以必须指定具体时间类型，如④所示。在javax.persistence.TemporalType枚举中定义了3种时间类型：
通过 @Temporal 定义映射到数据库的时间精度：
@Temporal(TemporalType.DATE) 日期
@Temporal(TemporalType.TIME) 时间
@Temporal(TemporalType.TIMESTAMP) 两者兼具
@Temporal只是起映射作用
13、@Transient
@Target(METHOD, FIELD) @Retention(RUNTIME)
public @interface Transient
指明一个属性或方法不能持久化
14、@TableGenerator：表生成器，将当前主键的值单独保存到一个数据库表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式是很常用的。这种方法生成主键的策略
可以适用于任何数据库，不必担心不同数据库不兼容造成的问题。大象推荐这种方式管理主键，很方便，集中式管理表的主键，而且更换数据库不会造成很大的问题。各属性含义如下：
name：表示该表主键生成策略的名称，这个名字可以自定义，它被引用在@GeneratedValue中设置的"generator"值中
table：表示表生成策略所持久化的表名，说简单点就是一个管理其它表主键的表，本例中，这个表名为GENERATOR_TABLE
pkColumnName：表生成器中的列名，用来存放其它表的主键键名，这个列名是与表中的字段对应的
pkColumnValue：实体表所对应到生成器表中的主键名，这个键名是可以自定义滴
valueColumnName：表生成器中的列名，实体表主键的下一个值，假设EMPLOYEE表中的EMPLOYEE_ID最大为2，那么此时，生成器表中与实体表主键对应的键名值则为3
allocationSize：表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50
15、 @Lob 声明字段为 Clob 或 Blob 类型
16、@Access
JPA的@Access批注,其值定义在AccessType枚举类中,包括AccessType.FIELD及AccessType.PROPERTY,这两个类型定义了实体的访问模式(Access mode)。
JPA注解有两种方式来指定持久化实体状态:
1）.字段访问,类似于
[java] view plain copy- @Column(length = 20, nullable = false)
- private String userName;
2）.属性访问,类似于 [java] view plain copy
- @Column(length = 20, nullable = false)
- public String getUserName()
- return userName;
当持久化实体通过字段访问(即注解到字段上)时,JPA只关注字段而不关注getter和setter方法,即使有另外的getter和setter方法,也不会去关注。这样JPA默认该实体访问类型是AccessType.FIELD类型,这个类型是最高级别,即使在实体上增加注解@Access(AccessType.PROPERTY)也不会起作用。
当持久化实体通过属性访问(即注解到getter方法上)时,JPA只关注getter和setter方法而不关注字段,即使写有其他的字段(没有写getter和setter方法),也不会去关注。这样JPA默认该实体访问类型是AccessType.PROPERTY类型,这个类型是最高级别,即使在实体上增加注解@Access(AccessType.FIELD)也不会起作用。
到这里,似乎@Access注解没起到什么作用,实际上,在通常应用中还会有第三种方式,即混合访问(不常用)。
3.混合访问,实现混合访问模式,必须达到三个条件:
(1)在实体上显式的标记类的访问模式,通过@Access注解进行显式的指定。(否则在字段和属性上都进行了注解,JPA不知道访问哪个模式有效)
(2)在其他(正常注解之外的)字段或属性上通过@Access注解与类级别相反的访问模式。
(3)在其他(正常注解之外的)属性或者字段(第二步的注解写在字段上,此处则指属性,相反亦然)上注解@Transient(临时的)。(使其不会被正常的访问模式持久化)
类似于:
[java] view plain copy- package org.eleazar.entity;
- import java.io.Serializable;
- import javax.persistence.Access;
- import javax.persistence.AccessType;
- import javax.persistence.Column;
- import javax.persistence.Entity;
- import javax.persistence.Id;
- import javax.persistence.Transient;
- /**
- * 预期:数据库表中有三个字段,分别是id(主键),userName,password(30个长度)
- * 实际:数据库表中有三个字段,分别是id(主键),userName,password(30个长度)
- */
- @Entity
- @Access(AccessType.FIELD)
- public class UserInfo8 implements Serializable
- /**
- * 注释内容
- */
- private static final （002）Spring Boot之常用注解及其说明