spring mvc 一次请求过程跟踪(一)

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

spring mvc 一次请求过程跟踪

项目背景

Spring Boot

  • 主方法
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UploadApplication {

    public static void main(String[] args) {
        SpringApplication.run(UploadApplication.class, args);
    }
}
  • Controller
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by wdmyong on 2017/9/2.
 */
@RequestMapping("/test")
@RestController
public class TestController {

    @RequestMapping("/index")
    public String testIndex() {
        return "testIndex";
    }
}
  • 项目启动
spring boot 启动方式很简单，以Application运行(或者debug)即可，eclipse的话应该还有以spring boot application方式。

跟踪方式

就是debug方式启动之后打断点

  • 1. 根据查询资料在启动时在RequestMappingHandlerMapping中打断点
public void afterPropertiesSet() {
        this.config = new BuilderConfiguration();
        this.config.setUrlPathHelper(this.getUrlPathHelper());
        this.config.setPathMatcher(this.getPathMatcher());
        this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
        this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
        this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
        this.config.setContentNegotiationManager(this.getContentNegotiationManager());
        super.afterPropertiesSet();   // 这里打断点点进去，到2
    }
  • 2. RequestMappingHandlerMapping父类RequestMappingInfoHandlerMapping的父类AbstractHandlerMethodMapping 
public void afterPropertiesSet() {
        this.initHandlerMethods();
    }
// initHandlerMethods方法中调用的以下部分
if(beanType != null && this.isHandler(beanType)) {
    this.detectHandlerMethods(beanName);
}
// 然后detectHandlerMethods继续
protected void detectHandlerMethods(Object handler) {
    // 前后代码我省略了
    this.registerHandlerMethod(handler, invocableMethod, mapping);
}
// registerHandlerMethod继续
protected void registerHandlerMethod(Object handler, Method method, T mapping) {
        this.mappingRegistry.register(mapping, handler, method);
}
// 调用到mappingRegistry.register, mappingRegistry定义
private final AbstractHandlerMethodMapping<T>.MappingRegistry mappingRegistry = new AbstractHandlerMethodMapping.MappingRegistry();
// AbstractHandlerMethodMapping中register方法
public void register(T mapping, Object handler, Method method) {
    this.readWriteLock.writeLock().lock();

    try {
        HandlerMethod handlerMethod = AbstractHandlerMethodMapping.this.createHandlerMethod(handler, method);
        this.assertUniqueMethodMapping(handlerMethod, mapping);
        if(AbstractHandlerMethodMapping.this.logger.isInfoEnabled()) {
            AbstractHandlerMethodMapping.this.logger.info("Mapped \"" + mapping + "\" onto " + handlerMethod);
        }

        this.mappingLookup.put(mapping, handlerMethod); // 这将mapping和handlerMethod的关系保存了
        List<String> directUrls = this.getDirectUrls(mapping);
        Iterator var6 = directUrls.iterator();

        while(var6.hasNext()) {
            String url = (String)var6.next();
            this.urlLookup.add(url, mapping);
        }

        String name = null;
        if(AbstractHandlerMethodMapping.this.getNamingStrategy() != null) {
            name = AbstractHandlerMethodMapping.this.getNamingStrategy().getName(handlerMethod, mapping);
            this.addMappingName(name, handlerMethod);
        }

        CorsConfiguration corsConfig = AbstractHandlerMethodMapping.this.initCorsConfiguration(handler, method, mapping);
        if(corsConfig != null) {
            this.corsLookup.put(handlerMethod, corsConfig);
        }

        this.registry.put(mapping, new AbstractHandlerMethodMapping.MappingRegistration(mapping, handlerMethod, directUrls, name));
            } finally {
        this.readWriteLock.writeLock().unlock();
    }
}
  • 3. 通过以上两步基本应该知道是通过mappingLookup来找到我们请求url里面path对应的处理方法的

请求跟踪

  • 1. 在DispatcherServlet中打断点，因为不管是spring boot里面，还是自己配置的spring mvc项目中入口都在这
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    mappedHandler = this.getHandler(processedRequest); // 通过mapping找到处理的handlerMethod，见1-1
                    if(mappedHandler == null || mappedHandler.getHandler() == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler()); // 通过handler再来找到对应的适配器，见1-2
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if(isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if(this.logger.isDebugEnabled()) {
                            this.logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                        }

                        if((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if(!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
                    // 见1-3
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if(asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if(asyncManager.isConcurrentHandlingStarted()) {
                if(mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if(multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }
  • 1-1. mappedHandler = this.getHandler(processedRequest);
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        /*
        * private List<HandlerMapping> handlerMappings;
        * 保存了一个HandlerMapping的列表
        * 每一项都是处理你mapping到handler的一个HandlerMapping
        * 本文调试中使用的是RequestMappingHandlerMapping@5034
        * 然后通过下面注释位置获取handler
        */
        Iterator var2 = this.handlerMappings.iterator();

        HandlerExecutionChain handler;
        do {
            if(!var2.hasNext()) {
                return null;
            }

            HandlerMapping hm = (HandlerMapping)var2.next();
            if(this.logger.isTraceEnabled()) {
                this.logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name '" + this.getServletName() + "'");
            }
            // 通过getHandler拿到handler
            handler = hm.getHandler(request);
        } while(handler == null);

        return handler;
    }

-1-2. HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        /*
        * private List<HandlerAdapter> handlerAdapters;
        * 保存了一个HandlerAdapter的列表
        * 找到一个能够支持传入handler的适配器，见注释
        * 本文调试过程为RequestMappingHandlerAdapter@4325
        */
        Iterator var2 = this.handlerAdapters.iterator();

        HandlerAdapter ha;
        do {
            if(!var2.hasNext()) {
                throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
            }

            ha = (HandlerAdapter)var2.next();
            if(this.logger.isTraceEnabled()) {
                this.logger.trace("Testing handler adapter [" + ha + "]");
            }
        } while(!ha.supports(handler)); // 直至找到能够支持的ha

        return ha;
    }

-1-3. AbstractHandlerMethodAdapter

// 父类模板方法
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return this.handleInternal(request, response, (HandlerMethod)handler);
    }
    protected abstract ModelAndView handleInternal(HttpServletRequest var1, HttpServletResponse var2, HandlerMethod var3) throws Exception; // 实现跟在后面
// class: RequestMappingHandlerAdapter
protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        this.checkRequest(request);
        ModelAndView mav;
        if(this.synchronizeOnSession) {
            HttpSession session = request.getSession(false);
            if(session != null) {
                Object mutex = WebUtils.getSessionMutex(session);
                synchronized(mutex) {
                    mav = this.invokeHandlerMethod(request, response, handlerMethod);
                }
            } else {
                mav = this.invokeHandlerMethod(request, response, handlerMethod);
            }
        } else {
            // 这一行就是得到结果的行，见1-3-1
            mav = this.invokeHandlerMethod(request, response, handlerMethod);
        }

        if(!response.containsHeader("Cache-Control")) {
            if(this.getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                this.applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
            } else {
                this.prepareResponse(response);
            }
        }

        return mav;
    }

-1-3-1. RequestMappingHandlerAdapter 

protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        ServletWebRequest webRequest = new ServletWebRequest(request, response);

        Object result;
        try {
            WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
            ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
            ServletInvocableHandlerMethod invocableMethod = this.createInvocableHandlerMethod(handlerMethod);
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            invocableMethod.setDataBinderFactory(binderFactory);
            invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
            mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
            modelFactory.initModel(webRequest, mavContainer, invocableMethod);
            mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
            AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
            asyncWebRequest.setTimeout(this.asyncRequestTimeout);
            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.setTaskExecutor(this.taskExecutor);
            asyncManager.setAsyncWebRequest(asyncWebRequest);
            asyncManager.registerCallableInterceptors(this.callableInterceptors);
            asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
            if(asyncManager.hasConcurrentResult()) {
                result = asyncManager.getConcurrentResult();
                mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
                asyncManager.clearConcurrentResult();
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Found concurrent result value [" + result + "]");
                }

                invocableMethod = invocableMethod.wrapConcurrentResult(result);
            }
            // 见1-3-2
            invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
            if(!asyncManager.isConcurrentHandlingStarted()) {
                ModelAndView var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
                return var15;
            }

            result = null;
        } finally {
            webRequest.requestCompleted();
        }

        return (ModelAndView)result;
    }

-1-3-2. ServletInvocableHandlerMethod

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        // 见1-3-3
        Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
        this.setResponseStatus(webRequest);
        if(returnValue == null) {
            if(this.isRequestNotModified(webRequest) || this.getResponseStatus() != null || mavContainer.isRequestHandled()) {
                mavContainer.setRequestHandled(true);
                return;
            }
        } else if(StringUtils.hasText(this.getResponseStatusReason())) {
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);

        try {
            this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
        } catch (Exception var6) {
            if(this.logger.isTraceEnabled()) {
                this.logger.trace(this.getReturnValueHandlingErrorMessage("Error handling return value", returnValue), var6);
            }

            throw var6;
        }
    }

-1-3-3. InvocableHandlerMethod

public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "' with arguments " + Arrays.toString(args));
        }
        // 见1--3-4
        Object returnValue = this.doInvoke(args);
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Method [" + ClassUtils.getQualifiedMethodName(this.getMethod(), this.getBeanType()) + "] returned [" + returnValue + "]");
        }

        return returnValue;
    }

-1-3-4 InvocableHandlerMethod

protected Object doInvoke(Object... args) throws Exception {
        ReflectionUtils.makeAccessible(this.getBridgedMethod());

        try {
            // 这一行去调用的controller
            return this.getBridgedMethod().invoke(this.getBean(), args);
        } catch (IllegalArgumentException var5) {
            this.assertTargetBean(this.getBridgedMethod(), this.getBean(), args);
            String text = var5.getMessage() != null?var5.getMessage():"Illegal argument";
            throw new IllegalStateException(this.getInvocationErrorMessage(text, args), var5);
        } catch (InvocationTargetException var6) {
            Throwable targetException = var6.getTargetException();
            if(targetException instanceof RuntimeException) {
                throw (RuntimeException)targetException;
            } else if(targetException instanceof Error) {
                throw (Error)targetException;
            } else if(targetException instanceof Exception) {
                throw (Exception)targetException;
            } else {
                String text = this.getInvocationErrorMessage("Failed to invoke handler method", args);
                throw new IllegalStateException(text, targetException);
            }
        }
    }
  • 2. 现在开始返回了哈
原路返回的这里就不多说了
  • 3. 说点返回过程中跟踪到的个人觉得有用的信息
见上文中的1-3-2中，this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);进行返回值的处理
// HandlerMethodReturnValueHandlerComposite
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        HandlerMethodReturnValueHandler handler = this.selectHandler(returnValue, returnType);
        if(handler == null) {
            throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
        } else {
            handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
        }
    }
// RequestResponseBodyMethodProcessor
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
        mavContainer.setRequestHandled(true);
        ServletServerHttpRequest inputMessage = this.createInputMessage(webRequest);
        ServletServerHttpResponse outputMessage = this.createOutputMessage(webRequest);
        this.writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
    }
//AbstractMessageConverterMethodProcessor
protected <T> void writeWithMessageConverters(T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
        Object outputValue;
        Class valueType;
        Object declaredType;
        if(value instanceof CharSequence) {
            outputValue = value.toString();
            valueType = String.class;
            declaredType = String.class;
        } else {
            outputValue = value;
            valueType = this.getReturnValueType(value, returnType);
            declaredType = this.getGenericType(returnType);
        }

        HttpServletRequest request = inputMessage.getServletRequest();
        List<MediaType> requestedMediaTypes = this.getAcceptableMediaTypes(request);
        List<MediaType> producibleMediaTypes = this.getProducibleMediaTypes(request, valueType, (Type)declaredType);
        if(outputValue != null && producibleMediaTypes.isEmpty()) {
            throw new IllegalArgumentException("No converter found for return value of type: " + valueType);
        } else {
            Set<MediaType> compatibleMediaTypes = new LinkedHashSet();
            Iterator var12 = requestedMediaTypes.iterator();

            MediaType selectedMediaType;
            Iterator var14;
            MediaType mediaType;
            while(var12.hasNext()) {
                selectedMediaType = (MediaType)var12.next();
                var14 = producibleMediaTypes.iterator();

                while(var14.hasNext()) {
                    mediaType = (MediaType)var14.next();
                    if(selectedMediaType.isCompatibleWith(mediaType)) {
                        compatibleMediaTypes.add(this.getMostSpecificMediaType(selectedMediaType, mediaType));
                    }
                }
            }

            if(compatibleMediaTypes.isEmpty()) {
                if(outputValue != null) {
                    throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
                }
            } else {
                List<MediaType> mediaTypes = new ArrayList(compatibleMediaTypes);
                MediaType.sortBySpecificityAndQuality(mediaTypes);
                selectedMediaType = null;
                var14 = mediaTypes.iterator();

                while(var14.hasNext()) {
                    mediaType = (MediaType)var14.next();
                    if(mediaType.isConcrete()) {
                        selectedMediaType = mediaType;
                        break;
                    }

                    if(mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
                        selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                        break;
                    }
                }

                if(selectedMediaType != null) {
                    selectedMediaType = selectedMediaType.removeQualityValue();
                    var14 = this.messageConverters.iterator();

                    while(var14.hasNext()) {
                        HttpMessageConverter<?> messageConverter = (HttpMessageConverter)var14.next();
                        if(messageConverter instanceof GenericHttpMessageConverter) {
                            if(((GenericHttpMessageConverter)messageConverter).canWrite((Type)declaredType, valueType, selectedMediaType)) {
                                outputValue = this.getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType, messageConverter.getClass(), inputMessage, outputMessage);
                                if(outputValue != null) {
                                    this.addContentDispositionHeader(inputMessage, outputMessage);
                                    ((GenericHttpMessageConverter)messageConverter).write(outputValue, (Type)declaredType, selectedMediaType, outputMessage);
                                    if(this.logger.isDebugEnabled()) {
                                        this.logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                                    }
                                }

                                return;
                            }
                        } else if(messageConverter.canWrite(valueType, selectedMediaType)) {
                            outputValue = this.getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType, messageConverter.getClass(), inputMessage, outputMessage);
                            if(outputValue != null) {
                                this.addContentDispositionHeader(inputMessage, outputMessage);
                                messageConverter.write(outputValue, selectedMediaType, outputMessage);
                                if(this.logger.isDebugEnabled()) {
                                    this.logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                                }
                            }

                            return;
                        }
                    }
                }

                if(outputValue != null) {
                    throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
                }
            }
        }
    }
// 见上文1中this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
        boolean errorView = false;
        if(exception != null) {
            if(exception instanceof ModelAndViewDefiningException) {
                this.logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException)exception).getModelAndView();
            } else {
                Object handler = mappedHandler != null?mappedHandler.getHandler():null;
                mv = this.processHandlerException(request, response, handler, exception);
                errorView = mv != null;
            }
        }

        if(mv != null && !mv.wasCleared()) {
            this.render(mv, request, response);
            if(errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        } else if(this.logger.isDebugEnabled()) {
            this.logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + this.getServletName() + "': assuming HandlerAdapter completed request handling");
        }

        if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if(mappedHandler != null) {
                // 调用了拦截哭的interceptor.afterCompletion(request, response, this.handler, ex);
                mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
            }

        }
    }

最后，过了FilterChain。调用了StandardContextValve中的

public final void invoke(Request request, Response response) throws IOException, ServletException {
        MessageBytes requestPathMB = request.getRequestPathMB();
        if(!requestPathMB.startsWithIgnoreCase("/META-INF/", 0) && !requestPathMB.equalsIgnoreCase("/META-INF") && !requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0) && !requestPathMB.equalsIgnoreCase("/WEB-INF")) {
            Wrapper wrapper = request.getWrapper();
            if(wrapper != null && !wrapper.isUnavailable()) {
                try {
                    response.sendAcknowledgement();
                } catch (IOException var6) {
                    this.container.getLogger().error(sm.getString("standardContextValve.acknowledgeException"), var6);
                    request.setAttribute("javax.servlet.error.exception", var6);
                    response.sendError(500);
                    return;
                }

                if(request.isAsyncSupported()) {
                    request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
                }

                wrapper.getPipeline().getFirst().invoke(request, response);
            } else {
                response.sendError(404);
            }
        } else {
            response.sendError(404);
        }
    }

后续还应该有挺多内容，在（二）中更吧，一写的比较粗糙。

dydm_13128
关注
专栏目录
SpringBoot请求处理过程
Louzen
08-01 507
SpringBoot 请求处理过程
Spring Cloud之（十九）微服务的链路追踪
qq_50994235的博客
09-27 777
十九、微服务的链路追踪 19.1 微服务架构下的问题 在大型系统的微服务化构建中，一个系统会被拆分成许多模块。这些模块负责不同的功能，组合成系统，最终可以提供丰富的功能。在这种架构中，一次请求往往需要涉及到多个服务。互联网应用构建在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言来实现、有可能布在了几千台服务器，横跨多个不同的数据中心，也就意味着这种架构形式也会存在一些问题： 如何快速发现问题？ 如何判断故障影响范围？ 如何梳理服务依赖以及依赖的合理性？ 如何分析链路性能
配置spring boot actuator跟踪 http 请求
allway2的博客
11-22 736
在这篇文章中，我们将在弹簧启动执行器的帮助下跟踪 http 请求。
Spring Boot 中使用 MDC 追踪一次请求全过程
热门推荐
carl.zhao的专栏
10-31 1万+
MDC 的全称是 Mapped Diagnostic Context，映射诊断上下文(MDC)。本质上是由日志框架维护的映射，其中应用程序代码提供键-值对，然后日志框架可以在日志消息中插入这些键-值对。MDC数据在过滤消息或触发某些操作方面也非常有用。管理开销。 SLF4J支持MDC，即映射的诊断上下文。如果底层日志框架提供MDC功能，那么SLF4J将委托给底层框架的MDC。注意，此时，只有log4j和logback提供MDC功能。如果底层框架不提供MDC，例如java.util。日志记录后，SLF4J仍将
SpringMvc源码记录之请求执行流程
qq_18634003的博客
01-28 218
在SpringMvc启动以及加载过程中以及讲到Spring启动加载过程，现在看下以及请求进来的过程以及数据流转过程，首先在看源码之前简单对SpringMvc请求过程有一个简单的大方向的了解：  第一步就是获取，然后在Web Spring获取后根据request 中url来从HandlerMap查询Handler 第二步 请求数据经过DispatchServerlet 通过request...
基于Spring MVC的物流跟踪系统.zip
最新发布
09-02
物流跟踪系统是一个基于Spring MVC框架开发的Web应用，专注于提供物流信息的实时跟踪和管理。该项目包含了多个模块，涵盖了从客户管理到物流节点跟踪的全流程。 主要功能模块 客户管理 CustomerController....
在Spring MVC或Spring Boot中使用Filter打印请求参数问题
12-21
Spring提供了`OncePerRequestFilter`抽象类，它是对传统`Filter`的一个封装，确保每个请求只被过滤一次，避免了在多线程环境下的并发问题。然而，如果在处理JSON类型的POST请求时，直接在Filter中打印请求参数，可能...
个人学校项目（Java Spring Boot MVC）-家庭预算跟踪器.zip
02-02
【标题】中的“个人学校项目（Java Spring Boot MVC）-家庭预算跟踪器”表明这是一个使用Java编程语言，基于Spring Boot框架，并且应用了MVC设计模式的个人学习项目。这个项目的目标是创建一个家庭预算跟踪器，帮助...
基于Spring + Spring MVC + MyBatis的图书馆管理系统
12-18
《构建基于Spring + Spring MVC + MyBatis的图书馆管理系统》 图书馆管理系统是信息化时代图书馆管理的重要工具，它能够高效地实现图书的查询、管理、编辑，以及读者的管理和服务。本系统采用Java语言，结合Spring...
SpringMVC一次请求过程
做个码农挺好的
09-04 597
SpringMVC一次请求响应的大致过程
SpringMVC3-处理-源码跟踪
dark
08-07 763
之前分析了，SpringMVC启动-源码跟踪，这里分析下SpringMVC是如何处理请求的。我们知道Servlet的处理请求的入口方法是： public void service(ServletRequest req, ServletResponse res); 以一个Http get请求为例，绘制如下流程图： 首先请求的入口是HttpServlet#service(ServletRe...
Spring Boot 实现日志追踪
yangkai100522208的博客
06-13 1853
所以想将同一个请求的所有相关日志当上一个唯一标记，便于进行区分与分析。新开线程或线程池中线程的MDC上下文无法获取到主线程中的traceId，需要重写，再创建新线程或者线程池启动新线程之前，复制主线程的 traceId，并创建新线程的spanId。1, 假如我们需要分析用户 a 的请求日志，但是程序的访问量很大，还有 b、c、d 用户同时访问，无法确定哪一条日志是 a 用户的请求。存储日志数据，所以它是线程安全的，它可以把同一个请求的日志都存储一个相同的值，每次打印日志的时候，会自动打印出当前日志的键值。
Spring Boot提供的产品就绪功能：跟踪（Tracing）
听海边涛声
02-21 1605
Spring Boot提供的产品就绪功能：跟踪（Tracing）
spring一次请求的过程学习-springboot
zhuping2002的专栏
02-01 395
一.简介 注（springboot版本2.0.4.Release） 基于Factories机制Springboot自动装配DispatcherServlet是由spring-boot-autoconfigure-2.0.4.RELEASE.jar中的spring.factories中 的org.springframework.boot.autoconfigure.web.servlet....
如何使用 CommonsRequestLoggingFilter 在 Spring 引导中跟踪 HTTP 请求
allway2的博客
11-22 1419
它可以作为 Bean 添加到任何配置类中。另一方面，如果要以流的形式接收HTTP请求，可以通过扩展。请注意，当您处理输入流时，您不能将它们读取两次！跟踪传入的 HTTP 请求。最简单的选择之一是使用。本教程展示了如何使用。
SpringBoot如何实现全链路调用日志跟踪
dongbeiou的专栏
06-05 4080
1SpringBoot如何实现全链路调用日志跟踪 MDC介绍 简介： MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 、logback及log4j2 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适...
Spring Boot项目如何实现分布式日志链路追踪
m0_71777195的博客
07-04 852
以上全部就是关于Spring Boot如何实现分布式日志链路追踪的相关知识点。工欲善其事，必先利其器，我们要想快速通过日志定位系统问题，就必须通过traceId高效查找一次请求的全部上下文日志，包括异步执行的逻辑。
SpringBoot中如何实现全链路调用日志跟踪？这种方法才叫优雅
王不困的博客
04-07 765
MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 、logback及log4j2 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。
SpringMvc打断点看请求执行过程
weixin_42490383的博客
06-29 1162
web.xml //1. 拦截所有请求 <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> //2. 交给DispatcherServlet处理 <servlet> <servlet-name>springmvc</servlet-name.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值