Hibernate通用序列化方案,制止延迟加载问题及序列化整个数据库至客户端

在利用Ajax: Hibernate Entity => json,　Flex RemoteObject:　Hibernate Entity => ActionScript Object的进程,常常遇到如下问题:

问题:

1.Hibernate遇到延迟加载的属性会见时假如session被封锁则抛出LazyInitializationException

2.Hibernate中的one-to-many等关联干系在序列化时假如没有节制,则将整个数据库都有大概被全部序列化

3.过多的利用DTO/ValueObject办理这个问题.

办理步伐:

对Entity工具生成一个动态署理,拦截getXXXX()要领,假如会见的是延迟加载的属性,则return null,而不抛出LazyInitializationException,递归生成属性的代码,只要遇到未延迟加载的属性,而序列化会自动遏制.制止将整个Entity序列化流传,导致大概序列化整个数据库的问题.

雷同办理方案:

dwr中HibernateConverter,在序列化时如上雷同,遇到延迟加载的属性自动遏制convert事情.而HibernateBeanSerializer则一劳永逸,无论object => json都可以事情.

利用用例:

Java代码

//role为原始工具
role　=　(Role)roleDao.getById(new　Long(1));
//生成的动态署理proxyRole,会见延迟加载的属性将return　null
Role　proxyRole　=　(Role)new　HibernateBeanSerializer<Role>(role).getProxy();
assertNotNull(role.getResource());
assertNull(proxyRole.getResource());　//延迟加载,为null

Hibernate.initialize(role.getResource());　//抓取进来
assertNotNull(proxyRole.getResource());　//不为null

源码.

Java代码

package　cn.org.rapid_framework.util;

import　java.lang.reflect.Modifier;
import　java.util.ArrayList;
import　java.util.Collection;
import　java.util.LinkedHashMap;
import　java.util.LinkedHashSet;
import　java.util.List;
import　java.util.Map;
import　java.util.Set;

import　org.aopalliance.intercept.MethodInterceptor;
import　org.aopalliance.intercept.MethodInvocation;
import　org.hibernate.Hibernate;
import　org.hibernate.collection.PersistentCollection;
import　org.hibernate.proxy.HibernateProxy;
import　org.springframework.aop.framework.ProxyFactory;
import　org.springframework.util.StringUtils;

/**
　 *　用于Hibernate　Object　的序列化,会见延迟加载的属性不会抛出LazyInitializationException,而会返回null值.
　 *　利用:
　 *　<pre>
　 *　Blog　proxyBlog　=　new　HibernateBeanSerializer(blog).getProxy();
　 *　</pre>
　 *　@author　badqiu
　 *　@param　<T>
　 */
public　class　HibernateBeanSerializer　<T>　{
　 T　proxy　=　null;
　 /**
　 */
　 public　HibernateBeanSerializer(T　object,String...　excludesProperties)　{
　 if(object　==　null)　{
　　 this.proxy　=　null;
　 }else　{
　　 ProxyFactory　pf　=　new　ProxyFactory();
　　 pf.setTargetClass(object.getClass());
　　 pf.setOptimize(true);
　　 pf.setTarget(object);
　　 pf.setProxyTargetClass(true);
　　 pf.setOpaque(true);
　　 pf.setExposeProxy(true);
　　 pf.setPreFiltered(true);
　　 HibernateBeanSerializerAdvice　beanSerializerAdvice　=　new　HibernateBeanSerializerAdvice();
　　 beanSerializerAdvice.setExcludesProperties(excludesProperties);
　　 pf.addAdvice(beanSerializerAdvice);

　　 this.proxy　=　(T)pf.getProxy();
　 }
　 }

　 public　T　getProxy(){
　 return　this.proxy;
　 }

　 static　private　class　HibernateBeanSerializerAdvice　implements　MethodInterceptor　{
　 private　String[]　excludesProperties　=　new　String[0];
　 public　String[]　getExcludesProperties()　{
　　 return　excludesProperties;
　 }
　 public　void　setExcludesProperties(String[]　excludesProperties)　{
　　 this.excludesProperties　=　excludesProperties　==　null　?　new　String[0]　:　excludesProperties;
　 }
　 public　Object　invoke(MethodInvocation　mi)　throws　Throwable　{
　　 String　propertyName　=　getPropertyName(mi.getMethod().getName());
　　 Class　returnType　=　mi.getMethod().getReturnType();

　　 if(propertyName　==　null)　{
　　 return　mi.proceed();
　　 }
　　 if(!Hibernate.isPropertyInitialized(mi.getThis(),　propertyName))　{
　　 return　null;
　　 }
　　 if(isExclude(mi,　propertyName))　{
　　 return　null;
　　 }

　　 Object　returnValue　=　mi.proceed();
　　 return　processReturnValue(returnType,　returnValue);
　 }

　 private　Object　processReturnValue(Class　returnType,　Object　returnValue)　{
　　 if(returnValue　==　null)
　　 return　null;
　　 if(returnType　!=　null　&&　Modifier.isFinal(returnType.getModifiers()))　{
　　 return　returnValue;
　　 }
　　 //This　might　be　a　lazy-collection　so　we　need　to　double　check
　　 if(!Hibernate.isInitialized(returnValue))　{
　　 return　null;
　　 }

　　 //this　is　Hibernate　Object
　　 if(returnValue　instanceof　HibernateProxy)　{
　　 return　new　HibernateBeanSerializer(returnValue).getProxy();
　　 }else　if(returnValue　instanceof　PersistentCollection)　{
　　 if(returnType.isAssignableFrom(Map.class))　{
　　　 Map　proxyMap　=　new　LinkedHashMap();
　　　 Map　map　=　(Map)returnValue;
　　　 Set<Map.Entry>　entrySet　=　map.entrySet();
　　　 for(Map.Entry　entry　:　entrySet)　{
　　　 proxyMap.put(entry.getKey(),　new　HibernateBeanSerializer(entry.getValue()));
　　　 }
　　　 return　proxyMap;
　　 }

　　 Collection　proxyCollection　=　null;
　　 if(returnType.isAssignableFrom(Set.class))　{
　　　 proxyCollection　=　new　LinkedHashSet();
　　 }else　if(returnType.isAssignableFrom(List.class))　{
　　　 proxyCollection　=　new　ArrayList();
　　 }else　{
　　　 return　returnValue;
　　 }

　　 for(Object　o　:　(Collection)returnValue)　{
　　　 proxyCollection.add(new　HibernateBeanSerializer(o).getProxy());
　　 }
　　 return　proxyCollection;
　　 }else　{
　　 return　returnValue;
　　 }
　 }

　 private　boolean　isExclude(MethodInvocation　mi,　String　propertyName)
　　 throws　Throwable　{

　　 for(String　excludePropertyName　:　excludesProperties)　{
　　 if(propertyName.equals(excludePropertyName))　{
　　　 return　true;
　　 }
　　 }

　　 return　false;
　 }

　 private　static　String　getPropertyName(String　methodName)　{
　　 String　propertyName　=　null;
　　 if(methodName.startsWith("get"))　{
　　 propertyName　=　methodName.substring("get".length());
　　 }else　if(methodName.startsWith("is"))　{
　　 propertyName　=　methodName.substring("is".length());
　　 }else　if(methodName.startsWith("set"))　{
　　 propertyName　=　methodName.substring("set".length());
　　 }
　　 return　propertyName　==　null　?　null　:　StringUtils.uncapitalize(propertyName);
　 }
　 }
}

另这个类属于rapid-framework的一部门,v2.0版本的flex RemoteObject将回收这个步伐.preview版本即将宣布