springmvc组件HandleMapping源码-AbstractUrlHandlerMapping

最新推荐文章于 2023-03-04 20:43:24 发布
最新推荐文章于 2023-03-04 20:43:24 发布
阅读量95 收藏
点赞数
分类专栏： springmvc源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39482039/article/details/119254926
版权 
/*
 * Copyright 2002-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.web.servlet.handler;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.web.servlet.HandlerExecutionChain;

/**
 * URL 映射的抽象基类 {@link org.springframework.web.servlet.HandlerMapping}
 * 实现。提供用于将处理程序映射到 URL 和可配置的基础结构
 * 网址查询。有关后者的信息，请参阅“alwaysUseFullPath”属性。
 *
 * <p>支持直接匹配，例如注册的“/test”匹配“/test”，并且
 * 各种 Ant 风格的模式匹配，例如注册的“/t*”模式匹配
 * "/test" 和 "/team", "/test/*" 匹配 "/test" 目录中的所有路径，
 * "/test/**" 匹配 "/test" 下的所有路径。有关详细信息，请参阅
 * {@link org.springframework.util.AntPathMatcher AntPathMatcher} javadoc。
 *
 * <p>将搜索所有路径模式以找到最精确的匹配
 * 当前请求路径。最精确的匹配被定义为最长的
 * 匹配当前请求路径的路径模式。
 *
 * @author Juergen Hoeller
 * @author Arjen Poutsma
 * @since 16.04.2003
 */
public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping implements MatchableHandlerMapping {

	@Nullable
	private Object rootHandler;

	private boolean useTrailingSlashMatch = false;

	private boolean lazyInitHandlers = false;

	private final Map<String, Object> handlerMap = new LinkedHashMap<>();


	/**
	 * 为这个处理程序映射设置根处理程序，即
	 * 要为根路径（“/”）注册的处理程序。
	 * <p>默认为 {@code null}，表示没有根处理程序。
	 */
	public void setRootHandler(@Nullable Object rootHandler) {
		this.rootHandler = rootHandler;
	}

	/**
	 * 返回此处理程序映射的根处理程序（为“/”注册），
	 * 或 {@code null} 如果没有。
	 */
	@Nullable
	public Object getRootHandler() {
		return this.rootHandler;
	}

	/**
	 * 是否与 URL 匹配而不考虑是否存在尾随斜杠。
	 * 如果启用，“/users”等 URL 模式也与“/users/”匹配。
	 * <p>默认值为{@code false}。
	 */
	public void setUseTrailingSlashMatch(boolean useTrailingSlashMatch) {
		this.useTrailingSlashMatch = useTrailingSlashMatch;
	}

	/**
	 * 是否与 URL 匹配而不考虑是否存在尾随斜杠。
	 */
	public boolean useTrailingSlashMatch() {
		return this.useTrailingSlashMatch;
	}

	/**
	 * 设置是否延迟初始化处理程序。仅适用于
	 * 单例处理程序，因为原型总是被延迟初始化。
	 * 默认为“false”，因为急切初始化可以提高效率
	 * 通过直接引用控制器对象。
	 * <p>如果你想让你的控制器延迟初始化，
	 * 使它们成为“lazy-init”并将此标志设置为 true。只是让他们
	 * "lazy-init" 不起作用，因为它们是通过
	 * 在这种情况下来自处理程序映射的引用。
	 */
	public void setLazyInitHandlers(boolean lazyInitHandlers) {
		this.lazyInitHandlers = lazyInitHandlers;
	}

	/**
	 * 查找给定请求的URL路径的处理程序。
	 *
	 * @param request current HTTP request
	 * @return the handler instance, or {@code null} if none found
	 */
	@Override
	@Nullable
	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		request.setAttribute(LOOKUP_PATH, lookupPath);
		Object handler = lookupHandler(lookupPath, request);
		if (handler == null) {
			// 我们需要直接关心默认处理程序，因为我们需要
			// 也为它公开 PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE。
			Object rawHandler = null;
			if ("/".equals(lookupPath)) {
				rawHandler = getRootHandler();
			}
			if (rawHandler == null) {
				rawHandler = getDefaultHandler();
			}
			if (rawHandler != null) {
				// Bean name or resolved handler?
				if (rawHandler instanceof String) {
					String handlerName = (String) rawHandler;
					rawHandler = obtainApplicationContext().getBean(handlerName);
				}
				validateHandler(rawHandler, request);
				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
			}
		}
		return handler;
	}

	/**
	 * 查找给定URL路径的处理程序实例。 * <p>
	 * 支持直接匹配，例如已注册的“ / test”匹配“ / test”，*，
	 * 以及各种Ant样式的模式匹配，例如注册的“ / t *”与“ / test”和“ / team”都匹配。
	 * 有关详细信息，请参见AntPathMatcher类。
	 * 找最精确的模式，其中最精确的定义为最长的路径模式。
	 *
	 * @param urlPath the URL the bean is mapped to
	 * @param request current HTTP request (to expose the path within the mapping to)
	 * @return the associated handler instance, or {@code null} if not found
	 * @see #exposePathWithinMapping
	 * @see org.springframework.util.AntPathMatcher
	 */
	@Nullable
	protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// Direct match?
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
			validateHandler(handler, request);
			return buildPathExposingHandler(handler, urlPath, urlPath, null);

		}

		// Pattern match?
		List<String> matchingPatterns = new ArrayList<>();
		for (String registeredPattern : this.handlerMap.keySet()) {
			if (getPathMatcher().match(registeredPattern, urlPath)) {
				matchingPatterns.add(registeredPattern);
			} else if (useTrailingSlashMatch()) {
				if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
					matchingPatterns.add(registeredPattern + "/");
				}
			}
		}

		String bestMatch = null;
		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
		if (!matchingPatterns.isEmpty()) {
			matchingPatterns.sort(patternComparator);
			if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
				logger.trace("Matching patterns " + matchingPatterns);
			}
			bestMatch = matchingPatterns.get(0);
		}
		if (bestMatch != null) {
			handler = this.handlerMap.get(bestMatch);
			if (handler == null) {
				if (bestMatch.endsWith("/")) {
					handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
				}
				if (handler == null) {
					throw new IllegalStateException(
							"Could not find handler for best pattern match [" + bestMatch + "]");
				}
			}
			// Bean name or resolved handler?
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
			validateHandler(handler, request);
			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);

			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
			// for all of them
			Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
			for (String matchingPattern : matchingPatterns) {
				if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
					uriTemplateVariables.putAll(decodedVars);
				}
			}
			if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) {
				logger.trace("URI variables " + uriTemplateVariables);
			}
			return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
		}

		// No handler found...
		return null;
	}

	/**
	 * 针对当前请求验证给定的处理程序。
	 * <p>默认实现为空。可以在子类中覆盖，
	 * 例如，强制执行 URL 映射中表达的特定先决条件。
	 *
	 * @param handler the handler object to validate
	 * @param request current HTTP request
	 * @throws Exception if validation failed
	 */
	protected void validateHandler(Object handler, HttpServletRequest request) throws Exception {
	}

	/**
	 * 为给定的原始处理程序构建一个处理程序对象，在执行处理程序之前，将实际的处理程序，
	 * {@link #PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE}以及{@link #URI_TEMPLATE_VARIABLES_ATTRIBUTE}公开。
	 * 默认实现使用特殊的拦截器构建{@link HandlerExecutionChain}
	 * 该拦截器公开了path属性和uri模板变量
	 *
	 * @param rawHandler           the raw handler to expose
	 * @param pathWithinMapping    the path to expose before executing the handler
	 * @param uriTemplateVariables the URI template variables, can be {@code null} if no variables found
	 * @return the final handler object
	 */
	protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
											  String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {

		HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
		chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
		if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
			chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
		}
		return chain;
	}

	/**
	 * 将当前映射中的路径公开为请求属性。
	 *
	 * @param pathWithinMapping the path within the current mapping
	 * @param request           the request to expose the path to
	 * @see #PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE
	 */
	protected void exposePathWithinMapping(String bestMatchingPattern, String pathWithinMapping,
										   HttpServletRequest request) {

		request.setAttribute(BEST_MATCHING_PATTERN_ATTRIBUTE, bestMatchingPattern);
		request.setAttribute(PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, pathWithinMapping);
	}

	/**
	 * 将 URI 模板变量公开为请求属性。
	 *
	 * @param uriTemplateVariables the URI template variables
	 * @param request              the request to expose the path to
	 * @see #PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE
	 */
	protected void exposeUriTemplateVariables(Map<String, String> uriTemplateVariables, HttpServletRequest request) {
		request.setAttribute(URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVariables);
	}

	@Override
	@Nullable
	public RequestMatchResult match(HttpServletRequest request, String pattern) {
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request, LOOKUP_PATH);
		if (getPathMatcher().match(pattern, lookupPath)) {
			return new RequestMatchResult(pattern, lookupPath, getPathMatcher());
		} else if (useTrailingSlashMatch()) {
			if (!pattern.endsWith("/") && getPathMatcher().match(pattern + "/", lookupPath)) {
				return new RequestMatchResult(pattern + "/", lookupPath, getPathMatcher());
			}
		}
		return null;
	}

	/**
	 * 为给定的 URL 路径注册指定的处理程序。
	 *
	 * @param urlPaths the URLs that the bean should be mapped to
	 * @param beanName the name of the handler bean
	 * @throws BeansException        if the handler couldn't be registered
	 * @throws IllegalStateException if there is a conflicting handler registered
	 */
	protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
		Assert.notNull(urlPaths, "URL path array must not be null");
		for (String urlPath : urlPaths) {
			registerHandler(urlPath, beanName);
		}
	}

	/**
	 * 为给定的URL路径注册指定的处理程序。
	 *
	 * @param urlPath the URL the bean should be mapped to
	 * @param handler the handler instance or handler bean name String
	 *                (a bean name will automatically be resolved into the corresponding handler bean)
	 * @throws BeansException        if the handler couldn't be registered
	 * @throws IllegalStateException if there is a conflicting handler registered
	 */
	protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
		Assert.notNull(urlPath, "URL path must not be null");
		Assert.notNull(handler, "Handler object must not be null");
		Object resolvedHandler = handler;

		// 如果通过名称引用单例，则急切地解析处理程序。
		if (!this.lazyInitHandlers && handler instanceof String) {
			String handlerName = (String) handler;
			ApplicationContext applicationContext = obtainApplicationContext();
			if (applicationContext.isSingleton(handlerName)) {
				resolvedHandler = applicationContext.getBean(handlerName);
			}
		}

		Object mappedHandler = this.handlerMap.get(urlPath);
		if (mappedHandler != null) {
			if (mappedHandler != resolvedHandler) {
				throw new IllegalStateException(
						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
								"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
			}
		} else {
			if (urlPath.equals("/")) {
				if (logger.isTraceEnabled()) {
					logger.trace("Root mapping to " + getHandlerDescription(handler));
				}
				setRootHandler(resolvedHandler);
			} else if (urlPath.equals("/*")) {
				if (logger.isTraceEnabled()) {
					logger.trace("Default mapping to " + getHandlerDescription(handler));
				}
				setDefaultHandler(resolvedHandler);
			} else {
				this.handlerMap.put(urlPath, resolvedHandler);
				if (logger.isTraceEnabled()) {
					logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
				}
			}
		}
	}

	private String getHandlerDescription(Object handler) {
		return (handler instanceof String ? "'" + handler + "'" : handler.toString());
	}


	/**
	 * 将注册的处理程序作为不可修改的 Map 返回，并带有注册的路径
	 * 作为键和处理程序对象（或延迟初始化处理程序的处理程序 bean 名称）
	 * 作为价值。
	 *
	 * @see #getDefaultHandler()
	 */
	public final Map<String, Object> getHandlerMap() {
		return Collections.unmodifiableMap(this.handlerMap);
	}

	/**
	 *指示此处理程序映射是否支持类型级映射。默认为 {@code false}。
	 */
	protected boolean supportsTypeLevelMappings() {
		return false;
	}


	/**
	 * Special interceptor for exposing the
	 * {@link AbstractUrlHandlerMapping#PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE} attribute.
	 *
	 * @see AbstractUrlHandlerMapping#exposePathWithinMapping
	 */
	private class PathExposingHandlerInterceptor extends HandlerInterceptorAdapter {

		private final String bestMatchingPattern;

		private final String pathWithinMapping;

		public PathExposingHandlerInterceptor(String bestMatchingPattern, String pathWithinMapping) {
			this.bestMatchingPattern = bestMatchingPattern;
			this.pathWithinMapping = pathWithinMapping;
		}

		@Override
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
			exposePathWithinMapping(this.bestMatchingPattern, this.pathWithinMapping, request);
			request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, handler);
			request.setAttribute(INTROSPECT_TYPE_LEVEL_MAPPING, supportsTypeLevelMappings());
			return true;
		}

	}

	/**
	 * 用于暴露的特殊拦截器
	 * {@link AbstractUrlHandlerMapping#URI_TEMPLATE_VARIABLES_ATTRIBUTE} attribute.
	 *
	 * @see AbstractUrlHandlerMapping#exposePathWithinMapping
	 */
	private class UriTemplateVariablesHandlerInterceptor extends HandlerInterceptorAdapter {

		private final Map<String, String> uriTemplateVariables;

		public UriTemplateVariablesHandlerInterceptor(Map<String, String> uriTemplateVariables) {
			this.uriTemplateVariables = uriTemplateVariables;
		}

		@Override
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
			exposeUriTemplateVariables(this.uriTemplateVariables, request);
			return true;
		}
	}

}

LouD_dm
关注
专栏目录
SpringMVC源码解读之HandlerMapping - AbstractUrlHandlerMapping系列request分发
09-02
在Spring MVC框架中，HandlerMapping是负责将HTTP请求映射到相应的处理器（Handler）的核心组件。AbstractUrlHandlerMapping是...理解这些源码对于深入学习Spring MVC的工作原理和优化应用性能非常有帮助。
SpringMVC ---- HelloWorld ---- 代码
09-18
SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- Hello...
springmvc组件HandleMapping源码分析-AbstractUrlHandlerMapping
qq_39482039的博客
08-08 87
1.AbstractUrlHandlerMapping继承图 2.概述 AbstractUrlHandlerMapping主要覆盖了AbstractHandlerMapping中的getHandlerInternal方法，根据请求的url获取到对应的处理器程序 3.AbstractUrlHandlerMapping源码翻译后的 https://blog.csdn.net/qq_39482039/article/details/119254926 4.getHandlerInternal方法 .
springmvc组件HandleMapping源码-AbstractDetectingUrlHandlerMapping
qq_39482039的博客
07-29 102
/* * Copyright 2002-2012 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.
springmvc组件HandleMapping源码分析-AbstractDetectingUrlHandlerMapping
qq_39482039的博客
07-29 111
1.AbstractDetectingUrlHandlerMapping继承图 2.概述 获取容器所有进行url映射的bean 3.AbstractDetectingUrlHandlerMapping整个代码用工具翻译后的 https://blog.csdn.net/qq_39482039/article/details/119221041 4.覆盖了AbstractUrlHandlerMapping的initApplicationContext方法，注册在上下文中找到的所有处理程序 /
springmvc组件HandleMapping源码分析-BeanNameUrlHandlerMapping
qq_39482039的博客
07-29 138
1.BeanNameUrlHandlerMapping继承图 2.概述 请求会映射到id或别名以/开头的bean，
springmvc源码分析3-DispatcherServlet
qq_39482039的博客
07-21 206
1.springmvc中DispatcherServlet继承体系 2.概述 1）初始化各种组件 主要组件有 MultipartResolver：文件上传处理 LocaleResolver：多语言支持 ThemeResolver：切换主题 HandlerMappings：处理器，这个请求的处理器 HandlerAdapters：处理器适配器，调用处理器 HandlerExceptionResolvers：全局异常处理 RequestToViewNameTranslator：如果没..
Servlet-Tomcat-Spring-SpringMVC-Mybatis 源码分析
Sunshine.wz的博客
08-01 615
源码分析—先看主干，再看分支 看源码，先看主干，把握主干，然后再看你自己关心的分支。 切记不要沿着源码一直一直点下来，这样很自己容易看蒙。 小技巧： 在源码中设置断点，然后按 F5 (进入方法中) 和 F6（向下执行）执行程序 在开源框架中，名字一般都是见名知意的，通过名字，可以大概知道方法的作用，从而选择是否跟进读 Servlet 源码分析 小技巧：使用 Maven 技术可以轻松查看源代码...
SpringMVC常见组件之HandlerMapping分析
小小默：进无止境
10-14 1128
在Spring MVC 3.1 之前的版本中，Spring默认使用 DefaultAnnotationHandlerMapping，AnnotationMethodHandlerAdapter来处理 @RequestMapping注解和请求方法调用，而从3.1开始提供了一组新的API，RequestMappingHandlerMapping和RequestMappingHandlerAdapter完成这些工作。 【1】几个概念 ① RequestMappingInfo 这个类是对请求映射的一个抽象，它包含了
zuul源码分析
donglebron的专栏
09-05 493
Zuul请求处理流程 zuul框架在处理http请求时，由springmvc所管理，一起看下具体流程： 请求由DispatchServlet分发，查找HandlerMapping，zuul框架定义了ZuulHandlerMapping，它是将路由规则绑定到了ZuulController上面； 查找HandlerMappingAdapter映射器处理器，由SimpleControllerH...
Spring MVC源码解析——HandlerMapping(处理器映射器)
小熊的学习记录
03-04 2774
在Spring MVC中，HandlerMapping（处理器映射器）用于确定请求处理器对象。请求处理器可以是任何对象，只要它们使用了@Controller注解或注解@RequestMapping。HandlerMapping负责将请求（url）映射到适当的处理器对象（Controller）。注：Handler即绑定了注解@RequestMapping或@Controller的类getHandler方法用于查找处理器对象并返回处理程序的执行链，HandlerExecutionChain包含了。
SpringMVC-Mybatis-Shiro-redis-0.2-master
01-25
基于SpringMVC Mybatis Shiro Redis 的权限管理系统，该系统已经部署到线上，线上访问地址：http://shiro.itboy.net，登录账号：admin 密码：sojson，，详细教程参考sojson.com/shiro
SpringMVC精品资源--JAX-RS & SpringMVC supported maven buil.zip
02-18
4. **文档教程**：可能包含PDF或Markdown格式的教程，解释了SpringMVC和JAX-RS的基本概念、核心组件和最佳实践，帮助初学者快速上手。 5. **代码样例**：各种示例代码片段，涵盖了从基础到进阶的各种用法，有助于...
毕业设计javajsp小区物业管理系统springmvc-sqlserver-qkrp源码含文档工具包
08-02
毕业设计javajsp小区物业管理系统springmvc-sqlserver-qkrp源码含文档工具包 页面是jsp，数据库sqlserver，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 本小区物业管理系统主要实现了管理员功能模块和...
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
最新发布
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
IMG_20240917_151703.jpg
09-17
IMG_20240917_151703.jpg
吉他谱_Pneuma - Tool.pdf
09-17
初级入门吉他谱 guitar tab
Java项目-基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的计算机网络课程试卷生成器系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
SpringMVC入门：模型-视图-控制器与项目搭建详解
在实际开发中，SpringMVC会配合Spring框架的其他组件如依赖注入（DI）、AOP（面向切面编程）等，提高代码的复用性和业务逻辑的清晰度。此外，SpringMVC还支持自定义拦截器（Interceptor）和视图解析器（View ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LouD_dm

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值