[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。

相关文章

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

1. 单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 示例代码： class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;this.data = [];}addData(value)
阅读更多...
缓存策略使用总结

缓存策略使用总结

缓存是提高系统性能的最简单方法之一。相对而言，数据库（or NoSQL数据库）的速度比较慢，而速度却又是致胜的关键。 如果使用得当，缓存可以减少相应时间、减少数据库负载以及节省成本。本文罗列了几种缓存策略，选择正确的一种会有很大的不同。缓存策略取决于数据和数据访问模式。换句话说，数据是如何写和读的。例如: 系统是写多读少的吗？(例如基于时间的日志)数据是否是只写入一次并被读取多次?(例如用户配
阅读更多...
Flink任务重启策略

Flink任务重启策略

概述 Flink支持不同的重启策略，以在故障发生时控制作业如何重启集群在启动时会伴随一个默认的重启策略，在没有定义具体重启策略时会使用该默认策略。如果在工作提交时指定了一个重启策略，该策略会覆盖集群的默认策略默认的重启策略可以通过 Flink 的配置文件 flink-conf.yaml 指定。配置参数 restart-strategy 定义了哪个策略被使用。常用的重启策略： 固定间隔 (Fixe
阅读更多...
Java后端微服务架构下的API限流策略：Guava RateLimiter

Java后端微服务架构下的API限流策略：Guava RateLimiter

Java后端微服务架构下的API限流策略：Guava RateLimiter 大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在微服务架构中，API限流是保护服务不受过度使用和拒绝服务攻击的重要手段。Guava RateLimiter是Google开源的Java库中的一个组件，提供了简单易用的限流功能。 API限流概述 API限流通过控制请求的速率来防止
阅读更多...
未雨绸缪：环保专包二级资质续期工程师招聘时间策略

未雨绸缪：环保专包二级资质续期工程师招聘时间策略

对于环保企业而言，在二级资质续期前启动工程师招聘的时间规划至关重要。考虑到招聘流程的复杂性、企业内部需求的变化以及政策标准的更新，建议环保企业在二级资质续期前至少提前6至12个月启动工程师招聘工作。这个时间规划可以细化为以下几个阶段： 一、前期准备阶段（提前6-12个月） 政策与标准研究： 深入研究国家和地方关于环保二级资质续期的最新政策、法规和标准，了解对工程师的具体要求。评估政策变化可
阅读更多...
面对Redis数据量庞大时的应对策略

面对Redis数据量庞大时的应对策略

面对Redis数据量庞大时的应对策略，我们可以从多个维度出发，包括数据分片、内存优化、持久化策略、使用集群、硬件升级、数据淘汰策略、以及数据结构选择等。以下是对这些策略的详细探讨： 一、数据分片（Sharding） 当Redis数据量持续增长，单个实例的处理能力可能达到瓶颈。此时，可以通过数据分片将数据分散存储到多个Redis实例中，以实现水平扩展。分片的主要策略包括： 一致性哈希：使用一
阅读更多...
集群环境下为雪花算法生成全局唯一机器ID策略

集群环境下为雪花算法生成全局唯一机器ID策略

雪花算法是生成数据id非常好的一种方式，机器id是雪花算法不可分割的一部分。但是对于集群应用，让不同的机器自动产生不同的机器id传统做法就是针对每一个机器进行单独配置，但这样做不利于集群水平扩展，且操作过程非常复杂，所以每一个机器在集群环境下是一个头疼的问题。现在借助spring+redis，给出一种策略，支持随意水平扩展，肥肠好用。 大致策略分为4步： 1.对机器ip进行hash,对某一个（大于
阅读更多...
数据库归档策略

数据库归档策略

数据库迁移策略 为备战双11，需要将数据库中的相关表（历史订单）进行归档，以便腾出更多的空间迎接订单的暴增。作者经过尝试，得出自认为最优的解决方案。下面给出数据库归档策略及示例代码。 现有条件： 1.现有两个数据库：db-A 以及 db-B； 2.两个库中有字段相同的表：tba（表中只有字段订单id–rx_id（long型） 有索引）； 3.归档库的tba中还有17年整年的归档数据。 4.由于单
阅读更多...
2024 年高教社杯全国大学生数学建模竞赛 C 题 农作物的种植策略 参考论文 无水印

2024 年高教社杯全国大学生数学建模竞赛 C 题 农作物的种植策略 参考论文 无水印

持续更新中，2024年数学建模比赛思路代码论文都会发布到专栏内，只需订阅一次！  完整论文+代码+数据结果链接在文末！  订阅后可查看参考论文文件 第一问 1.1 问题重述 这个问题围绕的是华北山区的某乡村，在有限的耕地条件下，如何制定最优的农作物种植策略。乡村有 34 块露天耕地和 20 个大棚，种植条件包括粮食作物、蔬菜、水稻和食用菌。除了要考虑地块的面积、种植季节等，还要确保
阅读更多...
【POJ 2970】The lazy programmer（优先队列+贪心）

【POJ 2970】The lazy programmer（优先队列+贪心）

这题范围不会超long long全用int存就行了 贪心的话，每次把一个任务加入到队列，如果不能在指定时间完成就到前面找a最小的一个任务补偿时间，当一个任务完成时间等于0的时候这个任务就不再放回队列 #include<cstdio>#include<queue>#include<algorithm>#include<cstring>using namespace std;//ty
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2