Hibernate的1+N(N+1)问题与解决方法

Hibernate的1+N问题：
fetch=FetchType.eager配置下，取某对象（Student）的自身属性，仍会导致其关联对象(Group)一并查询，本来只需要发1条SQL语句即可完成，结果却发了1+N条SQL语句，影响性能。

 解决方法：
1.fetch = FetchType.lazy , 开始只发关于本表的SQL语句，即等用到关联对象时，再发关联表的SQL语句。
2.在关联对象类上标注@BatchSize(size=x) , 设置管理对象查询时一次性查询多少条记录， 使转为为 1+n/x问题。（不推荐）
3.join fetch , 如 使用"from Student s left join fetch s.group g"， 进行表连接查询，此时就发1条SQL语句。

4.使用QBC查询，默认效果与3相同。

JUnit测试类：

 

import java.util.List;

import org.hibernate.Session;
import org.junit.Test;

import com.ekunt.Util.HibernateUtil;
import com.ekunt.entity.Group;
import com.ekunt.entity.Student;

/**
 * 演示Hibernate的1+N问题：
 * fetch=FetchType.eager配置下，
 * 取某对象（Student）的自身属性，仍会导致其关联对象(Group)一并查询，
 * 本来只需要发1条SQL语句即可完成，结果却发了1+N条SQL语句，影响性能。
 * 
 * 解决方法：
 * 1.fetch = FetchType.lazy , 开始只发关于本表的SQL语句，即等用到关联对象时，再发关联表的SQL语句。
 * 2.在关联对象类上标注@BatchSize(size=x) , 设置管理对象查询时一次性查询多少条记录， 使转为为 1+n/x问题。（不推荐）
 * 3.join fetch , 如 使用"from Student s left join fetch s.group g"， 进行表连接查询，此时就发1条SQL语句。
 * 4.使用QBC查询，默认效果与3相同。
 * 
 * @author E-Kunt
 *
 */
public class HibernateTest {

	@Test
	public void saveTest(){
		Group g1 = new Group("JAVA","JavaSE");
		Group g2 = new Group("ASP.NET","ASP.NET3.5");
		Student s1 = new Student("古月哥欠",35);
		Student s2 = new Student("纠结伦",45);
		s1.setGroup(g1);
		s2.setGroup(g2);
		
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		session.save(g1);
		session.save(g2);
		session.save(s1);
		session.save(s2);
		session.getTransaction().commit();
		HibernateUtil.closeSession(session);
	}
	
	@Test
	public void queryTest() {
		Session session = HibernateUtil.getSession();
		List<Student> students = session.createQuery("from Student").list();
		for(Student s : students) {
			System.out.println(s.getId() + "-" + s.getName());
		}
	}
	
	/**
	 * 1+N问题解决方法3
	 */
	@Test
	public void joinFetchTest() {
		Session session = HibernateUtil.getSession();
		List<Student> students = session.createQuery("from Student s left join fetch s.group g").list();
		for(Student s : students) {
			System.out.println(s.getId() + "-" + s.getName());
		}
	}
	
	/**
	 * 1+N问题解决方法4
	 */
	@Test
	public void QBCTest() {
		Session session = HibernateUtil.getSession();
		List<Student> students = session.createCriteria(Student.class).list();
		for(Student s : students) {
			System.out.println(s.getId() + "-" + s.getName());
		}
	}
	
	
}

小组实体类：

package com.ekunt.entity;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.BatchSize;


@Entity
@Table(name="t_group")
//@BatchSize(size=2) //1+N问题解决方法2
public class Group implements Serializable {
	private int id;
	private String name;
	private String description;
	
	public Group() {
		
	}
	
	public Group(String name, String description) {
		this.name = name;
		this.description = description;
	}

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	public String getDescription() {
		return description;
	}

	public void setId(int id) {
		this.id = id;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	@Override
	public String toString() {
		return "Group [id=" + id + ", name=" + name + ", description=" + description + "]";
	}
	
}

 

学生实体类：

package com.ekunt.entity;

import java.io.Serializable;

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

@Entity
@Table(name="t_student")
public class Student implements Serializable {
	private int id;
	private String name;
	private int age;
	private Group group;

	public Student() {

	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@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;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	@ManyToOne//(fetch=FetchType.LAZY) //1+N问题解决方法1
	@JoinColumn(name="group_id")
	public Group getGroup() {
		return group;
	}

	public void setGroup(Group group) {
		this.group = group;
	}


	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age +  "]";
	}
	

}

辅助工具类：

 

package com.ekunt.Util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtil {
	
	private static SessionFactory sessionFactory;
	private static Session session;
	
	/**
	 * 创建Configuration对象，读取hibernate.cfg.xml文件，完成初始化
	 */
	static{
		Configuration cfg = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();
		sessionFactory = cfg.buildSessionFactory(serviceRegistry);
	}

	/**
	 * 获取SessionFactory
	 * @return SessionFactory
	 */
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	
	/**
	 * 获取Session
	 * @return Session
	 */
	public static Session getSession() {
		session = sessionFactory.openSession();
		return session;
	}
	
	/**
	 * 关闭Session
	 */
	public static void closeSession(Session session) {
		if(session != null) {
			session.close();
			session = null;
		}
	}
	
	

}