2. 程式人生 > >Spring註解之實體類常用註解

Spring註解之實體類常用註解

阿新 • • 發佈：2019-01-26 
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的名字。
@

[email protected](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
[email protected]() { ... } //transient propertyString getName() {...} // persistent [email protected] 


getLength() { ...} // persistent [email protected](fetch =FetchType.LAZY)StringgetDetailedComment() { ... } // persistent [email protected](TemporalType.TIME)


Java.util.DategetDepartureTime() { ... } // persistent [email protected](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
@[email protected](strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")public Integer getId(){ ... }
@[email protected](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 [email protected](     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 [email protected](     name="SEQ_GEN",     sequenceName="my_sequence",     allocationSize=20)
 
The next example showsthe definition of a sequence generator in a class scope:
@[email protected](    name="SEQ_STORE",    sequenceName="my_sequence")public class Storeimplements Serializable {   private Long id;   


@[email protected](strategy=GenerationType.SEQUENCE,generator="SEQ_STORE")   public Long getId() { return id; }}
Store類使用名為my_sequence的sequence，並且SEQ_STORE生成器對於其他類是不可見的。
7、通過下面語法，你可以定義組合鍵。
•將元件類註解為@Embeddable，並將元件的屬性註解為 @Id•將元件的屬性註解為@EmbeddedId•將類註解為@IdClass，並將該實體中所有主鍵的屬性都註解為 @Id
@[email protected](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}
 
@[email protected](name="id.channel", joinColumns [email protected](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 註解來定義所選的之類策略。
每個類一張表
@[email protected](strategy= InheritanceType.TABLE_PER_CLASS)public class Flightimplements Serializable {
有缺點，如多型查詢或關聯。Hibernate使用 SQL Union 查詢來實現這種策略。這種策略支援雙向的一對多關聯，但不支援IDENTIFY 生成器策略，因為ID必須在多個表間共享。一旦使用


就不能使用AUTO和IDENTIFY生成器。
每個類層次結構一張表
@[email protected](strategy=InheritanceType.SINGLE_TABLE)@DiscriminatorColumn(    name="planetype",    discriminatorType=DiscriminatorType.STRING)


@DiscriminatorValue("Plane")public class Plane {... }
@[email protected]("A320")public class A320extends Plane { ... }
整個層次結構中的所有父類和子類屬性都對映到同一個表中，他們的例項通過一個辨別符列（discriminator）來區分。
Plane 是父類。@DiscriminatorColumn註解定義了辨別符列。對於繼承層次結構中的每個類,@DiscriminatorValue 註解指定了用來辨別該類的值。辨別符列名字預設為DTYPE，其預設值為


實體名。其型別為DiscriminatorType.STRING。
連線的子類
@[email protected](strategy=InheritanceType.JOINED)public class Boatimplements Serializable { ... }
@Entitypublic class Ferryextends Boat { ... }
@[email protected](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 [email protected](name="FLIGHT_ID"),       


inverseJoinColumns [email protected](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",   [email protected](name="EMPER_ID"),   [email protected]


(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 引數可以指定某個列所屬的特定表。
@[email protected](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>[email protected]@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, 其中每個屬性都和一個列關聯，列名通過查詢獲取。
@[email protected](name="implicit",  [email protected](   entit[email protected](      


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的名字組成：定義這種關係的屬性名


字 +"." + 主鍵名或主鍵列或主鍵屬性。
@[email protected](name="compositekey", [email protected](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特有的識別符號。
@[email protected](generator="system-uuid")@GenericGenerator(name="system-uuid",strategy = "uuid")public String getId(){@[email protected](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;}
辨別符
@[email protected]("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）.欄位訪問,類似於

  1. @Column(length = 20, nullable = false)  
  2. private String userName;  
通過欄位來獲取或設定實體的狀態,getter和setter方法可能存在或不存在。這樣JPA預設的訪問型別為AccessType.FIELD
2）.屬性訪問,類似於
  1. @Column(length = 20, nullable = false)  
  2. public String getUserName()  
  3. {  
  4.     return userName;  
  5. }  
持久化屬性必須有getter和setter方法,屬性的型別由getter方法的返回型別決定,同時必須與傳遞到setter方法的單個引數的型別相同。這樣JPA預設的訪問型別為AccessType.PROPERTY

當持久化實體通過欄位訪問(即註解到欄位上)時,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(臨時的)。(使其不會被正常的訪問模式持久化)

類似於:

  1. package org.eleazar.entity;  
  2. import java.io.Serializable;  
  3. import javax.persistence.Access;  
  4. import javax.persistence.AccessType;  
  5. import javax.persistence.Column;  
  6. import javax.persistence.Entity;  
  7. import javax.persistence.Id;  
  8. import javax.persistence.Transient;  
  9. /** 
  10.  * 預期:資料庫表中有三個欄位,分別是id(主鍵),userName,password(30個長度) 
  11.  * 實際:資料庫表中有三個欄位,分別是id(主鍵),userName,password(30個長度) 
  12.  */
  13. @Entity
  14. @Access(AccessType.FIELD)  
  15. publicclass UserInfo8 implements Serializable  
  16. {  
  17.     /** 
  18.      * 註釋內容 
  19.      */
  20.     privatestaticfinallong serialVersionUID = 8694447074089053604L;  
  21.     @Id
  22.     private Integer id;  
  23.     private String userName;  
  24.     @Transient
  25.     private String password;  
  26.     public Integer getId()  
  27.     {  
  28.         return id;  
  29.     }  
  30.     publicvoid setId(Integer id)  
  31.     {  
  32.         this.id = id;  
  33.     }  
  34.     public String getUserName()  
  35.     {  
  36.         return userName;  
  37.     }  
  38.     publicvoid setUserName(String userName)  
  39.     {  
  40.         this.userName = userName;  
  41.     }  
  42.     @Access(AccessType.PROPERTY)  
  43.     @Column(length = 30)  
  44.     public String getPassword()  
  45.     {  
  46.         return password;  <

相關推薦

Spring註解之實體類常用註解

import org.hibernate.annotations.AccessType; import org.hibernate.annotations.*; import javax.persistence.*; import javax.persistence.En

spring boot 實體類常用註解範例

定義User.java實體類 @Data@Entitypublic class User { @Id @GeneratedValue private Long id; @Col

SpringDataJpa基礎篇1:實體類常用註解

SpringDataJpa下的實體類使用註解都是javax.persistence包下的註解。 1、實體類中常用註解 【1、@Entity和@Table(name="")註解】        @Entity和@Table(name="")註解：表明

Jpa 實體類常用註解

記錄一些spring-data-jpa常用的註解,程式碼執行環境：spring boot + spring-data-jpa 1. @Entity 被Entity標註的實體類將會被JPA管理控制，在程式執行時，JPA會識別並對映到指定的資料庫

Spring註解開發-全面解析常用註解使用方法之生命周期

統一 ota tco conf struct 賦值 組件註冊 功能 pri 本文github位置:https://github.com/WillVi/Spring-Annotation/ 往期文章：Spring註解開發-全面解析常用註解使用方法之組件註冊 bean生命周期

spring中 hibernate實體類註解

@Autowired宣告在屬性上,表示這個屬性需要注入 然後在你的applicationContext.xml中加入以下配製 <context:component-scan base-pack

Hibernate_實體類_註解_大全

ipp com ndt hiberna eip inf 實體 userinfo aix 頰f詒諫趙a舜42pfvhttp://tushu.docin.com/kikko96829 rhx苛滓8鄙06窩84蕾rhttp://weibo.com/u/6370723660 2

Spring Boot開發中的常用註解的介紹

一、簡言 在spring boot的開發中常常會用到註解 @RequestParam、@PathVariable、@RequestBody、@PageableDefault、@RequestMapping、@GetMapping 和 @PostMapping定義提供給前端的介面函式。下面

Spring Data Elasticsearch篇(1):常用註解

1、註解@Document 1.1、@Document原始碼 @Persistent @Inherited @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface Document {

SpringBoot實體類驗證註解

Hibernate Validator 定義 Annotation 檔案 @Target( {ElementType.METHOD, ElementType.FIELD} ) //標註在方法和屬性上

註解配置實體類出現錯誤：Could not determine type for: java.util.Set, at table

org.hibernate.MappingException: Could not determine type for: java.util.Set, at table: bs_merchant, for columns: [org.hibernate.mapping.Co

Spring Boot（5）---常用註解總結

Spring Boot常用註解總結 @RestController和@RequestMapping註解 @RestController註解，它繼承自@Controller註解。4.0之前的版本，Spring MVC的元件都使用@Controller來標識當前類是一個控制器

使用Java註解將實體類轉化為sql字串

首先是定義一個實體類，如下 /* * 定義使用者，通過註解對映到資料庫 */ @Table("user") public class User { @Column("id") private int id; @Column("username") privat

JPA註解的使用,用於實體類的註解

1、 @Entity(name=”EntityName”)       表示該類是一個可持化的實體。當在容器中時，伺服器將會首先載入所有標註了@Entity註釋的實體類，其中@Entity中的“name”屬性表示實體名稱，若不作設定，預設為標註實體類的名稱（注意大小寫與系統的關係。）。 @Entity

hibernate tool 從資料庫逆向生成Hibernate帶註解的實體類

1. 首先，要在eclipse中採用自帶的資料庫管理器（Data Management），連通你的資料庫：   然後選擇資料庫，這裡用的oracle，然後給個名字，如MyOracle。 點選下圖中按鈕，新建一個數據庫驅動的配置。 選擇資料庫版本，這裡是oracle

spring AOP 之二：@AspectJ註解的3種配置

@AspectJ相關文章 與 AspectJ 相同的是，Spring AOP 同樣需要對目標類進行增強，也就是生成新的 AOP 代理類；與 AspectJ 不同的是，Spring AOP 無需使用任何特殊命令對 Java 原始碼進行編譯，它採用執行時動態地、在記憶體中臨時生成“代理類”的方式

MyEclipse通過Oracle資料庫表反轉生成實體類(包括註解)，hibernate反向生成

在開發專案的階段，當專案的資料庫表設計完畢之後,一般都是存在很多資料庫表,這時候我們會想起使用MyEclipse的反轉功能,站在巨人的肩膀上會減少我們的開發的時間; 反轉生成實體類大致分為3步。 第一步：通過Myeclipse連線資料庫

spring為何在有的類中註解會失效

      今天碰到一個特別噁心的問題，就是我想從配置檔案讀取配置檔案的值，但是死活注入不進來，我在Controller類中去試了下，發現可以注入進來，我在springboot工程的啟動類中試了下，發現也可以注入進來，一直想不通是啥原因讓我在這個handler類中死活注入不成

JPA學習 —— 第七課、Eclipse使用JPA Tools反向生成帶註解的實體類

1.首先在Eclipse建立資料庫連線 先開啟Data Source Explorer視窗 然後在Database Connection右擊新建一個連結,進入這裡 我這裡用的是mysql資料庫，選擇點選Next 然後出現這個面板,點選紅圈圈裡

由資料表反向生成帶註解的實體類

1、通過myeclipse，開啟MyEclipse Database Explorer模式，在裡面新建連結； 單擊finish，即可完成，雙擊新建的mysql，看是否能開啟，也可以在第一個頁面的test driver測試是否連結成功； 2、返回Mye