Annotation在框架中是越來越受歡迎了，因為annotation的配置比起XML的配置來說方便了很多，不需要大量的XML來書寫，方便簡單了很多，只要幾個annotation的配置，就可以完成我們以前需要書寫的大量的XML文件。當然annotation的配置也有缺陷的，那就是annotation一般都是配置在代碼中的，如果要修改的話，需要動源代碼，喪失了靈活性，違背了OCP(增加開放，修改關閉)原則，但是在真實的項目開發中，我們只是動配置文件，而不修改源代碼的情況實在是太少見了，所以現在annotation已經被廣泛的運用到了編程中，各種框架都提供了基于annotation的配置。

hibernate的注解配置和Jpa中的注解使用基本上都差不多。

參考博客：

導入jar包：

還有mysql的驅動

----------------------

簡單的插入測試小案例：

實體：User

packageorg.model;importjava.util.Date;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.Table;importorg.hibernate.annotations.GenericGenerator;

@Entity//@Table(name="t_user")//表名 默認不寫的話 就是類名

public classUser {private intid;privateString username;privateString password;privateString nickname;privateDate bornDate;publicUser() {

}public User(intid, String username, String password, String nickname, Date bornDate) {super();this.id =id;this.username =username;this.password =password;this.nickname =nickname;this.bornDate =bornDate;

}publicUser(String username, String password, String nickname, Date bornDate) {super();this.username =username;this.password =password;this.nickname =nickname;this.bornDate =bornDate;

}

@Id

@GeneratedValue()//默認native @GeneratedValue()//@GeneratedValue(generator = "x")//使用uuid id的類型必須是String類型//@GenericGenerator(name = "x", strategy = "uuid")//使用hibernate的uuid策略

public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 5, nullable = false)publicString getUsername() {returnusername;

}public voidsetUsername(String username) {this.username =username;

}

@Column(length= 10, nullable = false)//nullable屬性：默認是true 允許空值

publicString getPassword() {returnpassword;

}public voidsetPassword(String password) {this.password =password;

}

@Column(length= 5, nullable = true)publicString getNickname() {returnnickname;

}public voidsetNickname(String nickname) {this.nickname =nickname;

}

@Column(name= "born_date")publicDate getBornDate() {returnbornDate;

}public voidsetBornDate(Date bornDate) {this.bornDate =bornDate;

}

@OverridepublicString toString() {return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" +nickname+ ", bornDate=" + bornDate + "]";

}

}

測試類：

packageorg.execute;importjava.util.Date;importorg.hibernate.Session;importorg.hibernate.SessionFactory;importorg.hibernate.cfg.Configuration;importorg.junit.Test;importorg.model.User;public classExe {static Configuration config = null;static SessionFactory sessionFactory = null;//初始化

static{//加載核心配置文件 默認加載類路徑下的hibernate.cfg.xml

config = newConfiguration();

config.configure();//創建工廠

sessionFactory =config.buildSessionFactory();

}//返回session

publicSession rtn() {returnsessionFactory.openSession();

}//保存測試

@Testpublic voidinsert() {

Session session=rtn();

session.getTransaction().begin();

User u= new User("laomu", "123", "老孫", newDate());

session.save(u);

session.getTransaction().commit();

}

}

我們發現在對實體進行注解配置的時候 ?導入的包和JPA配置時一樣

在測試類中進行插入時，使用的不是JPA中的EntityManager對象，

EntityManagerFactory factory=Persistence.createEntityManagerFactory("simple");

EntityManager em = factory.createEntityManager();

而還是hibernate中的session對象。

配置文件：類路徑下的hibernate.cfg.xml文件 ?默認會去找該文件

/p>

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

org.hibernate.dialect.MySQLDialect

update

jdbc:mysql://localhost:3308/annotationhibernate

root

jay571018

com.mysql.jdbc.Driver

true

View Code

下面觀察數據庫：

插入的數據：

-------------------------------------------------

annotation配置many-to-one雙向

先看有問題的代碼：(明明配置了級聯 ?但是卻沒有進行級聯保存的問題)

多方：Student

packageorg.model;importjavax.persistence.CascadeType;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.ManyToOne;importjavax.persistence.Table;//多方 由該方維護外鍵

@Entity

@Table(name= "t_student")public classStudent {private intid;privateString name;privateString stuNo;//一方的屬性

privateClassRoom room;

@Id

@GeneratedValue()public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 5, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@Column(length= 10, nullable = false)publicString getStuNo() {returnstuNo;

}public voidsetStuNo(String stuNo) {this.stuNo =stuNo;

}//optional=false 外鍵字段不能為空 即每個學生都必須有對應的班級 默認為true//ManyToOne 查詢student 默認使用即時加載

@ManyToOne(cascade ={ CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH })//在維護端 指定外鍵字段名 也可以不寫 默認屬性_id

@JoinColumn(name = "r_id")publicClassRoom getRoom() {returnroom;

}public voidsetRoom(ClassRoom room) {this.room =room;

}publicStudent() {

}//互相關聯的方法

publicStudent(String name, String stuNo) {this.name =name;this.stuNo =stuNo;

}

@OverridepublicString toString() {return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo + ", classRoom=" + room.toString() + "]";

}

}

一方：ClassRoom

packageorg.model;importjava.util.HashSet;importjava.util.Set;importjavax.persistence.CascadeType;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.FetchType;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.OneToMany;importjavax.persistence.Table;//一方 被維護端

@Entity

@Table(name= "t_classroom")public classClassRoom {private intid;privateString name;//多方的集合屬性

private Set students = new HashSet();

@Id

@GeneratedValue()public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 10, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}//mappedBy屬性：由集合中對應的實體Student中的classroom屬性來維護外鍵 聲明mappedBy的實體為被維護方//抓取方式 onetoMany 默認為lazy加載

@OneToMany(cascade = { CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH }, mappedBy = "room")public SetgetStudents() {returnstudents;

}public void setStudents(Setstudents) {this.students =students;

}publicClassRoom(String name) {this.name =name;

}publicClassRoom() {}/** public ClassRoom(int id,String name) { this.id=id; this.name = name; }*/

//互相關聯的方法

public voidaddStudent(Student student) {

student.setRoom(this);this.students.add(student);

}

@OverridepublicString toString() {return "ClassRoom [id=" + id + ", name=" + name + "]";

}

}

測試類：

//一對多插入測試

@Testpublic voidoneToManyInsert() {

Session session=rtn();

session.getTransaction().begin();//創建對象

Student s1=new Student("喬克","A01010");

Student s2=new Student("小明","A01012");

ClassRoom classRoom=new ClassRoom("就業班");//進行互相關聯

classRoom.addStudent(s1);

classRoom.addStudent(s2);//在addStudent()中進行了互相關聯 這里直接調用這個方法即完成了互相關聯//進行持久化操作

session.save(classRoom);

session.getTransaction().commit();

}

然后查看數據庫：

可以看到 ?只對classRoom表進行了數據的插入 ? 可以我們在實體中明明配置了級聯保存的操作啊 ? 同時也進行了互相的關聯 ?為啥會出現這種情況呢？

還記得學習JPA時級聯操作觸發的時機嗎？----》如果使用javax.persistence.*里面的注解，只有調用相應的方法才生效，如PERSIST，只有調用persist方法才生效

所以這里當然不能實現級聯了

第一種測試：

根據網上說的情況 ?我了試試 ?如果把ClassRoom中的級聯屬性配置為以下的情況：

CascadeType.PESIST,CascadeType.REMOVE,CascadeType.MERGE,CascadeType.REFRESH

也不能進行級聯保存，但是，如果配置為CascadeType.All則可以級聯保存成功，說明

JPA中的CascadeType.ALL并不等于{CascadeType.PESIST,CascadeType.REMOVE,CascadeType.MERGE,CascadeType.REFRESH}

第二種測試：

然后我把級聯屬性設置成了上面說的那種方式save_update ? 注意 ?導入的是hibernate.annotation中的包 ?而不再是jpa中的級聯包了

roomClass中的級聯方式修改為：

測試結果：

級聯保存成功，所以這里需要明白，hibernate注解開發 設置級聯時不能使用jpa規范中的級聯方式，而只能是使用自己提供的級聯方式，如下：

---------------------------------------

上面進行了插入測試，下面我們進行查詢測試：

可見只查詢了一次數據庫，在查詢student對象(多方) ?立即查詢一方數據

因為我們在student中是這樣配置的

抓取方式 ?在ManyToOne情況下 ?默認直接加載了一方屬性 ?如果改為下面的配置方式：

執行查詢 ?觀察打印的sql

可以看到 ?是發送了兩次sql查詢 ?同樣 ?在執行查詢一方屬性時 ?不指定查詢方式時 ? 默認是懶加載多方屬性的 ?這里就不再執行了

需要注意的一點是：在查詢某個實體的時候 ?需要在該實體中配置一個無參數的構造方法 ? ?比如 ?我把student實體中的無參構造刪除掉 ?然后執行查詢

所以 ?因為框架中好多地方都會用到無參構造 ?在我們創建有參構造的時候 ?記得把無參構造也寫出來。

---------------------------------------------------------------

annotation配置many-to-one單向

student

packageorg.model.om.danxiang;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.ManyToOne;importjavax.persistence.Table;

@Entity

@Table(name= "danxiang_student")public classStudent {private intid;privateString name;privateString stuNo;//一方的屬性

privateClassRoom room;

@Id

@GeneratedValue()public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 5, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@Column(length= 10, nullable = false)publicString getStuNo() {returnstuNo;

}public voidsetStuNo(String stuNo) {this.stuNo =stuNo;

}//optional=false 外鍵字段不能為空 即每個學生都必須有對應的班級 默認為true//ManyToOne 查詢student 默認使用即時加載//使用hibernate自己的級聯方式

@ManyToOne()//@Cascade({CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH})//在維護端 指定外鍵字段名 也可以不寫 默認屬性_id

@JoinColumn(name = "cid")publicClassRoom getRoom() {returnroom;

}public voidsetRoom(ClassRoom classRoom) {this.room =classRoom;

}publicStudent() {

}//互相關聯的方法

publicStudent(String name, String stuNo) {this.name =name;this.stuNo =stuNo;

}

@OverridepublicString toString() {return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo + ", classRoom=" + room.toString() + "]";

}

}

classRoom

packageorg.model.om.danxiang;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.Table;//一方 被維護端

@Entity

@Table(name= "danxiang_classroom")public classClassRoom {private intid;privateString name;/*// 多方的集合屬性

private Set students = new HashSet();*/@Id

@GeneratedValue()public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 10, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}/*// mappedBy屬性：由集合中對應的實體Student中的classroom屬性來維護外鍵 聲明mappedBy的實體為被維護方

// 抓取方式 onetoMany 默認為lazy加載

//使用hibernate自己的級聯方式

@OneToMany(mappedBy = "room")

@Cascade({CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH})

public Set getStudents() {

return students;

}

public void setStudents(Set students) {

this.students = students;

}*/

publicClassRoom(String name) {this.name =name;

}publicClassRoom() {}/** public ClassRoom(int id,String name) { this.id=id; this.name = name; }*/

/*// 互相關聯的方法

public void addStudent(Student student) {

student.setRoom(this);

this.students.add(student);

}*/@OverridepublicString toString() {return "ClassRoom [id=" + id + ", name=" + name + "]";

}

}

測試：

//單向 一方classroom中不創建集合 只在多方student中創建一方對象 ---》 測試成功//所以 單向方式操作時 只能是：在多方對象中創建一方對象屬性 在一方中省略創建多方的集合屬性 反之則不行 比如測試2

@Testpublic voidoneToManyInsertDanXiang() {

Session session=rtn();

session.getTransaction().begin();//創建對象

org.model.om.danxiang.Student s1=new org.model.om.danxiang.Student("喬克","A01010");

org.model.om.danxiang.Student s2=new org.model.om.danxiang.Student("喬克2","A01012");

org.model.om.danxiang.ClassRoom classRoom=new org.model.om.danxiang.ClassRoom("就業班");//進行互相關聯

s1.setRoom(classRoom);

s2.setRoom(classRoom);//保存

session.save(classRoom);//保存的順序無關

session.save(s1);

session.save(s2);//classRoom.addStudent(s1);//classRoom.addStudent(s2);//在addStudent()中進行了互相關聯 這里直接調用這個方法即完成了互相關聯//進行持久化操作

session.save(classRoom);

session.getTransaction().commit();

}

查詢測試：

//單向查詢

@Testpublic voidoneToManyInsertDanXiangQuery() {

Session session=rtn();//查詢多方 觀察是否同時查詢一方數據

org.model.om.danxiang.Student student = session.get(org.model.om.danxiang.Student.class,67);

System.out.println(student);

}

單向關系，查詢多方的時候，可以順帶查詢一方的數據 ? 但是不能通過查詢一方同時獲得多方的數據 ? 但是雙向關系就可以 ?查詢ClassRoom時 ?可以選擇即使加載或者懶加載多方屬性 ? 然后通過ClassRoom中的students屬性就可以得到多方集合數據

-----------------------------------------------

openSession和getCurrentSession的區別：

使用getCurrentSession時 ?出現下面錯誤 ?是因為沒有開啟事務

開啟事務 ?就可以解決該問題

---------------------------------------------------

annotation配置many-to-one雙向

Person

packageorg.model;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.OneToOne;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;//一對一雙向實體 person作為維護方

@Entity

@Table(name= "t_person")public classPerson {private int id;//主鍵

private String name;//姓名

privateIDCard idCard;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}//這里暫時不配置 數據庫默認字段為name 可以為空 長度255

publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@OneToOne

@JoinColumn(name= "cardid")

@Cascade(value={ CascadeType.ALL })publicIDCard getIdCard() {returnidCard;

}public voidsetIdCard(IDCard idCard) {this.idCard =idCard;

}

@OverridepublicString toString() {return "Person [id=" + id + ", name=" + name + ", idCard=" + idCard + "]";

}

}

IDCard

packageorg.model;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.OneToOne;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;//一對一雙向實體

@Entity

@Table(name= "t_card")public classIDCard {private int id;//主鍵

private String no;//編號

privatePerson person;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}publicString getNo() {returnno;

}public voidsetNo(String no) {this.no =no;

}

@OneToOne(mappedBy= "idCard")

@Cascade(value={ CascadeType.ALL })publicPerson getPerson() {returnperson;

}public voidsetPerson(Person person) {this.person =person;

}

@OverridepublicString toString() {return "IDCard [id=" + id + ", no=" + no + ", person=" + person + "]";

}

}

測試

//一對一雙向關聯

@Testpublic voidoneToOne() {

Session session=rtn();

session.getTransaction().begin();//創建person對象

Person p=newPerson();

p.setName("張三");//創建IDCard對象

IDCard idCard=newIDCard();

idCard.setNo("xx1");//進行相互關聯

/*** 如果沒有配置級聯保存的話 那么需要相互關聯 并且還要分別保存

p.setIdCard(idCard);

idCard.setPerson(p);

session.save(idCard);

session.save(p);*/

//配置級聯之后

p.setIdCard(idCard);

session.save(p);

session.getTransaction().commit();

session.close();

}

數據庫:

-------------------------------------

annotation配置many-to-many

user

packageorg.model.mm.shuangxiang;importjava.util.Date;importjava.util.Set;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.ManyToMany;importjavax.persistence.Table;importjavax.persistence.Temporal;importjavax.persistence.TemporalType;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;

@Entity

@Table(name="mm_user")//規定該實體為外鍵維護方

public classUser {private intid;privateString username;privateString password;privateString nickname;privateDate bornDate;private Setroles;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length=10,nullable=false)publicString getUsername() {returnusername;

}public voidsetUsername(String username) {this.username =username;

}

@Column(length=10,nullable=false)publicString getPassword() {returnpassword;

}public voidsetPassword(String password) {this.password =password;

}

@Column(length=10,nullable=false)publicString getNickname() {returnnickname;

}public voidsetNickname(String nickname) {this.nickname =nickname;

}

@Temporal(TemporalType.TIMESTAMP)//日期 時間 yyyy-dd-mm HH:MM:SS

publicDate getBornDate() {returnbornDate;

}public voidsetBornDate(Date bornDate) {this.bornDate =bornDate;

}//以m打頭 默認加載方式為lazy

@ManyToMany()

@Cascade(value={CascadeType.ALL})/**@JoinTable(

name="u_r",//中間表名稱

joinColumns=@JoinColumn(name="uid"),//本實體在中間表中創建的字段名

inverseJoinColumns= @JoinColumn(name="rid"))//關聯實體在中間表中創建的字段名

//以上內容可以省略不寫 有默認值*/

public SetgetRoles() {returnroles;

}public void setRoles(Setroles) {this.roles =roles;

}publicUser(String username, String password, String nickname, Date bornDate) {super();this.username =username;this.password =password;this.nickname =nickname;this.bornDate =bornDate;

}publicUser() {}

}

role

packageorg.model.mm.shuangxiang;importjava.util.Set;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.ManyToMany;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;

@Entity

@Table(name= "mm_role")public classRole {private intid;privateString name;private Setusers;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length=10,nullable=false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@ManyToMany(mappedBy="roles")

@Cascade(value={CascadeType.ALL})public SetgetUsers() {returnusers;

}public void setUsers(Setusers) {this.users =users;

}

@OverridepublicString toString() {return "Role [id=" + id + ", name=" + name + ", users=" + users + "]";

}publicRole(String name) {super();this.name =name;

}publicRole() {}

}

測試：

//多對多不拆分

@Testpublic voidmanyToMany() {

Session session=rtn();

session.getTransaction().begin();//創建user對象

org.model.mm.shuangxiang.User user1=new org.model.mm.shuangxiang.User("zhang","123","小張",newDate());//org.model.mm.shuangxiang.User user2=new org.model.mm.shuangxiang.User("wang","123","小王",new Date());//org.model.mm.shuangxiang.User user3=new org.model.mm.shuangxiang.User("sun","123","小孫",new Date());//創建role對象

Role role1=new Role("總監");

Role role2=new Role("保安");

Role role3=new Role("菜鳥");//創建集合

Set roles=new HashSet();

roles.add(role1);

roles.add(role2);

roles.add(role3);//進行關聯

user1.setRoles(roles);//保存user對象

session.save(user1);

session.getTransaction().commit();

session.close();

}

數據庫：

-----------------------------------------

annotation配置many-to-many變種 ?拆分為兩個一對多

Student

packageorg.model.mm.shuangxiang2;importjava.util.Set;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.OneToMany;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;

@Entity

@Table(name= "mm_student")public classStudent {private intid;privateString name;privateString stuNo;private Settcs;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 10, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@Column(length= 10, nullable = false)publicString getStuNo() {returnstuNo;

}public voidsetStuNo(String stuNo) {this.stuNo =stuNo;

}//與中間表相比 是一方 被維護端

@OneToMany(mappedBy = "student")

@Cascade(value={ CascadeType.ALL })public SetgetTcs() {returntcs;

}public void setTcs(Settcs) {this.tcs =tcs;

}publicStudent() {

}publicStudent(String name, String stuNo) {this.name =name;this.stuNo =stuNo;

}

}

Course

packageorg.model.mm.shuangxiang2;importjava.util.Set;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.OneToMany;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;

@Entity

@Table(name= "mm_course")public classCourse {private intid;privateString name;private Settcs;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 10, nullable = false)publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}//是一方 被維護端

@OneToMany(mappedBy = "course")

@Cascade(value={ CascadeType.ALL })public SetgetTcs() {returntcs;

}public void setTcs(Settcs) {this.tcs =tcs;

}publicCourse() {

}publicCourse(String name) {this.name =name;

}

}

中間實體 ?StudentCourse

packageorg.model.mm.shuangxiang2;importjavax.persistence.Column;importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.ManyToOne;importjavax.persistence.Table;importorg.hibernate.annotations.Cascade;importorg.hibernate.annotations.CascadeType;

@Entity

@Table(name= "mm_SC") //指定中間表名稱

public classStudentCourse {private intid;private doublescore;privateStudent student;privateCourse course;

@Id

@GeneratedValuepublic intgetId() {returnid;

}public void setId(intid) {this.id =id;

}

@Column(length= 5, nullable = false)public doublegetScore() {returnscore;

}public void setScore(doublescore) {this.score =score;

}//多方維護外鍵 指定中間表外鍵名稱為student_ID

@ManyToOne()

@Cascade(value={ CascadeType.ALL })

@JoinColumn(name= "student_ID")publicStudent getStudent() {returnstudent;

}public voidsetStudent(Student student) {this.student =student;

}//多方維護外鍵 指定中間表外鍵名稱為course_ID

@ManyToOne()

@Cascade(value={ CascadeType.ALL })

@JoinColumn(name= "course_ID") //多方作為維護端

publicCourse getCourse() {returncourse;

}public voidsetCourse(Course course) {this.course =course;

}public StudentCourse(doublescore, Student student, Course course) {super();this.score =score;this.student =student;this.course =course;

}publicStudentCourse() {

}

}

配置文件中引入：

測試：

//多對多 拆分為兩個一對多

@Testpublic voidmanyToMany2() {

Session session=rtn();

session.getTransaction().begin();//創建2個student對象

org.model.mm.shuangxiang2.Student student1=new org.model.mm.shuangxiang2.Student("zhang","141164000");

org.model.mm.shuangxiang2.Student student2=new org.model.mm.shuangxiang2.Student("wang","141164888");//創建2個course對象

Course course1=new Course("java");

Course course2=new Course("php");//創建studentCourse對象 把創建的student course加入進去//學生1的兩門課成績

StudentCourse sc1=new StudentCourse(88.5,student1,course1);

StudentCourse sc2=new StudentCourse(99.5,student1,course2);//學生2的兩門課成績

StudentCourse sc3=new StudentCourse(66.5,student2,course1);

StudentCourse sc4=new StudentCourse(49.5,student2,course2);//保存維護端對象 studentcourse

session.save(sc1);

session.save(sc2);

session.save(sc3);

session.save(sc4);

session.getTransaction().commit();

session.close();

}

數據庫：

-------------------------------------

總結

以上是生活随笔為你收集整理的hibernate mysql annotation_Hibernate基于注解annotation的配置的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。