Spring AOP 实现方式

最新推荐文章于 2024-07-30 12:48:07 发布
最新推荐文章于 2024-07-30 12:48:07 发布
阅读量262 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrathena/article/details/116939734
版权

博文目录

文章目录

AspectJ

  • 定义了切面表达式的语法和解析机制
  • 提供了强大的织入工具

它是通过织入的方式：直接将切面在【编译时、后】或【JVM加载的时候】进行织入到.class代码中。百度相关示例

Spring AOP

目前 Spring AOP 一共有三种配置方式

  • Spring 1.2 基于接口的配置：最早的 Spring AOP 是完全基于几个接口的，MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor 等。
  • Spring 2.0 schema-based 配置：Spring 2.0 以后使用 XML 的方式来配置，使用 命名空间
  • Spring 2.0 @AspectJ 配置：使用注解的方式来配置，这种方式最方便

注意: AspectJ 是 AOP 的实现, 但不是 Spring AOP 的实现

使用如下的 Calculate 计算类来演示

package com.mrathena.aop.usage;

public interface Calculate {
	int add(int a, int b);
	int subtract(int a, int b);
	int multiply(int a, int b);
	int divide(int a, int b);
}

package com.mrathena.aop.usage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CalculateImpl implements Calculate {
	private static final Logger log = LoggerFactory.getLogger(CalculateImpl.class);
	@Override
	public int add(int a, int b) {
		log.info("CalculateImpl.add");
		return a + b;
	}
	@Override
	public int subtract(int a, int b) {
		log.info("CalculateImpl.subtract");
		return a - b;
	}
	@Override
	public int multiply(int a, int b) {
		log.info("CalculateImpl.multiply");
		return a * b;
	}
	@Override
	public int divide(int a, int b) {
		log.info("CalculateImpl.divide");
		return a / b;
	}
}

基于接口

public class CalculateMethodBeforeAdvice implements MethodBeforeAdvice {
	private static final Logger log = LoggerFactory.getLogger(CalculateMethodBeforeAdvice.class);
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		log.info("{} - CalculateMethodBeforeAdvice.before", getClass());
	}
}

public class CalculateAfterReturningAdvice implements AfterReturningAdvice {
	private static final Logger log = LoggerFactory.getLogger(CalculateAfterReturningAdvice.class);
	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		log.info("{} - CalculateAfterReturningAdvice.afterReturning", getClass());
	}
}

/**
 * Interceptor 也是一个 Advice
 * interface MethodInterceptor extends Interceptor
 * interface Interceptor extends Advice
 */
public class CalculateMethodInterceptor implements MethodInterceptor {
	private static final Logger log = LoggerFactory.getLogger(CalculateMethodInterceptor.class);
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object result;
		try {
			log.info("CalculateMethodInterceptor.invoke.before");
			result = invocation.proceed();
			log.info("CalculateMethodInterceptor.invoke.afterReturning");
			return result;
		} catch (Throwable cause) {
			log.info("CalculateMethodInterceptor.invoke.afterThrowing");
			throw new RuntimeException(cause);
		} finally {
			log.info("CalculateMethodInterceptor.invoke.after");
		}
	}
}

Advice 方式

指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public CalculateAfterReturningAdvice calculateAfterReturningAdvice() {
		return new CalculateAfterReturningAdvice();
	}

	@Bean
	public ProxyFactoryBean calculateProxy() {
		// 需要通过 ProxyFactoryBean 来生产 代理 Calculate
		ProxyFactoryBean factoryBean = new ProxyFactoryBean();
		// 设置拦截链名字(有先后顺序), 可以是 advice, 也可以是 interceptor(本质上也是 advice), 也可以是 advisor
		factoryBean.setInterceptorNames("calculateMethodBeforeAdvice", "calculateAfterReturningAdvice");
		factoryBean.setTarget(calculate());
		return factoryBean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:33:06.937 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:33:06.937 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add
16:33:06.937 [main] INFO com.mrathena.aop.usage.基于接口.CalculateAfterReturningAdvice - CalculateAfterReturningAdvice.afterReturning

16:33:06.938 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:33:06.938 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodInterceptor calculateMethodInterceptor() {
		return new CalculateMethodInterceptor();
	}

	@Bean
	public ProxyFactoryBean calculateProxy() {
		// 需要通过 ProxyFactoryBean 来生产 代理 Calculate
		ProxyFactoryBean factoryBean = new ProxyFactoryBean();
		// 设置拦截链名字(有先后顺序), 可以是 advice, 也可以是 interceptor(本质上也是 advice), 也可以是 advisor
		factoryBean.setInterceptorNames("calculateMethodInterceptor");
		factoryBean.setTarget(calculate());
		return factoryBean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.before
16:36:33.083 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add
16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.afterReturning
16:36:33.083 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.after

16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.before
16:36:33.084 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.afterThrowing
16:36:33.084 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodInterceptor - CalculateMethodInterceptor.invoke.after
Exception in thread "main" java.lang.RuntimeException: java.lang.ArithmeticException: / by zero

Advisor 方式

Advice: 指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

Advisor: 扩展了 Advice. 指定某个 Bean 的 指定某些方法, 使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public NameMatchMethodPointcutAdvisor calculateNameMatchMethodPointcutAdvisor() {
		NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
		// 通知(Advice)  ：是我们的通知类
		// 通知者(Advisor)：是经过包装后的细粒度控制方式。
		// Advisor 持有 Advice 和 某个 Pointcut
		advisor.setAdvice(calculateMethodBeforeAdvice());
		advisor.setMappedNames("add", "subtract");
		return advisor;
	}

	@Bean
	public ProxyFactoryBean calculateProxy() {
		ProxyFactoryBean factoryBean = new ProxyFactoryBean();
		// 设置拦截链名字(有先后顺序), 可以是 advice, 也可以是 interceptor(本质上也是 advice), 也可以是 advisor
		factoryBean.setInterceptorNames("calculateNameMatchMethodPointcutAdvisor");
		factoryBean.setTarget(calculate());
		return factoryBean;
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculateProxy", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.subtract(1, 2);
		System.out.println();
		bean.multiply(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:39:04.690 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:39:04.690 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add

16:39:04.694 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.subtract

16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply

16:39:04.695 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

AutoProxyCreator 方式

Advice: 指定某个 Bean 的所有方法都使用指定的某些 Advice 做增强

Advisor: 扩展了 Advice. 指定某个 Bean 的 指定某些方法, 使用指定的某些 Advice 做增强

AutoProxyCreator: 扩展了 Advisor. 指定某些 Bean 的 某些方法, 使用指定的某些 Advice 做增强

@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateMethodBeforeAdvice calculateMethodBeforeAdvice() {
		return new CalculateMethodBeforeAdvice();
	}

	@Bean
	public NameMatchMethodPointcutAdvisor calculateNameMatchMethodPointcutAdvisor() {
		NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
		// 通知(Advice)  ：是我们的通知类
		// 通知者(Advisor)：是经过包装后的细粒度控制方式。
		// advisor 持有 advice 和 某个 pointcut
		// advisor 负责决定拦截哪些方法, advice 定义拦截后的逻辑
		advisor.setAdvice(calculateMethodBeforeAdvice());
		advisor.setMappedNames("add", "subtract");
		return advisor;
	}

	@Bean
	public RegexpMethodPointcutAdvisor calculateRegexpMethodPointcutAdvisor() {
		RegexpMethodPointcutAdvisor regexpMethodPointcutAdvisor = new RegexpMethodPointcutAdvisor();
		regexpMethodPointcutAdvisor.setAdvice(calculateMethodBeforeAdvice());
		regexpMethodPointcutAdvisor.setPatterns("com.mrathena.aop.usage.CalculateImpl.add", "com.mrathena.aop.usage.CalculateImpl.subtract");
		return regexpMethodPointcutAdvisor;
	}

	/**
	 * BeanNameAutoProxyCreator 和 DefaultAdvisorAutoProxyCreator 二者选一个留下
	 * 需要指定 BeanNames 和 InterceptorNames(advice, interceptor, advisor)
	 */
	@Bean
	public BeanNameAutoProxyCreator calculateBeanNameAutoProxyCreator() {
		BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
		// 设置要创建代理的那些Bean的名字
		beanNameAutoProxyCreator.setBeanNames("calc*");
		// 设置拦截链名字(有先后顺序), 可以是 advice, 也可以是 interceptor(本质上也是 advice), 也可以是 advisor
		// 拦截器使用 advice, 作用于所有方法
		beanNameAutoProxyCreator.setInterceptorNames("calculateMethodBeforeAdvice");
		// 拦截器使用 advisor, 作用于指定方法
		beanNameAutoProxyCreator.setInterceptorNames("calculateRegexpMethodPointcutAdvisor", "calculateNameMatchMethodPointcutAdvisor");
		beanNameAutoProxyCreator.setInterceptorNames("calculateNameMatchMethodPointcutAdvisor");
		beanNameAutoProxyCreator.setInterceptorNames("calculateRegexpMethodPointcutAdvisor");
		return beanNameAutoProxyCreator;
	}

	/**
	 * BeanNameAutoProxyCreator 和 DefaultAdvisorAutoProxyCreator 二者选一个留下
	 * DefaultAdvisorAutoProxyCreator 让容器中的所有 advisor 都生效
	 */
//	@Bean
//	public DefaultAdvisorAutoProxyCreator calculateDefaultAdvisorAutoProxyCreator() {
//		return new DefaultAdvisorAutoProxyCreator();
//	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculate", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.subtract(1, 2);
		System.out.println();
		bean.multiply(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:40:28.030 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.add

16:40:28.030 [main] INFO com.mrathena.aop.usage.基于接口.CalculateMethodBeforeAdvice - CalculateMethodBeforeAdvice.before
16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.subtract

16:40:28.030 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply

16:40:28.031 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
Exception in thread "main" java.lang.ArithmeticException: / by zero

基于 XML

百度

基于注解

@Aspect
public class CalculateAspect {

	private static final Logger log = LoggerFactory.getLogger(CalculateAspect.class);

	// Before:			方法执行前
	// After:			方法执行后(不管是否异常)
	// AfterReturning:	方法成功执行后
	// AfterThrowing:	方法抛出异常后
	// Around:			自己封装整个代理逻辑

	// 可以不写切点, 直接把切点表达式写在 @Before 等括号中
	@Pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.*(..))")
	public void all() {}
	@Pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.add(..))")
	public void add() {}
	@Pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.subtract(..))")
	public void subtract() {}
	@Pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.multiply(..))")
	public void multiply() {}
	@Pointcut("execution (* com.mrathena.aop.usage.CalculateImpl.divide(..))")
	public void divide() {}

	@Before("all()")
	public void allBefore(JoinPoint joinPoint) {
		log.info("AllBefore: {}, {}", joinPoint.getSignature().getName(), Arrays.asList(joinPoint.getArgs()));
	}

	@After("all()")
	public void allAfter(JoinPoint joinPoint) {
		log.info("AllAfter");
	}

	@AfterReturning(value = "all()", returning = "result")
	public void allAfterReturning(JoinPoint joinPoint, Object result) {
		log.info("AllAfterReturning: {}", result);
	}

	@AfterThrowing(value = "all()", throwing = "cause")
	public void allAfterThrowing(JoinPoint joinPoint, Throwable cause) {
		log.info("AllAfterThrowing: {}", cause.getMessage());
	}

	//	@Before("add()")
	// ajc: circular advice precedence: can't determine precedence between two or more pieces of advice that apply to the same join point: method-execution(int com.mrathena.aop.usage.CalculateImpl.add(int, int))
	// 每一个方法只能被一个@Before横切
	public void addBefore(JoinPoint joinPoint) {
		log.info("AddBefore: {}, {}", joinPoint.getSignature().getName(), Arrays.asList(joinPoint.getArgs()));
	}

}

@EnableAspectJAutoProxy
@Configuration
public class Application {

	@Bean
	public Calculate calculate() {
		return new CalculateImpl();
	}

	@Bean
	public CalculateAspect calculateAspect() {
		return new CalculateAspect();
	}

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
		Calculate bean = context.getBean("calculate", Calculate.class);
		System.out.println();
		bean.add(1, 2);
		System.out.println();
		bean.subtract(1, 2);
		System.out.println();
		bean.multiply(1, 2);
		System.out.println();
		bean.divide(1, 0);
	}

}

16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllBefore: multiply, [1, 2]
16:50:49.263 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.multiply
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfter
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfterReturning: 2

16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllBefore: divide, [1, 0]
16:50:49.263 [main] INFO com.mrathena.aop.usage.CalculateImpl - CalculateImpl.divide
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfter
16:50:49.263 [main] INFO com.mrathena.aop.usage.基于注解.CalculateAspect - AllAfterThrowing: / by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero
mrathena
关注
专栏目录
Spring实现AOP的4种方式
10-25
Spring中实现AOP有很多方式，这里总结了四种，有基于代理的实现方式，也有基于AspectJ 的注解方式，还有基于AOP标签的配置
springAOP的三种实现方式示例代码
08-18
Spring AOP 三种实现方式示例代码 Spring AOP（Aspect-Oriented Programming）是 Spring 框架中的一种面向方面编程技术，主要用于解决横切关注点的问题。AOP 的主要思想是将横切逻辑代码从业务逻辑代码中分离出来，...
Spring AOP 实现机制
最新发布
DHG2012的博客
07-30 1082
使用注解定义Spring AOP允许使用注解来定义pointcuts。常见的注解有@Before@After@Around等，它们内部隐含了一个pointcut。
Spring学习总结（三）——Spring实现AOP的多种方式
weixin_30561177的博客
08-04 667
AOP（Aspect Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的横向多模块统一控制的一种技术。AOP是OOP的补充，是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP可以分为静态织入与动态织入，静态织入即在编译前将...
SpringAOP实现方式
疯一样的女子
06-20 214
一、AOP是什么？ AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表。本文会分别对AspectJ和Spring AOP的实现进行分析和介绍。 二、springaop如何实现的？ Spring AOP中
Spring实现AOP的方式
xishilife的专栏
08-28 89
前置条件 ①导入jar <dependencies> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependenc
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
Spring AOP如何整合redis（注解方式）实现缓存统一管理详解
08-27
Spring AOP如何整合redis（注解方式）实现缓存统一管理详解 Spring AOP是Spring框架中的一种面向方面编程（AOP）的实现，它可以将横切关注点（Cross-Cutting Concerns）与业务逻辑进行分离，从而实现更加灵活和模块...
spring aop实现用户权限管理的示例
08-28
本篇文章主要介绍了使用 Spring AOP 实现用户权限管理的示例，通过 AOP 方式来实现权限管理，可以降低项目后期开发的可扩展性和代码重复率。 知识点一：AOP 在实际项目中的应用场景 AOP（Aspect-Oriented ...
Spring AOP 常用的四种实现方式
05-03
NULL 博文链接：https://junle.iteye.com/blog/2429125
Spring实现Aop的方式
菜菜的博客
03-18 502
Spring实现AOP
Spring AOP是怎么实现的
一江溪水
11-17 5212
概述 Spring的AOP实现是通过动态代理实现的。如果我们为Spring的一个bean配置了AOP切面，那么Spring在创建这个bean的时候，实际上创建的是这个bean的一个代理对象，我们后续对bean中方法的调用，实际上调用的是代理类重写的代理方法。 而Spring的AOP使用了两种动态代理，分别是 JDK的动态代理； CGLib的动态代理。 JDK动态代理 Spring默认使用JDK的动态代理实现AOP，类如果实现了接口，Spring就会使用这种方式实现动态代理。JDK实现动态代理需要两个组件
spring中Aop实现方式（附代码）
ebdbbd的博客
07-15 452
AOP的切入三种方式详解
Spring的Aop实现
qq_32998153的博客
05-04 300
AOP（Aspect-Oriented Programming）面向切面编程为什么要使用AOP？维基百科对AOP相关概念的叙述：Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点。从关注点中分离出横切关注点是面向切面的程序设计的核心概念。分离关注点使解决特定问题的代码从业务逻辑中独立出来、业务逻辑的代码中不再含有针对特定领域问题代码的调用，业务逻辑同特定领域问题的关系通过...
Spring中AOP的实现
苦行僧
09-07 266
1、概述 它最大的作用是什么？ 在不更改源代码的情况下，对其原有功能进行增强。使得代码的重用率、开发效率、维护产生极大的方便。 运用场景 最常见的有：事务、日志、请求拦截等 2、使用 如何在Spring中使用AOP？ 1、开启配置 @EnableAspectJAutoProxy 2、写代理类和被代理的类 @Component @Aspect public class AopConfig { @PostConstruct public void init(){ System.out.pri
Spring aop的实现原理
热门推荐
weianluo的博客
08-12 1万+
转载：https://www.cnblogs.com/lcngu/p/5339555.html 简介     前段时间写的java设计模式--代理模式，最近在看Spring Aop的时候，觉得于代理模式应该有密切的联系，于是决定了解下Spring Aop的实现原理。     说起AOP就不得不说下OOP了，OOP中引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值