转载

关于Spring InitialzationBean遇到的坑及分析思考

背景

在项目中，会遇到如下情况，即需要在 Tomcat 启动时去执行一些操作，首先我们想到的是继承 ServletContextListener，然后在 contextInitialized 加入需要执行的操作，这是一种方法；那么对于 Spring 项目来说，也可以继承 InitialzationBean 来实现，在初始化 bean 和销毁 bean 的时候执行某个方法，由于 ServletContextListener 需要在 web.xml 中进行配置，而且可能要注入其他 bean，所以笔者选择了继承 InitialzationBean 来实现。

遇到的坑

新建一个类，继承 InitialzationBean，代码如下：

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class DoOnStart implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("xxxxxxxx");
    }
}

本以为这样就 OK 了，启动 Tomcat 后发现，afterPropertiesSet 方法被执行了两次，奇怪，难道 Spring 会初始化两次 Bean？带着这种猜测，又进行了如下验证：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class DoOnStart implements InitializingBean, ApplicationContextAware {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("xxxxxxxx");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("xxxxxxxx");
    }
}

通过 Debug 发现，setApplicationContext 方法确实执行了两次，也就是说，有两个容器被初始化了，通过查看 applicationContext 发现，第一次是 Root WebApplicationContext，第二次是 WebApplicationContext for namespace spring-servlet，看到这里，茅塞顿开：

第一次是 Spring 对 Bean 进行了初始化，第二次是 Spring MVC 又对 Bean 进行了初始化

那么如何解决加载两次对问题呢？那就是让 Spring MVC 只扫描 @Controller 注解，配置如下：

<!-- spring 配置文件-->  
<context:component-scan base-package="com.xxx.xxx">  
     <context:exclude-filter type="annotation"   
         expression="org.springframework.stereotype.Controller" />  
</context:component-scan>  
  
<!-- spring mvc -->     
<context:component-scan base-package="com.xxx.xxx.web" use-default-filters="false">  
    <context:include-filter type="annotation"   
        expression="org.springframework.stereotype.Controller" />  
</context:component-scan>

为什么要将 Spring 的配置文件和 Spring MVC 的配置文件分开呢？

我们用以下代码进行测试：

@Service  
public class DoOnStart implements InitializingBean {   
    @Autowired  
    private XXXController xxxController;  
  
    @Override  
    public void afterPropertiesSet() throws Exception {  
        System.out.println("xxxxxxxx");  
    }  
}

有如下情况：

Spring 加载全部 bean,MVC 加载 Controller
- 可以
Spring 加载全部 bean,MVC 容器啥也不加载
- 可以
Spring 加载所有除了 Controller 的 bean，MVC 只加载 Controller
- 不可以，父容器不能访问子容器的 bean
Spring 不加载 bean，MVC 加载所有的 bean
- 可以

原来 Spring 是父容器， Spring MVC 是子容器，子容器可以访问父容器的 bean,父容器不能访问子容器的 bean

单例的bean在父子容器中存在一个实例还是两个实例？

初始化两次，Spring 容器先初始化 bean,MVC 容器再初始化 bean，所以应该是两个 bean

为啥不把所有 bean 都在子容器中扫描？

缺点是不利于扩展

源码分析

通过查看 Spring 的加载 bean 的源码类 AbstractAutowireCapableBeanFactory 可看出其中奥妙，AbstractAutowireCapableBeanFactory 类中的 invokeInitMethods 讲解的非常清楚，源码如下：

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)  
      throws Throwable {  
  //判断该bean是否实现了实现了InitializingBean接口，如果实现了InitializingBean接口，则只掉调用bean的afterPropertiesSet方法  
  boolean isInitializingBean = (bean instanceof InitializingBean);  
  if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {  
      if (logger.isDebugEnabled()) {  
          logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");  
      }  
        
      if (System.getSecurityManager() != null) {  
          try {  
              AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {  
                  public Object run() throws Exception {  
                      //直接调用afterPropertiesSet  
                      ((InitializingBean) bean).afterPropertiesSet();  
                      return null;  
                  }  
              },getAccessControlContext());  
          } catch (PrivilegedActionException pae) {  
              throw pae.getException();  
          }  
      }                  
      else {  
          //直接调用afterPropertiesSet  
          ((InitializingBean) bean).afterPropertiesSet();  
      }  
  }  
  if (mbd != null) {  
      String initMethodName = mbd.getInitMethodName();  
      //判断是否指定了init-method方法，如果指定了init-method方法，则再调用制定的init-method  
      if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&  
              !mbd.isExternallyManagedInitMethod(initMethodName)) {  
              //进一步查看该方法的源码，可以发现init-method方法中指定的方法是通过反射实现  
          invokeCustomInitMethod(beanName, bean, mbd);  
      }  
  }

总结

Spring 为 bean 提供了两种初始化 bean 的方式，实现 InitializingBean 接口，实现 afterPropertiesSet 方法，或者在配置文件中通过 init-method 指定，两种方式可以同时使用
实现 InitializingBean 接口是直接调用 afterPropertiesSet 方法，比通过反射调用 init-method 指定的方法效率相对来说要高点。但是 init-method 方式消除了对 Spring 的依赖
如果调用 afterPropertiesSet 方法时出错，则不调用 init-method 指定的方法
要将 Spring 的配置文件和 Spring MVC 的配置文件分开

原文 https://juejin.im/post/5b3a31776fb9a024e62b8c77

正文到此结束