`
schy_hqh
  • 浏览: 555871 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

Hibernate基于配置文件（八）多对一单向关联映射

 
阅读更多

 

多对一单向关联，只能从多的一端导航到一的一端

 

实体类

package org.leadfar.hibernate.model;



public class ContactPerson {
	private int id;
	private String name;
	private Group group;
	
	public ContactPerson() {
		// TODO Auto-generated constructor stub
	}
	public ContactPerson(String name) {
		// TODO Auto-generated constructor stub
		this.name = name;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Group getGroup() {
		return group;
	}
	public void setGroup(Group group) {
		this.group = group;
	}
	
	
}

 

<?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="org.hibernate.auction">
	<!-- name为实体类 table为映射到数据库中的表  lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)-->
	<class name="org.leadfar.hibernate.model.ContactPerson" table="t_person" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		
		<!--多对一关联映射配置-->
		<many-to-one name="group" column="gid"></many-to-one>
		
	</class>
	
</hibernate-mapping>

 

package org.leadfar.hibernate.model;

public class Group {
	private int id;
	private String name;
	
	public Group() {
		// TODO Auto-generated constructor stub
	}
	public Group(String name) {
		this.name = name;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

 

<?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="org.hibernate.auction">
	<!-- name为实体类 table为映射到数据库中的表  lazy默认为true 延迟发出select语句，直到真正用到对象的属性(非id属性)-->
	<class name="org.leadfar.hibernate.model.Group" table="t_group" >
		<!-- id为数据库标识，作为主键 -->
		<id name="id">
			<generator class="native"/>
		</id>
		
		<property name="name"/>
		

		
	</class>
	
</hibernate-mapping>

 

Hibernate配置文件

<!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.url">jdbc:mysql://localhost/hibernate</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="dialect">org.hibernate.dialect.MySQLDialect</property>
		
	
		<property name="show_sql">true</property>
		
		<!-- create-drop 测试用，用完即删 -->
		<!-- create 如果没有则创建，有则替换 -->
		<!-- validate 校验，如果没有表，则报错 -->
		<!-- update，没有则创建，有且数据有变化，则更新，没有则什么都不做 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		
		<mapping resource="org/leadfar/hibernate/model/ContactPerson.hbm.xml"></mapping>
		<mapping resource="org/leadfar/hibernate/model/Group.hbm.xml"></mapping>		
	</session-factory>
</hibernate-configuration>

 

 

测试

package org.leadfar.hibernate.model;




import junit.framework.TestCase;

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

public class Test_Many2One_01 extends TestCase {

	
	//多对一单向关联
	public void testSave_01() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		//buildSessionFactory的时候会自动创建数据库表
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			ContactPerson cp1 = new ContactPerson("张学友");
			session.save(cp1);
			ContactPerson cp2 = new ContactPerson("郑伊健");
			session.save(cp2);
			ContactPerson cp3 = new ContactPerson("郭富城");
			session.save(cp3);
			
			Group g1 = new Group("朋友");
			session.save(g1);
			Group g2 = new Group("商务");
			session.save(g2);
			Group g3 = new Group("陌生人");
			session.save(g3);

			//发出了多余的update语句！ 因为cp1 cp2 cp3被save后都变为持久化对象，当属性改变时hibernate会自动发出update语句
			cp1.setGroup(g1);
			cp2.setGroup(g2);
			cp3.setGroup(g3);

			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//避免多余的update语句发出
	//先建立一的一端，再建立多的一端，避免不合理的创建导致hibernate发出多余的update语句
	public void testSave_02() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		//buildSessionFactory的时候会自动创建数据库表
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			Group g1 = new Group("朋友");
			session.save(g1);
			Group g2 = new Group("商务");
			session.save(g2);
			Group g3 = new Group("陌生人");
			session.save(g3);
			
			ContactPerson cp1 = new ContactPerson("张学友");
			cp1.setGroup(g1);
			session.save(cp1);
			
			ContactPerson cp2 = new ContactPerson("郑伊健");
			cp2.setGroup(g2);
			session.save(cp2);
			
			ContactPerson cp3 = new ContactPerson("郭富城");
			cp3.setGroup(g3);
			session.save(cp3);
			
			
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	public void testSave_03() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		//buildSessionFactory的时候会自动创建数据库表
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			//模拟页面提交用户并要求设置到某个组(由Struts2完成)
			Group g4 = new Group();
			g4.setId(3);//设置到第3个组
			ContactPerson cp4 = new ContactPerson("刘德华");
			cp4.setGroup(g4);
			
			session.save(cp4);
			
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//仅仅是获取对象为了建立关联，使用load加载对象，hibernate不用发出select语句
	public void testSave_04() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		//buildSessionFactory的时候会自动创建数据库表
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			ContactPerson cp4 = new ContactPerson("路人丙");
			cp4.setGroup((Group)session.load(Group.class, 1));
			//仅仅是为了建立对象间的关联关系，没有使用到非id属性，hibernate不会发出查询语句
			//这就是load方法的经典之处！
			
			session.save(cp4);//瞬时对象--》持久化对象，发出insert语句
			
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	//内存中重建对象之间的关联（hibernate底层是如何完成的呢？利用引用关系？反射？）
	public void testLoad_01() throws Exception {
		//默认读取类路径根目录下的hibernate.cfg.xml配置文件
		Configuration cfg = new Configuration().configure();
		
		//创建SessionFactory
		//buildSessionFactory的时候会自动创建数据库表
		SessionFactory sfactory = cfg.buildSessionFactory();
		
		//创建Hibernate Session
		Session session = sfactory.openSession();
		
		try {
			//开启事务
			session.beginTransaction();
			
			ContactPerson cp1 = (ContactPerson)session.load(ContactPerson.class, 1);
			System.out.println(cp1.getId());
			
			System.out.println(cp1.getName());//hibernate:select t_person
		
			System.out.println(cp1.getGroup().getName());	//hibernate:select t_group
			
			//提交事务
			session.getTransaction().commit();
			
		} catch(Exception e) {
			e.printStackTrace();
			//出现异常，回滚事务
			session.getTransaction().rollback();
		} finally {
			//关闭session
			session.close();//session关闭之后，user对象处于离线Detached状态
		}
	}
	
	
	
}

 

 

分享到：
| Hibernate基于配置文件（七）关联关系的分 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate多对一单向关联关系实现源码

    在Java的持久化框架Hibernate中，多对一（ManyToOne）关联关系是一种常见的对象关系映射（ORM）场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录，而另一个实体类可能只有一条对应的记录。例如...

    Hibernate基于连接表的一对多单向关联

    总结，"Hibernate基于连接表的一对多单向关联"涉及到的主要知识点包括：数据库设计的一对多关系、Hibernate的实体映射、单向关联的配置、以及如何在Java代码中操作和查询这种关联。理解并熟练应用这些知识点，对于...

    Hibernate一对多单向关联映射

    总结，Hibernate的一对多单向关联映射通过XML映射文件和注解配合，可以方便地管理实体之间的关系。这种方式简化了数据库操作，提高了代码的可读性和可维护性。在实际开发中，应根据业务需求灵活运用，确保数据的一致...

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

    5. **映射方式**：映射一对多关联可以通过XML配置文件（hibernate.cfg.xml和.hbm.xml文件）或使用Java注解完成。在XML中，可以使用`&lt;set&gt;`标签；在注解中，可以用`@OneToMany`。 6. ** Cascade操作**：在配置一对多...

    hibernate一对多关联映射（单向关联）

    至此，我们在User类中完成了对Order的单向关联映射。为了使数据库表能够正确地反映这种关系，我们需要在数据库中创建对应的外键约束。通常，Hibernate会在子实体（Order）的表中创建一个引用父实体（User）主键的...

    Hibernate一对一唯一外键关联映射（单向关联）

    在Java的持久化框架Hibernate中，一对一（One-to-One）关联映射是常见的...以上就是关于Hibernate一对一唯一外键关联映射（单向关联）的详细说明。通过这种方式，我们可以轻松地在Java应用中处理数据库的一对一关系。

    hibernate多对多关联映射（单项关联）

    在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系模型，它用于处理两个实体类之间存在多个对应关系的情况。这篇博客"hibernate多对多关联映射（单项关联）"深入探讨了如何在Hibernate中实现这种映射...

    Hibernate教程10_关系映射之多对一单向关联

    压缩包中的`s2sh_relation07_many2one_uni`可能是示例项目的名称，暗示这是一个基于Spring、Struts2和Hibernate（S2SH）的项目，其中包含了多对一单向关联的实例代码。你可以下载并运行这个项目，以便更直观地理解...

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

    在Java的持久化框架Hibernate中，单向一对多关联映射是常见的数据关系处理方式，尤其是在处理数据库中的实体类和表之间的关系时。本主题主要关注如何使用注解来实现这种映射。Hibernate通过注解使得对象关系映射...

    hibernate主键实现一对一单向关联关系源码

    2. **Hibernate配置文件** 在`Person.hbm.xml`中，我们需要如下配置： ```xml &lt;!-- Person.hbm.xml --&gt; &lt;!-- 单向一对一关联Address --&gt; &lt;!-- Address.hbm.xml --&gt; ...

    Hibernate教程04_关系映射之一对一单向外键关联

    这个文件名暗示了这是一组基于Spring、Struts和Hibernate（简称S2SH）的示例代码，具体涉及的是关系映射中的一对一单向外键关联。"uni_fk"表示单向（unidirectional）外键（foreign key）关联。在数据库中，外键用于...

    Hibernate学习：单向多对一关联 工程

    本项目“Hibernate学习：单向多对一关联 工程”专注于讲解Hibernate中的单向多对一关联映射，这是数据库设计中常见的关系类型，尤其在处理具有层次结构的数据时。 单向多对一关联指的是在一个实体类中有一个引用，...

    hibernate单向多对多映射(XML版)

    总结起来，Hibernate的单向多对多映射通过XML配置文件定义了实体之间的关系，使得在Java代码中处理数据库的多对多关联变得更加简单和直观。理解和熟练掌握这一映射方式，对于提升Java持久层开发的效率和质量至关重要...

    Hibernate一对一关联映射(注解)

    通过注解方式实现一对一关联映射，可以避免传统的XML配置文件，使得代码更加简洁、易读。 ### Hibernate一对一关联映射原理 一对一关联映射是指在数据库中两个表之间存在一对一的关系，例如，一个人只有一个身份证...

    Hibernate关联映射

    6. Hibernate 多对一外键单向关联： 在多对一关联中，多个实体（如 Order）可以关联到一个实体（如 Customer）。在 Order 实体类中，会有 `many-to-one` 元素指向 Customer。 7. Hibernate 多对一连接表单向关联：...

Magicbox
Global site tag (gtag.js) - Google Analytics