Java注解 + 基于注解 & 拦截器实现登录验证 / 权限控制

Java中的注解是如何工作的？
java 注解的几大作用及使用方法详解
一种基于注解的Spring MVC权限控制方法
第五章 处理器拦截器详解

---

2017-04-17
token可以通过加密（如DES）的方式构造 / 解密：在线加密解密
密码（秘钥）生成：在线生成随机密码

---

一、注解的作用

1、生成文档。这是最常见的，也是Java最早提供的注解。常用的有@see @param @return 等；
2、跟踪代码依赖性，实现替代配置文件功能。比较常见的是spring 2.5 开始的基于注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文件的数量。以后java的程序开发，最多的也将实现注解配置，具有很大用处;
3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

注解用例

注解的功能很强大，Spring和Hebernate这些框架在日志和有效性中大量使用了注解功能。注解可以应用在使用标记接口的地方。不同的是标记接口用来定义完整的类，但你可以为单个的方法定义注释，例如是否将一个方法暴露为服务。

在最新的servlet3.0中引入了很多新的注解，尤其是和servlet安全相关的注解。

• HandlesTypes –该注解用来表示一组传递给ServletContainerInitializer的应用类。
• HttpConstraint – 该注解代表所有HTTP方法的应用请求的安全约束，和ServletSecurity注释中定义的HttpMethodConstraint安全约束不同。
• HttpMethodConstraint – 指明不同类型请求的安全约束，和ServletSecurity 注解中描述HTTP协议方法类型的注释不同。
• MultipartConfig –该注解标注在Servlet上面，表示该Servlet希望处理的请求的 MIME 类型是 multipart/form-data。
• ServletSecurity 该注解标注在Servlet继承类上面，强制该HTTP协议请求遵循安全约束。
• WebFilter – 该注解用来声明一个Server过滤器；
• WebInitParam – 该注解用来声明Servlet或是过滤器的中的初始化参数，通常配合 @WebServlet 或者 @WebFilter 使用。
• WebListener –该注解为Web应用程序上下文中不同类型的事件声明监听器。
• WebServlet –该注解用来声明一个Servlet的配置。

二、annotation是如何工作的？

记住：annotation仅仅是元数据，和业务逻辑无关。
怎么理解呢？annotation只是做一个“标记”，至多携带一些附加信息，比如：

// 一个自定义的annotation
@Todo(priority = Todo.Priority.MEDIUM, author = "Yashwant", status = Todo.Status.STARTED)

再比如@Override注解的实现：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {

}

可以看到：什么都没有。
既然annotation仅仅是“标记”，没有实现逻辑，那么必须有人来实现这些逻辑 —— 元数据的用户来做这个事情：annotations仅仅提供它定义的属性(类/方法/包/域)的信息，annotations的用户(同样是一些代码)来读取这些信息并实现必要的逻辑，这些逻辑的实现往往是通过反射机制，通过getAnnotation()这个方法用来返回注解信息。在spring中通过HandlerInterceptorAdapter来实现逻辑。

比如说，当我们使用Java的标注annotations(例如@Override)时，JVM就是一个用户，它在字节码层面工作。到这里，应用开发人员还不能控制也不能使用自定义的注解。因此，我们讲解一下如何编写自定义的annotations。

三、编写自定义的annotation

我们来逐个讲述编写自定义Annotations的要点。上面的例子中，你看到一些注解应用在注解上。
J2SE5.0版本在 java.lang.annotation提供了四种元注解，专门注解其他的注解：

• @Documented 注解是否将包含在JavaDoc中
• @Retention 什么时候使用该注解
• @Target 注解用于什么地方
• @Inherited 是否允许子类继承该注解

@Documented

表示是否将注解信息添加在java文档中

@Retention

定义该注解的生命周期

• RetentionPolicy.SOURCE
  在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。

• RetentionPolicy.CLASS
  在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式。

• RetentionPolicy.RUNTIME
  始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

@Target

表示该注解用于什么地方。如果不明确指出，该注解可以放在任何地方。以下是一些可用的参数。需要说明的是：属性的注解是兼容的，如果你想给7个属性都添加注解，仅仅排除一个属性，那么你需要在定义target包含所有的属性。

• ElementType.TYPE:用于描述类、接口或enum声明
• ElementType.FIELD:用于描述实例变量
• ElementType.METHOD
• ElementType.PARAMETER
• ElementType.CONSTRUCTOR
• ElementType.LOCAL_VARIABLE
• ElementType.ANNOTATION_TYPE 另一个注释
• ElementType.PACKAGE 用于记录java文件的package信息

@Inherited

定义该注释和子类的关系
那么，注解的内部到底是如何定义的呢？annotations只支持基本类型、String及枚举类型。注释中所有的属性被定义成方法，并允许提供默认值。

例子：

定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Todo {
public enum Priority {LOW, MEDIUM, HIGH}
  public enum Status {STARTED, NOT_STARTED}
  String author() default "Yash";
  Priority priority() default Priority.LOW;
  Status status() default Status.NOT_STARTED;
}

// 如果注解中只有一个属性，可以直接命名为“value”，使用时无需再标明属性名：
@interface Author{
  String value();
}

使用注解

@Todo(priority = Todo.Priority.MEDIUM, author = "Yashwant", status = Todo.Status.STARTED)
public void incompleteMethod1() {
  //Some business logic is written
  //But it’s not complete yet
}

@Author("Yashwant")
public void someMethod() {
}

用户程序实现注解

我们定义了自己的注解并将其应用在业务逻辑的方法上，现在我们需要写一个用户程序调用我们的注解。这里我们需要使用反射机制。如果你熟悉反射代码，就会知道反射可以提供类名、方法和实例变量对象。所有这些对象都有getAnnotation()这个方法用来返回注解信息。我们需要把这个对象转换为我们自定义的注释(使用 instanceOf()检查之后)，同时也可以调用自定义注释里面的方法。看看以下的实例代码，使用了上面的注解:

Class businessLogicClass = BusinessLogic.class;
for(Method method : businessLogicClass.getMethods()) {
  Todo todoAnnotation = (Todo)method.getAnnotation(Todo.class);
  if(todoAnnotation != null) {
    System.out.println(" Method Name : " + method.getName());
    System.out.println(" Author : " + todoAnnotation.author());
    System.out.println(" Priority : " + todoAnnotation.priority());
    System.out.println(" Status : " + todoAnnotation.status());
  }
}

四、annotation+spring mvc实现权限控制

参考：一种基于注解的Spring MVC权限控制方法

四、annotation+spring mvc实现登录验证

1、定义annotation：

/**
 * 登录访问控制
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginControl {
    // 是否需要验证
    Required required() default Required.YES;
    // 返回类型：Json / 重定向
    ResponseType responseType() default ResponseType.REDIRECT;
    // 登录验证类
    Class validatorClass() default UcenterDefaultLoginValidator.class;
    // 是否需要https登录
    Required needHttps() default Required.NO;
}

3、登录校验器：

/**
 * 登录校验器
 */
public interface LoginValidator {
    boolean validate(HttpServletRequest request);
}

/**
 * 登录校验逻辑
 */
public class QsurveyLoginValidator implements LoginValidator {

    @Override
    public boolean validate(HttpServletRequest request) {
        Preconditions.checkNotNull(request);

        HttpSession session = request.getSession();
        WebApplicationContext webApplicationContext = WebApplicationContextUtils
                .getWebApplicationContext(session.getServletContext());

        Preconditions.checkNotNull(webApplicationContext);

        UserService userService = (UserService) webApplicationContext.getBean("userService");

        Preconditions.checkNotNull(userService);

        User user = userService.getCurrenUser(UserUtils.getIdFromCookie(request));

        return !(rtxUser == null || Strings.isNullOrEmpty(rtxUser.getRtxId()));
    }
}

2、interceptor拦截：

/**
 * 登录检查拦截器
 * 

 * Created by fupan on 15-4-28.
 */
public class LoginInterceptor extends HandlerInterceptorAdapter {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoginInterceptor.class);

    /**
     * 全局是否需要https
     */
    private boolean isAllNeedHttps = false;

    /**
     * 全局是否需要登陆检查
     */
    private boolean isAllNeedLogin = false;

    /**
     * 跳转登陆的url
     */
    private String loginUrl = "https://xxxx.com/passport/login.jsp";

    private ResponseType defaultResponseType = ResponseType.REDIRECT;

    private Class defaultClass = UcenterDefaultLoginValidator.class;

    // 登录验证处理类缓存：防止反复创建大量对象
    private LoadingCache, LoginValidator> validatorCache = CacheBuilder.newBuilder()
            .build(new CacheLoader, LoginValidator>() {
                @Override
                public LoginValidator load(Class validatorClass) throws Exception {
                    Constructor[] constructors = validatorClass.getConstructors();
                    LoginValidator loginValidator = (LoginValidator) constructors[0].newInstance();
                    return loginValidator;
                }
            });

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 没有加登录验证的注解：放行
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        // 这个方法一般就是controller
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        // 获取注解在对象上的注解中的LoginControl
        LoginControl beanLoginControl = handlerMethod.getBeanType().getAnnotation(LoginControl.class);
        // 获取注解在方法上的注解中的LoginControl
        LoginControl methodLoginControl = handlerMethod.getMethod().getAnnotation(LoginControl.class);
        // 方法上的注解覆盖类上的（方法注解优先）
        LoginControl loginControl = methodLoginControl == null ? beanLoginControl : methodLoginControl;
        // 方法和类上都没有声明LoginControl,采用默认配置（isAllNeedLogin），如果未配置则不需要登录
        if (loginControl == null) {
            // 默认配置需要登录
            if (isAllNeedLogin) {
                // 校验是否登陆
                if (valid(request, defaultClass)) {
                    return true;
                }
            } else {
                // 未声明注解，并且默认配置为不需要登录：放行
                return true;
            }
        } else {
            // 声明不需要登录
            if (loginControl.required() == Required.NO) {
                return true;
            }
            // 验证通过
            if (valid(request, loginControl.validatorClass())) {
                return true;
            }
        }

        // 这以下是未通过验证的处理

        ResponseType responseType = (loginControl == null) ? defaultResponseType : loginControl.responseType();

        // 用户未登录，声明了返回值类型为ResponseType.JSON
        if (responseType == ResponseType.JSON) {
            ApiResponse apiResponse = ApiResponseUtils.buildErrorApiResponse(CommonErrMsgEnum.ERR_USER_NOT_LOGIN, null,
                    loginUrl);
            response.setContentType("application/json");
            response.setCharacterEncoding("UTF-8");
            response.getWriter().write(JsonUtil.toJson(apiResponse));
            response.flushBuffer();
            return false;
        }
        // 用户未登录，默认为跳转到登录页,ResponseType.REDIRECT
        else {
            
            // defaultUrl为StringUtils.EMPTY的原因是：判断returnUrl是否合法不应该在这处理，应该是登录时来判断
            String returnUrl = URLUtil.processReturnUrl(request.getRequestURL().toString(), StringUtils.EMPTY);
            if (loginControl == null ? isAllNeedHttps : loginControl.needHttps() == Required.YES) {
                returnUrl = URLUtil.urlToHttps(returnUrl);
            }
            if (StringUtils.isBlank(returnUrl)) {
                response.sendRedirect(loginUrl);
            } else {
                response.sendRedirect(loginUrl + "?ret=" + returnUrl);
            }
            return false;
        }
    }

    /**
     * 登录验证
     *
     * @param request
     * @param validatorClass
     * @return
     * @throws java.util.concurrent.ExecutionException
     */
    private boolean valid(HttpServletRequest request, Class validatorClass)
            throws java.util.concurrent.ExecutionException {
        // 从缓存中获取一个处理类
        LoginValidator loginValidator = validatorCache.get(validatorClass);
        if (loginValidator == null) {
            LOGGER.error("配置的validatorClass为空 {}", validatorClass.getSimpleName());
            throw new IllegalArgumentException("validatorClass null");
        }
        // 登录验证
        return loginValidator.validate(request);
    }

    public void setAllNeedHttps(boolean isAllNeedHttps) {
        this.isAllNeedHttps = isAllNeedHttps;
    }

    public void setAllNeedLogin(boolean isAllNeedLogin) {
        this.isAllNeedLogin = isAllNeedLogin;
    }

    public void setLoginUrl(String loginUrl) {
        this.loginUrl = loginUrl;
    }

    public void setDefaultClass(Class defaultClass) {
        this.defaultClass = defaultClass;
    }

    public void setDefaultResponseType(ResponseType defaultResponseType) {
        this.defaultResponseType = defaultResponseType;
    }
}

3、拦截器配置

4、在需要登录验证的地方添加注解

（1）加在controller类上

@Controller
@LoginControl(validatorClass = QsurveyLoginValidator.class)
public class UserSurveyController {
    private static final Logger logger = LoggerFactory.getLogger(UserSurveyController.class);
    ... 

（2）加在controller方法上

@RequestMapping(value = "/")
@LoginControl(validatorClass = QsurveyLoginValidator.class)
@CommonPropertiesControl
public ModelAndView home(HttpServletRequest request) {
    ModelAndView modelAndView = new ModelAndView("index");
    ...