简单理解SpringMvc模块组件

编辑推荐:

文章主要介绍了使用非资源配置(不使用XML文件)搭建一个Spring项目。并没有说明SpringMVC是如何加载各个组件的，希望对您的学习有所帮助。

@EnableWebMvc 注解

之前介绍过Spring的模式注解，其实@EnableWebMvc就是一个模式注解，我们来看一下这个注解

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

我们可以看到这个注解使用了驱动注解编程,通过引用
DelegatingWebMvcConfiguration 这个类来实现装配，但是我们进一步看一下 DelegatingWebMvcConfiguration 这个类，发现这个类中没有任何一个Bean定义。

@Configuration
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);
}
}

@Override
protected void configurePathMatch(PathMatchConfigurer 
configurer) {
this.configurers.configurePathMatch(configurer);
}
@Override
protected void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
this.configurers.configureContentNegotiation(configurer);
}
......
}

只是简单的覆盖父类的方法，那么我们在进入父类
WebMvcConfigurationSupport 看一下。

在
WebMvcConfigurationSupport中我们发现了很多默认的@Bean定义，结合之前一篇文章，Debugger的时候发现在 org.springframework.web.servlet . DispatcherServlet#getHandler 方法中有两个 HandlerMapping 具体的实现类。

一个是
RequestMappingHandlerMapping,另一个是 BeanNameUrlHandlerMapping 这两个Bean定义我们都可以在WebMvcConfigurationSupport中找到初始化的Bean。

/**
* Return a {@link BeanNameUrlHandlerMapping} ordered 
at 2 to map URL
* paths to controller bean names.
*/
@Bean
public BeanNameUrlHandlerMapping beanNameHandle
rMapping() {
BeanNameUrlHandlerMapping mapping = new BeanNameUrlHandlerMapping();
mapping.setOrder(2);
mapping.setInterceptors(getInterceptors());
mapping.setCorsConfigurations(getCorsConfigurations());
return mapping;
}

@Bean
public RequestMappingHandlerMapping requestMappingHandlerMapping() {
RequestMappingHandlerMapping mapping = createRequest
MappingHandlerMapping();
mapping.setOrder(0);
mapping.setInterceptors(getInterceptors());
mapping.setContentNegotiationManager(mvcContent
NegotiationManager());
mapping.setCorsConfigurations(getCorsConfigurations());
PathMatchConfigurer configurer = getPathMatchConfigurer();
Boolean useSuffixPatternMatch = configurer.isUse
SuffixPatternMatch();
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);
}
return mapping;
}

同理，实现默认的HandlerAdapter接口的类也是在这里定义的。这里就不多做阐述，感兴趣的小伙伴可以自己去看一下源码。

其实SpringMvc默认的组件加载就是在@EnableWebMvc这个注解标注在某个@Configuration 类上时，通过
DelegatingWebMvcConfiguration 这个类来加载的，然后在Servlet中组装

注入组件

了解了如何加载，那么这些组件是何时注入的呢? 其实是在刷新上下文成功后注入的。

具体方法流程是

@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}

其实注入的方式都是一样的，我们就打开其中一个注入方法看一下细节 #initHandlerMappings()

/**
* Initialize the HandlerMappings used by this class.
* <p>If no HandlerMapping beans are defined in the 
BeanFactory for this namespace,
* we default to 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<>(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");
}
}
}

在这里最主要的就是

Map<String, HandlerMapping> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);

这一段代码，这段代码就是通过应用上下文找到所有实现 HandlerMapping接口的Bean并装载到DispatcherServlet中。

自定义组件-- WebMvcConfigurer

在上面的
DelegatingWebMvcConfiguration这个类中我们发现有一个方法那就是

@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> 
configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}
}

这个方法就是加载自定义配置组件的类方法。从这个方法的参数中我们可以看出，所有的自定义组件必须实现org .springframework .web .servlet.config .annotation .WebMvcConfigurer接口。

下面来让我们实现一个简单的自定义组件。让我们添加一个在执行HandlerAdapter 方法之前的拦截器。

简单的代码如下，该代码是在上一篇的配置类的新增的。

/**
* Spring Mvc 配置
*/
@Configuration //配置
@EnableWebMvc //激活组件并自动装配
@ComponentScan(basePackages = "com.web")
public class WebMvcConfig implements WebMvcConfigurer {
/**
* <bean id="viewResolver" class="org.springframework.web.servlet.view.Internal
ResourceViewResolver">
* <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
* <property name="prefix" value="/WEB-INF/jsp/"/>
* <property name="suffix" value=".jsp"/>
* </bean>
* @return
*/
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
internalResourceViewResolver.setViewClass(JstlView.class);
internalResourceViewResolver.setPrefix("/WEB-INF/jsp/");
internalResourceViewResolver.setSuffix(".jsp");
return internalResourceViewResolver;
}

//增加自定义拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new HandlerInterceptor() {
@Override
public boolean preHandle(HttpServletRequest request, 
HttpServletResponse response, Object handler) throws 
Exception System.out.println("---------自定义拦截器拦截
-------");
return true;
}
});
}
}

同时我们改一下controller代码。

@Controller
public class HelloWorldController {
@RequestMapping("/index")
public String index() {
System.out.println("执行HelloWorldController中的index()方法");
return "index";
}
}

自定义完成之后接下来只需要跑一下程序，就可以看到自定义的组件是否加载到了容器之中，并成功拦截。

我们已经简单的实现了一个自定义组件,我们可以通过根据业务需要覆盖WebMvcConfigurer接口中的默认方法来丰富我们的项目。

因为内容实在是太多了，小编在此就不做过多的介绍了，想了解更多的Java知识可以关注小编！