`

hibernate一对多,多对一,一对多双向关联

阅读更多
hibernate之多对一。在多对一中,在多的一方设置many-to-one,而在一的一方不设置。
1、新建一个java项目hibernate,新建类Employee.java与Department.java

Employee.java
package cn.ehoo.hibernate.domain;
/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Employee {
	private Long id;
	private String name;
	private Department depart;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Department getDepart() {
		return depart;
	}
	public void setDepart(Department depart) {
		this.depart = depart;
	}
}


Employee.java的配置文件Employee.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 package="cn.ehoo.hibernate.domain" >
	<class name="Employee" table="employee" dynamic-update="true" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
		<many-to-one name="depart" column="depart_id" cascade="save-update"/>
	</class>
</hibernate-mapping>


Department.java

package cn.ehoo.hibernate.domain;


/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Department {
	private Long id;
	private String name;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Department.java的配置文件Department.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 package="cn.ehoo.hibernate.domain">
	<class name="Department" table="department" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
	</class>

</hibernate-mapping>


2、新建类Many2One.java
package cn.ehoo.hibernate;

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

import cn.ehoo.hibernate.domain.Department;
import cn.ehoo.hibernate.domain.Employee;

/**
 * @author whp
 * @Email whp@ehoo.cn
 * @Nov 11, 2010
 * 
 */
public class Many2One {
	public static void main(String[] args) {
		Session s = null;
		Transaction tr = null;
		s = HibernateUtil.getCurrentSession();
		tr = s.beginTransaction();
		tr.begin();
		/*Department dep = (Department) s.load(Department.class, 1L);
		dep.setName("department_1");
		Employee em = new Employee();
		em.setName("employee_2");
		em.setDepart(dep);
		s.save(em);*/
		Department dep = (Department) s.load(Department.class, 1L);
		Employee em = (Employee)s.load(Employee.class, 1L);
		em.setName("whp1");
		em.setDepart(dep);
		s.update(em);
		tr.commit();
	}

}


3、hibernate.cfg.xml文件的配置
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	<property name="connection.url">jdbc:mysql:///test</property>
	<property name="connection.username">root</property>
	<property name="connection.password">123</property>
	<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
	<property name="current_session_context_class">thread</property>
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<property name="format_sql">true</property>
	<property name="generate_statistics">true</property>
	<mapping resource="cn/ehoo/hibernate/domain/Department.hbm.xml" />
	<mapping resource="cn/ehoo/hibernate/domain/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>




hibernate之一对多。在一对多中,在多的一方不设置many-to-one,而在一的一方设置one-to-many。

1、新建一个java项目hibernate,新建类Employee.java与Department.java

Employee.java
package cn.ehoo.hibernate.domain;
/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Employee {
	private Long id;
	private String name;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}


Employee.java的配置文件Employee.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 package="cn.ehoo.hibernate.domain" >
	<class name="Employee" table="employee" dynamic-update="true" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
	</class>
</hibernate-mapping>


Department.java

package cn.ehoo.hibernate.domain;

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

/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Department {
	private Long id;
	private String name;
	private Set<Employee> emps = new HashSet<Employee>();
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Employee> getEmps() {
		return emps;
	}
	public void setEmps(Set<Employee> emps) {
		this.emps = emps;
	}
}

Department.java的配置文件Department.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 package="cn.ehoo.hibernate.domain">
	<class name="Department" table="department" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="emps" cascade="save-update">
			<key column="depart_id" />
			<one-to-many class="Employee" />
		</set>
	</class>
</hibernate-mapping>


2、新建类One2Many.java
package cn.ehoo.hibernate;

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

import cn.ehoo.hibernate.domain.Department;
import cn.ehoo.hibernate.domain.Employee;

/**
 * @author whp
 * @Email whp@ehoo.cn
 * @Nov 11, 2010
 * 
 */
public class One2Many {
	public static void main(String[] args) {
		Session s = null;
		Transaction tr = null;
		s = HibernateUtil.getCurrentSession();
		tr = s.beginTransaction();
		tr.begin();
		 Department dep = new Department();
		dep.setName("department_1");
		Employee em = new Employee();
		em.setName("employee_2");
		dep.getEmps().add(em);
		s.save(dep); 
		tr.commit();
	}

}


3、hibernate.cfg.xml文件的配置
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	<property name="connection.url">jdbc:mysql:///test</property>
	<property name="connection.username">root</property>
	<property name="connection.password">123</property>
	<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
	<property name="current_session_context_class">thread</property>
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<property name="format_sql">true</property>
	<property name="generate_statistics">true</property>
	<mapping resource="cn/ehoo/hibernate/domain/Department.hbm.xml" />
	<mapping resource="cn/ehoo/hibernate/domain/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>






hibernate之一对多双向关联。在一的一方要配置one-to-many,在多的一方要配置many-to-one。在一对多双向关联时,一般要把一一方的集合中设置inverse=true,这样可以让一的一方来放弃关系的维护,从而节省资源。

1、新建一个java项目hibernate,新建类Employee.java与Department.java

Employee.java
package cn.ehoo.hibernate.domain;
/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Employee {
	private Long id;
	private String name;
	private Department depart;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Department getDepart() {
		return depart;
	}
	public void setDepart(Department depart) {
		this.depart = depart;
	}
}


Employee.java的配置文件Employee.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 package="cn.ehoo.hibernate.domain" >
	<class name="Employee" table="employee" dynamic-update="true" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
		<many-to-one name="depart" column="depart_id" cascade="save-update"/>
	</class>
</hibernate-mapping>


Department.java

package cn.ehoo.hibernate.domain;

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

/**
 *@author whp
 *@Email whp@ehoo.cn
 *@Nov 11, 2010
 *
 */
public class Department {
	private Long id;
	private String name;
	private Set<Employee> emps = new HashSet<Employee>();
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Employee> getEmps() {
		return emps;
	}
	public void setEmps(Set<Employee> emps) {
		this.emps = emps;
	}
}

Department.java的配置文件Department.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 package="cn.ehoo.hibernate.domain">
	<class name="Department" table="department" >
		<id name="id" type="long">
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="emps" cascade="save-update">
			<key column="depart_id" />
			<one-to-many class="Employee" />
		</set>
	</class>
</hibernate-mapping>


2、新建类One2Many.java
package cn.ehoo.hibernate;

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

import cn.ehoo.hibernate.domain.Department;
import cn.ehoo.hibernate.domain.Employee;

/**
 * @author whp
 * @Email whp@ehoo.cn
 * @Nov 11, 2010
 * 
 */
public class One2Many {
	public static void main(String[] args) {
		Session s = null;
		Transaction tr = null;
		s = HibernateUtil.getCurrentSession();
		tr = s.beginTransaction();
		tr.begin();
		 Department dep = new Department();
		dep.setName("department_1");
		Employee em = new Employee();
		em.setName("employee_2");
		dep.getEmps().add(em);
		s.save(dep); 
		tr.commit();
	}

}


3、hibernate.cfg.xml文件的配置
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	<property name="connection.url">jdbc:mysql:///test</property>
	<property name="connection.username">root</property>
	<property name="connection.password">123</property>
	<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
	<property name="current_session_context_class">thread</property>
	<property name="hbm2ddl.auto">update</property>
	<property name="show_sql">true</property>
	<property name="format_sql">true</property>
	<property name="generate_statistics">true</property>
	<mapping resource="cn/ehoo/hibernate/domain/Department.hbm.xml" />
	<mapping resource="cn/ehoo/hibernate/domain/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>




casecade为级联。inverse为关联。inverse设置为true是放弃关系的维护,一般在双向关联里使用。并且只有集合一端才有。而casecode在一的一端与多的一端里都会存在
分享到:
评论

相关推荐

    Hibernate ORM - 一对多双向关联关系

    标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中,Hibernate ORM(对象关系映射)框架如何处理一个实体类(如User)与多个实体类(如Article)之间的关系。在这种关系中,一个用户可以拥有多个文章...

    hibernate双向一对多关联映射(注解版)

    在Java的持久化框架Hibernate中,双向一对多关联映射是一种常见的关系映射方式,它模拟了数据库中的外键关联,使得一个实体可以拥有多个另一个实体的实例。在这个注解版的实现中,我们将深入探讨如何使用Hibernate的...

    Hibernate一对多双向自身关联demo代码

    在这个“Hibernate一对多双向自身关联demo代码”中,我们将深入理解如何实现一个实体类与其自身进行一对多的双向关联。这种关联在实际应用中常见于例如用户的朋友关系、员工的上下级关系等场景。 首先,让我们了解...

    Hibernate双向一对一关联映射(注解版)

    本主题聚焦于“Hibernate双向一对一关联映射”的注解实现,这是一种高级的数据库设计模式,用于处理两个实体之间一对一的关系。 在Hibernate中,一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...

    hibernate多对多双向关联

    **标题解析:**“hibernate多对多双向关联” 在Java编程中,Hibernate是一个流行的ORM(对象关系映射)框架,它允许开发者用面向对象的方式处理数据库操作。"多对多双向关联"是Hibernate中一种关系映射类型,涉及两...

    Hibernate双向一对多经典实例

    **标题:“Hibernate双向一对多经典实例”** 在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库操作,使得开发者能够用面向对象的方式处理数据。本实例将聚焦于Hibernate中的一对多关系...

    Hibernate一对一主键关联映射(双向关联)

    标题"Hibernate一对一主键关联映射(双向关联)"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中,都可以直接访问到对方的实例,即在实体A中有一个对实体B的引用,...

    Hibernate双向一对多

    标题"Hibernate双向一对多"指的是Hibernate框架中的一个重要关系映射概念,即在一个实体类中,一个实例可以与多个另一个实体类的实例相关联,而在另一个实体类中,每个实例也可以关联到该实体类的一个实例。...

    hibernate双向一对多关联映射(XML)

    在Java的持久化框架Hibernate中,双向一对多关联映射是一种常见的关系数据库模型与对象模型之间的映射方式。这种映射允许在一个实体类中存在多个另一个实体类的实例,而在另一个实体类中也可能存在对第一个实体类的...

    Hibernate Annotation 基于外键的一对多双向关联

    本文将深入探讨如何使用Hibernate注解实现基于外键的一对多双向关联。我们将通过具体实例来解析这个主题,并结合源码分析其工作原理。 首先,我们要明白一对多关联意味着一个实体可以拥有多个关联的实体。在数据库...

    Hibernate一对多(多对一)双向关联(annotation/xml)

    总之,理解和熟练运用Hibernate的一对多、多对一以及双向关联,是提升Java企业级应用开发效率的关键。通过注解或XML配置,开发者可以灵活地定义实体间的关联,实现数据的持久化。同时,注意级联操作、懒加载策略等...

    Hibernate ORM - 一对多双向连接表关联关系

    "HibernateORM"可能是包含有关Hibernate ORM框架的详细信息的文件夹或压缩包,里面可能包含示例代码、教程文档或其他资源,用于辅助学习和理解Hibernate ORM的一对多双向关联。 **知识点详解:** 1. **Hibernate ...

    hibernate一对多双向

    在Hibernate中,一对多双向关联的实现涉及了延迟加载、级联操作以及集合的管理。延迟加载意味着直到真正需要访问集合时才加载数据,从而提高了应用程序的性能。级联操作允许在父实体上执行的操作自动应用到子实体...

    hibernate一对一关联关系

    在实体类之间,Hibernate支持多种关联关系,包括一对一(One-to-One)、一对多(One-to-Many)和多对多(Many-to-Many)。本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,...

    hibernate外键实现一对一双向关联关系源码

    本主题将深入探讨如何使用Hibernate实现一对一双向关联关系,并通过源码解析这一过程。 一对一双向关联关系指的是两个实体类之间存在一对一的关系,且在各自的类中都可以直接访问对方。这种关联可以通过注解或XML...

    hibernate一对多关联映射(双向关联)

    总之,理解并正确实现Hibernate中的一对多双向关联映射是提升应用程序性能和数据一致性的重要步骤。通过细心配置映射文件,编写相应的实体类,以及妥善处理关联关系的维护,我们可以有效地管理复杂的数据结构。

    hibernate关联映射详解

    包含《多对多双向关联映射》《多对一单向关联映射》《多对一双向关联映射》《一对多单向关联映射》等文档,并有图解及例子,非常适合新手学习,尤其是刚刚接触hibernate,对映射关系不清楚的。。。。

Global site tag (gtag.js) - Google Analytics