Hibernate之单向一对多关联的实现

qq_33174994

于 2018-03-13 16:29:10 发布

阅读量1.5k

点赞数 2

分类专栏： JavaWeb

本文链接：https://blog.csdn.net/qq_33174994/article/details/79541432

版权

JavaWeb 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

单向的一对多关联映射关系主要是通过外键来关联的。一对多的关联映射是在表示“多”的一方的数据表中增加一个外键，并由“一”的一方指向“多”的一方。

单向一对多关联的持久化类里需要包含一个集合属性，在“一”的一方访问“多”的一方时，“多”的一方将以集合的形式来体现。如一个用户对应多个地址，则在grade类的定义中会包含一个集合属性，该属性就用来保存多个student实体。

单向的多对一关联映射关系也是通过外键来关联的。多对一的映射方式类似于一对多的映射方式，不过它的映射关系是由“多”的一方指向“一”的一方。在表示“多”的一方的数据表中增加一个外键来指向表示“一”的一方数据表，“一”的一方作为主表，“多”的一方作为从表。

下面我们来一个例子

首先我们在MySQL创建imooc数据库,在数据库中创建grade和student表

create database imooc;
create table grade
(
	gid int primary key,
	gname varchar(20) not null,
	gdesc varchar(50)
);

create table student
(
	sid int primary key,
	sname varchar(20) not null,
	sex char(2),
	gid int 
);
alter table student add constraint fk_student_gid foreign key (gid)
references grade(gid);

运行之后的结果如下：

在这里的班级为“一”方，学生为“多”方

先创建一个Dynamic Web Project项目，将其命名为Hibernate-one2many

现在我们来导入Hibernate支持jar包，此处用的是4.3版本

然后我们导入MySql驱动

导入的jar包位置

接下来我们来创建Hibernate.cfg.xml文件

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <property name="hibernate.connection.url">
        	<![CDATA[
        		jdbc:mysql://localhost:3306/imooc?useUnicode=true&characterEncoding=utf8
        	]]>
        </property>
        <property name="show_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
    
    	<!-- 指定映射文件的路径 -->
    	<mapping resource="com/imooc/entity/Grade.hbm.xml"/>
    	<mapping resource="com/imooc/entity/Student.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

然后在src文件夹中的com.imooc.entity包中创建grade的实体类

package com.imooc.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Grade implements Serializable {
	private int gid;
	private String gname;
	private String gdesc;
	private Set<Student> students=new HashSet<Student>();

	public int getGid() {
		return gid;
	}

	public void setGid(int gid) {
		this.gid = gid;
	}

	public String getGname() {
		return gname;
	}

	public void setGname(String gname) {
		this.gname = gname;
	}

	public String getGdesc() {
		return gdesc;
	}

	public void setGdesc(String gdesc) {
		this.gdesc = gdesc;
	}

	public Grade() {
		super();
	}

	public Set<Student> getStudents() {
		return students;
	}

	public void setStudents(Set<Student> students) {
		this.students = students;
	}

	public Grade(int gid, String gname, String gdesc) {
		super();
		this.gid = gid;
		this.gname = gname;
		this.gdesc = gdesc;
	}

	public Grade(String gname, String gdesc) {
		super();
		this.gname = gname;
		this.gdesc = gdesc;
	}

}

创建学生实体类

package com.imooc.entity;

import java.io.Serializable;

public class Student implements Serializable {
	private int sid;
	private String sname;
	private String sex;
	
	public int getSid() {
		return sid;
	}

	public void setSid(int sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public Student() {
		super();
	}

	public Student(String sname, String sex) {
		super();
		this.sname = sname;
		this.sex = sex;
	}

}

创建grade类的映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.imooc.entity.Grade" table="grade">
		<id name="gid" column="gid" type="java.lang.Integer">
			<generator class="increment"></generator>
		</id>
		<property name="gname" type="java.lang.String">
			<column name="gname" length="20" not-null="true"></column>
		</property>
		<property name="gdesc">
			<column name="gdesc"></column>
		</property>
		<!-- 配置一对多关联关系 -->
		<set name="students" table="student">
			<key column="gid"></key>
			<one-to-many class="com.imooc.entity.Student"/>
		</set>
	</class>
</hibernate-mapping>

创建studnet类的映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.imooc.entity.Student" table="student">
		<id name="sid" column="sid" type="java.lang.Integer">
			<generator class="increment"></generator>
		</id>
		<property name="sname" type="java.lang.String">
			<column name="sname" length="20" not-null="true"></column>
		</property>
		<property name="sex">
			<column name="sex"></column>
		</property>
		
	</class>
</hibernate-mapping>

最后创建Test类

package com.imooc.test;

import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;

/*
 * 单向一对多关联关系（班级------>学生）
 * 建立关联关系后，可以方便地从一个对象导航到另一个对象
 * 注意关联的方向
 */
public class Test {
	public static void main(String[] args) {
		add();
		//findStudentsByGrade();
		//update();
		//delete();
		
	}
	
	//添加
	public static void add(){
		Grade g=new Grade("Java2班", "Java软件开发2班");
		Student stu1=new Student("李四", "男");
		Student stu2=new Student("Amy", "女");
		
		//如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
		g.getStudents().add(stu1);
		g.getStudents().add(stu2);
		
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		session.save(g);
		session.save(stu1);
		session.save(stu2);
		tx.commit();
		HibernateUtil.closeSession(session);
	}
	
	//查询班级中包含的学生
	public static void findStudentsByGrade(){
		Session session=HibernateUtil.getSession();
		Grade grade=(Grade) session.get(Grade.class, 1);
		System.out.println(grade.getGname()+","+grade.getGdesc());
		
		Set<Student> students=grade.getStudents();
		for(Student stu:students){
			System.out.println(stu.getSname()+","+stu.getSex());
		}
	}

	//修改学生的信息
	public static void update(){
		Grade g=new Grade("Java二班", "Java软件开发二班");
		
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		Student stu=(Student) session.get(Student.class, 1);
		g.getStudents().add(stu);
		session.save(g);
		tx.commit();
		HibernateUtil.closeSession(session);
	}

	//删除学生信息
	public static void delete(){
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		Student stu=(Student) session.get(Student.class, 1);
		session.delete(stu);
		tx.commit();
		HibernateUtil.closeSession(session);
	}
}

运行的结果如下：

本实验是我在慕课网上学习一对多的一个小例子，在这里分享给需要的小伙伴~

实验例子百度网盘下载路径：链接：https://pan.baidu.com/s/1j5_pqBNW5H9I_jYHDK8B3Q 密码：j7k2

qq_33174994

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Hibernate之单向一对多关联的实现

单向的一对多关联映射关系主要是通过外键来关联的。一对多的关联映射是在表示“多”的一方的数据表中增加一个外键，并由“一”的一方指向“多”的一方。单向一对多关联的持久化类里需要包含一个集合属性，在“一”的一方访问“多”的一方时，“多”的一方将以集合的形式来体现。如一个用户对应多个地址，则在grade类的定义中会包含一个集合属性，该属性就用来保存多个student实体。 ...
复制链接

扫一扫

专栏目录