@RequestMapping的注册及查找过程

最新推荐文章于 2023-05-20 22:09:12 发布
最新推荐文章于 2023-05-20 22:09:12 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： Spring 文章标签： java 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzti_erlie/article/details/105608485
版权

在这里插入图片描述

介绍

一个@RequestMapping请求的流程如下

  1. 通过RequestMappingHandlerMapping返回HandlerMethod这种类型的handler
  2. 找到能处理HandlerMethod的RequestMappingHandlerAdapter
  3. RequestMappingHandlerAdapter执行业务逻辑返回ModelAndView

Spring容器启动的时候，会将@RequestMapping中的信息和要执行的方法存放在AbstractHandlerMethodMapping的内部类MappingRegistry中的5个成员变量中，其中的T为RequestMappingInfo，是对@RequestMapping注解信息的封装

class MappingRegistry {

	// MappingRegistration包含
	// 1. 映射信息
	// 2. 映射信息中的直接路径（非模式化路径）
	// 3. 映射名
	// 4. 对应的处理器方法
	
	// 分别为下面4个map的key
	// 这个只是对4个key的封装，只在unregister方法中会使用
	private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

	// RequestMappingInfo -> HandlerMethod
	private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();

	// 不包含通配符的url -> List<RequestMappingInfo>
	// 这里为什么是一个List呢？因为一个url有可能对应多个方法，即这些方法的@RequestMapping注解path属性一样，但是其他属性不一样
	private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();

	// 映射名 -> HandlerMethod
	private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

	// HandlerMethod -> 跨域配置
	private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
}

其中最主要的是如下2个map，其余的本节关联不大，不再分析

urlLookup：保存了如下映射关系
key=不包含通配符的url
value=List<RequestMappingInfo>

mappingLookup：
key=RequestMappingInfo
value=HandlerMethod

为什么需要这2个map呢？先留着这个问题，我们继续往后看

RequestMappingHandlerMapping的查找过程

RequestMappingHandlerMapping的继承关系如下
在这里插入图片描述
HandlerMapping接口一个getHandler方法，用来根据请求的url找到对应的HandlerExecutionChain对象。

public interface HandlerMapping {

	@Nullable
	HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

而HandlerExecutionChain对象就是简单的将url对应的Handler和拦截器封装了一下

public class HandlerExecutionChain {

	private final Object handler;

	@Nullable
	private List<HandlerInterceptor> interceptorList;
}

通过debug发现，整个查找过程只是依次调用了如下3个方法

  1. AbstractHandlerMapping#getHandler
  2. AbstractHandlerMethodMapping#getHandlerInternal
  3. AbstractHandlerMethodMapping#lookupHandlerMethod

AbstractHandlerMapping#getHandler

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	// getHandlerInternal 是模板方法，留给子类去实现
	Object handler = getHandlerInternal(request);
	if (handler == null) {
		// 没有获取到使用默认的handler
		handler = getDefaultHandler();
	}
	if (handler == null) {
		return null;
	}
	// Bean name or resolved handler?
	// 如果handler是string类型，则以它为名从容器中查找相应的bean
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = obtainApplicationContext().getBean(handlerName);
	}

	// 拿到handler，和我们配置的拦截器，封装成HandlerExecutionChain对象返回
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
	// 跨域配置
	if (CorsUtils.isCorsRequest(request)) {
		CorsConfiguration globalConfig = this.globalCorsConfigSource.getCorsConfiguration(request);
		CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
		CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}
	return executionChain;
}

可以看到找handler的过程是交由子类去实现的。并将对这个请求适用的拦截器，跨域配置，handler封装成HandlerExecutionChain返回给DispatcherServlet

AbstractHandlerMethodMapping#getHandlerInternal

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	// 获取请求路径，作为查找路径
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	if (logger.isDebugEnabled()) {
		logger.debug("Looking up handler method for path " + lookupPath);
	}
	// 获取读锁
	this.mappingRegistry.acquireReadLock();
	try {
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		if (logger.isDebugEnabled()) {
			if (handlerMethod != null) {
				logger.debug("Returning handler method [" + handlerMethod + "]");
			}
			else {
				logger.debug("Did not find handler method for [" + lookupPath + "]");
			}
		}
		// handlerMethod就是要执行的controller方法的封装
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	}
	finally {
		this.mappingRegistry.releaseReadLock();
	}
}

这一步做的事情也不是很多，就是根据url找到对应的HandlerMethod

AbstractHandlerMethodMapping#lookupHandlerMethod

兜兜转转终于来到根据请求获取相应的HandlerMethod对象了

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
	// 匹配结果列表
	List<Match> matches = new ArrayList<>();
	// 直接匹配
	List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
	// 如果有匹配的，就添加进匹配列表中
	if (directPathMatches != null) {
		addMatchingMappings(directPathMatches, matches, request);
	}
	// 还没有匹配，就遍历所有的处理方法去找
	if (matches.isEmpty()) {
		// No choice but to go through all mappings...
		addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
	}

	// 匹配结果不为空
	if (!matches.isEmpty()) {
		// 匹配结果比较器，直接使用匹配信息进行比较
		Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
		// 对多个匹配结果进行排序
		matches.sort(comparator);
		if (logger.isTraceEnabled()) {
			logger.trace("Found " + matches.size() + " matching mapping(s) for [" + lookupPath + "] : " + matches);
		}
		// 最佳匹配
		Match bestMatch = matches.get(0);
		if (matches.size() > 1) {
			if (CorsUtils.isPreFlightRequest(request)) {
				return PREFLIGHT_AMBIGUOUS_MATCH;
			}
			Match secondBestMatch = matches.get(1);
			// 第一个元素和第二个元素进行比较
			if (comparator.compare(bestMatch, secondBestMatch) == 0) {
				// 结果为0，至少有2个最佳匹配
				Method m1 = bestMatch.handlerMethod.getMethod();
				Method m2 = secondBestMatch.handlerMethod.getMethod();
				// 多个最佳匹配，抛出异常
				throw new IllegalStateException("Ambiguous handler methods mapped for HTTP path '" +
						request.getRequestURL() + "': {" + m1 + ", " + m2 + "}");
			}
		}
		request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
		handleMatch(bestMatch.mapping, lookupPath, request);
		// 返回最佳匹配对应的处理器方法
		return bestMatch.handlerMethod;
	}
	else {
		// 没有匹配结果，执行无处理器匹配方法，可执行一些特殊逻辑
		return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
	}
}

这个方法就涉及到我们最开始提到的那2个map。

urlLookup
key=不包含通配符的url
value=List<RequestMappingInfo>

mappingLookup
key=RequestMappingInfo
value=HandlerMethod

  1. 先根据url从urlLookup中查找对应的RequestMappingInfo，如果找到的List<RequestMappingInfo>不为空，则判断其他匹配条件是否符合
  2. 如果其他条件也有符合的，则不再遍历所有的RequestMappingInfo，否则遍历所有的RequestMappingInfo，因为考虑到有通配符形式的url必须遍历所有的RequestMappingInfo才能找出来符合条件的
  3. 如果最终找到的RequestMappingInfo有多个，则按照特定的规则找出一个最匹配的，并返回其对应的HandlerMethod

可能有小伙伴有很多疑惑，为什么一个请求请求地址会有多个实现。我给你举一个例子，有3个相同的handler方法，@RequestMapping中的其他属性都相同，只是method不同，这样就有可能根据一个url找到3个RequestMappingInfo，这样就有选择一个最优RequestMappingInfo的过程

当然还有其他情况，比如一个url同时匹配2个通配符路径。

可以看出来查找的过程还是挺简单的，接着我们就来分析一下注册的过程

RequestMappingHandlerMapping的初始化过程

从上面的分析中我们可以得出结论，在Spring容器启动后，RequestMappingInfo和HandlerMethod的映射关系已经被保存到MappingRegistry对象中，那么它是多会保存的以及以何种形式保存的？

通过查看调用关系法相，MappingRegistry中各种映射关系的初始化在register()方法，所以我们只需要在其register()方法上加一个断点，查看其调用链路即可

在这里插入图片描述

  1. RequestMappingHandlerMapping#afterPropertiesSet
  2. AbstractHandlerMethodMapping#afterPropertiesSet
  3. AbstractHandlerMethodMapping#initHandlerMethods
  4. AbstractHandlerMethodMapping#detectHandlerMethods
  5. AbstractHandlerMethodMapping#registerHandlerMethod

从RequestMappingInfoHandlerMapping可以看出AbstractHandlerMethodMapping中的泛型类为RequestMappingInfo

RequestMappingInfoHandlerMapping extends AbstractHandlerMethodMapping<RequestMappingInfo>

接着仔细分析这些方法

RequestMappingHandlerMapping#afterPropertiesSet

@Override
public void afterPropertiesSet() {
	// 创建映射信息构造器配置，用于构造映射信息RequestMappingInfo
	this.config = new RequestMappingInfo.BuilderConfiguration();
	this.config.setUrlPathHelper(getUrlPathHelper());
	this.config.setPathMatcher(getPathMatcher());
	this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
	this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
	this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
	// 设置内容协商管理器组件
	this.config.setContentNegotiationManager(getContentNegotiationManager());

	// 执行处理器方法的初始化逻辑
	super.afterPropertiesSet();
}

主要做了一些初始化设置

AbstractHandlerMethodMapping#afterPropertiesSet

@Override
public void afterPropertiesSet() {
	initHandlerMethods();
}

单纯调用initHandlerMethods方法

AbstractHandlerMethodMapping#initHandlerMethods

protected void initHandlerMethods() {
	if (logger.isDebugEnabled()) {
		logger.debug("Looking for request mappings in application context: " + getApplicationContext());
	}
	
	// 获取ApplicationContext中所有BeanName
	String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
			BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :
			obtainApplicationContext().getBeanNamesForType(Object.class));

	for (String beanName : beanNames) {
		// 排除Scoped目标类型Bean
		if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
			Class<?> beanType = null;
			try {
				beanType = obtainApplicationContext().getType(beanName);
			}
			catch (Throwable ex) {
				// An unresolvable bean type, probably from a lazy bean - let's ignore it.
				if (logger.isDebugEnabled()) {
					logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
				}
			}
			// 如果获取的BeanName类型不为空，且是一个处理器类型的Bean
			// 如果beanType上有Controller注解或者RequestMapping注解则是handler
			if (beanType != null && isHandler(beanType)) {
				detectHandlerMethods(beanName);
			}
		}
	}
	handlerMethodsInitialized(getHandlerMethods());
}

从容器中拿到所有的beanName，排除Scope类型的bean，根据beanName得到beanType，如果一个beanType是一个handler，则调用AbstractHandlerMethodMapping#detectHandlerMethods方法

AbstractHandlerMethodMapping#detectHandlerMethods

注册的重头戏就在这里了

protected void detectHandlerMethods(Object handler) {
	// 如果传入的handler是String类型，则表示是一个BeanName，从上下文获取
	Class<?> handlerType = (handler instanceof String ?
			obtainApplicationContext().getType((String) handler) : handler.getClass());

	if (handlerType != null) {
		Class<?> userType = ClassUtils.getUserClass(handlerType);
		// Method -> Method上对应的RequestMappingInfo
		Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
				(MethodIntrospector.MetadataLookup<T>) method -> {
					try {
						return getMappingForMethod(method, userType);
					}
					catch (Throwable ex) {
						throw new IllegalStateException("Invalid mapping on handler class [" +
								userType.getName() + "]: " + method, ex);
					}
				});
		if (logger.isDebugEnabled()) {
			logger.debug(methods.size() + " request handler methods found on " + userType + ": " + methods);
		}
		methods.forEach((method, mapping) -> {
			// 获取真实的可执行的方法，因为上述查找逻辑在特殊情况下查找到的方法可能存在于代理上
			// 需要获取非代理方法作为可执行方法调用
			Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
			registerHandlerMethod(handler, invocableMethod, mapping);
		});
	}
}

就是获取Handler上的Method，以及根据Method上@RequestMapping注解封装的RequestMappingInfo，

最后根据Handler，Method，RequestMappingInfo将映射关系注册到map中

AbstractHandlerMethodMapping#registerHandlerMethod

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
	this.mappingRegistry.register(mapping, handler, method);
}

AbstractHandlerMethodMapping#MappingRegistry#register

主要就是初始化本文最开始说的MappingRegistry中的5个成员变量

public void register(T mapping, Object handler, Method method) {
	// 获取写锁
	this.readWriteLock.writeLock().lock();
	try {
		// 把类和方法封装为HandlerMethod
		HandlerMethod handlerMethod = createHandlerMethod(handler, method);
		// 保证方法映射唯一
		// 如果一个相同的url对应多个handlerMethod则会抛出异常
		assertUniqueMethodMapping(handlerMethod, mapping);
		// 向映射查找表中添加  映射信息->对应的处理器方法
		this.mappingLookup.put(mapping, handlerMethod);

		if (logger.isInfoEnabled()) {
			logger.info("Mapped \"" + mapping + "\" onto " + handlerMethod);
		}

		// 存储 不带统配符的url -> RequestMappingInfo 的映射关系
		List<String> directUrls = getDirectUrls(mapping);
		for (String url : directUrls) {
			this.urlLookup.add(url, mapping);
		}

		String name = null;
		// 命名策略不为空
		if (getNamingStrategy() != null) {
			// 通过命名策略获取映射名
			name = getNamingStrategy().getName(handlerMethod, mapping);
			// 注册到nameLookup
			addMappingName(name, handlerMethod);
		}

		// 获取HandlerMethod对应的CORS配置
		CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
		if (corsConfig != null) {
			this.corsLookup.put(handlerMethod, corsConfig);
		}

		// 注册跨域配置
		this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
	}
	finally {
		this.readWriteLock.writeLock().unlock();
	}
}

至此整个注册过程分析完毕，总结起来就是初始化Map和从Map中取值的过程

参考博客

[1]https://www.cnblogs.com/Java-Starter/p/10315964.html
[2]https://cloud.tencent.com/developer/article/1497621

Java识堂
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
简化版@requestmapping注解注册源码
03-26
根据读@requestmapping源码，理解实现原理后，自己写的简单的仿@requestmapping的代码，将该代码放置到自己的工程中就可以用。
02@RequestMapping映射.md
最新发布
08-24
02@RequestMapping映射.md
Spring MVC之@RequestMapping详解
09-21
前段时间项目中用到了REST风格来开发程序，但是当用POST、PUT模式提交数据时，发现服务器端接受不到提交的数据（服务器端参数绑定没有加任何注解），查看了提交方式为application/json， 而且服务器端通过request.getReader() 打出的数据里确实存在浏览器提交的数据。为了找出原因，便对参数绑定（@RequestParam、 @RequestBody、 @RequestHeader 、 @PathVariable）进行了研究，同时也看了一下HttpMessageConverter的相关内容，在此一并总结。
SpringMVC@RequestMapping(重点)@RequestParam@PathVariable示例
05-15
SpringMVC@RequestMapping(重点)@RequestParam@PathVariable示例
Spring MVC之@RequestMapping注解详解
08-31
本篇文章主要介绍了Spring MVC之@RequestMapping 详解，RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。有兴趣的可以了解一下。
IDEA插件系列（83）：Request mapper插件——搜索SpringMVC中的请求URL
二木成林
08-25 3935
1.插件介绍 Request mapper插件。 用于快速导航到 url 映射声明的插件。 支持的语言： Java Kotlin 支持的框架： Spring JAX-RS Micronaut 2.安装方式 第一种方式，是在IDEA上搜索插件进行安装，会适配当前IDEA的版本。 第二种安装方式是使用离线插件进行安装。 插件下载地址：https://plugins.jetbrains.com/plugin/9567-request-mapper 3.使用方法 快捷键 Sh
Spring 系列（三）：你真的懂@RequestMapping吗？
Firstlucky77的博客
06-23 645
前言上篇给大家介绍了Spring MVC父子容器的概念，主要提到的知识点是:在文章最后我也给大家也留了一个问题，既然子容器找不到就去父容器找，那干脆把bean定义都放在父容器不就行了？是这样吗，我们做个实验。我们把 这条语句从spring-mvc.xml文件中挪到spring.xml中，重启应用。会发现报404，如下图：404说明请求的资源没有找到，为什么呢？使用Spring MVC的同学一般都会以下方式定义请...
SpringMVC系列六：RequestMappingHandlerMapping的初始化
Running666的博客
05-20 238
因为RequestMappingHandlerMapping实现InitializingBean接口所以在spring初始化的时候调用在RequestMappingHandlerMapping的afterPropertiesSet方法，并在其中设置 Method 与 RequestMappingInfo 的映射关系。设置请求 url 与 RequestMappingInfo 的映射关系，设置 RequestMappingInfo 与 HandlerMethod 的映射关系。解析映射关系初始化完成。
springboot实现最基础的登录注册功能(步骤详细，逻辑清晰)
热门推荐
qq_44697268的博客
08-15 3万+
springboot实现最基础的登录注册功能
RequestMapping
weixin_45156514的博客
04-28 179
@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。 @Controller public class TestController { @RequestMapping("/h1") public String test(){ return "test"; } } 访问路径：http://localhost:8080 / 项目名 / h1 @Controller
@RequestMapping 使用@PathVariable 从URI中获取参数
梅川酷紫
12-05 1万+
@RequestMapping 使用@PathVariable 从URI中获取参数URI中的请求参数定义URL变量规则获取URI变量定义多个URL变量匹配正则表达式 URI中的请求参数 在Web应用中URL通常不是一成不变的，例如微博两个不同用户的个人主页对应两个不同的URL：http://weibo.com/user1,http://weibo.com/user2 。我们不能对于每一个用户都编写...
java获取 requestmapping的value url_关于requestMapping 进行url映射实现小小知识点 以及如何获取请求的url中的参数...
weixin_39781363的博客
02-27 741
requstMapping 用来处理url映射 可以作用在controller类上 也可以作用在方法上经常使用的方式 通过接收一种映射关系@RequestMapping("/deleteMainMultipleMessages")publicModelAndView deleteMainMultipleMessages(String id[]){for (int i = 0; i < ...
SpringMVC获取所有RequestMapping以及对应方法和参数
weixin_42290901的博客
04-19 1753
在Spring MVC中想要对每一个URL进行权限控制，不想手工整理这样会有遗漏，所以就动手写程序了。代码如下： /** * @return * @author 杨红杰 * 创建时间：2021年4月19日 * 功能：返回系统中的所有控制器映射路径，以及对应的方法 */ @RequestMapping(value = "/maps", produces = "application/json; charset=utf-8") @ResponseBody p
Android Groovy 动态（十三）
假装你是大灰狼的专栏
10-11 263
首先申明下，本文为笔者学习《Groovy 程序设计》的笔记，并加入笔者自己的理解和归纳总结。 1. 动态访问 访问属性 class AGroovyClass { int value = 10 } obj = new AGroovyClass() pName = "value" println obj["value"] // 10 println obj.value // 10 pr...
sping-mvc @RequestMapping注解不生效404、500报错
09-18 1716
解决spring-mvc ，RequestMapping注解不生效
springmvc 路径注册MappingRegistry
weixin_42859458的博客
06-29 1616
之前一直好奇为什么我们写上@RequestMapping就能访问我们的程序接口，研究源码发现是spring在启动的时候就已经把我们的所有包含@RequestMapping的类和方法上的路径拼接好放在一个map缓存中，后面我们通过请求url的时候会直接从缓存中获取，然后匹配，今天就带大家看一下springmvc是如何将我们写的@RequestMapping上的路径注册给程序并放入缓存中的，话不多说，上源码。 spring在启动的时候会初始化AbstractHandlerMethodMapping类，他实现了I
SpringMVC--@RequestMapping的注册及查找流程
IT利刃出鞘的博客
02-05 917
其他网址 Spring MVC源码解析之流程解析：@RequestMapping的注册及查找过程_小识的博客-CSDN博客
@RequestMapping
weixin_44471080的博客
09-10 4989
@RequestMapping 是 Spring Web 应用程序中最常被用到的注解之一。这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上。 源码 @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Mapping public @interface RequestMapping { String name() default ""
【Spring MVC】@RequestMapping 详解
pcdd 的博客
11-09 3286
RequestMapping注解一共有8个属性，常用的有value属性、method属性，其它6个属性往往容易被忽视，因此本文将逐一介绍这8个属性的作用及用法示例代码依赖版本如下。
、(2分 ) @RequestMapping注解有四种请求表示方式，下列选项中属于它请求方式的是( ) A @RequestMapping( "/helloWorld.action" ) B. @RequestMapping(url= "/helloWorld.action" )с. @RequestMapping(name= "/helloWorld.action" )D. @RequestMapping(path=( "/hellWorld.action )
06-10
@RequestMapping( "/helloWorld.action" )。@RequestMapping 是 Spring MVC 框架中用于处理请求映射的注解。它可以标注在类或方法上，用于指定请求的 URL 和请求方法等信息。@RequestMapping 注解有四个常用的属性...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Java识堂

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

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

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

打赏作者

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

抵扣说明：

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

余额充值