关于Filter，interceptor和aop横切面的使用

最近公司的活不太忙，学习netty之余又复习了一下过滤器和拦截器的区别，多余的话就不说了，只说我认为比较重要的几点，过滤器是实现filter接口，是jdk自带的功能，只生效一次，而拦截器是spring的功能，是interceptor,可以环绕，是通过aop原理实现，而@Aspect注解类似拦截器，但是个人认为，就是拦截器是是全面应用于所有方法，而@Aspect注解只针对某一部分接口

package com.filter;

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;

import org.springframework.stereotype.Component;

/**
 * 这是个过滤器
 * 
 * @author 087
 *
 */
@Component
public class MyFilter implements Filter {

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println("经过了init");
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		// TODO Auto-generated method stub
		HttpServletRequest req = (HttpServletRequest) request;
		System.out.println("经过了dofilter");
		// 这里我随便写的可以随便改
		if (req.getRequestURL().toString().contains(".do")) {
			chain.doFilter(request, response);
		}
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		System.out.println("经过了destroy");
	}

}

这就是一个简单的过滤器，有什么操作在dofilter里写就可以了
拦截器稍微麻烦一点，第一步是创建一个类，实现 HandlerInterceptor 接口，需要注意的是preHandle的返回值，如果返回的是true，就能正常访问，如果是false,就无法访问接口了

package com.filter;

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

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

/**
 * 这是个拦截器
 * 
 * @author 087
 *
 */

@Component
public class MyInterceptor implements HandlerInterceptor {

	/**
	 * 在业务处理器处理请求之前被调用。预处理，可以进行编码、安全控制、权限校验等处理；
	 */

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("我是prehandle");
		return true;
	}

	/**
	 * 在业务处理器处理请求执行完成后，生成视图之前执行。后处理（调用了Service并返回ModelAndView，但未进行页面渲染），有机会修改ModelAndView
	 * （这个博主就基本不怎么用了）；
	 */

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
		String servletPath = request.getServletPath();
		// 我是方法名
		System.out.println(servletPath);
		System.out.println("我是postHandle");

	}

	/**
	 * 在DispatcherServlet完全处理完请求后被调用，可用于清理资源等。返回处理（已经渲染了页面）；
	 */
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception { // TODO Auto-generated method stub System.out.println("我是afterCompletion");
	}

}

因为这个过滤器是spring整体框架里带的功能，所以理所应当需要在spring里配置一下，filter因为是java的jdk自带的，所以不需要，配置文件如下

package com.configuration;

import java.util.List;

import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.AsyncSupportConfigurer;
import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.filter.MyInterceptor;

/**
 * @author 087
 */
@Configuration
public class MyConfiguration implements WebMvcConfigurer {

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
	}

	@Override
	public void configurePathMatch(PathMatchConfigurer configurer) {
	}

	@Override
	public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {

	}

	@Override
	public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
	}

	@Override
	public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
	}

	@Override
	public void addFormatters(FormatterRegistry registry) {
	}

	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {

	}

	@Override
	public void addCorsMappings(CorsRegistry registry) {

	}

	@Override
	public void addViewControllers(ViewControllerRegistry registry) {

	}

	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {

	}

	@Override
	public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {

	}

	@Override
	public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {

	}

	@Override
	public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
	}

	@Override
	public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

	}

	@Override
	public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {

	}

	@Override
	public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
	}

	@Override
	public Validator getValidator() {
		return null;
	}

	@Override
	public MessageCodesResolver getMessageCodesResolver() {
		return null;
	}
}

还有一个注解@Aspect，使用这个可以取得横切面，就是aop，用这个的好处就是可以指定方法路径或者指定方法名前缀

package com.filter;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect // 该注解标示该类为切面类
@Component
public class MyAction {

	@Around("execution(* com.service.*.*(..))")
//  @After("execution(* com.service.*.*(..))")
//	@Before("execution(* com.service.*.*(..))")
//  @AfterThrowing()
//  @AfterReturning()
	public Object method(ProceedingJoinPoint point) throws Throwable {
		System.out.println("经过切面");
		Object[] args = point.getArgs();
		Object proceed = point.proceed(args);
		System.out.println(proceed);
		System.out.println("后置通知");
		return proceed;
	}
	
	
	@AfterReturning(value = "execution(* com.service.*.*(..))", returning = "value")
	public void method(JoinPoint point, Object value) {
		System.out.println("返回参数是" + value);
	}

}