我读过动态 bean 定义更改。我在一个简单的代码示例中尝试了它(请参阅下面的代码)，我发现它在我不想停止服务器但添加/更改 bean 定义的情况下非常有吸引力。

问题:

1. 这样做安全吗(见下面的代码)？

2. 我读到可以在 StaticApplicationContex 或 BeanPostProcessor 或 BeanFactoryPostProcessor< 的帮助下在运行时实现="" bean="">？那么有什么区别呢？

   public class Main {
   final static String header = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
           "<beans xmlns=\"http://www.springframework.org/schema/beans\"\n" +
           "       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
           "       xmlns:context=\"http://www.springframework.org/schema/context\"\n" +
           "       xsi:schemaLocation=\"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd\">\n" +
           "    <context:annotation-config />\n" +
           "    <context:component-scan base-package=\"vbah\"/>";
   
   final static String contextA =
           "<bean id=\"test\" class=\"java.lang.String\">\n" +
                   "\t\t<constructor-arg value=\"fromContextA\"/>\n" +
                   "</bean></beans>";
   
   final static String contextB =
           "<bean id=\"test\" class=\"java.lang.String\">\n" +
                   "\t\t<constructor-arg value=\"fromContextB\"/>\n" +
                   "</bean></beans>";
   
   public static void main(String[] args) throws IOException {
       //create a single context file
       final File contextFile = new File("src/resources/spring-config.xml");
   
       //write the first context into it
       FileUtils.writeStringToFile(contextFile, header + contextA);
   
       //create a spring context
       FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(
               new String[]{contextFile.getPath()}
       );
   
       //echo "fromContextA"
       System.out.println(context.getBean("test"));
   
       //write the second context into it
       FileUtils.writeStringToFile(contextFile, header + contextB);
   
       //refresh the context
       context.refresh();
   
       //echo "fromContextB"
       System.out.println(context.getBean("test"));
   }
   }
   

编辑:

你能回答下面的问题吗:

1. 据我所知，BeanPostProcess 允许您通过使用代理包装对象来在运行时修改已经存在的 bean 实例。我说得对吗？

2. AbstractApplicationContext#refresh() 删除所有单例 bean 并重新创建它们。

   • 但是如果我想更改原型(prototype)/自定义作用域 bean 的定义呢？
   • 如果我有两个 bean:A 和 B。A 引用了 B。如果我以不包含 B 定义的方式更改 bean 定义。那么 B 实例将被销毁，但新实例将被销毁不会被创建。比 A 将获得 null 依赖项。我说得对吗？

3. StaticApplicationContext 和 BeanFactoryPostProcessor 都允许我在运行时更改 bean 定义。但是有什么区别，优点/缺点？

4. [主要问题] 为什么 Spring 有 3 种机制来实现相同的目标。你能在 AbstractApplicationContext#refresh()、StaticApplicationContext 和 BeanFactoryPostProcessor 之间做一个简短的比较(或用例示例)吗？

最佳答案

Is it safe do to so (see code below)?

您必须定义安全。

AbstractApplicationContext#refresh()方法 javadoc 状态

As this is a startup method, it should destroy already created singletons if it fails, to avoid dangling resources. In other words, after invocation of that method, either all or no singletons at all should be instantiated.

基本上，上下文中的每个 bean 都将被销毁，所有对它们的引用都将被删除，使它们成为垃圾收集的候选对象。您需要确保这些 bean 有适当的方法来释放它们可能拥有的任何资源。 There are different ways to do that

• 让你的类(class)实现DisposableBean界面。
• 添加 destroy-method属性给你的 <bean>或 @Bean定义。
• 用 @PreDestroy 注释一个方法.

请注意 refresh()通常会急切地刷新您的 ApplicationContext ， IE。立即重新实例化所有 bean。发生这种情况时，您可能会注意到您的应用程序速度有所下降。

I've read that it is possible to achieve bean definition change in runtime with help of StaticApplicationContext or BeanPostProcessor or BeanFactoryPostProcessor? So what is the difference?

StaticApplicationContext是 ApplicationContext 之一您自己注册 bean 定义的类。在您的示例中，bean 定义是从您的 XML 文件中解析并在后台注册的。用 StaticApplicationContext , 你使用 registerBeanDefinition(..) 或另一个registerXxx()显式注册 bean 定义的方法。

A BeanFactoryPostProcessor可以访问 BeanFactory正在使用，因此所有已注册的 bean 定义。因此，您可以检索任何 BeanDefinition你想要并修改它。作为 BeanFactoryPostProcess#postProcessBeanFactory(..) 的 javadoc州

All bean definitions will have been loaded, but no beans will have been instantiated yet. This allows for overriding or adding properties even to eager-initializing beans.

您可以在 ApplicationContext 之前更改 bean 定义实际使用它。

最后，一个 BeanPostProcessor不会更改 bean 定义。您可以使用 BeanPostProcessor改变 bean 的创建方式，但底层 BeanDefinition将保持不变。

对于您的编辑(比实际答案更大:))

As I understand BeanPostProcess allow you to modify already existed bean instances at runtime by wrapping the object with proxy. Am I right?

它不仅仅用于代理，您可以对对象做任何您想做的事情:修改它的属性，在其他上下文中注册它，将它设为null。等。这围绕着 bean 定义。

AbstractApplicationContext#refresh() drop all singleton beans and recreate them.

But If I want to change the definition of prototype/custom scoped bean? If I've got two beans: A and B. A has reference to B. If I change the bean definition in such way that it doesn't contain definition of B. Than B instances will be destroyed, but new instances won't be created. Than A will get a null dependency. Am I right?

在 ApplicationContext 中，您声明您的 bean 定义。如果您要更改 bean 定义，请在 BeanFactoryPostProcessor 中更改它或者在上下文配置中以不同方式声明它。

对于依赖，如果你销毁B bean 定义，将不会有一个 bean 注入(inject) A Spring 会提示，抛出 NoSuchBeanDefinitionException . bean注入(inject)从不注入(inject)null除非你明确告诉它。

StaticApplicationContext and BeanFactoryPostProcessor both allow me to change a bean definition in runtime. But what are the difference, pros/cons?

两者的用途完全不同。 StaticApplicationContext是一个 ApplicationContext执行。在这里，您声明 bean 定义。 BeanFactoryPostProcessor用于根据您想要实现的任何条件以任何方式修改这些 bean 定义。

Why Spring has 3 mechanism to achieve the same goal. Can you make a brief comparison (or usecases examples) between AbstractApplicationContext#refresh(), StaticApplicationContext and BeanFactoryPostProcessor please.

目标不一样。一个ApplicationContext不同于 BeanFactoryPostProcessor并在上下文生命周期的不同时间发挥作用(请参阅您在上一个问题中得到的漂亮图表)。

我没有适合您的用例。了解以上各项的功能，您就会知道在收到特定要求时何时应用它们。

关于java - Spring上下文动态变化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21221125/