Spring AOP 实现

最新推荐文章于 2023-06-14 16:22:28 发布
最新推荐文章于 2023-06-14 16:22:28 发布
阅读量120 收藏
点赞数
分类专栏： Spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44615754/article/details/104769529
版权

一、使用jdk动态代理实现AOP

  • 科普：JDK动态代理是通过java.lang.reflect.Proxy类来实现的，可以调用Proxy类的

    newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。由java jdk提供

  1. 接口类

    public interface UserDao {
	/**
	 * 添加用户
	 */
	public void addUser();
	/**
	 * 删除用户
	 */
	public void deleteUser();	
}

  2. 实现类

    public class UserDaoImpl implements UserDao {
	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("我是添加用户");
	}
	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("我是删除用户");
	}
}

  3. 切面类（模拟检查权限，模拟记录日志）

    public class MyAspect {
	/**
	 * 检查权限
	 */
	public void check() {
		System.out.println("模拟检查方法");
	}

	/**
	 * 记录日志权限
	 */
	public void log() {
		System.out.println("模拟记录日志");
	}
}

  4. jdk代理类

    public class JdkProxy implements InvocationHandler {
//	声明目标类的接口
	private UserDao userDao;

	public Object createProxy(UserDao userDao) {
		this.userDao = userDao;
//		类加载器
		ClassLoader classLoader = JdkProxy.class.getClassLoader();
//		被代理对象实现所有接口
		Class[] classes = userDao.getClass().getInterfaces();
//		使用代理类，进行增强，返回的是代理后的对象
		return Proxy.newProxyInstance(classLoader, classes, this);
	}
/** 所有动态代理的方法调用，都会有invoke方法处理
	proxy:被代理后的对象
    method:将要执行的方法信息
    args执行方法时需要的参数
*/
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		//声明切面
		MyAspect myAspect = new MyAspect();
		myAspect.check();
		//在目标类调用方法，传入参数
		Object obj = method.invoke(userDao, args);
		myAspect.log();
		return obj;
	}

}

  5. 测试

    public class JdkTest {
	@Test
	public void test2() {
	//实例化jdk代理类
		JdkProxy jdkProxy = new JdkProxy();
    //创建目标对象
		UserDao useDao = new UserDaoImpl();
    //从代理类中获取增强后的目标对象
		UserDao cp = (UserDao) jdkProxy.createProxy(useDao);
//		执行方法
		cp.addUser();
		cp.deleteUser();
	}
}

二、使用cglib实现Aop

  • 科普：cglib代理是一个高性能开源的代码生成包，利用底层字节码技术，对指定的目标生成一个子类,对子类进行增强,由spring提供
  • 任务描述：创建UserDaoImpl类，不用实现接口。把UserDaoImpl作为目标类，对其中的方法进行增强处理。

  1. 目标类

    public class UserDaoImpl {
	/**
	 * 添加用户
	 */
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("我是添加用户");
	}
	/**
	 * 删除用户
	 */
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("我是删除用户");
	}
}

  2. 代理类：

    public class Cglibproxy implements MethodInterceptor {
	public Object createProxy(Object target) {
//		创建动态类对象
		Enhancer enhancer = new Enhancer();
//		确定需要增强的类，设置其为父类
		enhancer.setSuperclass(target.getClass());
//		添加回调函数enhancer
		enhancer.setCallback(this);
		return enhancer.create();
	}
   	//method:拦截的方法，arg2：拦截方法的参数数组，MethodProxy方法的代理对象，用于执行父类的方法
	@Override
	public Object intercept(Object proxy, Method arg1, Object[] arg2, MethodProxy methodProxy) throws Throwable {
		// TODO Auto-generated method stub
//		创建切面对象
		MyAspect myAspect = new MyAspect();
//		前置增强
		myAspect.check();
//		目标方法执行
		Object obj = methodProxy.invokeSuper(proxy, arg2);
//		后置增强
		myAspect.log();
		return obj;
	}
}

  3. 测试

    public class CglibTest {
	@Test
	public void test2() {
//	创建代理对象
		Cglibproxy cp = new Cglibproxy();
//	创建目标对象
		UserDaoImpl userDaoImpl = new UserDaoImpl();
//	获取增强后的目标对象
		UserDao udi = (UserDao) cp.createProxy(userDao);
//	执行方法
		udi.addUser();
		udi.deleteUser();

	}
}

三、spring代理类实现Aop

  • 任务描述：创建配置文件指定代理对象，指定UserDao为代理实现的接口，指定UserDaoImpl为目标类，对其中的方法进行增强处理。
  • 实现思路：创建Spring配置文件，通过定义目标类和切面，然后使用ProxyFactoryBean类定义代理对象。在定义代理对象中，通过子元素指定代理实现的接口，代理的目标对象，需要织入目标类的通知以及代理方式

  1. 切面类

    public class MyAspect implements MethodInterceptor {
	/**
	 * 日志信息
	 */
	private void log() {
		// TODO Auto-generated method stub
		System.out.println("模拟检查日志");
	}
	/**
	 * 模拟检查权限
	 */
	private void check() {
		// TODO Auto-generated method stub
		System.out.println("模拟检查权限");
	}
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		// TODO Auto-generated method stub
		check();
//		执行目录方法
		Object object = mi.proceed();
		log();
		return object;
	}
}

  2. spring配置文件

    	<!-- 目标类 -->
	<bean id="userDao" class="com.ruanyuan.jdk.UserDaoImpl"></bean>
	<!-- 切面类 -->
	<bean id="myAspect" class="com.ruanyuan.factorybean.MyAspect"></bean>
	<!-- 使用spring代理工厂定义一个名称为UserDaoProxy对象 -->
	<bean id="userDaoProxy"
		class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 指定实现代理接口 -->
		<property name="proxyInterfaces"
			value="com.ruanyuan.jdk.UserDao"></property>
		<!-- 指定目标对象 -->
		<property name="target" ref="userDao"></property>
		<!-- 指定切面，植入环绕通知 -->
		<property name="interceptorNames" value="myAspect"></property>
		<property name="proxyTargetClass" value="true"></property>
	</bean>

  3. 测试类

    public class ProxyFactoryBeanTest {
	@SuppressWarnings("resource")
	@Test
	public void test2() {
//		定义配置路径
		String path="com/ruanyuan/factorybean/applicationContext.xml";
//	加载配置路径
		ApplicationContext context = new ClassPathXmlApplicationContext(path);
//		获取bean
		UserDao userDao = (UserDao) context.getBean("userDaoProxy");
//		执行方法
		userDao.addUser();
		userDao.deleteUser();
	}
}

四、基于xml的声明式AspectJ

  • 任务描述：通过XML文件来定义切面，切入点及通知

  1. 接口类

    public interface UserDao {
	/**
	 * 添加用户
	 */
	public void addUser();
	/**
	 * 删除用户
	 */
	public void deleteUser();
	
}

  2. 实现类

    public class UserDaoImpl implements UserDao{
	/**
	 * 添加
	 */
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("我是添加用户");
	}
	/**
	 * 删除
	 */
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("我是删除用户");
	}
}

  3. 切面类

    public class MyAspect {
	/**
	 * 前置通知
	 * @param joinPoint
	 */
	public void Before(JoinPoint joinPoint) {
		System.out.println("前置通知，模拟检查权限");
		System.out.println("目标类是"+joinPoint.getTarget());
		System.out.println(",被织入增强处理的目标方法"+joinPoint.getSignature().getName());
		System.out.println("----------------前置分隔----------------------");

	}
	/**
	 * 后置返回通知
	 * @param joinPoint
	 */
	public void AfterReturning(JoinPoint joinPoint) {
		System.out.println("后置通知，模拟记录日志");
		System.out.println("目标是"+joinPoint.getTarget());
		System.out.println(",被织入增强处理的目标方法"+joinPoint.getSignature().getName());
		System.out.println("----------------后置返回分隔----------------------");

	}
	/**
	 * 环绕通知
	 * @param proceedingJoinPoint
	 * @return
	 * @throws Throwable
	 */
	public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//		环绕开始
		System.out.println("环绕开始，执行目标方法之前，模拟开启事物");
		Object obj = proceedingJoinPoint.proceed();
//		环绕结束
		System.out.println("环绕结束，模拟事物关闭释放资源");
		System.out.println("----------------环绕分隔----------------------");

		return obj;
	}
	/**
	 * 异常通知
	 * @param joinPoint
	 * @param e
	 */
	public void AfterThrowing(JoinPoint joinPoint,Throwable e) {
		System.out.println("异常通知"+e.getMessage());
		System.out.println("----------------异常分隔----------------------");

	}
	/**
	 * 最终通知
	 */
	public void finish() {
		System.out.println("最终通知，模拟方法结束后的释放资源");
		System.out.println("----------------最终分隔----------------------");

	}
}

  4. 配置文件

    <!-- 目标类 -->
	<bean id="userDao" class="com.ry.aspectj.UserDaoImpl"></bean>
	<!-- 切面 -->
	<bean id="myAspect" class="com.ry.aspectj.MyAspect"></bean>
	<!-- aop编程 -->
	<aop:config>
		<!--配置切面 -->
		<aop:aspect ref="myAspect">
			<!-- 配置切入点 -->
			<aop:pointcut
				expression="execution(* com.ry.aspectj.*.*(..))"
				id="myPointCut" />
			<!-- 前置通知 -->
			<aop:before method="Before" pointcut-ref="myPointCut" />
			<!-- 后置通知 -->
			<aop:after-returning method="AfterReturning"
				pointcut-ref="myPointCut" returning="returnVal" />
			<!-- 环绕通知 -->
			<aop:around method="Around" pointcut-ref="myPointCut" />
			<!-- 异常通知 -->
			<aop:after-throwing method="AfterThrowing"
				pointcut-ref="myPointCut" throwing="e" />
			<!-- 最终通知 -->
			<aop:after method="finish" pointcut-ref="myPointCut" />
		</aop:aspect>
	</aop:config>

  5. 测试类

    public class TestXmlAspectj {
	@Test
	public void test2() {
		String path = "com/ruanyuan/aspectj/applicationContext.xml";
		ApplicationContext context = new ClassPathXmlApplicationContext(path);
//		从Spring容器获得内容
		UserDao userDao = (UserDao) context.getBean("userDao");
//		执行方法
		userDao.addUser();
	}
}

五、注解实现AOP

  • 通过注解来定义切面，切入点及通知，所有的切面，切入点和通知。

  1. 接口类

    public interface UserDao {
	/**
	 * 添加用户
	 */
	public void addUser();
	/**
	 * 删除用户
	 */
	public void deleteUser();
	
}

  2. 实现类

    @Repository("userDao1")
public class UserDaoImpl implements UserDao{
	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("添加用户。。。");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户。。。");
	}
}

  3. 切面类

    @Aspect
@Component
public class MyAspect {
//	定义切入点表达式
	@Pointcut("execution(* com.ruanyuan.aspectj.annotation.*.*(..))")
//	使用方法体为空的方法作为切入点
	private void myPointCut() {

	}

	/**
	 * 前置通知
	 * 
	 * @param joinPoint
	 */
	@Before("myPointCut()")
	public void Before1(JoinPoint joinPoint) {
		System.out.println("前置通知，模拟检查权限");
		System.out.println("目标类是" + joinPoint.getTarget());
		System.out.println(",被织入增强处理的目标方法" + joinPoint.getSignature().getName());
		System.out.println("----------------前置分隔----------------------");
	}

	/**
	 * 后置返回通知
	 * 
	 * @param joinPoint
	 */
	@After(value = "myPointCut()")
	public void AfterReturning(JoinPoint joinPoint) {
		System.out.println("后置通知，模拟记录日志");
		System.out.println("目标是" + joinPoint.getTarget());
		System.out.println(",被织入增强处理的目标方法" + joinPoint.getSignature().getName());
		System.out.println("----------------后置返回分隔----------------------");

	}

	/**
	 * 环绕通知
	 * 
	 * @param proceedingJoinPoint
	 * @return
	 * @throws Throwable
	 */
	@Around("myPointCut()")
	public Object Around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//		环绕开始
		System.out.println("环绕开始，执行目标方法之前，模拟开启事物");
		Object obj = proceedingJoinPoint.proceed();
//		环绕结束
		System.out.println("环绕结束，模拟事物关闭释放资源");
		System.out.println("----------------环绕通知分隔----------------------");
		return obj;

	}

	/**
	 * 异常通知
	 * 
	 * @param joinPoint
	 * @param e
	 */
	@AfterThrowing(value = "myPointCut()", throwing = "e")
	public void AfterThrowing1(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知" + e.getMessage());
		System.out.println("----------------异常分隔----------------------");

	}

	/**
	 * 最终通知
	 */
	@After("myPointCut()")
	public void finish() {
		System.out.println("最终通知，模拟方法结束后的释放资源");
		System.out.println("----------------后置分隔----------------------");

	}
}

  4. 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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">
       <context:component-scan base-package="com.ruanyuan.aspectj.annotation"/>
       <!-- 基于注解的声明式事物支持 -->
       <aop:aspectj-autoproxy/>
</beans>

  5. 测试类

    public class AnnotationTest {
	@Test
	public void test2() {
		String path = "com/ruanyuan/aspectj/annotation/applicationContext.xml";
		ApplicationContext context = new ClassPathXmlApplicationContext(path);
//		从Spring容器获得内容
		UserDao userDao = (UserDao) context.getBean("userDao1");
//		执行方法
		userDao.addUser();
	}
}
herospirit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP之JDK动态代理
weixin_43541255的博客
04-15 389
一.什么是AOP？ AOP简介 AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。 AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然...
Spring AOP动态代理之JDK代理
kbh528202的博客
11-12 210
前言 我们都知道AOP中的代理就是由AOP框架动态生成的一个对象，该对象可以作为目标对象使用。此处讲解Spring中的AOP代理之JDK动态代理。 JDK代理是什么 JDK动态代理是通过java.lang.reflect.Proxy类来实现的，我们可以调用Proxy了的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP....
spring-实现AOP
周思漩的博客
10-21 116
AOP基本概念： Aspect(切面):通常是一个类，里面可以定义切入点和通知 JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用 Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式 AOP代理： AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态
Spring AOP
m0_51457307的博客
11-20 413
一、AOP的概念和作用 AOP:面向切面编程（也称面向方面编程，是面向对象编程（OOP）的一种补充）。 AOP作用：aop采用横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或者运行时，再将这些提取出来的代码应用到需要执行的地方。AOP是OOP的延伸和补充，不是OOP的替代品。AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。 AOP思想中，类和切面的关系： 二、AOP术语 .
Spring AOP（实验三）
重庆科技学院XMY的博客
12-10 1119
什么是AOP？ 将分散在各个方法中重复的代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方 AOP术语 点击此处学习AOP术语 在切面覆盖下的类里面，任何对象方法的调用都被叫做连接点。 切面 只是一个类，但是这个类只有在Spring容器中被配置才能被识别为切面 切入点就是 需要处理的连接点 通知增强处理就是 切入点需要执行的程序代码，就是切面类中的某个方法 目标对象就是 执行了切面类中方法的一个类。 代理是 在“动态的AOP”方法中，被动态创建的虚拟对象。 织入也就是 生成代理
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
Spring AOP实现机制
08-02
**Spring AOP 实现机制详解** Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许程序员在不修改源代码的情况下，通过“切面”来插入额外的业务逻辑，如日志、事务管理等。AOP的引入极大地提高了代码的...
Spring AOP实现Redis缓存数据库查询
08-29
Spring AOP实现Redis缓存数据库查询 Spring AOP（Aspect-Oriented Programming，面向方面编程）是一种编程技术，可以将散落在各个对象之间的逻辑提取出来，封装成一个个独立的模块，并将这些模块组合起来，形成一...
Spring AOP实现原理解析
08-28
Spring AOP实现原理解析 Spring AOP（Aspect-Oriented Programming）是一种面向方面编程的技术，它可以将公共行为封装到一个可重用模块中，以减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可...
springAOP实现
05-02
在Spring AOP中，切面可以通过编写带有注解的类或者XML配置来实现。切面通常包括一个或多个通知，以及连接点的定义。 2. **通知（Advice）** 通知是在特定的连接点上执行的代码，它可以是前置通知（Before）、后置...
Spring中的JDK动态代理是如何实现的？
Aa112233aA1的博客
05-24 420
JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。 接下来，通过一个案例来演示Spring中JDK动态代理的实现过程，具体步骤如下。 （1）创建一个名为chapter03的Web项目，导入Spring框架所需JAR包到项目的lib目录中，并发布到类路径下。 （2）在src目录下，创建一个com.itheima.jdk包，在该包
java框架013——Spring AOP面向切面编程
weixin_45084986的博客
10-17 543
一、Spring AOP简介 AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。 在业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但有时为了实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代
Spring-AOP 相关配置文件Proxy代理问题
QWDWQWQ的博客
03-04 338
Spring AOP jdk动态代理 接口问题 com.sun.proxy.$Proxy15 cannot be cast to com.ywb.proxy.aop.Target
使用接口实现静态代理和动态代理（Java）
m0_70302303的博客
06-14 457
(2) 创建 PeopleProxy 类，实现接口 InvocationHandler，实现其有参构造方法，并实现。(3) 思考如果要再创建一个新的 Russian 类，如果要对 Russian 类也实现静态代理，要怎。(2) 创建 ChineseProxy 类，实现接口 People，实现对 Chinese 类的代理。代理分为静态代理和动态代理。静态代理需要为每一个被代理类创建代理类，如果被代。3. 代理类，代理类也实现这个接口。并创建这个被代理类的实例，然后实现接口中方法的时候调用被代理类的方法。
java报错：com.sun.proxy.$Proxy15 cannot be cast to com.yh.service.UserServiceImpl
weixin_43932247的博客
12-18 911
我是用UserServiceImpl（这是service的一个实例）调用一个方法，一直报上面的错误；然后找了同事帮忙看下，同事在spring-mybatis.xml文件里component-scan里增加了下面3个context解决了报错  &lt;context:component-scan base-package="com.yh"&gt;          &lt;context:incl...
Spring面试题复习（一）
今晨的个人博客
06-12 291
Spring面试题复习（一） 一、Spring是什么？ Spring是一个轻量级的开发框架，常说的Spring框架，就是指Spring Framework，它是很多模块的集合，这些模块可以帮助我们开发人员简化开发，这些模块有核心容器、数据访问/继承、web、AOP、消息和测试模块。主要有以下几个重要的模块： Spring Core：核心类库，Spring框架几乎所有的功能都依赖于此类库，主要提供IOC依赖注入功能。 Spring Context：提供框架式的Bean访问方式，以及企业级功能（定时任务等）；
动态代理之： com.sun.proxy.$Proxy0 cannot be cast to 问题
热门推荐
qq_38409944的博客
05-13 2万+
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to Father.FatherInter at Father.Main.main(Main.java:13) 不知道写动态代理的时候 你们有没有被这个问题困扰过 反正我是有的 不过和网上的问题不...
but was actually of type 'com.sun.proxy.$Proxy**'解决方法
穷水叮咚的博客
04-28 3110
由于项目使用了shiro安全框架，启动一直报错在shiro中有这个配置&lt;!-- 开启Shiro注解 --&gt; &lt;bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"&gt; ...
SSM整合后出现com.sun.proxy.$Proxy16
weixin_43802688的博客
06-05 1479
我的aop配置，如果SSM整合后出现com.sun.proxy.$Proxy16错误 <aop:config> <!-- 切入点表达式 --> <aop:pointcut expression="execution(* com.dancer.crud.service..*(..))" id="txPoint"/> <!-- 配置事物增强 --...
spring aop实现
最新发布
03-23
Spring AOP的实现主要依赖于以下几个核心概念： 1. 切面（Aspect）：切面是一个模块化的单元，它封装了与横切关注点相关的行为。在Spring AOP中，切面可以包含通知（Advice）和切点（Pointcut）。 2. 通知（Advice...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值