spring之AOP

最新推荐文章于 2023-11-13 19:27:30 发布
最新推荐文章于 2023-11-13 19:27:30 发布
阅读量119 收藏
点赞数
文章标签： spring之AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349974/article/details/100672227
版权

aop的简介

解决的问题：解决了需求的改变，造成了原有没必要改变的代码，需要去改变它；
比如：书籍的增删改，本身只需要完成增删改的功能即可，这是如果需要添加日志功能，那么需要在原有的代码基础上，去修改添加日志功能，受牵连的方法就三个（add/edit/del）了;
AOP中关键性概念
连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.

目标(Target)：被通知(被代理)的对象
注1：完成具体的业务逻辑

通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
注2：完成切面编程

代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),
例子：外科医生+护士

注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。
(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

案例
前置通知
实现org.springframework.aop.MethodBeforeAdvice接口
买书、评论前加系统日志

后置通知
实现org.springframework.aop.AfterReturningAdvice接口
买书返利（存在bug）

环绕通知
org.aopalliance.intercept.MethodInterceptor
类似拦截器，会包括切入点，目标类前后都会执行代码。

异常通知
org.springframework.aop.ThrowsAdvice
出现异常执行系统提示，然后进行处理。价格异常为例

过滤通知（适配器）
org.springframework.aop.support.RegexpMethodPointcutAdvisor
处理买书返利的bug

前置通知
BookBizImpl

package com.yq.aop.biz.impl;

import com.yq.aop.biz.IBookBiz;
import com.yq.aop.exception.PriceException;

public class BookBizImpl implements IBookBiz {

	public BookBizImpl() {
		super();
	}

	public boolean buy(String userName, String bookName, Double price) {
		// 通过控制台的输出方式模拟购书
		if (null == price || price <= 0) {
			throw new PriceException("book price exception");
		}
		System.out.println(userName + " buy " + bookName + ", spend " + price);
		return true;
	}

	public void comment(String userName, String comments) {
		// 通过控制台的输出方式模拟发表书评
		System.out.println(userName + " say:" + comments);
	}

}

在这里插入代码片

IBookBiz

package com.yq.aop.biz;

public interface IBookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);

	// 发表书评
	public void comment(String userName, String comments);
}

在这里插入代码片

MyMethodBeforeAdvice

package com.yq.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 买书，评论前加系统日志
 * @author 陌陌
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
//		在这里，可以获取到目标类的全路径名及方法参数，然后就可以将他们写到日志里面去
		String target = arg2.getClass().getName();
		String methodName = arg0.getName();
		String args = Arrays.toString(arg1);
		System.out.println("[前置通知：系统日志]，"+target+"."+methodName+"("+args+")被调用了");
	}

}

在这里插入代码片

配置spring-context.xml

<!--.......aop的讲解。。。。。  -->
<!-- 目标 -->	
<bean class="com.yq.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>	
<!-- 前置通知 -->	
<bean class="com.yq.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>

<!-- 利用目标+通知生成代理对象 -->	
<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
<property name="target" ref="bookBiz"></property>
<property name="proxyInterfaces">
<list>
<value>com.yq.aop.biz.IBookBiz</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
</list>
</property>
</bean>
在这里插入代码片

AopTest

package com.yq.aop.test;

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

import com.yq.aop.biz.IBookBiz;

public class AopTest {
@SuppressWarnings("resource")
public static void main(String[] args) {
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookBiz");
	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookProxy");
	bean.buy("张三", "java编程思想", 19.9);
	bean.comment("张三", "太难了，看不懂");
}
}

在这里插入代码片

在这里插入图片描述
后置通知
MyAfterReturningAdvice

package com.yq.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 买书返利
 */
import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
		String target = arg3.getClass().getName();
		String methodName = arg1.getName();
		String args = Arrays.toString(arg2);
		System.out.println("[后置通知：买书返利]，"+target+"."+methodName+"("+args+")被调用了."+"该方法被调用后的返回值为："+arg0);
		
	}

}

在这里插入代码片

配置spring-context.xml

<!--.......aop的讲解。。。。。  -->
<!-- 目标 -->	
<bean class="com.yq.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>	
<!-- 前置通知 -->	
<bean class="com.yq.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
<!-- 后置通知 -->
<bean class="com.yq.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>

<!-- 利用目标+通知生成代理对象 -->	
<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
<property name="target" ref="bookBiz"></property>
<property name="proxyInterfaces">
<list>
<value>com.yq.aop.biz.IBookBiz</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
<value>myAfterReturningAdvice</value>
</list>
</property>
</bean>
在这里插入代码片

AopTest

package com.yq.aop.test;

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

import com.yq.aop.biz.IBookBiz;

public class AopTest {
@SuppressWarnings("resource")
public static void main(String[] args) {
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookBiz");
	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookProxy");
	bean.buy("张三", "java编程思想", 19.9);
	bean.comment("张三", "太难了，看不懂");
}
}

在这里插入代码片

在这里插入图片描述
环绕通知
MyMethodInterceptor

package com.yq.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 环绕通知
 * 包含了前置和后置通知
 * @author 陌陌
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		String target = arg0.getThis().getClass().getName();
		String methodName = arg0.getMethod().getName();
		String args = Arrays.toString(arg0.getArguments());
		System.out.println("[环绕通知调用前：]，"+target+"."+methodName+"("+args+")被调用了."+"该方法被调用后的返回值为："+arg0);
//		arg0.proceed()就是目标对象的方法
		Object proceed = arg0.proceed();
		System.out.println("[环绕通知调用后：]，该方法被调用后的返回值为："+proceed);
		return proceed;
	}

}

在这里插入代码片

配置spring-context.xml

<!--.......aop的讲解。。。。。  -->
<!-- 目标 -->	
<bean class="com.yq.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>	
<!-- 前置通知 -->	
<bean class="com.yq.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
<!-- 后置通知 -->
<bean class="com.yq.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
<!-- 环绕通知 -->
<bean class="com.yq.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>

<!-- 利用目标+通知生成代理对象 -->	
<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
<property name="target" ref="bookBiz"></property>
<property name="proxyInterfaces">
<list>
<value>com.yq.aop.biz.IBookBiz</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
<value>myAfterReturningAdvice</value>
<value>myMethodInterceptor</value>
</list>
</property>
</bean>
在这里插入代码片

AopTest

package com.yq.aop.test;

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

import com.yq.aop.biz.IBookBiz;

public class AopTest {
@SuppressWarnings("resource")
public static void main(String[] args) {
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookBiz");
	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookProxy");
	bean.buy("张三", "java编程思想", 19.9);
	System.out.println("---------------");
	bean.comment("张三", "太难了，看不懂");
}
}

在这里插入代码片

在这里插入图片描述
异常通知
MyThrowsAdvice

package com.yq.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.yq.aop.exception.PriceException;
/**
 * 出现异常执行系统提示，然后进行处理，价格异常为例
 * @author 陌陌
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
public void afterThrowing(PriceException ex) {
	System.out.println("[异常通知]，当价格方式异常，那么执行此处代码块！！！！！");
}
}

在这里插入代码片

配置spring-context.xml

<!--.......aop的讲解。。。。。  -->
<!-- 目标 -->	
<bean class="com.yq.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>	
<!-- 前置通知 -->	
<bean class="com.yq.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
<!-- 后置通知 -->
<bean class="com.yq.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
<!-- 环绕通知 -->
<bean class="com.yq.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>
<!-- 异常通知 -->
<bean class="com.yq.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>

<!-- 利用目标+通知生成代理对象 -->	
<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
<property name="target" ref="bookBiz"></property>
<property name="proxyInterfaces">
<list>
<value>com.yq.aop.biz.IBookBiz</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
<value>myAfterReturningAdvice</value>
<value>myMethodInterceptor</value>
<value>myThrowsAdvice</value>
</list>
</property>
</bean>
在这里插入代码片

AopTest

package com.yq.aop.test;

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

import com.yq.aop.biz.IBookBiz;

public class AopTest {
@SuppressWarnings("resource")
public static void main(String[] args) {
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookBiz");
	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookProxy");
	bean.buy("张三", "java编程思想", -19.9);
	System.out.println("---------------");
	bean.comment("张三", "太难了，看不懂");
}
}

在这里插入代码片

在这里插入图片描述
过滤通知
配置spring-context.xml

<!--.......aop的讲解。。。。。  -->
<!-- 目标 -->	
<bean class="com.yq.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>	
<!-- 前置通知 -->	
<bean class="com.yq.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
<!-- 后置通知 -->
<bean class="com.yq.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
<!-- 环绕通知 -->
<bean class="com.yq.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>
<!-- 异常通知 -->
<bean class="com.yq.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
<!-- 过滤通知 -->
<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myAfterReturningAdvicePlus">
<property name="advice" ref="myAfterReturningAdvice"></property>
<property name="pattern" value=".*buy"></property>
</bean>

<!-- 利用目标+通知生成代理对象 -->	
<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
<property name="target" ref="bookBiz"></property>
<property name="proxyInterfaces">
<list>
<value>com.yq.aop.biz.IBookBiz</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
<!-- <value>myAfterReturningAdvice</value> -->
<value>myAfterReturningAdvicePlus</value>
<value>myMethodInterceptor</value>
<value>myThrowsAdvice</value>

</list>
</property>
</bean>
在这里插入代码片

AopTest

package com.yq.aop.test;

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

import com.yq.aop.biz.IBookBiz;

public class AopTest {
@SuppressWarnings("resource")
public static void main(String[] args) {
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookBiz");
	IBookBiz bean= (IBookBiz) applicationContext.getBean("bookProxy");
	bean.buy("张三", "java编程思想", 19.9);
	System.out.println("---------------");
	bean.comment("张三", "太难了，看不懂");
}
}

在这里插入代码片

在这里插入图片描述

陌离～
关注
JAVA8反射获取方法参数名
ilovewqf的博客
11-22 806
jDK1.8的修改，在JDK8中，反射可以得到方法参数名了。是因为Method类加了新的方法 public Parameter[] getParameters() 但是实际项目中得到的确是arg0这样的参数名。请看下面代码: public static void main(String[] args) throws NoSuchMethodException { final Method...
【Java】JDK8的通过反射获得方法的实际形参名，而非arg0等
MarcherXL的博客
09-15 538
今天在写一个AOP代理的时候，发现通过反射获取了类的Method对象之后，再获得方法的形参列表，从而获取方法的形参名的时候，发现输出的为默认的arg0、arg1…或者Override compiler parameters per-module中新增一个module并设置 Compilation options值为-parameters。使用手动命令方式编译：javac -parameters XXX.java，之后再使用java XXX.java运行。
java java.lang.reflect.Parameter .getName() 取method的参数变量名(Obtaining Names of Method Parameters)
starzxf的专栏
10-17 1893
       根据 oracle 官方解释(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html) ， 编译器为了压缩 .class 大小，压缩了参数名，默认用 argN, N代表方法参数列表下标，通过 java.lang.reflect.Parameter .getName() ...
【SpringBoot应用篇】【AOP+注解】SpringBoot使用Aspect AOP基于注解获取方法形参
输入技术、输出想法
04-04 1862
需求: 需要保存的日志内容在方法的参数中，并且方法参数的类型对象不一样，且对象的属性名称不一样。这一篇文章已经给出了解决方法。但是如果方法的参数不同，会出来转换器类爆炸的情况。问题：Java反射中Parameter的getName后得到arg0的问题。1、@LogPro注解中添加field目标属性字段。2、LogAspectPro切面增强。
java反射中Parameter的getName后得到arg0的问题
深入Java世界：探索编程之美与技术深度
02-22 1965
一次实际研发中偶然碰到的问题 private List getParamsName(HandlerMethod handlerMethod) { Parameter[] parameters = handlerMethod.getMethod().getParameters(); List<String> list = new ArrayList<>(); for (Parameter parameter : parameters)
手写DispatcherServlet中央控制器，获取参数的名字parameter.getName(),获取的名字是arg0，arg1，arg2....导致接收不到前端传过来的token，登录已过期。
最新发布
小丁的博客
11-13 494
参数名称为arg0、arg1等是因为Java默认使用参数名称来引用参数。如果没有在编译时使用特定的标志，则编译器会将参数名称设置为arg0，arg1等。解决此问题的方法之一是在编译时使用 -parameters 标志。这将告诉编译器将参数名称编译到字节码中。例如，在使用Maven构建项目时，可以在pom.xml文件中添加以下插件配置：
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
spring 之aop
03-06
标题中的“Spring 之AOP”指的是在Spring框架中对面向切面编程（Aspect-Oriented Programming，简称AOP）的使用。AOP是软件设计的一种模式，它将关注点分离，使得我们可以独立地处理系统中的交叉关注点，如日志、...
spring之AOP（动态代理）
09-06
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志、事务管理、权限检查等）与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
java反射中Parameter的getName函数如何得到参数名
虚拟-Worder的博客
05-06 5740
如果jdk是1.8一下或者没有设置带参数名编译，那么Parameter的getName函数只会返回arg0，arg1，arg2......想要得到真正的参数名，得勾选一下带参数名编译的设置：这样就ok了为什么要勾选带参数编译的设置呢？想到前几天学的词法分析和语法分析才知道，变量名，函数名等在编译时并不会按照程序员自己给的名字编译，相反，编译器会一一做替换，比如你的public void fun（ ...
通过java反射机制，Method获取出来的参数名为arg
热门推荐
BeamCSDN的博客
11-25 1万+
记录2018年我遇见的一个大坑！！！！！前言具体介绍出现问题解决 前言 最近我一直在尝试手写一个简单的框架，其中，在补全mvc框架的时候，遇到了Method方法关于版本以及一些奇奇怪怪的坑。 具体介绍 框架需要实现的部分如下 将到有@requestMapping的注解的方法通过反射机制获取出来 将获取到的Method放入一个Map&amp;lt;String,Object&amp;gt;中，其中key为re...
java：能否通过反射获取方法的参数名字？
qq_36642340的博客
07-31 5572
前言：   最近在牛客网上看到有人分享面试经验，其中有一个非常刁钻的问题：能否通过反射获取方法的参数名字？我我觉得非常奇怪，明明反射获取方法后获取参数（Parameter）中带有getName方法，怎么可能获取不到呢？ 后续： 但在网上翻阅资料发现，原理jdk1.8之前java文件编译成class文件时并不会将参数名字也一起编译进去，而是以arg0，arg1这种模糊名字来替代。 所以在j...
【JavaWeb】网页发送request执行getName获取不到参数名的字符串却返回arg0、arg1...解决办法
weixin_45873353的博客
09-16 301
网页发送request，执行getName获取不到参数名的字符串，却返回arg0、arg1…从而产生参数获得为nul的问题。如图，此处parameterName的结果应为具体的参数结果。这是IDEA设置产生的问题，在。结果却得到“arg0”
Java8获取运行时方法参数
Technology exist forever
04-18 2142
jdk1.8之前reflect没有提供直接读取运行时方法参数的api。java8提供了Method.getParameters() 和parameter.getName()的api，但必须设置编译器的-parameter参数才能获取到正确的参数名称，而不是arg0，arg1这种格式，而且要注意一定要使用javac编译器。除此之外，该参数在jdk1.8.0上似乎不起作用，原因未知，可以使用jdk1....
Java8反射机制下获取方法名、参数名（配置-parameters、Idea/Eclipse/Maven配置）
【CSDN】
07-28 4661
在Java8之前，代码编译为class文件后，方法参数的类型固定，但是方法名称会丢失，方法名称会变成arg0、arg1....。而现在，在Java8开始可以在class文件中保留参数名，这就给反射带来了极大的遍历。像mybatis等需要使用反射机制获取方法参数的时候就可以不用像以前一样需要使用类似于@Para之类的注解。 功能测试 代码参考自,点击进入 编写测试类 import java.lang.reflect.Method; import java.lang.reflect...
方法拦截器（MethodInterceptor）使用
aben06的专栏
07-16 3230
方法拦截器（MethodInterceptor）使用   package cuigh.spring.aop.step01; /*  * 功能：目标类  * */ public class MessageWriter { public void writeMessage(String name){ System.out.print(" World "); } public
spring AOP——MethodInterceptor接口实现方法执行前后环绕通知
Bruce_Json的博客
09-01 2167
方法执行前后环绕通知（可以理解为方法执行前后环绕“增强”）需要实现接口：MethodInterceptor interface package com.inter; public interface HelloInter { public void hello(); } helloImpl package com.impl; import com.inter.HelloI...
Spring的核心功能之AOP(面向切面编程)
water_java的博客
09-10 375
AOP基本概念 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发...
Spring学习笔记(三)——继续AOP
Faith
11-13 131
上次我们谈到了简单的AOP，今天我们继续旅程。     上次我们谈到了对一个对象的方法进行切割，那如果要对两个、3个对象呢？我们发现： &lt;bean id="result" class="org.springframework.aop.framework.ProxyFactoryBean"&gt;  &lt;property name="interceptorNames"&gt;   &l...
Spring框架AOP初学者指南
这使得Spring框架成为企业级Java应用中的首选框架之一。 在实际应用中，Spring AOP支持多种通知类型，包括前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值