Hibernate OneToMany 单向和双向配置对数据存取性能的比较

最新推荐文章于 2022-10-26 15:41:29 发布
最新推荐文章于 2022-10-26 15:41:29 发布
阅读量366 收藏
点赞数
分类专栏： JavaEE 文章标签： Hibernate SQL SQL Server JBoss log4j

1. 开篇说明：今天是春节长假的最后一天，春节过后博客将继续，这篇博客主要用来总结年前的研究结果，研究的主要Hibernate OneToMany 单向和双向配置对数据存取性能的问题。本文按照我测试实验的过程，最后得出结论。

 

2. 本文实验是基于之前博客EJB 学习阶段总结：JBoss下发布一个Toy企业应用，在此工程基础上，在实体中添加一对独立的一对多关系如下图：

 如上图Man和Lover是一对多关系，一个Man可以有多个Lover，为了简单我们设定Man和Lover都只有Id和name属性，我们在com.home.po中添加Entity Man和Lover的代码如下：

@Entity(name="Man")
@Table(name="k_man")
public class Man {

	private Long id;	
	private String name;
	private List<Lover> lovers;
	
	@Column
	@Id
	@GeneratedValue
	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 List<Lover> getLovers() {
		return lovers;
	}
	
	public void setLovers(List<Lover> lovers) {
		this.lovers = lovers;
	}
}

 

@Entity(name="Lover")
@Table(name="k_lover")
public class Lover {

	private Long id;
	private String name;
	
	@Column
	@Id
	@GeneratedValue
	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;
	}
}

 我要做的测试是像数据库中插入Man和Man对应的Lover，我们通过一个独立的EJB来完成，ＥＪＢ中ＳｅｓｓｉｏｎＢｅａｎ和接口代码如下：

public interface ManService {
	public void insertManListUni(Integer num, Integer loverNum);
	public void insertManListDul(Integer num, Integer loverNum);
}

 

@Stateless
@Remote(ManService.class)
public class ManServiceSession implements ManService {

	@PersistenceContext(unitName="com.home.po") 
	protected EntityManager em;
	
	@TransactionAttribute(TransactionAttributeType.REQUIRED)
	public void insertManListUni(Integer num, Integer loverNum) {
		List<Lover> lovers = getLoverList(loverNum);
		for(int i = 0 ; i < num ; i ++) {
			
		}
	}

	@TransactionAttribute(TransactionAttributeType.REQUIRED)
	public void insertManListDul(Integer num, Integer loverNum) {
		List<Lover> lovers = getLoverList(loverNum);
		for(int i = 0 ; i < num ; i ++) {
			
		}
	}
	
	public List<Lover> getLoverList(Integer loverNum) {
		List<Lover> lovers = new ArrayList<Lover>();
		for(int i = 0 ; i < loverNum ; i ++) {
			Lover l = new Lover();
			l.setName("kylin-test-lover-" + i);
			lovers.add(l);
		}
		return lovers;
	}

}

 

 

３　配置ＪＢｏｓｓ的日志文件，让其输出Ｈｉｂｅｒｎａｔｅ数据库操作语句

Hibernate日志输出文件配置在JBoss_Home\server\production\conf下jboss-log4j.xml文件中，要输出Hibernate的SQL语句只需在jboss-log4j.xml的配置文件中添加Category和相应的Appender，如下：

<appender name="SWFILE" class="org.jboss.logging.appender.DailyRollingFileAppender">
      <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/>
      <param name="File" value="${jboss.server.log.dir}/FFTrace.log"/>
      <param name="Encoding" value="UTF-8"/>
      <param name="Append" value="false"/>

      <param name="DatePattern" value="'.'yyyy-MM-dd"/>

      <layout class="org.apache.log4j.PatternLayout">
         <param name="ConversionPattern" value="%d %-5p [%c] %m%n"/>
      </layout>
   </appender>

<category name="org.hibernate.SQL" additivity="false">
   		<priority value="debug"/>
		<appender-ref ref="SWFILE" />
   	</category>

 

 

4 一对多单向配置下插入一个Man查看日志

在Man中添加单向配置：

@OneToMany (
			targetEntity=com.home.po.Lover.class,
			fetch=FetchType.LAZY,
			cascade = { CascadeType.ALL })
	@Cascade( { org.hibernate.annotations.CascadeType.ALL } )  
	@ForeignKey(name="MAN_TO_LOVER_FK")
	@JoinColumn(name = "MAN_ID")
	public List<Lover> getLovers() {
		if(lovers == null) {
			lovers = new ArrayList<Lover>();
		}
		return lovers;
	}

修给ManServiceSession的insertManListUni方法如下：

public void insertManListUni(Integer num, Integer loverNum) {	
		for(int i = 0 ; i < num ; i ++) {
			List<Lover> lovers = getLoverList(loverNum);
			Man m = new Man();
			m.setName("kylin-test-man-" + i);
			em.persist(m);
			for(Lover l : lovers) {
				m.getLovers().add(l);
			}
		}
	}

插入一个Man一个Man对应两个Lover后 查看日志如下：

2011-02-08 15:31:58,562 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 15:31:58,750 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 15:31:58,765 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 15:31:58,781 DEBUG [org.hibernate.SQL] insert into k_man (name, id) values (?, ?)
2011-02-08 15:31:58,781 DEBUG [org.hibernate.SQL] insert into k_lover (name, id) values (?, ?)
2011-02-08 15:31:58,781 DEBUG [org.hibernate.SQL] insert into k_lover (name, id) values (?, ?)
2011-02-08 15:31:58,781 DEBUG [org.hibernate.SQL] update k_lover set MAN_ID=? where id=?
2011-02-08 15:31:58,781 DEBUG [org.hibernate.SQL] update k_lover set MAN_ID=? where id=?

如上是插入一个Man，一个Man对应两个Lover，SQL语句统计如下:

3 select语句，1 insert Man语句，2 insert lover语句， 2 update lover语句，总共：8 SQL语句

依次推断得出计算SQL语句公式：假设插入Man的个数用 m表示，一个Man对应的Lover个数用 l表示，SQL总数用s表示：给出公式：S=（m + m*n）*2 + m*n,用此公式

插入1个Man，一个Man对应2个LoverSQL总数：（1+1*2）*2+1*2 =8
插入100个Man，一个Man对应1000个LoverSQL总数：（100+100*1000）*2+100*1000=300200

插入100个Man，一个Man对应1000个Lover 3次，记录操作时间如下：

 即完成插入100个Man，一个Man对应1000个Lover 需要时间大概是110秒

 

5 一对多双向下插入Man及对应的Lover查看日志

修改实体类

Man实体如下：

@OneToMany (
			targetEntity=com.home.po.Lover.class,
			fetch=FetchType.LAZY,
			cascade = { CascadeType.ALL },
			mappedBy = "man")
	@Cascade( { org.hibernate.annotations.CascadeType.ALL } )  
	@ForeignKey(name="MAN_TO_LOVER_FK")
	public List<Lover> getLovers() {
		if(lovers == null) {
			lovers = new ArrayList<Lover>();
		}
		return lovers;
	}

Lover实体添加Man属性如下：

private Man man;
	
	@ManyToOne
	public Man getMan() {
		return man;
	}

	public void setMan(Man man) {
		this.man = man;
	}

 修给ManServiceSession的insertManListDul方法如下

public void insertManListDul(Integer num, Integer loverNum) {
		for(int i = 0 ; i < num ; i ++) {
			List<Lover> lovers = getLoverList(loverNum);
			Man m = new Man();
			m.setName("kylin-test-man-" + i);
			em.persist(m);
			for(Lover l : lovers) {
				l.setMan(m);
				em.persist(l);
			}
		}
	}

 同样插入一个Man一个Man对应两个Lover后 查看日志如下：

2011-02-08 16:40:11,859 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 16:40:12,031 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 16:40:12,031 DEBUG [org.hibernate.SQL] select hibernate_sequence.nextval from dual
2011-02-08 16:40:12,046 DEBUG [org.hibernate.SQL] insert into k_man (name, id) values (?, ?)
2011-02-08 16:40:12,062 DEBUG [org.hibernate.SQL] insert into k_lover (man_id, name, id) values (?, ?, ?)
2011-02-08 16:40:12,062 DEBUG [org.hibernate.SQL] insert into k_lover (man_id, name, id) values (?, ?, ?) 

3 select语句，1 insert Man语句，2 insert lover语句， 总共：6 SQL语句

依次推断得出计算SQL语句公式：假设插入Man的个数用 m表示，一个Man对应的Lover个数用 l表示，SQL总数用s表示：给出公式：S=（m + m*n）*2 ,用此公式

插入1个Man，一个Man对应2个LoverSQL总数：（1+1*2）*2=6
插入100个Man，一个Man对应1000个LoverSQL总数：（100+100*1000）*2=200200

插入100个Man，一个Man对应1000个Lover 3次，记录操作时间如下：


  即完成插入100个Man，一个Man对应1000个Lover 需要时间大概是90秒

 

6 结论：比较步骤4和步骤5，可以看到同样是插入100个Man，一个Man对应1000个Lover 用双向配置节约了20秒时间，即结论：一对多关系一般推荐使用双向配置

iteye_1706
关注
专栏目录
（5）OneToMany单向、双向manytoone
FixedStar 的博客
11-12 1985
一、OneToMany单向 OneToMany说明是一个组知道有哪些成员，而成员不知道自己是哪个组（这是类层面的理解）。数据库方面还是多端（User）有外键属性。 若两个表中只写OneToMany,则必须写@JoinColumn(name=”groupId”)，否则hibernate会当成多对多建立中间表 Group（一端）/* * 一对多，即在一端加 * 并且不需要在多端加外键。 *
Hibernate 系列教程 单向一对多
11-30
理解并熟练掌握Hibernate的单向一对多关联，能够帮助开发者更高效地处理复杂的数据库操作，减少不必要的数据库交互，提高应用程序的性能。在实际项目中，应根据业务需求灵活选择关联类型，并合理优化查询策略，以...
JPA课程manyToMany OneToMany 等全部测试
11-13
JPA课程manyToMany OneToMany 等全部测试 注解， 有注释
hibernate annotations OneToMany与ManyToOne 分析 以及延迟加载性能分析
cool_rain_man的专栏
08-25 8604
在EJB3.0 规范中 多对一与一对多的双向关系， 多对一（就是@ManyToOne注解的这端，是多端哦 不要搞混了）这端总是双向关联端的主题(owner)端， 而一对多端的关联注解为 @OneToMany（mappedBy=" " ）其值是：多对一端的属性demo：被动方：其实也就是一方 或者说（OneToMany方）@Entitypublic class Customer exte
Hiberante(一十一) hibernate的高效解决办法(最佳方案)
hong199275的专栏
06-25 166
使用hibernate的最佳实践 1.在做关系尽可能使用单向关联， 不要使用双向关联 2.在大项目中(数据量如果超过百万条的项目)，使用hibernate可以酌情考虑一下几个原则： 2.1 不要 使用对象关联，尽可能用冗余字段来代替外键（使用冗余字段所带来的问题是，在修改时必须修改所有的冗余） 2.2 查询数据不再使用Hql，全部使用sql查询，如果涉及...
Hibernate one to many(many to one) 配置
03-20
NULL 博文链接：https://fqh1987.iteye.com/blog/791845
hibernate一对多关联映射（单向关联）
03-01
这篇博客文章“hibernate一对多关联映射（单向关联）”将深入讲解如何配置和使用这种映射关系。 在单向关联中，只有一个实体知道另一个实体的存在，也就是说，只有父实体（"一"的一端）有对子实体（"多"的一端）的...
一对多单向和双向映射
07-26
本篇将详细探讨"一对多单向和双向映射"这一主题，结合标签中的"源码"和"工具"，我们将深入理解这些概念，并可能涉及到具体的代码实现。 首先，映射是ORM框架的核心，它允许开发者将数据库表与Java类之间的关系进行...
hibernate03:多对一单向关联、多对一双向关联
08-12
本文主要探讨的是Hibernate中的两种关联关系：多对一单向关联和多对一双向关联。通过理解这两种关联方式，我们可以更好地设计和实现复杂的数据库模型。 首先，我们来看**多对一单向关联**。这种关联意味着一个实体...
Hibernate中的@OneToMany关系及其风险
专业的开发者“讨论”
04-23 307
最近，我在使用Hibernate持久化对象时遇到了麻烦。 我想通&#368...
Hibernate-一对多OneToMany
weixin_45335305的博客
06-10 885
例子： 一个班级对应多个学生 一对多：一的一方用se接口集合，不能用HashSet，因为Hibernate有自己的set实现。 set与list区别：set无序，set不重复 班级表： public class Clazz { private int id; private String name; private Set<Student> students; //get、set省略 } Clazz.hbm.xml 学生表： p
在 JPA 和Hibernate中映射多对多关系的 6 种方法
最新发布
allway2的博客
10-26 556
连接实体将使用 1 个用 @EmbeddedId 标记@Embeddable对象字段和 2 个用@MapsId标记的@ManyToOne来定义，这些字段指向@Embeddable类中定义的关键字段。在双向映射的情况下，如果需要快速导航并将 CRUD 操作级联到子集合关联，请将@OneToMany放在父实体上，如上述方法 2。有几种方法可以通过使用@ManyToMany、@OneToMany和@ManyToOne来映射 JPA 和Hibernate中的多对多关系，包括。此映射不会使用任何联接的实体。
Hibernate08_映射关系---OneToMany单向
chbxw
08-27 391
组和用户的关系–oneToMany1.1、用户User, 多的一方package com.chb.model;public class User { private int id; private String username; private String passwd; public User() {} public User(int id, String
Hibernate 使用 Annotation 之 OneToMany(单向关联关系)
liangoo7的专栏
10-10 8989
Java代码如下： package com.lwp.hibernate.Model; import java.io.Serializable; import java.util.HashSet; import java.util.Set; import javax.persistence.Column; import javax.persistence.Entity; import
[JavaEE - JPA] 性能优化: 4种触发懒加载的方式
热门推荐
不忘初心，好好沉淀
11-27 1万+
在一个JPA应用中，可以通过懒加载来提高应用的性能。这一点毋庸置疑，但是懒加载不等于不加载，在某个时刻还是需要加载这些数据的，那么如何触发这个加载的行为才能够事半功倍呢？这里我想说一点题外话，面试的时候我也会考察被面试者对于JPA/Hibernate的看法，得到的答复通常都包含了对JPA/Hibernate的一些”鄙夷”，比如JPA/Hibernate性能太菜了，现在主流的持久层框架是MyBatis
hibernate几个 OneToMany.错误总结
pyzheng的专栏
01-13 289
[url]http://alinazh.blog.51cto.com/5459270/1279354[/url] 错误一 org.hibernate.AnnotationException: [color=red][b]Collection has neither generic type or OneToMany.targetEntity() defined[/b][/color]: com...
Hibernate注解 @OneToMany 相关属性
weixin_30477797的博客
03-02 305
@OneToMany(fetch=FetchType,cascade=CascadeType) 可选 @OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段. fetch:表示抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库预先读取到内存 cascade:表示级联操作策略,对于OneToMany类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值