`

hibernate中lazy的使用

HibernateSQLjunit单元测试 
阅读更多

lazy，延迟加载

Lazy的有效期：只有在session打开的时候才有效；session关闭后lazy就没效了。

lazy策略可以用在：

* <class>标签上：可以取值true/false

* <property>标签上，可以取值true/false，这个特性需要类增强

* <set>/<list>等集合上，可以取值为true/false/extra

* <one-to-one>/<many-to-one>等标签上，可以取值false/proxy/no-proxy

6.1 get和load的区别：

* get不支持延迟加载，而load支持。

* 当查询特定的数据库中不存在的数据时，get会返回null，而load则抛出异常。

6.2 类(Class)的延迟加载：

* 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)

* 如果lazy的属性值为true，那么在使用load方法加载数据时，只有确实用到数据的时候才会发出sql语句；这样有可能减少系统的开销。

* //不会发出查询sql

       System.out.println("group id=" + group.getId());

这里有一个问题，为什么加载主键的时候不需要发出sql语句。

6.3 集合(collection)的延迟加载：可以取值true，false，extra

* 保持集合上的lazy的默认值，此时的效果和lazy="extra"是基本一样的。

   * 设置集合上的lazy=extra,此时的效果和lazy属性的默认值是基本一样的。但是推荐使用这个属性值，因为在统计时这种情况显得比较智能。当然延迟是有效果的。

* 设置集合上的lazy=false

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其集合元素的数据

false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据

extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate

并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

6.4 Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置

懒加载策略。可以取值为：false/proxy/no-proxy

false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象

proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候才真正发出查询语句查询其对象数据，其关联对象是代理类

no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类

注意：在class标签上配置的lazy属性不会影响到关联对象!!!

 

Java代码 复制代码
  1. <hibernate-mapping>   
  2.     <class name="com.bjsxt.hibernate.Group" table="t_group">   
  3.         <id name="id">   
  4.             <generator class="native"/>   
  5.         </id>   
  6.         <property name="name"/>   
  7.     </class>   
  8. </hibernate-mapping>    
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>


Java代码 复制代码
  1. package com.bjsxt.hibernate;   
  2. import org.hibernate.Session;   
  3.   
  4. import com.bjsxt.hibernate.Group;   
  5. import com.bjsxt.hibernate.HibernateUtils;   
  6.   
  7.   
  8. public class InitData {   
  9.   
  10.     public static void main(String[] args) {   
  11.         Session session = null;   
  12.         try {   
  13.             session = HibernateUtils.getSession();   
  14.             session.beginTransaction();   
  15.             Group group = new Group();   
  16.             group.setName("java开发组");   
  17.             session.save(group);   
  18.             session.getTransaction().commit();   
  19.         }catch(Exception e) {   
  20.             e.printStackTrace();   
  21.             session.getTransaction().rollback();   
  22.         }finally {   
  23.             HibernateUtils.closeSession(session);   
  24.         }      
  25.     }   
  26.   
  27. }  
package com.bjsxt.hibernate;
import org.hibernate.Session;

import com.bjsxt.hibernate.Group;
import com.bjsxt.hibernate.HibernateUtils;


public class InitData {

	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Group group = new Group();
			group.setName("java开发组");
			session.save(group);
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

}

 

Java代码 复制代码
  1.   
  2. package com.bjsxt.hibernate;   
  3.   
  4. import org.hibernate.Session;   
  5.   
  6. import junit.framework.TestCase;   
  7.   
  8. /**  
  9.  * 运行本单元测试的前提条件：  
  10.  * 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)  
  11.  *   
  12.  * @author Administrator  
  13.  *  
  14.  */  
  15. public class ClassLazyTest extends TestCase {   
  16.   
  17.     public void testLoadGroup1() {   
  18.         Session session = null;   
  19.         try {   
  20.             session = HibernateUtils.getSession();   
  21.                
  22.             //不会发出查询sql   
  23.             Group group = (Group)session.load(Group.class, 1);   
  24.                
  25.             //不会发出查询sql   
  26.             System.out.println("group id=" + group.getId());   
  27.                
  28.             //发出查询sql，加载数据到Group   
  29.             System.out.println("group name=" + group.getName());   
  30.                
  31.             //不会发出查询sql   
  32.             System.out.println("group name=" + group.getName());   
  33.         }catch(Exception e) {   
  34.             e.printStackTrace();   
  35.         }finally {   
  36.             HibernateUtils.closeSession(session);   
  37.         }      
  38.     }   
  39.   
  40.     public void testLoadGroup2() {   
  41.         Session session = null;   
  42.         Group group = null;   
  43.         try {   
  44.             session = HibernateUtils.getSession();   
  45.                
  46.             //不会发出查询sql   
  47.             group = (Group)session.load(Group.class, 1);   
  48.                
  49.         }catch(Exception e) {   
  50.             e.printStackTrace();   
  51.         }finally {   
  52.             HibernateUtils.closeSession(session);   
  53.         }   
  54.         //不能正常输出，抛出了 LazyInitializationException，因为session已经关闭了   
  55.         //注意：Hibernate支持Lazy策略，只有session打开状态才有效        
  56.         System.out.println("group name=" + group.getName());   
  57.            
  58.     }   
  59.        
  60.        
  61. }  
package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 运行本单元测试的前提条件：
 * 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)
 * 
 * @author Administrator
 *
 */
public class ClassLazyTest extends TestCase {

	public void testLoadGroup1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Group group = (Group)session.load(Group.class, 1);
			
			//不会发出查询sql
			System.out.println("group id=" + group.getId());
			
			//发出查询sql，加载数据到Group
			System.out.println("group name=" + group.getName());
			
			//不会发出查询sql
			System.out.println("group name=" + group.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testLoadGroup2() {
		Session session = null;
		Group group = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			group = (Group)session.load(Group.class, 1);
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
		//不能正常输出，抛出了 LazyInitializationException，因为session已经关闭了
		//注意：Hibernate支持Lazy策略，只有session打开状态才有效		
		System.out.println("group name=" + group.getName());
		
	}
	
	
}





---------------------------------------------------------------------
集合类测试

Java代码 复制代码
  1. <hibernate-mapping>   
  2.     <class name="com.bjsxt.hibernate.Classes" table="t_classes">   
  3.         <id name="id">   
  4.             <generator class="native"/>   
  5.         </id>   
  6.         <property name="name"/>   
  7.         <!--    
  8.             <set name="students" cascade="all" order-by="id">   
  9.          -->   
  10.          <set name="students" lazy="extra">   
  11.             <key column="classid"/>   
  12.             <one-to-many class="com.bjsxt.hibernate.Student"/>   
  13.         </set>   
  14.     </class>   
  15. </hibernate-mapping>   
  16.   
  17. <hibernate-mapping>   
  18.     <class name="com.bjsxt.hibernate.Student" table="t_student">   
  19.         <id name="id">   
  20.             <generator class="native"/>   
  21.         </id>   
  22.         <property name="name"/>   
  23.     </class>   
  24. </hibernate-mapping>  
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Classes" table="t_classes">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!-- 
			<set name="students" cascade="all" order-by="id">
		 -->
		 <set name="students" lazy="extra">
			<key column="classid"/>
			<one-to-many class="com.bjsxt.hibernate.Student"/>
		</set>
	</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>


Java代码 复制代码
  1. package com.bjsxt.hibernate;   
  2.   
  3. import java.util.Iterator;   
  4. import java.util.Set;   
  5.   
  6. import org.hibernate.Session;   
  7.   
  8. import junit.framework.TestCase;   
  9.   
  10. /**  
  11.  * 保持lazy的默认值  
  12.  * @author Administrator  
  13.  *  
  14.  */  
  15. public class CollectionLazyTest1 extends TestCase {   
  16.        
  17.     public void testLoadClasses1() {   
  18.         Session session = null;   
  19.         try {   
  20.             session = HibernateUtils.getSession();   
  21.                
  22.             //不会发出查询sql   
  23.             Classes classes = (Classes)session.load(Classes.class, 1);   
  24.                
  25.             //会发出一条查询sql，加载数据到classes   
  26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
  27.                
  28.             //不会发出查询sql   
  29.             Set students = classes.getStudents();   
  30.                
  31.             //会发出一条查询sql，加载数据到Students   
  32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
  33.                 Student student = (Student)iter.next();   
  34.                 System.out.println(student.getName());   
  35.             }   
  36.         }catch(Exception e) {   
  37.             e.printStackTrace();   
  38.         }finally {   
  39.             HibernateUtils.closeSession(session);   
  40.         }      
  41.     }   
  42.        
  43.     public void testLoadClasses2() {   
  44.         Session session = null;   
  45.         try {   
  46.             session = HibernateUtils.getSession();   
  47.                
  48.             //不会发出查询sql   
  49.             Classes classes = (Classes)session.load(Classes.class, 1);   
  50.                
  51.             //会发出一条查询sql，加载数据到classes   
  52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
  53.   
  54.             //不会发出查询sql    
  55.             Set students = classes.getStudents();   
  56.                
  57.             //会发出一条查询sql，加载全部的数据到Students   
  58.             System.out.println(students.size());   
  59.                
  60.         }catch(Exception e) {   
  61.             e.printStackTrace();   
  62.         }finally {   
  63.             HibernateUtils.closeSession(session);   
  64.         }      
  65.     }   
  66.        
  67. }  
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 保持lazy的默认值
 * @author Administrator
 *
 */
public class CollectionLazyTest1 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到Students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载全部的数据到Students
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}


Java代码 复制代码
  1. package com.bjsxt.hibernate;   
  2.   
  3. import java.util.Iterator;   
  4. import java.util.Set;   
  5.   
  6. import org.hibernate.Session;   
  7.   
  8. import junit.framework.TestCase;   
  9.   
  10. /**  
  11.  * 设置集合上的lazy=false  
  12.  * @author Administrator  
  13.  *  
  14.  */  
  15. public class CollectionLazyTest2 extends TestCase {   
  16.        
  17.     public void testLoadClasses1() {   
  18.         Session session = null;   
  19.         try {   
  20.             session = HibernateUtils.getSession();   
  21.                
  22.             //不会发出查询sql   
  23.             Classes classes = (Classes)session.load(Classes.class, 1);   
  24.                
  25.             //会发出两条查询sql，加载数据到classes和Students中   
  26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
  27.                
  28.             //不会发出查询sql   
  29.             Set students = classes.getStudents();   
  30.                
  31.             //不会发出查询sql   
  32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
  33.                 Student student = (Student)iter.next();   
  34.                 System.out.println(student.getName());   
  35.             }   
  36.         }catch(Exception e) {   
  37.             e.printStackTrace();   
  38.         }finally {   
  39.             HibernateUtils.closeSession(session);   
  40.         }      
  41.     }   
  42.        
  43.     public void testLoadClasses2() {   
  44.         Session session = null;   
  45.         try {   
  46.             session = HibernateUtils.getSession();   
  47.                
  48.             //不会发出查询sql   
  49.             Classes classes = (Classes)session.load(Classes.class, 1);   
  50.                
  51.             //会发出两条查询sql，加载数据到classes和Students中   
  52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
  53.   
  54.             //不会发出查询sql    
  55.             Set students = classes.getStudents();   
  56.                
  57.             //不会发出查询sql    
  58.             System.out.println(students.size());   
  59.                
  60.         }catch(Exception e) {   
  61.             e.printStackTrace();   
  62.         }finally {   
  63.             HibernateUtils.closeSession(session);   
  64.         }      
  65.     }   
  66.        
  67. }  
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=false
 * @author Administrator
 *
 */
public class CollectionLazyTest2 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//不会发出查询sql
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//不会发出查询sql	
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

 

Java代码 复制代码
  1. package com.bjsxt.hibernate;   
  2.   
  3. import java.util.Iterator;   
  4. import java.util.Set;   
  5.   
  6. import org.hibernate.Session;   
  7.   
  8. import junit.framework.TestCase;   
  9.   
  10. /**  
  11.  * 设置集合上的lazy=extra  
  12.  * @author Administrator  
  13.  *  
  14.  */  
  15. public class CollectionLazyTest3 extends TestCase {   
  16.        
  17.     public void testLoadClasses1() {   
  18.         Session session = null;   
  19.         try {   
  20.             session = HibernateUtils.getSession();   
  21.                
  22.             //不会发出查询sql   
  23.             Classes classes = (Classes)session.load(Classes.class, 1);   
  24.                
  25.             //会发出一条查询sql，加载数据到classes   
  26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
  27.                
  28.             //不会发出查询sql   
  29.             Set students = classes.getStudents();   
  30.                
  31.             //会发出一条查询sql，加载数据到students   
  32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
  33.                 Student student = (Student)iter.next();   
  34.                 System.out.println(student.getName());   
  35.             }   
  36.         }catch(Exception e) {   
  37.             e.printStackTrace();   
  38.         }finally {   
  39.             HibernateUtils.closeSession(session);   
  40.         }      
  41.     }   
  42.        
  43.     public void testLoadClasses2() {   
  44.         Session session = null;   
  45.         try {   
  46.             session = HibernateUtils.getSession();   
  47.                
  48.             //不会发出查询sql   
  49.             Classes classes = (Classes)session.load(Classes.class, 1);   
  50.                
  51.             //会发出一条查询sql，加载数据到classes   
  52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
  53.   
  54.             //不会发出查询sql    
  55.             Set students = classes.getStudents();   
  56.   
  57.             //会发出一条较为智能的查询sql，如：   
  58.             //select count(id) from t_student where classid =?   
  59.             System.out.println(students.size());   
  60.                
  61.         }catch(Exception e) {   
  62.             e.printStackTrace();   
  63.         }finally {   
  64.             HibernateUtils.closeSession(session);   
  65.         }      
  66.     }   
  67.        
  68. }  
package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=extra
 * @author Administrator
 *
 */
public class CollectionLazyTest3 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();

			//会发出一条较为智能的查询sql，如：
			//select count(id) from t_student where classid =?
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}


----------------------------------------------------------------

单端关联加载


Java代码 复制代码
  1.   
  2. <hibernate-mapping>   
  3.     <class name="com.bjsxt.hibernate.Group" table="t_group">   
  4.         <id name="id">   
  5.             <generator class="native"/>   
  6.         </id>   
  7.         <property name="name"/>   
  8.     </class>   
  9. </hibernate-mapping>   
  10.   
  11. <hibernate-mapping>   
  12.     <class name="com.bjsxt.hibernate.User" table="t_user" >   
  13.         <id name="id">   
  14.             <generator class="native"/>   
  15.         </id>   
  16.         <property name="name"/>   
  17.         <!--   
  18.         <many-to-one name="group" column="relatedGroup" />   
  19.          -->   
  20.            
  21.         <many-to-one name="group" column="relatedGroup"/>    
  22.     </class>   
  23. </hibernate-mapping>        
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.User" table="t_user" >
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!--
		<many-to-one name="group" column="relatedGroup" />
		 -->
		
		<many-to-one name="group" column="relatedGroup"/> 
	</class>
</hibernate-mapping>


Java代码 复制代码
  1. package com.bjsxt.hibernate;   
  2.   
  3. import org.hibernate.Session;   
  4.   
  5. import junit.framework.TestCase;   
  6.   
  7. /**  
  8.  * 所有lazy的属性默认  
  9.  * @author Administrator  
  10.  *  
  11.  */  
  12. public class SingleEndTest1 extends TestCase {   
  13.   
  14.     public void testLoadUser() {   
  15.         Session session = null;   
  16.         try {   
  17.             session = HibernateUtils.getSession();   
  18.                
  19.             //不会发出查询sql   
  20.             User user = (User)session.load(User.class, 2);   
  21.                
  22.             //会发出一条查询sql，转载数据到User   
  23.             System.out.println("user name=" + user.getName());   
  24.                
  25.             //不会发出查询sql   
  26.             Group group = user.getGroup();   
  27.  
    分享到：
    | Window.open() 全攻略
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    hibernate 中的lazy属性祥解.txt

    在探讨Hibernate框架中的`lazy`属性时，我们深入解析了其功能、应用场景以及与之相关的潜在问题，尤其关注于如何有效利用此特性以优化数据库性能和应用响应速度。 ### Hibernate框架简介 Hibernate是一个开放源码...

    hibernate的lazy策略forClass

    在Java的持久化框架Hibernate中，懒加载（Lazy Loading）是一种重要的对象关系映射策略，用于提高应用程序的性能。懒加载的基本思想是延迟加载，即当真正需要数据时，才去数据库加载。在这个场景中，我们关注的是...

    gilead hibernate lazyload例子

    在Flex中使用Gilead和Hibernate的懒加载，首先需要确保在Hibernate配置文件中对关联实体设置了懒加载属性。例如，如果有一个`User`类和一个`Address`类，`User`中包含一个`List&lt;Address&gt;`，那么在`User`的映射文件中...

    Dwr+Hibernate的Lazy问题

    然而，在DWR场景下，由于DWR需要将Java对象转换为JSON格式，以便在JavaScript中使用，这会触发getter方法，从而无意中激活了延迟加载，导致每访问一个延迟加载属性，就会执行一条SQL查询。 解决方案： 1. 使用`...

    Hibernate lazy延迟加载

    在Java的持久化框架Hibernate中，懒加载（Lazy Loading）是一种重要的优化策略，它的核心思想是“延迟加载”或“按需加载”。默认情况下，当一个实体被加载时，并不会立即加载其关联的对象或集合，而是在真正需要...

    Hibernate lazy加载FOR Connection

    标题中的“Hibernate lazy加载FOR Connection”指的是Hibernate框架中的一种特性，即懒加载（Lazy Loading）。在Hibernate中，懒加载是一种优化策略，它推迟对关联对象的加载，直到真正需要使用这些对象时才进行加载...

    当设置lazy=true时，怎样使用extjs和Hibernate

    标题"当设置lazy=true时，怎样使用ExtJS和Hibernate"所涉及的知识点主要集中在如何在ExtJS前端应用中与使用了懒加载特性的Hibernate后端进行交互。以下是对这个主题的详细解释： 1. **Hibernate懒加载**： - 懒...

    hibernate在集合上的lazy策略

    7. **最佳实践**：提供关于在实际项目中使用懒加载的最佳实践，包括避免在视图层触发懒加载，以及合理设计数据访问模式。 8. **源码分析**：深入到Hibernate的源码层面，解析懒加载的实现细节，帮助读者理解其工作...

    Hibernate延时加载与lazy机制.doc

    综上，理解并正确使用Hibernate的延迟加载和懒加载机制对于优化应用程序性能至关重要。开发者需要谨慎处理Session的生命周期，确保在合适的时间访问延迟加载的属性，避免引发异常。同时，合理设计实体关系和懒加载...

    hibernate中文参考文档pdf

    14. **Hibernate与JPA**：比较Hibernate与Java Persistence API（JPA）的关系，以及如何在JPA规范下使用Hibernate。 15. **其他高级特性**：包括实体继承、多态性、集合映射、复杂类型、时间/日期处理、SQL特定功能...

    hibernate中文文档 HTML格式

    3. 异步操作：通过使用Hibernate的异步API，可以在后台线程中执行数据库操作，不阻塞主线程。 4. 事件监听：可以注册监听器来响应特定的ORM事件，如对象的保存、更新或删除。 在“Hibernate中文文档 HTML格式”中，...

    hibernate在单端关联上的lazy策略

    而“工具”则可能涵盖了如何在实际项目中使用Hibernate的懒加载功能。 在压缩包文件“hibernate_lazy_for_single_end”中，可能包含了一些示例代码或测试用例，帮助读者理解并实践Hibernate的单端关联懒加载策略。...

    Hibernate使用指南

    Hibernate 的主要作用是将 Java 对象映射到关系数据库表中，从而使得 Java 程序员可以使用面向对象的编程思想来操作数据库。 二、 Hibernate 的优点 Hibernate 的优点有很多，以下是一些主要的优点： * 轻量级...

    hibernate 3.6 中文 chm

    12. **延迟加载（Lazy Loading）**：为了提高性能，Hibernate支持属性和关联的延迟加载，即只有在真正需要时才加载数据。 13. **事件监听器**：Hibernate允许定义事件监听器来处理特定的数据库操作，如对象的保存、...

    hibernate 中 fetch=FetchType.LAZY 懒加载失败处理方法

    当我们在 Hibernate 中使用懒加载特性时，可能会遇到 LazyInitializationException 异常，这是因为 Hibernate 的 Session 生命周期太短，导致了懒加载失败。 为了解决这个问题，我们可以使用 Spring 提供的一个支持...

    hibernate_reference中文版和Hibernate中文手册

    《Hibernate参考指南中文版》与《Hibernate中文手册》是学习Java领域中ORM（对象关系映射）框架Hibernate的重要参考资料。Hibernate作为一个开源的、强大的持久化框架，极大地简化了数据库操作，使得开发人员能够以...

    Hibernate中文API大全

    你必须作出一个选择，要么在组合元素中使用不能为空的属性，要么选择使用,,&lt;bag&gt; 或者 而不是 。 组合元素有个特别的用法是它可以包含一个元素。类似这样的映射允许你将一个many-to-many关联表映射为组合元素的...

    hibernate中文文档

    6. **懒加载（Lazy Loading）**：为了提高性能，Hibernate支持懒加载机制，即关联的对象在需要时才从数据库加载，而不是在加载主体对象时一起加载。 7. **缓存（Caching）**：Hibernate集成了二级缓存机制，可以...

    hibernate

    根据提供的文件信息，我们可以深入探讨Hibernate框架中的几个关键概念，特别是`fetch`, `lazy`, `cascade`, 和 `inverse`关键字的使用与理解。这四个概念在处理对象关系映射（ORM）时非常重要，尤其是在Java环境下...

Magicbox
Global site tag (gtag.js) - Google Analytics