Spring(三)-AOP面向切面编程

最新推荐文章于 2024-08-22 14:38:37 发布
最新推荐文章于 2024-08-22 14:38:37 发布
阅读量959 收藏
点赞数
分类专栏： Spring框架 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu_xin5056/article/details/128975249
版权

目录

一、增加功能导致的问题

二、AOP的概念

2.1 什么是AOP

2.2 AOP作用

2.3 AOP中术语

三、什么时候用AOP

四、AOP技术思想的实现

五、使用AspectJ框架实现AOP

5.1通知

5.2 Pointcut位置

5.3 @before前置通知

切入点表达式的变化形式

通知方法的参数JoinPoint

5.4 @AfterReturning后置通知

5.5 @Around环绕通知

5.6 @AfterThrowing异常通知

5.7 @After最终通知

六、AOP总结

一、增加功能导致的问题

问题引出：如果要在已经实现的某个复杂的业务方法前，后增加新的功能，传统方法是怎么做的？

在源代码中业务方法中增加新功能，

1）源代码可能改动的比较多

2）重负代码多

3）代码难于维护

二、AOP的概念

2.1 什么是AOP

AOP(Aspect Orient Programming) : 面向切面编程

Aspect : 表示切面，给业务方法增加的功能叫做切面。切面一般都是非业务功能，而且切面功能一般都是可复用的。例如：日志功能，事务功能，权限检查，参数检查，统计信息等。

Orient : 面向，对看

Programming : 编程

怎么理解面向切面编程？ 以切面为核心设计开发你的应用

1）设计项目时，找出切面的功能。

2）安排切面的执行时间，执行的位置。

2.2 AOP作用

1）让切面功能复用

2）让开发人员专注业务逻辑，提高开发效率

3）实现业务功能和其他非业务功能解耦合

4）给存在的业务方法增加功能，不用修改原来的代码

2.3 AOP中术语

1）Aspect : 切面，给业务方法增加的功能。

2）JoinPoint : 连接点，连接切面的业务方法。在这个业务方法执行时，会同时执行切面的功能。

3）Pointcut : 切入点，是一个或多个连接点的集合。表示这些方法执行时，都能增加切面的功能。表示切面执行 的位置。

4）target : 目标对象，给哪个对象增加切面的功能，这个对象就是目标对象。

5）Advice : 通知，表示切面的执行时间，在目标方法之前执行切面还是目标方法之后执行切面。

AOP中重要三要素：Aspect,Pointcut,Advice。这个概念的理解是：在Advice的时间，在Pointcut的位置，执行Aspect。

AOP是一个动态的思想。在程序运行期间，创建代理（ServiceProxy）,使用代理执行方法时增加切面的功能。这个代理对象是存在内存中的。

三、什么时候用AOP

你要给某些方法增加相同的一些功能。源代码不能修改。给业务方法增加非业务功能。都可以使用AOP。

四、AOP技术思想的实现

使用框架实现AOP，实现AOP的框架有很多，比较有名的两个：

1）Spring : Spring框架实现AOP的部分功能。Spring框架实现AOP的操作比较繁琐，笨重。

2）Aspectj : 独立的框架，专门是实现AOP。属于Eclipse

五、使用AspectJ框架实现AOP

AspectJ框架可以使用注解和xml配置文件两种方式实现AOP

5.1通知

Aspectj表示切面执行的时间，用的是通知（Advice）。这个通知可以使用注解表示

5个注解，表示切面的五个执行时间，这些注解称为通知注解。

@Before : 前置通知

@AfterReturning : 后置通知

@Around : 环绕通知

@AfterThrowing : 异常通知

@After : 最终通知

5.2 Pointcut位置

Pointcut用来表示切面执行的位置，使用Aspectj中切入点表达式。

切入点表达式语法： execution(访问权限修饰符 方法返回值 方法声明(参数) 异常类型)

5.3 @before前置通知

使用aspectj框架的注解，实现前置通知：

①业务逻辑

package com.feiyang.service;



public interface SomeService {

void doSome(String name,Integer age);

}
package com.feiyang.service.impl;

import com.feiyang.service.SomeService;

/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class SomeServiceImpl implements SomeService {



@Override

public void doSome(String name, Integer age) {

System.out.println("业务方法doSome(),执行了");

}

}

②定义一个切面类：

package com.feiyang.handler;



import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;



import java.util.Date;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/



@Aspect

public class MyAspectj {



@Before(value = "execution(public void com.feiyang.service.impl.SomeServiceImpl.doSome(String, Integer))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}

}

③修改配置文件

​
<?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="Index of /schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd Index of /schema/context https://www.springframework.org/schema/context/spring-context.xsd Index of /schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="someService" class="com.feiyang.service.impl.SomeServiceImpl"></bean>

<bean id="myAspect" class="com.feiyang.handler.MyAspectj"></bean>

<!-- 声明自动代理生成器：目的是创建目标对象的代理 -->

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

​

④测试类：

package com.feiyang;



import com.feiyang.service.SomeService;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class Mytest01 {



@Test

public void test01(){

String config = "applicationContext.xml";

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

SomeService someService = (SomeService) ctx.getBean("someService");

System.out.println(someService.getClass().getName());

someService.doSome("张三",18);

}

}

执行结果：

com.sun.proxy.$Proxy8

前置通知执行了Tue Oct 04 11:18:25 GMT+08:00 2022

业务方法doSome(),执行了

可以看到someService运行时类型为代理对象$Proxy8，

代理对象调用方法，才有切面的功能增强

切入点表达式的变化形式

package com.feiyang.handler;



import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;



import java.util.Date;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/



@Aspect

public class MyAspectj {



//匹配指定方法

/*@Before(value = "execution(public void com.feiyang.service.impl.SomeServiceImpl.doSome(String, Integer))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}*/



//匹配任意访问修饰符的指定方法

/*@Before(value = "execution(void com.feiyang.service.impl.SomeServiceImpl.doSome(String, Integer))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}*/



//匹配任意包下的，指定参数类型的doSome方法

/*@Before(value = "execution(* *..doSome(String, Integer))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}*/



//匹配任意包下，任意参数类型的doSome方法

/*@Before(value = "execution(* *..doSome(..))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}*/



//匹配任意包下，do开头的方法

/*@Before(value = "execution(* *..do*(..))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}*/



//匹配任意包下任意方法

@Before(value = "execution(* *..*(..))")

public void myBefore(){

System.out.println("前置通知执行了" + new Date());

}

}

通知方法的参数JoinPoint

package com.feiyang.handler;



import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;



import java.util.Date;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/



@Aspect

public class MyAspectj {



@Before(value = "execution(* *..*(..))")

public void myBefore(JoinPoint jp){

Object[] args = jp.getArgs();//数组中存放的是 方法的所有参数

for (Object arg : args) {

System.out.println("前置通知，获取方法的参数： " + arg);

}



String methodName = jp.getSignature().getName();

if("doSome".equals(methodName)){

System.out.println("doSome输出日志，在目标方法前先执行=" + new Date());

}else if("doOther".equals(methodName)){

System.out.println("doOther参数检查，在目标方法前先执行=" + new Date());

}else{

System.out.println("没有匹配到通知方法");

}

}

}

package com.feiyang;



import com.feiyang.service.SomeService;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class Mytest01 {



@Test

public void test01(){

String config = "applicationContext.xml";

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

SomeService someService = (SomeService) ctx.getBean("someService");

someService.doSome("张三",18);

//someService.doOther("张三",18);

}

}

执行结果：

前置通知，获取方法的参数： 张三

前置通知，获取方法的参数： 18

doSome输出日志，在目标方法前先执行=Tue Oct 04 13:25:54 GMT+08:00 2022

业务方法doSome(),执行了

5.4 @AfterReturning后置通知

@AfterReturning后置通知

属性：value 切入点表达式

returning 自定义的变量，表示目标方法的返回值

自定义变量名称必须和通知方法的形参名一样

位置：在方法的上面

特点：

1.在目标方法之后执行的。

2.能获取到目标方法的执行结果

3.不会影响目标方法的执行

方法的参数：

Object res：表示目标方法的返回值，使用res接收doAfter()的调用结果，

Object res = doAfter()。

后置通知的执行顺序：

Object res = SomeServiceImpl.doAfter();

myAfter(res);

demo:

package com.feiyang.service;


public interface SomeService {

String doAfter();

}
package com.feiyang.service.impl;



import com.feiyang.service.SomeService;


/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class SomeServiceImpl implements SomeService {



@Override

public String doAfter() {

System.out.println("后置通知doAfter()方法执行了");

return "res";

}

}
package com.feiyang.handler;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import java.util.Date;

/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

@Aspect
public class MyAspectj {

//后置通知

@AfterReturning(value = "execution(* *..doAfter(..))",returning = "res")

public void myAfter(Object res){

System.out.println("后置通知，在目标方法之后执行，能拿到业务执行结果：" + res);

}
}
package com.feiyang;

import com.feiyang.service.SomeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class Mytest01 {


@Test

public void test01(){
String config = "applicationContext.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
SomeService someService = (SomeService) ctx.getBean("someService");
someService.doAfter();
}

}

执行结果：

后置通知doAfter()方法执行了

后置通知，在目标方法之后执行，能拿到业务执行结果：res

注意：JoinPoint jp 必须是第一个参数

//后置通知

@AfterReturning(value = "execution(* *..doAfter(..))",returning = "res")

public void myAfter(JoinPoint jp,Object res){

System.out.println("后置通知，在目标方法之后执行，能拿到业务执行结果：" + res);

}

下面这样会报错：

//后置通知

@AfterReturning(value = "execution(* *..doAfter(..))",returning = "res")

public void myAfter(Object res，JoinPoint jp){

System.out.println("后置通知，在目标方法之后执行，能拿到业务执行结果：" + res);

}

5.5 @Around环绕通知

@Around : 环绕通知

属性 ： value

位置 ： 在方法定义的上面

返回值 ： Object，表示调用目标方法希望得到执行结果（不一定是目标方法自己的返回值）

参数 ： ProceedingJoinPoint，相当于反射中的Method

作用 ： 执行目标方法的，等于Method.invoke()

特点 ：

1.在目标方法前后都能增强功能

2.控制目标方法是否执行

3.修改目标方法的执行结果

demo:

package com.feiyang.service;

public interface SomeService {
String doFirst(String name);
}

package com.feiyang.service.impl;

import com.feiyang.service.SomeService;

/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/
public class SomeServiceImpl implements SomeService {

@Override
public String doFirst(String name) {
System.out.println("业务方法执行了。。。");
return "sss";
}
}
package com.feiyang.handler;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import java.util.Date;


/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/


@Aspect
public class MyAspectj {


//后置通知

@AfterReturning(value = "execution(* *..doAfter(..))",returning = "res")
public void myAfter(JoinPoint jp,Object res){
System.out.println("后置通知，在目标方法之后执行，能拿到业务执行结果：" + res);
}


//环绕通知
@Around("execution(* *..doFirst(..))")
public void myAround(ProceedingJoinPoint pjp) throws Throwable {
//可以控制在业务方法执行前执行什么逻辑
System.out.println("执行了环绕通知的myAround（）方法,在业务方法执行前");


//可以控制业务方法是否执行
String returnValue = (String)pjp.proceed();


//可以控制返回值
String res="";
if("aaa".equals(returnValue)){
res = returnValue;
}else{
res = "bbb";
}


//可以控制在业务方法执行后执行什么逻辑
System.out.println("执行了环绕通知的myAround（）方法,在业务方法执行后: " + res);
}
}
package com.feiyang;



import com.feiyang.service.SomeService;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

public class Mytest01 {



//环绕通知

@Test

public void test03(){

String config = "applicationContext.xml";

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

SomeService someService = (SomeService) ctx.getBean("someService");

someService.doFirst("张三");

}



}

执行结果：

执行了环绕通知的myAround（）方法,在业务方法执行前

业务方法执行了。。。

执行了环绕通知的myAround（）方法,在业务方法执行后bbb

5.6 @AfterThrowing异常通知

//异常通知

@AfterThrowing(value = "execution(* *..doSecond(..))", throwing = "ex")

public void myAfterThrowing(Exception ex){

System.out.println("异常通知，执行目标方法时抛异常了,异常原因：" + ex.getMessage());

}

@Override

public void doSecond(String name) {

int z;

z = 5/0;

System.out.println("异常通知业务方法执行了。");

}

//异常通知

@Test

public void test04(){

String config = "applicationContext.xml";

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

SomeService someService = (SomeService) ctx.getBean("someService");

someService.doSecond("lisi");

}

执行结果：

异常通知，执行目标方法时抛异常了,异常原因：/ by zero

5.7 @After最终通知

在目标方法之后执行，总是会被执行，可以用来做程序最后的首位工作，例如清除临时数据，变量，清理内存等。

//最终通知

@After("execution(* *..doThird(..))")

public void myAfter(){

System.out.println("最终通知总是会执行。");

}

//最终通知

@Test

public void test05(){

String config = "applicationContext.xml";

ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

SomeService someService = (SomeService) ctx.getBean("someService");

someService.doThird();

}

执行结果：

业务方法执行了。

最终通知总是会执行。

5.8 @Pointcut

定义和管理切入点，不是通知注解。

package com.feiyang.handler;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import java.util.Date;


/**

* @author：飞扬

* @公众hao：程序员飞扬

* @description:

*/

@Aspect
public class MyAspectj {

@Before(value = "mypt()")

public void method1(){

System.out.println("业务逻辑执行了");

}


@After(value = "mypt()")

public void method2(){

System.out.println("业务逻辑执行了");

}


@Pointcut("execution(* *..doThird(..))")

public void mypt(){

//无需代码

}

}

六、AOP总结

        AOP是一种动态的技术思想，目的是实现业务功能和非业务功能的解耦合。业务功能是独立的模块，其他功能也是独立的业务模块。例如事务功能，日志等等。让这些功能，如事务，日志等是可以复用的。

        当目标方法需要一些功能时，可以在不修改源代码的情况下，使用aop的技术在程序执行期间，生成代理对象，通过执行业务方法，增加了功能。

程序员飞扬
关注
专栏目录
AOP面向切面编程
weixin_45723046的博客
03-26 914
AOP 什么是AOP AOP (Aspect Oriented programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性。 Aop在Spring中的作用：提供声明式的事务，允许用户自定义切面 横切关注点:跨越应用程序多个模块的方法或功能。即是
AOP（面向切面编程）
m0_58487321的博客
04-21 2197
AOP（面向切面编程）注解
AOP——面向切面编程
m0_62912377的博客
05-05 8773
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程，是一种编程思想，所以，AOP也是一种编程思想，只是他们两个是不同的编程范式。
AOP(面向切面编程)
Java程序媛，欢迎大家一起交流学习~
05-04 2729
AOP作为Spring的一个子模块，和OOP（面向对象编程）一样是一种编程思想，是对OOP的一种补充。博主下面对AOP整理了相关内容，下面我们一起来看下吧。提示：以下是本篇文章正文内容，下面案例可供参考AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
16.2 Spring框架-AOP面向切面编程
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
java-AOP面向切面编程
06-14
面向切面编程（AOP）是Java开发中的一个重要概念，它是对传统的面向对象编程（OOP）的一个补充。AOP的主要目标是将关注点分离，让系统中的核心业务逻辑与系统服务（如日志、事务管理等）解耦。通过AOP，开发者可以将...
CH03-AOP面向切面编程.pptx
12-28
AOP(Aspect Oriented Programming)：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是对OOP的补充，是软件开发中的一个热点，也是Spring框架中的一个重要内容。 利用AOP...
spring-aop面向切面系统日志案例
07-17
在IT行业中，Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的核心特性之一，它使得我们能够以一种声明式的方式处理系统中的横切关注点，如日志记录、事务管理、性能监控等。这个“spring-...
aop（面向切面编程）
最新发布
xiaobai_cpp的博客
08-22 1283
连接点指的是程序执行的某个特定位置，如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后等。在Spring AOP中，由于它仅支持方法级别的增强，因此连接点通常指的是方法的执行点。
Aop【面向切面编程】
爪哇人的博客
12-12 473
1 什么是aop aop是通过预编译方式和运行期动态代理实现程序功能统一维护的一种技术。aop是又叫做面向切面编程，是oop的延续，是软件开发中的一个热点，也是spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用aop可以对业务逻辑的各个部分进行隔离，从而使得各个部分耦合度降低，提高程序的重用性，同时提高了开发的效率。 2 业务场景 参考博客：细说Spring——AOP详解（AOP概览）_啦啦啦的博客-CSDN博客_aop 我们可能会在不同的方法中用到同...
Springboot AOP切面
m0_58680865的博客
12-28 6924
定义AOP切面
Aop面向切面编程
Angel__wings的博客
07-26 225
面向切面的程序设计(AspectOrientedProgramming)又译作和OOP(ObjectOrientedProgramming)一样,也是计算机开发的一种程序设计思想,是函数式编程的一种衍生范型。web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。。)在实际开发中，比如、促销查询等业务，。就是在不修改现有程序代码的前提下,可以设置某个方法运行之前或运行之后新增额外代码的操作。.........
Spring之AOP面向切面编程
andyliu198571的博客
07-07 225
2.3 AOP面向切面编程 ​ 在软件行业中，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 注意 对于实现过接口的类在AOP时，使用基于JDK的动态代理来生成
Spring AOP：面向切面编程详解与实战
CH03-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、付费专栏及课程。

余额充值