Spring AOP 中 advice 的四种类型 before after throwing advice around

最新推荐文章于 2023-06-04 20:41:24 发布
最新推荐文章于 2023-06-04 20:41:24 发布
阅读量3.3w 收藏 21
点赞数 13
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/topwqp/article/details/8695180
版权

Spring  AOP(Aspect-oriented programming) 是用于切面编程，简单的来说：AOP相当于一个拦截器，去拦截一些处理，例如：当一个方法执行的时候，Spring 能够拦截正在执行的方法，在方法执行的前或者后增加额外的功能和处理。


在Spring AOP中支持4中类型的通知：

1：before advice 在方法执行前执行。

2：after  returning  advice 在方法执行后返回一个结果后执行。

3：after  throwing advice 在方法执行过程中抛出异常的时候执行。

4：Around  advice 在方法执行前后和抛出异常时执行，相当于综合了以上三种通知。


下面是一个简单的AOP  advice 的例子：

 首先给出一个简单的Spring 注入的例子，

定义一个Book类：

package com.myapp.core.aop.advice;

public class Book {
   private  String  name;
   private  String  url;
   private   int    pages;
   
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public int getPages() {
		return pages;
	}
	public void setPages(int pages) {
		this.pages = pages;
	}


	public  void  printName(){
		System.out.println("Book name "+ this.name);
	}
	
	public  void  printUrl(){
		System.out.println("Book URL "+this.url);
	}
	
	public  void  printThrowException(){
		throw  new  IllegalArgumentException();
	}
   
}

相应的配置文件： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- more bean definitions for data access objects go here -->
   
    <bean id="book" class="com.myapp.core.aop.advice.Book">
	    <property name="name" value="Effective java" />
	    <property name="url" value="www.google.cn"/>
	    <property name="pages" value="300" />
    </bean>
</beans>
对应的测试类： 

package com.myapp.core.aop.advice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
   public static void main(String[] args) {
	  
	   ApplicationContext  context  = new  ClassPathXmlApplicationContext("resource/aop.xml");
	   
	   Book   book  =   (Book) context.getBean("book");
	   
	   System.out.println("---------------------");
       
	   book.printName();
	   
	   System.out.println("---------------------");
	   
	   book.printUrl();
	   
	   System.out.println("----------------------");
	   
	   try{
		   
		  book.printThrowException();
		   
	   }catch(Exception e){
		 //  e.printStackTrace();
	   }
	   
	   
}
}

输出结果： 

三月 20, 2013 11:01:01 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@11e831: startup date [Wed Mar 20 11:01:01 CST 2013]; root of context hierarchy
三月 20, 2013 11:01:01 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [resource/aop.xml]
三月 20, 2013 11:01:01 上午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@13b5500: defining beans [book]; root of factory hierarchy
---------------------
Book name Effective java
---------------------
Book URL www.google.cn
----------------------

下面对以上的Book加上Spring   AOP   advices

1：before  advice

before advice将在方法执行前执行，创建一个实现MethodBeforeAdvice接口的类能够定义执行方法前的操作。
类如下： 
package com.myapp.core.aop.advice;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class BeforeMethod  implements MethodBeforeAdvice {

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {
		// TODO Auto-generated method stub
		
		System.out.println("Before  Method");
		System.out.println("--------------------");
		
	}
 
}
配置对应的bean：
在aop.xml中配置，创建一个BeforeMethod类，一个新的代理命名为：bookProxy
1： target 设置你想拦截的bean
2：interceptorNames设置通知，你想作用于proxy/target上的
对应的配置文件如下： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- more bean definitions for data access objects go here -->
   
    <bean id="book" class="com.myapp.core.aop.advice.Book">
	    <property name="name" value="Effective java" />
	    <property name="url" value="www.google.cn"/>
	    <property name="pages" value="300" />
    </bean>
    
    <bean id="beforeMethodBean" class="com.myapp.core.aop.advice.BeforeMethod" />
    
    <bean id="bookProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
     
     <property name="target" ref="book"/>
     
     <property name="interceptorNames">
       <list>
        <value>beforeMethodBean</value>
       </list>
     </property>
    
     </bean>
</beans>

注意：为了使用proxy（代理）我们需要引入 CGLIB2， pom.xml文件中注入如下： 
	<dependency>
		<groupId>cglib</groupId>
		<artifactId>cglib</artifactId>
		<version>2.2.2</version>
	</dependency>

运行测试类： 
package com.myapp.core.aop.advice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {
   public static void main(String[] args) {
	  
	   ApplicationContext  context  = new  ClassPathXmlApplicationContext("resource/aop.xml");
	   
	   Book   book  =   (Book) context.getBean("bookProxy");
	   
	   System.out.println("---------------------");
       
	   book.printName();
	   
	   System.out.println("---------------------");
	   
	   book.printUrl();
	   
	   System.out.println("----------------------");
	   
	   try{
		   
		  book.printThrowException();
		   
	   }catch(Exception e){
		 //  e.printStackTrace();
	   }
	   
	   
}
}

注意以上获得的是代理bean；
运行结果如下： 
三月 20, 2013 2:18:56 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@eb67e8: startup date [Wed Mar 20 14:18:55 CST 2013]; root of context hierarchy
三月 20, 2013 2:18:56 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [resource/aop.xml]
三月 20, 2013 2:18:57 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@157985: defining beans [book,beforeMethodBean,bookProxy]; root of factory hierarchy
---------------------
Before  Method
--------------------
Book name Effective java
---------------------
Before  Method
--------------------
Book URL www.google.cn
----------------------
Before  Method
--------------------

2： after  advice

在方法运行返回结果后将执行这个 afterReturning方法，创建的这个类必须实现：AfterReturningAdvice接口 
package com.myapp.core.aop.advice;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class AfterMethod  implements  AfterReturningAdvice {

	@Override
	public void afterReturning(Object arg0, Method arg1, Object[] arg2,
			Object arg3) throws Throwable {
		// TODO Auto-generated method stub
		
		System.out.println("-------------------");
		
		System.out.println("After  method ");
		
		
		
	}

}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- more bean definitions for data access objects go here -->
   
    <bean id="book" class="com.myapp.core.aop.advice.Book">
	    <property name="name" value="Effective java" />
	    <property name="url" value="www.google.cn"/>
	    <property name="pages" value="300" />
    </bean>
    
    <bean id="beforeMethodBean" class="com.myapp.core.aop.advice.BeforeMethod" />
    
      <bean id="afterMethodBean" class="com.myapp.core.aop.advice.AfterMethod" />
    
    <bean id="bookProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
     
     <property name="target" ref="book"/>
     
     <property name="interceptorNames">
       <list>
        <value>beforeMethodBean</value>
        <value>afterMethodBean</value>
       </list>
     </property>
    
     </bean>
</beans>

运行结果如下： 
三月 20, 2013 2:22:19 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@eb67e8: startup date [Wed Mar 20 14:22:19 CST 2013]; root of context hierarchy
三月 20, 2013 2:22:19 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [resource/aop.xml]
三月 20, 2013 2:22:20 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@157985: defining beans [book,beforeMethodBean,afterMethodBean,bookProxy]; root of factory hierarchy
---------------------
Before  Method
--------------------
Book name Effective java
-------------------
After  method 
---------------------
Before  Method
--------------------
Book URL www.google.cn
-------------------
After  method 
----------------------
Before  Method
--------------------

3：after  throwing  advice 

当方法执行抛出一个异常后，会执行这个方法，创建一个类实现：ThrowsAdvice接口，创建一个afterThrowing拦截：IllegalArgumentException异常。
类如下： 
package com.myapp.core.aop.advice;

import org.springframework.aop.ThrowsAdvice;

public class ThrowException  implements ThrowsAdvice{
   
	public  void  afterThrowing(IllegalArgumentException e)  throws  Throwable{
		System.out.println("after Throwing  Exception");
	}
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- more bean definitions for data access objects go here -->
   
    <bean id="book" class="com.myapp.core.aop.advice.Book">
	    <property name="name" value="Effective java" />
	    <property name="url" value="www.google.cn"/>
	    <property name="pages" value="300" />
    </bean>
    
    <!-- before  advice -->
    <bean id="beforeMethodBean" class="com.myapp.core.aop.advice.BeforeMethod" />
    
    <!-- after  advice -->
      <bean id="afterMethodBean" class="com.myapp.core.aop.advice.AfterMethod" />
      
      <!-- throwing  advice -->
      
      <bean id="throwException" class="com.myapp.core.aop.advice.ThrowException" />
    
    <bean id="bookProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
     
     <property name="target" ref="book"/>
     
     <property name="interceptorNames">
       <list>
        <value>beforeMethodBean</value>
        <value>afterMethodBean</value>
        <value>throwException</value>
       </list>
     </property>
    
     </bean>
</beans>
执行结果如下： 
三月 20, 2013 2:37:36 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@eb67e8: startup date [Wed Mar 20 14:37:36 CST 2013]; root of context hierarchy
三月 20, 2013 2:37:36 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [resource/aop.xml]
三月 20, 2013 2:37:36 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@157985: defining beans [book,beforeMethodBean,afterMethodBean,throwException,bookProxy]; root of factory hierarchy
---------------------
Before  Method
--------------------
Book name Effective java
-------------------
After  method 
---------------------
Before  Method
--------------------
Book URL www.google.cn
-------------------
After  method 
----------------------
Before  Method
--------------------
after Throwing  Exception

4：Around  advice

这个advice 联合了上面的三个advices，在方法执行期间执行，创建一个类实现MethodInterceptor接口，需要在方法中执行Object result = methodInvocation.proceed();方法才能得到执行，否则方法不会执行。
类如下： 
package com.myapp.core.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AroundMethod  implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation methodInvocation) throws Throwable {
		// TODO Auto-generated method stub
		
		System.out.println("method  name:" + methodInvocation.getMethod().getName());
		
		System.out.println("method  arguments" + Arrays.toString(methodInvocation.getArguments()));
		
		System.out.println("Around  method : before ");
		
		try{
			
			Object result = methodInvocation.proceed();
			
			System.out.println("Around method : after ");
			return  result;
			
		}catch(IllegalArgumentException e){
			
			System.out.println("Around method : throw  an  exception ");
			throw  e;
		}
	}

}

配置文件如下： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- more bean definitions for data access objects go here -->
   
    <bean id="book" class="com.myapp.core.aop.advice.Book">
	    <property name="name" value="Effective java" />
	    <property name="url" value="www.google.cn"/>
	    <property name="pages" value="300" />
    </bean>
  
    <bean id="aroundMethod"  class="com.myapp.core.aop.advice.AroundMethod" />
    
    <bean id="bookProxy" class="org.springframework.aop.framework.ProxyFactoryBean" >
     <property name="target" ref="book"/>
     
     <property name="interceptorNames">
       <list>
    
         <value>aroundMethod</value>
       </list>
     </property>
    
     </bean>
</beans>

测试结果： 
三月 20, 2013 3:02:19 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@eb67e8: startup date [Wed Mar 20 15:02:19 CST 2013]; root of context hierarchy
三月 20, 2013 3:02:19 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [resource/aop.xml]
三月 20, 2013 3:02:19 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@e29127: defining beans [book,aroundMethod,bookProxy]; root of factory hierarchy
---------------------
method  name:printName
method  arguments[]
Around  method : before 
Book name Effective java
Around method : after 
---------------------
method  name:printUrl
method  arguments[]
Around  method : before 
Book URL www.google.cn
Around method : after 
----------------------
method  name:printThrowException
method  arguments[]
Around  method : before 
Around method : throw  an  exception

around  advice得到实现。 over




bird_cat
关注
  • 13
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
AOP的5种advice
weixin_38626208的博客
11-20 2434
advice 5种： before after returning(成功) 在目标方法成功之后织入advice 可额外指定一个returning属性，该属性有2个作用： -advice方法可以通过该属性指定的值来访问目标方法的返回值 -advice方法的声明该返回值类型时，限制目标方法的返回值必须为指定的类型，否则不会织入 如果不想对目标方法的返回值进行限制，可将该返回值声明为Object aft...
实习笔记—— AOP开发II（AOP中Advice的类型）
LGoGoGo的博客
04-24 1370
AOP中Advice的类型的XML配置文件形式 + 注解（基本注解 + 切入点注解）形式
Spring AOP四种创建通知(拦截器)类型
03-15
Spring AOP四种创建通知(拦截器)类型
Spring AOP 基本方式(Advice方式)
ArtistCoder
09-19 1094
1、通知 Advice 1）根据对方法进行拦截的时机，分为四种： Before Advice：方法执行之前进行拦截  AfterReturning Advice：方法正常执行结束之后进行拦截 AfterThrowing Advice：方法异常结束之后进行拦截 Around Advice：环绕通知 2）注意： AroundAdvice应单独使用，不和其他的三种混
Spring AOP通知（Advice）详解
最新发布
Purpletaro的专栏
06-04 1180
Before advice（前置通知）：连接点前面执行，不能终止后续流程，除非抛异常After returning advice（后置通知）：连接点正常返回时执行，有异常不执行Around advice（环绕通知）：围绕连接点前后执行，也能捕获异常处理After advice（最终通知）：连接点退出时执行，无论是正常退出还是异常退出After throwing advice（异常通知）：连接点方法抛出异常时执行。
Spring AOP 中 advice 的四种类型 before after throwing advice around
xiongzhichao的博客
12-24 764
Spring  AOP(Aspect-oriented programming) 是用于切面编程，简单的来说：AOP相当于一个拦截器，去拦截一些处理，例如：当一个方法执行的时候，Spring 能够拦截正在执行的方法，在方法执行的前或者后增加额外的功能和处理。 在Spring AOP中支持4中类型的通知： 1：before advice 在方法执行前执行。 2：after
spring-aop组件详解——Advice通知
蔡小兵的博客
05-03 1141
Advice（通知）是面向切面编程中的一个非常重要的概念。我们都知道，AOP的目的在于对目标类或目标方法的逻辑增强（如：日志逻辑、统计逻辑、访问控制逻辑等），那么Advice就代表要增强的具体逻辑。Advice接口由AOP联盟（aopalliance.org）定义，它只是一个标记接口，用来强调概念，没有定义任何功能（或者说没有定义增强方式或增强内容）。 Advice体系图如下： ...
Spring AOP创建BeforeAdvice和AfterAdvice实例
schangxiang的专栏
07-07 601
BeforeAdvice 1、会在目标对象的方法执行之前被调用。 2、通过实现MethodBeforeAdvice接口来实现。 3、该接口中定义了一个方法即before方法，before方法会在目标对象target之前执行。 AfterAdvice 1、在目标对象的方法执行之后被调用 2、通过实现AfterReturningAdvice接口实现...
Spring基础（15）——AOP——BeforeAdvice
Waiter软件工作室
07-05 616
Spring运行时通知对象：代理Bean只有在第一次被系统需要时才创建。如果使用ApplicationContext，代理对象在BeanFactory载入所有Bean时被创建。因为Spring在运行时创建代理，所以使用SpringAOP不需要特殊编译器。Spring有两种代理创建方式。如果目标对象实现了一个或多个接口暴露的方法，Spring将使用jdk的java.long.Proxy类创建代理。这...
AOP :五种Advice注解
liyu121的博客
01-26 3042
                                                     五种Advice注解 @Before,前置通知 @After(finally), 后置通知，方法执行完之后 @AfterReturning,返回通知，成功执行之后 @AfterThrowing,异常通知，只有抛出异常之后执行 @Around,环绕通知...
浅谈spring aop的五种通知类型
08-28
主要介绍了浅谈spring aop的五种通知类型，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解spring中aop不生效的几种解决办法
08-19
主要介绍了详解spring中aop不生效的几种解决办法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring AOP的Around增强实现方法分析
08-25
主要介绍了spring AOP的Around增强实现方法,结合实例形式分析了spring面向切面AOP的Around增强具体步骤与相关操作方法,需要的朋友可以参考下
Spring aop失效的几种解决方案
08-19
主要介绍了Spring aop失效的几种解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
通过Spring @PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作
热门推荐
安德里亚的成长
03-16 22万+
关于在spring  容器初始化 bean 和销毁前所做的操作定义方式有三种： 第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 第二种是：通过 在xml中定义init-method 和  destory-method方法 第三种是： 通过bean实现InitializingBean和 DisposableBean接口
Spring 的 init-method 和 destory-method
安德里亚的成长
03-16 8万+
关于在spring  容器初始化 bean 和销毁前所做的操作定义方式有三种： 第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 第二种是：通过 在xml中定义init-method 和  destory-method方法 第三种是： 通过bean实现InitializingBean和 DisposableBean接口
Spring bean 通过实现 InitializingBean ,DisposableBean 接口实现初始化方法和销毁前操作
安德里亚的成长
03-16 4万+
关于在spring  容器初始化 bean 和销毁前所做的操作定义方式有三种： 第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 第二种是：通过 在xml中定义init-method 和  destory-method方法 第三种是： 通过bean实现InitializingBean和 DisposableBean接口
Spring FactoryBean
安德里亚的成长
03-15 1万+
Spring  FactoryBean 是创建 复杂的bean，一般的bean 直接用xml配置即可，如果一个bean的创建过程中涉及到很多其他的bean 和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean 例子如下： 1：创建一个Car类（是为了简便）一般不能直接给出Car类，如果是这样直接注入就可以或者Car对象了，这里只是为了简便。 package com.mya
springaop的advice类型有
04-06
Spring AOP 的 Advice 类型有以下几种： 1. Before Advice（前置通知）：在目标方法执行前执行。 2. After Returning Advice（返回通知）：在目标方法正常执行并返回后执行。 3. After Throwing Advice（异常通知）：在目标方法抛出异常后执行。 4. After Advice（后置通知）：在目标方法执行后执行（无论是正常执行、异常执行还是其他方式结束）。 5. Around Advice（环绕通知）：在目标方法执行前和执行后都执行，可以在方法执行前后进行一些操作和监听。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值