发布一篇Hibernate通用序列化计划,制止提早加载成绩及序列化全部数据库至客户端 ...

为什么外国人还要写那些框架进行代码封装，他们不就是为了别人使用时可以更简单么！如果要达到一个企业级项目的不用框架是很难的。小一些的项目还行，大的光是MVC模式的设计的编码量就够大的了。还有性能方面，单轮windows，这个工具是微软写的，。
在利用Ajax:HibernateEntity=>json,　FlexRemoteObject:　HibernateEntity=>ActionScriptObject的历程,常常碰着以下成绩:
成绩:
1.Hibernate碰着提早加载的属性会见时假如session被封闭则抛出LazyInitializationException
2.Hibernate中的one-to-many等联系关系干系在序列化时假如没有把持,则将全部数据库都有大概被全体序列化
3.过量的利用DTO/ValueObject办理这个成绩.
办理举措:
对Entity对象天生一个静态代办署理,拦阻getXXXX()办法,假如会见的是提早加载的属性,则returnnull,而不抛出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版本的flexRemoteObject将接纳这个举措.preview版本行将公布

Java的桌面程序开发在java程序员里通常叫swing开发，主要用的swing包里的类开发的，也就是通常说的c/s架构开发

是一种语言，用以产生「小应用程序(Applet(s))

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

是一种使网页(Web Page)产生生动活泼画面的语言

那么我书也看了，程序也做了，别人问我的问题我都能解决了，是不是就成为高手了呢？当然没那么简单，这只是万里长征走完了第一步。不信？那你出去接一个项目，你知道怎么下手吗，你知道怎么设计吗，你知道怎么组织人员进行开发吗？你现在脑子里除了一些散乱的代码之外，可能再没有别的东西了吧！

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

仓酷云

你现在最缺的是实际的工作经验，而不是书本上那些凭空想出来的程序。

是一种突破用户端机器环境和CPU

一般学编程语言都是从C语开始学的，我也不例外，但还是可能不学过程语言而直接学面向对象语言的，你是刚接触语言，还是从C开始学比较好，基础会很深点，如果你直接学习JAVA也能上手，一般大家在学语言的时候都记一些语言的关键词，常有的包和接口等。再去做逻辑代码的编写，以后的学习过程都是从逻辑代码编写中提升的，所以这方面都是经验积累的。你要开始学习就从

是一种简化的C++语言 是一种安全的语言，具有阻绝计算机病毒传输的功能

[url]http://www.jdon.com/[/url]去下载，或到同济技术论坛的服务器[url]ftp://nro.shtdu.edu.cn[/url]去下，安装上有什么问题，可以到论坛上去提问。