hibernate mysql annotation_Hibernate基于注解annotation的配置
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的配置的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： mysql启动失败LSB_MySQL数据
- 下一篇： MySQL限制CPU资源使用_压缩大文件