/**
 * Indicates that a method declaration is intended to override a
 * method declaration in a supertype. If a method is annotated with
 * this annotation type compilers are required to generate an error
 * message unless at least one of the following conditions hold:
 * The method does override or implement a method declared in a
 * supertype.
 * The method has a signature that is override-equivalent to that of
 * any public method declared in Object.
 *
 * @author Peter von der Ahé
 * @author Joshua Bloch
 * @jls 9.6.1.4 @Override
 * @since 1.5
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

/**
 * Indicates how long annotations with the annotated type are to
 * be retained. If no Retention annotation is present on
 * an annotation type declaration, the retention policy defaults to
 * RetentionPolicy.CLASS.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
  /**
   * Returns the retention policy.
   * @return the retention policy
   */
  RetentionPolicy value();
}

public enum RetentionPolicy {
  /**
   * Annotations are to be discarded by the compiler.
   */
  SOURCE,
  /**
   * Annotations are to be recorded in the class file by the compiler
   * but need not be retained by the VM at run time. This is the default
   * behavior.
   */
  CLASS,
  /**
   * Annotations are to be recorded in the class file by the compiler and
   * retained by the VM at run time, so they may be read reflectively.
   *
   * @see java.lang.reflect.AnnotatedElement
   */
  RUNTIME
}

package java.lang.annotation;
/**
 * Indicates the contexts in which an annotation type is applicable. The
 * declaration contexts and type contexts in which an annotation type may be
 * applicable are specified in JLS 9.6.4.1, and denoted in source code by enum
 * constants of java.lang.annotation.ElementType
 * @since 1.5
 * @jls 9.6.4.1 @Target
 * @jls 9.7.4 Where Annotations May Appear
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
 /**
   * Returns an array of the kinds of elements an annotation type
   * can be applied to.
   * @return an array of the kinds of elements an annotation type
   * can be applied to
   */
 ElementType[] value();
}

public enum ElementType {
  /** Class, interface (including annotation type), or enum declaration */
  TYPE,
  /** Field declaration (includes enum constants) */
  FIELD,
  /** Method declaration */
  METHOD,
  /** Formal parameter declaration */
  PARAMETER,
  /** Constructor declaration */
  CONSTRUCTOR,
  /** Local variable declaration */
  LOCAL_VARIABLE,
  /** Annotation type declaration */
  ANNOTATION_TYPE,
  /** Package declaration */
  PACKAGE,
  /**
   * Type parameter declaration
   * @since 1.8
   */
  TYPE_PARAMETER,
  /**
   * Use of a type
   * @since 1.8
   */
  TYPE_USE
}

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

/**
 * Indicates that annotations with a type are to be documented by javadoc
 * and similar tools by default. This type should be used to annotate the
 * declarations of types whose annotations affect the use of annotated
 * elements by their clients. If a type declaration is annotated with
 * Documented, its annotations become part of the public API
 * of the annotated elements.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

/**
 * 不需要登录注解
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NoLogin {
}

/**
 * 检查登录拦截器
 * 如不需要检查登录可在方法或者controller上加上@NoLogin
 */
public class CheckLoginInterceptor implements HandlerInterceptor {
 private static final Logger logger = Logger.getLogger(CheckLoginInterceptor.class);
 @Override
   public Boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                Object handler) throws Exception {
  if (!(handler instanceof HandlerMethod)) {
   logger.warn("当前操作handler不为HandlerMethod=" + handler.getClass().getName() + ",req="
               + request.getQueryString());
   return true;
  }
  HandlerMethod handlerMethod = (HandlerMethod) handler;
  String methodName = handlerMethod.getMethod().getName();
  // 判断是否需要检查登录
  NoLogin noLogin = handlerMethod.getMethod().getAnnotation(NoLogin.class);
  if (null != noLogin) {
   if (logger.isDebugEnabled()) {
    logger.debug("当前操作methodName=" + methodName + "不需要检查登录情况");
   }
   return true;
  }
  noLogin = handlerMethod.getMethod().getDeclaringClass().getAnnotation(NoLogin.class);
  if (null != noLogin) {
   if (logger.isDebugEnabled()) {
    logger.debug("当前操作methodName=" + methodName + "不需要检查登录情况");
   }
   return true;
  }
  if (null == request.getSession().getAttribute(CommonConstants.SESSION_KEY_USER)) {
   logger.warn("当前操作" + methodName + "用户未登录,ip=" + request.getRemoteAddr());
   response.getWriter().write(JsonConvertor.convertFailResult(ErrorCodeEnum.NOT_LOGIN).toString());
   // 返回错误信息
   return false;
  }
  return true;
 }
 @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response,
               Object handler, ModelAndView modelAndView) throws Exception {
 }
 @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                 Object handler, Exception ex) throws Exception {
 }
}

@Controller
@RequestMapping("/user")
public class HelloController {
  @Autowired
  @Qualifier("userService")
  private UserService userService;

public interface BeanPostProcessor {
  Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
  Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}