这个问题是在做beetl-spring扩展的时候遇到的一个问题。扩展的思想是尽可能允许Beetl模板用到的所有可配置组件都交给Spring容器管理。
但是遇到问题是Beetl引擎在内部对模板执行进行优化的时候有使用Java对象序列化和反序列化来实现深拷贝，序列化的对象中包括了一个 可能被Spring管理的Bean：SpringBeanTagFactory，通过这个操作该对象会从Spring容器中脱管，更麻烦的该对象是通过 ApplicationContextAware注入的ApplicationContext实例无法序列化。
在这样的基础上，想到如下的解决方案：SpringBeanTagFactory序列化时，只序列化当前Bean的名字和Bean所在的 ApplicationContext的标识（id），反序列化时通过ApplicationContext标识找到对应的 ApplicationContext实例，再继续通过Bean名获取到对应的实例。
首先的第一个问题，我们应该维护好ApplicationContext id与ApplicationContext实例的关系，这在Spring MVC项目中很重要（因为除了顶层的WebApplicationContext外，每个DispatcherServlet都对应了一个子 ApplicationContext)，这个维护工作可以采用Spring ApplicationEvent机制来实现，设计这样一个类，在应用程序上下文创建时，将他添加到缓存中，在应用程序上下文关闭时，将他从缓存中删除：
1 package org.fox.beetl.ext.spring.utils; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 6 import org.apache.commons.logging.Log; 7 import org.apache.commons.logging.LogFactory; 8 import org.springframework.context.ApplicationContext; 9 import org.springframework.context.ApplicationListener; 10 import org.springframework.context.event.ApplicationContextEvent; 11 import org.springframework.context.event.ContextClosedEvent; 12 import org.springframework.context.event.ContextRefreshedEvent; 13 import org.springframework.context.event.ContextStartedEvent; 14 import org.springframework.context.event.ContextStoppedEvent; 15 16 /** 17 * ApplicationContext生命周期事件监听器 18 * 19 * @author Chen Rui 20 */ 21 public class ApplicationContextLifecycleEventListener implements ApplicationListener<ApplicationContextEvent> { 22 private Log log = LogFactory.getLog(ApplicationContextLifecycleEventListener.class); 23 24 @Override 25 public void onApplicationEvent(ApplicationContextEvent event) { 26 // 获取应用程序上下文 27 ApplicationContext applicationContext = event.getApplicationContext(); 28 log.info(String.format("ApplicationContext生命周期事件(%s): %s", 29 applicationContext != null ? applicationContext.getId() : "null", event.getClass().getSimpleName())); 30 31 if (applicationContext != null) { 32 if ((event instanceof ContextStoppedEvent) || (event instanceof ContextClosedEvent)) { 33 // 应用程序上下文关闭或停止 34 removeApplicationContext(applicationContext.getId()); 35 } else if ((event instanceof ContextRefreshedEvent) || (event instanceof ContextStartedEvent)) { 36 // 应用程序上下文启动或刷新 37 setApplicationContext(applicationContext); 38 } 39 } 40 } 41 42 /* ----- ----- ----- ----- ApplicationContext管理 ----- ----- ----- ----- */ 43 /** 44 * application应用程序上下文 45 */ 46 private static Map<String, ApplicationContext> applicationContextPool = new HashMap<String, ApplicationContext>(); 47 48 /** 49 * 添加ApplicationContext对象 50 * 51 * @param applicationContext 52 */ 53 private static synchronized void setApplicationContext(ApplicationContext applicationContext) { 54 applicationContextPool.put(applicationContext.getId(), applicationContext); 55 } 56 57 /** 58 * 删除ApplicationContext对象 59 * 60 * @param id 61 */ 62 private static synchronized void removeApplicationContext(String id) { 63 applicationContextPool.remove(id); 64 } 65 66 /** 67 * 获取ID指定的ApplicationContext 68 * 69 * @param id 70 * @return 71 */ 72 public static synchronized ApplicationContext getApplicationContext(String id) { 73 return applicationContextPool.get(id); 74 } 75 }
将这个Bean定义在Spring容器中（Spring MVC项目中，只需要将他添加到顶层的WebApplicationContext中即可，对子上下文也会生效）：
<bean class="org.fox.beetl.ext.spring.utils.ApplicationContextLifecycleEventListener"/>
第二个问题，我们要干涉SpringBeanTagFactory类的序列化机制，让他在序列化的时候只保存 ApplicationContext的标识和Bean名称，这里我们使用了Java序列化提供的writeReplace() 和 readResolve()方法。
首先定义一个实际用于序列化的类，他持有ApplicationContext的id值和bean名字进行实际的序列化，在反序列化时，通过readResolve()方法找回实际被Spring Bean管理的Bean实例：
package org.fox.beetl.ext.spring.utils; import java.io.Serializable; import org.springframework.context.ApplicationContext; /** * Spring Bean序列化类 * * @author Chen Rui */ public class SpringBeanSerializable implements Serializable { private static final long serialVersionUID = 1L; /** * Bean所属applicationContextId */ private String applicationContextId = null; /** * bean名称 */ private String beanName = null; /** * @param applicationContextId * @param beanName */ public SpringBeanSerializable(String applicationContextId, String beanName) { this.applicationContextId = applicationContextId; this.beanName = beanName; } /** * 将序列化内容还原成原Spring Bean的方法 * * @return */ private Object readResolve() { ApplicationContext applicationContext = ApplicationContextLifecycleEventListener .getApplicationContext(applicationContextId); if (applicationContext == null) { throw new IllegalStateException(String.format("id为%s的ApplicationContext不存在", applicationContextId)); } return applicationContext.getBean(beanName); } }
然后改写SpringBeanTagFactory类，让他能知道自己的Bean名和所在ApplicationContext的id（这通过 Spring容器感知特性很容易实现，只需要实现相应接口），然后提供writeReplace()方法，在序列化时，将实际执行序列化的对象替换成上面 定义的SpringBeanSerializable对象：
package org.fox.beetl.ext.spring.tag; import org.beetl.core.Tag; import org.beetl.core.TagFactory; import org.fox.beetl.ext.spring.utils.SpringBeanSerializable; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.annotation.Required; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; /** * 使用指定名字的Spring Bean为Beetl的Tag对象 注意这个Tag Bean应该是prototype而非单例的，否则在程序中会有问题 * * @author Chen Rui */ public class SpringBeanTagFactory implements TagFactory, ApplicationContextAware, BeanNameAware { private static final long serialVersionUID = 1L; /* ----- ----- ----- ----- 属性 ----- ----- ----- ----- */ /** * 目标Bean名 */ private String name = null; /** * Spring 应用程序上下文 */ private ApplicationContext applicationContext = null; /** * Spring Bean名称 */ private String beanName = null; /** * 目标Bean名 * * @param name */ @Required public void setName(String name) { this.name = name; } /** * Spring 应用程序上下文 * * @param applicationContext */ @Override public void setApplicationContext(ApplicationContext applicationContext) { this.applicationContext = applicationContext; } /** * Spring Bean名称 * * @param beanName */ @Override public void setBeanName(String beanName) { this.beanName = beanName; } /* ----- ----- ----- ----- 其他方法 ----- ----- ----- ----- */ /** * 返回上下文中对应Tag bean对象 * * @return */ @Override public Tag createTag() { return applicationContext.getBean(name, Tag.class); } /* ----- ----- ----- ----- 序列化方法 ----- ----- ----- ----- */ /** * 生成序列化替代类 * * @return */ private Object writeReplace() { return new SpringBeanSerializable(applicationContext.getId(), beanName); } }
好了，到此大功告成。测试通过。
其实说大功告成还差得远，上面的解决方案有几个致命性的限制条件：
1. SpringBeanSerializable通过bean名从applicationContext中获取bean实例，所以SpringBeanTagFactory这个Bean必须是通过名字可直接获取的，即bean必须是公开的有明确名字的bean，不能是内部bean或匿名bean，否则反序列化时会抛出异常(NoSuchBean......);
2. 通过如此反序列化得到的SpringBeanTagFactory，并不保证和原对象有相同的状态， 即他实际是用ApplicationContext的标识和bean的名字来获取的，如果序列化内容传递到其他的JVM进程，实际反序列化时的 ApplicationContext即使标识相同，仍是两个无关的实例。即使ApplicationContext实例相同，如果bean本身 scope不保证单例的话，也可能造成无法完全还原序列化前bean的所有可变属性。对于这一点在使用时必须要多注意。
3.Web环境下的WebApplicationContext和DispacherServlet所持有的应用程序上下文的标识与进程无关。但在一般的Application应用程序中，ApplicationContext实例的id实际上是类名加hashcode() (如ClasspathXmlApplicationContext)，在这种情况下，序列化数据不能传递出当前JVM进程的。对于这一点在使用时必须要多注意。