如何在反序列化时重新附加单例springbean

在反序列化对象时,如何使用方面添加注入步骤?

为此,您需要AspectJ或类似的工具。它的工作原理与Spring中的@Configurable函数非常相似。

本文也可能有助于: http://java.sun.com/developer/technicalArticles/Programming/serialization/

public class Process implements HttpSessionActivationListener {
    ...
    @Override
    public void sessionDidActivate(HttpSessionEvent e) {
        ServletContext sc = e.getSession().getServletContext();
        WebApplicationContext newContext = WebApplicationContextUtils
            .getRequiredWebApplicationContext(sc);
        newContext.getAutowireCapableBeanFactory().configureBean(this, beanName);
    }
}

该示例适用于应用程序服务器序列化会话的web环境,但它应该适用于任何ApplicationContext。

看一下spring文档 http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/aop.html#aop-atconfigurable .

7.8.1使用AspectJ向Spring注入依赖域对象

支持用于在外部创建的对象 这是因为它们通常是以编程方式创建的

诀窍是使用加载时编织。只需启动jvm-javaagent:path/to/org.springframework.instrument-{version}.jar。此代理将识别实例化的每个对象,如果它用@Configurable注释,它将配置(注入@Autowired或@Resource dependencies)该对象。

只需将Process类更改为

@Configurable
class Process {

   @Autowired
   private transient Repository repository;
   // getters, setters, etc.
}

创建新实例时

Process process = new Process();

如果进程对象被反序列化,这也可以工作。

不如用某种ProcessWrapper bean来代替它,它可以是单例的。它将被注入到存储库中,或者管理进程的反序列化,或者为其设置一个setter。在包装器中设置新进程时,它将调用 setRepository() 在这个过程中。使用流程的bean可以由包装器设置为新的bean,也可以调用将委托给流程的ProcessWrapper。

class ProcessWrapper {
   private Repository repository;
   private Process process;
   // getters, setters, etc.

   public void do() {
      process.do();
   }

   public void setProcess(Process process) {
      this.process = process;
      this.process.setRepository(repository);
   }
}

回答我自己的问题:到目前为止,我是如何解决这个问题的,就是创建一个基类,使用一个便宜的小代理来序列化和反序列化。代理只包含bean的名称。

public abstract class CheaplySerializableBase 
   implements Serializable, BeanNameAware {

    private String name;

    private static class SerializationProxy implements Serializable {

        private final String name;

        public SerializationProxy(CheaplySerializableBase target) {
            this.name = target.name;
        }

        Object readResolve() throws ObjectStreamException {
            return ContextLoader.globalEvilSpringContext.getBean(name);
        }

    }

    @Override
    public void setBeanName(String name) {
        this.name = name;
    }

    protected Object writeReplace() throws ObjectStreamException {
        if (name != null) {
            return new SerializationProxy(this);
        }
        return this;
    }
}

得到的序列化对象大约是150字节(如果我没记错的话)。

applicationContext.getAutowireCapableBeanFactory().autowireBean(detachedBean); 可用于重新配置序列化然后反序列化的Spring托管bean(其 @Autowired 田地变成 null ). 参见下面的示例。为了简单起见,省略了序列化细节。

public class DefaultFooService implements FooService {

    @Autowired
    private ApplicationContext ctx;

    @Override
    public SerializableBean bar() {
        SerializableBean detachedBean = performAction();
        ctx.getAutowireCapableBeanFactory().autowireBean(detachedBean);
        return detachedBean;
    }

    private SerializableBean performAction() {
        SerializableBean outcome = ... // Obtains a deserialized instance, whose @Autowired fields are detached.
        return outcome;
    }

}


public class SerializableBean {

    @Autowired
    private transient BarService barService;

    private int value;

    public void doSomething() {
        barService.doBar(value);
    }

}