场景
通常来说依赖注入的对象一旦创建完成后就不会在改变，因为Spring的默认行为创建的都是单例对象。HttpServletRequest和HttpServletResponse不是单例对象，它们都是根据HTTP请求进行创建的，一个HTTP请求对象一个request和response。但是通过@Autowired可以实现每当一个请求进来时使用的都是当前的request或response对象,
演示代码如下
@RestController
@RequestMapping("/test")
public void TestController {
@Autowired
private HttpServletRequest request;
@GetMapping("/request")
public String test() {
String queryString = request.getQueryString();
}
}
实现原理
实际上，通过@Autowire注入的HttpServletRequest只是一个代理对象，其内部会实时获取当前请求对应的真正的HttpServletRequest对象。
在上面的TestController中，框架在进行依赖注入HttpServletRequest 时，会去IOC容器中查找类型为HttpServletRequest的Bean，
首先会调用DefaultListableBeanFactory#doResolveDependency(DependencyDescriptor, String, Set<String>, TypeConverter)进行依赖的解析，最终会调用到DefaultListableBeanFactory#findAutowireCandidates(String, Class<?>, DependencyDescriptor), 该方法主要是从依赖注入源中查找对应类型的Bean，源码如下：
// 存放用于依赖注入的Bean
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
if (autowiringType.isAssignableFrom(requiredType)) {
// 从依赖注入源查找对应类型的Bean
Object autowiringValue = this.resolvableDependencies.get(autowiringType);
// 如果有必要的话，为autowiringValue创建代理对象
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
// 省略其他代码...
return result;
}
值得注意的是resolvableDependencies中存放的Bean只用于依赖注入，不用于依赖查找
在this.resolvableDependencies.get(autowiringType);这段代码中会获取到一个类型为RequestObjectFactory的Bean，该Bean实现了ObjectFactory 接口，属于WebApplicationContextUtils的内部类，源码如下
private static class RequestObjectFactory implements ObjectFactory<ServletRequest>, Serializable {
@Override
public ServletRequest getObject() {
return currentRequestAttributes().getRequest();
}
@Override
public String toString() {
return "Current HttpServletRequest";
}
}
private static ServletRequestAttributes currentRequestAttributes() {
RequestAttributes requestAttr = RequestContextHolder.currentRequestAttributes();
if (!(requestAttr instanceof ServletRequestAttributes)) {
throw new IllegalStateException("Current request is not a servlet request");
}
return (ServletRequestAttributes) requestAttr;
}
通过代码可以看出来RequestObjectFactory 的作用就是实时从ThreadLocal中获取当前请求对应的request对象，RequestContextHolder 内部使用的就是ThreadLocal
在获取到RequestObjectFactory 对象后，AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType) 这段代码中会为其创建一个代理对象，源码如下
// AutowireUtils#resolveAutowiringValue
public static Object resolveAutowiringValue(Object autowiringValue, Class<?> requiredType) {
if (autowiringValue instanceof ObjectFactory && !requiredType.isInstance(autowiringValue)) {
// 此时 factory = RequestObjectFactory
ObjectFactory<?> factory = (ObjectFactory<?>) autowiringValue;
if (autowiringValue instanceof Serializable && requiredType.isInterface()) {
// 创建代理对象， requiredType = HttpServletRequest.class
// 并将RequestObjectFactory传入ObjectFactoryDelegatingInvocationHandler中
autowiringValue = Proxy.newProxyInstance(requiredType.getClassLoader(),
new Class<?>[] {requiredType}, new ObjectFactoryDelegatingInvocationHandler(factory));
}
else {
return factory.getObject();
}
}
return autowiringValue;
}
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();
}
// 在代理类中，每次调用HttpServetRequest中的方法都会去RequestObjectFactory中获取线程本 // 地变量中的HttpServletRequest对象，并通过反射调用其对应的方法
try {
return method.invoke(this.objectFactory.getObject(), args);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
从源码中可以看出在示例代码TestController中调用request.getQueryString()，会直接进入到ObjectFactoryDelegatingInvocationHandler的invoke()方法中，然后通过反射的方式调用真正的HttpServletRequest对象中的方法
RequestObjectFactory 和 RequestAttributes 初始化时机
RequestObjectFactory
在容器启动阶段，会有一个BeanFactory后置处理阶段，其中会调用AbstractApplicatioContext#postProcessBeanFactory(ConfigurableListableBeanFactory) 方法，其中一个子类,AnnotationConfigReactiveWebServerApplicationContext对其进行了实现，其中会调用到WebApplicationContextUtils#registerWebApplicationScopes(ConfigurableListableBeanFactory, ServletContext)方法，源码如下
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
@Nullable ServletContext sc) {
beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
if (sc != null) {
ServletContextScope appScope = new ServletContextScope(sc);
beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
// Register as ServletContext attribute, for ContextCleanupListener to detect it.
sc.setAttribute(ServletContextScope.class.getName(), appScope);
}
// 添加依赖注入Bean的来源
beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
if (jsfPresent) {
FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
}
}
// DefaultListableBeanFactory#registerResolvableDependency
public void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) {
Assert.notNull(dependencyType, "Dependency type must not be null");
if (autowiredValue != null) {
if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
throw new IllegalArgumentException("Value [" + autowiredValue +
"] does not implement specified dependency type [" + dependencyType.getName() + "]");
}
// 添加进依赖注入源
this.resolvableDependencies.put(dependencyType, autowiredValue);
}
}
在上面代码中会将RequestObjectFactory和其他实现了ObjectFactory接口的对象添加到依赖注入源中，到这一步也就和上面获取requset对象的过程对应起来了
RequestAttributes
RequestAttributes 在Spring中的多处代码中都有使用到，这里列举两个Web场景下常用的两处
RequestContextFilter中
第一个在过滤器RequestContextFilter中，会把当前的HttpServletRequest和HttpServletResponse都放入ThreadLocal中，过滤器代码如下
public class RequestContextFilter extends OncePerRequestFilter {
// 省略类中其他代码...
// 该方法属于OncePerRequestFilter的模板方法，
// 会在OncePerRequestFilter#doFilter(ServletRequest, ServletResponse, FilterChain)中被调用
protected void doFilterInternal(
HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
// 创建RequestAttributes的子类对象`ServletRequestAttributes`
ServletRequestAttributes attributes = new ServletRequestAttributes(request, response);
// 初始化RequestContextHolder
initContextHolders(request, attributes);
try {
filterChain.doFilter(request, response);
}
finally {
resetContextHolders();
if (logger.isDebugEnabled()) {
logger.debug("Cleared thread-bound request context: " + request);
}
attributes.requestCompleted();
}
}
private void initContextHolders(HttpServletRequest request, ServletRequestAttributes requestAttributes) {
LocaleContextHolder.setLocale(request.getLocale(), this.threadContextInheritable);
// 将RequestAttributes 放入ThreadLocal中
RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
}
}
RequestContextListener中
RequestContextListener 实现了Servlet中的监听器ServletRequestListener, 当事件发生，会将requset对象放入ThreadLocal中
public class RequestContextListener implements ServletRequestListener {
private static final String REQUEST_ATTRIBUTES_ATTRIBUTE =
RequestContextListener.class.getName() + ".REQUEST_ATTRIBUTES";
@Override
public void requestInitialized(ServletRequestEvent requestEvent) {
if (!(requestEvent.getServletRequest() instanceof HttpServletRequest)) {
throw new IllegalArgumentException(
"Request is not an HttpServletRequest: " + requestEvent.getServletRequest());
}
HttpServletRequest request = (HttpServletRequest) requestEvent.getServletRequest();
ServletRequestAttributes attributes = new ServletRequestAttributes(request);
request.setAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE, attributes);
LocaleContextHolder.setLocale(request.getLocale());
RequestContextHolder.setRequestAttributes(attributes);
}
}
