Hibernate中多种方式解除延迟加载

问题引发：因为dao使用load（），默认延迟加载的，当在biz关闭session之后，UI层无法获取对象的非id属性值

解决方案：

1.变成get，即时加载

2.用Hibernate.isInitialized(obj)被初始化

3.类级别的lazy属性设为true

4.用final修饰类，因为用final修饰的类不允许有子类。而我们所说的内存中保存的代理对象其实就是该类的子类。此方法从根本上解决了延迟加载

5.在事务提交之前，先调用一下该类的非id属性

 1 package cn.happy.entity;
 2
 3 public class Users {
 4     private Integer id;
 5     private String name;
 6     private String password;
 7     private String telephone;
 8     private String userName;
 9     private String isAdmin;
10
11
12     public Integer getId() {
13         return id;
14     }
15
16     public void setId(Integer id) {
17         this.id = id;
18     }
19
20     public String getName() {
21         return name;
22     }
23
24     public void setName(String name) {
25         this.name = name;
26     }
27
28     public String getPassword() {
29         return password;
30     }
31
32     public void setPassword(String password) {
33         this.password = password;
34     }
35
36     public String getTelephone() {
37         return telephone;
38     }
39
40     public void setTelephone(String telephone) {
41         this.telephone = telephone;
42     }
43
44     public String getUserName() {
45         return userName;
46     }
47
48     public void setUserName(String userName) {
49         this.userName = userName;
50     }
51
52     public String getIsAdmin() {
53         return isAdmin;
54     }
55
56     public void setIsAdmin(String isAdmin) {
57         this.isAdmin = isAdmin;
58     }
59
60 }

User.java

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5
 6
 7     <hibernate-mapping package="cn.happy.entity">
 8
 9         <class name="Users" table="USERS" lazy="false">
10             <id name="id" column="ID">
11                 <generator class="native" />
12             </id>
13             <property name="name" type="string" column="NAME" />
14             <property name="password" />
15             <property name="telephone" />
16             <property name="userName" />
17             <property name="isAdmin" />
18         </class>
19
20 </hibernate-mapping>

Users.hbm.xml

 1 package cn.happy.dao;
 2
 3 import java.io.Serializable;
 4
 5 import cn.happy.until.HibernateUtil;
 6
 7 public class UsersDao {
 8    //添加用户记录
 9     public Serializable save(Object object){
10         return HibernateUtil.currentSession().save(object);
11     }
12     //检索oid
13     public Object get(Class clazz, Serializable id){
14         return HibernateUtil.currentSession().load(clazz, id);
15     }
16
17     //修改用户记录
18     public void update(Object object){
19         HibernateUtil.currentSession().update(object);
20     }
21
22 }

UsersDao

 1 package cn.happy.biz;
 2
 3 import java.io.Serializable;
 4
 5 import org.hibernate.Hibernate;
 6 import org.hibernate.Transaction;
 7
 8 import cn.happy.dao.UsersDao;
 9 import cn.happy.until.HibernateUtil;
10
11 public class UsersBiz {
12     UsersDao user=new UsersDao();
13     //添加用户记录
14     public Serializable save(Object object){
15         Transaction tx=HibernateUtil.currentSession().beginTransaction();
16         Serializable result=user.save(object);
17         tx.commit();
18         return result;
19     }
20     //检索oid
21     public Object get(Class clazz, Serializable id){
22         Transaction tx = HibernateUtil.currentSession().beginTransaction();
23         Object obj=user.get(clazz, id);
24 //        if(!Hibernate.isInitialized(obj)){
25 //            Hibernate.initialize(obj);
26 //        }
27         tx.commit();
28         HibernateUtil.closeSession();
29         return obj;
30     }
31
32     //修改用户记录
33     public void update(Object object){
34         Transaction tx=HibernateUtil.currentSession().beginTransaction();
35         user.update(object);
36         tx.commit();
37     }
38 }

UsersBiz

 1 package cn.happy.ui;
 2
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7
 8 import cn.happy.biz.UsersBiz;
 9 import cn.happy.entity.Users;
10 import cn.happy.until.HibernateUtil;
11
12 public class Test {
13   public static void main(String[] args) {
14       get();
15 }
16   //添加
17   public static void add(){
18       Users user=new Users();
19       user.setName("回青");
20       user.setIsAdmin("yes");
21       user.setPassword("123456");
22       user.setTelephone("18265808945");
23       user.setUserName("户梦艳");
24       UsersBiz usersBiz=new UsersBiz();
25       usersBiz.save(user);
26       System.out.println("ok");
27
28   }
29  //修改
30   public static void modify(){
31       Session session = HibernateUtil.currentSession();
32       Transaction transaction = session.beginTransaction();
33       Users user = (Users)session.get(Users.class, 6);
34       user.setName("岁月静好");
35       session.update(user);
36       transaction.commit();
37       HibernateUtil.closeSession();
38   }
39
40   //
41   public static void get(){
42       UsersBiz ub=new UsersBiz();
43       Users user = (Users)ub.get(Users.class, 6);
44       System.out.println(user.getName());
45   }
46 }

测试类

6.用openSessionInView模式

Open Session In View模式的主要思想：在用户的每一次请求过程始终保持一个Session对象打开着

过滤器：过滤用的。过滤请求和响应。双向过滤

实现步骤：

Until包

 1 package cn.happy.until;
 2
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.cfg.Configuration;
 6
 7 public class HibernateUtil {
 8      private static final ThreadLocal sessionTL=new ThreadLocal();
 9      private static Configuration configuration;
10      private final static SessionFactory sessionFactory;
11      static{
12         configuration=new Configuration().configure();
13         sessionFactory=configuration.buildSessionFactory();
14      }
15      public static Session currentSession(){
16             Session session=(Session)sessionTL.get();
17             //如果session为null，则打开一个新的session
18             if(session==null){
19                 session=sessionFactory.openSession();
20                 sessionTL.set(session);
21             }
22             return session;
23         }
24      public static void closeSession(){
25          Session session=(Session)sessionTL.get();
26          sessionTL.set(null);
27          session.close();
28      }
29 }

 1 package cn.happy.entity;
 2
 3 public class Users {
 4     private Integer id;
 5     private String name;
 6     private String password;
 7     private String telephone;
 8     private String userName;
 9     private String isAdmin;
10
11
12     public Integer getId() {
13         return id;
14     }
15
16     public void setId(Integer id) {
17         this.id = id;
18     }
19
20     public String getName() {
21         return name;
22     }
23
24     public void setName(String name) {
25         this.name = name;
26     }
27
28     public String getPassword() {
29         return password;
30     }
31
32     public void setPassword(String password) {
33         this.password = password;
34     }
35
36     public String getTelephone() {
37         return telephone;
38     }
39
40     public void setTelephone(String telephone) {
41         this.telephone = telephone;
42     }
43
44     public String getUserName() {
45         return userName;
46     }
47
48     public void setUserName(String userName) {
49         this.userName = userName;
50     }
51
52     public String getIsAdmin() {
53         return isAdmin;
54     }
55
56     public void setIsAdmin(String isAdmin) {
57         this.isAdmin = isAdmin;
58     }
59
60 }

HibernateUtil.javaUser.java

entity包

 1 package cn.happy.entity;
 2
 3 public class Users {
 4     private Integer id;
 5     private String name;
 6     private String password;
 7     private String telephone;
 8     private String userName;
 9     private String isAdmin;
10
11
12     public Integer getId() {
13         return id;
14     }
15
16     public void setId(Integer id) {
17         this.id = id;
18     }
19
20     public String getName() {
21         return name;
22     }
23
24     public void setName(String name) {
25         this.name = name;
26     }
27
28     public String getPassword() {
29         return password;
30     }
31
32     public void setPassword(String password) {
33         this.password = password;
34     }
35
36     public String getTelephone() {
37         return telephone;
38     }
39
40     public void setTelephone(String telephone) {
41         this.telephone = telephone;
42     }
43
44     public String getUserName() {
45         return userName;
46     }
47
48     public void setUserName(String userName) {
49         this.userName = userName;
50     }
51
52     public String getIsAdmin() {
53         return isAdmin;
54     }
55
56     public void setIsAdmin(String isAdmin) {
57         this.isAdmin = isAdmin;
58     }
59
60 }

Users.java

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC
 3         "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5
 6
 7     <hibernate-mapping package="cn.happy.entity">
 8
 9         <class name="Users" table="USERS">
10             <id name="id" column="ID">
11                 <generator class="native" />
12             </id>
13             <property name="name" type="string" column="NAME" />
14             <property name="password" />
15             <property name="telephone" />
16             <property name="userName" />
17             <property name="isAdmin" />
18         </class>
19
20 </hibernate-mapping>

Users.hbm.xml

Dao包

 1 package cn.happy.dao;
 2
 3 import java.io.Serializable;
 4
 5 import cn.happy.until.HibernateUtil;
 6
 7 public class UsersDao {
 8    //添加用户记录
 9     public Serializable save(Object object){
10         return HibernateUtil.currentSession().save(object);
11     }
12     //检索oid
13     public Object get(Class clazz, Serializable id){
14         return HibernateUtil.currentSession().load(clazz, id);
15     }
16
17     //修改用户记录
18     public void update(Object object){
19         HibernateUtil.currentSession().update(object);
20     }
21
22 }

UsersDao.java

Biz包

 1 package cn.happy.biz;
 2
 3 import java.io.Serializable;
 4
 5 import org.hibernate.Hibernate;
 6 import org.hibernate.Transaction;
 7
 8 import cn.happy.dao.UsersDao;
 9 import cn.happy.until.HibernateUtil;
10
11 public class UsersBiz {
12     UsersDao user=new UsersDao();
13     //添加用户记录
14     public Serializable save(Object object){
15         Transaction tx=HibernateUtil.currentSession().beginTransaction();
16         Serializable result=user.save(object);
17         tx.commit();
18         return result;
19     }
20     //检索oid
21     public Object get(Class clazz, Serializable id){
22         //Transaction tx = HibernateUtil.currentSession().beginTransaction();
23         Object obj=user.get(clazz, id);
24 //        if(!Hibernate.isInitialized(obj)){
25 //            Hibernate.initialize(obj);
26 //        }
27         //tx.commit();
28         //HibernateUtil.closeSession();
29         return obj;
30     }
31
32     //修改用户记录
33     public void update(Object object){
34         Transaction tx=HibernateUtil.currentSession().beginTransaction();
35         user.update(object);
36         tx.commit();
37     }
38 }

UsersBiz.java

Filter包

 1 package cn.happy.filter;
 2
 3 import java.io.IOException;
 4
 5 import javax.servlet.Filter;
 6 import javax.servlet.FilterChain;
 7 import javax.servlet.FilterConfig;
 8 import javax.servlet.ServletException;
 9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11
12 import org.hibernate.HibernateException;
13 import org.hibernate.Session;
14 import org.hibernate.Transaction;
15
16 import cn.happy.until.HibernateUtil;
17
18 public class OpenSessionInViewFilter implements Filter {
19
20
21     public void doFilter(ServletRequest request, ServletResponse response,
22             FilterChain chain) throws IOException, ServletException {
23         request.setCharacterEncoding("utf-8");
24         Session session=null;
25         Transaction tx=null;
26         try {
27             session=HibernateUtil.currentSession();
28             System.out.println("filter\t"+session.hashCode());
29             tx=session.beginTransaction();
30             //执行请求处理链   双向过滤
31             chain.doFilter(request, response);
32             //返回响应  提交事务
33             tx.commit();
34         } catch (HibernateException e) {
35             e.printStackTrace();
36             tx.rollback();
37         }finally{
38             HibernateUtil.closeSession();
39         }
40
41     }
42
43     public void init(FilterConfig arg0) throws ServletException {
44         // TODO Auto-generated method stub
45
46     }
47     public void destroy() {
48         // TODO Auto-generated method stub
49
50     }
51
52
53 }

OpensessionInviewFilter

时间： 2024-10-21 18:59:06

Hibernate中多种方式解除延迟加载的相关文章

hibernate中注解方式中的控制反转

都知道hibernate用xml方式配置关系时(one-to-many,many-to-many)可以添加控制反转属性 inverse=false(默认) 即将两表之间的关系交给对方来维护. inverse=true表示本方不维护关系,有对方维护关系但是需注意的是,one-to-one关系是没有控制反转的,只能交由外键来维护关系. 从而导致在设置关系时,只能有外键方设置,移除关系时,只能从外键方来解除关系,删除记录时,只能先删外键方,在删主键方(save,remove,delete) 如果有控

hibernate(七) hibernate中查询方式详解

序言之前对hibernate中的查询总是搞混淆,不明白里面具体有哪些东西.就是因为缺少总结.在看这篇文章之前,你应该知道的是数据库的一些查询操作,多表查询等,如果不明白,可以先去看一下 MySQL数据表查询操作详解 ,以至于看这篇文章不用那么吃力. --WH 一.hibernate中的5种检索方式 1.1.导航对象图检索方式根据已经加载的对象导航到其他对象例如:在前面的各种映射关系中,实体类包含对其他类对象的引用. Dept d = (Dept) session.get(Dept.cla

Hibernate学习（七）———— hibernate中查询方式详解

序言之前对hibernate中的查询总是搞混淆,不明白里面具体有哪些东西.就是因为缺少总结.在看这篇文章之前,你应该知道的是数据库的一些查询操作,多表查询等 --WH 一.hibernate中的5种检索方式 1.1.导航对象图检索方式根据已经加载的对象导航到其他对象例如:在前面的各种映射关系中,实体类包含对其他类对象的引用. Dept d = (Dept) session.get(Dept.class,2); d.getStaffSet().size(); //d对象关联Staff集合,h

(IO流)java中多种方式读文件,追加文件内容,对文件的各种操作

import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.RandomAccessFile; import java.io.R

Hibernate中的延迟加载(懒加载)

什么是懒加载? Hibernate提供了一种机制,即在设置了使用懒加载的情况下,查询某一条数据时不会立即访问数据库,因此不会返回指定对象,而是返回代理对象,该代理对象并不为null,它实际上是Hibernate自动实现的指定对象所属类的子类的对象,该对象具有默认值.当要使用真正对象的属性的时候才会访问数据库,这时代理对象会自动查询数据库中对应对象的数据并返回. 这样一来降低了程序对数据库访问次数和内存使用量.下面我们通过懒加载适用情况分析它究竟是如何做到的. 懒加载的适用情况? 1.获取某一个对

Hibernate中延迟加载和缓存

什么是延迟加载? 延迟加载是指当应用程序想要从数据库获取对象时(在没有设置lazy属性值为false),Hibernate只是从数据库获取符合条件的对象的OId从而生成代理对象,并没有加载出对象访问该对象的属性时才会加载出相应的值.简答来说就是尽可能的减少查询的数据量. 如何配置延迟加载在Hibernate中通过.hbm配置文件中的lazy属性来陪值,并且lazy属性出现的位置不同其作用和取值也不同.下面来详细介绍其在不同位置的不同取值和作用类Class标签中的lazy: 在类标签Clas

JavaScript中判断为整数的多种方式

原文:JavaScript中判断为整数的多种方式之前记录过JavaScript中判断为数字类型的多种方式,这篇看看如何判断为整数类型(Integer). JavaScript中不区分整数和浮点数,所有数字内部都采用64位浮点格式表示.但实际操作中比如数组索引.位操作则是基于32位整数. 方式一.使用取余运算符判断任何整数都会被1整除,即余数是0.利用这个规则来判断是否是整数. function isInteger(obj) { return obj%1 === 0 } isInteger(3

hibernate中一种导致a different object with the same identifier value was already associated with the session错误方式及解决方法

先将自己出现错误的全部代码都贴出来: hibernate.cfg.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-con

（十六）Hibernate中的延迟加载

一.什么是延迟加载为了节省Hibernate加载对象的性能节销,在Hibernate中真正需要用到这个对象时,才会发出 SQL语句来抓取这个对象.这一个过程称为延迟加载. 二.延迟加载的分类 A:实体对象的延迟加载 B:一对多|多对多的延迟加载 C:多对一|一对一的延迟加载 D:属性的延迟加载 A:实体对象的延迟加载:使用session.get()和session.load()获取对象的区别就是是否开启延迟加载. Hibernate只加载