Spring依赖注入到可序列化的bean中

Question

我有一个不可序列化的服务类和一个必须可序列化但必须有权访问此服务类的 bean：

class SomeBean implements Serializable
{
    private StuffFactory factory;

    @Autowired
    public SomeBean(StuffFactory factory)
    {
        this.factory = factory;
    }

    public getOther()
    {
        return this.factory.getSomeOtherStuff();
    }
}

这显然不起作用，因为现在SomeBean 类不再可序列化。在 Spring 中解决这个问题的正确方法是什么？当我使factory 字段瞬态时，我会在反序列化时释放注入的工厂实例，或者不是？当我使StuffFactory 也可序列化时，这个类将不再是单例，因为每个SomeBean 实例在反序列化后都会有自己的工厂。

Answer 1

你需要某种上下文来让这个魔法发挥作用。

我能想到的一种丑陋方式是静态的ThreadLocal 持有ApplicationContext - 这就是使用SecurityContextHolder 的spring-security 的工作方式。

但如果你能够将需要StuffFactory 的逻辑外部化为某种单例SomeBeanService，那就最好了，即：

public class SomeBeanService {
    @Autowired
    private StuffFactory stuffFactory;

    public void doWithSomeBean(SomeBean bean) {
        // do the stuff using stuffFactory here
    }
}

更新：

上面替代ThreadLocal 的重点是完全摆脱SomeBean 对StuffFactory 的依赖。这应该是可能的，但需要对架构进行更改。 关注点分离（不仅是 Spring 的基本规则之一）意味着让 SomeBean 成为一个简单的数据传输对象可能是个好主意，并且将业务逻辑移至服务层。

如果您无法实现这一点，那么唯一的方法是使用某种static 上下文（正如 Ralph 所说）。这种上下文的实现可能涉及使用ThreadLocal。这将允许访问ApplicationContext 以获取StuffFactory，但它几乎与全局变量一样丑陋，因此请尽可能避免使用它。

更新2：

我刚刚看到您的评论，SomeBean 存储在 HTTP 会话中，因此存在序列化/反序列化问题。现在我更建议更改您的设计并删除依赖项。使SomeBean 成为一个简单的 DTO，尽可能小以避免会话过载。应该没有逻辑需要访问 SomeBean 中的单例 Spring bean。这样的逻辑应该放在控制器或服务层。

Answer 2

Java 提供了一种通过实现这两种方法来控制序列化和反序列化的方法：

• private void writeObject(ObjectOutputStream out) throws IOException;
• private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

因此，您可以更改写入以在不引用服务的情况下存储 bean，然后在读取对象时再次“注入”引用。

@see http://java.sun.com/developer/technicalArticles/Programming/serialization/

您必须将readObject 中的实例创建为 bean。如果你只使用一个简单的new 它不会变成一个bean。 因此，您需要访问 Spring 上下文，例如通过静态方法。 最好的办法是使用bean factory来创建新的实例。

---

您可以尝试使用@Configurable 使实例成为spring bean 的另一种方法，但这需要真正的AspectJ。

Answer 3

也许有一个SomeBeanFactory：

class SomeBeanFactory {
    @Autowired
    private StuffFactory stuffFactory;

    public SomeBean deserialize(...) {
        SomeBean someBean = ...;
        someBean.setStuffFactory(stuffFactory);
        return someBean;
    }
}

显然，您需要在SomeBean 中为factory 创建一个setter。

Answer 4

在这种情况下，重新考虑您的架构可能是可行的。如果您可以将需要序列化的数据隔离到一个简单的数据传输对象 (DTO) 中，那么应该可以为该 DTO 提供一个包装器，该包装器本身可以包含对其他 bean 的依赖关系。

例如：

public interface IDataBean {
    void setSomething(String someData);
}

// This is your session bean - just a plain DTO
public class MyDataBean implements IDataBean, Serializable {

   private String someData;

   public void setSomething( String someData ) {
      this.someData = someData;
   }
}

// This is the wrapper that delegates calls to a wrapped MyDataBean.
public class MyDataBeanWithDependency() implements IDataBean {

    private SomeOtherService service;

    private MyDataBean dataBean;

    public SimpleDataBeanWithDependency(MyDataBean dataBean, SomeOtherService service) {
       this.dataBean = dataBean;
       this.service = service;
    }

    public void setSomething(String someData) {
       // Here we make a call to the service to perform some specific logic that may, for example, hit a DB or something.
       String transformedString = service.transformString(someData);
       dataBean.setSomething(transformedString);
    }
}

public class SomeService {

    // This is a Spring session scoped bean (configured using <aop:scoped-proxy/>)
    @Autowired
    private MyDataBean myDataBean;

    // Just a plain singleton Spring bean
    @Autowired
    private SomeOtherService someOtherService;

    public IDataBean getDataBean() {
         return new MyDataBeanWithDependency(myDataBean, someOtherService); 
    }
}

对不起所有的代码！但是，让我试着解释一下我在这里的意思。如果您总是通过服务（在本例中为 SomeService）检索会话 bean，那么您可以选择围绕会话 bean 创建一个包装器。此包装器可以包含您可能希望用作与会话 bean 一起执行逻辑的一部分的任何 bean 依赖项（自动装配到 SomeService 中）。

这种方法的巧妙之处在于您也可以对接口进行编程（请参阅 IDataBean）。这意味着，例如，如果您有一个从服务获取数据 bean 的控制器，它会使单元测试/模拟变得非常干净。

可能，从代码的角度来看，一种更简洁的方法是使用“请求”范围在 Spring 容器中注册 MyDataBeanWithDependency。因此，您可以直接将该 bean 自动装配到 SomeService 中。这基本上可以透明地处理实例化，因此您无需从服务中手动实例化 MyDataBeanWithDependency。

希望我已经做了足够的工作来在这里解释自己！