Spring-AOP @AspectJ切点函数之args()和@args()

最新推荐文章于 2023-09-30 22:42:22 发布
最新推荐文章于 2023-09-30 22:42:22 发布
阅读量2.9w 收藏 16
点赞数 1
分类专栏： 【Spring-AOP进阶】 文章标签： spring aop args
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/77731696
版权

文章目录

概述

args函数的入参是类名， 而 @args()的入参必须是注解类的类名。

虽然args()允许在类名后使用“+”通配符，但该通配符在此处没有意义，添加和不添加的效果都一样。

args()

该函数接收一个类名，表示目标类方法入参对象是指定类（包含子类）时，切点匹配。

比如args(com.xgj.Waiter) 表示运行时入参是Waiter类型的方法，它和execution(* *(com.xgj.Waiter))的区别在于后者是这对类方法的签名而言的，而前者是针对运行时的入参类型而言。

比如args(com.xgj.Waiter)既匹配addWiter（Waiter waiter），又匹配addNaiveWaiter(NaiveWaiter waiter)； 而 execution(* *(com.xgj.Waiter))，实际上 args(com.xgj.Waiter)等价于 execution(* *(com.xgj.Waiter+))，当然也等价于 args(com.xgj.Waiter+)

@args()

该函数接收一个注解类的类名，当方法的运行时入参对象标注了指定的注解时，匹配切点。

我们来通过下图@args（M）匹配示意图来详细解释下：

这里写图片描述

T0、T1、T2、T3有如上继承关系，假设目标类方法的签名为fun(T1 t),它的入参为T1,而切面的切点定义为@args(M), T2类标注了@M。 当fun(T1 t)的传入对象为T2或者T3时，方法匹配@args(M)声明所定义的切点。

假设方法签名是funt(T1 t),入参为T1，而标注了@M的类是T0,当fun(T1 t)传入T1、T2、T3的实例时，均不匹配切点@args(M).

在类的继承树中，（1）处为方法签名中入参类型在继承树的位置，称之为入参类型点， 而（2）处标注了@M注解的类在类继承树中的位置，称之为注解点。 判断方法在运行时是否匹配@args(M)切点，可以根据（1）和（2）在类继承树中的相对位置来判断。

  • 如果在继承树中注解点（2）高于入参类型点（1），则该目标方法不可能匹配到切点@args(M) ,如下图所示

这里写图片描述

  • 如果在类继承树中注解点（2）低于入参类型点（1），则注解点所在类及其子孙类作为方法入参时，该方法匹配切点@args(M)

实例请参考下文。

实例

代码已托管到Github—> https://github.com/yangshangwei/SpringMaster

args()

在这里插入图片描述

POJO

package com.xgj.aop.spring.advisor.aspectJ.function.args;

import org.springframework.stereotype.Component;

@Component
public class UserService {

	public void addUser(User user) {
		System.out.println("addUser " + user);
	}

	public void modifyUser(User user) {
		System.out.println("modifyUser " + user);
	}

	public void delUser(User user) {
		System.out.println("delUser " + user);
	}

	/**
	 * 
	 * 
	 * @Title: addArtisanTT
	 * 
	 * @Description: 入参为ArtisanTT
	 * 
	 * @param artisan
	 * 
	 * @return: void
	 */
	public void addArtisanTT(ArtisanTT artisan) {
		System.out.println("addArtisanTT " + artisan);
	}

	public void modifyArtisanTT(ArtisanTT artisan) {
		System.out.println("modifyArtisanTT " + artisan);
	}

	public void delArtisanTT(ArtisanTT artisan) {
		System.out.println("delArtisanTT " + artisan);
	}

}

POJO

package com.xgj.aop.spring.advisor.aspectJ.function.args;

import org.springframework.stereotype.Component;

@Component
public class UserServiceExt {
	public void addUser(User user) {
		System.out.println("入参为user的类  addUser " + user);
	}

	public void modifyUser(User user) {
		System.out.println("入参为user的类   modifyUser " + user);
	}

	public void delUser(User user) {
		System.out.println("入参为user的类  delUser " + user);
	}

	/**
	 * 
	 * 
	 * @Title: addArtisanTT
	 * 
	 * @Description: 入参为ArtisanTT
	 * 
	 * @param artisan
	 * 
	 * @return: void
	 */
	public void addArtisanTT(ArtisanTT artisan) {
		System.out.println("addArtisanTT " + artisan);
	}

	public void modifyArtisanTT(ArtisanTT artisan) {
		System.out.println("modifyArtisanTT " + artisan);
	}

	public void delArtisanTT(ArtisanTT artisan) {
		System.out.println("delArtisanTT " + artisan);
	}
}

切面

package com.xgj.aop.spring.advisor.aspectJ.function.args;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * 
 * 
 * @ClassName: ArgsAspectJ
 * 
 * @Description: 该函数接收一个类名，表示目标类方法入参对象是指定类（包含子类）时，切点匹配
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年9月1日 上午11:36:23
 */

@Aspect
public class ArgsAspect {

	@Before("args(com.xgj.aop.spring.advisor.aspectJ.function.args.User)")
	public void crossCuttingCode() {
		System.out.println("some logic is here ");
	}
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context 
       	http://www.springframework.org/schema/context/spring-context.xsd">

<!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
<context:component-scan base-package="com.xgj.aop.spring.advisor.aspectJ.function.args"/>


 
<!-- 基于@AspectJ切面的驱动器 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>
 


<!-- 使用了@AspectJ注解的切面类 -->
<bean class="com.xgj.aop.spring.advisor.aspectJ.function.args.ArgsAspect"/>

</beans>

测试类：

package com.xgj.aop.spring.advisor.aspectJ.function.args;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ArgsAspectTest {

	private ApplicationContext ctx;

	@Test
	public void test() {
		ctx = new ClassPathXmlApplicationContext("classpath:com/xgj/aop/spring/advisor/aspectJ/function/args/conf-args.xml");
		UserService userService = ctx.getBean("userService", UserService.class);
		UserServiceExt userServiceExt = ctx.getBean("userServiceExt", UserServiceExt.class);

		User user = new User();
		ArtisanTT artisan = new ArtisanTT();

		// 织入横切逻辑
		userService.addUser(user);
		// 织入横切逻辑
		userService.modifyUser(user);
		// 织入横切逻辑
		userService.delUser(user);

		System.out.println("================================");
		// 入参不是user，因此不会被织入横切逻辑
		userService.addArtisanTT(artisan);
		userService.modifyArtisanTT(artisan);
		userService.delArtisanTT(artisan);

		System.out.println("================================");

		// 入参为user，因此也会被织入横切逻辑
		userServiceExt.addUser(user);
		// 入参为user，因此也会被织入横切逻辑
		userServiceExt.modifyUser(user);
		// 入参为user，因此也会被织入横切逻辑
		userServiceExt.delUser(user);
		System.out.println("================================");

		// 入参不是user，因此不会被织入横切逻辑
		userServiceExt.addArtisanTT(artisan);
		userServiceExt.modifyArtisanTT(artisan);
		userServiceExt.delArtisanTT(artisan);

	}
}

运行结果：

2018-01-04 09:19:50,614  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4a05bc0c: startup date [Thu Jan 04 09:19:50 CST 2018]; root of context hierarchy
2018-01-04 09:19:50,795  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/conf-args.xml]
some logic is here 
addUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
some logic is here 
modifyUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
some logic is here 
delUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
================================
addArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
modifyArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
delArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
================================
some logic is here 
入参为user的类  addUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
some logic is here 
入参为user的类   modifyUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
some logic is here 
入参为user的类  delUser com.xgj.aop.spring.advisor.aspectJ.function.args.User@657531ef
================================
addArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
modifyArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2
delArtisanTT com.xgj.aop.spring.advisor.aspectJ.function.args.ArtisanTT@712175f2

@args()

首先我们先自定义一个注解，用于测试用

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 
 * 
 * @ClassName: Monitor
 * 
 * @Description: 自定义注解 @Monitor
 *               更多信息请阅读http://blog.csdn.net/yangshangwei/article/
 *               details/77477840
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年9月1日 下午4:00:12
 */

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
public @interface Monitor {

	public boolean value() default true;
}

使用注解扫描的4个POJO

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.springframework.stereotype.Component;

@Component
public class T0 {

}


package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.springframework.stereotype.Component;

@Component
public class T1 extends T0 {

	/**
	 * 
	 * 
	 * @Title: fun
	 * 
	 * @Description: 目标类方法,旨在这个方法中织入增强逻辑. 当注解标注在T2,方法的入参为T2或者T2的子孙类时,会织入增强
	 * 
	 * @param t
	 * 
	 * @return: void
	 */
	public void fun(T2 t) {
		System.out.println(t.getClass().getName() + " fun executed");
	}
}


package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.springframework.stereotype.Component;

@Monitor
@Component
public class T2 extends T1 {

}

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.springframework.stereotype.Component;

@Component
public class T3 extends T2 {

}

切面

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * 
 * 
 * @ClassName: AtArgsAspect
 * 
 * @Description: 标注了@Aspect的切面
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年9月1日 下午4:21:14
 */

@Aspect
public class AtArgsAspect {

	@Before("@args(com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.Monitor)")
	public void crossCuttingCode() {
		System.out.println("前置增强 横切逻辑织入 some logic is here ");
	}
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context 
       	http://www.springframework.org/schema/context/spring-context.xsd">

<!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
<context:component-scan base-package="com.xgj.aop.spring.advisor.aspectJ.function.args.atargs"/>
 
<!-- 基于@AspectJ切面的驱动器 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>

<!-- 使用了@AspectJ注解的切面类 -->
<bean class="com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.AtArgsAspect"/>

</beans>

测试类

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AtArgsAspectTest {

	@Test
	public void test() {
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"classpath:com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml");

		T0 t0 = ctx.getBean("t0", T0.class);
		T1 t1 = ctx.getBean("t1", T1.class);
		T2 t2 = ctx.getBean("t2", T2.class);
		T3 t3 = ctx.getBean("t3", T3.class);

		// 因t1中的fun入参为t2,且注解标注在了T2类上，t3又是t2的子类，所以 下面两个调用都会织入增强
		t1.fun(t2);
		t1.fun(t3);

	}
}

运行结果：

2017-09-04 17:43:44,302  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@f4efcb0: startup date [Mon Sep 04 17:43:44 BOT 2017]; root of context hierarchy
2017-09-04 17:43:44,390  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml]
前置增强 横切逻辑织入 some logic is here 
com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T2$$EnhancerBySpringCGLIB$$fcff1873 fun executed
前置增强 横切逻辑织入 some logic is here 
com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T3$$EnhancerBySpringCGLIB$$109aa116 fun executed

从运行结果看，正确的织入了横切逻辑。

在类继承树中注解点低于入参类型点，则注解点所在类及其子孙类作为方法入参时，该方法匹配切点@args(M)， 符合。

如果我们先取消掉T2上的@Monitor注解，然后把注解标注在T0上

如下：

package com.xgj.aop.spring.advisor.aspectJ.function.args.atargs;

import org.springframework.stereotype.Component;

@Monitor
@Component
public class T0 {

}

运行结果：

2017-09-04 17:56:31,858  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1c057a1e: startup date [Mon Sep 04 17:56:31 BOT 2017]; root of context hierarchy
2017-09-04 17:56:31,970  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/aop/spring/advisor/aspectJ/function/args/atargs/conf-atargs.xml]
com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T2$$EnhancerBySpringCGLIB$$42855f4c fun executed
com.xgj.aop.spring.advisor.aspectJ.function.args.atargs.T3$$EnhancerBySpringCGLIB$$5620e7ef fun executed

因在继承树中注解点高于入参类型点，因此该目标方法不可能匹配到切点@args(M)。

小小工匠
关注
专栏目录
spring-aop 之 aop:config
悟已往之不谏，知来者之可追
10-10 891
开头 aop部分的解析器由AopNamespaceHandler注册，其init方法: @Override public void init() { registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser()); registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
基于aspectj的pcd的@args和args实现
@siye
09-06 196
aspectj-pcd-@args-args
Aspectj中@args使用误解
Codestream's cold-dream
08-15 3478
刚刚开始触AOP，什么都不懂就要
spring应用手册-AOP(注解)-(12)-@Pointcut的表达式-args
10-14 729
戴着假发的程序员出品 抖音ID：戴着假发的程序员 欢迎关注 @Pointcut的表达式-args 限制匹配连接点(使用 Spring AOP 时执行方法)，其中 arguments 是给定类型的实例。 这个很好理解，就是在所有的joint point (连接点)中匹配指定参数类型和个数的方法进行匹配。 官方案例： args(java.io.Serializable) 我们的例子： 我们修改BookService类，添加一个重载sageBook方法： /** * @author 戴着假发的程序员 *
spring Ioc AspectJ注解args
weixin_40648117的博客
12-16 256
@Around(value = "execution(* AspectTest.*Impl.*(..))&&args(p)",argNames = "p")      public Object exec(ProceedingJoinPoint invocation,Person p) throws Throwable {  } 匹配AspectTest.*Impl包下任意方法，且方法参数传
Spring 之AOP AspectJ切入点语法详解（最全面、最详细）
gaoshan12345678910的博客
10-12 1033
6.5 AspectJ切入点语法详解 6.5.1 Spring AOP支持的AspectJ切入点指示符 切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下： execution：用于匹配方法执行的连接点； within：用于匹配指定类型内的方法执行； this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的...
@AspectJ切点函数详解
weixin_43611145的博客
10-28 3440
@AspectJ切点函数详解5.3.1 方法切点函数5.3.1.1 execution()5.3.1.2 @annotation()5.3.2 方法入参切点函数5.3.2.1 args()和@args()5.3.3 目标类切点函数5.3.3.1 within()5.3.3.2 @within()与@target()5.3.3.3 target()5.3.4 代理类切点函数5.3.4.1 this(...
spring - AOP - AspectJ标签 - 基于注解 or 基于配置文件
LawssssCat的博客
12-15 349
加入Jar包 实现AspectJ代理 aopalliance-1.0.jar aspectjweaver-1.6.8.jar spring-aop-4.0.0.RELEASE.jar spring-aspects-4.0.0.RELEASE.jar(没用到) 实现spring创建类 spring-context-4.0.0.RELEASE.jar spring-beans-4....
【Spring AOP】AspectJ语法基础
Andy Zheng's Blog
11-03 839
Spring支持9个@AspectJ切点表达式函数，它们用不同的方式
spring-aop-practice
05-15
Spring AOP提供了更高级的切面概念，可以定义切点（Pointcut）、通知（Advice）和切面（Aspect），使得AOP的使用更加灵活和抽象。 在"spring-aop-practice-master"项目中，我们可以看到具体的Spring AOP实践代码，...
Spring AOP中使用args表达式的方法示例
08-25
主要介绍了Spring AOP中使用args表达式的方法,结合实例形式分析了spring面向切面AOP中使用args表达式具体步骤、相关实现技巧与操作注意事项,需要的朋友可以参考下
SpringAOP详细使用
小丑竟是我自己
12-09 567
1.AOP切入点表达式 支持切点标识符 Spring AOP支持使用以下AspectJ切点标识符(PCD),用于切点表达式： execution: 用于匹配方法执行连接点。 这是使用Spring AOP时使用的主要切点标识符。 可以匹配到方法级别 ，细粒度 within: 只能匹配类这级，只能指定类， 类下面的某个具体的方法无法指定， 粗粒度 this: 匹配实现了某个接口：this(com.xyz.service.AccountService) target: 限制匹配到连接点（使用Sprin
Spring-AOP-学习笔记(2)-AspectJ
weixin_30306905的博客
10-22 66
1.启用@AspectJ,需要下载aspectjweaver.jar　　　 <!-- 默认启用动态代理 --><aop:aspectj-autoproxy/><!-- 注解启用CGliB --><aop:aspectj-autoproxy proxy-target-class="true"/><!--XML方式启用CGLIB -->...
Spring AOP之@args注解疑惑
lemon
05-29 2976
注解点以及入参类型点参考 Spring-AOP @AspectJ切点函数之args()和@args()精通Spring 4.x  企业应用开发实战中8.5.3章节1、注解点高于入参类型点不匹配切点2、注解点等于入参类型点匹配切点包括子类即使子类没有标注切点指定注解3、注解点低于入参类型点只有标注了切点指定注解的类才会匹配切点从IOC容器获取的实例以及直接new关键字创建的实例对于会匹配对于注解上是...
Spring aop @args 用法 demo（—）
Yuanyuanasdf的专栏
09-21 2099
spring aop @args 用法
AspectJ——切入点语法（7）之this、target、args、if以及逻辑运算
Gavin
05-10 2779
更多的切入点语法 本节介绍AspectJ中更多的切入点语法，有很多在之前都用过，这里做一个总结。 0.捕获this引用的是特定类型对象的连接点 AspectJ提供了this原生切入点来捕获所有的连接点，这些连接点处的this引用的是一个特定的类型。 我们在Test13包下做测试，首先业务类Service如下： package Test13; public class Servi...
Spring 是如何将前端请求中的参数解析到指定对象的
wojiushimogui的博客
12-05 2471
Spring 是如何将前端请求中的参数解析到指定对象的 注：文章稍微偏源码，对照着源码debug看效果更好一点。 先说下背景，最近看一个项目，有一个接口的定义如下 @PostMapping(value = "/conditionConfig") public BaseResponse<PageInfo<ConfigDTO>> conditionConfig(@Valid @RequestBody ConfigQuery configQuery) { return config
Spring AOP 切点表达式args与@args区别
永远相信美好的事情即将发生
05-31 1668
Spring AOP 中提供了丰富的切点表达式用于描述相对应的增强方法，其中@args是其中一种基于请求参数的增强逻辑。 @args 表达式是用于限制目标方法参数的，与args类似。区别在于@args限制的是目标方法参数对象上所添加的注解。 args 表达式用于限制 目标方法 在运行过程中传入的参数对象类型，@args实现了类似的效果，但是相对于args，@args限制了 目标方法在运行过程中传入的参数对象类型上面所添加的注解。 需要注意的是，这两个表达式限制的对象是方法调用时传入的参数对象类型，而不是方
Spring5应用之AOP切入点详解
最新发布
探索知识，创造未来
09-30 544
在前面的几篇文章里，我们已经探讨了AOP的四步编程以及Spring所提供的额外方法接口。今天，我们要探讨的是另一个核心概念——切入点。切入点决定了在何处插入这些额外的功能。但如之前文章所述，我们的切入点表达式相当粗糙，将额外的功能直接加入了所有类和方法中。这种做法明显不够精细，因为并不是每个原始方法都需要加入如日志、性能监测之类的额外功能本篇文章深入探讨了AOP中切入点的各个方面。在切入点表达式部分，我们详述了方法、类以及包的匹配方式。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小工匠

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

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

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

打赏作者

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

抵扣说明：

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

余额充值