hibernate双向一对多关联映射XML与注解版

最新推荐文章于 2020-11-15 15:14:54 发布

码农致富

最新推荐文章于 2020-11-15 15:14:54 发布

阅读量1k

点赞数

分类专栏： Hibernate

本文链接：https://blog.csdn.net/u011781521/article/details/71247256

版权

Hibernate 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

双向一对多关联映射原理:

一对多双向关联映射，即在一的一端存在多的一端的一个集合对象，在多的一端存在一的一端的一个对象，这样就可以保证在加载一的一端或多的一端将被指向端的集合或对象加载上来，即保证双向关联。

1、一对多双向关联也就是说，在加载班级时，能够知道这个班级所有的学生，同时，在加载学生时，也能够知道这个学生所在的班级。

2、我们知道，一对多关联映射和多对一关联映射是一样的，都是在多的一端加外键了。

只不过是角度不同，我们从Classes一端来看，它就是一对多，它维护了一个一指向多的关系。在加载班级时，能够把学生加载上来。返过来，多个学生是属于一个班级的，它就是多对一。

3、而像我们的用户和组，就是多对一。多对一维护了一种知道，就是多指向一，所以在加载学生时，就能拿到这个学生所在的班级。如果能够拿到它所在的班级，那么必须在对象模型Student中，持有Classes对象的一个引用。

(1)XML版

SQL文件:

CREATE TABLE `student` (
  `id` varchar(255) NOT NULL,
  `sname` varchar(255) DEFAULT NULL,
  `class_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `classess` (
  `id` varchar(255) NOT NULL,
  `cname` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Classess类:

package Hibernate_demo1.Demo13.Entity;

import java.util.Set;

public class Classess {

	private String id;
	private String cname;
	private Set<Student> students;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
}

Student类:

package Hibernate_demo1.Demo13.Entity;

public class Student {

	private String id;
	private String sname;
	private Classess classes;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public Classess getClasses() {
		return classes;
	}
	public void setClasses(Classess classes) {
		this.classes = classes;
	}
}

Classess.hbm.xml映射文件:

<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC   
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
<hibernate-mapping>  
    <class name="Hibernate_demo1.Demo13.Entity.Classess" table="classess">  
        <id name="id" type="java.lang.String"> 
            <column name="id"/>
            <generator class="uuid">  
            </generator>  
        </id>  
        <property name="cname" column="cname"/>
        
        <set name="students">  
            <key column="class_id"></key>  
            <one-to-many class="Hibernate_demo1.Demo13.Entity.Student"></one-to-many>  
        </set>  
    </class>  
</hibernate-mapping>

Student.hbm.xml映射文件:

<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC   
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
<hibernate-mapping>  
    <class name="Hibernate_demo1.Demo13.Entity.Student" table="student">  
        <id name="id">  
            <generator class="uuid">  
            </generator>  
        </id>  
        
        <property name="sname" column="sname"/>  
        
        <!-- 在多的一端Student中添加一行新的Classes列 ,并且列的名称要和Classes.hbm.xml的列明相同-->  
        <many-to-one name="classes" column="class_id"></many-to-one>  
    </class>  
</hibernate-mapping>

测试:

1、先写班级后写学生

先把班级写入到数据库中后，Classes对象进入了Transient状态，并在数据库中有了一行，这时再写Student对象，Student对象会查找对应的Classes的主键将其写入到表中，所以此时关系模型中的数据都是非空的，保存的代码如下：

package Hibernate_demo1.Demo13;

import org.hibernate.Session;

import Hibernate_demo1.Demo13.Entity.Classess;
import Hibernate_demo1.Demo13.Entity.Student;
import Hibernate_demo1.Demo13.Util.HibernateUtils;


//在多的一端存储
public class Test1 
{
    public static void main( String[] args )
    {
    	Session session = null;
    	try{  
    		  
    	    session = HibernateUtils.getSession();
    	    session.beginTransaction();  
    	    
    	    //创建班级
    	    Classess cla1=new Classess();
    	    cla1.setCname("1班");  
    	    session.save(cla1);
    	    
    	    //创建学生
    	    Student stu1=new Student();
    	    stu1.setSname("小黑");
    	    stu1.setClasses(cla1);
    	    session.save(stu1);
    	    
    	    Student stu2=new Student();
    	    stu2.setSname("小明");
    	    stu2.setClasses(cla1);
    	    session.save(stu2);
    	    
    	  
    	    session.getTransaction().commit();  
    	}catch(Exception e){  
    	    e.printStackTrace();  
    	    session.getTransaction().rollback();  
    	}finally{  
    	    HibernateUtils.closeSession(session);  
    	}
    }
}

执行结果:

Hibernate: 
    insert 
    into
        classess
        (cname, id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        student
        (sname, class_id, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        student
        (sname, class_id, id) 
    values
        (?, ?, ?)

数据库结果:

classess表:

student表:

2、先写学生后写班级

代码如下:

package Hibernate_demo1.Demo13;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;

import Hibernate_demo1.Demo13.Entity.Classess;
import Hibernate_demo1.Demo13.Entity.Student;
import Hibernate_demo1.Demo13.Util.HibernateUtils;

public class Test2 {

	public static void main(String[] args) {
		Session session = null;
    	try{  
    		  
    	    session = HibernateUtils.getSession();
    	    session.beginTransaction();  
    	    

    	    
    	    //创建学生对象
    	    Student stu1=new Student();
    	    stu1.setSname("小黑");
    	    session.save(stu1);
    	    
    	    Student stu2=new Student();
    	    stu2.setSname("小明");
    	    session.save(stu2);
    	    
    	    //创建学生集合
    	    Set<Student> st=new HashSet();
    	    st.add(stu1);
    	    st.add(stu2);

    	    //创建班级
    	    Classess cla1=new Classess();
    	    cla1.setCname("1班"); 
    	    cla1.setStudents(st);
    	    
            //将学生集合写入到Classes中  
                	    
    	    session.save(cla1);
    	  
    	    session.getTransaction().commit();  
    	}catch(Exception e){  
    	    e.printStackTrace();  
    	    session.getTransaction().rollback();  
    	}finally{  
    	    HibernateUtils.closeSession(session);  
    	}
	}
}

执行结果如下:

Hibernate: 
    insert 
    into
        student
        (sname, class_id, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        student
        (sname, class_id, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        classess
        (cname, id) 
    values
        (?, ?)
Hibernate: 
    update
        student 
    set
        class_id=? 
    where
        id=?
Hibernate: 
    update
        student 
    set
        class_id=? 
    where
        id=?

完整示例: http://download.csdn.net/detail/u011781521/9835744

(2)注解版

Classess类:

package Hibernate_demo1.Demo14.Entity;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;


import org.hibernate.annotations.GenericGenerator;


@Entity
@Table(name="classess")
public class Classess {


	@Id
        @GenericGenerator(name="uuidGenerator", strategy="uuid")
        @GeneratedValue(generator="uuidGenerator")
	private String id;
	
	@Column(name="cname")
	private String cname;
	
	@JoinColumn(name="class_id")
        @OneToMany
	private Set<Student> students=new HashSet<Student>();
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}	
}

Student类:

package Hibernate_demo1.Demo14.Entity;


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


import org.hibernate.annotations.GenericGenerator;


@Entity
@Table(name="student")
public class Student {


	@Id
        @GenericGenerator(name="uuidGenerator", strategy="uuid")
        @GeneratedValue(generator="uuidGenerator")
	private String id;
	
	@Column(name="sname")
	private String sname;
	
	@JoinColumn(name="class_id")
        @ManyToOne
	private Classess classes;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public Classess getClasses() {
		return classes;
	}
	public void setClasses(Classess classes) {
		this.classes = classes;
	}
}

注意，两个实体类中的@JoinColumn(name=”class_id”) 值要一致

测试类:

package Hibernate_demo1.Demo14;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import Hibernate_demo1.Demo14.Entity.Classess;
import Hibernate_demo1.Demo14.Entity.Student;

public class App 
{
    public static void main( String[] args )
    {
    	SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();  
    	Session session = sessionFactory.getCurrentSession();  
    	Transaction tx = session.beginTransaction();  
        
    	 //创建班级
	    Classess cla1=new Classess();
	    cla1.setCname("2班");  
	    session.save(cla1);
	    
	    //创建学生
	    Student stu1=new Student();
	    stu1.setSname("小黑");
	    stu1.setClasses(cla1);
	    session.save(stu1);
	    
	    Student stu2=new Student();
	    stu2.setSname("小明");
	    stu2.setClasses(cla1);
	    session.save(stu2);
    	
        tx.commit();
        session.close();
    }
}

执行结果如下:

Hibernate: 
    insert 
    into
        classess
        (cname, id) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        student
        (class_id, sname, id) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        student
        (class_id, sname, id) 
    values
        (?, ?, ?)

示例代码: http://download.csdn.net/detail/u011781521/9835780

码农致富

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
hibernate双向一对多关联映射XML与注解版

双向一对多关联映射原理: 一对多双向关联映射，即在一的一端存在多的一端的一个集合对象，在多的一端存在一的一端的一个对象，这样就可以保证在加载一的一端或多的一端将被指向端的集合或对象加载上来，即保证双向关联。1、一对多双向关联也就是说，在加载班级时，能够知道这个班级所有的学生，同时，在加载学生时，也能够知道这个学生所在的班级。2、我们知道，一对多
复制链接

扫一扫

专栏目录