Spring源码学习25

最新推荐文章于 2024-11-21 05:30:00 发布
原创 最新推荐文章于 2024-11-21 05:30:00 发布 · 244 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring源码 #MVC


1.SpringMVC十大核心对象

接口使用场景实现类参考博客
MultipartResolver用于解析文件上传CommonsMultipartResolver 
StandardServletMultipartResolver 
LocaleResolver用于国际化CookieLocaleResolver 
FixedLocaleResolver 
AcceptHeaderLocaleResolver 
SessionLocaleResolver 
ThemeResolver用户控制页面主题风格FixedThemeResolver 
SessionThemeResolver 
CookieThemeResolver 
HandlerMapping用于为一个请求找到处理类或者处理方法BeanNameUrlHandlerMappinghttps://blog.youkuaiyun.com/qq_23536449/article/details/99944430
SimpleUrlHandlerMappinghttps://blog.youkuaiyun.com/qq_23536449/article/details/99944430
RequestMappingHandlerMappinghttps://blog.youkuaiyun.com/qq_23536449/article/details/99944430
HandlerAdapter适配请求处理对象，调用处理器的方法处理请求SimpleMappingExceptionResolver 
RequestMappingHandlerAdapter 
SimpleControllerHandlerAdapter 
HandlerExceptionResolver异常解析处理器，比如给异常返回状态码、返回json文件、返回到某个错误页面ExceptionHandlerExceptionResolver 
DefaultHandlerExceptionResolver 
ResponseStatusExceptionResolver 
RequestToViewNameTranslator在返回view为空时，它能够根据request请求获得viewNameDefaultRequestToViewNameTranslator 
ViewResolver视图解析器，把逻辑视图名称解析为View对象InternalResourceViewResolver 
UrlBasedViewResolver 
BeanNameViewResolver 
ViewResolverComposite 
XmlViewResolver 
FlashMapManager重定向请求传参用获取上一个request的参数信息SessionFlashMapManager 
View视图展示，比如jsp、html、excel、pdf都是视图InternalResourceView 
JstlView 
AbstractPdfView 
AbstractXlsView 

 2.核心对象的初始化

/**
     * 初始化此servlet使用的策略对象。
     * <p>可以在子类中重写以初始化其他策略对象。
     */
    protected void initStrategies(ApplicationContext context) {
        //用于解析文件上传
        initMultipartResolver(context);
        //用于配置国际化
        initLocaleResolver(context);
        //用于控制主题页面的风格
        initThemeResolver(context);
        //用于为一个请求找到处理类或者处理方法
        initHandlerMappings(context);
        //适配请求处理对象，调用处理器的方法处理请求
        initHandlerAdapters(context);
        //异常解析处理器，比如给异常返回状态码、返回json文件、返回到某个错误页面
        initHandlerExceptionResolvers(context);
        //在返回view为空时，它能够根据request请求获得viewName
        initRequestToViewNameTranslator(context);
        //视图解析器，把逻辑视图名称解析为View对象
        initViewResolvers(context);
        //重定向请求传参用获取上一个request的参数信息
        initFlashMapManager(context);
    }

a.初始化MultipartResolver对象

 /**
     * 初始化此类使用的MultipartResolver
     * <p>如果没有在BeanFactory中为此命名空间定义具有给定名称的bean，则不提供Multipart的处理。
     */
    private void initMultipartResolver(ApplicationContext context) {
        try {
            this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // Default is no multipart resolver.
            this.multipartResolver = null;
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
                        "': no multipart request handling provided");
            }
        }
    }

b.初始化LocaleResolver

/**
     * 初始化此类使用的LocaleResolver。
     * <p>如果在此命名空间的BeanFactory中没有使用给定名称定义bean，则默认为AcceptHeaderLocaleResolver。
     */
    private void initLocaleResolver(ApplicationContext context) {
        try {
            this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using LocaleResolver [" + this.localeResolver + "]");
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // We need to use the default.
            // 创建默认的哎嘿嘿
            this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate LocaleResolver with name '" + LOCALE_RESOLVER_BEAN_NAME +
                        "': using default [" + this.localeResolver + "]");
            }
        }
    }

c.初始化ThemeResolver

/**
     * 初始化此类使用的ThemeResolver。
     * <p>如果在此命名空间的BeanFactory中没有使用给定名称定义bean，则默认为FixedThemeResolver。
     */
    private void initThemeResolver(ApplicationContext context) {
        try {
            this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using ThemeResolver [" + this.themeResolver + "]");
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // 从
            this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate ThemeResolver with name '" + THEME_RESOLVER_BEAN_NAME +
                        "': using default [" + this.themeResolver + "]");
            }
        }
    }

d.初始化HandlerMappings

/**
     * 初始化此类使用的HandlerMappings。
     * <p>如果没有在BeanFactory中为此命名空间定义HandlerMapping bean，我们默认为BeanNameUrlHandlerMapping。
     */
    private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;

        if (this.detectAllHandlerMappings) {
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerMapping> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        } else {
            try {
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerMapping later.
            }
        }

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
        if (this.handlerMappings == null) {
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
            }
        }
    }

e.初始化HandlerAdapters

 /**
     * Initialize the HandlerAdapters used by this class.
     * <p>If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
     * we default to SimpleControllerHandlerAdapter.
     */
    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;

        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerAdapter> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        } else {
            try {
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                this.handlerAdapters = Collections.singletonList(ha);
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerAdapter later.
            }
        }

        // Ensure we have at least some HandlerAdapters, by registering
        // default HandlerAdapters if no other adapters are found.
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
            }
        }
    }

f.初始化HandlerExceptionResolvers

/**
     * 初始化此类使用的HandlerExceptionResolver。
     * <p>如果在此命名空间的BeanFactory中没有使用给定名称定义bean，则默认情况下不会出现异常解析程序。
     */
    private void initHandlerExceptionResolvers(ApplicationContext context) {
        this.handlerExceptionResolvers = null;

        if (this.detectAllHandlerExceptionResolvers) {
            // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
                    .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
                // We keep HandlerExceptionResolvers in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
            }
        } else {
            try {
                HandlerExceptionResolver her =
                        context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
                this.handlerExceptionResolvers = Collections.singletonList(her);
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, no HandlerExceptionResolver is fine too.
            }
        }

        // Ensure we have at least some HandlerExceptionResolvers, by registering
        // default HandlerExceptionResolvers if no other resolvers are found.
        if (this.handlerExceptionResolvers == null) {
            this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No HandlerExceptionResolvers found in servlet '" + getServletName() + "': using default");
            }
        }
    }

g.初始化RequestToViewNameTranslator对象

/**
     * 初始化此servlet实例使用的RequestToViewNameTranslator。
     * <p>如果未配置任何实现，则默认为DefaultRequestToViewNameTranslator。
     */
    private void initRequestToViewNameTranslator(ApplicationContext context) {
        try {
            this.viewNameTranslator =
                    context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using RequestToViewNameTranslator [" + this.viewNameTranslator + "]");
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // We need to use the default.
            this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate RequestToViewNameTranslator with name '" +
                        REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME + "': using default [" + this.viewNameTranslator +
                        "]");
            }
        }
    }

h.初始化ViewResolvers

 /**
     * 初始化此类使用的ViewResolvers。
     * <p>如果没有为此命名空间的BeanFactory定义ViewResolver bean，我们默认为InternalResourceViewResolver。
     */
    private void initViewResolvers(ApplicationContext context) {
        this.viewResolvers = null;

        if (this.detectAllViewResolvers) {
            // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
            Map<String, ViewResolver> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());
                // We keep ViewResolvers in sorted order.
                AnnotationAwareOrderComparator.sort(this.viewResolvers);
            }
        } else {
            try {
                ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
                this.viewResolvers = Collections.singletonList(vr);
            } catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default ViewResolver later.
            }
        }

        // Ensure we have at least one ViewResolver, by registering
        // a default ViewResolver if no other resolvers are found.
        if (this.viewResolvers == null) {
            this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default");
            }
        }
    }

i.初始化FlashMapManager对象

/**
     * 初始化此servlet实例使用的{@link FlashMapManager}。
     * <p>如果没有配置任何实现，那么我们默认为{@code org.springframework.web.servlet.support.SessionFlashMapManager}。
     */
    private void initFlashMapManager(ApplicationContext context) {
        try {
            this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using FlashMapManager [" + this.flashMapManager + "]");
            }
        } catch (NoSuchBeanDefinitionException ex) {
            // We need to use the default.
            this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate FlashMapManager with name '" +
                        FLASH_MAP_MANAGER_BEAN_NAME + "': using default [" + this.flashMapManager + "]");
            }
        }
    }

3.SpringMVC默认给DispatcherSerlvet的九大对象提供的默认值通过如下方法获取

/**
 * 返回给定策略接口的默认策略对象。
 * <p>默认实现委托给{@link #getDefaultStrategies}，期望列表中有一个对象。
 *
 * @param context           the current WebApplicationContext
 * @param strategyInterface the strategy interface
 * @return the corresponding strategy object
 * @see #getDefaultStrategies
 */
protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
    List<T> strategies = getDefaultStrategies(context, strategyInterface);
    if (strategies.size() != 1) {
        throw new BeanInitializationException(
                "DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
    }
    return strategies.get(0);
}

 protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
        //class 名称
        String key = strategyInterface.getName();
        //从DispatcherServlet.properties配置文件寻找className对应的类
        String value = defaultStrategies.getProperty(key);
        if (value != null) {
            //按逗号切分
            String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
            List<T> strategies = new ArrayList<T>(classNames.length);
            for (String className : classNames) {
                try {
                    //加载Class对象
                    Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
                    //创建对象
                    Object strategy = createDefaultStrategy(context, clazz);
                    strategies.add((T) strategy);
                } catch (ClassNotFoundException ex) {
                    throw new BeanInitializationException(
                            "Could not find DispatcherServlet's default strategy class [" + className +
                                    "] for interface [" + key + "]", ex);
                } catch (LinkageError err) {
                    throw new BeanInitializationException(
                            "Error loading DispatcherServlet's default strategy class [" + className +
                                    "] for interface [" + key + "]: problem with class file or dependent class", err);
                }
            }
            return strategies;
        } else {
            return new LinkedList<T>();
        }
    }

可以看到都是从defaultStrategies中获取的，我们在DispatcherServlet中找到该属性;并且找到该属性的初始化方法

private static final Properties defaultStrategies;

    static {
        // Load default strategy implementations from properties file.
        // This is currently strictly internal and not meant to be customized
        // by application developers.
        try {
            ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
        } catch (IOException ex) {
            throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
        }
    }

上面方法加载读取DispatcherServlet.properties文件：

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
   org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
   org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
   org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
   org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
   org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
spring的BeanFactoryUtils用法
某某人的博客
02-09 7150
BeanFactoryUtils可以获取bean的实例，其中主要讲解BeanFactoryUtils.beansOfTypeIncludingAncestors(this.getApplicationContext(), ServiceInitializer.class, true, false);通过这个方法可以获取，实现了ServiceInitializer这个接口的类实例，然后就可以使用该类...
SpringMVC源码解析四(处理适配器HandlerAdapter的解析)
AN_ERA的博客
12-24 915
HandlerAdapter继承关系图: DispatcherServlet#getHandlerAdapter()方法实现: protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException { if (this.handlerAdapters != null) { ...
spring源码---mvc:HandlerMapping
阿七
08-12 275
一.接口HandlerMapping public interface HandlerMapping { @Nullable HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception; } 只有一个方法getHandler()，根据request返回一个handlerExecutionChain执行链，该接口还有很多字段。 二. AbstractHandlerMapping H...
【spring】BeanFactoryUtils学习
最新发布
一个写了10年bug的程序员日常笔记。
11-21 642
是 Spring 框架中的一个实用工具类，提供了一些与 BeanFactory 相关的实用方法。它主要用于在 BeanFactory 中查找和管理 Bean，特别是在处理层次化 BeanFactory 时非常有用。
JAVA的@EXCEL导出导入常用注解汇总
你好，我是小新，很高兴认识你！
07-04 4924
JAVA的@EXCEL导出导入常用注解汇总
Spring源码学习加注释，方便学习.zip
05-11
spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文...
SpringStudy:GitHub下载的Spring源码，用于Spring源码学习
03-24
Spring框架 这是Spring框架的所在地：所有的基础。 总体来说，Spring框架和Spring项目系列通常简称为“ Spring”。 Spring提供了Java编程语言以外的所有所需内容，可用于为各种场景和体系结构创建企业应用程序。 请...
spring源码，配套完善的注释
01-15
本压缩包包含了Spring的源码，对于理解Spring的工作原理、深入学习和优化自己的项目具有极大的帮助。 源码分析： 1. **IoC容器**：Spring的核心是IoC容器，它负责管理对象的生命周期和依赖关系。通过XML配置文件或...
spring源码雷神spring源码雷神
08-06
"Spring源码雷神"可能指的是对Spring框架深入源码级别的理解和解析。以下将详细阐述Spring框架的一些核心知识点： 1. **IoC（Inversion of Control）控制反转**：Spring的核心特性之一，它通过依赖注入（Dependency...
spring源码学习之思维导图
05-09
1、spring 的整体架构 2、spring的基本实现（xml的加载原理、标签解析、bean加载） 3、容器扩展 4、ioc和aop 5、事务 6、springmvc 7、dispatcherServlet
SpringMVC启动过程浅析
懋懋之为
03-25 2198
ContextLoaderListener初始化 ContextLoaderListener的作用就是启动web容器时，自动装配ApplicationContext的配置信息。因为它实现了ServletContextListener接口，当web容器启动时，会触发ServletContextListener的contextInitialized方法。 public interface Se...
使用Spring MVC时的常见错误
最佳 Java 编程
05-23 827
当我大约10年前开始我的职业生涯时，Struts MVC就是市场上的常态。 但是，多年来，我观察到Spring MVC逐渐流行起来。 鉴于Spring MVC与Spring容器的无缝集成以及它提供的灵活性和可扩展性，这对我来说并不奇怪。 从到目前为止的Spring旅程中，我通常会看到人们在配置Spring框架时犯了一些常见的错误。 与人们仍然使用Struts框架的时间相比，这种情况发生...
spring基本使用(18)-springMVC2-SpringMVC九大组件的初始化原理分析
qq_34978129的博客
07-30 422
1、上篇博客讲到了SpringMVC的九大组件初始化，我们只看到了在什么时候初始化，并没有进行详细的原理分析，今天我们就来分析一下SpringMVC的九大组件是如何初始化的？？？？？？。 在DispatcherServelt中： protected void initStrategies(ApplicationContext context) { 1、初始化文件上传解析器 this.initMultipartResolver(contex...
Dubbo源码分析（三）：Dubbo之服务端（Service）
flashflight的专栏
03-20 3万+
如上图所示的Dubbo的暴露服务的过程，不难看出它也和消费者端很像，也需要一个像reference的对象来维护service关联的所有对象及其属性，这里的reference就是provider。由于ServiceBean实现了  InitializingBean接口，所有在Spring实例化这个bean后会调用接口方法afterPropertiesSet： public void aft
Dubbo原理简述四：服务暴露、服务引用和调用流程
热门推荐
.... 永远年轻，永远热泪盈眶
01-15 5万+
关于服务暴露，首先需要了解：ServiceBean.java 此类实现了几个Spring中比较重要的接口：如InitializingBean、ApplicationContextAware、ApplicationListener等，查看该类结构图： 接下来分析一下该类的一些主要方法： 在ServiceBean.afterPropertiesSet()方法中，就是将配置文件的各项属性信息都配置到该...
Spring源码阅读-BeanFactory子接口ListableBeanFactory
iycynna_123的博客
10-21 3651
package org.springframework.beans.factory;import java.lang.annotation.Annotation; import java.util.Map;import org.springframework.beans.BeansException; import org.springframework.core.ResolvableType;/*
《spring-boot学习》-01-初体验
九师兄
02-23 1405
1.项目结构如下 2.pox.xml配置<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache
springMVC源码学习之addFlashAttribute源码分析
weixin_30756499的博客
12-03 211
本文主要从falshMap初始化，存，取，消毁来进行源码分析，springmvc版本4.3.18。关于使用及验证请参考另一篇jsp取addFlashAttribute值深入理解即springMVC发redirect传隐藏参数 说明：在action中通过redirectAttributes.addFlashAttribute(userName,"mike")，retrun "redirect:in...
Spring源码中文注释学习资料
资源摘要信息: "Spring源码学习加注释，方便学习.zip" 是一个为学习和理解Spring框架源码提供的资源包。该资源通过添加中文注释的方式，旨在降低学习者对Spring源码的阅读难度，提供一种更直观的学习方式。Spring是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值