【Spring】AOP底层原理(动态代理)-》 AOP概念及术语 -》 AOP实现

最新推荐文章于 2024-09-16 13:30:48 发布
最新推荐文章于 2024-09-16 13:30:48 发布
阅读量1.7k 收藏 24
点赞数 18
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ebb29bbe/article/details/128813234
版权

在这里插入图片描述

个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
个人主页：.29.的博客
学习社区：进去逛一逛~

在这里插入图片描述

AOP - 面向切面编程



一、简述AOP

AOP —— 面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的作用：

  • 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

  • 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。



二、AOP底层原理

AOP面向切面编程，在底层使用动态代理实现，其中分为两种情况：

  • 有接口时，使用JDK动态代理
  • 无接口时，使用CGLIB动态代理

JDK动态代理：创建接口实现类代理对象，增强类的方法；
CGLIB动态代理：创建子类的代理对象，增强类的方法；



三、实现动态代理（案例）

使用的相关Maven依赖：

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

① 声明计算器接口Calculator，包含加减乘除的抽象方法：

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */
public interface Calculator {
    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}

② 创建接口实现类，实现加减乘除等方法：

import org.springframework.stereotype.Component;

/**
 * @author .29.
 * @create 2023-02-04 15:02
 */

//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

③ 编写被代理对象的工厂类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @author .29.
 * @create 2023-02-04 22:05
 */
public class ProxyFactory {
    //目标对象
    private Object target;

    public ProxyFactory(Object target){
        this.target = target;
    }

    //返回代理对象
    public Object getProxy(){
        //动态代理返回对象
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
        /*
        * newProxyInstance()中需要传入三个参数
        * ① ClassLoader：加载动态生成代理类的 类加载器
        * ② Class[] interfaces： 目标对象实现的所有接口
        * ③ InvocationHandler: 设置代理对象实现目标对象方法的过程
        * */
        ClassLoader classLoader = target.getClass().getClassLoader();

        Class<?>[] interfaces = target.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler(){
            //参数一：代理对象
            //参数二：需要重写目标对象的方法
            //参数三：method方法（参数二）中的参数
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法调用前输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",参数："+ Arrays.toString(args));

                //调用目标方法
                Object result = method.invoke(target, args);

                //方法调用后输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",结果："+ result);
                return result;
            }
        };
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
         return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}

④ 测试：

/**
 * @author .29.
 * @create 2023-02-04 22:24
 */
public class TestCalculator {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        //通过代理对象获取目标对象
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        //调用目标对象方法
        proxy.add(1,1);
        System.out.println();

        proxy.div(1,1);
        System.out.println();

        proxy.mul(1,1);
        System.out.println();

        proxy.sub(1,1);
        System.out.println();
    }
}

在这里插入图片描述



四、AOP术语

1.横切关注点：
分散在每个各个模块中解决同一样的问题，如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

2.通知：
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

  • 前置通知：使用@Before注解标识，在被代理的目标方法前执行
  • 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
  • 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
  • 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
  • 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

各种通知的执行顺序：

  • Spring版本5.3.x以前：
    • 前置通知
    • 目标操作
    • 后置通知
    • 返回通知或异常通知
  • Spring版本5.3.x以后：
    • 前置通知
    • 目标操作
    • 返回通知或异常通知
    • 后置通知

3.切面：
即：封装通知方法的类。

4.目标：
即：被代理的目标对象。

5.代理：
向目标对象应用通知之后创建的代理对象。

6.连接点：
这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。通俗说，就是spring允许你使用通知的地方

7.切入点：
定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。



五、AOP的注解方式实现

须知：
切入点表达式语法：
execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

在这里插入图片描述


1.导入Maven依赖：

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>

2.准备被代理的 接口+实现类：

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */

public interface Calculator {
    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}


import org.springframework.stereotype.Component;

/**
 * @author .29.
 * @create 2023-02-04 15:02
 */

//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {

        int result = i + j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int sub(int i, int j) {

        int result = i - j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int mul(int i, int j) {

        int result = i * j;

        System.out.println("方法内部 result = " + result);

        return result;
    }

    @Override
    public int div(int i, int j) {

        int result = i / j;

        System.out.println("方法内部 result = " + result);

        return result;
    }
}

※ 3.创建并配置切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author .29.
 * @create 2023-02-04 22:47
 */
//切面类
//@Aspect代表这是一个切面类
//@Component代表将此类交给Spring处理，能够放入IOC容器中去
@Aspect
@Component
public class LogAspect {
    //设置切入点 和 通知类型
    //切入点表达式：execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))

    //重用切入点表达式：使用@Pointcut注解，设置需要重复使用的切入点表达式
    @Pointcut(value = "execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void pointCut(){}
    //之后，在使用通知时，将切入点表达式用 方法名 替换，即pointCut()（同一个切面）
    //若在不同的切面，需要加上重用切入点表达式方法的全类名：com.haojin.spring.aop.annoaop.LogAspect.pointCut()（不同的切面）

    //通知类型：
    // @Before("切入点表达式配置切入点") 前置
    @Before(value = "pointCut()")   //重用切入点表达式，使用方法名替换
    public void beforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        Object[] args = joinPoint.getArgs();             //获取增强方法的参数数组
        System.out.println("Logger-->前置通知，增强方法为："+name+",参数："+ Arrays.toString(args));
    }

    // @AfterReturning() 返回
    //返回通知 可以获取到返回值，在切入表达式中增加返回值属性:returning = ""
    @AfterReturning(value = "pointCut()",returning = "result")
    //增强方法中需要添加 返回值参数result，参数名与切入点表达式保持一致（result）
    public void afterReturningMethod(JoinPoint joinPoint,Object result){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->返回通知，增强方法为："+name+"，返回结果："+result);

    }

    // @AfterThrowing() 异常
    //目标方法出现异常时，此通知会执行，在切入表达式中增加属性：
    @AfterThrowing(value = "pointCut()",throwing = "exception")
    //增加 Throwable类型参数，参数名必须与切入点表达式保持一致（exception）
    public void aAfterThrowingMethod(JoinPoint joinPoint,Throwable exception){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->异常通知，增强方法为："+name+"异常信息："+exception);

    }

    // @After() 后置
    @After(value = "execution(* com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){//可以存在参数JoinPoint，以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->后置通知，增强方法为："+name);

    }
    // @Around() 环绕通知，可以通过try-catch-finally,使得增强方法在所有阶段执行（增强方法可设置返回值）
    @Around("execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    //可设置 ProceedingJoinPoint属性参数,以此调用增强方法(JoinPoint的子接口，JoinPoint没有调用目标方法的功能)
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//通过ProceedingJoinPoint参数获取增强方法名
        Object[] args = joinPoint.getArgs();             //获取增强方法参数数组
        String argStr = Arrays.toString(args);           //参数数组转字符串
        Object result = null;

        try{
            System.out.println("环绕通知 == 增强方法执行前执行");

            //通过ProceedingJoinPoint类型参数调用增强方法
            result = joinPoint.proceed();

            System.out.println("环绕通知 = 增强方法返回值之后执行");

        }catch(Throwable throwable){//捕捉Throwable类型异常
            throwable.printStackTrace();
            System.out.println("环绕通知 = 增强方法异常时执行");

        }finally {
            System.out.println("环绕方法 = 增强方法执行完毕执行");

        }

        return result;
    }

切面优先级：

切面的优先级控制切面的 内外嵌套 顺序
外层切面：优先级高
内层切面：优先级低

…
可使用@Order()注解设置优先级
@Order(较小的数) 优先级较高
@Order(较大的数) 优先级较低


4.配置Spring配置文件（这里命名为 bean.xml）：

<?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/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        基于注解的AOP的实现：
        1、将目标对象和切面交给IOC容器管理（注解+扫描）
        2、开启AspectJ的自动代理，为目标对象自动生成代理
        3、将切面类通过注解@Aspect标识
    -->
    <context:component-scan base-package="com.haojin.spring.aop.annoaop"></context:component-scan>

    <!--开启AspectJ的自动代理-->
    <aop:aspectj-autoproxy />

</beans>

5.测试：

import com.haojin.spring.aop.annoaop.Calculator;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author .29.
 * @create 2023-02-06 9:34
 */
public class TestAop {
    //以实现类中的加法功能为例
    @Test
    public void testAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Calculator bean = context.getBean(Calculator.class);
        bean.add(3,13);
    }
}

在这里插入图片描述

.29.
关注
专栏目录
AOP的底层实现-CGLIB动态代理和JDK动态代理
836811384
10-20 1024
AOP是目前Spring框架中的核心之一，在应用中具有非常重要的作用，也是Spring其他组件的基础。它是一种面向切面编程的思想。关于AOP的基础知识，相信多数童鞋都已经了如指掌，我们就略过这部分，来讲解下AOP的核心功能的底层实现机制：如何用动态代理来实现切面拦截。 AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面...
AOP的动态代理
xh_yj的博客
01-13 640
一、什么是AOP 1、面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重复性，同时提高了开发的效率。 2、通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。 3、列：实现登录权限功能中用到了AOP 二、AOP底层原理 1、Aop底层使用动态代理 （1）有两种情况动态代理   第一种 有接口情况，使用JDK动态代理   第二种没有接口情况，使用CGLIB动态代理 ...
Spring的AOP原理
weixin_33896069的博客
03-04 1342
为什么80%的码农都做不了架构师？>>> ...
简单了解AOP
最新发布
2302_78100610的博客
09-16 1445
AOP（面向切面编程）：一、概念解释AOP 即 Aspect Oriented Programming，意为面向切面编程。它是通过预编译方式和运行期间动态代理实现程序功能统一维护的一种技术。AOP 是面向对象编程（OOP）的延续，在 Java 开发中占据重要地位。它能够将业务逻辑和非业务逻辑进行隔离，比如将日志记录、事务管理、权限验证等与核心业务逻辑分离，从而降低各部分之间的耦合度，提高程序的可重用性和开发效率。二、核心原理AOP 的核心原理是使用动态代理的方式在执行方法前后或者出现异常的时候加入相关的逻辑
动态代理方式实现AOP
weixin_34085658的博客
01-01 235
摘要：面向对象的思想强调"一切皆是对象"，在面向对象的程序中我们使用真实概念的模型思考问题，使得整个软件系统开发可以像搭建房屋一样有条不紊。然而面向对象也并非完美无缺的，它更注重于对象层次结构方面的东西，对于如何更好的管理对象行为内部结构，还存在着些许不足。那么我们如何使这个问题的得到更完美的解决呢？答案就是AOP。 主要内容： AOP简述 利用动态代理实现AOP 总结 一、A...
aop的底层原理
weixin_42596214的博客
01-05 899
AOP(面向切面编程)是一种程序设计思想，旨在将一些跨越多个对象的功能(即切面)模块化。这样可以有效地将与一般业务逻辑无关的功能从核心业务逻辑中分离出来，这样就可以在不修改核心业务逻辑的情况下在不同的地方重用这些功能，也可以更灵活地对这些功能进行配置和管理。 AOP的底层原理是动态代理。动态代理是在运行时动态地创建代理类的一种机制，它可以在不修改源码的情况下，为一个对象提供额外的功能。在 AOP ...
Spring AOP底层原理、注解和代码样例
热门推荐
用文字记录下每一个瞬间的感动和每一次思考的火花
03-11 11万+
Spring AOP是面向切面编程的一种实现，它允许开发者将横切关注点（如日志、事务管理等）与业务逻辑分离，从而提高代码的模块化和可维护性。在底层，Spring AOP主要通过Java的动态代理机制实现，对于实现了接口的类，它使用JDK动态代理；对于没有实现接口的类，则使用CGLIB代理。连接点（Join Point）表示“在哪里干”；只支持方法执行作为连接点；所有类的所有方法均可以作为连接点。切点（Pointcut）“在哪里干”的集合；
SpringBoot下的SpringAOP-day04-源代码
03-09
SpringBoot下的Spring——DAY04——动态代理总结、AOP、自定义注解进行拦截、动态获取注解参数、通知方法 1.动态代理总结 1.1 JDK动态代理特点 1.2 CGlib动态代理 1.2.1 CGLib特点说明 1.3 动态代理的作用 2 Spring...
2024-spring-aop学习项目
01-26
代理模式下，Spring可以创建JDK动态代理或CGLIB代理对象，来实现切面的插入。ASM字节码操作则允许在运行时对类进行修改，实现更灵活的切面织入。 四、AOP实战 1. 配置切面：在Spring配置文件中声明切面，定义切入点...
小马哥讲 Spring AOP 编程思想 - API 线索图.pdf
04-13
上述知识点覆盖了Spring AOP的基本概念、核心组件以及如何通过配置来创建和使用代理对象。通过这些知识的学习和应用，可以更好地实现业务逻辑与非业务逻辑代码的分离，提高代码的可维护性和可重用性。
AOP术语、SpringAOP
qq_45859087的博客
08-09 280
AOP术语、SpringAOPAOP中的相关术语SpringAOP中的实现Spring对AOP的支持示例切点表达式、切点切面增强通知织入目标对象结果 AOP中的相关术语 官方 Aspect: A modularization of a concern that cuts across multiple classes. Transaction management is a good example of a crosscutting concern in enterprise Java applicat
AOP底层原理
QQ3156304857的博客
12-12 365
AOP底层原理： (1)有接口的情况下，使用jdk实现动态代理。 (2)没有接口的情况下，使用cglib实现动态代理。
AOP-底层原理
cy364328541的博客
04-16 5238
AOP底层原理讲解及代码实现
AOP原理
Just Do It!
03-09 658
AOP概述 软件的编程语言最终的目的就是用更自然更灵活的方式模拟世界，从原始机器语言到过程语言再到面向对象的语言，我们看到编程语言在一步步用更自然、更强大的方式描述软件。AOP是软件开发思想的一个飞跃，AOP的引入将有效弥补OOP的不足，OOP和AOP分别从纵向和横向对软件进行抽象，有效地消除重复性的代码，使代码以更优雅的更有效的方式进行逻辑表达。 AOP有三种植入切面的方法：其一是编译期织入
Spring Aop底层原理（动态代理）
weixin_44084096的博客
04-02 255
通过静态代理引出动态代理理解Spring Aop底层原理
Java AOP的底层原理
Spring_Lws的博客
07-13 1万+
一、什么是AOP？1.AOP：Aspect Oriented Programming（面向切面编程），OOP是面向对象编程，AOP是在OOP基础之上的一种更高级的设计思想。2.OOP和AOP之间也存在一些区别，OOP侧重于对象的提取和封装。—封装对象AOP侧重于方面组件，方面组件可以理解成封装了通用功能的组件，方面组件可以通过配置方式，灵活地切入到某一批目标对象方法上。—封装功能3.AOP用于处理...
Spring框架-AOP底层实现原理
qq_44715376的博客
01-28 1828
Spring框架-AOP底层实现原理
AOP动态代理原理剖析
开心的哈士奇
03-24 234
1. 神马是AOP ？ AOP，英文（Aspect Oriented Programming）的缩写，意为：面向切面编程，通过预编译方式和运行时期动态代理实现程序功能的统一维护的一种技术。 AOP可以看做是OOP（面向对象编程）的延续，是软件开发的一个热点，也是Spring框架中的一个重要内容...
AOP底层原理（JDK动态代理实现）
m0_61465063的博客
01-05 219
AOP底层使用动态代理 有两种情况动态代理 第一种有接口情况，使用JDK动态代理 第二种无接口情况，使用CGKIB动态代理 这里来演示第一种情况 1我们先定义一个接口 public interface UserDao { public int add(int a,int b); public String update(String s); } 2定义接口的实现类 public class UserDaoIm implements UserDao{ @Override pub
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

.29.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值