05-SpringAOP的使用详解

最新推荐文章于 2024-05-15 09:41:25 发布
最新推荐文章于 2024-05-15 09:41:25 发布
阅读量187 收藏 1
点赞数
分类专栏： Spring 文章标签： java spring 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yh360311/article/details/126992184
版权

大家好，我是徐庶老师，专注java，想要学习java的同学可以欢迎关注我。

结合视频观看效果更佳哦：2022最新Spring5入门到源码【完整资料+源码】_哔哩哔哩_bilibili

SpringAOP的使用详解

1、AOP切入点表达式

切点标识符

Spring AOP支持使用以下AspectJ切点标识符(PCD),用于切点表达式：

  • execution: 用于匹配方法执行连接点。 这是使用Spring AOP时使用的主要切点标识符。 可以匹配到方法级别 ，细粒度
  • within: 只能匹配类这级，只能指定类， 类下面的某个具体的方法无法指定， 粗粒度
  • this: 匹配实现了某个接口：this(com.xyz.service.AccountService)
  • target: 限制匹配到连接点（使用Spring AOP时方法的执行），其中目标对象（正在代理的应用程序对象）是给定类型的实例。
  • args: 限制与连接点的匹配（使用Spring AOP时方法的执行），其中变量是给定类型的实例。 AOP) where the arguments are instances of the given types.
  • @target: 限制与连接点的匹配（使用Spring AOP时方法的执行），其中执行对象的类具有给定类型的注解。
  • @args: 限制匹配连接点（使用Spring AOP时方法的执行），其中传递的实际参数的运行时类型具有给定类型的注解。
  • @within: 限制与具有给定注解的类型中的连接点匹配（使用Spring AOP时在具有给定注解的类型中声明的方法的执行）。
  • @annotation:限制匹配连接点（在Spring AOP中执行的方法具有给定的注解）。

这里重点介绍3个： execition、within、@annotation 更多详解有兴趣可通过视频学习：
2022最新Spring5入门到源码【完整资料+源码】_哔哩哔哩_bilibili

切点标识符—within表达式

通过类名进行匹配 粗粒度的切入点表达式

within(包名.类名)

则这个类中的所有的连接点都会被表达式识别，成为切入点。

<aop:pointcut expression="within(cn.tulingxueyuan.service.UserServiceImpl)"

在within表达式中可以使用*号匹配符，匹配指定包下所有的类，注意，只匹配当前包，不包括当前包的子孙包。

    <aop:pointcut expression="within(cn.tulingxueyuan.service.*)"

在within表达式中也可以用*号匹配符，匹配包

    <aop:pointcut expression="within(cn.tulingxueyuan.*.*)"

在within表达式中也可以用..*号匹配符，匹配指定包下及其子孙包下的所有的类

    <aop:pointcut expression="within(cn.tulingxueyuan..*)"
切点标识符—execution()表达式

细粒度的切入点表达式，可以以方法为单位定义切入点规则

基本语法：
在这里插入图片描述

语法说明：

  • 访问修饰符：(public、protected …)可不写，不写则可以匹配任何一个访问修饰符

  • 返回值：

    • 如果是jdk自带类型可以不用写完整限定名；(如:String,Integer 等…)
    • 如果是自定义类型需要写上完整限定名；(如:com.xushu.UserServiceImple等…)
    • 如果被切入的方法返回值不一样可以使用* 代表所有的方法值都能匹配

  • 包名：

    • 示例： cn.* == cn.tulingxuyuean == cn.任意名字 ，但是只能匹配一级 比如 cn.tulingxueyuan.service就无法匹配
    • 如果要匹配cn.tulingxueyuan.service 可以 cn.tulingxueyuan.* 但cn.tulingxueyuan.service.impl又无法匹配
    • 可以用.. (代表子孙包) : cn.tulingxueyuan..* ==cn.tulingxueyuan.service.impl 可以匹配

  • 类名：可以具体类名也 可以写*，代表任何名字的类名。

    • 也可以模糊匹配 *ServiceImpl==> UserServiceImpl ==>RoleServiceImpl

  • 方法名：可以具体方法名也可以写*，代表任何方法。

    • 也可以模糊匹配 *add==> useradd ==>roleadd

  • 参数：如果是jdk自带类型可以不用写完整限定名，如果是自定义类型需要写上完整限定名。

    • 如果需要匹配任意参数 可以写：..

示例：
在这里插入图片描述

  • 例子1：

      <aop:pointcut expression="execution(void cn.tulingxueyuan.service.UserServiceImpl.addUser(java.lang.String))" id="pc1"/>

该切入点规则表示，切出指定包下指定类下指定名称指定参数指定返回值的方法。

  • 例子2：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service.*.query())" id="pc1"/>

该切入点规则表示，切出指定包下所有的类中的query方法，要求无参，但返回值类型不限。

  • 例子3：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service..*.query())" id="pc1"/>

该切入点规则表示，切出指定包及其子孙包下所有的类中的query方法，要求无参，但返回值类型不限。

  • 例子4：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service..*.query(int,java.lang.String))" id="pc1"/>

该切入点规则表示，切出指定包及其子孙包下所有的类中的query方法，要求参数为int java.langString类型，但返回值类型不限。

  • 例子5：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service..*.query(..))" id="pc1"/>

该切入点规则表示，切出指定包及其子孙包下所有的类中的query方法，参数数量及类型不限，返回值类型不限。

  • 例子6：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service..*.*(..))" id="pc1"/>

该切入点规则表示，切出指定包及其子孙包下所有的类中的任意方法，参数数量及类型不限，返回值类型不限。这种写法等价于within表达式的功能。

  • 例子7：

      <aop:pointcut expression="execution(* cn.tulingxueyuan.service..*.del*(..))" id="pc1"/>

合并切点表达式

您可以使用 &&, || 和 !等符号进行合并操作。也可以通过名字来指向切点表达式。

  • //&&：两个表达式同时=并且

      execution( public int cn.tulingxueyuan.inter.MyCalculator.*(..)) && execution(* *.*(int,int) )

  • //||：任意满足一个表达式即可

      execution( public int cn.tulingxueyuan.inter.MyCalculator.*(..)) && execution(* *.*(int,int) )

  • //！：只要不是这个位置都可以进行切入= 取反

      ! execution( public int cn.tulingxueyuan.inter.MyCalculator.*(..))

2、通知方法的执行顺序

		在之前的代码中大家一直对通知的执行顺序有疑问，其实执行的结果并没有错，大家需要注意：
		1、正常执行：@Before--->@After--->@AfterReturning
		2、异常执行：@Before--->@After--->@AfterThrowing

在这里插入图片描述

Spring在5.2.7之后改变了advice 的执行顺序。
之前：
在这里插入图片描述
改后：

1、正常执行：@Before—>@AfterReturning—>@After
2、异常执行：@Before—>@AfterThrowing—>@After

如想追溯官方说明：在github官网版本更新说明中有说明：如图

更新说明：https://github.com/spring-projects/spring-framewor…
#25186链接：https://github.com/spring-projects/spring-framewor…

3、获取方法的详细信息

	在上面的案例中，我们并没有获取Method的详细信息，例如方法名、参数列表等信息，想要获取的话其实非常简单，只需要添加JoinPoint参数即可。

LogUtil.java

package cn.tulingxueyuan.util;

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

import java.util.Arrays;

@Component
@Aspect
public class LogUtil {

    @Before("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public static void start(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法开始执行，参数是："+ Arrays.asList(args));
    }

    @AfterReturning("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public static void stop(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完成，结果是：");

    }

    @AfterThrowing("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public static void logException(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法出现异常：");
    }

    @After("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public static void end(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行结束了......");
    }
}

获取返回值

刚刚只是获取了方法的信息，但是如果需要获取结果，还需要添加另外一个方法参数，并且告诉spring使用哪个参数来进行结果接收
LogUtil.java

 @AfterReturning(value = "execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))",
                    returning = "result")
    public static void stop(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完成，结果是："+result);

    }

获取异常信息

也可以通过相同的方式来获取异常的信息
LogUtil.java

   @AfterThrowing(value = "execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))",throwing = "exception")
    public static void logException(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法出现异常："+exception);
    }

4、表达式的抽取

如果在实际使用过程中，多个方法的表达式是一致的话，那么可以考虑将切入点表达式抽取出来：
a、随便生命一个没有实现的返回void的空方法
b、给方法上标注@Potintcut注解

package cn.tulingxueyuan.util;

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

import java.util.Arrays;

@Component
@Aspect
public class LogUtil {
    
    @Pointcut("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public void myPoint(){}
    
    @Before("myPoint()")
    public static void start(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法开始执行，参数是："+ Arrays.asList(args));
    }

    @AfterReturning(value = "myPoint()",returning = "result")
    public static void stop(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完成，结果是："+result);

    }

    @AfterThrowing(value = "myPoint()",throwing = "exception")
    public static void logException(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法出现异常："+exception.getMessage());
    }

    @After("myPoint()")
    private int end(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行结束了......");
        return 0;
    }
}

5、环绕通知的使用

LogUtil.java

package cn.tulingxueyuan.util;

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

import java.util.Arrays;

@Component
@Aspect
public class LogUtil {
    @Pointcut("execution( public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))")
    public void myPoint(){}
    
    /**
     * 环绕通知是spring中功能最强大的通知
     * @param proceedingJoinPoint
     * @return
     */
    @Around("myPoint()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint){
        Object[] args = proceedingJoinPoint.getArgs();
        String name = proceedingJoinPoint.getSignature().getName();
        Object proceed = null;
        try {
            System.out.println("环绕前置通知:"+name+"方法开始，参数是"+Arrays.asList(args));
            //利用反射调用目标方法，就是method.invoke()
            proceed = proceedingJoinPoint.proceed(args);
            System.out.println("环绕返回通知:"+name+"方法返回，返回值是"+proceed);
        } catch (Throwable e) {
            System.out.println("环绕异常通知"+name+"方法出现异常，异常信息是："+e);
        }finally {
            System.out.println("环绕后置通知"+name+"方法结束");
        }
        return proceed;
    }
}

环绕通知的执行顺序是优于普通通知的，具体的执行顺序如下：
环绕前置–>普通前置–>目标方法执行–>环绕正常结束/出现异常–>环绕后置–>普通后置–>普通返回或者异常。

但是需要注意的是，如果出现了异常，那么环绕通知会处理或者捕获异常，普通异常通知是接收不到的，因此最好的方式是在环绕异常通知中向外抛出异常。

6、基于XML配置的AOP配置

	之前我们讲解了基于注解的AOP配置方式，下面我们开始讲一下基于xml的配置方式，虽然在现在的企业级开发中使用注解的方式比较多，但是你不能不会，因此需要简单的进行配置，注解配置快速简单，配置的方式共呢个完善。

1、将所有的注解都进行删除
2、添加配置文件
spring.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
       https://www.springframework.org/schema/aop/spring-aop.xsd
">

    <context:component-scan base-package="cn.tulingxueyuan"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="logUtil" class="cn.tulingxueyuan.util.LogUtil2"></bean>
    <bean id="securityAspect" class="cn.tulingxueyuan.util.SecurityAspect"></bean>
    <bean id="myCalculator" class="cn.tulingxueyuan.inter.MyCalculator"></bean>
    <aop:config>
        <aop:pointcut id="globalPoint" expression="execution(public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))"/>
        <aop:aspect ref="logUtil">
            <aop:pointcut id="mypoint" expression="execution(public int cn.tulingxueyuan.inter.MyCalculator.*(int,int))"/>
            <aop:before method="start" pointcut-ref="mypoint"></aop:before>
            <aop:after method="end" pointcut-ref="mypoint"></aop:after>
            <aop:after-returning method="stop" pointcut-ref="mypoint" returning="result"></aop:after-returning>
            <aop:after-throwing method="logException" pointcut-ref="mypoint" throwing="exception"></aop:after-throwing>
            <aop:around method="myAround" pointcut-ref="mypoint"></aop:around>
        </aop:aspect> 
    </aop:config>
</beans>

面试题

  • Spring通知有哪些类型？
  • 解释基于XML Schema方式的切面实现
  • 解释基于注解的切面实现
老徐爱编程
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP用法详解
深圳市多克创新科技有限公司
10-23 987
AOP：Aspect Oriented Programming，中文翻译为”面向切面编程“。面向切面编程是一种编程范式，它作为OOP面向对象编程的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、权限控制、缓存控制、日志打印等等。AOP采取横向抽取机制，取代了传统纵向继承体系的重复性代码
Spring AOP 的三种使用方式(万字长文)
大鹏的博客
06-21 2457
Spring AOP 作为 Spring Framework 的核心模块，对 Spring IOC 加以补充，Spring 内部使用它提供了企业级的服务，如事务、异步、缓存等，同时它也允许用户自定义 Aspect，以便用 AOP 补充对 OOP 的使用。通常情况下，我们会通过 AspectJ 的注解来使用 Spring AOP，那么 Spring 一共提供了哪些使用 AOP 的方式呢？本篇将对其总结，并尝试了解 Spring AOP 的内部实现。
【Spring】AOP中的核心概念：通知(Advice)和切点(Pointcut)
最新发布
m0_65277261的博客
05-15 1054
通知(Advice)：在切面的某个特定的连接点上执行的动作。通知有多种类型，包括“around”，“before” 和“after”等等。通知的类型将在后面详细了解。许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链。 用来放增强的代码的那个方法 环绕通知@Around：可以把代码增强在目标方法的任意地方，更通用 前置通知@Before：目标方法之前执行 后置通知@After：目标方法之后执行 异常通知@AfterThrowing：目标方法出现了异常执行
AOP的使用（详细讲解）
酷小亚
08-31 1万+
一、AOP基本概念 二、AOP底层原理 三、AOP的JDK动态代理 四、AOP术语 五、AOP操作（准备） 六、AOP操作（AspectJ注解）【重点】 七、AOP操作（AspectJ配置文件）
spring18--spring中的通知
月落孤城的博客
04-29 343
1、前置通知 org.springframework.aop.MethodBeforeAdvice * 在目标方法执行前实施增强 2、后置通知 org.springframework.aop.AfterReturningAdvice * 在目标方法执行后实施增强 3、环绕通知 org.aopalliance.intercept.MethodInterceptor * 在目标方法执行前后实...
设计模式--谈谈AOP 面向切面编程
penriver的博客
07-07 1553
1. AOP AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的一种技术。 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率 面向方面编程(AOP)通过提供考虑程序结构的另一种方法来补充面向对象编程(OOP)。OOP中模块化的关键单元是
Spring AOP的使用详解
08-25
Spring AOP的使用详解 Spring AOP是一种面向切面编程（Aspect-Oriented Programming）的技术，用于实现程序功能的统一维护。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容。 AOP的主要...
Spring框架系列(9) - Spring AOP实现原理详解之AOP切面的实现.doc
07-08
Spring AOP 实现原理详解之 AOP 切面的实现 Spring AOP 是基于 IOC 的 Bean 加载来实现的，本文主要介绍 Spring AOP 原理解析的切面实现过程。AOP 切面的实现是将切面类的所有切面方法根据使用的注解生成对应 ...
spring aop的简单使用方法详解
08-25
主要介绍了spring aop的简单使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringAOP中的注解配置详解
08-25
本文将详细介绍SpringAOP中的注解配置详解，包括使用注解实现SpringAOP的功能、XML配置等方面的内容。 一、使用注解实现SpringAOP的功能 在SpringAOP中，注解是实现AOP功能的主要方式之一。通过使用注解，开发者...
Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc
07-08
Cglib代理是Spring AOP在无法使用JDK动态代理（例如代理的目标对象没有实现接口）时的另一种选择。Cglib是一个强大的、高性能的代码生成库，它基于ASM库来动态生成子类，从而实现对方法的拦截。当目标类是不可变的...
spring AOP的使用方法
Crime11的博客
03-23 1561
Spring AOP是一个基于Java的AOP框架，它是Spring框架的一部分。Spring AOP支持的通知类型包括前置通知、后置通知、环绕通知、引发异常通知和最终通知。可以使用Spring AOP来定义切面、切入点和通知，并配置Spring AOP，在执行前和执行后输出一些消息。在上面的例子中，我们定义了一个LoggingAspect类，它包含了两个通知方法：logBefore()和logAfter()。现在我们已经定义了一个切面类，并且配置了Spring AOP，我们可以测试它是否工作。
使用Spring实现Aop三种方法
vengu733的博客
08-05 3177
** 方式一 ：使用spring的AP接口 方式二 ： 自定义来实现AOP (主要是切面定义) 方式三 ：使用注解实现AOP **使用AOP 植入 ，需要导入依赖包aspectj 方式一 ：使用spring的AP接口 定义uservice接口 接口实现类userviceImpl 创建要做代理 为uservice 添加日志 的log类 创建afterlog 类 ben.xml 创建测试： div 自定义一个类 bean.xml 测试结果： 分析： 创建annotation类 bean.xml 测试
AOP使用方式
weixin_44250483的博客
11-13 628
AOP AOP（Aspect Oriented Programming），面向切面编程。 原本的面向对象编程（OOP）是将一类实体的共有行为抽象成一个公共的类，共有行为既包含核心功能，又包含一些公共行为（比如，日志、权限、缓存、同步、事务等）。这些公共行为重复出现在每个类中，造成了大量的冗余，也不利用各个模块的重用。 面向切面编程（AOP）将这些公共行为抽取出来，每一种公共行为（横切关注点）可以配置成一个“通知（advice）”，利用动...
AOP的两种使用方法
weixin_45323139的博客
01-09 614
简单使用aop
AOP是什么？如何使用AOP？
热门推荐
weixin_64572002的博客
06-13 3万+
AOP就是面向切面编程，或者叫面向方面编程，或者开玩笑的说叫面向方便面编程在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。用我的话讲，比如一个方法，他只能计
（二）AOP基本使用方法
chai0404的博客
02-19 714
Spring AOP基本使用方式
Aop(二)基本用法
TaiYangb的博客
05-30 599
Aop的基本用法: 1 使用Aop解决日志处理问题: Aop的配置有两种: 注解方式 和 xml方式 注解方式解决日志处理问题: 步骤: 1 jar包坐标的引入: 2 beans.xml 配置 添加命名空间 配置aop代理 编写代码: package com.sun.aop; import org.aspectj.lang.ProceedingJoinPoint; import or...
【Spring框架】Spring的AOP使用
Sampson_S的博客
06-22 4883
Spring的AOP使用 我们在Spring框架中实现AOP功能主要是通过AspectJ实现的，AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。需要注意的是，AspectJ并不是Spring框架的一部分，它只是用于和Spring结合在一起共同完成有关AOP的操作而已。 AOP结合AspectJ的使用主要有两种方式： 基于XML配置的方式实现； 基于注解的方式实现； 基于XML配置的方式实现 1
Spring AOP详解：从入门到实践
1. Spring中的AspectJ注解支持：Spring框架允许开发者使用AspectJ注解来声明和实现切面，简化了AOP的使用。启用注解支持意味着可以在不编写XML配置的情况下实现切面功能。 2. 声明切面：通过`@Aspect`注解来声明一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值