[SXT][WY]Hibernate09 Lazy策略

2024-01-25 19:48
文章标签 策略 lazy wy sxt hibernate09

本文主要是介绍[SXT][WY]Hibernate09 Lazy策略，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

hibernate lazy策略可以使用在：
 * <class>标签上，可以取值：true/false
 * <property>标签上，可以取值：true/false需要类增强工具
 * <set><list>标签上，可以取值：true/false/extra
 * <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy
 
lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用

 

Group.hbm.xml  class's default 'lazy' value is 'true'

 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Group" table="t_group">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
 </class>
</hibernate-mapping>

 

public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Group group = (Group)session.load(Group.class, 1);
   
   //不会发出sql
   System.out.println("group.id=" + group.getId());
   
   //会发出sql
   System.out.println("group.name=" + group.getName());
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }

 

public void testLoad2() {
  Session session = null;
  Group group = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   group = (Group)session.load(Group.class, 1);
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
  
  //不能正确输出，抛出LazyInitializationException 异常，因为session已经关闭
  //hibernate支持lazy策略只有在session打开状态下有效
  System.out.println("group.name=" + group.getName());
 } 

 

 

lazy_for_collection

hibernate在集合上的lazy策略，可以取值：true/false/extra

<class>标签上的lazy不会影响到集合上的lazy特性

 

// class lazy is default 'true'

public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //会发出sql
   for (Iterator iter=students.iterator(); iter.hasNext();) {
    Student student = (Student)iter.next();
    System.out.println("student.name=" + student.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 } 

// class lazy is default 'true'

public void testLoad2() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //会发出sql,发出查询全部数据的sql
   System.out.println("student.count=" + students.size());
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }  

 

// class lazy is 'false', but set lazy is default 'true'

public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //不会发出sql
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //会发出sql
   for (Iterator iter=students.iterator(); iter.hasNext();) {
    Student student = (Student)iter.next();
    System.out.println("student.name=" + student.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }

 

/**
 * 设置集合上的lazy=false,其它默认
 */

public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql,会发出两条sql分别加载Classes和Student
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //不会发出sql
   for (Iterator iter=students.iterator(); iter.hasNext();) {
    Student student = (Student)iter.next();
    System.out.println("student.name=" + student.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 } 

/**
 * 设置集合上的lazy=false,其它默认
 */

public void testLoad2() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql,会发出两条sql分别加载Classes和Student
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //不会发出sql
   System.out.println("student.count=" + students.size());
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }  

 

/**
 * 设置集合上的lazy=extra,其它默认
 */

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
 <class name="Classes" table="t_classes">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="students" inverse="true" cascade="all" lazy="extra">
   <key column="classesid"/>
   <one-to-many class="Student"/>
  </set>
 </class>
</hibernate-mapping>

 

public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   
   //会发出sql
   for (Iterator iter=students.iterator(); iter.hasNext();) {
    Student student = (Student)iter.next();
    System.out.println("student.name=" + student.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }

 

public void testLoad2() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   Classes classes = (Classes)session.load(Classes.class, 1);
   
   //会发出sql
   System.out.println("classes.name=" + classes.getName());
   
   //不会发出sql
   Set students = classes.getStudents();
   //会发出sql,发出一条比较智能的sql
   System.out.println("student.count=" + students.size());
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }  

 

 

lazy_for_single_end

 

hibernate在单端关联上的lazy策略，可以取值：false/proxy/noproxy

<class>标签上的lazy不会影响到单端关联上的lazy特性

 

/**
 * 所有lazy属性默认
 */
public class SingleEndTest1 extends TestCase {
 
 public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   User user = (User)session.load(User.class, 1);
   
   //会发出sql
   System.out.println("user.name=" + user.getName());
   
   //不会发出sql
   Group group = user.getGroup();
   
   //会发出sql
   System.out.println("group.name=" + group.getName());
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 } 
 
}

 

/**
 * 将<many-to-one>中的lazy设置为false,其它默认
 */
public class SingleEndTest2 extends TestCase {
 
 public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //不会发出sql
   User user = (User)session.load(User.class, 1);
   
   //会发出sql，发出两条sql分别加载User和Group
   System.out.println("user.name=" + user.getName());
   
   //不会发出sql
   Group group = user.getGroup();
   
   //不会发出sql
   System.out.println("group.name=" + group.getName());
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 } 
 
}

 

/**
 * <class>标签上的lazy=false,其它默认
 */
public class SingleEndTest3 extends TestCase {
 
 public void testLoad1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   //会发出sql
   User user = (User)session.load(User.class, 1);
   
   //不会发出sql
   System.out.println("user.name=" + user.getName());
   
   //不会发出sql
   Group group = user.getGroup();
   
   //会发出sql
   System.out.println("group.name=" + group.getName());
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 } 
 
}

 

 

这篇关于[SXT][WY]Hibernate09 Lazy策略的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/644413。

相关文章

MySQL 分区与分库分表策略应用小结

MySQL 分区与分库分表策略应用小结

《MySQL分区与分库分表策略应用小结》在大数据量、复杂查询和高并发的应用场景下,单一数据库往往难以满足性能和扩展性的要求,本文将详细介绍这两种策略的基本概念、实现方法及优缺点,并通过实际案例展示如... 目录mysql 分区与分库分表策略1. 数据库水平拆分的背景2. MySQL 分区策略2.1 分区概念
阅读更多...
SpringBoot如何通过Map实现策略模式

SpringBoot如何通过Map实现策略模式

《SpringBoot如何通过Map实现策略模式》策略模式是一种行为设计模式,它允许在运行时选择算法的行为,在Spring框架中,我们可以利用@Resource注解和Map集合来优雅地实现策略模式,这... 目录前言底层机制解析Spring的集合类型自动装配@Resource注解的行为实现原理使用直接使用M
阅读更多...
Redis 内存淘汰策略深度解析(最新推荐)

Redis 内存淘汰策略深度解析(最新推荐)

《Redis内存淘汰策略深度解析(最新推荐)》本文详细探讨了Redis的内存淘汰策略、实现原理、适用场景及最佳实践,介绍了八种内存淘汰策略,包括noeviction、LRU、LFU、TTL、Rand... 目录一、 内存淘汰策略概述二、内存淘汰策略详解2.1 ​noeviction（不淘汰）​2.2 ​LR
阅读更多...
Spring中@Lazy注解的使用技巧与实例解析

Spring中@Lazy注解的使用技巧与实例解析

《Spring中@Lazy注解的使用技巧与实例解析》@Lazy注解在Spring框架中用于延迟Bean的初始化,优化应用启动性能,它不仅适用于@Bean和@Component,还可以用于注入点,通过将... 目录一、@Lazy注解的作用（一）延迟Bean的初始化（二）与@Autowired结合使用二、实例解
阅读更多...
Deepseek使用指南与提问优化策略方式

Deepseek使用指南与提问优化策略方式

《Deepseek使用指南与提问优化策略方式》本文介绍了DeepSeek语义搜索引擎的核心功能、集成方法及优化提问策略,通过自然语言处理和机器学习提供精准搜索结果,适用于智能客服、知识库检索等领域... 目录序言1. DeepSeek 概述2. DeepSeek 的集成与使用2.1 DeepSeek API
阅读更多...
Redis的数据过期策略和数据淘汰策略

Redis的数据过期策略和数据淘汰策略

《Redis的数据过期策略和数据淘汰策略》本文主要介绍了Redis的数据过期策略和数据淘汰策略,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录一、数据过期策略1、惰性删除2、定期删除二、数据淘汰策略1、数据淘汰策略概念2、8种数据淘汰策略
阅读更多...
SpringBoot中的404错误:原因、影响及解决策略

SpringBoot中的404错误:原因、影响及解决策略

《SpringBoot中的404错误:原因、影响及解决策略》本文详细介绍了SpringBoot中404错误的出现原因、影响以及处理策略,404错误常见于URL路径错误、控制器配置问题、静态资源配置错误... 目录Spring Boot中的404错误：原因、影响及处理策略404错误的出现原因1. URL路径错
阅读更多...
Redis多种内存淘汰策略及配置技巧分享

Redis多种内存淘汰策略及配置技巧分享

《Redis多种内存淘汰策略及配置技巧分享》本文介绍了Redis内存满时的淘汰机制,包括内存淘汰机制的概念,Redis提供的8种淘汰策略（如noeviction、volatile-lru等）及其适用场... 目录前言一、什么是 Redis 的内存淘汰机制？二、Redis 内存淘汰策略1. pythonnoe
阅读更多...
Python 中 requests 与 aiohttp 在实际项目中的选择策略详解

Python 中 requests 与 aiohttp 在实际项目中的选择策略详解

《Python中requests与aiohttp在实际项目中的选择策略详解》本文主要介绍了Python爬虫开发中常用的两个库requests和aiohttp的使用方法及其区别,通过实际项目案... 目录一、requests 库二、aiohttp 库三、requests 和 aiohttp 的比较四、requ
阅读更多...
Redis过期键删除策略解读

Redis过期键删除策略解读

《Redis过期键删除策略解读》Redis通过惰性删除策略和定期删除策略来管理过期键,惰性删除策略在键被访问时检查是否过期并删除,节省CPU开销但可能导致过期键滞留,定期删除策略定期扫描并删除过期键,... 目录1.Redis使用两种不同的策略来删除过期键，分别是惰性删除策略和定期删除策略1.1惰性删除策略
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2