SpringMVC源码分析-ViewResolver

快来打我* 2022-05-15 04:54 262阅读 0赞

ViewResolver的主要作用是根据视图名和Locale解析出视图，解析过程主要做了两件事，解析出使用的模板和视图的类型。ViewResolver的继承结构图如下所示：

![70][]

SpringMVC中的ViewResolver整体可以分为四大类：AbstractCachingViewResolver、BeanNameViewResovler、ContentNegotiatingViewResolver和ViewResolverComposite。其中后三类每一类都只有一个实现类，而AbstractCachingViewResolver却一家独大，因为这个类下面可以缓存解析过的视图的基类，而逻辑视图和视图的关系一般是不变的，所以不需要每一都重新解析，最好解析一次就缓存起来，

** 1.BeanNameViewResolver**是使用逻辑视图作为beanName从SpringMVC容器中查找。

** 2. ViewResolverComposite**是一个封装着多个ViewResolver的容器，解析视图时遍历封装着的ViewResolver具体解析，不过ViewResolverComposite除了遍历成员解析视图外还给成员进行了必要的初始化，其中包括对实现了ApplicationContextAware接口的ViewResolver设置ApplicationContext、是给实现了ServletContextAware接口的ViewResolver设置ServletContext以及对实现了InitializingBean接口的ViewResolver调用afterPropertiesSet方法。

源码：

public class ViewResolverComposite implements ViewResolver, Ordered, InitializingBean, ApplicationContextAware, ServletContextAware {
        private final List<ViewResolver> viewResolvers = new ArrayList();
        private int order = 2147483647;
    
        public ViewResolverComposite() {
        }
    
        public void setViewResolvers(List<ViewResolver> viewResolvers) {
            this.viewResolvers.clear();
            if (!CollectionUtils.isEmpty(viewResolvers)) {
                this.viewResolvers.addAll(viewResolvers);
            }
    
        }
    
        public List<ViewResolver> getViewResolvers() {
            return Collections.unmodifiableList(this.viewResolvers);
        }
    
        public void setOrder(int order) {
            this.order = order;
        }
    
        public int getOrder() {
            return this.order;
        }
    
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            Iterator var2 = this.viewResolvers.iterator();
    
            while(var2.hasNext()) {
                ViewResolver viewResolver = (ViewResolver)var2.next();
                if (viewResolver instanceof ApplicationContextAware) {
                    ((ApplicationContextAware)viewResolver).setApplicationContext(applicationContext);
                }
            }
    
        }
    
        public void setServletContext(ServletContext servletContext) {
            Iterator var2 = this.viewResolvers.iterator();
    
            while(var2.hasNext()) {
                ViewResolver viewResolver = (ViewResolver)var2.next();
                if (viewResolver instanceof ServletContextAware) {
                    ((ServletContextAware)viewResolver).setServletContext(servletContext);
                }
            }
    
        }
    
        public void afterPropertiesSet() throws Exception {
            Iterator var1 = this.viewResolvers.iterator();
    
            while(var1.hasNext()) {
                ViewResolver viewResolver = (ViewResolver)var1.next();
                if (viewResolver instanceof InitializingBean) {
                    ((InitializingBean)viewResolver).afterPropertiesSet();
                }
            }
    
        }
    
        //主要是这个方法用来解析View的
        @Nullable
        public View resolveViewName(String viewName, Locale locale) throws Exception {
            Iterator var3 = this.viewResolvers.iterator();
    
            View view;
            do {
                if (!var3.hasNext()) {
                    return null;
                }
    
                ViewResolver viewResolver = (ViewResolver)var3.next();
                view = viewResolver.resolveViewName(viewName, locale);
            } while(view == null);
    
            return view;
        }
    }

## 3.ContentNegotiatingViewResolver ##

这个解析器的作用就是在别的解析器解析的结果上增加了对MediaType和后缀的支持，MediaType即媒体类型，有的地方页脚Content-Type，比如常用的text/html、text/javascript以及表示上传表单的multipart/form-data等。对视图的解析不是它本身完成的而是通过封装的ViewResolver来进行的。

整个过程：首先遍历所封装的ViewResolver具体解析视图，可能会解析出多个视图，然后再使用request获取MediaType，也可能有多个结果，然后这两个结果进行匹配找出最优视图。

属性中的ViewResolvers有两种初始化方式：一种是手动设置，另外一种是如果没有设置则自动获取spring容器中除了他自己外的所有ViewResolver并设置到ViewResolver中，如果是手动设置的，而且不在spring容器中，会对它进行初始化，

代码如下：

protected void initServletContext(ServletContext servletContext) {
            //获取容器中所有的ViewResolver类型的bean，是整个spring容器，而不仅仅是springMVC
            Collection<ViewResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.obtainApplicationContext(), ViewResolver.class).values();
            ViewResolver viewResolver;
            //如果没有手动注册则将容器中找到的ViewResolver设置给ViewResolvers
            if (this.viewResolvers == null) {
                this.viewResolvers = new ArrayList(matchingBeans.size());
                Iterator var3 = matchingBeans.iterator();
    
                while(var3.hasNext()) {
                    viewResolver = (ViewResolver)var3.next();
                    if (this != viewResolver) {
                        this.viewResolvers.add(viewResolver);
                    }
                }
            } else {
                 //如果是手动注册，但是容器中不存在，则进行初始化
                for(int i = 0; i < this.viewResolvers.size(); ++i) {
                    viewResolver = (ViewResolver)this.viewResolvers.get(i);
                    if (!matchingBeans.contains(viewResolver)) {
                        String name = viewResolver.getClass().getName() + i;
                        this.obtainApplicationContext().getAutowireCapableBeanFactory().initializeBean(viewResolver, name);
                    }
                }
            }
    
            if (this.viewResolvers.isEmpty()) {
                this.logger.warn("Did not find any ViewResolvers to delegate to; please configure them using the 'viewResolvers' property on the ContentNegotiatingViewResolver");
            }
            //按照Order属性进行排序
            AnnotationAwareOrderComparator.sort(this.viewResolvers);
            this.cnmFactoryBean.setServletContext(servletContext);
        }

**解析视图的方法源码如下：**

@Nullable
        public View resolveViewName(String viewName, Locale locale) throws Exception {
            //使用RequestContextHolder获取RequestAttribute，进而获取request
            RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
            Assert.state(attrs instanceof ServletRequestAttributes, "No current ServletRequestAttributes");
            //通过request获取MediaType,用作需要满足的条件
            List<MediaType> requestedMediaTypes = this.getMediaTypes(((ServletRequestAttributes)attrs).getRequest());
            if (requestedMediaTypes != null) {
                //获取所有的候选视图，内部通过遍历封装的viewResolver来解析
                List<View> candidateViews = this.getCandidateViews(viewName, locale, requestedMediaTypes);
                //从多个候选视图中选出最好的一个
                View bestView = this.getBestView(candidateViews, requestedMediaTypes, attrs);
                if (bestView != null) {
                    return bestView;
                }
            }
    
            if (this.useNotAcceptableStatusCode) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("No acceptable view found; returning 406 (Not Acceptable) status code");
                }
    
                return NOT_ACCEPTABLE_VIEW;
            } else {
                this.logger.debug("No acceptable view found; returning null");
                return null;
            }
        }

其中从多个候选图获取最好的视图的方法源码：

private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes, RequestAttributes attrs) {
            Iterator var4 = candidateViews.iterator();
            //判断候选视图中有没有redirect视图，如果有直接返回
            while(var4.hasNext()) {
                View candidateView = (View)var4.next();
                if (candidateView instanceof SmartView) {
                    SmartView smartView = (SmartView)candidateView;
                    if (smartView.isRedirectView()) {
                        if (this.logger.isDebugEnabled()) {
                            this.logger.debug("Returning redirect view [" + candidateView + "]");
                        }
    
                        return candidateView;
                    }
                }
            }
    
            var4 = requestedMediaTypes.iterator();
    
            while(var4.hasNext()) {
                MediaType mediaType = (MediaType)var4.next();
                Iterator var10 = candidateViews.iterator();
    
                while(var10.hasNext()) {
                    View candidateView = (View)var10.next();
                    if (StringUtils.hasText(candidateView.getContentType())) {
                        //根据候选视图获取对应的MediaType
                        MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
                        //判断当前MediaType是否支持从候选视图获取对应的MediaType,如text/*可以支持test/html,text/css,text/xml等所有的text类型
                        if (mediaType.isCompatibleWith(candidateContentType)) {
                            if (this.logger.isDebugEnabled()) {
                                this.logger.debug("Returning [" + candidateView + "] based on requested media type '" + mediaType + "'");
                            }
    
                            attrs.setAttribute(View.SELECTED_CONTENT_TYPE, mediaType, 0);
                            return candidateView;
                        }
                    }
                }
            }
    
            return null;
        }

## 4.AbstractCachingViewResolver ##

这个解析器提供统一的缓存功能干呢个，当视图解析过一次就被缓存起来，缓存被删除前视图解析都会从缓存中获取。

它的直接继承类有三个：**ResourceBundleViewResolver、XmlViewResolver和UrlBasedViewResolver。**

*  ResourceBundleViewResolver是通过使用properties属性配置文件解析视图；
 *  XmlViewResolver是通过xml配置文件解析视图
 *  UrlBasedViewResolver是所有直接将逻辑视图作为url查找模板文件的ViewResolver的基类，这个类设置了统一的查找模板的规则，它的子类只需要确定渲染方式就可以确定视图类型，它的每一个子类都对应一种视图类型。

###  4.1 AbstractCachingViewResolver 解析视图 ###

这个抽象类中有一个cacheLimit参数，他是用来设置最大缓存书的，当设置为0时不启用缓存，isCache就是判断是否大于0，如果设置为一个大于0的数则表示最多可以缓存视图的数量，如果往里面添加视图超过了这个数那么最前面缓存的值将删除，其中LinkedHashMap中removeEldestEntry方法可以在返回true时，超过给定大小就会删除最前面的值，具体百度。

解析视图源码：

public View resolveViewName(String viewName, Locale locale) throws Exception {
            //是否有缓存
            if (!this.isCache()) {
                return this.createView(viewName, locale);//创建视图
            } else {
                Object cacheKey = this.getCacheKey(viewName, locale);
                //这里是通过concurrentHashMap的容器中获取的缓存
                View view = (View)this.viewAccessCache.get(cacheKey);
                if (view == null) {
                    Map var5 = this.viewCreationCache;
                    synchronized(this.viewCreationCache) {
                        view = (View)this.viewCreationCache.get(cacheKey);
                        if (view == null) {
                            //创建视图
                            view = this.createView(viewName, locale);
                            if (view == null && this.cacheUnresolved) {
                                view = UNRESOLVED_VIEW;
                            }
    
                            if (view != null) {
                                //这里同时在创建视图后存入缓存中，这里放到两个容器中了
                                this.viewAccessCache.put(cacheKey, view);
                                this.viewCreationCache.put(cacheKey, view);
                                if (this.logger.isTraceEnabled()) {
                                    this.logger.trace("Cached view [" + cacheKey + "]");
                                }
                            }
                        }
                    }
                }
    
                return view != UNRESOLVED_VIEW ? view : null;
            }
        }
    
        @Nullable
        protected View createView(String viewName, Locale locale) throws Exception {
            return this.loadView(viewName, locale);
        }
        //这是一个模板方法由子类实现
        @Nullable
        protected abstract View loadView(String var1, Locale var2) throws Exception;

###      4.2 UrlBasedViewResolver ###

这个重写了父类的getCacheKey、createView和loadView三个方法。

** getCacheKey方法**直接返回viewName，和原来父类的返回viewName+“\_”+locale相比，子类覆盖而没有使用locale，说明这个UrlBasedViewResolver并没有使用Locale，只是用viewName。

源码：

protected Object getCacheKey(String viewName, Locale locale) {
            return viewName;
        }

**createView源码**：

protected View createView(String viewName, Locale locale) throws Exception {
            //检查是否支持此逻辑视图，可以配置支持的模板
            if (!this.canHandle(viewName, locale)) {
                return null;
            } else {
                String forwardUrl;
                //检查是不是redirect视图
                if (viewName.startsWith("redirect:")) {
                    forwardUrl = viewName.substring("redirect:".length());
                    RedirectView view = new RedirectView(forwardUrl, this.isRedirectContextRelative(), this.isRedirectHttp10Compatible());
                    String[] hosts = this.getRedirectHosts();
                    if (hosts != null) {
                        view.setHosts(hosts);
                    }
    
                    return this.applyLifecycleMethods(viewName, view);
                //检查是不是forward视图
                } else if (viewName.startsWith("forward:")) {
                    forwardUrl = viewName.substring("forward:".length());
                    return new InternalResourceView(forwardUrl);
                } else {
                    //如果都不是则调用父类的createView，也就会调用loadView()方法
                    return super.createView(viewName, locale);
                }
            }
        }

**loadView源码：**

protected View loadView(String viewName, Locale locale) throws Exception {
            //创建view
            AbstractUrlBasedView view = this.buildView(viewName);
            初始化view
            View result = this.applyLifecycleMethods(viewName, view);
            //检查模板是否存在，存在则返回，否则返回null
            return view.checkResource(locale) ? result : null;
        }
        
        protected AbstractUrlBasedView buildView(String viewName) throws Exception {
            Class<?> viewClass = this.getViewClass();
            Assert.state(viewClass != null, "No view class");
            AbstractUrlBasedView view = (AbstractUrlBasedView)BeanUtils.instantiateClass(viewClass);
            //这里给viewName加上前缀和后缀，可以通过配置设置
            view.setUrl(this.getPrefix() + viewName + this.getSuffix());
            String contentType = this.getContentType();
            if (contentType != null) {
                //contentType不为空设置给view
                view.setContentType(contentType);
            }
    
            view.setRequestContextAttribute(this.getRequestContextAttribute());
            view.setAttributesMap(this.getAttributesMap());
            Boolean exposePathVariables = this.getExposePathVariables();
            if (exposePathVariables != null) {
                //这个表示让view使用PathVariables,可以在ViewResolver中设置，PathVariable就是处理器中@PathVariables注释的参数
                view.setExposePathVariables(exposePathVariables);
            }
    
            Boolean exposeContextBeansAsAttributes = this.getExposeContextBeansAsAttributes();
            if (exposeContextBeansAsAttributes != null) {
                //这个不为空的时候设置给view，表示让view使用容器中注册的bean，此参数可以在ViewResolver中配置
                view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
            }
    
            String[] exposedContextBeanNames = this.getExposedContextBeanNames();
            if (exposedContextBeanNames != null) {
                //这个不为空的时候设置给view，表示让view使用容器中注册的bean，此参数可以在ViewResolver中配置
                view.setExposedContextBeanNames(exposedContextBeanNames);
            }
    
            return view;
        }

上面方法Class<?> viewClass = this.getViewClass();可以在子类通过setViewClass()方法从新设置viewClass类型，另外还有一个requiredViewClass方法，它用于在设置视图时判断所设置的类型是否支持。UrlBasedViewResolver默认返回的AbstractUrlBasedView类型。源码如下：

public void setViewClass(@Nullable Class<?> viewClass) {
            if (viewClass != null && !this.requiredViewClass().isAssignableFrom(viewClass)) {
                throw new IllegalArgumentException("Given view class [" + viewClass.getName() + "] is not of type [" + this.requiredViewClass().getName() + "]");
            } else {
                this.viewClass = viewClass;
            }
        }
    
        @Nullable
        protected Class<?> getViewClass() {
            return this.viewClass;
        }
    
        protected Class<?> requiredViewClass() {
            return AbstractUrlBasedView.class;
        }

***补充：***

UrlBasedViewResolver的子类主要做三件事：

*  通过重写requiredViewClass方法修改了必须符合视图类型的值；
 *  使用setViewClass方法设置了使用的视图类型；
 *  给创建出来的视图设置一些属性
 *

###  4.3 InternalResourceViewResolver和FreeMarkerViewResolver ###

这两个都是继承UrlBasedViewResolver，前者用来解析jsp，后者用来解析FreeMarker视图。

###     4.3.1 InternalResourceViewResolver源码，相关注释也在其中： ###

public class InternalResourceViewResolver extends UrlBasedViewResolver {
        private static final boolean jstlPresent = ClassUtils.isPresent("javax.servlet.jsp.jstl.core.Config", InternalResourceViewResolver.class.getClassLoader());
        @Nullable
        private Boolean alwaysInclude;
        //这里如果类型是jstlPresent，viewClass会使用JstlView.class
        public InternalResourceViewResolver() {
            Class<?> viewClass = this.requiredViewClass();
            if (InternalResourceView.class == viewClass && jstlPresent) {
                viewClass = JstlView.class;
            }
    
            this.setViewClass(viewClass);
        }
    
        public InternalResourceViewResolver(String prefix, String suffix) {
            this();
            this.setPrefix(prefix);
            this.setSuffix(suffix);
        }
        //返回的类型是InternalResourceView  
        protected Class<?> requiredViewClass() {
            return InternalResourceView.class;
        }
    
        public void setAlwaysInclude(boolean alwaysInclude) {
            this.alwaysInclude = alwaysInclude;
        }
        //新添加了alwaysInclude属性
        protected AbstractUrlBasedView buildView(String viewName) throws Exception {
            InternalResourceView view = (InternalResourceView)super.buildView(viewName);
            //这个表示是否在使用forward的情况下也强制使用include，默认是false，可以在注册解析器时配置
            if (this.alwaysInclude != null) {
                view.setAlwaysInclude(this.alwaysInclude);
            }
            //用于阻止循环调用，也就是请求处理完成后又转发回了原来使用的处理器的情况
            view.setPreventDispatchLoop(true);
            return view;
        }
    }

###       4.3.2 FreeMarkerViewResolver  ###

这个类继承UrlBasedViewResolver的子类AbstractTemplateViewResolver，AbstractTemplateViewResolver是所用模板ViewResolver的父类，它里面主要对创建的View设置一些属性，并将requiredViewClass的返回值设置为AbstractTemplateView类型。

**1）AbstractTemplateViewResolver源码：**

public class AbstractTemplateViewResolver extends UrlBasedViewResolver {
        private boolean exposeRequestAttributes = false;
        private boolean allowRequestOverride = false;
        private boolean exposeSessionAttributes = false;
        private boolean allowSessionOverride = false;
        private boolean exposeSpringMacroHelpers = true; 
        //...setter和getter方法
    
       protected AbstractUrlBasedView buildView(String viewName) throws Exception {
            AbstractTemplateView view = (AbstractTemplateView)super.buildView(viewName);
            //是否将requestAttributes暴露给view，默认为false
            view.setExposeRequestAttributes(this.exposeRequestAttributes);
            //当requestAttributes中存在Model中同名的参数，是否允许将Model中的值覆盖，默认false
            view.setAllowRequestOverride(this.allowRequestOverride);
            //是否将SessionAttribute暴露给view使用，默认是false
            view.setExposeSessionAttributes(this.exposeSessionAttributes);
            //当SessionAttributes中存在Model中同名的参数，是否使用requestAttributes的值将Model中的覆盖，默认false
            view.setAllowSessionOverride(this.allowSessionOverride);
            view.setExposeSpringMacroHelpers(this.exposeSpringMacroHelpers);
            return view;
        }
    }

**        2）FreeMarkerViewResolver 源码： **

**             ** 这个只需要覆盖requiredViewClass方法就返回freeMakerView类型，如下：    **       **

public class FreeMarkerViewResolver extends AbstractTemplateViewResolver {
        public FreeMarkerViewResolver() {
            this.setViewClass(this.requiredViewClass());
        }
    
        public FreeMarkerViewResolver(String prefix, String suffix) {
            this();
            this.setPrefix(prefix);
            this.setSuffix(suffix);
        }
    
        protected Class<?> requiredViewClass() {
            return FreeMarkerView.class;
        }
    }

### 总结： ###

大部分实现类都是继承AbstractCachingViewResolver，他提供了对解析结果进行缓存的统一解决方法，他的子类中ResourceBundlerViewResolver和XmlViewResolver分别通过properties和xml配置文件进行解析。UrlBasedViewResolver将viewName添加前后缀用作url，他的子类只需要提供视图类型就可以了。

除了AbstractCachingViewResolver，还有三个类，BeanNameViewResolver、ContentNegotiatingViewResolver和ViewResolverComposite。第一个是通过在Spring容器里使用viewName查找bean来作为View；第二个是使用内部封装的ViewResolver解析后再根据MediaType或者后缀找出最优的视图；第三个直接遍历内部封装的ViewResolver进行解析。这三个都是不需要缓存的。

解析视图的核心工作是查找模板文件和视图类型，而查找的主要参数只有viewName，有三种解析思路：

*  使用viewName查找模板文件---对应URLBasedViewResolver；
 *  使用viewName查找视图类型--对应BeanNameViewResolver；
 *  使用viewName同时查找视图类型和模板文件--对应ResourceBundlerViewResolver和XmlViewResolver；

[70]: /images/20220515/78c65f1f47de49cebb02d28f839760d8.png