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的配置相关推荐
- Spring 基于注解(annotation)的配置之@Required注解
从 Spring 2.5 开始就可以使用注解来配置依赖注入.注解连线在默认情况下在 Spring 容器中不打开.因此,在可以使用基于注解的连线之前,我们将需要在我们的 Spring 配置文件中启用它: ...
- Spring 基于注解(annotation)的配置之@Autowired注解
Setter 方法中的 @Autowired 当 Spring遇到一个在 setter 方法中使用的 @Autowired 注解,它会试图执行 byType 自动连接.换言之,加了@Autowired ...
- Spring 基于注解(annotation)的配置之@Qualifier注解
使用@Qualifier可以分别为同样类型的Bean分别注入不同的依赖值.看个例子: Student.java: package com.sap;public class Student {priva ...
- spring 基于注解的控制器配置
http://ttaale.iteye.com/blog/787586 spring 基于注解的控制器配置 博客分类: spring SpringBeanServletMVCWeb 13.12. 基于 ...
- 缓存初解（五）---SpringMVC基于注解的缓存配置--web应用实例
之前为大家介绍了如何使用spring注解来进行缓存配置 (EHCache 和 OSCache)的简单的例子,详见 Spring基于注解的缓存配置--EHCache AND OSCache 现在介绍一下 ...
- IoC容器9——基于注解的容器配置
2019独角兽企业重金招聘Python工程师标准>>> 基于注解的容器配置 注解比XML更适合配置Spring吗? 引入基于注解的配置提出了这种方法是否比XML更好的问题.简短的回答 ...
- 基于注解的 AOP 配置
基于注解的 AOP 配置 bean.xml <?xml version="1.0" encoding="UTF-8"?> <beans xml ...
- 基于注解的 IOC 配置
基于注解的 IOC 配置 学习基于注解的 IoC 配置,大家脑海里首先得有一个认知,即注解配置和 xml 配置要实现的功能都是一样 的,都是要降低程序间的耦合.只是配置的形式不一样. 关于实际的开发中 ...
- 基于注解的 IOC 配置——创建对象（Component、Controller、Service、Repository）注入数据（Autowired、Qualifier、Resource、Value）
基于注解的 IOC 配置 注解配置和 xml 配置要实现的功能都是一样的,都是要降低程序间的耦合.只是配置的形式不一样. XML的配置: 用于创建对象的 用于注入数据的 用于改变作用范围的 生命周期相 ...
最新文章
- struts2 action间跳转传值
- POJ_3685_Matrix_(二分,查找第k大的值)
- android多语言编码格式,在Android中使用国家/地区代码以编程方式更改语言
- 迷宫java代码_java写的迷宫代码
- Constructor vs Object
- django 文件上传 研究
- netstat命令---Linux查看网络和socket信息
- 女粉想要找男朋友，竟是为了...
- 第十一章：项目风险管理 - （11.5 规划风险应对）
- oracle中字符串长度计算,根据 oracle 标准计算超长字符串的长度
- 像素坐标转换实际坐标python_像素坐标转世界坐标的计算
- deb软件包管理（二）
- Java实现阿拉伯数字转换成中文大写数字，以及中文大写数字到阿拉伯数字的转换。
- 用户画像业务数据调研及ETL(二)持续更新中...
- 这个Q版卡通头像生成器，太符合程序员形象了
- InvalidDefinitionException: No serializer found for class java.lang.Object and no properties discove
- 2014年最新810多套源码2.46GB免费一次性打包下载
- 【程序23】TestAge.java 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。 //问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个
- Eplan P8 窗口宏/符号宏、页宏、宏值集的创建与插入 ＜四＞
- 网吧服务器硬盘压力百分之百,网吧无盘服务器硬盘的测试方法
热门文章
- leetcode 452. Minimum Number of Arrows to Burst Balloons | 452. 用最少数量的箭引爆气球（左程云：最大线段重合问题）
- leetcode 303. 区域和检索 - 数组不可变（Java版）
- 头条上python广告_满大街都是Python广告，真的如广告说的那样方便吗？，学精通后真能月如过万吗？业内大佬怎么看？...
- idea console中文乱码_idea控制台tomcat中文乱码的处理方法
- mysql的水平分表和垂直分表的区别
- 记一次 @Transactional不生效的问题
- 03.body_search
- 【GIF动画+完整可运行源代码】C++实现 基数排序——十大经典排序算法之十
- python3 ftp模块_python3利用pyftpdlib模块启动ftp服务
- mysql不用left join_MySQL在右表数据不唯一的情况下使用left join的方法_MySQL - join