Spring_AOP_简单入门示例

最新推荐文章于 2024-09-15 11:16:00 发布
最新推荐文章于 2024-09-15 11:16:00 发布
阅读量776 收藏
点赞数
分类专栏： Java spring 文章标签： JAVA spring
Java 同时被 2 个专栏收录
81 篇文章 0 订阅
订阅专栏
spring
51 篇文章 0 订阅
订阅专栏

分享一个自己写的最为简单的Spring AOP的应用，其实，本人也是学习Spring不久，只是把一些个人的理解分享下，供参考。可能很多人刚开始不太理解到底啥是AOP，其实它也是相对OOP来说的，类似OOP其实也是一种编程思想吧。本人暂且把Spring 中的AOP理解成一种方法的拦截器（可能有所片面，主要是方便理解）。

个人通俗理解，就好比你去自动取款机取钱，边上装了个摄像头在监视着。你取你的钱，不用管那摄像头干嘛，只是对于摄像头来说，已经把你取钱的这一过程记录了下来。你取钱的这一过程我们可以从OOP角度分析，而对于摄像头来说，就是从AOP角度去分析了。反映到我下面要讲的示例就是系统日志的记录。

 

我要讲的示例大致是这样的，从OOP角度分析，就是说现在有一个User对象，然后你要调用业务逻辑实现去保存（或者其他行为）这个User对象，或者说是做持久化操作，把User对象相关信息写进数据库。那么从AOP角度来看，就是在你进行保存对象这一行为发生的时候进行日志记录。就是说，你在进行业务操作的时候，不需要去关心系统背后到底做了啥，Spring AOP它已经帮你搞定了。


(图一、个人对于OOP与AOP在本人示例中的理解)

 

  上图说表示的东西是个人的理解理解，纵向为主业务逻辑这里表现为对User对象的持久化操作，横向为AOP实现，这里表现为系统日志记录。

 

以下是代码具体实现：（采用Spring2.5，Myeclipse6.5）

Java代码

  1. （一）、从AOP角度分析：   
  2.   
  3. package org.wiki.spring.aspect;   
  4.   
  5. import org.aspectj.lang.JoinPoint;   
  6.   
  7. /**  
  8.  * 定义切面类，将系统中的横切性关注点模块化  
  9.  *   
  10.  * @author Wiki.M  
  11.  *   
  12.  */  
  13. public class Aspect {   
  14.   
  15.     /**  
  16.      * 定义advice，即切面类中方法具体实现， 这里主要是用于记录日志，只做简单处理。  
  17.      *   
  18.      * @param joinPoint,可以取得被拦截方法的一些信息  
  19.      */  
  20.     public void logging(JoinPoint joinPoint) {   
  21.         //得到被拦截方法参数，并打印   
  22.         Object[] args = joinPoint.getArgs();   
  23.         for (int i = 0; i < args.length; i++) {   
  24.             System.out.println("method arg" + i + " -- " + args[i]);   
  25.         }   
  26.            
  27.         //得到被拦截方法签名   
  28.         System.out.println(joinPoint.getSignature().getName());   
  29.            
  30.         //记录系统日志具体实现   
  31.         System.out.println("----logging-----");   
  32.     }   
  33. }   
  34.   
  35. （二）从DAO，数据持久化角度分析：   
  36. package org.wiki.spring.dao;     
  37.   
  38. import org.wiki.spring.domain.User;   
  39.   
  40. /**  
  41.  * 定义IUserDAO接口，目的是为了灵活实现UserDAO不同的操作。  
  42.  * @author Wiki.M  
  43.  *  
  44.  */  
  45. public interface IUserDAO {   
  46.        
  47.     public void addUser(User user);   
  48.        
  49.     public void deleteUser(int id);   
  50.        
  51.     public void updateUser(int id);   
  52. }   
  53.   
  54.   
  55. //==================================================   
  56.   
  57. package org.wiki.spring.dao;     
  58.   
  59. import org.wiki.spring.domain.User;   
  60.   
  61. /**  
  62.  * IUserDAO接口的具体实现，这里只做简单处理  
  63.  * @author Wiki.M  
  64.  *  
  65.  */  
  66. public class UserDAOImpl implements IUserDAO {   
  67.   
  68.     @Override  
  69.     public void addUser(User user) {   
  70.         System.out.println("----addUser----");   
  71.   
  72.     }   
  73.   
  74.     @Override  
  75.     public void deleteUser(int id) {   
  76.         System.out.println("----deleteUser----");   
  77.   
  78.     }   
  79.   
  80.     @Override  
  81.     public void updateUser(int id) {   
  82.         System.out.println("----updateUser----");   
  83.   
  84.     }   
  85. }   
  86.   
  87. （三）域模型分析   
  88. package org.wiki.spring.domain;     
  89.   
  90. /**  
  91.  * 领域模型User  
  92.  * @author Wiki.M  
  93.  *  
  94.  */  
  95. public class User {   
  96.        
  97.     private int id;   
  98.        
  99.     private String name;   
  100.        
  101.     private String password;   
  102.        
  103.     public int getId() {   
  104.         return id;   
  105.     }   
  106.   
  107.     public void setId(int id) {   
  108.         this.id = id;   
  109.     }   
  110.   
  111.     public String getName() {   
  112.         return name;   
  113.     }   
  114.        
  115.     public void setName(String name) {   
  116.         this.name = name;   
  117.     }   
  118.        
  119.     public String getPassword() {   
  120.         return password;   
  121.     }   
  122.        
  123.     public void setPassword(String password) {   
  124.         this.password = password;   
  125.     }   
  126.   
  127. }   
  128.   
  129. （四）、从业务层分析：   
  130. package org.wiki.spring.service;     
  131.   
  132. import org.wiki.spring.domain.User;   
  133.   
  134. /**  
  135.  * 定义User业务逻辑相关的一个接口，  
  136.  * 目的是为了在客户端自由调用接口实现  
  137.  * @author Wiki.M  
  138.  *  
  139.  */  
  140. public interface IUserService {   
  141.        
  142.    public void saveUser(User user);   
  143.       
  144.    public void deleteUser(int id);   
  145.       
  146.    public void updateUser(int id);    
  147. }   
  148.   
  149. //=========================================   
  150.   
  151.  package org.wiki.spring.service;     
  152.   
  153. import org.wiki.spring.dao.IUserDAO;   
  154. import org.wiki.spring.domain.User;   
  155.   
  156. /**  
  157.  * 业务逻辑接口IUserService的具体实现  
  158.  * @author Wiki.M  
  159.  *  
  160.  */  
  161. public class UserServiceImpl implements IUserService {   
  162.   
  163.     private IUserDAO userDAO;   
  164.        
  165.     public void setUserDAO(IUserDAO userDAO) {   
  166.         this.userDAO = userDAO;   
  167.     }   
  168.        
  169.     @Override  
  170.     public void deleteUser(int id) {   
  171.         userDAO.deleteUser(id);   
  172.     }   
  173.   
  174.     @Override  
  175.     public void saveUser(User user) {   
  176.         userDAO.addUser(user);   
  177.   
  178.     }   
  179.   
  180.     @Override  
  181.     public void updateUser(int id) {   
  182.         userDAO.updateUser(id);   
  183.     }   
  184.   
  185. }   
  186.   
  187. （五）从客户端调用分析：   
  188. package org.wiki.spring.client;     
  189.   
  190. import org.springframework.beans.factory.BeanFactory;   
  191. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  192. import org.wiki.spring.domain.User;   
  193. import org.wiki.spring.service.IUserService;   
  194.   
  195. public class Client {   
  196.        
  197.     /**  
  198.      * 客户端调用，用于测试  
  199.      * @param args  
  200.      */  
  201.     public static void main(String[] args){   
  202.            
  203.         BeanFactory factory = new ClassPathXmlApplicationContext("*.xml");   
  204.            
  205.         //得到UserService具体实现，用于操作业务逻辑   
  206.         IUserService userService = (IUserService)factory.getBean("userServiceImpl");   
  207.            
  208.         User user = new User();   
  209.         user.setId(1);   
  210.         user.setName("Wiki");   
  211.         user.setPassword("123");   
  212.            
  213.         //测试1，记录日志   
  214.         userService.saveUser(user);   
  215.            
  216.         //测试2，记录日志   
  217.         userService.deleteUser(1);   
  218.     }   
  219. }  

（一）、从AOP角度分析：

 

package org.wiki.spring.aspect;

 

import org.aspectj.lang.JoinPoint;

 

/**

 * 定义切面类，将系统中的横切性关注点模块化

 *

 * @author Wiki.M

 *

 */

public class Aspect {

 

    /**

 * 定义advice，即切面类中方法具体实现，这里主要是用于记录日志，只做简单处理。

 *

     * @param joinPoint,可以取得被拦截方法的一些信息

     */

public void logging(JoinPoint joinPoint) {

  //得到被拦截方法参数，并打印

  Object[] args = joinPoint.getArgs();

  for (int i = 0; i < args.length; i++) {

   System.out.println("method arg" + i + " -- " +args[i]);

  }

 

  //得到被拦截方法签名

  System.out.println(joinPoint.getSignature().getName());

       

  //记录系统日志具体实现

  System.out.println("----logging-----");

}

}

 

（二）从DAO，数据持久化角度分析：

packageorg.wiki.spring.dao; 

 

importorg.wiki.spring.domain.User;

 

/**

 * 定义IUserDAO接口，目的是为了灵活实现UserDAO不同的操作。

 * @author Wiki.M

 *

 */

public interface IUserDAO {

public void addUser(User user);

public void deleteUser(int id);

public void updateUser(int id);

}

 

 

//==================================================

 

packageorg.wiki.spring.dao; 

 

importorg.wiki.spring.domain.User;

 

/**

 * IUserDAO接口的具体实现，这里只做简单处理

 * @author Wiki.M

 *

 */

public class UserDAOImplimplements IUserDAO {

 

@Override

public void addUser(User user) {

  System.out.println("----addUser----");

 

}

 

@Override

public void deleteUser(int id) {

  System.out.println("----deleteUser----");

 

}

 

@Override

public void updateUser(int id) {

  System.out.println("----updateUser----");

 

}

}

 

（三）域模型分析

packageorg.wiki.spring.domain; 

 

/**

 * 领域模型User

 * @author Wiki.M

 *

 */

public class User {

private int id;

private String name;

private String password;

public int getId() {

  return id;

}

 

public void setId(int id) {

  this.id = id;

}

 

public String getName() {

  return name;

}

public void setName(String name) {

  this.name = name;

}

public String getPassword() {

  return password;

}

public void setPassword(String password) {

  this.password = password;

}

 

}

 

（四）、从业务层分析：

packageorg.wiki.spring.service; 

 

importorg.wiki.spring.domain.User;

 

/**

 * 定义User业务逻辑相关的一个接口，

 * 目的是为了在客户端自由调用接口实现

 * @author Wiki.M

 *

 */

public interface IUserService {

   public void saveUser(User user);

  

   public void deleteUser(int id);

  

   public void updateUser(int id);

}

 

//=========================================

 

 packageorg.wiki.spring.service; 

 

importorg.wiki.spring.dao.IUserDAO;

importorg.wiki.spring.domain.User;

 

/**

 * 业务逻辑接口IUserService的具体实现

 * @author Wiki.M

 *

 */

public class UserServiceImplimplements IUserService {

 

private IUserDAO userDAO;

public void setUserDAO(IUserDAO userDAO) {

  this.userDAO = userDAO;

}

@Override

public void deleteUser(int id) {

  userDAO.deleteUser(id);

}

 

@Override

public void saveUser(User user) {

  userDAO.addUser(user);

 

}

 

@Override

public void updateUser(int id) {

  userDAO.updateUser(id);

}

 

}

 

（五）从客户端调用分析：

packageorg.wiki.spring.client; 

 

importorg.springframework.beans.factory.BeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

importorg.wiki.spring.domain.User;

importorg.wiki.spring.service.IUserService;

 

public class Client {

/**

 * 客户端调用，用于测试

 * @param args

 */

public static void main(String[] args){

 

  BeanFactory factory = newClassPathXmlApplicationContext("*.xml");

 

  //得到UserService具体实现，用于操作业务逻辑

  IUserService userService =(IUserService)factory.getBean("userServiceImpl");

 

  User user = new User();

  user.setId(1);

  user.setName("Wiki");

  user.setPassword("123");

 

  //测试1，记录日志

  userService.saveUser(user);

 

  //测试2，记录日志

  userService.deleteUser(1);

}

}

 

 

 

    Spring配置文件：

Xml代码

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
  8.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd   
  9.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
  10.        
  11.     <!-- 配置UserDAOImpl -->  
  12.     <bean id="userDAO" class="org.wiki.spring.dao.UserDAOImpl"/>   
  13.     <!-- 配置UserServiceImpl -->  
  14.     <bean id="userServiceImpl"  
  15.         class="org.wiki.spring.service.UserServiceImpl">  
  16.         <!-- 注入userDAO，实际为UserDAOImpl，即对数据持久化的具体实现 -->  
  17.         <property name="userDAO" ref="userDAO" />  
  18.     </bean>  
  19.        
  20.     <!-- 配置aspect切面类 -->  
  21.     <bean id="userAspect" class="org.wiki.spring.aspect.Aspect" />  
  22.   
  23.     <!-- 配置AOP -->  
  24.     <aop:config>  
  25.         <!-- 配置aspect切面类 -->  
  26.         <aop:aspect ref="userAspect">  
  27.             <!-- 配置pointcut,即切入点，对哪些类的哪些方法起到AOP的作用 -->  
  28.             <aop:pointcut id="userServiceMethods"  
  29.                 expression="execution(* org.wiki.spring.service.UserServiceImpl.*(..))" />      
  30.             <!-- 配置advice,即Aspect类中的logging()方法，这里采用在业务方法执行前进行拦截 -->  
  31.             <aop:before method="logging" pointcut-ref="userServiceMethods" />  
  32.         </aop:aspect>  
  33.            
  34.     </aop:config>  
  35. </beans>  

<?xmlversion="1.0" encoding="UTF-8"?>

 

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd

          http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.0.xsd

          http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

   

    <!-- 配置UserDAOImpl -->

<bean id="userDAO"class="org.wiki.spring.dao.UserDAOImpl"/>

   

    <!-- 配置UserServiceImpl -->

<bean id="userServiceImpl"

  class="org.wiki.spring.service.UserServiceImpl">

  <!-- 注入userDAO，实际为UserDAOImpl，即对数据持久化的具体实现 -->

  <property name="userDAO" ref="userDAO" />

</bean>

    <!-- 配置aspect切面类 -->

<bean id="userAspect"class="org.wiki.spring.aspect.Aspect" />

 

    <!-- 配置AOP -->

<aop:config>

    <!-- 配置aspect切面类 -->

  <aop:aspect ref="userAspect">

      <!-- 配置pointcut,即切入点，对哪些类的哪些方法起到AOP的作用 -->

   <aop:pointcut id="userServiceMethods"

    expression="execution(*org.wiki.spring.service.UserServiceImpl.*(..))" />

   <!-- 配置advice,即Aspect类中的logging()方法，这里采用在业务方法执行前进行拦截 -->

   <aop:before method="logging"pointcut-ref="userServiceMethods" />

  </aop:aspect>

 

</aop:config>

</beans>

 

可能用到的Jar包： commons-logging.jar,  log4j.jar,spring.jar, aspectjrt.jar, aspectjweaver.jar

 

Ethan_Fu
关注
专栏目录
Spring AOP 快速入门使用
jason559的博客
01-23 214
目录一、Spring 中 AOP 的配置方式二、XML 配置模式1、导入依赖2、aop 核心配置3、核心配置细节1）关于切入点表达式2）改变代理方式的配置3）五种通知类型4）特别说明三、XML + 注解模式1、XML 中开启 Spring 对注解 AOP 的支持2、示例四、注解模式1、注解 一、Spring 中 AOP 的配置方式 在 Spring 的 AOP 配置中，也和 IoC 配置一样，支持3类配置方式。 第一类：使用 XML 配置； 第二类：使用 XML + 注解组合配置； 第三类：使用纯注解配置。
Spring_02_入门篇_AOP_简单实例
04-18
**Spring AOP 入门篇：面向切面编程的注解与XML模式** 在软件开发中，Spring框架因其强大的功能和灵活性而广受欢迎，尤其是在企业级应用开发中。本教程将深入探讨Spring中的核心概念之一——面向切面编程（Aspect-...
SpringAop简单入门示例
hqc_xds的博客
11-29 377
项目结构图： <?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...
Spring_AOP 入门案列
markya的博客
04-04 85
文件目录 1.IAccountService package com.suse.service; /** * 账户的业务接口 */ public interface IAccountService { void saveAccount(); void updateAccount(int i); int deleteAccount(); } 2.AccountServiceImpl package com.suse.service.impl; import com.su
SpringAOP的简单介绍及入门案例
qq_53118426的博客
07-18 1101
AOP( 面向切面编程 )是一种思想，它的目的就是在不修改源代码的基础上，对原有功能进行增强。SpringAOP是对AOP思想的一种实现，Spring底层同时支持jdk和cglib动态代理。如果有接口，就采用jdk动态代理如果没接口，就采用cglib的方式AOP中有一些核心概念:目标对象（Target）被代理的对象连接点（JoinPoint）目标对象中得所有方法切入点（PointCut）目标对象中得要进行功能增强那部分方法增强 (Advice 通知)
Spring AOP 快速入门
Node_Hao的博客
06-12 1189
添加 AOP 支持框架定义切面和切点定义通知Spring AOP 是通过动态代理的方式 , 在运行期间将 AOP 代码织入到程序中的 , 实现方式有两种 , JDK Porxy 和 CGLIB.
Spring AOP 入门、实现原理及实践案例
一名Java语言狂热分子。
05-26 1646
Spring 是目前 Java 领域最为流行的开发框架之一，它提供了很多方便快捷的功能，其中之一就是 AOP（Aspect Oriented Programming），即面向切面编程。本文将详细介绍 Spring AOP 的实现原理、核心概念以及在实际应用中的使用案例。
SpringAOP详解+快速入门
zhaolk的博客
06-04 3404
本文介绍了 Spring AOP 的实现原理，并通过实例解析详细阐述了其实现过程。在使用 Spring AOP时，我们需要定义切面类，并为需要实现AOP的方法添加注解。 Spring 会自动将切面逻辑插入到这些方法中，从而实现AOP的功能。
Spring AOP 代码加案例详解
持续学习，持续更新
04-27 2703
学习AOP就要先学习代理模式，这样AOP的学习就简单了。代理模式是Java常见的设计模式之一，包含：静态代理和动态代理。通过案例感受静态代理：租房子问题。房东需要将房子出租，如果都亲力亲为太麻烦了：房东要自己出去贴广告，带租客看房，讨价还价，签合同，收租金，定期检查房子，定期保洁。这时候就需要中介代理了，房东就是要租房拿钱，额外的功能：签合同，讨价还价，定期检查房子 ，定期保洁都由中介代理去做，所以 代理 简化了 业主的功能,同时对房东的功能做了一个扩展。找中介的好处：（1）保护真实对象 （房东） （2
aop注解配置切点 spring_使用注解匹配Spring Aop切点表达式
weixin_39839162的博客
12-21 638
Spring中的类基本都会标注解，所以使用注解匹配切点可以满足绝大部分需求主要使用@within()/@target @annotaton() @args()等...匹配@Service类中的所有方法：@within(org.springframework.stereotype.Service)或@target(org.springframework.stereotype.Service)匹配标注...
spring_aop1.rar_java aop_spring mvc 例子
09-14
本实例“spring_aop1.rar”是一个关于Spring AOP入门的教程，旨在帮助开发者更好地理解和运用Spring的AOP特性，同时也涉及到Spring MVC的相关知识。下面我们将深入探讨这两个关键概念。 首先，让我们了解一下Spring...
SpringAOP简单入门示例..pdf
09-06
Spring AOP 简单入门示例 AOP（Aspect-Oriented Programming），即面向方面编程，是一种编程范式。AOP 是 OOP 的补充，它将系统中的横切性关注点模块化，并将其与业务逻辑分离。 在 Spring 中，AOP 是通过使用 ...
spring_mvc.zip_spring_spring mvc_springmvc_springmvc架构
09-20
这个“spring_mvc.zip”压缩包很可能是为了帮助初学者快速入门Spring MVC而准备的资源。 在Spring MVC中，核心概念包括DispatcherServlet、Controller、Model、View以及ViewResolver。DispatcherServlet作为前端...
第五章示例代码__AOP入门
03-21
在本章节中，我们将深入探讨AOP（面向切面编程）这一重要的编程概念，并通过具体的示例代码来帮助初学者入门。AOP是现代软件开发中的一个重要技术，它旨在提高代码的可重用性和模块化，减少代码冗余，使得程序更加...
Spring Framework 学习总结博客
2302_80084329的博客
09-13 1128
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1432
本文写了基于spring mvc创建的博客系统；
SpringBoot结合Mybatis-plus项目直接执行sql语句
最新发布
qq_50801874的博客
09-15 268
在平常的SpringBoot项目中，只有极少的情况需要直接执行sql语句，不需要传参。这里通过Mybatis-plus实习效果。impl层将sql语句作为参数直接调用dao层接口，这里需要注意，在dao层新增一个接口，通过@Select注解执行sql语句。，不然会报错，所以在调用之前最好判断一下sql语句是否为空。
构建基于SpringBoot的在线学习平台
2402_85762143的博客
09-14 893
首页、课程信息、个人中心、后台管理、购物车等功能，这给管理者的工作带来了巨大的挑战，面对大量的信息，传统的管理系统，都是通过笔记的方式进行详细信息的统计，后来出现电脑，通过电脑输入软件将纸质的信息统计到电脑上，这种方式比较传统，而且想要统计数据信息比较麻烦，还受时间和空间的影响，所以为此开发了在线视频教育平台；可以在多种平台上运用的，兼容性比较强，适应市面上大多数操作系统，不会出现乱码的现像，其扩展性和维护性都更好，具有分析问题和解决问题的能力，是面向过程的程序设计方便我们编写的代码更强壮。
Spring框架AOP编程基础：入门与通知、切入点解析
"Spring框架中的AOP编程之入门篇" 在Spring Framework中，面向方面编程（AOP）是一种强大的工具，用于解耦关注点，特别是那些横切关注点，如日志、事务管理或安全性。AOP的核心概念在于，它允许程序员定义所谓的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值