Web容器启动时执行代码的几种方式

Web容器启动后执行代码的几种方式

一、没有用Spring Web框架时的方式

对于Java Web，如果没有使用Spring Web框架，则可以利用 三大Web组件的生命周期 来进行执行需要初始化的代码

　　1、web.xml文件中的加载顺序为：listener-filter-servlet

　　2、如果web.xml中配置了<context-param>，初始化顺序：context-param > Listener > Filter > Servlet

 

1、实现Servlet API监听器接口ServletContextListener

在 Servlet API 中有一个 ServletContextListener 接口，它能够监听 ServletContext 对象的生命周期，实际上就是监听 Web 应用的生命周期。

当Servlet 容器启动或终止Web 应用时，会触发ServletContextEvent 事件，该事件由 ServletContextListener 来处理。

在 ServletContextListener 接口中定义了处理ServletContextEvent 事件的两个方法：

1. contextInitialized(ServletContextEvent sce) ：当Servlet 容器启动Web 应用时调用该方法。在调用完该方法之后，容器再对Filter 初始化，并且对那些在Web 应用启动时就需要被初始化的Servlet 进行初始化。
2. contextDestroyed(ServletContextEvent sce) ：当Servlet 容器终止Web 应用时调用该方法。在调用该方法之前，容器会先销毁所有的Servlet 和Filter 过滤器。

示例代码如下：

public class InitListener implements ServletContextListener {  
  
    @Override  
    public void contextDestroyed(ServletContextEvent context) {  
          
    }  
  
    @Override  
    public void contextInitialized(ServletContextEvent context) {  
        // 上下文初始化执行  
        System.out.println("================>[ServletContextListener]自动加载启动开始.");  
        SpringUtil.getInstance().setContext(  
        WebApplicationContextUtils.getWebApplicationContext(arg0.getServletContext())  
    }  
  
}  

然后在web.xml文件配置该监听器

<listener>  
    <listener-class>com.test.init.InitListener</listener-class>  
</listener> 

2、实现Servlet API的过滤器Filter

public class InitFilter implements Filter {  
  
    @Override  
    public void destroy() {  
  
    }  
  
    @Override  
    public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2) throws IOException,  
            ServletException {  
  
    }  
  
    @Override  
    public void init(FilterConfig config) throws ServletException {  
        System.out.println("================>[Filter]自动加载启动开始.");  
        // 读取Spring容器中的Bean[此时Bean已加载,可以使用]  
       //写启动需要执行的代码  
        System.out.println("================>[Filter]自动加载启动结束.");  
    }  
  
}  

然后在web.xml文件配置过滤器即可

<filter>  
    <filter-name>InitFilter</filter-name>  
    <filter-class>com.test.init.InitFilter</filter-class>  
</filter>  
<filter-mapping>  
    <filter-name>InitFilter</filter-name>  
    <url-pattern>/</url-pattern>  
</filter-mapping>  

3、编写一个Servlet,在web.xml里面配置容器启动后执行即可

public class InitServlet extends HttpServlet {  
  
    /**  
     */  
    private static final long serialVersionUID = 1L;  
  
    @Override  
    public void init(ServletConfig config) {  
        try {  
            super.init();  
        } catch (ServletException e) {  
            e.printStackTrace();  
        }  
        System.out.println("================>[Servlet]自动加载启动开始.");  
        // 读取Spring容器中的Bean[此时Bean已加载,可以使用]  
       //执行想要的代码  
        System.out.println("================>[Servlet]自动加载启动结束.");  
    }  
}  
   
然后在web.xml文件配置该Servlet的启动方式为：容器启动后执行  
    <servlet>  
        <servlet-name>InitServlet</servlet-name>  
        <servlet-class>com.test.init.InitServlet</servlet-class>  
        <init-param>  
            <param-name>username</param-name>  
            <param-value>test</param-value>  
        </init-param>  
                <!-- 此处指定加载顺序为2,表明还有优先级更高的Servlet要先执行 -->  
        <load-on-startup>2</load-on-startup>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>InitServlet</servlet-name>  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
 关于启动后执行，由load-on-startup指定：  
（1）当值为0或者大于0时，表示容器在应用启动时就加载这个servlet。值越小，启动优先级越高；  
（2）当是一个负数时或者没有指定时，表示该servlet被调用时才加载。  
   

二、基于Spring Web集成的Web项目

基于Spring Web集成的Web项目可以通过Bean的完整生命周期来执行需要初始化的代码

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1、Bean自身的方法　　：　　这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法

2、Bean级生命周期接口方法　　：　　这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法

3、容器级生命周期接口方法　　：　　这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

4、工厂后处理器接口方法　　：　　这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

一般常用的方式有以下三种：

• @PostConstruct 构造后置执行
• @Bean(initMethod="xxx") 初始化功能
• @InitializingBean#afterPropertiesSet 属性填充后执行

也可以使用 “容器级生命周期接口方法” 和 “工厂后处理器接口方法”，不过不常用。

1、如果你使用Spring IOC作为Bean管理容器，那么可以指定init-method其中init-method表示bean加载成功后，立即执行某个方法。或者@Bean(initMethod)

配置如下：start为要执行的方法名称

<!-- service -->  
<bean id="shopService" class="com.test.teach.service.ShopService" init-method="start">  
    <property name="shopDao" ref="shopDao" />  
</bean> 

2、使用@PostConstruce，会在Bean的构造函数执行后执行

3、声明InitializingBean接口，该接口有一个afterPropertiesSet方法，会在属性填充后执行

4、如果你使用Spring IOC作为Bean管理容器，还可以实现Spring的Bean后置处理器接口

BeanFactoryPostProcessor表示：该Bean加载完成之后，Spring可以让开发者自定义一些事件

public class KeyWordInit implements BeanFactoryPostProcessor {  
  
    @Override  
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {  
        System.out.println("================>[BeanFactoryPostProcessor]自动加载启动开始.");  
        ShopService shopService = factory.getBean("shopService", ShopService.class);  
        List<Map<String, Object>> shopList = shopService.findAllShop();  
        System.out.println("================>" + shopList);  
        System.out.println("================>[BeanFactoryPostProcessor]自动加载启动结束.");  
    }  
  
}  

 

5、在Spring中，凡是实现ServletContextAware接口的类，都可以取得ServletContext。

实现如下： 

private ServletContext application;
public void setServletContext(ServletContext servletContext) {  
    this.application = servletContext;  
}

那么Spring是在什么时候把ServletContext放置进去的呢？通过对Spring的学习，终于明白了。 

在web项目中，Spring容器的加载是通过XmlWebApplicationContext进行的。 

它的父类AbstractRefreshableWebApplicationContext，在postProcessBeanFactory方法中进行了如下操作(postProcessBeanFactory方法被AbstractApplicationContext的refresh方法调用) 

beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);

代码的第一句就是添加了一个ServletContextAwareProcessor。 

该类的postProcessBeforeInitialization方法如下

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (this.servletContext != null && bean instanceof ServletContextAware) {
            ((ServletContextAware) bean).setServletContext(this.servletContext);
        }
        if (this.servletConfig != null && bean instanceof ServletConfigAware) {
            ((ServletConfigAware) bean).setServletConfig(this.servletConfig);
        }
        return bean;
    }

而所有的BeanPostProcessor都将在AbstractAutowireCapableBeanFactory类的initializeBean方法中，通过调用applyBeanPostProcessorsBeforeInitialization方法完成所有实现BeanPostProcessor接口的postProcessBeforeInitialization的调用。 

XmlWebApplicationContext使用的BeanFactory是DefaultListableBeanFactory。 

DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory，因此可以完成上述操作。 

如此完成了只要实现了ServletContextAware接口的，都可以获取ServletContext。