huakaile
- 浏览: 63149 次
- 性别:
- 来自: 上海
-
最新评论
-
and1990：
哈哈。。。很不错，看过马老师的视频吧？？？
面向对象 -
renmin520：
谢谢分享
谢谢
Button事件监听
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特性只对普通属性起作用
hibernate在单端关联上的lazy策略，可以取值：false/proxy(默认)/noproxy
<class>标签上的lazy不会影响到单端关联上的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特性只对普通属性起作用
//model
public class Group {
private int id;
private String name;
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;
}
}//Group.hbm.xml <hibernate-mapping> <class name="com.bjsxt.hibernate.Group" table="t_group"><!-- 默认lazy为true --> <id name="id"> <generator class="native"/> </id> <property name="name" length = "10"/> </class> </hibernate-mapping> <mapping resource="com/bjsxt/hibernate/Group.hbm.xml"/>
import org.hibernate.Session;
public class InitData {
public static void main(String[] args) {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Group group = new Group();
group.setName("尚学堂");
session.save(group);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
import org.hibernate.Session;
import junit.framework.TestCase;
/**
* 运行本单元测试的条件：
*
* 设置<class>标签上的lazy=true，也就是默认配置
*
* @author Administrator
*
*/
public class ClassLazyTest extends TestCase {
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
// 不会发出sql,load支持lazy，get不支持
Group group = (Group) session.load(Group.class, 1);// 根据主键查找
// 不会发出sql，因为查找的ID为传入值，不需要经过数据库
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());
}
}hibernate在集合上的lazy策略，可以取值：true/false/extra
<set name="students" inverse="true" cascade="all" lazy="extra"> <key column="classesid"/> <one-to-many class="Student"/> </set><class>标签上的lazy不会影响到集合上的lazy特性
public class Student {
private int id;
private String name;
private Classes classes;
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 Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
}
import java.util.Set;
public class Classes {
private int id;
private String name;
private Set<Student> students;
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 void setStudents(Set<Student> students) {
this.students = students;
}
public Set<Student> getStudents() {
return students;
}
}//Classes.hbm.xml <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> //Student.hbm.xml <hibernate-mapping> <class name="com.bjsxt.hibernate.Student" table="t_student"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <many-to-one name="classes" column="classesid"/> </class> </hibernate-mapping>
import org.hibernate.Session;
public class InitData {
public static void main(String[] args) {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Classes classes = new Classes();
classes.setName("尚学堂");
session.save(classes);
Student student1 = new Student();
student1.setName("10");
student1.setClasses(classes);
session.save(student1);
Student student2 = new Student();
student2.setName("祖儿");
student2.setClasses(classes);
session.save(student2);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
* 保持lazy默认true
* @author Administrator
*
*/
public class CellectionlazyTest1 extends TestCase {
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql，load支持lazy，生成代理
Classes classes = (Classes)session.load(Classes.class, 1);
//会发出sql,要通过数据库查班级名字
System.out.println("classes.name=" + classes.getName());
//不会发出sql,没有真正要用
Set<Student> students = classes.getStudents();
//会发出sql，真正要用于输出
for (Iterator<Student> 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<Student> 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);
}
}
}
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
* 设置<class>标签上的lazy=false
* @author Administrator
*
*/
public class CellectionlazyTest2 extends TestCase {
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//会发出sql,
Classes classes = (Classes)session.load(Classes.class, 1);
//不会发出sql,<class>标签上的lazy=false只对普通属性起作用
System.out.println("classes.name=" + classes.getName());
//不会发出sql
Set<Student> students = classes.getStudents();
//会发出sql，<class>标签上的lazy=false对集合没有影响
for (Iterator<Student> 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);
}
}
}
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
* 设置集合<Set>上的lazy=false,其它默认
* @author Administrator
*
*/
public class CellectionlazyTest3 extends TestCase {
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<Student> students = classes.getStudents();
//不会发出sql
for (Iterator<Student> 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,会发出两条sql分别加载Classes和Student
System.out.println("classes.name=" + classes.getName());
//不会发出sql
Set<Student> 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);
}
}
}
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
* 设置集合<Set>上的lazy=extra,其它默认
* @author Administrator
*
*/
public class CellectionlazyTest4 extends TestCase {
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<Student> students = classes.getStudents();
//会发出sql，加载学生
for (Iterator<Student> 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<Student> 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);
}
}
}
hibernate在单端关联上的lazy策略，可以取值：false/proxy(默认)/noproxy
<class>标签上的lazy不会影响到单端关联上的lazy特性
public class User {
private int id;
private String name;
private Group group;
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 Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
}
public class Group {
private int id;
private String name;
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;
}
}//User.hbm.xml <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="groupid" cascade="all"/> --> <many-to-one name="group" column="groupid"/> </class> </hibernate-mapping> //Group.hbm.xml <hibernate-mapping> <class name="com.bjsxt.hibernate.Group" table="t_group"> <id name="id"> <generator class="native"/> </id> <property name="name"/> </class> </hibernate-mapping>
import org.hibernate.Session;
public class InitData {
/**
* @param args
*/
public static void main(String[] args) {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Group group = new Group();
group.setName("尚学堂");
session.save(group);
User user1 = new User();
user1.setName("菜10");
user1.setGroup(group);
User user2 = new User();
user2.setName("容祖儿");
user2.setGroup(group);
//可以正确存储
session.save(user1);
session.save(user2);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
import org.hibernate.Session;
import junit.framework.TestCase;
/**
* 所有lazy属性默认
* @author Administrator
*
*/
public class SingleEndTest1 extends TestCase {
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//不会发出sql,load支持lazy
User user = (User)session.load(User.class, 1);
//会发出sql，真正使用普通属性
System.out.println("user.name=" + user.getName());
//不会发出sql，返回代理
Group group = user.getGroup();
//会发出sql，真正使用group属性
System.out.println("group.name=" + group.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
import org.hibernate.Session;
import junit.framework.TestCase;
/**
* 将<many-to-one>中的lazy设置为false,其它默认
* @author Administrator
*
*/
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);
}
}
}
import org.hibernate.Session;
import junit.framework.TestCase;
/**
* <class>标签上的lazy=false,其它默认
* @author Administrator
*
*/
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);
}
}
}
分享到：
发表评论
-
JAVA手动连接数据库
2011-04-17 10:02 862// jsp <%@ page language=&q ... -
hibernate CoreAPI
2011-04-14 09:22 659// model import java.util.Date ... -
抓取策略
2011-03-31 09:41 6641、hibernate抓取策略（单端代理的批量抓取）(抓取当前 ... -
缓存(查询优化)
2011-03-31 08:57 6321)hibernate一级缓存：一级缓存很短和session的 ... -
hibernate查询语言(hql)
2011-03-30 08:57 635在hql中关键字不区分大 ... -
读取文件夹生成目录树
2011-03-30 08:18 1378// model import java.util.Set; ... -
悲观锁、乐观锁
2011-03-28 09:05 6351、悲观锁(处理并行问题)：悲观锁的实现，通常依赖于数据库机制 ... -
component、composite、collection映射
2011-03-28 08:55 7001、component(组件)映射：在hibernate中,c ... -
继承映射
2011-03-27 14:21 661每棵继承树映射成一张表 1、理解如何映射 ... -
多对多关联映射
2011-03-26 11:05 596hibernate多对多关联映射(单向User----> ... -
一对多关联映射
2011-03-26 10:55 702hihernate一对多关联映射（单向Classes----- ... -
session_flush
2011-03-26 10:46 704session flush测试： session flush ... -
一对一唯一外键关联映射
2011-03-26 10:37 644hibernate一对一唯一外键关联映射（单向关联Person ... -
一对一主键关联映射
2011-03-26 10:02 569hibernate一对一主键关联映射（单向关联Person-- ... -
多对一关联映射
2011-03-26 09:31 617hibernate多对一关联映射 关联映射的本质： * 将 ... -
基本映射
2011-03-26 09:14 591hibernate基本映射 实体类---表 实体类中的普通属 ... -
Hibernate基础
2011-03-24 08:34 781import org.hibernate.cfg.Config ... -
get、load加载
2011-03-24 08:30 456junit简介： ... -
HQL(对象查询语言) 和 SQL(结构化查询语言)
2011-02-18 08:44 11241. 查询整个映射对象所有字段 //返回Student对象的 ... -
java基础
2011-02-17 09:09 444使用equals函数 str.e ...
相关推荐
博文链接：https://llying.iteye.com/blog/221700
博文链接：https://llying.iteye.com/blog/221699
主要介绍了mybatis中延迟加载Lazy策略,需要的朋友可以参考下
博文链接：https://llying.iteye.com/blog/221701
hibernate映射lazy策略hibernate查询语言hql
hibernate的类级别检索策略和检索策略的lazy、fetch、batch-size属性使用
针对这两类方法存在的问题, 提出了一种基于混合策略的关联分类方法。具体算法为：先判断待分类样本是否满足显式学习模式的分类器特征; 然后把满足分类器特征的待分类样本用显式模式进行分类, 把不满足分类器特征的待...
延迟侧罗和抓取策略 ---- 和延迟加载策略正好相反，是把相关的全部加载出来。通过写一条left join left语句把相关联的两个实体的数据一次性从数据库中加载下来。这样可以节省sql查询次数。
懒商人在 上分享了一种交易策略。 我使用这种方法已经有一段时间了，结果相当一致。 我在日线图上使用了3对货币对（图表时间框架实际上无关紧要）：EURJPY，EURUSD，USDJPY。 这给了我三个位置之间的对冲。 在外汇...
001 Hibernate 简介(开源 O/R 映射框架) 002 第一个 Hibernate 示例 003 hibernate 主要接口介绍 004 持久对象的生命周期介绍 005 query 接口初步 006 开源 O/R 映射框架内容回顾 ...029 hibernate 抓取策略
Hibernate3开始增加了通过property节点的lazy属性，为特定的属性指定延迟加载策略，以避免实体整体加载可能带来的性能浪费，尤其是像长文本之类的大字段。那么实现属性延迟加载需要做两件事： 1.修改映射配置...
本文介绍一些关于响应式图像的适配应用策略，回退原理，SVG的换色技巧，雪碧图的百分比定位计算公式等相关的一些小知识点，目的在于帮助一部分同学快速的理清图像应用思路，以及一些web图像的应用技巧。特点：应用...
用法< v xss=removed xss=removed> 提供者组件使用provider选择图像处理策略，以下是可用值： 阿里巴巴（默认值，与华为云兼容） 秦牛自己没有任何默认情况下使用阿里巴巴OSS服务，因此，如果您在阿里巴巴OSS上托管...
大多数提供的适配器通过专用的JsonQualifier注释链接， JsonQualifier注释会更改序列化/反序列化策略。如何使用它默认情况下，该库不会强制使用其自身的任何适配器。 要利用提供的任何注释/适配器，请将它们各自的...
使用 PostgreSQL 的物化视图策略 此存储库包含此博客文章的测试数据和代码： : 加载测试数据： createdb pg_cache_demo psql -f accounts.sql pg_cache_demo psql -f transactions.sql pg_cache_demo psql -f ...
自定义延迟加载策略4g和WiFi与其他连接 动态组件加载 SCAM组件，懒惰地使用导入的Load组件，它的好处，独立组件 使用ngComponentOutlet导入带有异步管道的组件 使用ngComponentOutlet的动态延迟加载 ...
Hibernate环境搭建 Hibernate主要接口 Hibernate主要映射 Hibernate的lazy、fetch、cascade等策略 Hibernate性能优化
该死的法典 该站点是《吸血鬼：永恒斗争》策略资源的汇编。 该网站可在上公开获得。 部分材料是Paradox Interactive AB的版权和商标，并经许可使用。 版权所有。 有关更多信息，请访问 。贡献欢迎捐款。 如果拉取...