`
OracleX
  • 浏览: 123569 次
  • 性别: Icon_minigender_1
  • 来自: 地球
社区版块
存档分类
最新评论

Hibernate学习之一对多关联

阅读更多

注意事项:

1.单向一对多
   只需在“一”放进行配置
2.双向一对多
   需要在关联双方都加以配置,而且需要在一的一方设置inverse=true

首先是实体类

TAddress.java(多的一方)

public class TAddress implements Serializable {

	private static final long serialVersionUID = 1121137857691229229L;
	private Integer id;
	private String address;
	private String zipcode;
	private String tel;
	private String type;
	private TUser user;    //必须有

	............
}

TUser.java(一的一方)

public class TUser implements Serializable {

	private static final long serialVersionUID = 1224691192698621789L;
	private Integer id;
	private Integer age;
	private String name;
	@SuppressWarnings("rawtypes")
	private Set address = new HashSet();    //多的一方放在集合中
           
             ....................
}

然后是各个实体类的配置文件

TAddress.hbm.xml

 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<!-- 一对多 -->
<hibernate-mapping>
<class name="com.model.TAddress" table="t_address"
        dynamic-update="false" dynamic-insert="false">

<id name="id" type="java.lang.Integer" column="id" unsaved-value="0">
<generator class="native" />
</id>

<property name="address" column="address" type="string" />
<property name="tel" column="tel" type="string" />
<property name="zipcode" column="zipcode" type="string" />
<property name="type" column="type" type="string" />

<!-- 必须有many-to-one 否则关联字段(user_id)为null -->
<many-to-one name="user" 
                     class="com.model.TUser" 
                     cascade="none"
                     outer-join="auto" 
                     update="true" 
                     insert="true" 
                     access="property" 
                     column="user_id"
                     not-null="true">
</many-to-one>
</class>
</hibernate-mapping>

 TUser.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<!-- 一对多 外键关联 -->
<!-- Select from TUser where id=1 Select from TUser where id=1 to Select 
    from TUser where id=1 or id=2 -->
<!-- batch-size 批量加载机制 可以自定义每次批量加载的数量 -->
<hibernate-mapping>
<class name="com.model.TUser" table="t_user" dynamic-update="true"
>

<id name="id" type="java.lang.Integer" column="id" unsaved-value="0">
<generator class="native" />
</id>

<property name="name" column="name" />
<property name="age" column="age" />
<set name="address" table="t_address" cascade="all" order-by="zipcode asc"
            lazy="true" inverse="true">
<key column="user_id" /><!-- 确定关联的外键列 -->
<one-to-many class="com.model.TAddress" />
</set>
</class>
</hibernate-mapping>

其次是hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 2.0//EN"

 "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- properties -->
<!-- 数据库URL -->
<property name="hibernate.connection.url">jdbc:mysql://localhost/onetomany</property>
<!-- 数据库JDBC驱动 -->
<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>
<!-- 数据库用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库密码 -->
<property name="hibernate.connection.password">hello</property>
<!-- 数据库方言 -->
<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
<!-- 是否日志调试 -->
<property name="show_sql">true</property>
<!-- 是否使用数据库外连接 -->
<property name="use_outer_join">true</property>
<!-- 事务管理 使用JDBC Transaction(使用JTA会报错) -->
<property name="transaction.factory_class">
            net.sf.hibernate.transaction.JDBCTransactionFactory
</property>
<!-- 指定hibernate每次提交的SQL数量  对批量操作的性能提升帮助很大!!!!!!!!!!!!! -->
<property name="hibernate.jdbc.batch_size">25</property>
<!-- 映射文件配置,配置文件名必须包含其相对于根的全路径 -->
<mapping resource="com/model/TUser.hbm.xml" />
<mapping resource="com/model/TAddress.hbm.xml" />

</session-factory>

</hibernate-configuration>

测试代码(部分)

增加

public void testSave(){
		try {
			Transaction tx=session.beginTransaction();
			
//			TUser user=(TUser) session.load(TUser.class, 1);
			
			TUser user=new TUser();
			user.setName("zhangsan");
			user.setAge(20);
			
			TAddress address=new TAddress();
			address.setAddress("jingsan");
			address.setTel("1361380");
			address.setZipcode("45000");
			address.setType("java");
			address.setUser(user); //设置关联的TUser对象
			user.getAddress().add(address);
			
			session.save(user);   //级联更新
			tx.commit();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}

查询

	public void testLoad(){
		try {
			Transaction tx=session.beginTransaction();
			String hql="from TUser where name='zhangsan'";
			List list=session.createQuery(hql).list();
			System.out.println("-------------1------------");
			Iterator iter=list.iterator();
			while(iter.hasNext()){
				TUser user=(TUser) iter.next();
				System.out.println("--------------2------------");
				System.out.println("user.name="+user.getName());
				System.out.println("--------------3------------");
				System.out.println("user.address="+user.getAddress().size());
				System.out.println("--------------4------------");
			}
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		
	}

批量插入(可以提高性能)

 实现机制:如果使用了批量加载机制,hibernate在进行数据查询操作前,会自动在当前session中寻找是否还存在
 其他同类型待加载的数据,如果有,则将其查询条件合并在当前的select语句中一并提交,这样,通过
 一次数据库操作即完成了多个读取任务。

//批量插入操作性能优化  通过配置<property name="hibernate.jdbc.batch_size">25</property>
	public void testBatchInsert(){
		long start=System.currentTimeMillis();
		this.importUserList();
		long end=System.currentTimeMillis();
		System.out.println("批量插入花费时间是"+(end-start));
	}
	public void importUserList(){
		try {
			Transaction tx=session.beginTransaction();
			for(int i=0;i<10000;i++){
				TUser user=new TUser();
				user.setName("user"+i);
				session.save(user);
				if(i%25==0){    //以每25个数据作为一个处理单元
					session.flush();
					session.clear();
				}
			}
			tx.commit();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    hibernate多对多双向关联

    "hibernate_many2many_2"这个文件名可能是指一个关于Hibernate多对多关联的示例或教程的第二部分,可能包含配置文件、Java实体类、映射文件以及相关的测试代码。 **详细知识点:** 1. **实体类定义**:在Hibernate...

    Hibernate学习之 : 一对多关联映射

    在Java世界中,ORM(对象关系映射)框架如...总之,理解并熟练运用Hibernate的一对多关联映射是提升Java企业级开发效率的关键技能之一。通过不断的实践和学习,开发者可以更好地应对各种复杂的数据库操作需求。

    hibernate学习资料大全

    【hibernate学习资料大全】 Hibernate 是一个开源的对象关系映射(ORM)框架,它极大地简化了Java应用程序对数据库的操作。...希望这些资料能对CSDN的网友们在Hibernate学习之路上提供宝贵的帮助。

    传智播客hibernate教程_保存多对一关联关系的更进一步分析

    通过“传智播客hibernate教程_保存多对一关联关系的更进一步分析”,你将学习到如何在实际项目中有效地处理多对一关联,包括关联的配置、保存策略、事务管理和性能优化。该教程通过实例讲解,有助于加深理解和应用...

    Hibernate教程07_关系映射之一对一双向主键关联

    在" Hibernate教程07_关系映射之一对一双向主键关联"中,我们将学习如何设置这种关联。首先,我们需要创建两个实体类,例如`Employee`和`Department`。在每个类中,我们都需要定义主键字段,并用`@Id`注解标记。然后...

    hibernate学习入门一对多实体映射源码

    在这个“hibernate学习入门之一对多实体映射源码”教程中,我们将深入探讨如何在Hibernate中设置和管理一对多的关系。 一、Hibernate简介 Hibernate是Java开发人员用于处理数据库操作的强大工具,通过它,我们可以...

    Hibernate教程05_关系映射之一对一双向外键关联

    在Hibernate中,一对一关联的配置主要通过注解或XML配置文件完成。对于双向关联,我们需要在两个实体类中分别设置相应的属性和关联注解。 在实体类A中,我们将添加一个类型为B的属性,并使用`@OneToOne`注解来指定...

    hibernate一对多关联映射学习小结

    在Hibernate中,一对多关联映射和多对一关联映射的区别在于维护的关系不同。多对一关联映射中,多的一端维护一的一端的关系,在加载多的一端时,可以将一的一端加载上来。一对多关联映射中,一的一端维护多的一端的...

    hibernate 全面学习->hibernate 关联映射学习

    本文将深入探讨Hibernate的关联映射学习,包括一对多、多对一、一对一等多种关系映射的方式。 首先,我们来看一下“一对多”(One-to-Many)的映射关系。在Hibernate中,这种关系通常用在一个实体可以拥有多个子...

    Hibernate的多对一和一对多操作实例

    本文将深入探讨Hibernate框架下“多对一”和“一对多”的关联关系,并通过一个具体示例来阐述其操作流程与实现细节。 ### Hibernate中的“多对一”和“一对多” 在数据库设计中,“多对一”(Many-to-One)和“一...

    JavaEE学习笔记之Hibernate表关系之一对多(inverse详解)

    1. **关联的插入和更新**:在一对多关系中,如果设置`inverse="true"`,那么在保存或更新父实体时,Hibernate会自动处理与子实体的关联,添加新的子实体或更新已存在的关联。相反,如果在子实体上操作,Hibernate将...

    hibernate关联映射详解SSH 多对多,一对多关系对象映射

    本篇文章将深入探讨Hibernate中的一对多和多对多关系映射。 首先,让我们理解一对多关联映射。在数据库中,一对多关系意味着一个表中的记录可以与另一个表中的多个记录相关联。在Hibernate中,这可以通过在实体类中...

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

    **标题详解:**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中,关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库...

    Hibernate教程12_关系映射之一对多(多对一)双向关联

    本教程主要聚焦于Hibernate中的关系映射,特别是"一对多"(多对一)的双向关联。在数据库设计中,这种关系映射非常常见,比如一个用户可以有多个订单,而每个订单对应一个用户。 首先,我们需要理解"一对多"(One-...

    hibernate学习总结文档

    Hibernate 支持多种关联关系,如一对一(OneToOne)、一对多(OneToMany)、多对一(ManyToOne)和多对多(ManyToMany)。关联关系可以通过外键或代理键实现,配置包括懒加载(lazy loading)和级联操作(cascading...

    Hibernate教程14_关系映射之多对多双向关联

    标题"Hibernate教程14_关系映射之多对多双向关联"暗示我们将探讨如何在Hibernate中设置两个实体之间的双向多对多关联。双向意味着在两个实体类中,都可以直接访问到对方的集合。 在描述中提到的链接是一个CSDN博客...

    Hibernate多对多实例+数据库代码

    标题"Hibernate多对多实例+数据库代码"揭示了我们将在讨论一个使用Hibernate框架实现的多对多关系映射的实际案例。在这个实例中,开发人员将两个或多个实体之间的复杂关联转化为简单易懂的数据库操作。描述中提到...

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

    本教程主要探讨的是Hibernate中的一种重要关系映射类型:一对多单向关联。在关系型数据库中,一对多关联是最常见的关系类型,一个实体可以与多个其他实体相关联。在Hibernate中,这种关系可以通过配置XML映射文件或...

Global site tag (gtag.js) - Google Analytics