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

最新推荐文章于 2020-06-10 11:14:51 发布
最新推荐文章于 2020-06-10 11:14:51 发布
阅读量363 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（5）OneToMany单向、双向manytoone
FixedStar 的博客
11-12 1972
一、OneToMany单向 OneToMany说明是一个组知道有哪些成员，而成员不知道自己是哪个组（这是类层面的理解）。数据库方面还是多端（User）有外键属性。 若两个表中只写OneToMany,则必须写@JoinColumn(name=”groupId”)，否则hibernate会当成多对多建立中间表 Group（一端）/* * 一对多，即在一端加 * 并且不需要在多端加外键。 *
JPA课程manyToMany OneToMany 等全部测试
11-13
JPA课程manyToMany OneToMany 等全部测试 注解， 有注释
hibernate annotations OneToMany与ManyToOne 分析 以及延迟加载性能分析
cool_rain_man的专栏
08-25 8600
在EJB3.0 规范中 多对一与一对多的双向关系， 多对一（就是@ManyToOne注解的这端，是多端哦 不要搞混了）这端总是双向关联端的主题(owner)端， 而一对多端的关联注解为 @OneToMany（mappedBy=" " ）其值是：多对一端的属性demo：被动方：其实也就是一方 或者说（OneToMany方）@Entitypublic class Customer exte
Hiberante(一十一) hibernate的高效解决办法(最佳方案)
hong199275的专栏
06-25 163
使用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 系列教程 单向一对多
11-30
理解并熟练掌握Hibernate的单向一对多关联，能够帮助开发者更高效地处理复杂的数据库操作，减少不必要的数据库交互，提高应用程序的性能。在实际项目中，应根据业务需求灵活选择关联类型，并合理优化查询策略，以...
hibernate一对多关联映射（单向关联）
03-01
这篇博客文章“hibernate一对多关联映射（单向关联）”将深入讲解如何配置和使用这种映射关系。 在单向关联中，只有一个实体知道另一个实体的存在，也就是说，只有父实体（"一"的一端）有对子实体（"多"的一端）的...
一对多单向和双向映射
07-26
本篇将详细探讨"一对多单向和双向映射"这一主题，结合标签中的"源码"和"工具"，我们将深入理解这些概念，并可能涉及到具体的代码实现。 首先，映射是ORM框架的核心，它允许开发者将数据库表与Java类之间的关系进行...
hibernate03:多对一单向关联、多对一双向关联
08-12
本文主要探讨的是Hibernate中的两种关联关系：多对一单向关联和多对一双向关联。通过理解这两种关联方式，我们可以更好地设计和实现复杂的数据库模型。 首先，我们来看**多对一单向关联**。这种关联意味着一个实体...
扼杀性能的 10 个常见 Hibernate 错误
236004的博客
01-11 4417
错误1：使用Eager Fetching FetchType.EAGER的启示已经讨论了好几年了，而且有很多文章对它进行了详细的解释。我自己也写了一篇。但不幸的是，它仍然是性能问题最常见的两个原因之一。 FetchType定义了Hibernate何时初始化关联。你可以使用@OneToMany，@ManyToOne，@ManyToMany和@OneToOneannotation注释的fe
Hibernate中的@OneToMany关系及其风险
专业的开发者“讨论”
04-23 304
最近，我在使用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
OneToMany()属性字段说明
孟美岐的博客
12-11 3780
@OneToMany(mappedBy = “groupinfo”, cascade = CascadeType.REMOVE, fetch = FetchType.LAZY) mappedBy这个注解只能够用在@OntToOne,@OneToMany,@manyToMany中，不能够用在@manyToOne中 mappedBy的值应该为一的一方的表名 CascadeType.REMOVE Cas...
[JavaEE - JPA] 性能优化: 4种触发懒加载的方式
热门推荐
不忘初心，好好沉淀
11-27 1万+
在一个JPA应用中，可以通过懒加载来提高应用的性能。这一点毋庸置疑，但是懒加载不等于不加载，在某个时刻还是需要加载这些数据的，那么如何触发这个加载的行为才能够事半功倍呢？这里我想说一点题外话，面试的时候我也会考察被面试者对于JPA/Hibernate的看法，得到的答复通常都包含了对JPA/Hibernate的一些”鄙夷”，比如JPA/Hibernate性能太菜了，现在主流的持久层框架是MyBatis
【JPA 级联保存/级联删除】@OneToMany （双向） 一对多--整个世界都干净了以及无法级联删除因为外键关联...
ncuitcast的博客
04-18 1698
[code="java"] http://blog.sina.com.cn/s/blog_6826662b01016ylz.html 看过前两篇帮助文档 【JPA】 @OneToOne 单向 和 【JPA】@OneToOne 双向 想必大家对级联操作已经充满了好奇和期待吧。那么本文将会想大家介绍JPA的级联保存操作。在此之前，我希望你能先看下这篇文档，对级联注释的各个属性有一个大概的...
Hibernate中的Entity类之间的OneToMany关联
成长的足迹
05-30 3193
OneToMany关联将一个父Entity类与若干个子Entity类联系起来。 1. 双向关联 通常，OneToMany关联都有与之反向的ManyToOne关联对应，两者成组出现，这被称为双向关联。 双向关联中，可以从任何一个Entity类实例访问关联的另一个Entity类实例（通过get*()方法）。 在数据库模式中，也只需要常规地，在子Entity类（owning side）中设置外键
Hibernate查询优化 HQL提高效率
xiaoli
04-11 1万+
1、Hibernate查询性能优化 1、1
Hibernate ORM教程：一对多单向关联实现
"一对多单向关联房间和人-hibernate基础教程" 在Java开发中，Hibernate是一个流行的ORM（对象关系映射）框架，它允许开发者使用面向对象的方式来操作数据库，消除了传统的JDBC代码与数据库之间的“阻抗不匹配”。本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值