主题
在使用spring框架开发的时候，我们经常会碰到这种情况：
@Controller
public class SomeController {
@RequestMapping("/test1")
public String test1(HttpServletRequest request) {
System.out.println(request.getQueryString());
return "";
}
@RequestMapping("/test2")
public String test2(HttpServletRequest request) {
System.out.println(request.getQueryString());
return "";
}
@RequestMapping("/test3")
public String test3(HttpServletRequest request) {
System.out.println(request.getQueryString());
return "";
}
}
即，一个@Controller或@Service中的多个方法都使用到了request这个参数，那么为了简化代码，我们会将request作为成员变量注入，改写成如下形式：
@Controller
public class SomeController {
@Resource
private HttpServletRequest request;
@RequestMapping("/test1")
public String test1() {
System.out.println(request.getQueryString());
return "";
}
@RequestMapping("/test2")
public String test2() {
System.out.println(request.getQueryString());
return "";
}
@RequestMapping("/test3")
public String test3() {
System.out.println(request.getQueryString());
return "";
}
}
这样，我们就可以不必在每个用到request的方法的参数列表都写一遍HttpServletRequest request这个参数了。工作中也经常是这样做的。
思考
但是，仔细思考一下，我们会有这样的疑问：
- spring中@Controller默认是单例的，其成员变量也是在bean初始化时注入好的，而HttpServletRequest这个变量对于每一次请求都是不同的，难道@Controller对每次请求都重新注入request这个成员变量？且不说这种做法不符合spring对bean管理的一般方式，即使这样做了，线程安全如何保证？
实现
先上结论，上面的写法，每次都可以取到正确的request对象，并且是线程安全的。
那么，spring是如何做到的呢？
首先debug看下两种做法真实注入类的区别：
区别很明显，
作为成员变量注入的时候注入的是代理对象，是 AutowireUtils.ObjectFactoryDelegatingInvocationHandler的实例。
而作为方法参数注入的就是我们一般使用的Request对象。
看下ObjectFactoryDelegatingInvocationHandler这个AutowireUtils的内部类：
/**
* Reflective InvocationHandler for lazy access to the current target object.
*/
@SuppressWarnings("serial")
private static class ObjectFactoryDelegatingInvocationHandler implements InvocationHandler, Serializable {
private final ObjectFactory<?> objectFactory;
public ObjectFactoryDelegatingInvocationHandler(ObjectFactory<?> objectFactory) {
this.objectFactory = objectFactory;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if (methodName.equals("equals")) {
// Only consider equal when proxies are identical.
return (proxy == args[0]);
}
else if (methodName.equals("hashCode")) {
// Use hashCode of proxy.
return System.identityHashCode(proxy);
}
else if (methodName.equals("toString")) {
return this.objectFactory.toString();
}
try {
return method.invoke(this.objectFactory.getObject(), args);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
可以看到，当代理对象的方法被调用时，除去少数几个方法，大部分的情况都是通过this.objectFactory.getObject()获取被代理对象，再调用被代理对象的相应方法
通过一步步debug，最终终于看到了熟悉的Request类，可以看到它是从requestAttributesHolder中取到的，那么requestAttributesHolder又是什么呢？
看到这里答案已经很明了了，这个RequestContextHolder的ThreadLocal成员变量就是实现的关键所在，它存放了每个线程对应的Request对象，因此在@Controller中调用作为成员变量注入的代理类的方法时，最终可以取到当前线程相对应的Request对象，并调用Request对应的方法，这样@Controller中的成员变量不需要重复注入（它一直都是最初bean初始化时注入的代理类），也避免了线程不安全的问题。
那么spring是何时将Request放入这个ThreadLocal之中的呢？
是在Springmvc的dispatcherServlet的父类FrameworkServlet里操作的：
可以看到对Servlet的doGet、dePost等各种调用，最终都通过processRequest(request, response)处理
该方法调用了initContextHolders(request, localeContext, requestAttributes);
最终看到了将Request放入ThreadLocal的操作。
总结
- 在bean中注入作为成员变量的HttpServletRequest时，实际注入的是spring框架生成的代理对象，是ObjectFactoryDelegatingInvocationHandler的实例。在我们调用这个成员变量的方法时，最终是调用了objectFactory的getObject()对象的对应方法，在这里objectFactory是RequestObjectFactory这个类的对象。
- RequestObjectFactory的getObject方法是从RequestContextHolder的threadlocal中去取值的。
- 请求刚进入springmvc的dispatcherServlet的时候会把request相关对象设置到RequestContextHolder的threadlocal中去.
