SpringMVC之@EnableWebMvc源码分析

最新推荐文章于 2024-03-08 02:08:37 发布
最新推荐文章于 2024-03-08 02:08:37 发布
阅读量576 收藏 1
点赞数
分类专栏： SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41071876/article/details/105607685
版权

前言

本文重点研究@EnableWebMvc的作用及其源码

一、源码研究

@EnableWebMvc源码

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}

从这可以看出@EnableWebMvc注解的作用是注册DelegatingWebMvcConfiguration类，注意他是一个配置类

配置 proxyBeanMethods 属性后，配置类不会被代理了。主要是为了提高性能，如果你的 @Bean 方法之间没有调用关系的话可以把 proxyBeanMethods 设置为 false。否则，方法内部引用的类生产的类和 Spring 容器中类是两个类。

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
   
	@Autowired(required = false)
	public void setConfigurers(List<WebMvcConfigurer> configurers) {
		if (!CollectionUtils.isEmpty(configurers)) {
			this.configurers.addWebMvcConfigurers(configurers);
		}
	}
    //忽略代码。。。。。

DelegatingWebMvcConfiguration有2个作用：
1、扫描容器中的WebMvcConfigurer，放到WebMvcConfigurerComposite中
2、其主要实现代码都在其父类WebMvcConfigurationSupport中，他将WebMvcConfigurer和WebMvcConfigurationSupport联系起来了

至于怎么联系，这边以其addFormatters方法作为案例说明：

public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    @Override
	protected void addFormatters(FormatterRegistry registry) {
	    //循环遍历configurers中WebMvcConfigurer到addFormatters方法
		this.configurers.addFormatters(registry);
	}

DelegatingWebMvcConfiguration重写类其父类的addFormatters方法

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    @Bean
	public FormattingConversionService mvcConversionService() {
		FormattingConversionService conversionService = new DefaultFormattingConversionService();
		addFormatters(conversionService);
		return conversionService;
	}
    //子类DelegatingWebMvcConfiguration重写
	protected void addFormatters(FormatterRegistry registry) {
	}

所以我们可以通过继承WebMvcConfigurer重写其addFormatters方法，来添加新的Converter

@ComponentScan(value = "clyu", useDefaultFilters = false,
               includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, 
@Configuration
@EnableWebMvc
public class MyWebMvcConfig implements WebMvcConfigurer {
        @Override
        public void addFormatters(FormatterRegistry registry) {
                registry.addConverter();
        }
}

这也是WebMvcConfigurer为什么要加@EnableWebMvc，才能生效的原因

二、注册方法研究

1、注册HandlerMapping

a、RequestMappingHandlerMapping
@Bean
public RequestMappingHandlerMapping requestMappingHandlerMapping(
			@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
        //直接new
		RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
		mapping.setOrder(0);
		//配置Interceptor
		mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
		mapping.setContentNegotiationManager(contentNegotiationManager);
		//配置CorsConfiguration
		mapping.setCorsConfigurations(getCorsConfigurations());

		PathMatchConfigurer configurer = getPathMatchConfigurer();

		Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
		if (useSuffixPatternMatch != null) {
			mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
		}
		Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
		if (useRegisteredSuffixPatternMatch != null) {
			mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
		}
		Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
		if (useTrailingSlashMatch != null) {
			mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
		}

		UrlPathHelper pathHelper = configurer.getUrlPathHelper();
		if (pathHelper != null) {
			mapping.setUrlPathHelper(pathHelper);
		}
		PathMatcher pathMatcher = configurer.getPathMatcher();
		if (pathMatcher != null) {
			mapping.setPathMatcher(pathMatcher);
		}
		Map<String, Predicate<Class<?>>> pathPrefixes = configurer.getPathPrefixes();
		if (pathPrefixes != null) {
			mapping.setPathPrefixes(pathPrefixes);
		}
		return mapping;
	}
b、BeanNameUrlHandlerMapping
@Bean
public BeanNameUrlHandlerMapping beanNameHandlerMapping(
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {

		BeanNameUrlHandlerMapping mapping = new BeanNameUrlHandlerMapping();
		mapping.setOrder(2);
		mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
		mapping.setCorsConfigurations(getCorsConfigurations());
		return mapping;
	}
c、RouterFunctionMapping
@Bean
public RouterFunctionMapping routerFunctionMapping(
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {

		RouterFunctionMapping mapping = new RouterFunctionMapping();
		mapping.setOrder(3);
		mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
		mapping.setCorsConfigurations(getCorsConfigurations());
		mapping.setMessageConverters(getMessageConverters());
		return mapping;
}
d、SimpleUrlHandlerMapping
protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {}

@Bean
public HandlerMapping defaultServletHandlerMapping() {
		Assert.state(this.servletContext != null, "No ServletContext set");
		DefaultServletHandlerConfigurer configurer = new DefaultServletHandlerConfigurer(this.servletContext);
		configureDefaultServletHandling(configurer);
		return configurer.buildHandlerMapping();
}
@Nullable
protected SimpleUrlHandlerMapping buildHandlerMapping() {
		if (this.handler == null) {
			return null;
		}
      return new SimpleUrlHandlerMapping(Collections.singletonMap("/**", this.handler), Ordered.LOWEST_PRECEDENCE);
}

protected void addViewControllers(ViewControllerRegistry registry) {
	}


@Bean
	@Nullable
	public HandlerMapping viewControllerHandlerMapping(
			@Qualifier("mvcPathMatcher") PathMatcher pathMatcher,
			@Qualifier("mvcUrlPathHelper") UrlPathHelper urlPathHelper,
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
		ViewControllerRegistry registry = new ViewControllerRegistry(this.applicationContext);
		addViewControllers(registry);

		AbstractHandlerMapping handlerMapping = registry.buildHandlerMapping();
		if (handlerMapping == null) {
			return null;
		}
		handlerMapping.setPathMatcher(pathMatcher);
		handlerMapping.setUrlPathHelper(urlPathHelper);
		handlerMapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
		handlerMapping.setCorsConfigurations(getCorsConfigurations());
		return handlerMapping;
	}
    @Nullable
	protected SimpleUrlHandlerMapping buildHandlerMapping() {
		if (this.registrations.isEmpty() && this.redirectRegistrations.isEmpty()) {
			return null;
		}

		Map<String, Object> urlMap = new LinkedHashMap<>();
		for (ViewControllerRegistration registration : this.registrations) {
			urlMap.put(registration.getUrlPath(), registration.getViewController());
		}
		for (RedirectViewControllerRegistration registration : this.redirectRegistrations) {
			urlMap.put(registration.getUrlPath(), registration.getViewController());
		}

		return new SimpleUrlHandlerMapping(urlMap, this.order);
	}

protected void addResourceHandlers(ResourceHandlerRegistry registry) {
	}

@Bean
	@Nullable
	public HandlerMapping resourceHandlerMapping(
			@Qualifier("mvcUrlPathHelper") UrlPathHelper urlPathHelper,
			@Qualifier("mvcPathMatcher") PathMatcher pathMatcher,
			@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {

		Assert.state(this.applicationContext != null, "No ApplicationContext set");
		Assert.state(this.servletContext != null, "No ServletContext set");

		ResourceHandlerRegistry registry = new ResourceHandlerRegistry(this.applicationContext,
				this.servletContext, contentNegotiationManager, urlPathHelper);
		addResourceHandlers(registry);
		AbstractHandlerMapping handlerMapping = registry.getHandlerMapping();
		if (handlerMapping == null) {
			return null;
		}
		handlerMapping.setPathMatcher(pathMatcher);
		handlerMapping.setUrlPathHelper(urlPathHelper);
		handlerMapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
		handlerMapping.setCorsConfigurations(getCorsConfigurations());
		return handlerMapping;
	}
@Nullable
	protected AbstractHandlerMapping getHandlerMapping() {
		if (this.registrations.isEmpty()) {
			return null;
		}

		Map<String, HttpRequestHandler> urlMap = new LinkedHashMap<>();
		for (ResourceHandlerRegistration registration : this.registrations) {
			for (String pathPattern : registration.getPathPatterns()) {
				ResourceHttpRequestHandler handler = registration.getRequestHandler();
				if (this.pathHelper != null) {
					handler.setUrlPathHelper(this.pathHelper);
				}
				if (this.contentNegotiationManager != null) {
					handler.setContentNegotiationManager(this.contentNegotiationManager);
				}
				handler.setServletContext(this.servletContext);
				handler.setApplicationContext(this.applicationContext);
				try {
					handler.afterPropertiesSet();
				}
				catch (Throwable ex) {
					throw new BeanInitializationException("Failed to init ResourceHttpRequestHandler", ex);
				}
				urlMap.put(pathPattern, handler);
			}
		}

		return new SimpleUrlHandlerMapping(urlMap, this.order);
	}

2、注册HandlerAdapter

a、RequestMappingHandlerAdapter
protected void configureAsyncSupport(AsyncSupportConfigurer configurer) {}

@Bean
public RequestMappingHandlerAdapter requestMappingHandlerAdapter(
			@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
			@Qualifier("mvcConversionService") FormattingConversionService conversionService,
			@Qualifier("mvcValidator") Validator validator) {
        //直接new个RequestMappingHandlerAdapter
		RequestMappingHandlerAdapter adapter = createRequestMappingHandlerAdapter();
		adapter.setContentNegotiationManager(contentNegotiationManager);
		adapter.setMessageConverters(getMessageConverters());
		adapter.setWebBindingInitializer(getConfigurableWebBindingInitializer(conversionService, validator));
		adapter.setCustomArgumentResolvers(getArgumentResolvers());
		adapter.setCustomReturnValueHandlers(getReturnValueHandlers());

		if (jackson2Present) {
			adapter.setRequestBodyAdvice(Collections.singletonList(new JsonViewRequestBodyAdvice()));
			adapter.setResponseBodyAdvice(Collections.singletonList(new JsonViewResponseBodyAdvice()));
		}

		AsyncSupportConfigurer configurer = new AsyncSupportConfigurer();
		configureAsyncSupport(configurer);
		if (configurer.getTaskExecutor() != null) {
			adapter.setTaskExecutor(configurer.getTaskExecutor());
		}
		if (configurer.getTimeout() != null) {
			adapter.setAsyncRequestTimeout(configurer.getTimeout());
		}
		adapter.setCallableInterceptors(configurer.getCallableInterceptors());
		adapter.setDeferredResultInterceptors(configurer.getDeferredResultInterceptors());

		return adapter;
	}
b、HttpRequestHandlerAdapter
@Bean
public HttpRequestHandlerAdapter httpRequestHandlerAdapter() {
        return new HttpRequestHandlerAdapter();
}
c、SimpleControllerHandlerAdapter
public SimpleControllerHandlerAdapter simpleControllerHandlerAdapter() {
        return new SimpleControllerHandlerAdapter();
}
d、HandlerFunctionAdapter
public HandlerFunctionAdapter handlerFunctionAdapter() {
		return new HandlerFunctionAdapter();
}

3、注册HandlerExceptionResolver

//注册HandlerExceptionResolver，这个exceptionResolvers是为空的
protected void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {}
//添加HandlerExceptionResolver，这个exceptionResolvers是有值的
protected void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {}

@Bean
public HandlerExceptionResolver handlerExceptionResolver(
			@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
		List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
		//模版方法，操作exceptionResolvers
		configureHandlerExceptionResolvers(exceptionResolvers);
		if (exceptionResolvers.isEmpty()) {
		    //如果我们没有配置HandlerExceptionResolver，那么就注册默认的
			addDefaultHandlerExceptionResolvers(exceptionResolvers, contentNegotiationManager);
		}
		//模版方法，操作exceptionResolvers
		extendHandlerExceptionResolvers(exceptionResolvers);
		HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
		composite.setOrder(0);
		composite.setExceptionResolvers(exceptionResolvers);
		return composite;
	}
	
   protected final void addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers,
                                                             ContentNegotiationManager mvcContentNegotiationManager) {

        //直接new
        ExceptionHandlerExceptionResolver exceptionHandlerResolver = createExceptionHandlerExceptionResolver();
        exceptionHandlerResolver.setContentNegotiationManager(mvcContentNegotiationManager);
        //添加MessageConverters
        exceptionHandlerResolver.setMessageConverters(getMessageConverters());
        //添加ArgumentResolvers
        exceptionHandlerResolver.setCustomArgumentResolvers(getArgumentResolvers());
        //添加ReturnValueHandlers
        exceptionHandlerResolver.setCustomReturnValueHandlers(getReturnValueHandlers());
        //如果com.fasterxml.jackson.databind.ObjectMapper", classLoader) 和 com.fasterxml.jackson.core.JsonGenerator 有
        if (jackson2Present) {
            exceptionHandlerResolver.setResponseBodyAdvice(
                    Collections.singletonList(new JsonViewResponseBodyAdvice()));
        }
        if (this.applicationContext != null) {
            exceptionHandlerResolver.setApplicationContext(this.applicationContext);
        }
        exceptionHandlerResolver.afterPropertiesSet();
        exceptionResolvers.add(exceptionHandlerResolver);

        ResponseStatusExceptionResolver responseStatusResolver = new ResponseStatusExceptionResolver();
        responseStatusResolver.setMessageSource(this.applicationContext);
        exceptionResolvers.add(responseStatusResolver);
        exceptionResolvers.add(new DefaultHandlerExceptionResolver());
    }

4、注册ViewResolver

protected void configureViewResolvers(ViewResolverRegistry registry) {}

@Bean
public ViewResolver mvcViewResolver(
            @Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager) {
        ViewResolverRegistry registry =
                new ViewResolverRegistry(contentNegotiationManager, this.applicationContext);
        configureViewResolvers(registry);

        if (registry.getViewResolvers().isEmpty() && this.applicationContext != null) {
            String[] names = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.applicationContext, ViewResolver.class, true, false);
            if (names.length == 1) {
                registry.getViewResolvers().add(new InternalResourceViewResolver());
            }
        }
        ViewResolverComposite composite = new ViewResolverComposite();
        composite.setOrder(registry.getOrder());
        composite.setViewResolvers(registry.getViewResolvers());
        if (this.applicationContext != null) {
            composite.setApplicationContext(this.applicationContext);
        }
        if (this.servletContext != null) {
            composite.setServletContext(this.servletContext);
        }
        return composite;
}

5、注册Validator

public Validator getValidator() {return null;}

@Bean
public Validator mvcValidator() {
        Validator validator = getValidator();
        if (validator == null) {
            if (ClassUtils.isPresent("javax.validation.Validator", getClass().getClassLoader())) {
                Class<?> clazz;
                try {
                    String className = "org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean";
                    clazz = ClassUtils.forName(className, WebMvcConfigurationSupport.class.getClassLoader());
                }
                catch (ClassNotFoundException | LinkageError ex) {
                    throw new BeanInitializationException("Failed to resolve default validator class", ex);
                }
                validator = (Validator) BeanUtils.instantiateClass(clazz);
            }
            else {
                validator = new NoOpValidator();
            }
        }
        return validator;
}

6、注册FormattingConversionService

protected void addFormatters(FormatterRegistry registry) {}

@Bean
public FormattingConversionService mvcConversionService() {
        FormattingConversionService conversionService = new DefaultFormattingConversionService();
        addFormatters(conversionService);
        return conversionService;
}

7、注册PathMatcher和UrlPathHelper

protected void configurePathMatch(PathMatchConfigurer configurer) {}

protected PathMatchConfigurer getPathMatchConfigurer() {
		if (this.pathMatchConfigurer == null) {
			this.pathMatchConfigurer = new PathMatchConfigurer();
			configurePathMatch(this.pathMatchConfigurer);
		}
		return this.pathMatchConfigurer;
}

@Bean
public ResourceUrlProvider mvcResourceUrlProvider() {
        ResourceUrlProvider urlProvider = new ResourceUrlProvider();
        UrlPathHelper pathHelper = getPathMatchConfigurer().getUrlPathHelper();
        if (pathHelper != null) {
            urlProvider.setUrlPathHelper(pathHelper);
        }
        PathMatcher pathMatcher = getPathMatchConfigurer().getPathMatcher();
        if (pathMatcher != null) {
            urlProvider.setPathMatcher(pathMatcher);
        }
        return urlProvider;
}

@Bean
public PathMatcher mvcPathMatcher() {
		PathMatcher pathMatcher = getPathMatchConfigurer().getPathMatcher();
		return (pathMatcher != null ? pathMatcher : new AntPathMatcher());
}

	
@Bean
public UrlPathHelper mvcUrlPathHelper() {
		UrlPathHelper pathHelper = getPathMatchConfigurer().getUrlPathHelper();
		return (pathHelper != null ? pathHelper : new UrlPathHelper());
}

8、 配置Interceptor

protected void addInterceptors(InterceptorRegistry registry) {}

protected final Object[] getInterceptors(FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
		if (this.interceptors == null) {
			InterceptorRegistry registry = new InterceptorRegistry();
			addInterceptors(registry);
			registry.addInterceptor(new ConversionServiceExposingInterceptor(mvcConversionService));
			registry.addInterceptor(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider));
			this.interceptors = registry.getInterceptors();
		}
		return this.interceptors.toArray();
}

9、 配置CorsConfiguration

protected void addCorsMappings(CorsRegistry registry) {}

protected final Map<String, CorsConfiguration> getCorsConfigurations() {
		if (this.corsConfigurations == null) {
			CorsRegistry registry = new CorsRegistry();
			addCorsMappings(registry);
			this.corsConfigurations = registry.getCorsConfigurations();
		}
		return this.corsConfigurations;
	}

10、配置MessageConverters

protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {}
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {}

protected final List<HttpMessageConverter<?>> getMessageConverters() {
		if (this.messageConverters == null) {
			this.messageConverters = new ArrayList<>();
			configureMessageConverters(this.messageConverters);
			if (this.messageConverters.isEmpty()) {
			    
				addDefaultHttpMessageConverters(this.messageConverters);
			}
			extendMessageConverters(this.messageConverters);
		}
		return this.messageConverters;
	}

addDefaultHttpMessageConverters逻辑如下

1、先添加 ByteArrayHttpMessageConverter，StringHttpMessageConverter，ResourceHttpMessageConverter，ResourceRegionHttpMessageConverter，SourceHttpMessageConverter，AllEncompassingFormHttpMessageConverter
2、判断 com.rometools.rome.feed.WireFeed 是否存在，如果在添加 AtomFeedHttpMessageConverter 和RssChannelHttpMessageConverter
3、判断com.fasterxml.jackson.dataformat.xml.XmlMappe是否存在，如果在添加 MappingJackson2XmlHttpMessageConverter
4、判断com.fasterxml.jackson.databind.ObjectMapper和 com.fasterxml.jackson.core.JsonGenerator 是否存在，如果在添加MappingJackson2HttpMessageConverter
5、判断javax.json.bind.Jsonb是否存在，如果在添加 JsonbHttpMessageConverter
6、判断com.google.gson.Gson是否存在，如果在添加 GsonHttpMessageConverter
7、判断com.fasterxml.jackson.dataformat.smile.SmileFactory是否存在，如果在添加 MappingJackson2SmileHttpMessageConverter
8、判断com.fasterxml.jackson.dataformat.cbor.CBORFactory是否存在，如果在添加 MappingJackson2CborHttpMessageConverter

11、配置MessageCodesResolver

protected MessageCodesResolver getMessageCodesResolver() {return null;}

protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer(
			FormattingConversionService mvcConversionService, Validator mvcValidator) {

		ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
		initializer.setConversionService(mvcConversionService);
		initializer.setValidator(mvcValidator);
		MessageCodesResolver messageCodesResolver = getMessageCodesResolver();
		if (messageCodesResolver != null) {
			initializer.setMessageCodesResolver(messageCodesResolver);
		}
		return initializer;
	}

12、配置MessageCodesResolver

protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {}

protected final List<HandlerMethodArgumentResolver> getArgumentResolvers() {
		if (this.argumentResolvers == null) {
			this.argumentResolvers = new ArrayList<>();
			addArgumentResolvers(this.argumentResolvers);
		}
		return this.argumentResolvers;
	}
这是一条海鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每天一个注解之@EnableWebMvc
qq_43406318的博客
07-31 4142
视图解析器（ViewResolvers）、静态资源处理（StaticResourcesHandling）、消息转换器（MessageConverters）、拦截器（Interceptors）、异常处理（ExceptionHandling）定义全局的异常处理器、跨域资源共享（CORS）、国际化和本地化（InternationalizationandLocalization）、文件上传配置（File Upload Configuration）、安全配置（SecurityConfiguration）。
@enablewebmvc注解有什么用途
热门推荐
香烟达人的博客
07-02 3万+
@EnableWebMvc是使用Java 注解快捷配置Spring Webmvc的一个注解。在使用该注解后配置一个继承于WebMvcConfigurerAdapter的配置类即可配置好Spring Webmvc。 通过查看@EnableWebMvc的源码，可以发现该注解就是为了引入一个DelegatingWebMvcConfiguration Java 配置类。并翻看DelegatingWebM...
@EnableWebMvc介绍和使用详细demo
最新发布
网络备忘录，总结记录Java开发的坑和道，如果文章对你有帮助，不妨关注一波~
03-08 4万+
@EnableWebMvc介绍和使用详细demo
spring mvc之注解@EnableWebMvc
程序猿的樊笼
12-25 1万+
前言 其实我接触Java web开发比较晚，这句话的意思就是，我做开发的时候就使用的是比较新的技术了，比如spring boot，从来没用过ssh那一套，虽然用了spring mvc，但也是基于spring boot封装好的。 当然了，这有好处，也有坏处，好处是跟上了时代的潮流，坏处是对于被封装的那一套了解不够深刻。 今天在翻某些框架封装的源码时候，看到一些WEB项目的配置类继承了WebMv...
Spring 注解 @EnableWebMvc 工作原理
Details Inside Spring
02-15 5948
本文分析所用源代码基于Spring 5.1.3 RELEASE 概述 通常我们使用注解@EnableWebMvc在一个@Configuration注解的配置类上，用于对Spring MVC进行配置。用法如下所示 : @Configuration @EnableWebMvc public class WebMvcConfig implements WebMvcConfigurer { /...
【springboot】@EnableWebMvc注解有什么用？导致@RestController不返回json default-property-inclusion: non_null不起作用？
孟秋与你的博客
04-09 4097
相信有比较多的一部分开发同行思维都是这样，没必要画流程图，懒得画，业务理清了就好。 当然，如果说开发年限很长了，经验老道，业务熟练，那画不画都无所谓了。如果对于初中级开发人员， 或者针对复杂的业务，个人觉得业务流程图是有必要的。 其一：开发之前，业务可能理清楚了，但是开发进行到后期，很可能脑子就开始混乱，业务条理开始不清晰 其二： 只有亲自画流程图，当自己流程图出现不规范的时候，并且想着怎么优化流程图的时候，才知道业务逻辑可以被优化。流程图可以说是我们思维的形象化，流程图不规范，说明我们的逻辑很可能不是最优
详解SpringMVC注解@initbinder解决类型转换问题
08-27
本篇文章主要介绍了详解SpringMVC注解@initbinder解决类型转换问题，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用SpringMVC的@Validated注解验证的实现
08-25
主要介绍了使用SpringMVC的@Validated注解验证的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springmvc的@Validated注解使用
08-25
主要介绍了springmvc的@Validated注解使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springmvc源码分析
12-29
源码分析
对SpringMVC的@RequestParam的解释
08-29
下面小编就为大家带来一篇对SpringMVC的@RequestParam的解释。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring MVC 十一：@EnableWebMvc
weixin_44612246的博客
10-14 1923
SpringMVC @EnableWebMvc的作用于底层原理
Spring MVC 代理配置类 DelegatingWebMvcConfiguration
Details Inside Spring
02-15 5993
概述 DelegatingWebMvcConfiguration是对Spring MVC进行配置的一个代理类。它结合缺省配置和用户配置定义Spring MVC运行时最终使用的配置。 DelegatingWebMvcConfiguration继承自WebMvcConfigurationSupport。而WebMvcConfigurationSupport为Spring MVC提供缺省配置。这就是上面...
Spring常见问题解决 - @EnableWebMvc 导致自定义序列化器失效
Zong_0915的博客
08-31 1290
这篇文章是在Spring常见问题解决 - Body返回体中对应值为null的不输出？的基础上讲的。我们有时候，可能需要自定义一个序列化器来满足自己的需要，但是如果项目中不正确使用了注解，可能会导致这个自定义的序列化器失效。首先我们应该看下这个注解是拿来干啥的吧。项目中，如果我们希望自定义一些MVC的功能，我们只需要实现接口即可。无需添加注解。添加注解，会导致SpringBoot对MVC的自动装配失效。因为Spring对于类型的Bean只允许存在一个（包括其子类）。此时以序列化器为例，使用。......
详解@EnableWebMvc
aar49191的博客
03-29 1211
最近看了《Spring in Action》的开头，就被Spring注解开发（完全不写web.xml）惊叹了，也第一次知道了@EnableWebMvc是SpringMVC的注解 @EnableWebMvc注解 @EnableWebMvc的javaDoc注释有点长。 从下图得到的几个信息：href="mailto:1.@EnableWebMvc">1.@EnableWebMv...
SpringMVC中的拦截器不生效的问题解决以及衍生出的WebMvcConfigurationSupport继承问题思考
十八岁讨厌编程的博客
03-08 4732
本文涉及SpringMVC中的拦截器不生效的问题解决以及衍生出的WebMvcConfigurationSupport继承问题思考
WebMvcConfigurer接口配置讲解及@EnableWebMvc的坑
cristianoxm的博客
06-01 3280
一、@EnableWebMvc使用坑点解析 通过注解的方式来进行Spring4 MVC开发时，我们都会在配置文件中加入<mvc:annotation-driven/>标签，这个配置会自动注册了一个 RequestMappingHandlerMapping、一个RequestMappingHandlerAdapter、以及一个ExceptionHandlerExceptionResolver 以支持使用注解Controller的注解方法（如@RequestMapping、@ExceptionHan
@EnableWebMvc
hsRick的博客
11-02 1051
SpringMvc
springmvc使用@Scheduled
03-29
@Scheduled是Spring提供的一个注解，用于在指定时间间隔内定时执行任务。 使用@Scheduled需要在方法上添加注解，并指定cron表达式或时间间隔。 例如，下面的代码定义了一个每分钟执行一次的任务： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值