Spring——AOP

最新推荐文章于 2023-10-26 10:30:45 发布
最新推荐文章于 2023-10-26 10:30:45 发布
阅读量127 收藏
点赞数
分类专栏： Spring 文章标签： Spring Spring AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41573234/article/details/96475234
版权

1. 相关概念

1.1 AOP 相关术语

  • 连接点（Joinpoint）：所谓连接点是指那些被拦截到的点，在spring中，这些点指方法，因为spring只支持方法类型的连接，实际上，jionpoint还可以是field或类构造器。
  • 切点（Pointcut）：被增强的连接点。例如：add()
  • 通知或增强（Advice）：所谓通知是指拦截到 joinpoint 之后所要做的事情，分为前通知、后置通知、异常通知、最终通知、环绕通知。
  • 目标对象（Target）：代理的目标对象.。如果没有 AOP，目标业务类需要自己实现所有逻辑，而在 AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用 AOP 动态织入到特定的连接点上。
  • 切面（Aspect）：切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP 就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。
  • 织入（Weaving）织入是将aspects对象应用到target对象并导致proxy对象创建的过程。

1.2 通知类型

  • 前置通知（Before）：在目标方法被调用之前调用通知功能；
  • 后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
  • 返回通知（After-returning）：在目标方法成功执行之后调用通知；
  • 异常通知（After-throwing）：在目标方法抛出异常后调用通知；
  • 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为；

 1.3 spring 提供了 2 种 AOP 实现方式

  1.3.1  Schema-based

  • 每个通知都需要实现接口或类
  • 配置 spring 配置文件时在<aop:config>配置

1.3.2 AspectJ

  • 每个通知不需要实现接口或类
  • 配置 spring 配置文件是在<aop:config>的子标签
  • <aop:aspect>中配置

2. Schema-based 方式实现

2.1 前置、后置通知

2.1.1 包依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zth.spring</groupId>
    <artifactId>spring09</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>5.1.4.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.4.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>



    </dependencies>

    <build>
        <finalName>spring09</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.1.2 原始类

@Component
public class Email {
    public void send(){
        System.out.println("发送中。。。");
    }

}

2.1.3 通知类

前置通知类

package com.zth.asp;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author zth
 * @Date 2019-07-19 10:26
 */
@Component
public class BeforeAdvice implements MethodBeforeAdvice {
    /**
     *
     * @param method 切点方法对象 Method 对象
     * @param args 切点方法参数
     * @param target 切点在哪个对象中
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("发送前邮件。。。");
    }
}

后置通知类：

package com.zth.asp;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author zth
 * @Date 2019-07-19 10:26
 */
@Component
public class AfterAdvice implements AfterReturningAdvice {

    /**
     *
     * @param returnValue 切点方法返回值
     * @param method 切点方法对象
     * @param args 切点方法参数
     * @param target 切点方法所在的类对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("发送邮件后。。。");
    }
}

2.1.4  spring 配置文件

<?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">

    <context:annotation-config/>
    <context:component-scan base-package="com"/>

    <!--配置切面-->
    <aop:config>
        <!--配置切点-->
        <aop:pointcut id="point01" expression="execution(* com.zth.service.*.*(..))"/>
        <!--通知-->
        <aop:advisor advice-ref="beforeAdvice" pointcut-ref="point01"/>
        <aop:advisor advice-ref="afterAdvice" pointcut-ref="point01"/>
    </aop:config>

</beans>

2.1.5 测试类

package com.zth;

import com.zth.service.Email;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


/**
 * @author zth
 * @Date 2019-07-19 10:52
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value={"/ApplicationContext.xml"})
public class MyTest {

    @Autowired
    Email email;
    @Test
    public void test(){
        email.send();
    }

}

2.1.6 执行结果

 

2.2 异常通知

2.2.1 创建异常通知类

package com.zth.asp;

import org.springframework.aop.ThrowsAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author zth
 * @Date 2019-07-19 11:41
 */
@Component
public class ExceptionAdvice implements ThrowsAdvice {
    public void afterThrowing(Method m, Object[] args, Object target, Exception ex) {
        System.out.println("执行异常通知");
    }
   /* public void afterThrowing(Exception ex) throws Throwable {
        System.out.println("执行异常通过-schema-base 方式");
    }*/
}
  • 新建一个类实现 throwsAdvice 接口
  • 必须自己写方法,且必须叫 afterThrowing
  • 有两种参数方式 ， 必须是 1 个或 4 个
  • 异常类型要与切点报的异常类型一致

2.2.2 spring 配置文件

<!--配置切面-->
<aop:config>
<!--配置切点-->
    <aop:pointcut id="point01" expression="execution(* com.zth.service.*.*(..))"/>
    <!--通知-->
    <aop:advisor advice-ref="exceptionAdvice" pointcut-ref="point01"/>
</aop:config>

【注】其他步骤同上

 

2.2.3 执行结果

没有异常：

添加异常：

@Component
public class Email {
    public void send() throws Exception {

        System.out.println("发送中。。。");
        throw new Exception();
    }

}

执行结果：

 

2.2 环绕通知

2.2.1 新建环绕通知类

package com.zth.asp;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.stereotype.Component;

@Component
public class MyArround implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("环绕前置。。。");
        Object result = invocation.proceed();
        System.out.println("环绕后置。。。");
        return result;
    }
}

2.2.2 spring 配置文件

 <!--配置切面-->
    <aop:config>
        <!--配置切点-->
        <aop:pointcut id="point01" expression="execution(* com.zth.service.*.*(..))"/>
        <!--通知-->
        <aop:advisor advice-ref="myArround" pointcut-ref="point01"/>
    </aop:config>

【注】其他同上

2.2.3 测试结果：

 

3. AspectJ 方式实现

3.1 前置、后置通知

3.1.1 原始类

@Component
public class Email {
    public void send(){
        System.out.println("发送中。。。");
    }

}

3.1.2 通知类

package com.zth.asp;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class Logger {

    public void before() {
        System.out.println("before...");
    }
    public void after() {
        System.out.println("after....");
    }
    public void exception(){
        System.out.println("出错了。。。");
    }

}

 

3.1.3  spring 配置文件

<!--配置切面-->
<aop:config>
   <aop:aspect ref="logger">
	   <aop:pointcut id="point01" expression="execution(* com.zth.service.*.*(..))"/>
	   <aop:before method="before" pointcut-ref="point01"/>
	   <aop:after method="after" pointcut-ref="point01"/>
	   <aop:after-throwing method="exception" pointcut-ref="point01"/>
   </aop:aspect>
</aop:config>

3.1.4  执行结果

有异常：

没有异常：

3.2 环绕通知

3.2.1 创建通知类

package com.zth.asp;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class Logger {

    public Object myArround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前置。。。");
        Object result = joinPoint.proceed();
        System.out.println("环绕后置。。。");
        return result;
    }



}

3.2.2 spring 配置文件

<aop:config>
   <aop:aspect ref="logger">
	   <aop:pointcut id="point01" expression="execution(* com.zth.service.*.*(..))"/>
	   <aop:around method="myArround" pointcut-ref="point01"/>
   </aop:aspect>
</aop:config>

【注】其他步骤同上

3.2.3 执行结果

  • <aop:after/> 后置通知,是否出现异常都执行
  • <aop:afte-returing />后置通知,只有当切点正确执行时 执行
  • <aop:after/>和 <aop:afte-returing />和<aop:afte-throwing/> 执行顺序和配置顺序有关

带参数的切点：

  • execution() 括号不能扩上 args
  • 中间使用 and 不能使用&& 由 spring 把 and 解析成&&
  • args() 有几个参数,arg-names 里面必须有几个参数
  • arg-names=”” 里面名称必须和通知方法参数名对应 

 

4. 使用注解(基于 Aspect)

4.1 applicationContent.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">

    <context:annotation-config/>
    <context:component-scan base-package="com"/>
    //启用Aspectj自动代理
    <aop:aspectj-autoproxy />

</beans>

4.2代理类

package com.zth.asp;

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

@Aspect
@Component
public class Logger {

    @Pointcut("execution(* com.zth.service.*.*(..))")
    private void anyPublicOperation() {}

    @Before("anyPublicOperation()")
    public void before() {
        System.out.println("before...");
    }
    @After("anyPublicOperation()")
    public void after() {
        System.out.println("after....");
    }
    @AfterThrowing("anyPublicOperation()")
    public void exception(){
        System.out.println("出错了。。。");
    }

    @Around("anyPublicOperation()" )
    public Object myArround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前置。。。");
        Object result = joinPoint.proceed();
        System.out.println("环绕后置。。。");
        return result;
    }
    
}

4.3 测试结果

 

 

时光·漫步zth
关注
专栏目录
»Spring 之AOP AspectJ切入点语法详解（最全了，不需要再去其他地找了）
jinnianshilongnian的专栏
02-21 6834
6.5  AspectJ切入点语法详解 6.5.1  Spring AOP支持的AspectJ切入点指示符        切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：          execution：用于匹配方法执行的连接点；          wi...
完爆面试官的Spring——AOP详解（AOP概览）
m0_68850571的博客
04-09 489
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 然后我们举一个比较容易理解
spring——AOP术语（Target(目标对象，目标类)，Joinpoint(连接点)，Pointcut(切入点)，Advice(通知/增强)，Aspect(切面)，Proxy（代理），织入）
Harden_zsc的博客
10-07 1734
Target(目标对象，目标类):代理的目标对象。例如：UserServiceImpl Joinpoint(连接点):程序的某个特定位置，比如类开始初始化前，初始化后，方法调用前后，抛出异常前后等。例如：eat方法调用前后 Pointcut(切入点):基于连接点，链接点描述的可以增强的点，如果真的在这个点增强了，那这个点就叫做切入点。例如：eat方法调用之前如果进行了增强，那这个点就叫做切入点 Advice(通知/增强):需要添加的那段增强功能的逻辑代码，通知的类型：前置通知,后置通知,异常通知,最终通知.
spring-aop组件详解——TargetSource目标源
stevenxyy的博客
03-12 957
spring aop
Spring AOP
qq_44807789的博客
03-06 215
Spring AOP 什么是AOP AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP作用 作用：在程序运行期间，在不修改源码的情况下对方法功能进行增强。 优势：减少重复代码，提高开发效率，并且便于维护 AOP底层实现 实际上，AOP的底层是通过Spring提供的的动态代理技术实现的。在运行期间, Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标
SpringAOP源码解析之TargetSource(四)
最新发布
于琦海
10-26 510
在Spring框架中，TargetSource是一个接口，用于封装获取目标对象（也就是被代理的对象）的逻辑。它的主要作用是提供代理对象使用的目标对象，并且允许在运行时动态地切换目标对象。TargetSource在Spring的AOP（面向切面编程）中非常重要，它定义了代理对象的目标是谁以及在何时获取目标对象。具体来说，TargetSource接口定义了以下两个方法：getTarget()：这个方法用于获取目标对象。
Spring——aop
12-23
**Spring AOP 知识详解** 在Java开发领域，Spring框架是不可或缺的一部分，它提供了许多强大的功能，其中AOP（面向切面编程）是其重要特性之一。AOP允许开发者将关注点分离，使得业务逻辑代码与系统服务如日志、...
【Spring——AOP详解】
your_棒棒糖的博客
05-03 254
Spring ——AOP详解 jdk代理（基于接口）：如果目标实现了接口，那么默认使用jdk代理。 cglib代理（基于类）：如果目标没有实现接口，那么默认使用cglib代理。 Spring AOP概述 纵向抽取： 在Java的面向对象中，代码重复了，则1. 抽取成方法；2. 抽取类；其中抽取成类的方式称之为：纵向抽取——通过继承的方式实现纵向抽取 横向抽取： 抽取成类还是会出现重复的代码，因为这些（开始，结束，提交事务）依附在我们业务类的方法逻辑中！——反复造轮子 AOP的理念：就是将分散
细说Spring——AOP详解（使用CGLIB实现AOP）
啦啦啦的博客
06-09 2681
一、动态代理实现AOP的缺陷 在上一篇文章细说Spring——AOP详解（动态代理实现AOP）中讲解了如何使用动态代理实现AOP，虽然Java动态代理为我们提供了非常灵活的代理机制，但Java动态代理是基于接口的，如果目标对象没有实现接口我们该如何代理呢？这时候我们就需要使用CGLIB来实现AOP了。 二、CGLIB实现代理的原理 我们先创建一个目标对象 package demo1; ...
Spring——AOP(Aspect Oriented Programming)
m0_50744075的博客
08-11 243
Spring——AOP
spring aop的@target与@within的真正区别到底是什么？
若鱼的专栏
06-19 5826
文档里面是这么说的： @target: Limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type. @within: Limits matching to join points within types that have the given annot
Spring中的AOP
weixin_44961111的博客
09-25 105
Spring中的AOP 1.什么是AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2.AOP的作用及其优势 作用：在程序运行期间，在不
彻底搞懂SpringAOP中的@within和@target
qq_36917119的博客
08-20 1万+
本文是对参考连接的一个补充，只讨论@within和@target的区别。如果不懂注解的、不懂AOP的先去补一下。 参考连接 概述 @within和@target是在配置切点的时候使用到的两个修饰符，都是基于注解来配置切点。 比如当前有注解@A "@within(com.annotation.other.A1)"该配置就是：如果某个类上标注了注解@A，那么该类中的方法就会被相关Advice所影响，如果该类有子类或孙子类，也会影响到子类中没有重写的父类方法。(看不懂的别急，后面有例子) "@target(co
Spring-AOP @AspectJ切点函数之@within()和@target
小工匠
09-05 7万+
概述 targetM的匹配规则 withinM的匹配规则 实例 target within 注意事项概述除了@annotation和@args外，还有另外两个用于注解的切点函数，分别是@target和@within. 和@annotation @args函数一样，@target和@within也只接受注解类名作为入参。 其中@target(M)匹配任意标注了@M的目标类，而@within(M)匹配标
Spring-AOP @AspectJ切点函数之target()和this()
小工匠
09-06 2万+
概述 实例 target this概述target()切点函数通过判断目标类是否按类型匹配指定类来决定连接点是否匹配. 用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；this()切点函数则通过判断代理类是否按类型匹配指定类来决定是否和切点匹配。 用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型
springAOP中的target、this、within的区别
菜到怀疑人生的博客
09-03 7697
前言 关于这三者的区别，在网上找到的资料不多，大多是AspectJ的资料，并且大量的copy，查阅官方文档后，自己又做了一些实验，最终有了这篇博客，因为是自己摸索的结果，并且没有阅读相应源码，如有错误，欢迎指出（有空还是把markdown给看了，csdn的排版不是很喜欢...........   target target匹配目标对象的类型，即被代理对象的类型，例如A继承了B接口，则使用t...
Spring AOP实现原理简介
热门推荐
wyl6019的博客
04-28 7万+
AOP联盟标准AOP联盟将AOP体系分为三层，从三层结构可以看出，AOP实现方式有很多种，包括反射、元数据处理、程序处理、拦截器处理等，通过本节学习，你就会看到Spring AOP的实现使用的是Java语言本身的特性，即Java Proxy代理类、拦截器技术实现。AOP简介概念切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。连接点（Joinpoint）...
Spring Aop之Target Source详解
lw_yang的博客
11-23 1957
在Spring代理目标bean的时候，其并不是直接创建一个目标bean的对象实例的，而是通过一个TargetSource类型的对象将目标bean进行封装，Spring Aop获取目标对象始终是通过TargetSource.getTarget()方法进行的。本文首先会讲解Spring Aop是如何封装目标对象到TargetSource中的，然后会讲解TargetSource各个方法的使用原理，接着会...
# spring-aop 切入点 target 表达式
A_com_Z的博客
08-19 772
# spring aop target表达式 基本的格式：@PointCut（"target(包名.接口名)"） 具体如下例子实现： 1.PersonDao接口： package com.Aop.Expression; public interface PersonDao { //测试这个target 表达式 public void personsay(String ...
Spring的AOP
08-12
- *1* [细说Spring——AOP详解（AOP概览）](https://blog.csdn.net/q982151756/article/details/80513340)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值