[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密码策略还可能包括密码复杂度的检查,如是否要求密码包含大写字母、小写字母、数字和特殊字符等,：本文主要介绍MySQL设置密码复杂度... 目录前言1. 使用 validate_password 插件1.1 启用 validate_passwo
阅读更多...
Python实现网格交易策略的过程

Python实现网格交易策略的过程

《Python实现网格交易策略的过程》本文讲解Python网格交易策略,利用ccxt获取加密货币数据及backtrader回测,通过设定网格节点,低买高卖获利,适合震荡行情,下面跟我一起看看我们的第一... 网格交易是一种经典的量化交易策略，其核心思想是在价格上下预设多个“网格”，当价格触发特定网格时执行买
阅读更多...
SpringBoot中4种数据水平分片策略

SpringBoot中4种数据水平分片策略

《SpringBoot中4种数据水平分片策略》数据水平分片作为一种水平扩展策略,通过将数据分散到多个物理节点上,有效解决了存储容量和性能瓶颈问题,下面小编就来和大家分享4种数据分片策略吧... 目录一、前言二、哈希分片2.1 原理2.2 SpringBoot实现2.3 优缺点分析2.4 适用场景三、范围分片
阅读更多...
Redis过期删除机制与内存淘汰策略的解析指南

Redis过期删除机制与内存淘汰策略的解析指南

《Redis过期删除机制与内存淘汰策略的解析指南》在使用Redis构建缓存系统时,很多开发者只设置了EXPIRE但却忽略了背后Redis的过期删除机制与内存淘汰策略,下面小编就来和大家详细介绍一下... 目录1、简述2、Redis http://www.chinasem.cn的过期删除策略（Key Expir
阅读更多...
利用Python实现时间序列动量策略

利用Python实现时间序列动量策略

《利用Python实现时间序列动量策略》时间序列动量策略作为量化交易领域中最为持久且被深入研究的策略类型之一,其核心理念相对简明：对于显示上升趋势的资产建立多头头寸,对于呈现下降趋势的资产建立空头头寸... 目录引言传统策略面临的风险管理挑战波动率调整机制：实现风险标准化策略实施的技术细节波动率调整的战略价
阅读更多...
Spring框架中@Lazy延迟加载原理和使用详解

Spring框架中@Lazy延迟加载原理和使用详解

《Spring框架中@Lazy延迟加载原理和使用详解》：本文主要介绍Spring框架中@Lazy延迟加载原理和使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录一、@Lazy延迟加载原理1.延迟加载原理1.1 @Lazy三种配置方法1.2 @Component
阅读更多...
Redis中6种缓存更新策略详解

Redis中6种缓存更新策略详解

《Redis中6种缓存更新策略详解》Redis作为一款高性能的内存数据库,已经成为缓存层的首选解决方案,然而,使用缓存时最大的挑战在于保证缓存数据与底层数据源的一致性,本文将介绍Redis中6种缓存更... 目录引言策略一：Cache-Aside（旁路缓存）策略工作原理代码示例优缺点分析适用场景策略二：Re
阅读更多...
SpringBoot基于配置实现短信服务策略的动态切换

SpringBoot基于配置实现短信服务策略的动态切换

《SpringBoot基于配置实现短信服务策略的动态切换》这篇文章主要为大家详细介绍了SpringBoot在接入多个短信服务商（如阿里云、腾讯云、华为云）后,如何根据配置或环境切换使用不同的服务商,需... 目录目标功能示例配置（application.yml）配置类绑定短信发送策略接口示例：阿里云 & 腾
阅读更多...
redis过期key的删除策略介绍

redis过期key的删除策略介绍

《redis过期key的删除策略介绍》：本文主要介绍redis过期key的删除策略,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录第一种策略：被动删除第二种策略：定期删除第三种策略：强制删除关于big key的清理UNLINK命令FLUSHALL/FLUSHDB命
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2