hibernate如何实现表的单向1:n、双向多对一（代码）

在数据库中如果对表和表的关系的描述主要是一对一，多对一和多对多。

但是在hibernate编写的时候多对一是有方向的。虽然都是在数据表中增加一个外键列，但是添加的方式有两种。

产生的效果也是不同的。

为什么呢？因为如果你在一方

代码如下：

创建两个实体类： Student + Grade

他们数据库的定义是：

下面代码为双向多对一。双向多对一就是把单项的一对多和多对一都写上。使得数据可以双向访问。

如果要一对多就保留Grade中红色的部分代码，和一方部分配置文件的信息；

在Grade中设置

private Set<Student> students = new HashSet<Student>();

在他的配置文件中设置inverse和cascade属性可以省略（当只有单项的时候）

	<set name="students" table="student" inverse="true" cascade="save-update">
  	<!-- 指定关联的外键列 -->
  		<key column="gid"></key>
  		<one-to-many class="com.imooc.entity.Student"/>
  	</set>

如果要设置单项的多对一，就保留Student中代码和配置文件的代码。

只在Sutdents中创建一个Grade的属性和相应的getter和setter。并在他的配置文件中写：

  <many-to-one name="grade" class="com.imooc.entity.Grade" column="gid"></many-to-one>

class是grade的完整路径。

Student_javabean

package com.imooc.entity;


import java.io.Serializable;


public class Student implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private int sid;
	private String sname;
	private String sex;
	private Grade grade;   //为了实现多对一的关联关系
	
	
	public Grade getGrade() {
		return grade;
	}
	public void setGrade(Grade grade) {
		this.grade = grade;
	}
	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(int sid, String sname, String sex) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.sex = sex;
	}
	public Student() {
		super();
	}
	public Student(String sname, String sex) {
		super();
		this.sname = sname;
		this.sex = sex;
	}
	
}

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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 column="sid" name="sid" type="java.lang.Integer">
   <generator class="increment"/>
  </id>
  <property generated="never" lazy="false" name="sname" type="java.lang.String">
   <column length="20" name="sname" not-null="false" unique="true"/>
  </property>
  <property generated="never" lazy="false" name="sex" type="java.lang.String">
   <column length="2" name="sex"/>
  </property>
  
  <!-- 配置多对一关联关系 -->
  <many-to-one name="grade" class="com.imooc.entity.Grade" column="gid"></many-to-one>
 </class>
</hibernate-mapping>

Grade_javabean

package com.imooc.entity;

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

public class Grade implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	
	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 Set<Student> getStudents() {
		return students;
	}

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

	public Grade() {
		super();
	}

	public Grade(int gid, String gname, String gdesc, Set<Student> students) {
		super();
		this.gid = gid;
		this.gname = gname;
		this.gdesc = gdesc;
		this.students = students;
	}

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

	

	
	
}

Grade.hbm.xml

<?xml version='1.0' encoding='UTF-8'?>
<!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" type="java.lang.String">
  		<column name="gdesc"></column>
  	</property>
  	
  	<!-- 配置单项的一对多关联关系  设置inverse为true，由多方维护关联关系，当保存和更新时进行级联操作-->
  	<set name="students" table="student" inverse="true" cascade="save-update">
  	<!-- 指定关联的外键列 -->
  		<key column="gid"></key>
  		<one-to-many class="com.imooc.entity.Student"/>
  	</set>
  	</class>
  
  </hibernate-mapping>       
          
          

hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!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">root</property>
	<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/imooc</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>

hibernate.util

package com.imooc.Util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static Session session;
	
	static {
		//创建configuration对象，读取hibernate.cfg.xml文件，完成初始化
		Configuration config = new Configuration().configure();
		System.out.print("3");
		//StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder().applySettings(config.getProperties());
		System.out.print("4");
		//StandardServiceRegistry ssr = ssrb.build();
		System.out.print("5");
		sessionFactory = config.buildSessionFactory();
		System.out.print("6");
	}
	//获取SessionFactory
	public static SessionFactory getSessionFactory()
	{
		return sessionFactory;
	}
	
	//获取Session
	public static Session getSession()
	{
		session = sessionFactory.openSession();
		return session;
	}
	
	//关闭Session
	public static void closeSession(Session session)
	{
		if(session!=null)
		{
			session.close();
		}
	}
}

test主函数，进行测试

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

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

public class test {
	public static void main(String[] args)
	{	
		
		add();
	}
	public static void add(){
		Grade g = new Grade("java一班","JAVA软件开发一班");
		Student stu1=new Student("张三","男");
		Student stu2=new Student("女神","女");
		
		//单项的一对多
		//如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，然后关联关系
		g.getStudents().add(stu1);
		g.getStudents().add(stu2);

		//单项的多对一
		stu1.setGrade(g);
		stu2.setGrade(g);
		
		//注意console语句。测试的时候，添加inverse属性控制关联关系的维护
		//cascade
		Session session = HibernateUtil.getSession();
		Transaction tx = session.beginTransaction();
		session.save(g);//级联信息
		session.save(stu1);
		session.save(stu2);
		tx.commit();
		HibernateUtil.closeSession(session);
		
	}
}