springframework包下的RequestContextHolder类和ServletRequestAttributes类的源码和使用

最新推荐文章于 2024-10-14 09:15:09 发布
最新推荐文章于 2024-10-14 09:15:09 发布
阅读量2.5k 收藏 2
点赞数
分类专栏： spring/springboot/springcloud 文章标签： java spring 5 springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41358574/article/details/120804391
版权

文章目录

1.通过RequestContextHolder的静态方法可以随时随地取到当前请求的request对象
该类可以用于获得客户端请求的上下文

RequestContextHolder源码：

Holder class to expose the web request in the form of a thread-bound RequestAttributes object. The request will be inherited by any child threads spawned by the current thread if the inheritable flag is set to true.
Use RequestContextListener or org.springframework.web.filter.RequestContextFilter to expose the current web request. Note that org.springframework.web.servlet.DispatcherServlet already exposes the current request by default.
package org.springframework.web.context.request;
翻译：
Holder类以线程绑定的RequestAttributes对象的形式公开web请求。如果可继承标志设置为true，该请求将被当前线程的所有子线程继承。

使用RequestContextListener或org.springframework.web.filter.RequestContextFilter来暴露当前的web请求。注意，org.springframework.web.servlet.DispatcherServlet已经默认暴露了当前请求。

源码：

//


import javax.faces.context.FacesContext;
import org.springframework.core.NamedInheritableThreadLocal;
import org.springframework.core.NamedThreadLocal;
import org.springframework.lang.Nullable;
import org.springframework.util.ClassUtils;

public abstract class RequestContextHolder {
    private static final boolean jsfPresent = ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader());
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal("Request attributes");
    private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder = new NamedInheritableThreadLocal("Request context");

    public RequestContextHolder() {
    }

    public static void resetRequestAttributes() {
        requestAttributesHolder.remove();
        inheritableRequestAttributesHolder.remove();
    }

    public static void setRequestAttributes(@Nullable RequestAttributes attributes) {
        setRequestAttributes(attributes, false);
    }

    public static void setRequestAttributes(@Nullable RequestAttributes attributes, boolean inheritable) {
        if (attributes == null) {
            resetRequestAttributes();
        } else if (inheritable) {
            inheritableRequestAttributesHolder.set(attributes);
            requestAttributesHolder.remove();
        } else {
            requestAttributesHolder.set(attributes);
            inheritableRequestAttributesHolder.remove();
        }

    }

    @Nullable
    public static RequestAttributes getRequestAttributes() {
        RequestAttributes attributes = (RequestAttributes)requestAttributesHolder.get();
        if (attributes == null) {
            attributes = (RequestAttributes)inheritableRequestAttributesHolder.get();
        }

        return attributes;
    }

    public static RequestAttributes currentRequestAttributes() throws IllegalStateException {
        RequestAttributes attributes = getRequestAttributes();
        if (attributes == null) {
            if (jsfPresent) {
                attributes = RequestContextHolder.FacesRequestAttributesFactory.getFacesRequestAttributes();
            }

            if (attributes == null) {
                throw new IllegalStateException("No thread-bound request found: Are you referring to request attributes outside of an actual web request, or processing a request outside of the originally receiving thread? If you are actually operating within a web request and still receive this message, your code is probably running outside of DispatcherServlet: In this case, use RequestContextListener or RequestContextFilter to expose the current request.");
            }
        }

        return attributes;
    }

    private static class FacesRequestAttributesFactory {
        private FacesRequestAttributesFactory() {
        }

        @Nullable
        public static RequestAttributes getFacesRequestAttributes() {
            FacesContext facesContext = FacesContext.getCurrentInstance();
            return facesContext != null ? new FacesRequestAttributes(facesContext) : null;
        }
    }
}

个人理解用ThreadLocal保证了数据间的隔离性

项目中使用RequestContextHolder

用一个servlet工具类：

public class ServletUtils
{
    /**
     * 定义移动端请求的所有可能类型
     */
    private final static String[] agent = { "Android", "iPhone", "iPod", "iPad", "Windows Phone", "MQQBrowser" };

    /**
     * 获取String参数
     */
    public static String getParameter(String name)
    {
        return getRequest().getParameter(name);
    }

    public static ServletRequestAttributes getRequestAttributes()
    {

        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();//这里用RequestContextHolder获得ServletRequestAttributes 
        return (ServletRequestAttributes) attributes;
    }
        /**
     * 获取request
     */
    public static HttpServletRequest getRequest()
    {
        return getRequestAttributes().getRequest();
    }

    /**
     * 获取response
     */
    public static HttpServletResponse getResponse()
    {
        return getRequestAttributes().getResponse();
    }

    /**
     * 获取session
     */
    public static HttpSession getSession()
    {
        return getRequest().getSession();
    }
    
 /**
     * 将字符串渲染到客户端
     * 
     * @param response 渲染对象
     * @param string 待渲染的字符串
     * @return null
     */
    public static String renderString(HttpServletResponse response, String string)
    {
        try
        {
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return null;
        }

通过这个工具类获得cookies:
Cookie[] cookies = ServletUtils.getRequest().getCookies();

在项目中获得完整请求路径

 /**
     * 获取完整的请求路径，包括：域名，端口，上下文访问路径
     * 
     * @return 服务地址
     */
    public String getUrl()
    {
        HttpServletRequest request = ServletUtils.getRequest();
        return getDomain(request);
    }

    public static String getDomain(HttpServletRequest request)
    {
        StringBuffer url = request.getRequestURL();
        String contextPath = request.getServletContext().getContextPath();//getServletContext()方法：获取这个ServletRequest最后被分派到的servlet上下文。返回:这个ServletRequest最后被分派到的servlet上下文
        return url.delete(url.length() - request.getRequestURI().length(), url.length()).append(contextPath).toString();
    }

关于ServletRequestAttributes源码 ：


/**
 * Servlet-based implementation of the {@link RequestAttributes} interface.
 *
 * <p>Accesses objects from servlet request and HTTP session scope,
 * with no distinction between "session" and "global session".
 *
 * @author Juergen Hoeller
 * @since 2.0
 * @see javax.servlet.ServletRequest#getAttribute
 * @see javax.servlet.http.HttpSession#getAttribute
 */
public class ServletRequestAttributes extends AbstractRequestAttributes {

	/**
	 * Constant identifying the {@link String} prefixed to the name of a
	 * destruction callback when it is stored in a {@link HttpSession}.
	 */
	public static final String DESTRUCTION_CALLBACK_NAME_PREFIX =
			ServletRequestAttributes.class.getName() + ".DESTRUCTION_CALLBACK.";

	protected static final Set<Class<?>> immutableValueTypes = new HashSet<>(16);

	static {
		immutableValueTypes.addAll(NumberUtils.STANDARD_NUMBER_TYPES);
		immutableValueTypes.add(Boolean.class);
		immutableValueTypes.add(Character.class);
		immutableValueTypes.add(String.class);
	}


	private final HttpServletRequest request;

	@Nullable
	private HttpServletResponse response;

	@Nullable
	private volatile HttpSession session;

	private final Map<String, Object> sessionAttributesToUpdate = new ConcurrentHashMap<>(1);


	/**
	 * Create a new ServletRequestAttributes instance for the given request.
	 * @param request current HTTP request
	 */
	public ServletRequestAttributes(HttpServletRequest request) {
		Assert.notNull(request, "Request must not be null");
		this.request = request;
	}

	/**
	 * Create a new ServletRequestAttributes instance for the given request.
	 * @param request current HTTP request
	 * @param response current HTTP response (for optional exposure)
	 */
	public ServletRequestAttributes(HttpServletRequest request, @Nullable HttpServletResponse response) {
		this(request);
		this.response = response;
	}


	/**
	 * Exposes the native {@link HttpServletRequest} that we're wrapping.
	 */
	public final HttpServletRequest getRequest() {
		return this.request;
	}

	/**
	 * Exposes the native {@link HttpServletResponse} that we're wrapping (if any).
	 */
	@Nullable
	public final HttpServletResponse getResponse() {
		return this.response;
	}

	/**
	 * Exposes the {@link HttpSession} that we're wrapping.
	 * @param allowCreate whether to allow creation of a new session if none exists yet
	 */
	@Nullable
	protected final HttpSession getSession(boolean allowCreate) {
		if (isRequestActive()) {
			HttpSession session = this.request.getSession(allowCreate);
			this.session = session;
			return session;
		}
		else {
			// Access through stored session reference, if any...
			HttpSession session = this.session;
			if (session == null) {
				if (allowCreate) {
					throw new IllegalStateException(
							"No session found and request already completed - cannot create new session!");
				}
				else {
					session = this.request.getSession(false);
					this.session = session;
				}
			}
			return session;
		}
	}

	private HttpSession obtainSession() {
		HttpSession session = getSession(true);
		Assert.state(session != null, "No HttpSession");
		return session;
	}


	@Override
	public Object getAttribute(String name, int scope) {
		if (scope == SCOPE_REQUEST) {
			if (!isRequestActive()) {
				throw new IllegalStateException(
						"Cannot ask for request attribute - request is not active anymore!");
			}
			return this.request.getAttribute(name);
		}
		else {
			HttpSession session = getSession(false);
			if (session != null) {
				try {
					Object value = session.getAttribute(name);
					if (value != null) {
						this.sessionAttributesToUpdate.put(name, value);
					}
					return value;
				}
				catch (IllegalStateException ex) {
					// Session invalidated - shouldn't usually happen.
				}
			}
			return null;
		}
	}

	@Override
	public void setAttribute(String name, Object value, int scope) {
		if (scope == SCOPE_REQUEST) {
			if (!isRequestActive()) {
				throw new IllegalStateException(
						"Cannot set request attribute - request is not active anymore!");
			}
			this.request.setAttribute(name, value);
		}
		else {
			HttpSession session = obtainSession();
			this.sessionAttributesToUpdate.remove(name);
			session.setAttribute(name, value);
		}
	}

	@Override
	public void removeAttribute(String name, int scope) {
		if (scope == SCOPE_REQUEST) {
			if (isRequestActive()) {
				removeRequestDestructionCallback(name);
				this.request.removeAttribute(name);
			}
		}
		else {
			HttpSession session = getSession(false);
			if (session != null) {
				this.sessionAttributesToUpdate.remove(name);
				try {
					session.removeAttribute(DESTRUCTION_CALLBACK_NAME_PREFIX + name);
					session.removeAttribute(name);
				}
				catch (IllegalStateException ex) {
					// Session invalidated - shouldn't usually happen.
				}
			}
		}
	}

	@Override
	public String[] getAttributeNames(int scope) {
		if (scope == SCOPE_REQUEST) {
			if (!isRequestActive()) {
				throw new IllegalStateException(
						"Cannot ask for request attributes - request is not active anymore!");
			}
			return StringUtils.toStringArray(this.request.getAttributeNames());
		}
		else {
			HttpSession session = getSession(false);
			if (session != null) {
				try {
					return StringUtils.toStringArray(session.getAttributeNames());
				}
				catch (IllegalStateException ex) {
					// Session invalidated - shouldn't usually happen.
				}
			}
			return new String[0];
		}
	}

	@Override
	public void registerDestructionCallback(String name, Runnable callback, int scope) {
		if (scope == SCOPE_REQUEST) {
			registerRequestDestructionCallback(name, callback);
		}
		else {
			registerSessionDestructionCallback(name, callback);
		}
	}

	@Override
	public Object resolveReference(String key) {
		if (REFERENCE_REQUEST.equals(key)) {
			return this.request;
		}
		else if (REFERENCE_SESSION.equals(key)) {
			return getSession(true);
		}
		else {
			return null;
		}
	}

	@Override
	public String getSessionId() {
		return obtainSession().getId();
	}

	@Override
	public Object getSessionMutex() {
		return WebUtils.getSessionMutex(obtainSession());
	}


	/**
	 * Update all accessed session attributes through {@code session.setAttribute}
	 * calls, explicitly indicating to the container that they might have been modified.
	 */
	@Override
	protected void updateAccessedSessionAttributes() {
		if (!this.sessionAttributesToUpdate.isEmpty()) {
			// Update all affected session attributes.
			HttpSession session = getSession(false);
			if (session != null) {
				try {
					for (Map.Entry<String, Object> entry : this.sessionAttributesToUpdate.entrySet()) {
						String name = entry.getKey();
						Object newValue = entry.getValue();
						Object oldValue = session.getAttribute(name);
						if (oldValue == newValue && !isImmutableSessionAttribute(name, newValue)) {
							session.setAttribute(name, newValue);
						}
					}
				}
				catch (IllegalStateException ex) {
					// Session invalidated - shouldn't usually happen.
				}
			}
			this.sessionAttributesToUpdate.clear();
		}
	}

	/**
	 * Determine whether the given value is to be considered as an immutable session
	 * attribute, that is, doesn't have to be re-set via {@code session.setAttribute}
	 * since its value cannot meaningfully change internally.
	 * <p>The default implementation returns {@code true} for {@code String},
	 * {@code Character}, {@code Boolean} and standard {@code Number} values.
	 * @param name the name of the attribute
	 * @param value the corresponding value to check
	 * @return {@code true} if the value is to be considered as immutable for the
	 * purposes of session attribute management; {@code false} otherwise
	 * @see #updateAccessedSessionAttributes()
	 */
	protected boolean isImmutableSessionAttribute(String name, @Nullable Object value) {
		return (value == null || immutableValueTypes.contains(value.getClass()));
	}

	/**
	 * Register the given callback as to be executed after session termination.
	 * <p>Note: The callback object should be serializable in order to survive
	 * web app restarts.
	 * @param name the name of the attribute to register the callback for
	 * @param callback the callback to be executed for destruction
	 */
	protected void registerSessionDestructionCallback(String name, Runnable callback) {
		HttpSession session = obtainSession();
		session.setAttribute(DESTRUCTION_CALLBACK_NAME_PREFIX + name,
				new DestructionCallbackBindingListener(callback));
	}


	@Override
	public String toString() {
		return this.request.toString();
	}

}

关于 HttpServletRequest和 HttpServletResponse

关于servlet的介绍：
客户端的网络请求首先会被Http服务器接收（也叫Web服务器、web容器，其需要提供web应用运行所需的环境，接收客户端的Http请求）；

Web服务器根据请求的路径将请求转交给对应的Servlet容器（也称Servlet引擎，为Servlet的运行提供环境支持，可以理解为tomcat或其他服务器）；

Servlet容器根据对应的虚拟路径（@WebServlet中配置的）来加载Servlet，如果Serlvet没有被实例化则创建该Servlet的一个实例（调用init方法）；

Servlet容器根据用户的HTTP请求，创建一个ServletRequest对象（HTTP的请求信息被封装在其中）和一个可以对HTTP请求进行响应的ServletResponse对象（类似于寄信，并在信中说明回信的地址），然后调用HttpServlet中重写的service(ServletRequest req, ServletResponse res)方法，并在这个方法中，将ServletRequest、ServletResponse这两个对象向下转型，得到我们非常熟悉的HttpServletRequest和HttpServletResponse两个对象，然后将客户端的请求转发到HttpServlet中protected修饰的service(HttpServletRequest req, HttpServletResponse resp)

cookie的写入和获得

/**
     * 获得指定Cookie的值
     * 
     * @param request 请求对象
     * @param response 响应对象
     * @param name 名字
     * @param isRemove 是否移除
     * @return 值
     */
    public static String getCookie(HttpServletRequest request, HttpServletResponse response, String name,
            boolean isRemove)
    {
        String value = null;
        Cookie[] cookies = request.getCookies();
        if (cookies != null)
        {
            for (Cookie cookie : cookies)
            {
                if (cookie.getName().equals(name))
                {
                    try
                    {
                        value = URLDecoder.decode(cookie.getValue(), "utf-8");
                    }
                    catch (UnsupportedEncodingException e)
                    {
                        e.printStackTrace();
                    }
                    if (isRemove)
                    {
                        cookie.setMaxAge(0);
                        response.addCookie(cookie);
                    }
                }
            }
        }
        return value;
    }
/**
     * 设置 Cookie
     * 
     * @param name 名称
     * @param value 值
     * @param maxAge 生存时间（单位秒）
     * @param uri 路径
     */
    public static void setCookie(HttpServletResponse response, String name, String value, String path, int maxAge)
    {
        Cookie cookie = new Cookie(name, null);
        cookie.setPath(path);
        cookie.setMaxAge(maxAge);//该方法用于设置cookie的生存时间，
        try
        {
            cookie.setValue(URLEncoder.encode(value, "utf-8"));//URLEncoder.encode()可以对要传递的中文进行编码a ,如果url参数值含有特殊字符时，需要使用 url 编码。否则可能特殊字符会消失
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }
        response.addCookie(cookie);
    }
march of Time
关注
专栏目录
Spring MVC 工作流程源码分析
weixin_42118323的博客
05-29 1004
我们知道 Servlet#service 方法的主要作用是接收客户端发送的 HTTP 请求，并根据请求的类型（GET、POST、PUT、DELETE等）将请求分发到相应的处理器（Controller）进行处理，处理器处理完请求后，将结果返回给 Servlet#service 方法，再由该方法返回给客户端，Servlet#service 方法是由 Spring DispatcherServlet 类实现的，它是整个Spring MVC 框架的核心组件之一。欢迎提出建议及对错误的地方指出纠正。
浅谈对Spring mvc的理解和DispatherServlet源码深入分析
1Q84emo的博客
09-19 1016
简介Spring mvc是Spring 为展示层提供的一个优秀的Web框架，它基于MVC的设计理念，并采用松耦合、可插拔的组件结构，让它比其他的MVC框架更具有灵活性和扩展性。体系结构学习Spring MVC的时候，最重要还是要懂得它里面内部的各个组件是如何运转工作的，我刚开始接触的时候，只想着一门心思去写代码，而忽略了其最精髓的原理理解和逻辑流程，这也导致我在进行Spring mvc配置和编写代码
深入理解 org.springframework.web.context.request.RequestContextHolder
一起coding，一起嗨。
06-03 633
深入理解 org.springframework.web.context.request.RequestContextHolder
Spring中RequestContextHolder以及HandlerInterceptorAdapter的使用
weixin_30904593的博客
11-08 262
1 . RequestContextHolder 的使用 想要使用RequestContextHolder，要在web.xml中配置RequestContextListener的监听才能使用。 //全局获取session的方法： HttpSession session = ((ServletRequestAttributes) RequestContextHolder.getRequestAtt...
Java学习笔记（七）
最新发布
m0_51431003的博客
10-14 961
你可以在 Spring 中注册自定义函数，并在 SpEL 中使用它们。// 调用自定义函数计算平方值Spring SpEL 是一种灵活且功能丰富的表达式语言，能够帮助开发者轻松地进行动态数据处理。在实际应用中，它常用于配置注入、条件判断以及复杂业务逻辑的实现。通过结合 Java 对象及其方法，SpEL 可以极大提高代码的可读性与可维护性。AdvisorAdvisor是 AOP 中最基本的概念，封装了增强和适用范围。是一种特定类型的 Advisor，根据切入点来决定何时应用增强。
【Java实习】工具包-RequestContextHolder工具包
Zhangsama1的博客
02-06 444
大三下啦，我也已经开始实习啦，因此现在会记录一些我在实习过程中使用到的，或者自己认为有用的自定义的工具包。当然这些工具包自然是根据一些已经开源的项目编写的，当然，也有可能记录的是我认为很好用的工具包，所以，这些文章类似于我的实习笔记，大家看个乐即可，菜菜，勿喷。
Spring RequestContextHolder 和 RequestContextFilter
lizhengyu891231的博客
12-16 2761
Spring RequestContextHolder 和 RequestContextFilter
Spring MVC 中RequestContextHolder获取request和response
linlinlinfeng的博客
12-17 1165
1.最简单方式：处理方法入参 例如： @RequestMapping("/test") @ResponseBody public void saveTest(HttpServletRequest request, HttpServletResponse response){ 　　 } 2.加入监听器，然后在代码里面获取 在Spring API中提供了一个非常便捷的工具类RequestCo...
springmvc中获得HttpServletRequest request方法(org.springframework.web.context.request.RequestContextList)
marila4720的专栏
01-06 9757
在Spring2.0中除了以前的Singleton和Prototype外又加入了三个新的web作用域，分别为request、session和global session，它们的含义和用法请大家参考Spring官方手册的相关章节。如果你想让你的容器里的某个bean拥有其中某种新的web作用域，除了在bean级上配置相应的scope属性，还必须在容器级做一个额外的初始化配置。即在web应用的XML
Spring源码——Spring MVC
等一杯咖啡的博客
11-22 1650
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第十一章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework Spring框架提供了构建Web应用程序的全功能MVC模...
关于springboot服务端实现国际化资源I18N工具类和MessageSource源码解析
qq_27471259的博客
07-27 1458
序言： 目前大多数公司都使用前后端分离的架构来搭建自己的web服务器。 这个程序是解决，当后端出现错误，由后端控制发送到前端的程序。 实现方式 @Component public class I18NUtls { private static MessageSource messageSource; @Autowired public void setMessageSource(Messag...
Feign调用服务Session失效问题以及使用RequestContextHolder.getRequestAttributes()获取值为null的问题
DreamsArchitects的博客
11-12 3849
文章目录一、Feign调用服务Session失效问题二、RequestContextHolder.getRequestAttributes()获取值为null解决方式一 关闭Fegin的熔断解决方式二 调整隔离策略解决方式三 自定义并发策略 一、Feign调用服务Session失效问题 微服务使用feign相互之间调用时，存在session丢失的问题。例如，使用Feign调用某个远程API，这个远程API需要传递一个鉴权信息，我们可以把cookie里面的session信息放到Header里面，我们需要编写
org.springframework.web.context.request.RequestContextListener作用
asdz1989253jm的专栏
03-17 1万+
在Spring2.0中除了以前的Singleton和Prototype外又加入了三个新的web作用域，分别为request、session和global session，它们的含义和用法请大家参考Spring官方手册的相关章节。如果你想让你的容器里的某个bean拥有其中某种新的web作用域，除了在bean级上配置相应的scope属性，还必须在容器级做一个额外的初始化配置。即在web应用的XML
Spring web作用域的配置方式
10-15 331
一、配置方式 在Spring2.0中除了以前的Singleton和Prototype外又加入了三个新的web作用域，分别为request、session和global session，如果你想让你的容器里的某个bean拥有其中某种新的web作用域，除了在bean级上配置相应的scope属性，还必须在容器级做一个额外的初始化配置。 [code="java"] ...
java之RequestContextHolder获取HttpServletRequest、HttpServletResponse
weixin_39585051的博客
07-28 749
/** * 原来写法 * * @param request * @param response */ @GetMapping(value = "/download") public void download(HttpServletRequest request, HttpServletResponse response) { // service层需要操作HttpServlet的时候还得需要在controll...
记录一个异步任务丢失request的坑，RequestContextHolder.setRequestAttributes(sra, true)；异步线程中会丢失
qq_31342501的博客
10-16 6919
ServletRequestAttributes sra = (ServletRequestAttributes); RequestContextHolder.setRequestAttributes(sra, true); 由上代码确实可以使request在异步子线程中被继承，在异步线程中获取requset HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttribut.
RequestContextHolder获取request
热门推荐
weixin_44251024的博客
01-18 1万+
SpringBoot--解决子线程无法获得HttpServletRequest的attribute的问题
IT利刃出鞘的博客
09-24 2789
本文介绍解决SpringBoot子线程无法获得HttpServletRequest的attribute的问题。 在SpringBoot请求中，如果创建了子线程获取request的attribute，会无法获取到。比如：我想记录日志，将日志放到了request的attribute中：request.setAttribute("logContent", "日志内容")，然后创建子线程去获取logContent，然后进行处理。...
SpringMVC之RequestContextHolder分析
大屎片的博客
03-12 226
看源码的时候发现可以在service获取request和response,正常来说在service层是没有request的,然而直接从controlller传过来的话解决方法太粗暴,后来发现了SpringMVC提供的RequestContextHolder来研究一下,并借此对SpringMVC的结构深入了解一下 #1.RequestContextHolder的使用 RequestContextHolder顾名思义,持有上下文的Request容器.使用是很简单的,具体使用如下: RequestAttr.
Spring Boot应用中Date与LocalDateTime的优雅使用教程
"这篇教程详细讲解了如何在Spring Boot应用中高效且优雅地使用Date和LocalDateTime。通过实例代码展示了具体的操作方法，适用于提升开发效率和避免常见的日期处理问题。文章特别提到了Java 8引入的新时间API，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值