【spring-boot神器】第一篇:拦截器，过滤器，监听器，控制器，消息转换器，AOP执行顺序

整理一下这几天学习的资料和代码

第一部分、上代码

1、spring各种器的实现，idea搭建spring-boot的教程在这里http://www.jianshu.com/p/9082a533fa3c（整理的很好）

 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
 import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
 import org.springframework.boot.web.servlet.ServletComponentScan;
 import org.springframework.context.annotation.ImportResource;

 @SpringBootApplication(exclude =
         {DataSourceAutoConfiguration.class,
                 HibernateJpaAutoConfiguration.class} //排除初始化的数据库的包
 ) //移除自动注入数据源
 @ServletComponentScan   //扫描过滤器、拦截器、监听器、servlet
 @ImportResource(locations = {"classpath:application-bean.xml"}) //加载配置的xml(路径是src/main/resourcse/application-bean.xml)
 public class SloveApplication {

     public static void main(String[] args) {
         SpringApplication.run(SloveApplication.class, args);
     }

 }

2、监听器

 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 import javax.servlet.annotation.WebListener;

 /**
  *
  */
 @WebListener
 public class MyListener  implements ServletContextListener{
     @Override
     public void contextInitialized(ServletContextEvent servletContextEvent) {
         System.out.println("监听器初始化");
         System.out.println(servletContextEvent.getServletContext().getServerInfo());
     }

     @Override
     public void contextDestroyed(ServletContextEvent servletContextEvent) {
         System.out.println("监听器销毁");
     }
 }

3、过滤器

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("过滤器操作");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("过滤器销毁");
    }
}

4、拦截器

 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 /**
  *
  *  拦截器实现
  */
 public class MyInterceptor implements HandlerInterceptor {

     @Override
     public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
         System.out.println("--------------拦截器请求前调用-----------------------------");
         return true;// 只有返回true才会继续向下执行，返回false取消当前请求
     }

     @Override
     public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
         System.out.println("请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");

     }

     @Override
     public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
         System.out.println("在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行（主要是用于进行资源清理工作）");

     }
 }

5、消息转换器

import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;

import java.io.IOException;

/**
 *
 */
public class MyConver extends FastJsonHttpMessageConverter {

    @Override
    protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        //fastJson的版本影响是否可以获取
        System.out.println("--------------请求进入到消息转化器-------------------");
        return super.readInternal(clazz, inputMessage);
    }

    @Override
    protected void writeInternal(Object obj, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        System.out.println("--------------响应进入到消息转化器-------------------");
        super.writeInternal(obj, outputMessage);
    }
}

配套的xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <!-- spring可以自动去扫描base-pack下面的包或者子包下面的java文件，
        如果扫描到有Spring的相关注解的类，则把这些类注册为Spring的bean -->
    <context:component-scan base-package="com.eternal"/>
    <!-- 实际开发中使用<mvc:annotation-driven/>代替注解适配器和映射器,设置配置方案 -->
    <mvc:annotation-driven>
        <!-- 设置不使用默认的消息转换器 -->
        <mvc:message-converters register-defaults="false">
            <!-- 配置Spring的转换器 -->
            <!-- 配置fastjson中实现HttpMessageConverter接口的转换器 -->
            <bean id="fastJsonHttpMessageConverter"  class="com.eternal.slovej.component.MyConver">
                <!-- 加入支持的媒体类型：返回contentType -->
                <property name="supportedMediaTypes">
                    <list>
                        <!-- 这里顺序不能反，一定先写text/html,不然ie下会出现下载提示 -->
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
            <!--<bean class="org.springframework.http.converter.StringHttpMessageConverter"/>-->
            <!--<bean class="org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter"/>-->
            <!--<bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter"/>-->
            <!--<bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/>-->
        </mvc:message-converters>
    </mvc:annotation-driven>
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.eternal.slovej.component.MyInterceptor" />
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

6、aop

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
 import org.springframework.context.annotation.Configuration;

 /**
  * Created by Administrator on 2017/7/31.
  */
 @Aspect
 @Configuration
 public class MyAop {
     /*
     * 定义一个切入点
     */
     @Pointcut("execution(* com.eternal.slovej.component.MyController.*(..))")
     public void excudeService() {
         System.out.println("==========定义切点===========");
     }

     /**
      * 通过连接点切入
      */
     @Before("excudeService()")
     public void twiceAsOld1(JoinPoint point) {
         System.out.println("before切面执行了。。。。" + point.getKind());
     }

     @Around("excudeService()")
     public Object twiceAsOld(ProceedingJoinPoint thisJoinPoint) {
         Object s =null ;
         try {
             s = thisJoinPoint.proceed();
         } catch (Throwable throwable) {
             throwable.printStackTrace();
         }
         System.out.println("Around切面执行了。。。。");
         return s;
     }

     @After("excudeService()")
     public void twiceAsOld3(JoinPoint point) {
         System.out.println("after切面执行了。。。。" + point.getKind());
     }

     @AfterReturning("excudeService()")
     public void doFindByIdCheck() {
         System.out.println("=======AfterReturning后置通知==================");
     }

 }

7、控制器

 import com.eternal.slovej.Test;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;

 /**
  *
  */
 @RestController
 public class MyController {

     //添加了一个方法
     @RequestMapping(value = "/hello")
     @ResponseStatus(HttpStatus.OK)
     public String hello(@RequestBody Test test) {
         System.out.println("----进入方法----" + test.getName()+"---------------"+test.getAge());
         return "no hello world";
     }
 }

8、servlet

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 *
 */
@WebServlet(urlPatterns = "/b")
public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doPost()");
    }
}

第二部分、跑代码

通过main()方法启动项目(使用内置的tomcat启动)---spring boot内置了三种servlet容器：tomcat，jetty，undertow。

监听器初始化
Apache Tomcat/8.5.16
过滤器初始化

启动成功后调用controller

过滤器操作
--------------拦截器请求前调用-----------------------------
--------------请求进入到消息转化器-------------------
before切面执行了。。。。method-execution
----进入方法----123---------------123
Around切面执行了。。。。
after切面执行了。。。。method-execution
=======AfterReturning后置通知==================
--------------响应进入到消息转化器-------------------
请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行（主要是用于进行资源清理工作）

执行顺序

接下来将对各个神器进行总结讲解

感谢 http://www.jianshu.com/u/8dc5811b228f 大神的精彩文章