當前位置:
首頁 >
前端技术
> javascript
>内容正文
javascript
Hibernate注解使用以及Spring整合
生活随笔
收集整理的這篇文章主要介紹了
Hibernate注解使用以及Spring整合
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
(1)
簡介:
在過去幾年里,Hibernate不斷發展,幾乎成為Java數據庫持久性的事實標準。它非常強大、靈活,而且具備了優異的性能。在本文中,我們將了解如何使用Java 5 注釋來簡化Hibernate代碼,并使持久層的編碼過程變得更為輕松。
傳統上,Hibernate的配置依賴于外部 XML 文件:數據庫映射被定義為一組 XML 映射文件,并且在啟動時進行加載。
? ?在最近發布的幾個Hibernate版本中,出現了一種基于 Java 5 注釋的更為巧妙的新方法。借助新的 Hibernate Annotation 庫,即可一次性地分配所有舊映射文件——一切都會按照您的想法來定義——注釋直接嵌入到您的Java 類中,并提供一種強大及靈活的方法來聲明持久性映射。即利用hibernate注解后,可不用定義持久化類對應的*.hbm.xml文件,直接以注解方式寫入在持久化類中來實現。Hibernate annotation使用了ejb JPA的注解,所以,下面安裝配置hibernate annotation環境時,需要導入ejb的包。許多網上的資料都是jpa hibernate annotation方面的資料。(2)
安裝 Hibernate Annotation
第一步,
環境與jar包:
要使用 Hibernate Annotation,您至少需要具備 Hibernate 3.2和Java 5。可以從 Hibernate 站點下載 Hibernate 3.2 和 Hibernate Annotation庫。除了標準的 Hibernate JAR 和依賴項之外,您還需要 Hibernate Annotations .jar 文件(hibernate-annotations.jar)、Java 持久性 API (lib/ejb3-persistence.jar)。添加hibernate3.2.jar,hibernate-annotations- 3.3.0.jar,hibernate-commons-annotations.jar和ejb3-persistence.jar 。這樣就可以使用hibernate的annotation了。
如果您正在使用 Maven,只需要向 POM 文件添加相應的依賴項即可,如下所示:
? ?...
? ?<dependency>
? ? ?<groupId>org.hibernate</groupId>
? ? ?<artifactId>hibernate</artifactId>
? ? ?<version>3.2.1.ga</version>
? ?</dependency>
? ?<dependency>
? ? ?<groupId>org.hibernate</groupId>
? ? ?<artifactId>hibernate-annotations</artifactId>
? ? ?<version>3.2.0.ga</version>
? ?</dependency>
? ?<dependency>
? ? ?<groupId>javax.persistence</groupId>
? ? ?<artifactId>persistence-api</artifactId>
? ? ?<version>1.0</version>
? ?</dependency>第二步,
獲取 Hibernate 會話工廠。盡管無需驚天的修改,但這一工作與使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 類來建立會話工廠:
sessionFactory = new AnnotationConfiguration().buildSessionFactory();
第三步,
盡管通常使用 <mapping> 元素來聲明持久性類,您還是需要在 Hibernate 配置文件(通常是 hibernate.cfg.xml)中聲明持久性類:
<!DOCTYPE hibernate-configuration PUBLIC
? ?"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
? ?"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
? ? ? ?<hibernate-configuration>
? ? ? ? ?<session-factory>
? ? ? ? ? ?<mapping class="com.onjava.modelplanes.domain.PlaneType"/>
? ? ? ? ? ?<mapping class="com.onjava.modelplanes.domain.ModelPlane"/>
? ? ? ? ?</session-factory>
? ? ? ?</hibernate-configuration>
近期的許多 Java 項目都使用了輕量級的應用框架,例如 Spring。如果您正在使用 Spring 框架,可以使用AnnotationSessionFactoryBean 類輕松建立一個基于注釋的 Hibernate 會話工廠,如下所示:
<!-- Hibernate session factory -->
?<bean id="sessionFactory"
? ? ? class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
? <property name="dataSource">
? ? <ref bean="dataSource"/>
? </property>
? <property name="hibernateProperties">
? ? <props>
? ? ? <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
? ? ? <prop key="hibernate.hbm2ddl.auto">create</prop>
? ? ? ...
? ? </props>
? </property><!--指明使用標注的實體類-->
? <property name="annotatedClasses">
? ? <list>
? ? ? <value>com.onjava.modelplanes.domain.PlaneType</value>
? ? ? <value>com.onjava.modelplanes.domain.ModelPlane</value>
? ? ? ...
? ? </list>
? </property><!--當然也可以不使用上面這種指定的方式,而使用包掃描的方式做為替換,推薦這種--><property name="packagesToScan">
? ? ? <list>
? ? ? ? ? ?<value>com.onjava.modelplanes.domain.*</value>
? ? ? ?</list>
? ? ?</property>
</bean>(3)
hibernate Annotation標簽的使用:[1]
1.帶注釋的持久性類也是普通 POJO,它們只是具備了持久性注釋的普通 POJO 。2.事實上,您既可以保持字段的持久性(注釋寫在成員變量之上),也可以保持屬性(注釋寫在getter方法之上)的持久性。3.常用的hibernate annotation標簽如下:@Entity ? ? ? ? ? ? ?--注釋聲明該類為持久類。將一個Javabean類聲明為一 個實體的數據庫表映射類,最好實現序列化.此時,默認情況下,所有的類屬性都為映射到數據表的持久性字段.若在類中,添加另外屬性,而非映射來數據庫的, 要用下面的Transient來注解.
@Table(name="promotion_info") ? ? ?--持久性映射的表(表名="promotion_info).@Table是類一級的注解,定義在@Entity下,為實體bean映射表,目錄和schema的名字,默認為實體bean的類名,不帶包名.
@Id--注釋可以表明哪種屬性是該類中的獨特標識符(即相當于數據表的主鍵)。
@GeneratedValue ? --定義自動增長的主鍵的生成策略.
@Transient ? ? ? ? ? ? --將忽略這些字段和屬性,不用持久化到數據庫.適用于,在當前的持久類中,某些屬性不是用于映射到數據表,而是用于其它的業務邏輯需要,這時,須將這些屬性進行transient的注解.否則系統會因映射不到數據表相應字段而出錯.
@Temporal(TemporalType.TIMESTAMP)--聲明時間格式
@Enumerated ? ? ? ? --聲明枚舉
@Version ? ? ? ? ? ? ? ?--聲明添加對樂觀鎖定的支持
@OneToOne ? ? ? ? ? ?--可以建立實體bean之間的一對一的關聯
@OneToMany ? ? ? ? ?--可以建立實體bean之間的一對多的關聯
@ManyToOne ? ? ? ? ?--可以建立實體bean之間的多對一的關聯
@ManyToMany ? ? ? ?--可以建立實體bean之間的多對多的關聯
@Formula ? ? ? ? ? ? ? --一個SQL表達式,這種屬性是只讀的,不在數據庫生成屬性(可以使用sum、average、max等)
@OrderBy ? ? ? ? ? ? ? --Many端某個字段排序(List)1.2
Hibernate 能夠出色地自動生成主鍵。Hibernate/EBJ 3 注釋也可以為主鍵的自動生成提供豐富的支持,允許實現各種策略。
其生成規則由@GeneratedValue設定的.這里的@id和@GeneratedValue都是JPA的標準用法, JPA提供四種標準用法,由@GeneratedValue的源代碼可以明顯看出.
JPA提供的四種標準用法為TABLE,SEQUENCE,IDENTITY,AUTO.
TABLE:使用一個特定的數據庫表格來保存主鍵。
SEQUENCE:根據底層數據庫的序列來生成主鍵,條件是數據庫支持序列。
IDENTITY:主鍵由數據庫自動生成(主要是自動增長型)
AUTO:主鍵由程序控制。在指定主鍵時,如果不指定主鍵生成策略,默認為AUTO。
@Id相當于@Id
@GeneratedValue(strategy = GenerationType.AUTO)identity:使用SQL Server 和 MySQL 的自增字段,這個方法不能放到 Oracle 中,Oracle 不支持自增字段,要設定sequence(MySQL 和 SQL Server 中很常用)。Oracle就要采用sequence了.同時,也可采用uuid,native等其它策略.(相關用法,上網查詢)[2]第一個持久性類
@Entity
@Table(name="T_MODEL_PLANE")
publicclass ModelPlane ? ?implements Serializable {
? ? ? ?@Id
? ? ? ?@Column(name="PLANE_ID") ? ?
? ? ? ?@GeneratedValue(strategy=GenerationType.AUTO) //注解于屬性中
/*
對于oracle想使用各自的Sequence,設置如下: ? ? ? ?
@GeneratedValue(strategy = GenerationType.AUTO,generator="PROMOTION_SEQ") ? ? ? ?
@SequenceGenerator(name="PROMOTION_SEQ",sequenceName="PROMOTION_SEQ") ? ?另外:對于自動增長后,在數據表中的相應字段,要設置字段為auto_increment.
*/
private Long id;
private String name;//注解寫于getter方法之上.請見下.
//DATE ? ? ? ? ? ?- java.sql.Date ? ? ? ?
//TIME ? ? ? ? ? ?- java.sql.Time ? ? ? ?
//TIMESTAMP - java.sql.Timestamp ? ? ? ?
? ? @Temporal(TemporalType.TIMESTAMP) ? ? ? ?
? ? @Column(name="start_time") ? ? ? ?
private Date startTime; ? ?
//顯示0 隱藏1 ? ? ? ?
publicstaticenum DisplayType {顯示,隱藏} ? ? ? ?
? ? @Enumerated(value = EnumType.ORDINAL)//ORDINAL序數 ? ? ? ?
private DisplayType displayType = DisplayType.顯示; ? ?
//1.sql語句中的字段和表名都應該和數據庫相應,而不是類中的字段, ? ? ? ?
//若帶有參數如la.id= id,這個=id才是類中屬性 ? ? ? ?
//2.操作字段一定要用別名 ? ? ? ?
? ? @Formula(select COUNT(la.id) from largess la) ? ? ? ?
privateint count; ? ?
//注解于方法中
? ? ? ?@Column(name="PLANE_ID", length=80, nullable=true) //較詳細定義
public String getName() {
return name;
? ? ? ?}
publicvoid setName(String name) {
this.name = name;
? ? ? ?}
其它的setter,getter省略......
}
該內容將映射到下表中:
CREATE TABLE T_MODEL_PLANE
(
? ? ? ?PLANE_ID long,
? ? ? ?PLANE_NAME varchar
? ? ? ?其它字段省略...
) ? ?默認情況下,Hibernate 會將持久類以匹配的名稱映射到表和字段中。例如,下例中,若不用注解,則會映射到如下一表中:
CREATE TABLE MODELPLANE
(
? ?ID long,
? ?NAME varchar其它字段省略...
)[3]
一對多注解:1.在一對多注解中,會用到:"一"方:
@OneToMany --> mappedBy:"多"方的關聯屬性(被控方)
"多"方:
@ManyToOne --> @JoinColumn,"多"方定義的外鍵字段.如數據表定義外鍵如下:FOREIGN KEY (classid) REFERENCES classes(id)則:@JoinColumn(name="classid") 2.在雙向關聯中,有且僅有一端作為主體(owner)端存在:主體端負責維護聯接列(即更新),對于不需要維護這種關系的從表則通過mappedNy屬性進行聲明。mappedBy的值指向另一主體的關聯屬性。例子中,mappedBy的值為classes。附加說明:mappedBy相當于過去的inverse="true".
inverse=false的side(side其實是指inverse=false所位于的class元素)端有責任維護關系,而inverse=true端無須維護這些關系。3.cascade與fetch使用說明:CascadeCascadeType.PERSIST (級聯新建)
CascadeType.REMOVE ?(級聯刪除)
CascadeType.REFRESH (級聯刷新)
CascadeType.MERGE ? (級聯更新)中選擇一個或多個。
CascadeType.ALL fetch屬性:關聯關系獲取方式,即是否采用延時加載。
LAZY(默認值)采用延時加載,查詢數據時,不一起查詢關聯對象的數據。而是當訪問關聯對象時(如:getStudnets()時)才觸發相應的查詢操作,獲取關聯對象數據。
EAGER:是在查詢數據時,也直接一起獲取關聯對象的數據。package oneToMany;
import java.util.Set;
import javax.persistence.*;
/*
注意導入時,是導入:import javax.persistence.*; ? ?
非導入org.hibernate的相關類:import org.hibernate.annotations.Entity;
*/
@Entity
@Table(name="classes")
publicclass Classes implements Serializable {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint id;
private String name;
?@OneToMany(cascade=CascadeType.ALL,mappedBy="classes") ? ?
private Set<Student> students;
//getter,setter省略
}
package oneToMany;
import javax.persistence.*;
@Entity
@Table(name="student")
publicclass Student implements Serializable ?{
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint sid;
private String sname;
//若有多個cascade,可以是:{CascadeType.PERSIST,CascadeType.MERGE}
?@ManyToOne(cascade={CascadeType.ALL}) ? ? ? ?
?@JoinColumn(name="classid") ? ? //student類中對應外鍵的屬性:classid
private Classes classes;
//getter,setter省略
}
publicclass TestOneToMany {
/*
CREATE TABLE ? ?student ( ? ?--要定義外鍵!!!!!!!
? ?`sid` double NOT NULL auto_increment,
? ?`classid` double NULL,
? ?`sname` varchar(255) NOT NULL,
? ?PRIMARY KEY ? ?(sid),
? ?INDEX par_ind (classid),
? ?FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
*/
publicstaticvoid main(String[] args) throws SQLException ? ?
?{
try
? ?{
? ? ?SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
? ? ?Session session=sf.openSession();
? ? ?Transaction tx=session.beginTransaction(); ? ? ? ? /*因為mappedBy是定義在classes中,即classes類不負責維護級聯關系.即維護者是student.所以,1.要將clsses的數據,賦給student,即用student的setClasses()方法去捆定class數據;2.在進行數據插入/更新session.save()/session.update()時,最后操作的是student.*/
? ? ?Classes classes=new Classes();
? ? ?classes.setName("access");
? ? ?Student st1=new Student();
? ? ?st1.setSname("jason");
? ? ?st1.setClasses(classes);
? ? ?session.save(st1);
? ? ?Student st2=new Student();
? ? ?st2.setSname("hwj");
? ? ?st2.setClasses(classes);
? ? ?session.save(st2);
? ? ?tx.commit();/* 輸出如下:Hibernate: insert into classes (name) values (?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)*//*因為一端維護關系另一端不維護關系的原因,我們必須注意避免在應用中用不維護關系的類(class)建立關系,因為這樣建立的關系是不會在數據庫中存儲的。如上的代碼倒過來,則插入時,student的外鍵值為空.如下:*/// ? ? ?Student st1=new Student();
// ? ? ?st1.setSname("jason");
// ? ? ?session.save(st1);
// ? ? ? ?
// ? ? ?Student st2=new Student();
// ? ? ?st2.setSname("hwj");
// ? ? ?session.save(st2);
// ? ? ? ?
// ? ? ?Set<Student> students=new HashSet<Student>();
// ? ? ?students.add(st1);
// ? ? ?students.add(st2);
// ? ? ? ?
// ? ? ?Classes classes=new Classes();
// ? ? ?classes.setName("access");
// ? ? ?classes.setStudents(students);
// ? ? ?session.save(classes); /*輸出如下:
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)Hibernate: insert into classes (name) values (?)*/
? ?}
catch(HibernateException e)
? ?{
? ? ?e.printStackTrace(); ? ? ? ?
? ?}
?}
}[4]
多對多注解: 在多對多注解中,雙方都采用@ManyToMany.其中被控方,像一對多注解中設置一樣,也要設置mappedBy.其中主控方,不像一對多注解那樣,采用@joinColumn,而是采用@joinTable.如下:@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})其中,如上所說,mappedBy,相當于inverse="true".所以,在@joinTable中的inverseJoinColumns中定義的字段為mappedBy所在類的主鍵.
joinColumns定義的字段,就是當前類的主鍵.@Entity
@Table(name="jcourse")
publicclass Jcourse {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint cid;
private String cname;
?@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY ,mappedBy="courses")
private Set<Jstudent> students;
//setter,getter省略.... ? ?
}
@Entity
@Table(name="jstudent")
publicclass Jstudent {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint sid;
private String sname;
?@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.EAGER)
//inverseJoinColumns中對應的id為以下屬性course的對應id.
?@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})
private Set<Jcourse> courses;
//setter,getter省略.... ? ?
}
publicclass Test {
publicstaticvoid main(String[] args) {
try
? ?{
? ? ?SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
? ? ?Session session=sf.openSession();
? ? ?Transaction tx=session.beginTransaction();
? ? ?Jcourse course=new Jcourse();
? ? ?course.setCname("jason-english");
? ? ?session.save(course); //先各自保存.
? ? ?Jcourse course2=new Jcourse();
? ? ?course2.setCname("herry-english");
? ? ?session.save(course2);
? ? ?Set<Jcourse> courses=new HashSet<Jcourse>();
? ? ?courses.add(course);
? ? ?courses.add(course2);
? ? ?Jstudent student=new Jstudent();
? ? ?student.setSname("jason");
? ? ?student.setCourses(courses);
? ? ?session.save(student);// 要用非mapby定義的類(studet)來作為主者(會控制級聯關系),一對多,多對一也一樣道理.
//可以嘗試反過來.
? ? ?tx.commit();
? ?}
catch(HibernateException e)
? ?{
? ? ?e.printStackTrace(); ? ? ? ?
? ?}
?}
}
簡介:
在過去幾年里,Hibernate不斷發展,幾乎成為Java數據庫持久性的事實標準。它非常強大、靈活,而且具備了優異的性能。在本文中,我們將了解如何使用Java 5 注釋來簡化Hibernate代碼,并使持久層的編碼過程變得更為輕松。
傳統上,Hibernate的配置依賴于外部 XML 文件:數據庫映射被定義為一組 XML 映射文件,并且在啟動時進行加載。
? ?在最近發布的幾個Hibernate版本中,出現了一種基于 Java 5 注釋的更為巧妙的新方法。借助新的 Hibernate Annotation 庫,即可一次性地分配所有舊映射文件——一切都會按照您的想法來定義——注釋直接嵌入到您的Java 類中,并提供一種強大及靈活的方法來聲明持久性映射。即利用hibernate注解后,可不用定義持久化類對應的*.hbm.xml文件,直接以注解方式寫入在持久化類中來實現。Hibernate annotation使用了ejb JPA的注解,所以,下面安裝配置hibernate annotation環境時,需要導入ejb的包。許多網上的資料都是jpa hibernate annotation方面的資料。(2)
安裝 Hibernate Annotation
第一步,
環境與jar包:
要使用 Hibernate Annotation,您至少需要具備 Hibernate 3.2和Java 5。可以從 Hibernate 站點下載 Hibernate 3.2 和 Hibernate Annotation庫。除了標準的 Hibernate JAR 和依賴項之外,您還需要 Hibernate Annotations .jar 文件(hibernate-annotations.jar)、Java 持久性 API (lib/ejb3-persistence.jar)。添加hibernate3.2.jar,hibernate-annotations- 3.3.0.jar,hibernate-commons-annotations.jar和ejb3-persistence.jar 。這樣就可以使用hibernate的annotation了。
如果您正在使用 Maven,只需要向 POM 文件添加相應的依賴項即可,如下所示:
? ?...
? ?<dependency>
? ? ?<groupId>org.hibernate</groupId>
? ? ?<artifactId>hibernate</artifactId>
? ? ?<version>3.2.1.ga</version>
? ?</dependency>
? ?<dependency>
? ? ?<groupId>org.hibernate</groupId>
? ? ?<artifactId>hibernate-annotations</artifactId>
? ? ?<version>3.2.0.ga</version>
? ?</dependency>
? ?<dependency>
? ? ?<groupId>javax.persistence</groupId>
? ? ?<artifactId>persistence-api</artifactId>
? ? ?<version>1.0</version>
? ?</dependency>第二步,
獲取 Hibernate 會話工廠。盡管無需驚天的修改,但這一工作與使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 類來建立會話工廠:
sessionFactory = new AnnotationConfiguration().buildSessionFactory();
第三步,
盡管通常使用 <mapping> 元素來聲明持久性類,您還是需要在 Hibernate 配置文件(通常是 hibernate.cfg.xml)中聲明持久性類:
<!DOCTYPE hibernate-configuration PUBLIC
? ?"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
? ?"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
? ? ? ?<hibernate-configuration>
? ? ? ? ?<session-factory>
? ? ? ? ? ?<mapping class="com.onjava.modelplanes.domain.PlaneType"/>
? ? ? ? ? ?<mapping class="com.onjava.modelplanes.domain.ModelPlane"/>
? ? ? ? ?</session-factory>
? ? ? ?</hibernate-configuration>
近期的許多 Java 項目都使用了輕量級的應用框架,例如 Spring。如果您正在使用 Spring 框架,可以使用AnnotationSessionFactoryBean 類輕松建立一個基于注釋的 Hibernate 會話工廠,如下所示:
<!-- Hibernate session factory -->
?<bean id="sessionFactory"
? ? ? class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
? <property name="dataSource">
? ? <ref bean="dataSource"/>
? </property>
? <property name="hibernateProperties">
? ? <props>
? ? ? <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
? ? ? <prop key="hibernate.hbm2ddl.auto">create</prop>
? ? ? ...
? ? </props>
? </property><!--指明使用標注的實體類-->
? <property name="annotatedClasses">
? ? <list>
? ? ? <value>com.onjava.modelplanes.domain.PlaneType</value>
? ? ? <value>com.onjava.modelplanes.domain.ModelPlane</value>
? ? ? ...
? ? </list>
? </property><!--當然也可以不使用上面這種指定的方式,而使用包掃描的方式做為替換,推薦這種--><property name="packagesToScan">
? ? ? <list>
? ? ? ? ? ?<value>com.onjava.modelplanes.domain.*</value>
? ? ? ?</list>
? ? ?</property>
</bean>(3)
hibernate Annotation標簽的使用:[1]
1.帶注釋的持久性類也是普通 POJO,它們只是具備了持久性注釋的普通 POJO 。2.事實上,您既可以保持字段的持久性(注釋寫在成員變量之上),也可以保持屬性(注釋寫在getter方法之上)的持久性。3.常用的hibernate annotation標簽如下:@Entity ? ? ? ? ? ? ?--注釋聲明該類為持久類。將一個Javabean類聲明為一 個實體的數據庫表映射類,最好實現序列化.此時,默認情況下,所有的類屬性都為映射到數據表的持久性字段.若在類中,添加另外屬性,而非映射來數據庫的, 要用下面的Transient來注解.
@Table(name="promotion_info") ? ? ?--持久性映射的表(表名="promotion_info).@Table是類一級的注解,定義在@Entity下,為實體bean映射表,目錄和schema的名字,默認為實體bean的類名,不帶包名.
@Id--注釋可以表明哪種屬性是該類中的獨特標識符(即相當于數據表的主鍵)。
@GeneratedValue ? --定義自動增長的主鍵的生成策略.
@Transient ? ? ? ? ? ? --將忽略這些字段和屬性,不用持久化到數據庫.適用于,在當前的持久類中,某些屬性不是用于映射到數據表,而是用于其它的業務邏輯需要,這時,須將這些屬性進行transient的注解.否則系統會因映射不到數據表相應字段而出錯.
@Temporal(TemporalType.TIMESTAMP)--聲明時間格式
@Enumerated ? ? ? ? --聲明枚舉
@Version ? ? ? ? ? ? ? ?--聲明添加對樂觀鎖定的支持
@OneToOne ? ? ? ? ? ?--可以建立實體bean之間的一對一的關聯
@OneToMany ? ? ? ? ?--可以建立實體bean之間的一對多的關聯
@ManyToOne ? ? ? ? ?--可以建立實體bean之間的多對一的關聯
@ManyToMany ? ? ? ?--可以建立實體bean之間的多對多的關聯
@Formula ? ? ? ? ? ? ? --一個SQL表達式,這種屬性是只讀的,不在數據庫生成屬性(可以使用sum、average、max等)
@OrderBy ? ? ? ? ? ? ? --Many端某個字段排序(List)1.2
Hibernate 能夠出色地自動生成主鍵。Hibernate/EBJ 3 注釋也可以為主鍵的自動生成提供豐富的支持,允許實現各種策略。
其生成規則由@GeneratedValue設定的.這里的@id和@GeneratedValue都是JPA的標準用法, JPA提供四種標準用法,由@GeneratedValue的源代碼可以明顯看出.
JPA提供的四種標準用法為TABLE,SEQUENCE,IDENTITY,AUTO.
TABLE:使用一個特定的數據庫表格來保存主鍵。
SEQUENCE:根據底層數據庫的序列來生成主鍵,條件是數據庫支持序列。
IDENTITY:主鍵由數據庫自動生成(主要是自動增長型)
AUTO:主鍵由程序控制。在指定主鍵時,如果不指定主鍵生成策略,默認為AUTO。
@Id相當于@Id
@GeneratedValue(strategy = GenerationType.AUTO)identity:使用SQL Server 和 MySQL 的自增字段,這個方法不能放到 Oracle 中,Oracle 不支持自增字段,要設定sequence(MySQL 和 SQL Server 中很常用)。Oracle就要采用sequence了.同時,也可采用uuid,native等其它策略.(相關用法,上網查詢)[2]第一個持久性類
@Entity
@Table(name="T_MODEL_PLANE")
publicclass ModelPlane ? ?implements Serializable {
? ? ? ?@Id
? ? ? ?@Column(name="PLANE_ID") ? ?
? ? ? ?@GeneratedValue(strategy=GenerationType.AUTO) //注解于屬性中
/*
對于oracle想使用各自的Sequence,設置如下: ? ? ? ?
@GeneratedValue(strategy = GenerationType.AUTO,generator="PROMOTION_SEQ") ? ? ? ?
@SequenceGenerator(name="PROMOTION_SEQ",sequenceName="PROMOTION_SEQ") ? ?另外:對于自動增長后,在數據表中的相應字段,要設置字段為auto_increment.
*/
private Long id;
private String name;//注解寫于getter方法之上.請見下.
//DATE ? ? ? ? ? ?- java.sql.Date ? ? ? ?
//TIME ? ? ? ? ? ?- java.sql.Time ? ? ? ?
//TIMESTAMP - java.sql.Timestamp ? ? ? ?
? ? @Temporal(TemporalType.TIMESTAMP) ? ? ? ?
? ? @Column(name="start_time") ? ? ? ?
private Date startTime; ? ?
//顯示0 隱藏1 ? ? ? ?
publicstaticenum DisplayType {顯示,隱藏} ? ? ? ?
? ? @Enumerated(value = EnumType.ORDINAL)//ORDINAL序數 ? ? ? ?
private DisplayType displayType = DisplayType.顯示; ? ?
//1.sql語句中的字段和表名都應該和數據庫相應,而不是類中的字段, ? ? ? ?
//若帶有參數如la.id= id,這個=id才是類中屬性 ? ? ? ?
//2.操作字段一定要用別名 ? ? ? ?
? ? @Formula(select COUNT(la.id) from largess la) ? ? ? ?
privateint count; ? ?
//注解于方法中
? ? ? ?@Column(name="PLANE_ID", length=80, nullable=true) //較詳細定義
public String getName() {
return name;
? ? ? ?}
publicvoid setName(String name) {
this.name = name;
? ? ? ?}
其它的setter,getter省略......
}
該內容將映射到下表中:
CREATE TABLE T_MODEL_PLANE
(
? ? ? ?PLANE_ID long,
? ? ? ?PLANE_NAME varchar
? ? ? ?其它字段省略...
) ? ?默認情況下,Hibernate 會將持久類以匹配的名稱映射到表和字段中。例如,下例中,若不用注解,則會映射到如下一表中:
CREATE TABLE MODELPLANE
(
? ?ID long,
? ?NAME varchar其它字段省略...
)[3]
一對多注解:1.在一對多注解中,會用到:"一"方:
@OneToMany --> mappedBy:"多"方的關聯屬性(被控方)
"多"方:
@ManyToOne --> @JoinColumn,"多"方定義的外鍵字段.如數據表定義外鍵如下:FOREIGN KEY (classid) REFERENCES classes(id)則:@JoinColumn(name="classid") 2.在雙向關聯中,有且僅有一端作為主體(owner)端存在:主體端負責維護聯接列(即更新),對于不需要維護這種關系的從表則通過mappedNy屬性進行聲明。mappedBy的值指向另一主體的關聯屬性。例子中,mappedBy的值為classes。附加說明:mappedBy相當于過去的inverse="true".
inverse=false的side(side其實是指inverse=false所位于的class元素)端有責任維護關系,而inverse=true端無須維護這些關系。3.cascade與fetch使用說明:CascadeCascadeType.PERSIST (級聯新建)
CascadeType.REMOVE ?(級聯刪除)
CascadeType.REFRESH (級聯刷新)
CascadeType.MERGE ? (級聯更新)中選擇一個或多個。
CascadeType.ALL fetch屬性:關聯關系獲取方式,即是否采用延時加載。
LAZY(默認值)采用延時加載,查詢數據時,不一起查詢關聯對象的數據。而是當訪問關聯對象時(如:getStudnets()時)才觸發相應的查詢操作,獲取關聯對象數據。
EAGER:是在查詢數據時,也直接一起獲取關聯對象的數據。package oneToMany;
import java.util.Set;
import javax.persistence.*;
/*
注意導入時,是導入:import javax.persistence.*; ? ?
非導入org.hibernate的相關類:import org.hibernate.annotations.Entity;
*/
@Entity
@Table(name="classes")
publicclass Classes implements Serializable {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint id;
private String name;
?@OneToMany(cascade=CascadeType.ALL,mappedBy="classes") ? ?
private Set<Student> students;
//getter,setter省略
}
package oneToMany;
import javax.persistence.*;
@Entity
@Table(name="student")
publicclass Student implements Serializable ?{
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint sid;
private String sname;
//若有多個cascade,可以是:{CascadeType.PERSIST,CascadeType.MERGE}
?@ManyToOne(cascade={CascadeType.ALL}) ? ? ? ?
?@JoinColumn(name="classid") ? ? //student類中對應外鍵的屬性:classid
private Classes classes;
//getter,setter省略
}
publicclass TestOneToMany {
/*
CREATE TABLE ? ?student ( ? ?--要定義外鍵!!!!!!!
? ?`sid` double NOT NULL auto_increment,
? ?`classid` double NULL,
? ?`sname` varchar(255) NOT NULL,
? ?PRIMARY KEY ? ?(sid),
? ?INDEX par_ind (classid),
? ?FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB
*/
publicstaticvoid main(String[] args) throws SQLException ? ?
?{
try
? ?{
? ? ?SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
? ? ?Session session=sf.openSession();
? ? ?Transaction tx=session.beginTransaction(); ? ? ? ? /*因為mappedBy是定義在classes中,即classes類不負責維護級聯關系.即維護者是student.所以,1.要將clsses的數據,賦給student,即用student的setClasses()方法去捆定class數據;2.在進行數據插入/更新session.save()/session.update()時,最后操作的是student.*/
? ? ?Classes classes=new Classes();
? ? ?classes.setName("access");
? ? ?Student st1=new Student();
? ? ?st1.setSname("jason");
? ? ?st1.setClasses(classes);
? ? ?session.save(st1);
? ? ?Student st2=new Student();
? ? ?st2.setSname("hwj");
? ? ?st2.setClasses(classes);
? ? ?session.save(st2);
? ? ?tx.commit();/* 輸出如下:Hibernate: insert into classes (name) values (?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)*//*因為一端維護關系另一端不維護關系的原因,我們必須注意避免在應用中用不維護關系的類(class)建立關系,因為這樣建立的關系是不會在數據庫中存儲的。如上的代碼倒過來,則插入時,student的外鍵值為空.如下:*/// ? ? ?Student st1=new Student();
// ? ? ?st1.setSname("jason");
// ? ? ?session.save(st1);
// ? ? ? ?
// ? ? ?Student st2=new Student();
// ? ? ?st2.setSname("hwj");
// ? ? ?session.save(st2);
// ? ? ? ?
// ? ? ?Set<Student> students=new HashSet<Student>();
// ? ? ?students.add(st1);
// ? ? ?students.add(st2);
// ? ? ? ?
// ? ? ?Classes classes=new Classes();
// ? ? ?classes.setName("access");
// ? ? ?classes.setStudents(students);
// ? ? ?session.save(classes); /*輸出如下:
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)Hibernate: insert into classes (name) values (?)*/
? ?}
catch(HibernateException e)
? ?{
? ? ?e.printStackTrace(); ? ? ? ?
? ?}
?}
}[4]
多對多注解: 在多對多注解中,雙方都采用@ManyToMany.其中被控方,像一對多注解中設置一樣,也要設置mappedBy.其中主控方,不像一對多注解那樣,采用@joinColumn,而是采用@joinTable.如下:@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})其中,如上所說,mappedBy,相當于inverse="true".所以,在@joinTable中的inverseJoinColumns中定義的字段為mappedBy所在類的主鍵.
joinColumns定義的字段,就是當前類的主鍵.@Entity
@Table(name="jcourse")
publicclass Jcourse {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint cid;
private String cname;
?@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY ,mappedBy="courses")
private Set<Jstudent> students;
//setter,getter省略.... ? ?
}
@Entity
@Table(name="jstudent")
publicclass Jstudent {
?@Id
?@GeneratedValue(strategy=GenerationType.AUTO)
privateint sid;
private String sname;
?@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.EAGER)
//inverseJoinColumns中對應的id為以下屬性course的對應id.
?@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})
private Set<Jcourse> courses;
//setter,getter省略.... ? ?
}
publicclass Test {
publicstaticvoid main(String[] args) {
try
? ?{
? ? ?SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory();
? ? ?Session session=sf.openSession();
? ? ?Transaction tx=session.beginTransaction();
? ? ?Jcourse course=new Jcourse();
? ? ?course.setCname("jason-english");
? ? ?session.save(course); //先各自保存.
? ? ?Jcourse course2=new Jcourse();
? ? ?course2.setCname("herry-english");
? ? ?session.save(course2);
? ? ?Set<Jcourse> courses=new HashSet<Jcourse>();
? ? ?courses.add(course);
? ? ?courses.add(course2);
? ? ?Jstudent student=new Jstudent();
? ? ?student.setSname("jason");
? ? ?student.setCourses(courses);
? ? ?session.save(student);// 要用非mapby定義的類(studet)來作為主者(會控制級聯關系),一對多,多對一也一樣道理.
//可以嘗試反過來.
? ? ?tx.commit();
? ?}
catch(HibernateException e)
? ?{
? ? ?e.printStackTrace(); ? ? ? ?
? ?}
?}
}
轉載于:https://blog.51cto.com/andysu/1212070
總結
以上是生活随笔為你收集整理的Hibernate注解使用以及Spring整合的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: .Net深入学习序列化和反序列化 (转)
- 下一篇: 十、Linux文件系统基本操作(moun