Spring Bean的序列化方案

　　这个问题是在做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机制来实现，设计这样一个类，在应用程序上下文创建时，将他添加到缓存中，在应用程序上下文关闭时，将他从缓存中删除：

package org.fox.beetl.ext.spring.utils;
 
import java.util.HashMap;
import java.util.Map;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ApplicationContextEvent;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.ContextStartedEvent;
import org.springframework.context.event.ContextStoppedEvent;
 
/**
 * ApplicationContext生命周期事件监听器
 * 
 * @author Chen Rui
 */
public class ApplicationContextLifecycleEventListener implements ApplicationListener<ApplicationContextEvent> {
    private Log log = LogFactory.getLog(ApplicationContextLifecycleEventListener.class);
 
    @Override
    public void onApplicationEvent(ApplicationContextEvent event) {
        // 获取应用程序上下文
        ApplicationContext applicationContext = event.getApplicationContext();
        log.info(String.format("ApplicationContext生命周期事件(%s): %s",
                applicationContext != null ? applicationContext.getId() : "null", event.getClass().getSimpleName()));
 
        if (applicationContext != null) {
            if ((event instanceof ContextStoppedEvent) || (event instanceof ContextClosedEvent)) {
                // 应用程序上下文关闭或停止
                removeApplicationContext(applicationContext.getId());
            } else if ((event instanceof ContextRefreshedEvent) || (event instanceof ContextStartedEvent)) {
                // 应用程序上下文启动或刷新
                setApplicationContext(applicationContext);
            }
        }
    }
 
    /* ----- ----- ----- ----- ApplicationContext管理 ----- ----- ----- ----- */
    /**
     * application应用程序上下文
     */
    private static Map<String, ApplicationContext> applicationContextPool = new HashMap<String, ApplicationContext>();
 
    /**
     * 添加ApplicationContext对象
     * 
     * @param applicationContext
     */
    private static synchronized void setApplicationContext(ApplicationContext applicationContext) {
        applicationContextPool.put(applicationContext.getId(), applicationContext);
    }
 
    /**
     * 删除ApplicationContext对象
     * 
     * @param id
     */
    private static synchronized void removeApplicationContext(String id) {
        applicationContextPool.remove(id);
    }
 
    /**
     * 获取ID指定的ApplicationContext
     * 
     * @param id
     * @return
     */
    public static synchronized ApplicationContext getApplicationContext(String id) {
        return applicationContextPool.get(id);
    }
}

　　将这个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进程的。对于这一点在使用时必须要多注意。