WebMvcAutoConfiguration源代码

最新推荐文章于 2023-10-30 09:10:56 发布
最新推荐文章于 2023-10-30 09:10:56 发布
阅读量464 收藏
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a52022920/article/details/97633578
版权

/*

  • Copyright 2012-2019 the original author or authors.
  • Licensed under the Apache License, Version 2.0 (the “License”);
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at
  •  https://www.apache.org/licenses/LICENSE-2.0
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an “AS IS” BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License.
    */

package org.springframework.boot.autoconfigure.web;

import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.Servlet;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.AutoConfigureOrder;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
import org.springframework.boot.autoconfigure.web.ResourceProperties.Strategy;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.filter.OrderedHiddenHttpMethodFilter;
import org.springframework.boot.web.filter.OrderedHttpPutFormContentFilter;
import org.springframework.boot.web.filter.OrderedRequestContextFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Primary;
import org.springframework.core.Ordered;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.convert.converter.GenericConverter;
import org.springframework.core.io.Resource;
import org.springframework.format.Formatter;
import org.springframework.format.FormatterRegistry;
import org.springframework.format.datetime.DateFormatter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.validation.DefaultMessageCodesResolver;
import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.accept.ContentNegotiationManager;
import org.springframework.web.accept.ContentNegotiationStrategy;
import org.springframework.web.accept.PathExtensionContentNegotiationStrategy;
import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextListener;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.filter.HttpPutFormContentFilter;
import org.springframework.web.filter.RequestContextFilter;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.AsyncSupportConfigurer;
import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
import org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceChainRegistration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.handler.AbstractHandlerExceptionResolver;
import org.springframework.web.servlet.handler.AbstractUrlHandlerMapping;
import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping;
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver;
import org.springframework.web.servlet.i18n.FixedLocaleResolver;
import org.springframework.web.servlet.mvc.ParameterizableViewController;
import org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import org.springframework.web.servlet.resource.AppCacheManifestTransformer;
import org.springframework.web.servlet.resource.GzipResourceResolver;
import org.springframework.web.servlet.resource.ResourceHttpRequestHandler;
import org.springframework.web.servlet.resource.ResourceResolver;
import org.springframework.web.servlet.resource.VersionResourceResolver;
import org.springframework.web.servlet.view.BeanNameViewResolver;
import org.springframework.web.servlet.view.ContentNegotiatingViewResolver;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

/**

  • {@link EnableAutoConfiguration Auto-configuration} for {@link EnableWebMvc Web MVC}.

  • @author Phillip Webb

  • @author Dave Syer

  • @author Andy Wilkinson

  • @author Sébastien Deleuze

  • @author Eddú Meléndez

  • @author Stephane Nicoll
    */
    @Configuration
    @ConditionalOnWebApplication
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
    WebMvcConfigurerAdapter.class })
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
    ValidationAutoConfiguration.class })
    public class WebMvcAutoConfiguration {

    public static final String DEFAULT_PREFIX = “”;

    public static final String DEFAULT_SUFFIX = “”;

    @Bean
    @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
    public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
    return new OrderedHiddenHttpMethodFilter();
    }

    @Bean
    @ConditionalOnMissingBean(HttpPutFormContentFilter.class)
    @ConditionalOnProperty(prefix = “spring.mvc.formcontent.putfilter”, name = “enabled”,
    matchIfMissing = true)
    public OrderedHttpPutFormContentFilter httpPutFormContentFilter() {
    return new OrderedHttpPutFormContentFilter();
    }

    // Defined as a nested config to ensure WebMvcConfigurerAdapter is not read when not
    // on the classpath
    @Configuration
    @Import(EnableWebMvcConfiguration.class)
    @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
    public static class WebMvcAutoConfigurationAdapter extends WebMvcConfigurerAdapter {

     private static final Log logger = LogFactory
 		.getLog(WebMvcConfigurerAdapter.class);

 private final ResourceProperties resourceProperties;

 private final WebMvcProperties mvcProperties;

 private final ListableBeanFactory beanFactory;

 private final HttpMessageConverters messageConverters;

 final ResourceHandlerRegistrationCustomizer resourceHandlerRegistrationCustomizer;

 public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties,
 		WebMvcProperties mvcProperties, ListableBeanFactory beanFactory,
 		@Lazy HttpMessageConverters messageConverters,
 		ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider) {
 	this.resourceProperties = resourceProperties;
 	this.mvcProperties = mvcProperties;
 	this.beanFactory = beanFactory;
 	this.messageConverters = messageConverters;
 	this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider
 			.getIfAvailable();
 }

 @Override
 public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
 	converters.addAll(this.messageConverters.getConverters());
 }

 @Override
 public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
 	Long timeout = this.mvcProperties.getAsync().getRequestTimeout();
 	if (timeout != null) {
 		configurer.setDefaultTimeout(timeout);
 	}
 }

 @Override
 public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
 	Map<String, MediaType> mediaTypes = this.mvcProperties.getMediaTypes();
 	for (Entry<String, MediaType> mediaType : mediaTypes.entrySet()) {
 		configurer.mediaType(mediaType.getKey(), mediaType.getValue());
 	}
 }

 @Bean
 @ConditionalOnMissingBean
 public InternalResourceViewResolver defaultViewResolver() {
 	InternalResourceViewResolver resolver = new InternalResourceViewResolver();
 	resolver.setPrefix(this.mvcProperties.getView().getPrefix());
 	resolver.setSuffix(this.mvcProperties.getView().getSuffix());
 	return resolver;
 }

 @Bean
 @ConditionalOnBean(View.class)
 @ConditionalOnMissingBean
 public BeanNameViewResolver beanNameViewResolver() {
 	BeanNameViewResolver resolver = new BeanNameViewResolver();
 	resolver.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
 	return resolver;
 }

 @Bean
 @ConditionalOnBean(ViewResolver.class)
 @ConditionalOnMissingBean(name = "viewResolver",
 		value = ContentNegotiatingViewResolver.class)
 public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
 	ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
 	resolver.setContentNegotiationManager(
 			beanFactory.getBean(ContentNegotiationManager.class));
 	// ContentNegotiatingViewResolver uses all the other view resolvers to locate
 	// a view so it should have a high precedence
 	resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
 	return resolver;
 }

 @Bean
 @ConditionalOnMissingBean
 @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
 public LocaleResolver localeResolver() {
 	if (this.mvcProperties
 			.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
 		return new FixedLocaleResolver(this.mvcProperties.getLocale());
 	}
 	AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
 	localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
 	return localeResolver;
 }

 @Bean
 @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")
 public Formatter<Date> dateFormatter() {
 	return new DateFormatter(this.mvcProperties.getDateFormat());
 }

 @Override
 public MessageCodesResolver getMessageCodesResolver() {
 	if (this.mvcProperties.getMessageCodesResolverFormat() != null) {
 		DefaultMessageCodesResolver resolver = new DefaultMessageCodesResolver();
 		resolver.setMessageCodeFormatter(
 				this.mvcProperties.getMessageCodesResolverFormat());
 		return resolver;
 	}
 	return null;
 }

 @Override
 public void addFormatters(FormatterRegistry registry) {
 	for (Converter<?, ?> converter : getBeansOfType(Converter.class)) {
 		registry.addConverter(converter);
 	}
 	for (GenericConverter converter : getBeansOfType(GenericConverter.class)) {
 		registry.addConverter(converter);
 	}
 	for (Formatter<?> formatter : getBeansOfType(Formatter.class)) {
 		registry.addFormatter(formatter);
 	}
 }

 private <T> Collection<T> getBeansOfType(Class<T> type) {
 	return this.beanFactory.getBeansOfType(type).values();
 }

 @Override
 public void addResourceHandlers(ResourceHandlerRegistry registry) {
 	if (!this.resourceProperties.isAddMappings()) {
 		logger.debug("Default resource handling disabled");
 		return;
 	}
 	Integer cachePeriod = this.resourceProperties.getCachePeriod();
 	if (!registry.hasMappingForPattern("/webjars/**")) {
 		customizeResourceHandlerRegistration(registry
 				.addResourceHandler("/webjars/**")
 				.addResourceLocations("classpath:/META-INF/resources/webjars/")
 				.setCachePeriod(cachePeriod));
 	}
 	String staticPathPattern = this.mvcProperties.getStaticPathPattern();
 	if (!registry.hasMappingForPattern(staticPathPattern)) {
 		customizeResourceHandlerRegistration(
 				registry.addResourceHandler(staticPathPattern)
 						.addResourceLocations(
 								this.resourceProperties.getStaticLocations())
 						.setCachePeriod(cachePeriod));
 	}
 }

 @Bean
 public WelcomePageHandlerMapping welcomePageHandlerMapping(
 		ResourceProperties resourceProperties) {
 	return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
 			this.mvcProperties.getStaticPathPattern());
 }

 private void customizeResourceHandlerRegistration(
 		ResourceHandlerRegistration registration) {
 	if (this.resourceHandlerRegistrationCustomizer != null) {
 		this.resourceHandlerRegistrationCustomizer.customize(registration);
 	}

 }

 @Bean
 @ConditionalOnMissingBean({ RequestContextListener.class,
 		RequestContextFilter.class })
 public static RequestContextFilter requestContextFilter() {
 	return new OrderedRequestContextFilter();
 }

 @Configuration
 @ConditionalOnProperty(value = "spring.mvc.favicon.enabled",
 		matchIfMissing = true)
 public static class FaviconConfiguration {

 	private final ResourceProperties resourceProperties;

 	public FaviconConfiguration(ResourceProperties resourceProperties) {
 		this.resourceProperties = resourceProperties;
 	}

 	@Bean
 	public SimpleUrlHandlerMapping faviconHandlerMapping() {
 		SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
 		mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
 		mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
 				faviconRequestHandler()));
 		return mapping;
 	}

 	@Bean
 	public ResourceHttpRequestHandler faviconRequestHandler() {
 		ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
 		requestHandler
 				.setLocations(this.resourceProperties.getFaviconLocations());
 		return requestHandler;
 	}

 }

    }

    /**

    • Configuration equivalent to {@code @EnableWebMvc}.
      */
      @Configuration
      public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {

      private final WebMvcProperties mvcProperties;

      private final ListableBeanFactory beanFactory;

      private final WebMvcRegistrations mvcRegistrations;

      public EnableWebMvcConfiguration(
      ObjectProvider mvcPropertiesProvider,
      ObjectProvider mvcRegistrationsProvider,
      ListableBeanFactory beanFactory) {
      this.mvcProperties = mvcPropertiesProvider.getIfAvailable();
      this.mvcRegistrations = mvcRegistrationsProvider.getIfUnique();
      this.beanFactory = beanFactory;
      }

      @Bean
      @Override
      public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
      RequestMappingHandlerAdapter adapter = super.requestMappingHandlerAdapter();
      adapter.setIgnoreDefaultModelOnRedirect((this.mvcProperties != null)
      ? this.mvcProperties.isIgnoreDefaultModelOnRedirect() : true);
      return adapter;
      }

      @Override
      protected RequestMappingHandlerAdapter createRequestMappingHandlerAdapter() {
      if (this.mvcRegistrations != null
      && this.mvcRegistrations.getRequestMappingHandlerAdapter() != null) {
      return this.mvcRegistrations.getRequestMappingHandlerAdapter();
      }
      return super.createRequestMappingHandlerAdapter();
      }

      @Bean
      @Primary
      @Override
      public RequestMappingHandlerMapping requestMappingHandlerMapping() {
      // Must be @Primary for MvcUriComponentsBuilder to work
      return super.requestMappingHandlerMapping();
      }

      @Bean
      @Override
      public Validator mvcValidator() {
      if (!ClassUtils.isPresent(“javax.validation.Validator”,
      getClass().getClassLoader())) {
      return super.mvcValidator();
      }
      return WebMvcValidator.get(getApplicationContext(), getValidator());
      }

      @Override
      protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() {
      if (this.mvcRegistrations != null
      && this.mvcRegistrations.getRequestMappingHandlerMapping() != null) {
      return this.mvcRegistrations.getRequestMappingHandlerMapping();
      }
      return super.createRequestMappingHandlerMapping();
      }

      @Override
      protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer() {
      try {
      return this.beanFactory.getBean(ConfigurableWebBindingInitializer.class);
      }
      catch (NoSuchBeanDefinitionException ex) {
      return super.getConfigurableWebBindingInitializer();
      }
      }

      @Override
      protected ExceptionHandlerExceptionResolver createExceptionHandlerExceptionResolver() {
      if (this.mvcRegistrations != null && this.mvcRegistrations
      .getExceptionHandlerExceptionResolver() != null) {
      return this.mvcRegistrations.getExceptionHandlerExceptionResolver();
      }
      return super.createExceptionHandlerExceptionResolver();
      }

      @Override
      protected void configureHandlerExceptionResolvers(
      List exceptionResolvers) {
      super.configureHandlerExceptionResolvers(exceptionResolvers);
      if (exceptionResolvers.isEmpty()) {
      addDefaultHandlerExceptionResolvers(exceptionResolvers);
      }
      if (this.mvcProperties.isLogResolvedException()) {
      for (HandlerExceptionResolver resolver : exceptionResolvers) {
      if (resolver instanceof AbstractHandlerExceptionResolver) {
      ((AbstractHandlerExceptionResolver) resolver)
      .setWarnLogCategory(resolver.getClass().getName());
      }
      }
      }
      }

      @Bean
      @Override
      public ContentNegotiationManager mvcContentNegotiationManager() {
      ContentNegotiationManager manager = super.mvcContentNegotiationManager();
      List strategies = manager.getStrategies();
      ListIterator iterator = strategies.listIterator();
      while (iterator.hasNext()) {
      ContentNegotiationStrategy strategy = iterator.next();
      if (strategy instanceof PathExtensionContentNegotiationStrategy) {
      iterator.set(new OptionalPathExtensionContentNegotiationStrategy(
      strategy));
      }
      }
      return manager;
      }

    }

    @Configuration
    @ConditionalOnEnabledResourceChain
    static class ResourceChainCustomizerConfiguration {

     @Bean
 public ResourceChainResourceHandlerRegistrationCustomizer resourceHandlerRegistrationCustomizer() {
 	return new ResourceChainResourceHandlerRegistrationCustomizer();
 }

    }

    interface ResourceHandlerRegistrationCustomizer {

     void customize(ResourceHandlerRegistration registration);

    }

    private static class ResourceChainResourceHandlerRegistrationCustomizer
    implements ResourceHandlerRegistrationCustomizer {

     @Autowired
 private ResourceProperties resourceProperties = new ResourceProperties();

 @Override
 public void customize(ResourceHandlerRegistration registration) {
 	ResourceProperties.Chain properties = this.resourceProperties.getChain();
 	configureResourceChain(properties,
 			registration.resourceChain(properties.isCache()));
 }

 private void configureResourceChain(ResourceProperties.Chain properties,
 		ResourceChainRegistration chain) {
 	Strategy strategy = properties.getStrategy();
 	if (strategy.getFixed().isEnabled() || strategy.getContent().isEnabled()) {
 		chain.addResolver(getVersionResourceResolver(strategy));
 	}
 	if (properties.isGzipped()) {
 		chain.addResolver(new GzipResourceResolver());
 	}
 	if (properties.isHtmlApplicationCache()) {
 		chain.addTransformer(new AppCacheManifestTransformer());
 	}
 }

 private ResourceResolver getVersionResourceResolver(
 		ResourceProperties.Strategy properties) {
 	VersionResourceResolver resolver = new VersionResourceResolver();
 	if (properties.getFixed().isEnabled()) {
 		String version = properties.getFixed().getVersion();
 		String[] paths = properties.getFixed().getPaths();
 		resolver.addFixedVersionStrategy(version, paths);
 	}
 	if (properties.getContent().isEnabled()) {
 		String[] paths = properties.getContent().getPaths();
 		resolver.addContentVersionStrategy(paths);
 	}
 	return resolver;
 }

    }

    static final class WelcomePageHandlerMapping extends AbstractUrlHandlerMapping {

     private static final Log logger = LogFactory
 		.getLog(WelcomePageHandlerMapping.class);

 private WelcomePageHandlerMapping(Resource welcomePage,
 		String staticPathPattern) {
 	if (welcomePage != null && "/**".equals(staticPathPattern)) {
 		logger.info("Adding welcome page: " + welcomePage);
 		ParameterizableViewController controller = new ParameterizableViewController();
 		controller.setViewName("forward:index.html");
 		setRootHandler(controller);
 		setOrder(0);
 	}
 }

 @Override
 public Object getHandlerInternal(HttpServletRequest request) throws Exception {
 	for (MediaType mediaType : getAcceptedMediaTypes(request)) {
 		if (mediaType.includes(MediaType.TEXT_HTML)) {
 			return super.getHandlerInternal(request);
 		}
 	}
 	return null;
 }

 private List<MediaType> getAcceptedMediaTypes(HttpServletRequest request) {
 	String acceptHeader = request.getHeader(HttpHeaders.ACCEPT);
 	return MediaType.parseMediaTypes(
 			StringUtils.hasText(acceptHeader) ? acceptHeader : "*/*");
 }

    }

    /**

    • Decorator to make {@link PathExtensionContentNegotiationStrategy} optional

    • depending on a request attribute.
      */
      static class OptionalPathExtensionContentNegotiationStrategy
      implements ContentNegotiationStrategy {

      private static final String SKIP_ATTRIBUTE = PathExtensionContentNegotiationStrategy.class
      .getName() + “.SKIP”;

      private final ContentNegotiationStrategy delegate;

      OptionalPathExtensionContentNegotiationStrategy(
      ContentNegotiationStrategy delegate) {
      this.delegate = delegate;
      }

      @Override
      public List resolveMediaTypes(NativeWebRequest webRequest)
      throws HttpMediaTypeNotAcceptableException {
      Object skip = webRequest.getAttribute(SKIP_ATTRIBUTE,
      RequestAttributes.SCOPE_REQUEST);
      if (skip != null && Boolean.parseBoolean(skip.toString())) {
      return Collections.emptyList();
      }
      return this.delegate.resolveMediaTypes(webRequest);
      }

    }

}

sdnugao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot默认配置原理：以WebMvcAutoConfiguration为例
全栈测试笔记
02-08 667
默认配置类 @EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么，这些默认配置是在哪里定义的呢？为何依赖引入就会触发配置呢？ 其实，在我们的项目中已经引入了一个依赖：spring-boot-autoconfigure，其中定义了大量自动配置类：下面截图没截完 我们来看一个我们熟悉的，例如SpringMVC，查看mv...
源码解析：WebMvcAutoConfiguration
柳絮飘扬
08-13 1681
文章目录一：WebMvcAutoConfiguration做了什么1.WebMvcAutoConfiguration 源码2.WebMvcConfigurer接口源码3. WebMvcAutoConfigurationAdapter4.自定义类实现WebMvcConfigurer这个接口，这样我们是不是就可以加上一些我们自己的配置了？试一试4.1如果我们想增加拦截器，怎么做，先看源码4.2写代码实践下 注：此篇文章适合对为什么自定义拦截器或者视图解析器生效的原因困惑的同学来看，带你从源码分析为什么。 一：W
SpringBoot的Web自动配置和默认功能、WebMvcAutoConfiguration原理
最新发布
Bulut0907
10-30 316
SpringBoot的Web开发能力，由SpringMVC提供。
SpringBoot3【② Web开发】
weixin_44981126的博客
07-02 849
SpringBoot3【② Web开发】
Spring boot 自动配置 : Servlet Web 应用有关 -- WebMvcAutoConfiguration
Details Inside Spring
03-31 3435
概述 WebMvcAutoConfiguration 是Spring boot针对Web MVC的自动配置机制，其效果等同于开发人员自己使用@EnableWebMvc进行的Web MVC配置。 WebMvcAutoConfiguration的启用是有条件的，它在如下条件都满足时才会起作用 : 必须是Servlet Web应用环境; 在classpath上必须有Servlet,Dispatcher...
springboot简单源代码
06-01
在开始探讨 SpringBoot 源代码之前，我们需要了解一些基本概念。 首先，SpringBoot 的自动配置是通过 `@EnableAutoConfiguration` 注解实现的。这个注解会启动自动配置过程，扫描应用的类路径，并根据存在的jar包和...
spring boot springMVC扩展配置实现解析
08-25
我们可以通过查看这个类的源代码来了解Spring Boot的自动配置机制。 例如，在WebMvcAutoConfiguration类中，我们可以看到addResourceHandlers方法，这个方法是用于添加静态资源路劲的。 ```java public void ...
springboot源码解析视频
02-19
视频课程中，讲解者会逐步剖析上述关键点的源代码，帮助观众理解每一步背后的逻辑。同时，通过对具体实例的分析，观众将学会如何阅读和理解SpringBoot的源码，从而在实际开发中更高效地定位问题和优化性能。此外，...
springboot-learning-example-master.zip
12-19
- `src/main/java`目录下存放源代码，`src/main/resources`则包含资源配置文件。 - `Application`类通常作为启动入口，通过`@SpringBootApplication`注解声明为Spring Boot应用。 2. **自动配置** - SpringBoot...
spring boot 深入浅出源码
01-29
例如，`WebMvcAutoConfiguration`用于配置Spring MVC，而`DataSourceAutoConfiguration`则负责数据源的设置。通过条件注解（@Conditional），Spring Boot能智能地根据类路径、环境变量和属性来决定是否激活某个配置...
Copyright © 2008 - 2010\nAll rights reserved
06-11
AnCal is personal information management software.
spring boot 源码解析18-WebMvcAutoConfiguration自动化配置揭秘
热门推荐
qq_26000415的博客
01-07 3万+
前言上篇文章,我们分析了spring boot 中其他有关mvc的自动化配置类,只剩下WebMvcAutoConfiguration没有解析,这篇文章对其进行收尾解析 WebMvcAutoConfiguration 有如下注解:@Configuration @ConditionalOnWebApplication @ConditionalOnClass({ Servlet.class, Dispat
springBoot 之WebMvcAutoConfiguration--国际化
ganlangreen的专栏
07-29 279
SpringBoot Web相关的自动配置WebMvcAutoConfiguration 国际化自动配置 springBoot的自动配置类里，已经为我们写好了国际化的自动配置。 通过注解我们可以得知 1、如果不配置其他的国际化Bean时会使用此配置 2、控制某个configuration是否生效。具体操作是通过其两个属性name以及havingValue来实现的，其中name用来从...
关于版权 声明
井中月
03-06 1547
Copyright © 1998 - 2005 TENCENT Inc. All Rights Reserved 这句话什么意思 版权，1998-2005 腾讯公司。保留所有权利。 1998指版权开始年份 2005指此最新作品的发布年份 ====================================== 关于版权声明的格式，可以参考以下资料 ====================
WebMvcAutoConfiguration
ybw
11-07 381
WebMvcAutoConfiguration 静态资源配置类 public void addResourceHandlers(ResourceHandlerRegistry registry) { if (!this.resourceProperties.isAddMappings()) { logger.debug("Default resource handling disabled"); } else { Duration cachePerio
springcloud整合zookeeper作为服务发现启动异常Error processing condition on org.springframework.boot.autoconfigure
撸起袖子加油干
07-20 1707
021-07-20 10:14:36.240 INFO 360520 --- [ main] c.jason.springcloud.ProviderApplication : Starting ProviderApplication on CNHQ-20018523N with PID 360520 (F:\Workspaces\springdemo\spring-provider\target\classes started by 20018523 in F:\Workspac...
Springboot中WebMvcAutoConfiguration源码的解读
独狼的博客
03-16 733
开头，我们先来看下在springboot中如何整一个欢迎页。在我们之前学的web项目中，都是在xml中配置欢迎页面，但是我们在sprginboot中该如何配置呢？ 我们可以顺着WebMvcAutoConfiguration看看 那我们有办法自定义静态文件的位置吗？ 我们可以看看源码 根据上面的源码，我们可以知道，我们可以通过 Properties文件中的 prefix+属性来自定义 ...
学习笔记(13):Spring Boot实战开发-WebMvcAutoConfiguration源码解读
greenJX的博客
10-03 129
本课程讲解了Spring Boot2.x中常见的技术内容，大家可以通过本课程的学习快速掌握Spring Boot的核心用法，并使用Spring Boot进行简化开发。 本课程在讲解时，使用了理论与案例相结合的方式，对每个知识点的介绍都会先简单的介绍，然后再通过具体的案例进行详细的演示，从而使每个知识点的表达足够清晰易懂。 整体来讲，本课程大致讲解了以下几方面的内容： 1.Sp...
Springboot2.0--WebMvcConfigurer详解
OceanSky的专栏
06-29 7219
WebMvcConfigurer是spring内部配置的一种方式，使用JavaBean的方式代替传统的xml配置；也可以自定义扩展配置类，实现方式是继承WebMvcConfigurer接口；WebMvcConfigurer其实就是一个接口，具体的配置是由实现类来决定的，现在会有两个问题，具体的实现类有哪些？这些实现类是如何加载到容器之中并生效的？带着这两个问题开启我们源码的探索之旅。 WebMvcConfigurer具体实现类 1.系统自带实现类 WebMvcAutoConfigurationAda.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值