`

Hibernate 1+N 问题

阅读更多

1+N问题的描述:举例,多个主题(Topic)属于一个帖子(Category),一个帖子含有多个主题。当只需要查询Topic时不要查询Category时,如果@ManyToOne的属性fetch=FetchType.EAGER,这时查询所有Topic时,每查询一个Topic就会多产生一个SQL语句查询相关的Category表的数据,这样要是有N条Topic数据,就会产生1+N条SQL语句。同样的在@OneToMany的情况下,要是在Many方设置fetch=FetchType.EAGER,同样也会产生1+N的问题。

 

解决方案有三种:

  1. fetch=FetchType.LAZY,设为懒加载

  2. @BatchSize(size=5)代表一次取5条数据,这样取5条数据只要发出一条SQL语句,注意是用在被关联类上的(不建议用)

  3. 迫切左外连接检索 join fetch(Criteria 查询默认就是join fetch)

下面请看代码:

Category类

package com.lbx.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import org.hibernate.annotations.BatchSize;

@Entity
@BatchSize(size=2)
public class Category {
	
	private int id;
	private String name;
	
	@Id
	@GeneratedValue
	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;
	}
	
}

 

Topic类

package com.lbx.model;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Topic {

	private int id;
	private String title;
	private Category category;
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	
	//@ManyToOne(fetch=FetchType.LAZY)
	@ManyToOne
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
	
}

 

 

hibernate.cfg.xml文件配置

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/testhib</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>

        <!-- JDBC connection pool (use the built-in) -->
       <!-- <property name="connection.pool_size">1</property> --> 

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <!-- <property name="current_session_context_class">thread</property>  -->

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>

		<mapping class="com.lbx.model.Category"/>
		<mapping class="com.lbx.model.Topic"/>
		<mapping class="com.lbx.model.Msg"/>
		

    </session-factory>

</hibernate-configuration>

 

 

测试代码

package com.lbx.model.test;

import java.util.List;

import javax.persistence.FetchType;
import javax.persistence.ManyToOne;

import junit.framework.TestCase;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.lucene.Text;

import com.lbx.hibernate.Util.HibUtil;
import com.lbx.model.Category;
import com.lbx.model.Msg;
import com.lbx.model.Topic;

public class Test extends TestCase {
	
	@Text
	public void save(){
		Session session = HibUtil.getSession();
		session.beginTransaction();
		
		for (int i = 0; i < 3; i++) {
			Category c = new Category();
			c.setName("c" + i);
			Topic t = new Topic();
			t.setTitle("t" + i);
			t.setCategory(c);
			session.save(c);
			session.save(t);
		}
		
		session.beginTransaction().commit();
		session.close();
	}
	
	//1+N问题(这里我只要取出Topic就可以了)
	@Text
	public void testHQL_01(){
		Session session = HibUtil.getSession();
		session.beginTransaction();
		
		//List<Topic> topics = (List<Topic>)session.createCriteria(Topic.class).list();
		/**
		 * 这里要是不把Topic类中不设 @ManyToOne(fetch=FetchType.LAZY),这里就要发很多SQL语句,关联的表都会查
		 * 但是设了@ManyToOne(fetch=FetchType.LAZY) 之后就不会发出查询相关表的查询语句,用到的时候才发出
		 */
		Query q = session.createQuery("from Topic");
		List<Topic> topics = (List<Topic>)q.list();
		System.out.println(topics.size());
		for (int i = 0; i < topics.size(); i++) {
			System.out.println(topics.get(i).getId() + "  " + topics.get(i).getTitle());
		}
		session.beginTransaction().commit();
		session.close();
	}
	
	//用到被关联表的信息
	@Text
	public void testHQL_02(){
		Session session = HibUtil.getSession();
		session.beginTransaction();
		
		//List<Topic> topics = (List<Topic>)session.createCriteria(Topic.class).list();
		/**
		 * 这里要是不把Topic类中不设 @ManyToOne(fetch=FetchType.LAZY),这里就要发很多SQL语句,关联的表都会查
		 * 但是设了@ManyToOne(fetch=FetchType.LAZY) 之后就不会发出查询相关表的查询语句,用到的时候才发出
		 */
		Query q = session.createQuery("from Topic");
		List<Topic> topics = (List<Topic>)q.list();
		System.out.println(topics.size());
		for (int i = 0; i < topics.size(); i++) {
			System.out.println(topics.get(i).getId() + "  " + topics.get(i).getTitle());
			/**
			 * 注意,在这里要用到Category类的信息,所以就会发出相关的查询信息
			 */
			System.out.println(topics.get(i).getCategory().getId() + "  " + 
					topics.get(i).getCategory().getName());
		}
		session.beginTransaction().commit();
		session.close();
	}
	
	//@BatchSize的使用,其属性size=5就代表一次取5个
	@Text
	public void testHQL_03(){
		Session session = HibUtil.getSession();
		session.beginTransaction();
		
		//List<Topic> topics = (List<Topic>)session.createCriteria(Topic.class).list();
		/**
		 * 这里要是不把Topic类中不设 @ManyToOne(fetch=FetchType.LAZY),这里就要发很多SQL语句,关联的表都会查
		 * 但是设了@ManyToOne(fetch=FetchType.LAZY) 之后就不会发出查询相关表的查询语句,用到的时候才发出
		 */
		Query q = session.createQuery("from Topic");
		List<Topic> topics = (List<Topic>)q.list();
		System.out.println(topics.size());
		for (int i = 0; i < topics.size(); i++) {
			System.out.println(topics.get(i).getId() + "  " + topics.get(i).getTitle());
			/**
			 * 注意,在这里要用到Category类的信息,所以就会发出相关的查询信息
			 */
			System.out.println(topics.get(i).getCategory().getId() + "  " + 
					topics.get(i).getCategory().getName());
		}
		session.beginTransaction().commit();
		session.close();
	}
	
	// join fetch,迫切左外连接检索
	@Text
	public void testHQL_04(){
		Session session = HibUtil.getSession();
		session.beginTransaction();
		//Criteria 查询默认就是join fetch
		//List<Topic> topics = (List<Topic>)session.createCriteria(Topic.class).list();  
		/**
		 * 这里要是不把Topic类中不设 @ManyToOne(fetch=FetchType.LAZY),这里就要发很多SQL语句,关联的表都会查
		 * 但是设了@ManyToOne(fetch=FetchType.LAZY) 之后就不会发出查询相关表的查询语句,用到的时候才发出
		 */
		Query q = session.createQuery("from Topic t left join fetch t.category c");
		List<Topic> topics = (List<Topic>)q.list();
		System.out.println(topics.size());
		for (int i = 0; i < topics.size(); i++) {
			System.out.println(topics.get(i).getId() + "  " + topics.get(i).getTitle());
		}
		session.beginTransaction().commit();
		session.close();
	}
	
}

 

 

分享到:
评论

相关推荐

    Hibernate 1+N问题详解

    - 但同时也可能导致“N+1”问题,即除了主表查询外,还需要额外的查询来加载每个关联的子记录,这在子记录较多时可能会导致性能下降。 **2. FetchType.LAZY:** - `LAZY`加载方式则是延迟加载,即只有当真正访问到...

    hibernate N+1问题解决办法

    **标题:“Hibernate N+1问题解决办法”** 在Java开发中,使用Hibernate作为ORM框架时,我们可能会遇到一个性能上的问题,那就是著名的“N+1查询问题”。此问题源于不恰当的数据加载策略,可能导致数据库查询效率...

    hibernate n+1查询

    HIBERNATE的N+1查询问题 关联查询时

    Hibernate教程24_Hibernate的1+N问题

    本教程聚焦于一个常见问题——"1+N"查询问题,这是Hibernate在处理关联关系时可能出现的性能瓶颈。 在关系型数据库中,我们经常遇到一对多(1:N)的关系,比如一个用户可以有多个订单,一个部门可以有多个员工。在...

    Struts2+hibernate4+layui+mysql简单的网站后台管理系统

    Struts2+hibernate4+layui+mysql简单的网站后台管理系统 项目描述 简单的网站后台管理系统 运行环境 jdk7+tomcat7+mysql+myeclipse ...链接: https://pan.baidu.com/s/1qNkWrWmAk44sh8JHZE1RIw 密码: wt5n

    浅谈Hibernate n+1问题

    浅谈Hibernate n+1问题 Hibernate 是一个基于Java的持久层框架,它提供了对数据库的访问和管理功能。在使用 Hibernate 进行数据访问时,经常会遇到一个问题,即 n+1 问题。该问题是指在一次数据库查询中,需要执行...

    hibernate的n+1问题.docx

    《理解Hibernate中的N+1问题及其解决方案》 在Java开发中,Hibernate作为一款流行的ORM(对象关系映射)框架,极大地简化了数据库操作。然而,使用不当可能会导致性能瓶颈,其中最典型的就是“N+1次SELECT查询问题...

    How to solve the hibernate N+1 problem?

    标题 "如何解决Hibernate的N+1问题" 涉及的是一个常见的数据库查询优化问题,主要出现在使用Hibernate等ORM框架时。N+1问题是指在进行一对多或多对多关联查询时,原本期望通过一次SQL查询获取所有数据,但实际执行了...

    Struts2.3.6+hibernate4.3.5+Spring 4.0.5+oracle 10g的集成

    1. **Struts2.3.6**:这是一个基于MVC设计模式的Java Web框架,用于构建可维护性高、结构清晰的Web应用。Struts2提供了强大的动作类、拦截器、结果类型和模板技术,使得开发者能够更方便地处理请求和响应。 2. **...

    hibernate5.2.10+struts2.5项目开发jar包

    3. **更好的类型安全**:引入了EntityGraph,用于在实体级别定义加载策略,避免了潜在的N+1查询问题。 4. **JDBC 4.2支持**:利用新版本的JDBC API,提供更丰富的数据库交互能力。 5. **更好的事务管理**:支持...

    Struts2+Spring+Hibernate3.2+整合文档及事例程序.zip

    Struts2、Spring和Hibernate是Java Web开发中的三大框架,它们的整合应用极大地提升了开发效率和系统的可维护性。在“Struts2+Spring+Hibernate3.2+整合文档及事例程序.zip”这个压缩包中,包含了这些框架的集成教程...

    内容管理系统(hibernate3+struts2+spring2)130224.zip

    此外,确保正确配置数据库连接和实体映射,避免出现N+1查询或性能瓶颈。安全方面,Struts2的安全漏洞需要关注,及时更新到安全版本。 综上所述,内容管理系统(hibernate3+struts2+spring2)130224.zip是一个典型的...

    struts2+hibernate3+spring3分页

    SELECT * FROM table LIMIT (n-1) * pageSize, pageSize; ``` 其中,`n`为页码,`pageSize`为每页显示的数据条数。 **分页实现**:在SSH框架中,通常创建一个PageModel类来封装分页信息,包括总记录数、总页数、...

    struts2+spring2.5+hibernate3+Extjs3实现的简单人员管理

    值得注意的是,这个系统在设计时需考虑性能优化,例如合理使用缓存、避免N+1查询等,以保证系统在大数据量下的高效运行。 总结,Struts2+Spring2.5+Hibernate3+Extjs3的组合为开发人员提供了强大而灵活的工具,它们...

    jsp源码内容管理系统(hibernate3+struts2+spring2)

    - **国际化支持**:内置的国际化(i18n)支持使得应用程序能够适应不同的语言环境。 ##### 3. Spring 2 Spring 框架提供了一种轻量级的DI(依赖注入)和AOP(面向切面编程)实现方式,能够有效地管理整个系统的组件依赖...

    Spring3+hibernate3+struts2

    在IT行业中,SSH(Spring、Struts2、Hibernate)是一个非常经典的Java Web开发框架组合,被誉为"Spring3+Hibernate3+Struts2"。这个组合是企业级应用开发的常用选择,因为它提供了全面的控制反转(IoC)和面向切面...

    Struts2+Hibernate3.1+Spring2.0整合使用的所有包

    通常,整合所需的JAR包包括Struts2的core、plugin、i18n等相关模块,Hibernate的主库、方言、连接池和JPA支持等,以及Spring的核心、AOP、ORM、Web等模块。 整合这三个框架需要配置相应的XML文件,如Struts2的...

    struts+hibernate+spring集成实现分页

    在实际项目中,还需要考虑性能优化,比如缓存策略、避免N+1查询问题,以及如何处理用户跳转到非法页码等情况。此外,还可以使用Spring Data JPA等更高级的库来简化分页实现,提高开发效率。 通过SSH集成实现分页,...

    struts2 + spring2.5 + hibernate3.0 + oracle 整合实例

    但同时,也需要注意性能优化,例如合理设计数据库索引,避免N+1查询问题,以及使用缓存技术提升应用性能。 总的来说,这个SSH整合实例涵盖了Java Web开发中的多个关键点,包括MVC设计模式、依赖注入、事务管理以及...

Global site tag (gtag.js) - Google Analytics