Python 很重要的一个概念 module，用来组织代码结构。

import 导入搜索的路径

• 代码的 home 路径
• PYTHONPATH 目录（如果存在的话）
• 标准库路径
• .pth 文件中配置的路径（如果存在的话）

最终，这些路径都会存在 sys.path 中，是一个保存着一系列搜索路径的 list。

>>> import sys
>>> sys.path

导入工作流程

• 在路径中找到导入的模块
• 编译
• 运行

Package

一个目录的 Python code 被称为 package，这样的导入被成为 package import。

import dir1.dir2.mod
from dir1.dir2.mod import x

文件目录结构可能是

dir0\dir1\dir2\mod.py

每一个 package 被定义时都会产生一个 __init__.py 的文件，该文件可以像普通文件一样包含 Python 代码，也可以为空。

Package 初始化

当 Python 导入 Package 时，会自动跑 `__init__.py` 下的内容，所以 `__init__.py` 文件下是天然的存放初始化内容的地方，比如初始化数据库连接等等。

如果定义了 __all__ ，在 from * 时导入，就会选择性导入指定内容

__all__ = ["Error", "encode", "decode"]

从 WizNote 中整理。

POJO, Plain Old java object, 最简单的 Java 对象

DI 带来的最大好处，松耦合，如果一个对象只通过接口（而不是具体实现或初始化过程）来表明依赖关系，那么这种依赖就能够在对象本身毫不知情的情况下，用不同的具体实现进行替换。

AOP aspect-oriented programming, 面向切面编程允许将遍布应用各处的功能分离出来形成可重用的组件

依赖注入让互相协作的软件组件保持松散耦合，而 AOP 则是让遍布各处的功能分离出来形成可重用的组件。

体系结构

Spring 框架提供约 20 个模块。

核心容器

由核心，Bean，上下文，表达式语言模块

• 核心模块提供框架基本组成部分，包括 IoC （控制反转） 和 依赖注入 DI
• Bean 模块提供 BeanFactory，是一个工厂模式的复杂实现
• 上下文，在核心和 Bean 模块基础上，访问定义和配置的任何对象的媒介，ApplicationContext 接口是上下文模块的重点
• 表达式语言模块在运行时提供查询和操作一个对象图的表达式

数据访问 / 集成

数据访问 / 集成层包括 JDBC，ORM，OXM，JMS 和事务处理模块

Web

Web 层由 Web，Web-MVC，Web-Socket 和 Web-Portlet 组成

其他

还有其他一些重要的模块，像 AOP，Aspects，Instrumentation，Web 和测试模块

1. DispatcherServlet

　　DispatcherServlet 是前置控制器，配置在 web.xml 文件中的。拦截匹配的请求，Servlet 拦截匹配规则要自已定义，把拦截下来的请求，依据相应的规则分发到目标 Controller 来处理，是配置 spring MVC 的第一步。

1. InternalResourceViewResolver

　　视图名称解析器

常用注解

@Controller 负责注册一个 bean 到 spring 上下文中，类名前加此注解，告知 Spring 容器这是一个控制器组件，负责注册一个 bean 到 spring 上下文中

Controller 注解示例

@Controller
@RequestMapping("/mvc")
public class mvcController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

@Controller
@RequestMapping("/rest")
public class RestController {
    @RequestMapping(value="/user/{id}",method=RequestMethod.GET)
    public String get(@PathVariable("id") Integer id){
        System.out.println("get"+id);
        return "/hello";
    }

    @RequestMapping(value="/user/{id}",method=RequestMethod.POST)
    public String post(@PathVariable("id") Integer id){
        System.out.println("post"+id);
        return "/hello";
    }

    @RequestMapping(value="/user/{id}",method=RequestMethod.PUT)
    public String put(@PathVariable("id") Integer id){
        System.out.println("put"+id);
        return "/hello";
    }

    @RequestMapping(value="/user/{id}",method=RequestMethod.DELETE)
    public String delete(@PathVariable("id") Integer id){
        System.out.println("delete"+id);
        return "/hello";
    }
}

@RequestMapping 类方法前加，注解为控制器指定可以处理哪些 URL 请求

@RequestMapping(value = "/register", method = RequestMethod.POST)

三个常用属性：value，params，method

value 必填属性，代表请求的 url，支持模糊配置。(value 字可以省略，但是属性值必须填）

@RequestMapping(value="/users/**")   匹配"/users/abc/abc"；
@RequestMapping(value="/product?")   匹配"/product1"或"/producta"，但不匹配"/product"或"/productaa"；
@RequestMapping(value="/product*")   匹配“/productabc”或“/product”，但不匹配“/productabc/abc”；
@RequestMapping(value="/product/*")   匹配“/product/abc”，但不匹配“/productabc”；

params 可选属性，代表对请求参数进行过滤

@RequestMapping(value="/login.do",params="flag")   代表请求中必须要有名为 flag 的提交项
@RequestMapping(value="/login.do",params="!flag")  代表请求中不能有名为 flag 的提交项
@RequestMapping(value="/login.do",params="flag=hello") 代表请求中必须有名为 flag 的提交项，且值为 hello
@RequestMapping(value="/login.do",params="flag!=hello") 代表请求中如果有名为 flag 的提交项，其值不能为 hello
@RequestMapping(value="/login.do",params={"flag1","flag2=hello"}) 代表请求中必须有名为 flag1 的提交项，同时必须有名为 flag2 的提交项，且 flag2 的值必须为 hello

method 可选属性，代表请求方式

@RequestMapping(value="/login.do",method=RequestMethod.POST)
@RequestMapping(value="/login.do",method=RequestMethod.GET)
@RequestMapping(value="/login.do", method= {RequestMethod.POST, RequestMethod.GET}"

@RequestBody 该注解用于读取 Request 请求的 body 部分数据，使用系统默认配置的 HttpMessageConverter 进行解析，然后把相应的数据绑定到要返回的对象上 , 再把 HttpMessageConverter 返回的对象数据绑定到 Controller 中方法的参数上

@ResponseBody 该注解用于将 Controller 的方法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式后，写入到 Response 对象的 body 数据区

@ModelAttribute 在方法定义上使用 @ModelAttribute 注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了 @ModelAttribute 的方法

在方法的入参前使用 @ModelAttribute 注解：可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数 –绑定到对象中，再传入入参将方法入参对象添加到模型中

@RequestParam　在处理方法入参处使用 @RequestParam 可以把请求参数传递给请求方法

@RequestMapping(value = "/check", method = RequestMethod.GET)
public
@ResponseBody
String check(@RequestParam(value = "signature", required = true, defaultValue = "") String signature,
             @RequestParam(value = "timestamp", required = true, defaultValue = "") String timestamp,
             @RequestParam(value = "nonce", required = true, defaultValue = "") String nonce,
             @RequestParam(value = "echostr", required = true, defaultValue = "") String echostr,
             HttpServletRequest request,
             HttpServletResponse response
) {
    response.addHeader("Access-Control-Allow-Origin", "*");
    response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");

    if (checkSignature(signature, timestamp, nonce)) {
        return echostr;
    }
    return "";
}

@PathVariable

　　绑定 URL 占位符到参数

@ExceptionHandler

　　注解到方法上，出现异常时会执行该方法

@ControllerAdvice

使 Contoller 成为全局的异常处理类，类中用 @ExceptionHandler 方法注解的方法可以处理所有 Controller 中发生的异常

@ControllerAdvice
public class GlobalExceptionHandler {
    private static Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public void exceptionHandler(HttpServletRequest req, Exception e) throws Exception {
        //todo add request info to log
        logger.error("error: {}", e);
        return;
    }

}

自动装配主要使用 @ComponentScan、@Component 和 @Autowired。

• @ComponentScan：作用在配置类上，启用组件扫描。扫描并注册标注了 @Component（@Controller\@Service\@Repository）的类型。@Configuration 已经应用了 @Component 注解。
• @Autowired：按类型自动装配。@Autowired 和使用 @Inject（JSR-330）或 @Resource（JSR-250）的效果是类似的。@Autowired 和 @Inject 默认按类型注入，@Resource 默认按名称注入。

@Autowired

@Resource

参数绑定注解

• A、处理 requet uri 部分（这里指 uri template 中 variable，不含 queryString 部分）的注解： @PathVariable;
• B、处理 request header 部分的注解： @RequestHeader, @CookieValue;
• C、处理 request body 部分的注解：@RequestParam, @RequestBody;
• D、处理 attribute 类型是注解： @SessionAttributes, @ModelAttribute;

@PathVariable

当使用 @RequestMapping URI template 样式映射时， 即 someUrl/{paramId}, 这时的 paramId 可通过 @Pathvariable 注解绑定它传过来的值到方法的参数上。

示例代码：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

	@RequestMapping("/pets/{petId}")
	public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
	// implementation omitted
	}
}

上面代码把 URI template 中变量 ownerId 的值和 petId 的值，绑定到方法的参数上。若方法参数名称和需要绑定的 uri template 中变量名称不一致，需要在 @PathVariable(“name”) 指定 uri template 中的名称。

@RequestHeader、@CookieValue

@RequestHeader 注解，可以把 Request 请求 header 部分的值绑定到方法的参数上。

示例代码：

这是一个 Request 的 header 部分：

Host
localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300


@RequestMapping("/displayHeaderInfo.do")
public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,                                @RequestHeader("Keep-Alive") long keepAlive)  {
	//...
}

上面的代码，把 request header 部分的 Accept-Encoding 的值，绑定到参数 encoding 上了， Keep-Alive header 的值绑定到参数 keepAlive 上。

@CookieValue 可以把 Request header 中关于 cookie 的值绑定到方法的参数上。

例如有如下 Cookie 值：

[java] view plain copy

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84 参数绑定的代码：

[java] view plain copy

@RequestMapping(“/displayHeaderInfo.do”) public void displayHeaderInfo(@CookieValue(“JSESSIONID”) String cookie) { //… } 即把 JSESSIONID 的值绑定到参数 cookie 上。

@RequestParam, @RequestBody

@RequestParam

A） 常用来处理简单类型的绑定，通过 Request.getParameter() 获取的 String 可直接转换为简单类型的情况（ String–> 简单类型的转换操作由 ConversionService 配置的转换器来完成）；因为使用 request.getParameter() 方式获取参数，所以可以处理 get 方式中 queryString 的值，也可以处理 post 方式中 body data 的值；

B）用来处理 Content-Type: 为 application/x-www-form-urlencoded 编码的内容，提交方式 GET、POST；

C) 该注解有两个属性： value、required； value 用来指定要传入值的 id 名称，required 用来指示参数是否必须绑定；

示例代码：

@Controller @RequestMapping(“/pets”) @SessionAttributes(“pet”) public class EditPetForm { // … @RequestMapping(method = RequestMethod.GET) public String setupForm(@RequestParam(“petId”) int petId, ModelMap model) { Pet pet = this.clinic.loadPet(petId); model.addAttribute(“pet”, pet); return “petForm”; } // …

@RequestBody

该注解常用来处理 Content-Type: 不是 application/x-www-form-urlencoded 编码的内容，例如 application/json, application/xml 等；

它是通过使用 HandlerAdapter 配置的 HttpMessageConverters 来解析 post data body，然后绑定到相应的 bean 上的。

因为配置有 FormHttpMessageConverter，所以也可以用来处理 application/x-www-form-urlencoded 的内容，处理完的结果放在一个 MultiValueMap<String, String>里，这种情况在某些特殊需求下使用，详情查看 FormHttpMessageConverter api;

示例代码：

[java] view plain copy

@RequestMapping(value = “/something”, method = RequestMethod.PUT) public void handle(@RequestBody String body, Writer writer) throws IOException { writer.write(body); }

4、@SessionAttributes, @ModelAttribute

@SessionAttributes:

该注解用来绑定 HttpSession 中的 attribute 对象的值，便于在方法中的参数里使用。

该注解有 value、types 两个属性，可以通过名字和类型指定要使用的 attribute 对象；

示例代码：

[java] view plain copy

@Controller @RequestMapping(“/editPet.do”) @SessionAttributes(“pet”) public class EditPetForm { // … }

@ModelAttribute

该注解有两个用法，一个是用于方法上，一个是用于参数上；

用于方法上时： 通常用来在处理 @RequestMapping 之前，为请求绑定需要从后台查询的 model；

用于参数上时： 用来通过名称对应，把相应名称的值绑定到注解的参数 bean 上；要绑定的值来源于：

A） @SessionAttributes 启用的 attribute 对象上；

B） @ModelAttribute 用于方法上时指定的 model 对象；

C） 上述两种情况都没有时，new 一个需要绑定的 bean 对象，然后把 request 中按名称对应的方式把值绑定到 bean 中。

用到方法上 @ModelAttribute 的示例代码：

// Add one attribute // The return value of the method is added to the model under the name “account” // You can customize the name via @ModelAttribute(“myAccount”) @ModelAttribute public Account addAccount(@RequestParam String number) { return accountManager.findAccount(number); } 这种方式实际的效果就是在调用 @RequestMapping 的方法之前，为 request 对象的 model 里 put（“account”， Account）；

用在参数上的 @ModelAttribute 示例代码：

@RequestMapping(value=”/owners/{ownerId}/pets/{petId}/edit”, method = RequestMethod.POST) public String processSubmit(@ModelAttribute Pet pet) { } 首先查询 @SessionAttributes 有无绑定的 Pet 对象，若没有则查询 @ModelAttribute 方法层面上是否绑定了 Pet 对象，若没有则将 URI template 中的值按对应的名称绑定到 Pet 对象的各属性上。

补充讲解：

问题： 在不给定注解的情况下，参数是怎样绑定的？

通过分析 AnnotationMethodHandlerAdapter 和 RequestMappingHandlerAdapter 的源代码发现，方法的参数在不给定参数的情况下：

若要绑定的对象时简单类型： 调用 @RequestParam 来处理的。

若要绑定的对象时复杂类型： 调用 @ModelAttribute 来处理的。

这里的简单类型指 Java 的原始类型 (boolean, int 等）、原始类型对象（Boolean, Int 等）、String、Date 等 ConversionService 里可以直接 String 转换成目标对象的类型；

下面贴出 AnnotationMethodHandlerAdapter 中绑定参数的部分源代码：

[java] view plain copy

RequestMappingHandlerAdapter 中使用的参数绑定，代码稍微有些不同，有兴趣的同仁可以分析下，最后处理的结果都是一样的。

示例：

@RequestMapping ({“/”, “/home”}) public String showHomePage(String key){ logger.debug(“key=”+key); return “home”; } 这种情况下，就调用默认的 @RequestParam 来处理。

[java] view plain copy

@RequestMapping (method = RequestMethod.POST) public String doRegister(User user){ if(logger.isDebugEnabled()){ logger.debug(“process url[/user], method[post] in “+getClass()); logger.debug(user); } return “user”; } 这种情况下，就调用 @ModelAttribute 来处理。

参考文档：

1、 spring Web Doc：

spring-3.1.0/docs/spring-framework-reference/html/mvc.html

一般的注解，比如常见的 @Override 是 Java 从 1.5 版本开始引入，注解一般用来对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等等进行注解，他的作用一般分为如下四个方面：

1. 生成文档
2. 编译检查，通过注解让编译器在编译期间进行检查校验
3. 编译时动态处理，编译时通过注解标示进行动态处理，比如生成代码
4. 运行时动态处理，反射注入实例等等

一般的注解可以分为三类：

1. Java 自带的注解，包括 @Override @Deprecated 等等
2. 元注解，用于定义注解，包括 @Retention @Target @Inherited @Documented @Retention 用于标明注解被保留的阶段，@Target 用于标明注解使用的范围，@Inherited 用于标明注解可继承，@Documented 用于标明是否生成 javadoc 文档
3. 自定义注解，根据需求使用元注解自定义注解

Spring 中的注解

Spring 中的注解大概可以分为两大类：

• Spring 的 bean 容器相关的注解，或者说 bean 工厂相关的注解
• Springmvc 相关的注解

Spring 的 bean 容器相关的注解，先后有：@Required， @Autowired, @PostConstruct, @PreDestory，还有 Spring3.0 开始支持的 JSR-330 标准 javax.inject.*中的注解 (@Inject, @Named, @Qualifier, @Provider, @Scope, @Singleton).

Spring mvc 相关的注解有：@Controller, @RequestMapping, @RequestParam， @ResponseBody 等等。

要理解 Spring 中的注解，先要理解 Java 中的注解。

Java 中的注解

Java 中 1.5 中开始引入注解，最熟悉的应该是：@Override, 它的定义如下：

/**
 * 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 {
}

从注释，我们可以看出，@Override 的作用是，提示编译器，使用了 @Override 注解的方法必须 override 父类或者 java.lang.Object 中的一个同名方法。我们看到 @Override 的定义中使用到了 @Target, @Retention，它们就是所谓的“元注解”——就是定义注解的注解，或者说注解注解的注解。我们看下 @Retention

/**
 * 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();
}

@Retention 用于提示注解被保留多长时间，有三种取值：

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
}

RetentionPolicy.SOURCE 保留在源码级别，被编译器抛弃 (@Override 就是此类）； RetentionPolicy.CLASS 被编译器保留在编译后的类文件级别，但是被虚拟机丢弃； RetentionPolicy.RUNTIME 保留至运行时，可以被反射读取。

再看 @Target:

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();
}

@Target 用于提示该注解使用的地方，取值有：

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
}

分别表示该注解可以被使用的地方：1)TYPE 用于类，接口（包括注解），enum 定义；2) FIELD 属性域；3）METHOD 方法；4）PARAMETER 参数；5）CONSTRUCTOR 构造函数；6）LOCAL_VARIABLE 局部变量；7）ANNOTATION_TYPE 注解类型；8）PACKAGE 包

所以：

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

表示 @Override 只能使用在方法上，保留在源码级别，被编译器处理，然后抛弃掉。

还有一个经常使用的元注解 @Documented ：

/**
 * 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 {
}

表示注解是否能被 javadoc 处理并保留在文档中。

使用 元注解 来自定义注解 和 处理自定义注解

有了元注解，那么我就可以使用它来自定义我们需要的注解。结合自定义注解和 AOP 或者过滤器，是一种十分强大的武器。比如可以使用注解来实现权限的细粒度的控制——在类或者方法上使用权限注解，然后在 AOP 或者过滤器中进行拦截处理。下面是一个关于登录的权限的注解的实现：

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

我们自定义了一个注解 @NoLogin, 可以被用于 方法 和 类 上，注解一直保留到运行期，可以被反射读取到。该注解的含义是：被 @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 {
	}
}

上面我们定义了一个登录拦截器，首先使用反射来判断方法上是否被 @NoLogin 注解：

NoLogin noLogin = handlerMethod.getMethod().getAnnotation(NoLogin.class);

然后判断类是否被 @NoLogin 注解：

noLogin = handlerMethod.getMethod().getDeclaringClass().getAnnotation(NoLogin.class);

如果被注解了，就返回 true，如果没有被注解，就判断是否已经登录，没有登录则返回错误信息给前台和 false. 这是一个简单的使用 注解 和 过滤器 来进行权限处理的例子。扩展开来，那么我们就可以使用注解，来表示某方法或者类，只能被具有某种角色，或者具有某种权限的用户所访问，然后在过滤器中进行判断处理。

Spring 的 bean 容器相关的注解

• @Autowired 是我们使用得最多的注解，其实就是 autowire=byType 就是根据类型的自动注入依赖（基于注解的依赖注入），可以被使用再属性域，方法，构造函数上。

• @Qualifier 就是 autowire=byName, @Autowired 注解判断多个 bean 类型相同时，就需要使用 @Qualifier(“xxBean”) 来指定依赖的 bean 的 id：

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

• @Resource 属于 JSR250 标准，用于属性域和方法上。也是 byName 类型的依赖注入。使用方式：@Resource(name=”xxBean”). 不带参数的 @Resource 默认值类名首字母小写。关于 Autowired 和 @Resouece 的区别可以参考这篇

• JSR-330 标准 javax.inject.* 中的注解 (@Inject, @Named, @Qualifier, @Provider, @Scope, @Singleton)。@Inject 就相当于 @Autowired, @Named 就相当于 @Qualifier, 另外 @Named 用在类上还有 @Component 的功能。

• @Component， @Controller, @Service, @Repository, 这几个注解不同于上面的注解，上面的注解都是将被依赖的 bean 注入进入，而这几个注解的作用都是生产 bean, 这些注解都是注解在类上，将类注解成 Spring 的 bean 工厂中一个一个的 bean。@Controller, @Service, @Repository 基本就是语义更加细化的 @Component。关于这几个注解可以参考这篇『文章』()

• @PostConstruct 和 @PreDestroy 不是用于依赖注入，而是 bean 的生命周期。类似于 init-method(InitializeingBean) destory-method(DisposableBean)

Spring 中注解的处理

Spring 中注解的处理基本都是通过实现接口 BeanPostProcessor 来进行的：

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

相关的处理类有： AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor， RequiredAnnotationBeanPostProcessor

这些处理类，可以通过 <context:annotation-config/> 配置隐式的配置进 Spring 容器。这些都是依赖注入的处理，还有生产 bean 的注解 (@Component， @Controller, @Service, @Repository) 的处理：

<context:component-scan base-package="net.aazj.service,net.aazj.aop" />

这些都是通过指定扫描的基包路径来进行的，将他们扫描进 Spring 的 bean 容器。注意 context:component-scan 也会默认将 AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor 配置进来。所以是可以省略的。另外 context:component-scan 也可以扫描 @Aspect 风格的 AOP 注解，但是需要在配置文件中加入 进行配合。

Spring 注解和 JSR-330 标准注解的区别：

注解的原理

注解被编译后本质上就是一个继承 Annotation 接口的接口

reference

• http://www.cnblogs.com/digdeep/p/4525567.html
• http://blog.csdn.net/wangyangzhizhou/article/details/51698638
• http://www.techferry.com/articles/spring-annotations.html

类型

Numbers

可以表示整形，浮点数，分数等等，甚至可以用来表示非常大的数，比如 2 ** 10000

不同进制表示

0x1234 0X1234               # 16 进制 0x 后接 [0-9A-F]
0o177 0O177                 # 8 进制  0o Zero 加大小写的 o 后接 [0-7]
0b101 0B101                 # 2 进制 New in 2.6 > ，后接 [0-1]

内置的 hex(number) ， oct(number) ， bin(number) 将 int 转变为这三种进制的字符串。

Strings

字符串在 Python 中支持切片的操作，比如 S = 'Spam'，这时 S[-1] 表示的是最后一个字符 m。

S[1:3]          # 'pa'  左边包括，右边不包括
S[1:]           # 'pam' [1:len(S)]
S[:3]           # 'Spa' 等效于 [0:3]
S[:-1]          # 除去最后一个元素
S[:]            # S 全部

字符串重复操作可以使用 S * 10 打印 10 遍 S.

字符串和 Java 一样是不可变对象，Numbers 和 Tuples 也是不可变的。

字符串常用函数

常用操作

S.find('pa')        # 输出字串位置 1
S.replace('pa', 'xy')   # 替换 pa 为 xy 输出到新的字符串，不改变原始字符串

line = 'hello world'
line.split(' ')     # 空格分割，输出列表
line.upper()        # 转为大写
line.isdigit()      # 判断是否为数字，还有 isalpha() isnumeric() isspace() 等等
line.rstrip()       # 移除行尾空白字符比如 `\n`

格式化字符串

'%s, eggs, and %s' % ('spam', 'SPAM!')     # Python 格式化表达式
# or
'%s, eggs, and %s' % ('spam', 'SPAM!')     # Python 2.6 and 3.0

对于任何一个对象，都可以调用内置方法 dir(S) 来查看相关属性和方法。dir 方法可以用来快速查看对象的可调用方法，所以记不住方法的名字也不需要担心，使用 dir() 方法即可。

对于任何方法的使用，可以用 help(S.replace) 查看。

正则

说到字符串处理就不可避免的要谈到正则

>>> import re
>>> match = re.match('Hello[ \t]*(.*)world', 'Hello
>>> match.group(1)
'Python '

>>> match = re.match('/(.*)/(.*)/(.*)', '/usr/home/einverne')
>>> match.groups()
('usr', 'home', 'einverne')

Lists

基本操作，可 Strings 类似也都支持切片，下标索引等等

L = [123, 'spam', 1.23]
L[0]
L[:-1]
L + [4,5,6]

Lists 不同于其他熟悉的语言，可以承载不同的类型，比如上面的例子，L 中就有三种完全不同的类型，Lists 没有特定的大小，可以根据需求调整长度。

L.append('NI')          # 添加
L.pop(2)                # 删除 index 为 2 的元素，并返回
L.insert(1, 'xyz')      # 在 index 之前插入 'xyz'
L.remove('xyz')         # 按照值移除第一个找到的 item

另外 list 的 sort() 和 reverse() 方法分别为 list 排序，逆序，直接改动 list 自身。

Nesting

循环嵌套，比如表示 3 × 3 矩阵

>>> M = [[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

在获取值的时候可以

>>> M[1]     # 获取第二行
>>> M[1][2]  # 获取第二行第三列

可以使用 List comprehensions 来获取列

>>> col2 = [row[1] for row in M]   # 获取第二列

这句话表达的意思就是，将矩阵 M 中每一行的 row[1] 第二个元素放到一个新的 list 中返回。这个表达式甚至可以更加复杂，比如在返回时每个元素乘以二。

>>> [row[1] * 2 for row in M]

或者加入判断，只有偶数才返回

>>> [row[1] for row in M if row[1] % 2 == 0]

List comprehensions 可以用在任何可以迭代的对象上，比如返回 M 矩阵对角线元素

>>> diag = [M[i][i] for i in range(3)]
>>> [c * 2 for c in 'spam']  # 输出一个列表 ['ss', 'pp', 'aa', 'mm']

在 Python 3.0 及以上，comprehension 语法也可以用来创建 set 或者 dict

{sum(row) for row in M}       # {sum(row) for row in M} 创建一个每一行和的 set
{i : sum(M[i]) for i in range(3)}    # {0: 6, 1: 15, 2: 24} dict

Dictionaries

基本操作

D = {}
D['name'] = 'bob'

dict 也同样支持嵌套，value 值可以为不同类型。

>>> rec = {'name': {'first': 'Bob', 'last': 'Smith'},
'job': ['dev', 'mgr'],
'age': 40.5}

构造这样一个复杂结构的 dict 在 Python 中非常轻松，但是如果在 C 中将会需要非常多的 coding。在一个 lower-level 的语言中我们需要非常小心释放变量内存空间，但是在 Python 中当丢失对象的引用时，内存空间会自动被释放。

>>> rec = 0

Python 也有自己的垃圾回收机制，在 Python 中当对象的最后一个引用丢失时，空间会立即被回收。

使用 in 来检查 key 是否在 dict 中

if 'f' in D:
    print D['f']

或者在 Python 3 可以使用 get() 方法，来避免获取一个不存在的 key 可能引发的错误

D.get('f', 0)           # 如果 f 存在返回 D['f']，否则返回 0，等效于
D['f'] if 'f' in D else 0

Tuples

元组，像 lists 一样的序列，但是像 string 一样不可变。支持任意的类型，任意的嵌套，和序列一样。

T = (1, 2, 3, 4)
T = ('spam', 3.0, [11, 22, 33])

Files

文件类型是 Python 用来和外部文件访问的重要接口。使用内置的 open() 函数来创建文件对象。

f = open('data.txt', 'w')
f.write('Hello\n')
f.close()

f = open('data.txt')          # 'r' 可以省略
text = f.read()
f.close()

在 Python 3 中区分了 text 和 binary data，Text files 代表字符串内容并且以 Unicode 形式可以 encode 和 decode。而 binary files 代表特殊的 bytes 并且允许用户直接访问无修改的文件内容。

Other Core Types

集合

X = set('spam')
Y = {'h', 'a', 'm'}

X & Y   # 交集
X | Y   # 并集
X - Y   # 差集

Decimal

import deciaml
d = decimal.Decimal('3.141')

>>> decimal.getcontext().prec = 2
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.33')

>>> from fractions import Fraction
>>> f = Fraction(2, 3)
>>> f + 1
Fraction(5, 3)
>>> f + Fraction(1, 2)
Fraction(7, 6)

Type check

if type(L) == type([]):
    print('yes')

if type(L) == list:
    print('yes')

if isinstance(L, list):
    print('yes')

不过需要记住，代码少用这些类型检查。

In Python, we code to object interfaces (operations supported), not to types.

Python 中所有的一切都是 Object，所以上面提到的所有类型都是 Object。

https://www.google.com/foobar/?eid=sfeTWdGPBIac8QXcxpXgAQ&usg=AG3vBD082_C21k4vEcaG4KspC-1eGqU7KA

Minion Labor Shifts
===================

Commander Lambda's minions are upset! They're given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it'll prove your chops to Commander Lambda so you can get promoted!

Minions' tasks are assigned by putting their ID numbers into a list, one time for each day they'll work that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they'll complain about it until they're taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task.  You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.

Write a function called answer(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don't want to mix up those carefully-planned shift rotations! For instance, if data was [5, 10, 15, 10, 7] and n was 1, answer(data, n) would return the list [5, 15, 7] because 10 occurs twice, and thus was removed from the list entirely.

Languages
=========

To provide a Python solution, edit solution.py
To provide a Java solution, edit solution.java

Test cases
==========

Inputs:
	(int list) data = [1, 2, 3]
	(int) n = 0
Output:
	(int list) []

Inputs:
	(int list) data = [1, 2, 2, 3, 3, 3, 4, 5, 5]
	(int) n = 1
Output:
	(int list) [1, 4]

Inputs:
	(int list) data = [1, 2, 3]
	(int) n = 6
Output:
	(int list) [1, 2, 3]

Use verify [file] to test your solution and see how it does. When you are finished editing your code, use submit [file] to submit your answer. If your solution passes the test cases, it will be removed from your home folder.

为了实现依赖注入 DI 而引入，Java 提供 javax.annotation.Resource , javax.inject.Inject 注解，Spring 框架提供了 org.springframework.beans.factory.annotation.Autowired 。依赖注入（Denpendency Injection，DI）， 控制反转（Inversion of Control, IoC），主要的目的是去除代码耦合。具体可参考其他资料。

使用

Spring 注入的方式有多种，可以写在 field 上，可以写在 setter 方法上，可以写在 constructor 上。

@Autowired
private UserDao userDao;

// constructor
@Autowired
public UserService(UserDao userDao) {
	this.userDao = userDao;
}


@Resource
private UserDao userDao;

配置

<context:annotation-config/>

or

<context:component-scan base-package="需要自动扫描的包" />

具体解释

@Autowired: Spring 特有的注解，@Autowired 通过类型来注入，比如通过类的类型，或者类的接口来注解 field 或者 constractor。为了防止在项目中实现同一个接口，或者一系列子类，可以使用 @Qualifier 注解来避免歧义。默认情况下 bean 的名字就是 qualifier 的值。 尽管你可以按照约定通过名字来使用 @Autowired 注解，@Autowired 根本上还是类型驱动的注入，并且附带可选的语义上的 qualifiers.

@Inject: 该注解基于 JSR-330, @Inject 注解是 Spring @Autowired 注解的代替品。所以使用 Spring 独有的 @Autowired 注解时，可以考虑选择使用 @Inject. @Autowired 和 @Inject 的不同之处在于是否有 required 属性，@Inject 没有 required 属性，因此在找不到合适的依赖对象时 inject 会失败，而 @Autowired 可以使用 required=false 来允许 null 注入。

使用 @Inject 需要添加如下依赖：

<dependency>
	<groupId>javax.inject</groupId>
	<artifactId>javax.inject</artifactId>
	<version>1</version>
</dependency>

Advantage of @Inject annotation is that rather than inject a reference directly, you could ask @Inject to inject a Provider. The Provider interface enables, among other things, lazy injection of bean references and injection of multiple instances of a bean. In case we have few implementation of an interface or a subclass we can narrow down the selection using the @Named annotation to avoid ambiguity. @Named annotation works much like Spring’s @Qualifier

@Resource: JDK 1.6 支持注解，JSR-250 引入。@Resource 和 @Autowired @Inject 类似，最主要的区别在于寻找存在的 Bean 注入的路径不同。@Resource 寻找的优先顺序为

• 1) 优先通过名字 (by name)
• 2）其次是类型 (by type)
• 3）再次是 qualifier(by qualifier)

而 @Autowired and @Inject 寻找的顺序为

• 1) 通过类型寻找
• 2）通过 qualifier
• 3) 最后通过名字寻找

@Resource 如果没有指定 name 属性，当注解标注在 field 上，默认取字段名称作为 bean 名称寻找依赖对象；当标注在属性 setter 方法上，默认取属性名作为 bean 名称寻找依赖。如果没有指定 name 属性，并且按照默认名称找不到依赖对象时，回退到类型装配。

扩展

https://github.com/google/guice/

Google 提供的轻量级依赖注入框架，支持 Java 6 及以上

http://square.github.io/dagger/

为 Android 和 Java 设计的 DI

reference

• https://stackoverflow.com/questions/4093504/resource-vs-autowired
• https://stackoverflow.com/questions/20450902/inject-and-resource-and-autowired-annotations
• http://www.baeldung.com/spring-annotations-resource-inject-autowire
• https://jcp.org/en/jsr/detail?id=250
• http://blogs.sourceallies.com/2011/08/spring-injection-with-resource-and-autowired/

Spring的Interceptor(拦截器)与Servlet的Filter有相似之处，都能实现权限检查、日志记录等。不同的是：

interceptor 使用

interceptor 的执行顺序大致为：

1. 请求到达 DispatcherServlet
2. DispatcherServlet 发送至 Interceptor ，执行 preHandle
3. 请求达到 Controller
4. 请求结束后，postHandle 执行

Spring 中主要通过 HandlerInterceptor 接口来实现请求的拦截，实现 HandlerInterceptor 接口需要实现下面三个方法：

• preHandle() – 在handler执行之前，返回 boolean 值，true 表示继续执行，false 为停止执行并返回。
• postHandle() – 在handler执行之后, 可以在返回之前对返回的结果进行修改
• afterCompletion() – 在请求完全结束后调用，可以用来统计请求耗时等等

统计请求耗时

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

import org.apache.log4j.Logger;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class ExecuteTimeInterceptor extends HandlerInterceptorAdapter{

	private static final Logger logger = Logger.getLogger(ExecuteTimeInterceptor.class);

	//before the actual handler will be executed
	public boolean preHandle(HttpServletRequest request,
		HttpServletResponse response, Object handler)
		throws Exception {

		long startTime = System.currentTimeMillis();
		request.setAttribute("startTime", startTime);

		return true;
	}

	//after the handler is executed
	public void postHandle(
		HttpServletRequest request, HttpServletResponse response,
		Object handler, ModelAndView modelAndView)
		throws Exception {

		long startTime = (Long)request.getAttribute("startTime");

		long endTime = System.currentTimeMillis();

		long executeTime = endTime - startTime;

		//modified the exisitng modelAndView
		modelAndView.addObject("executeTime",executeTime);

		//log it
		if(logger.isDebugEnabled()){
		   logger.debug("[" + handler + "] executeTime : " + executeTime + "ms");
		}
	}
}

例子来源 mkyong

使用mvc:interceptors标签来声明需要加入到SpringMVC拦截器链中的拦截器

<mvc:interceptors>  
<!-- 使用bean定义一个Interceptor，直接定义在mvc:interceptors根下面的Interceptor将拦截所有的请求 -->  
<bean class="com.company.app.web.interceptor.AllInterceptor"/>  
	<mvc:interceptor>  
		 <mvc:mapping path="/**"/>  
		 <mvc:exclude-mapping path="/parent/**"/>  
		 <bean class="com.company.authorization.interceptor.SecurityInterceptor" />  
	</mvc:interceptor>  
	<mvc:interceptor>  
		 <mvc:mapping path="/parent/**"/>  
		 <bean class="com.company.authorization.interceptor.SecuritySystemInterceptor" />  
	</mvc:interceptor>  
</mvc:interceptors>  

可以利用mvc:interceptors标签声明一系列的拦截器，然后它们就可以形成一个拦截器链，拦截器的执行顺序是按声明的先后顺序执行的，先声明的拦截器中的preHandle方法会先执行，然而它的postHandle方法和afterCompletion方法却会后执行。

在mvc:interceptors标签下声明interceptor主要有两种方式：

• 直接定义一个Interceptor实现类的bean对象。使用这种方式声明的Interceptor拦截器将会对所有的请求进行拦截。
• 使用mvc:interceptor标签进行声明。使用这种方式进行声明的Interceptor可以通过mvc:mapping子标签来定义需要进行拦截的请求路径。

经过上述两步之后，定义的拦截器就会发生作用对特定的请求进行拦截了。

Filter 使用

Servlet 的 Filter 接口需要实现如下方法：

• void init(FilterConfig paramFilterConfig) – 当容器初始化 Filter 时调用，该方法在 Filter 的生命周期只会被调用一次，一般在该方法中初始化一些资源，FilterConfig 是容器提供给 Filter 的初始化参数，在该方法中可以抛出 ServletException 。init 方法必须执行成功，否则 Filter 可能不起作用，出现以下两种情况时，web 容器中 Filter 可能无效： 1）抛出 ServletException 2）超过 web 容器定义的执行时间。
• doFilter(ServletRequest paramServletRequest, ServletResponse paramServletResponse, FilterChain paramFilterChain) – Web 容器每一次请求都会调用该方法。该方法将容器的请求和响应作为参数传递进来， FilterChain 用来调用下一个 Filter。

• void destroy() – 当容器销毁 Filter 实例时调用该方法，可以在方法中销毁资源，该方法在 Filter 的生命周期只会被调用一次。

  FrequencyLimitFilter com.company.filter.FrequencyLimitFilter FrequencyLimitFilter /login/*

Filter 和 Interceptor 的一些用途

• Authentication Filters
• Logging and Auditing Filters
• Image conversion Filters
• Data compression Filters
• Encryption Filters
• Tokenizing Filters
• Filters that trigger resource access events
• XSL/T filters
• Mime-type chain Filter

Request Filters 可以:

• 执行安全检查 perform security checks
• 格式化请求头和主体 reformat request headers or bodies
• 审查或者记录日志 audit or log requests
• 根据请求内容授权或者限制用户访问 Authentication-Blocking requests based on user identity.
• 根据请求频率限制用户访问

Response Filters 可以:

• 压缩响应内容,比如让下载的内容更小 Compress the response stream
• 追加或者修改响应 append or alter the response stream
• 创建或者整体修改响应 create a different response altogether
• 根据地方不同修改响应内容 Localization-Targeting the request and response to a particular locale.

reference

• https://gopalakrishnadurga.wordpress.com/2012/06/08/filter-vs-interceptor/

@Component, @Service, @Controller 和 @Repository 四个注解在 Spring 中等同于在XML中定义 <bean> 标签，他们注解的对象都是 Spring 的 Bean。@Service，@Controller 和 @Repository 本质上就是 @Component。 @Controller，@Service，@Repository 他们在功能上几乎相同，主要的功能是用来给应用分层。

• @Controller: 处理对应的请求，对应表现层（控制层），使用 @RequestMapping 注解来定义请求 Path，在该层中做请求分发，转发，调用Service方法等
• @Service: 所有业务逻辑放在 Service 中，对应业务层，包括数值计算，业务逻辑，在该层中直接调用持久层的方法
• @Repository: 持久层，访问数据，保存数据，DAO(Data Access Objects)，比如所有数据库相关的操作
• @Component: 通用的Spring 组件，generic stereotype for any Spring-managed component，当组件不好归类时可以使用该注解

在配置文件中定义

<context:component-scan base-package="com.mycompany.mypackage" />

Spring 就会自动扫描package下所有类，将带有@Component、@Repository、@Service、@Controller 标签的类自动注册到Spring容器。 简而言之，注解的方式省去了过去需要在 XML 中定义 <bean class="..."> 的繁重工作。component-scan 包含了annotation-config标签的作用。 @Repository、@Service、@Controller 这三个注解除了作用于不同的软件层面外，其他使用方式和 @Repository 几乎一致。

除了上面的四个注解外，用户同样也可以创建自定义的注解，然后在注解上标注 @Component，那么，该自定义注解便具有了与所 @Component 相同的功能。

当一个 Bean 被自动检测到时，会根据那个扫描器的 BeanNameGenerator 策略生成它的 bean 名称。默认情况下，对于包含 name 属性的 @Component、@Repository、 @Service 和 @Controller，会把 name 取值作为 Bean 的名字。如果这个注解不包含 name 值或是其他被自定义过滤器发现的组件，默认 Bean 名称会是小写开头的非限定类名。如果你不想使用默认 bean 命名策略，可以提供一个自定义的命名策略。首先实现 BeanNameGenerator 接口，确认包含了一个默认的无参数构造方法。然后在配置扫描器时提供一个全限定类名，如下所示：

<beans ...> 
<context:component-scan 
	base-package="a.b" name-generator="a.SimpleNameGenerator"/> 
</beans> 

与通过 XML 配置的 Spring Bean 一样，通过上述注解标识的 Bean，其默认作用域是”singleton”，为了配合这四个注解，在标注 Bean 的同时能够指定 Bean 的作用域，Spring 2.5 引入了 @Scope 注解。 可以在定义Component 的时候指定 @Scope("prototype”) 来改变。

@Component
@Scope("prototype")
public class UserService {
	private int counter;

}

通过名字获取Bean

在一些特殊情况下当我们无法使用注解直接使用 Spring Bean 时，比如在 Filter 中，有一些教程提示我们可以直接使用 ApplicationContext.getBean() 来后去 Bean，但这样的方式不优雅 ，我们可以考虑实现 org.springframework.context.ApplicationContextAware 接口，来动态的根据名字来获取 Bean。文档上

Interface to be implemented by any object that wishes to be notified of the ApplicationContext that it runs in. Implementing this interface makes sense for example when an object requires access to a set of collaborating beans. Note that configuration via bean references is preferable to implementing this interface just for bean lookup purposes.

具体实现如下：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
@Component
public class ContextProvider implements ApplicationContextAware {
 
	private static ApplicationContext CONTEXT;
 
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		CONTEXT = applicationContext;
	}
 
	/**
	 * Get a Spring bean by type.
	 **/
	public static <T> T getBean(Class<T> beanClass) {
		return CONTEXT.getBean(beanClass);
	}
 
	/**
	 * Get a Spring bean by name.
	 **/
	public static Object getBean(String beanName) {
		return CONTEXT.getBean(beanName);
	}
}

上面的类实现，定义了一个简单的 @Component 实现了 ApplicationContextAware 接口，当 Spring Context 被创建时会被通知到。当被通知后 Spring context 会被放到唯一的静态变量 CONTEXT 中，因此静态方法能够通过 getBean 方法找到相应的 Bean 实例。

getBean 的默认名称是类名（头字母小写），如果想简单自定义Bean名字，可以@Service("serviceNewName") 这样来指定。

使用 @PostConstruct 和 @PreDestroy 指定生命周期回调方法

可以使用以下方式指定初始化方法和销毁方法：

@PostConstruct
public void init() { 

} 

@PreDestroy
public void destory() { 

}

Spring Bean 是受 Spring IoC 容器管理，由容器进行初始化和销毁的（prototype 类型由容器初始化之后便不受容器管理），通常我们不需要关注容器对 Bean 的初始化和销毁操作，由 Spring 经过构造函数或者工厂方法创建的 Bean 就是已经初始化完成并立即可用的。然而在某些情况下，可能需要我们手工做一些额外的初始化或者销毁操作，这通常是针对一些资源的获取和释放操作。

Spring 2.5 在保留以上两种方式的基础上，提供了对 JSR-250 的支持。JSR-250 规范定义了两个用于指定声明周期方法的注解：@PostConstruct 和 @PreDestroy。这两个注解使用非常简单，只需分别将他们标注于初始化之后执行的回调方法或者销毁之前执行的回调方法上。由于使用了注解，因此需要配置相应的 Bean 后处理器，亦即在 XML 中增加如下一行：

比较上述三种指定生命周期回调方法的方式，第一种是不建议使用的，不但其用法不如后两种方式灵活，而且无形中增加了代码与框架的耦合度。后面两种方式开发者可以根据使用习惯选择其中一种，但是最好不要混合使用，以免增加维护的难度。

reference

• https://stackoverflow.com/questions/6827752/whats-the-difference-between-component-repository-service-annotations-in
• https://brunozambiazi.wordpress.com/2016/01/16/getting-spring-beans-programmatically/
• https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-iocannt/index.html?ca=drs-cn-0506

一般在开发网站时使用 session 或者 cookie 来处理用户登陆等等权限问题，而在移动应用中要验证用户身份采用登录时给用户生成一个 token（令牌）的方式。每次用户发出需要身份认证的请求时，就需要验证一次 token 是否有效，无效的情况包括 token 无法被解析等。在向不可信环境发送数据时，确保数据经过签名，使用只有自己知道的密钥来签名数据，加密后发送，在取回数据时，确保没有人篡改过。

Python 有个 itsdangerous 包含了很多安全校验 token 验证相关的方案。 itsdangerous 就是这样一个签名校验的工具，内部使用 HMAC 和 SHA1 来签名。基于 Django 签名模块，支持 JSON Web 签名 (JWS), 这个库采用 BSD 协议。

给定字符串签名

发送方和接收方拥有相同的密钥 secret-key ，发送方使用密钥对发送内容进行签名，接收方使用相同的密钥对接收到的内容进行验证，看是否是发送方发送的内容。

>>> from itsdangerous import Signer
>>> s = Signer('secret-key')
>>> s.sign('my string')
'my string.wh6tMHxLgJqB6oY1uT73iMlyrOA'

签名过的字符串使用 . 分割。验证使用 unsign

>>> s.unsign('my string.wh6tMHxLgJqB6oY1uT73iMlyrOA')

带时间戳的签名

签名有一定的时效性，发送方发送时，带上时间信息，接收方判断多长时间内是否失效

>>> from itsdangerous import TimestampSigner
>>> s = TimestampSigner('secret-key')
>>> string = s.sign('foo')
foo.DlGDsw.dpJ37ffyfNAVufH21lH_yoelnKA
>>> s.unsign(string, max_age=5)

如果验证时间不对会抛出异常

序列化

>>> from itsdangerous import Serializer
>>> s = Serializer('secret-key')
>>> s.dumps([1, 2, 3, 4])
>>> s.loads('[1, 2, 3, 4].r7R9RhGgDPvvWl3iNzLuIIfELmo')

带时间戳的序列化

>>> from itsdangerous import TimedSerializer
>>> s=TimedSerializer('secret-key')
>>> s.dumps([1,2,3,4])
>>> s.loads('[1, 2, 3, 4].DlGEjg.1yG-U7iBk92FBYAZLezoBv2mfJs')

URL 安全序列化

如果加密过的字符串需要在 URL 中传输，可以使用这种方式。常见的就是在邮件验证 token 中。

>>> from itsdangerous import URLSafeSerializer
>>> s = URLSafeSerializer('secret-key')
>>> s.dumps([1, 2, 3, 4])
'WzEsMiwzLDRd.wSPHqC0gR7VUqivlSukJ0IeTDgo'
>>> s.loads('WzEsMiwzLDRd.wSPHqC0gR7VUqivlSukJ0IeTDgo')
[1, 2, 3, 4]

JSON Web Signatures

>>> from itsdangerous import JSONWebSignatureSerializer
>>> s = JSONWebSignatureSerializer('secret-key')
>>> s.dumps({'x': 42})
'eyJhbGciOiJIUzI1NiJ9.eyJ4Ijo0Mn0.ZdTn1YyGz9Yx5B5wNpWRL221G1WpVE5fPCPKNuc6UAo'

带时间戳的 JSON Web 签名

from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
s = Serializer('secret-key', expires_in=60)
s.dumps({'id': user.id}) # user 为 model 中封装过的对象

在 Flask 中应用

from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from itsdangerous import SignatureExpired, BadSignature
from config import config

def gen_token(user, expiration=1440*31*60):  # 单位为秒，设定 31 天过期
    s = Serializer(config.SECRET_KEY, expires_in=expiration)
    return s.dumps({'id': user.id})  # user 为 model 中封装过的对象

装饰器

from functools import wraps
def token_required(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        token = request.form['token']
        s = Serializer(config.SECRET_KEY)
        try:
            data = s.loads(token)
        except SignatureExpired:
            return jsonify({'status': 'fail', 'data': {'msg': 'expired token'}})
        except BadSignature:
            return jsonify({'status': 'fail', 'data': {'msg': 'useless token'}})
        kwargs['user_id'] = data['id']
        return func(*args, **kwargs)
    return wrapper

盐值

不同的盐值，生成的签名或者序列化的数值不一样，这里的盐 （SALT）不同于加密算法中的盐值，这里的盐值是用来避免彩虹表破解。

Hash

哈希（Hash）算法就是单向散列算法，它把某个较大的集合 P 映射到另一个较小的集合 Q 中，假如这个算法叫 H，那么就有 Q = H（P）。对于 P 中任何一个值 p 都有唯一确定的 q 与之对应，但是一个 q 可以对应多个 p。作为一个有用的 Hash 算法，H 还应该满足：H(p) 速度比较快； 给出一个 q，很难算出一个 p 满足 q = H(p)；给出一个 p1，很难算出一个不等于 p1 的 p2 使得 H(p1)=H(p2)。正因为有这样的特性，Hash 算法经常被用来保存密码————这样不会泄露密码明文，又可以校验输入的密码是否正确。常用的 Hash 算法有 MD5、SHA1 等。

破解 Hash 的任务就是，对于给出的一个 q，反算出一个 p 来满足 q = H(p)。通常我们能想到的两种办法，一种就是暴力破解法，把 P 中的每一个 p 都算一下 H(p)，直到结果等于 q；另一种办法是查表法，搞一个很大的数据 库，把每个 p 和对应的 q 都记录下来，按 q 做一下索引，到时候查一下就知道了。这两种办法理论上都是可以的，但是前一种可能需要海量的时间，后一种需要海量 的存储空间，以至于以目前的人类资源无法实现。

扩展

JWT 是一次性认证完毕加载信息到 token 里的，token 的信息内含过期信息。过期时间过长则被重放攻击的风险太大，而过期时间太短则请求端体验太差（动不动就要重新登录）

第三方认证协议 Oauth2.0 RFC6749 ，它采取了另一种方法：refresh_token，一个用于更新令牌的令牌。在用户首次认证后，签发两个 token： 一个为 access_token，用于用户后续的各个请求中携带的认证信息；另一个是 refresh_token，为 access_token 过期后，用于申请一个新的 access_token。

由此可以给两类不同 token 设置不同的有效期，例如给 access_token 仅 1 小时的有效时间，而 refresh_token 则可以是一个月。api 的登出通过 access token 的过期来实现（前端则可直接抛弃此 token 实现登出），在 refresh token 的存续期内，访问 api 时可执 refresh token 申请新的 access token（前端可存此 refresh token，access token 过其实进行更新，达到自动延期的效果）。refresh token 不可再延期，过期需重新使用用户名密码登录。

这种方式的理念在于，将证书分为三种级别：

• access token 短期证书，用于最终鉴权
• refresh token 较长期的证书，用于产生短期证书，不可直接用于服务请求
• 用户名密码 几乎永久的证书，用于产生长期证书和短期证书，不可直接用于服务请求

reference

• https://pythonhosted.org/itsdangerous/

能否使用 == 来针对 enum 来比较？

答案是：YES, 枚举谨慎的实例化管理允许使用 == 来进行比较，JLS 8.9 Enums 中有Java 语言的规范定义：

枚举类型除了定义时的枚举常量外没有其他实例

如果显示的实例化枚举类型，会产生编译时异常。final clone 方法保证了 Enum 变量不会被 clone， 序列化的机制也保证了重复的实例在反序列化时不会创建额外的枚举变量。通过反射实例化 Enum 类型是被禁止的。所有这四种方式确保了 enum 类型不存在额外的实例，除了定义时的常量

因为每一个枚举常量只有一个实例，因此使用 == 来代替 equals 方法来比较两个枚举是被允许的.

== 和 equals 的区别

使用 == 来代替 equals 也存在两点需要注意的问题。

== 不会抛出空指针异常

enum Color { BLACK, WHITE };

Color nothing = null;
if (nothing == Color.BLACK);      // runs fine
if (nothing.equals(Color.BLACK)); // throws NullPointerException

不过 == 有编译时类型检查，这一点还是很不错的

enum Color { BLACK, WHITE };
enum Chiral { LEFT, RIGHT };

if (Color.BLACK.equals(Chiral.LEFT)); // compiles fine
if (Color.BLACK == Chiral.LEFT);      // DOESN'T COMPILE!!! Incompatible types!

总结

对于不可变类，并且该类能够有效的控制实例数量， == 就是可用的。

在 Effective Java 一书中指出：

考虑静态工厂方法代替构造器，它使得不可变类可以确保不存在两个相等的实例，即当且仅当 a==b 时才有 a.equals(b) 成立，如果类能够保证这一点，它的客户端可以使用 == 来代替 equals 方法，这样可以提升性能，而枚举类型可以保证这一点。

所以在枚举比较中可以使用 ==：

1. 可以正常工作
2. 更快
3. 运行时安全
4. 编译期也是安全的。

reference

• http://stackoverflow.com/questions/1750435/comparing-java-enum-members-or-equals