spring的面向切面编程AOP最强解释

最新推荐文章于 2023-08-17 20:34:03 发布
最新推荐文章于 2023-08-17 20:34:03 发布
阅读量481 收藏 5
点赞数
分类专栏： ssm spring 文章标签： AOP spring 面向切面编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36250202/article/details/103488544
版权

 

 

 

面向切面编程 AOP

也就是面向横切面编程, 在软件原有流程中横向织入扩展功能代码, 在不改变原有功能的情况下扩展横切功能.

生活中的横切面功能:

面向切面编程解决的横切问题:

面向切面编程中的关键概念:

  1. 切面组件
  2. 通知
  3. 切入点
  4. 运行期间织入

1. 切面组件

切面组件本身也是一个被Spring管理的Bean组件, 这个组件用于封装面向切面的功能扩展方法.

在软件中执行切向功能的组件. 是一种"拦截器"组件.

案例:

@Component
@Aspect
public class DemoAspect {

    //通知(切入点) 通知+切入点=织入位置
    @Before(
    "execution(* cn.tedu.note.service.*Service.*(..))")
    public void hello(){
        System.out.println("Hello World!");
    }
}

使用如上功能必须导入 AspectJ 相关的包, Spring提供的AOP功能是利用 AspectJ 的API实现的.

    <dependency>
        <groupId>aspectj</groupId>
        <artifactId>aspectjlib</artifactId>
        <version>1.5.3</version>
    </dependency>
    <dependency>
        <groupId>aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.5.3</version>
    </dependency>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

2. 通知

用于指定发生切向事件的位置点:

通知有如下几种:

  • @Before 
  • @AfterRetuning
  • @AfterThrowing
  • @After
  • @Around

其在方法的切位置关系如下: 

try{
    // @Before 
    切入点 方法
    // @AfterRetuning
}catch(e){
    // @AfterThrowing
}finally{
    // @After
}

@Around 通知, 是在方法前后调用的通知:

@Around("bean(userService)")
public Object testAround(
        ProceedingJoinPoint target)
    throws Throwable{
    System.out.println("调用开始");
    //执行目标方法
    Object obj=target.proceed();
    System.out.println("调用结束");
    return obj;
}

3. 切入点

切入点是指明 通知发送的位置.

仅仅指定通知是不能精确定位 切面 的织入位置, 还要在通知中指定切入点. 

有3种：

3.1：Bean组件切入 (按照Bean对象进行切入)

bean(beanId) 
如: bean(userService)  
    bean(noteService)
    bean(*Service)

多个Bean
    bean(userService) || bean(noteService)

3.2：类限定名: 包和类进行切入

within(包名.类名)
如:
within(cn.tedu.note.service.UserService)
within(cn.tedu.note.service.*)
within(cn.tedu.note.service.*Service)
within(cn.tedu.note..*Service)

3.3方法限定名: 切入到特定方法

execution(* 包.类.方法(参数))
如:
execution(* cn.tedu.note.service.UserService.login(..))
execution(* cn.tedu.note.service.UserService.find*(..))
execution(* cn.tedu.note.service.*Service.find*(..))
execution(* cn.tedu.note.service.*.find*(..))
execution(* cn.tedu.note..*.find*(..))
execution(* cn.tedu.note.service.*.*(..))

织入位置

通过通知和切入点的组合,才能明确指定切面代码的位置, 也就是: 

通知+切入点=织入位置

AOP 的配置

AOP注解必须与Spring配合才能起到作用, Spring的配置如下:

 <context:component-scan 
    base-package="cn.tedu.aop"/>
 <!-- 注解驱动 aspectj AOP,
    使 @Aspect 和 @Before 等注解起作用  -->
 <aop:aspectj-autoproxy />

案例:

@Component
@Aspect
public class DemoAspect {

    //通知(切入点) 通知+切入点=织入位置
    @Before("execution(* cn.tedu.note.service.*Service.*(..))")
    public void hello(){
        System.out.println("Hello World!");
    }

    @Around("bean(userService)")
    public Object testAround( ProceedingJoinPoint target)
        throws Throwable{
        System.out.println("调用开始");
        //执行目标方法
        Object obj=target.proceed();
        System.out.println("调用结束");
        return obj;
    }
}

测试结果说明: 如上代码在执行时候, 会在所有的业务层方法中织入 hello() 方法, 也就是在所有业务方法之前执行 hello(). 

 

AOP 是如何做到的：

  1. 采用动态代理模式实现.
  2. 动态代理是利用反射技术实现的.

代理模式:

 

案例:

@Component("userServiceProxy")
public class UserServiceProxy 
    implements UserService{

    @Autowired
    DemoAspect demoAspect;

    @Autowired 
    UserService target;

    public User login(String name, String password) throws NameOrPasswordException {
        //调用切面组件的方法?
        demoAspect.hello();
        System.out.println("Hello Proxy");
        return target.login(name, password);
    }
    public User regist(String name, String nick, String password, String confirm) {
        System.out.println("Hello Proxy");
        return target.regist(name, nick, password, confirm);
    }
}

如上类就是一个静态代理类, 代理的业务层UserService的方法.

 

动态代理技术

  1. JDK 的反射API提供了动态代理 
    • JDK的动态代理必须依赖于接口
  2. CBLIB API 提供了基于类的动态代理
  3. Spring会自动的使用如上API, 在有接口时候 优先选JDK代理, 如果没有接口,会自动利用CGLIB代理.

        Spring的AOP底层就是利用动态代理技术实现的.

        提示: 可以查看异常出现时候的方法调用栈, 来了解Spring内部的调用关系:

如:

java.lang.NullPointerException
    at cn.tedu.note.service.NoteServiceImpl.createNote(NoteServiceImpl.java:76)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:317)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:183)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
    at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:51)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:96)
    at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:260)
    at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:94)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:91)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:204)
    at com.sun.proxy.$Proxy24.createNote(Unknown Source)
    at cn.tedu.note.web.NoteController.addNote(NoteController.java:58)
    at cn.tedu.note.web.NoteController$$FastClassBySpringCGLIB$$fb9c5e1b.invoke(<generated>)
    at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
    at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:700)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
    at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:80)
    at cn.tedu.aop.ExceptionAspect.process(ExceptionAspect.java:21)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:621)
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:610)
    at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:65)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:91)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:633)
    at cn.tedu.note.web.NoteController$$EnhancerBySpringCGLIB$$d281c6f4.addNote(<generated>)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:215)
    at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:132)
    at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104)
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:745)
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:686)
    at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
    at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:925)
    at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:856)
    at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:953)
    at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:855)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
    at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:829)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    at cn.tedu.note.util.AccessFilter.checkdo(AccessFilter.java:66)
    at cn.tedu.note.util.AccessFilter.doFilter(AccessFilter.java:45)
    at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:220)
    at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:122)
    at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:505)
    at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:169)
    at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103)
    at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:956)
    at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116)
    at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:423)
    at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1079)
    at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:625)
    at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:318)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
    at java.lang.Thread.run(Thread.java:745)

Spring事务处理

关键特性: ACID

  • A 原子性
  • C 一致性
  • I 隔离性
  • D 持久性

Oracle 支持ACID

MySQL 有两种数据库引擎: 

  • MyISAM 引擎 不支持 ACID, 适合数据一致性要求不高,性能好就行
  • INNODB 引擎 支持ACID, 适合数据一致性高的场合.

编程式事务控制:

经典代码

try{
    开启事务
    业务处理.
    业务处理.
    提交事务
}catch(e){
    回滚事务
}finally{
    回收资源
}

很明显, 编程式事务处理, 非常适合替换为AOP事务处理:

Spring 事务处理, 是AOP的经典用途. Spring的事务处理底层就是AOP.

使用Spring 事务

使用Spring 事务 并不需要AOP编程, 只需要使用注解即可

配置:

<!-- 添加 注解事务支持 -->
<bean id="txManager" 
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" 
        ref="dataSource" />
</bean>
<tx:annotation-driven
    transaction-manager="txManager"/>

使用:

@Transactional(readOnly=true,
        isolation=Isolation.READ_COMMITTED,
        propagation=Propagation.REQUIRED)
public Note loadNote(String noteId) {
    if(noteId==null || noteId.trim().isEmpty()){
        throw new IllegalArgumentException("noteId不能空");
    }
    return noteDao.findNoteById(noteId);
}

 

 

 

 

任错错
关注
专栏目录
spring框架学习 - 使用 Spring 的面向切面编程 补充1
TyuIn的博客
12-20 408
接上一篇博客：https://blog.csdn.net/qq_43605444/article/details/122050740?spm=1001.2014.3001.5502 6、选择要使用的 AOP 声明样式 一旦您确定一个方面是实现给定需求的最佳方法，您如何在使用 Spring AOP 或 AspectJ 以及在 Aspect 语言（代码）样式、@AspectJ 注解样式或 Spring XML 样式之间做出决定？ 这些决策受到许多因素的影响，包括应用程序需求、开发工具和团队对 AOP 的熟悉程度
使用Spring进行面向切面编程
02-09 1万+
Chapter 6. 使用Spring进行面向切面编程（AOP） 6.1. 简介 面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutti
Spring AOP——Spring 中面向切面编程
杜海的博客
09-14 216
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有某段
Spring的面向切面
weixin_33755847的博客
10-22 109
Spring的面向切面 　　在应用开发中，有很多类似日志、安全和事务管理的功能。这些功能都有一个共同点，那就是很多个对象都需要这些功能。复用这些通用的功能的最简单的方法就是继承或者委托。但是当应用规模达到一定程度时，使用继承或委托将会使应用的结构非常复杂。 　　面向切面便是解决上面问题的最佳办法。我们把这些通用的功能（横切关注点）放在专门的类中（这种类又叫切面），然后在程序运行后通过动态代理，...
【Spring】AOP - 面向切面
王晓斌的专栏
05-26 1万+
AOP
Spring之面向切面（AOP）
最新发布
weixin_74352229的博客
08-17 1816
切点（Pointcut）：切点指定了在应用程序中哪些连接点应该被拦截和处理。连接点可以是方法的执行、方法的调用、对象的创建与初始化等。切点可以使用表达式或模式进行定义，以匹配特定的连接点。通知（Advice）：通知指定了在切点上要执行的逻辑。通知可以是在切点之前、之后或周围执行。在Spring中，常见的通知类型有前置通知、后置通知、返回通知和异常通知。切面（Aspect）：切面是通知和切点的组合。它是代码模块化的单元，它封装了特定关注点的逻辑和行为。切面定义了在哪些切点上应该执行特定的通知。
SpringBoot-AOP面向切面编程-实战
ZhAoYaJ的博客
01-05 2299
SpringBoot集成AOP之列文虎克
AOP编程大揭秘：Spring与面向切面编程的实战指南
[AOP编程大揭秘：Spring与面向切面编程的实战指南](https://foxminded.ua/wp-content/uploads/2023/05/image-36.png) # 1. AOP编程概念解析 ## 1.1 AOP的基本概念 面向切面编程（Aspect-Oriented Programming，AOP...
springAOP实现数据字典.zip
03-04
在IT行业中，Spring AOP（面向切面编程）是一种强大的工具，它允许开发者在不修改原有业务代码的情况下，对程序进行功能增强或监控。在这个"springAOP实现数据字典.zip"压缩包中，我们主要关注的是如何利用Spring ...
Spring 面向切面 代理
西柚的博客
09-18 570
Aop(Aspect Oriented Programming), 即面向切面编程，可以说是OOP的补充和完善，与OOP有些区别， AOP技术恰恰相反，它利用一种称为"横面"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用的模板，并将其命名为"Aspect"，即切面，所谓"切面",简单说就是那些与业务无关，却为业务模板所公共调用的逻辑或责任封装起来，便于减少系统的重复...
AOP_使用spring框架进行面向切面编程
03-26
NULL 博文链接：https://countme.iteye.com/blog/1132555
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3771
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring之面向切面编程（AOP）
旭日的芬芳
10-29 7334
1. 面向切面编程 以下内容来自百度百科： 定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。 总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生
Spring实战——面向切面的Spring
Zerohuan的专栏
09-27 3562
面向切面是Spring又一大核心，本章我们就来详细了解下：面向切面编程的基本原理以及创建使用切面的常用方法，如何为POJO创建切面，使用@AspectJ注释，为AspectJ切面注入依赖。 为什么要AOP： 日志、安全和事物管理是软件中很重要的组成部分，但是如果每个应用对象都需要自己处理这些问题，不仅开发者会十分厌烦，而且也不利于维护、复用以及扩展。这些分布于应用多处的功能
Spring面向切面编程
张晨光老师的播客
09-23 3221
第1章主要介绍了Spring管理实体对象的应用，通过ApplicationContext容器来了解Spring管理实体对象的原理以及设值注入、构造方法及自动注入等不同的注入方式。本章先介绍为什么需要AOP以及使用AOP的好处，然后采用手动代理的方式介绍什么是代理及代理的必要性，最后结合商场手机进货和收获的案例分别介绍前置通知、后置通知、环绕通知和异常通知。在介绍前置通知的时候，分别采用Spring
Spring基础篇：面向切面编程
七叔的博客
12-03 1万+
Spring基础篇：面向切面编程
2021-08-08 SpringAop解析
joker的博客
08-08 115
@TOCS 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
Spring核心AOP（面向切面编程）总结
热门推荐
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
Spring 面向切面配置声明
yunzhonghefei的博客
02-27 257
1.首先声明bean"minstrel" 2.在切面配置中引用bean 3.声明切入点，使用表达式进行声明 4.声明方法执行前后各需要执行的逻辑，如果需要更细化，则调整代码中的逻辑即可...
Spring AOP：面向切面编程详解与实战
本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中管理和维护，从而提高代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

任错错

如果对您有帮助我很开心

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

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

打赏作者

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

抵扣说明：

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

余额充值