通过注解实现调用指定的拦截器

绝地灬酷狼 2022-09-25 12:21 149阅读 0赞

import java.lang.annotation.ElementType;
    import java.lang.annotation.Target;
    import java.text.MessageFormat;
    
    import javax.annotation.PostConstruct;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.commons.lang3.ArrayUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.method.HandlerMethod;
    import org.springframework.web.servlet.AsyncHandlerInterceptor;
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    /**
     * 通过注解实现调用指定的拦截器
     * 
     * @author Saleson Lee.
     * @date 2016年3月19日
     * @time 下午6:58:10
     */
    public class AnnotationHandlerInterceptor extends HandlerInterceptorAdapter {
    
    	private static final Logger LOG = LoggerFactory
    			.getLogger(AnnotationHandlerInterceptor.class);
    
    	/**
    	 * 需要过滤的注解类型
    	 */
    	@SuppressWarnings("rawtypes")
    	private Class annotationClass;
    
    	/**
    	 * 过滤器
    	 */
    	private AsyncHandlerInterceptor[] handlerInterceptors;
    
    	/**
    	 * 检测类或方法的注解
    	 */
    	private AnnotationTarget annotationTarget;
    
    	@SuppressWarnings("unchecked")
    	@PostConstruct
    	public void init() throws Exception {
    		if (this.annotationClass == null) {
    			throw new Exception("属性annotationClass为空");
    		} else if (handlerInterceptors == null) {
    			throw new Exception("属性handlerInterceptors为空");
    		}
    		if (annotationTarget == null) {
    			Target target = (Target) annotationClass
    					.getAnnotation(Target.class);
    			if (target == null) {
    				throw new Exception(MessageFormat.format("注解{0}没有定义{1}注解",
    						annotationClass, target));
    			}
    			ElementType[] eTypes = target.value();
    			if (ArrayUtils.contains(eTypes, ElementType.METHOD)
    					&& ArrayUtils.contains(eTypes, ElementType.TYPE)) {
    				annotationTarget = AnnotationTarget.TYPE_AND_METHOD;
    
    			} else if (ArrayUtils.contains(eTypes, ElementType.METHOD)) {
    				annotationTarget = AnnotationTarget.METHOD;
    
    			} else if (ArrayUtils.contains(eTypes, ElementType.TYPE)) {
    				annotationTarget = AnnotationTarget.TYPE;
    
    			} else {
    				throw new Exception(MessageFormat.format(
    						"注解{0}中{1}注解没有定义{2}或{3}", annotationClass, target,
    						ElementType.TYPE, AnnotationTarget.METHOD));
    			}
    		}
    		printDebugInitLog();
    	}
    
    	@SuppressWarnings("unchecked")
    	@Override
    	public boolean preHandle(HttpServletRequest request,
    			HttpServletResponse response, Object handler) throws Exception {
    		HandlerMethod method = (HandlerMethod) handler;
    		boolean invokable = false;
    		switch (annotationTarget) {
    		case METHOD:
    			invokable = method.getMethod().getAnnotation(annotationClass) != null;
    			break;
    		case TYPE:
    			invokable = method.getBeanType().getAnnotation(annotationClass) != null;
    			break;
    		case TYPE_AND_METHOD:
    			invokable = method.getMethod().getAnnotation(annotationClass) != null
    					|| method.getBeanType().getAnnotation(annotationClass) != null;
    			break;
    		}
    
    		if (invokable) {
    			return invokeHandlerInterceptorsPreHandle(request, response,
    					handler);
    		}
    		return true;
    	}
    
    	/**
    	 * 调用过滤器
    	 * 
    	 * @param request
    	 * @param response
    	 * @param handler
    	 * @return
    	 * @throws Exception
    	 */
    	private boolean invokeHandlerInterceptorsPreHandle(
    			HttpServletRequest request, HttpServletResponse response,
    			Object handler) throws Exception {
    		for (AsyncHandlerInterceptor handlerInterceptor : handlerInterceptors) {
    			if (!handlerInterceptor.preHandle(request, response,
    					handler)) {
    				return false;
    			}
    		}
    		return true;
    	}
    
    	/**
    	 * @param handlerInterceptors
    	 *            the handlerInterceptors to set
    	 */
    	public void setHandlerInterceptors(
    			AsyncHandlerInterceptor[] handlerInterceptors) {
    		this.handlerInterceptors = handlerInterceptors;
    	}
    
    	/**
    	 * @param annotationClass
    	 *            the annotationClass to set
    	 */
    	public void setAnnotationClass(String annotationClass) {
    		try {
    			this.annotationClass = Class.forName(annotationClass);
    		} catch (ClassNotFoundException e) {
    			LOG.error(MessageFormat.format("找不到类 ==> {0}", annotationClass), e);
    		}
    	}
    
    	/**
    	 * @param annotationTarget
    	 *            the annotationTarget to set
    	 */
    	public void setAnnotationTarget(AnnotationTarget annotationTarget) {
    		this.annotationTarget = annotationTarget;
    	}
    
    	/**
    	 * 打印Debug日志
    	 */
    	private void printDebugInitLog() {
    		switch (annotationTarget) {
    		case TYPE_AND_METHOD:
    			LOG.debug("拦截标有{}注解的Controller类和方法, 调用过滤器{}", annotationClass,
    					handlerInterceptors);
    			break;
    		case TYPE:
    			LOG.debug("拦截标有{}注解的Controller类, 调用过滤器{}", annotationClass,
    					handlerInterceptors);
    			break;
    		case METHOD:
    			LOG.debug("拦截标有{}注解的Controller类方法, 调用过滤器{}", annotationClass,
    					handlerInterceptors);
    		}
    	}
    
    	enum AnnotationTarget {
    		TYPE_AND_METHOD, TYPE, METHOD
    	}
    
    }