java Web 启动时自动执行代码的几种方式

1、实现Servlet监听器接口ServletContextListener
2、实现Servlet的过滤器Filter
3、编写一个Servlet,在web.xml里面配置容器启动后执行即可
4、如果你使用Spring IOC作为Bean管理容器，那么可以指定init-method其中init-method表示bean加载成功后，立即执行某个方法
5、如果你使用Spring IOC作为Bean管理容器，还可以实现Spring的Bean后置处理器接口：BeanFactoryPostProcessor表示：该Bean加载完成之后，Spring可以让开发者自定义一些事件

Web容器启动后执行代码的顺序为：4===>5===>1===>2===>3

下面对于上面几种方式，我逐一讲解：

1、实现Servlet监听器接口ServletContextListener

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class myListener implements ServletContextListener{
    public void contextDestroyed(ServletContextEvent arg0) {
        System.out.println("容器关闭时执行");
    }
    public void contextInitialized(ServletContextEvent arg0) {
        System.out.println("容器启动时执行");
    }
}

它对应web.xml中的配置

    com.primeton.eos2.myListener.

2、实现Servlet的过滤器Filter

Filter也称之为过滤器，它是Servlet技术中最实用的技术，Web开发人员通过Filter技术，对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息等一些高级功能。
Filter功能:在HttpServletRequest到达 Servlet 之前，拦截客户的HttpServletRequest 。根据需要检查HttpServletRequest，也可以修改HttpServletRequest 头和数据。
在HttpServletResponse到达客户端之前，拦截HttpServletResponse 。根据需要检查HttpServletResponse，也可以修改HttpServletResponse头和数据。

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class MyFilter implements Filter{
    public void destroy() {
        //Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才销毁。在Web容器卸载 Filter 对象之前被调用。
        //该方法在Filter的生命周期中仅执行一次。在这个方法中，可以释放过滤器使用的资源。
    }
    public void doFilter(ServletRequest arg0, ServletResponse arg1,
            FilterChain arg2) throws IOException, ServletException {
        //这个方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL的时候，Servlet过滤器将先执行doFilter方法。FilterChain参数用于访问后续过滤器。
    }
    public void init(FilterConfig arg0) throws ServletException {
        //和我们编写的Servlet程序一样，Filter的创建和销毁由WEB服务器负责。 web 应用程序启动时，web 服务器将创建Filter 的实例对象，
        //并调用其init方法，读取web.xml配置，完成对象的初始化功能，从而为后续的用户请求作好拦截的准备工作（filter对象只会创建一次，
        //init方法也只会执行一次）。开发人员通过init方法的参数，可获得代表当前filter配置信息的FilterConfig对象。
    }
}

它对应web.xml中的配置
        
        MyFilter用于为过滤器指定一个名字，该元素的内容不能为空
        com.primeton.eos2.MyFilter元素用于指定过滤器的完整的限定类名
                配置一些初始化参数
                        redirectPath
                        /index.jsp
                
    
    
        MyFilter子元素用于设置filter的注册名称。该值必须是在元素中声明过的过滤器的名字
        /*设置 filter 所拦截的请求路径(过滤器关联的URL样式)
                FORWARD指定过滤器所拦截的资源被 Servlet 容器调用的方式，可以是REQUEST,INCLUDE,FORWARD和ERROR之一，默认REQUEST。用户可以设置多个子元素用来指定 Filter 对资源的多种调用方式进行拦截
        REQUEST
        INCLUDE
    

子元素可以设置的值及其意义
REQUEST：当用户直接访问页面时，Web容器将会调用过滤器。如果目标资源是通过RequestDispatcher的include()或forward()方法访问时，那么该过滤器就不会被调用。
INCLUDE：如果目标资源是通过RequestDispatcher的include()方法访问时，那么该过滤器将被调用。除此之外，该过滤器不会被调用。
FORWARD：如果目标资源是通过RequestDispatcher的forward()方法访问时，那么该过滤器将被调用，除此之外，该过滤器不会被调用。
ERROR：如果目标资源是通过声明式异常处理机制调用时，那么该过滤器将被调用。除此之外，过滤器不会被调用。

注意:如果存在多个Filter，其过滤的先后顺序是在web.xml文件中配置的先后顺序，配在上面的优先过滤;而对请求和返回值的拦截为doFilter()函数前的为请求的拦截，函数后的为对返回值的拦截，返回值的拦截，通过ServletResponse不能直接拿到返回的内容，需要自定义一个类(继承HttpServletResponseWrapper),在这个类中获取返回值

初始化参数的获取：
用户在配置filter时，可以使用为filter配置一些初始化参数，当web容器实例化Filter对象，调用其init方法时，会把封装了filter初始
化参数的filterConfig对象传递进来。因此开发人员在编写filter时，通过filterConfig对象的方法，就可获得以下内容：
String getFilterName();//得到filter的名称。 
String getInitParameter(String name);//返回在部署描述中指定名称的初始化参数的值。如果不存在返回null. 
Enumeration getInitParameterNames();//返回过滤器的所有初始化参数的名字的枚举集合。 
public ServletContext getServletContext();//返回Servlet上下文对象的引用。

一段简单的代码：
/**
 *    判断用户是否登录,未登录则退出系统
 */
public class SessionFilter implements Filter {

    public FilterConfig config;

    public void destroy() {
        this.config = null;
    }

    public static boolean isContains(String container, String[] regx) {
        boolean result = false;

        for (int i = 0; i < regx.length; i++) {
            if (container.indexOf(regx[i]) != -1) {
                return true;
            }
        }
        return result;
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest hrequest = (HttpServletRequest)request;
        HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) response);

        String logonStrings = config.getInitParameter("logonStrings");        // 登录登陆页面
        String includeStrings = config.getInitParameter("includeStrings");    // 过滤资源后缀参数
        String redirectPath = hrequest.getContextPath() + config.getInitParameter("redirectPath");// 没有登陆转向页面
        String disabletestfilter = config.getInitParameter("disabletestfilter");// 过滤器是否有效

        if (disabletestfilter.toUpperCase().equals("Y")) {    // 过滤无效
            chain.doFilter(request, response);
            return;
        }
        String[] logonList = logonStrings.split(";");
        String[] includeList = includeStrings.split(";");

        if (!this.isContains(hrequest.getRequestURI(), includeList)) {// 只对指定过滤参数后缀进行过滤
            chain.doFilter(request, response);
            return;
        }

        if (this.isContains(hrequest.getRequestURI(), logonList)) {// 对登录页面不进行过滤
            chain.doFilter(request, response);
            return;
        }

        String user = ( String ) hrequest.getSession().getAttribute("useronly");//判断用户是否登录
        if (user == null) {
            wrapper.sendRedirect(redirectPath);
            return;
        }else {
            chain.doFilter(request, response);
            return;
        }
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        config = filterConfig;
    }
}

//例如在处理某个系统的跨域问题时，可以加一个过滤器，给所有请求的返回数据加些头信息
public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException,ServletException { 
    HttpServletRequest hrequest =(HttpServletRequest)request;
    HttpServletResponse hresponse = (HttpServletResponse)response;
    HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper(hresponse);
    chain.doFilter(request,response);
    hresponse.setCharacterEncoding(“UTF-8”);
    hresponse.setHeader("Access-Control-Allow-Origin","*");
    hresponse.setHeader("Access-Control-Allow-Methods","OPTIONS,GET,POST");
    hresponse.setHeader("Access-Control-Allow-Headers","x-requested-with,content-type");
    hresponse.setHeader("Access-Control-Max-Age","86400");
    response=hresponse;
}

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

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyServlet extends HttpServlet{
    public void init(ServletConfig config) {
        //初始化时使用，只会执行一次
                String username = config.getInitParameter("username");
        System.out.println(username);
    }
    protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,java.io.IOException
    {
        resp.getWriter().println("I am httpServlet doGet()");
    }
 
    protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,java.io.IOException
    {
        resp.getWriter().println("I am httpServlet doPost()");
    }
    public void destory(ServletConfig config){
        
    }
}

它对应的web.xml的配置：
        
        MyServlet名称
        com.primeton.eos2.MyServlet
        
            username
            test
        
                
        2
    
    
        MyServlet名称（要是selvet声明过的名称）
        /abc
    
 关于启动后执行，由load-on-startup指定：
（1）当值为0或者大于0时，表示容器在应用启动时就加载这个servlet。值越小，启动优先级越高；
（2）当是一个负数时或者没有指定时，表示该servlet被调用时才加载。

4、如果你使用Spring IOC作为Bean管理容器，那么可以指定init-method其中init-method表示bean加载成功后，立即执行某个方法。配置如下：start为要执行的方法名称

5、如果你使用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> shopList = shopService.findAllShop();
        System.out.println("================>" + shopList);
        System.out.println("================>[BeanFactoryPostProcessor]自动加载启动结束.");
    }
}

本文借鉴于：https://blog.csdn.net/fcly2013/article/details/19984061，如有兴趣，请看原文