SpringBoot整合Drools

最新推荐文章于 2024-04-21 06:41:31 发布
最新推荐文章于 2024-04-21 06:41:31 发布
阅读量6.5k 收藏 20
点赞数 3
分类专栏： SpringBoot 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43466788/article/details/120916500
版权

文章目录

关于Drools

博客： 规则引擎 Drools
上面那篇博客详细的介绍了Drools，还要语法规则，关于什么是Drools，看这篇博客完全足够了。

下面的重点是springboot整合drools

整合Drools

一般流程

  1. 创建一个springboot项目，不会创建的可以参考这篇博客：【Spring Boot】快速上手SpringBoot

  2. 引入我们的drools依赖：

        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>7.37.0.Final</version>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.37.0.Final</version>
        </dependency>

配合测试可能还需要引入的依赖：

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
  1. 配置好我们的工具类KieSessionUtils，后面可以直接调用即可：
package com.gaolang.utils;

import org.drools.decisiontable.InputType;
import org.drools.decisiontable.SpreadsheetCompiler;
import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.event.rule.DebugRuleRuntimeEventListener;
import org.kie.api.io.Resource;
import org.kie.api.io.ResourceType;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.api.runtime.StatelessKieSession;
import org.kie.internal.utils.KieHelper;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;

/**
 *
 * 1.维护了有状态和无状态的两种Session对象，不推荐使用get。
 * 2.全局的Session已经在config下的Configuration中自动装配了。
 * 3.无并发的情况下，使用newKieSession()既可。
 * @author Hong Wen 2018/04/04
 *
 */
public class KieSessionUtils {

    private static KieSession kieSession;
    private static final String RULES_PATH = "rules/";

    private KieSessionUtils() {

    }
    /**
     * @description TODO(创建包含所有规则的对象)
     * @throws Exception
     * @return KieSession
     */
    public static KieSession getAllRules() throws Exception {
        try {
            disposeKieSession();
            KieServices kieServices = KieServices.Factory.get();
            KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
            for (org.springframework.core.io.Resource file : new PathMatchingResourcePatternResolver().getResources("classpath*:" + RULES_PATH + "**/*.*")) {
                kieFileSystem.write(org.kie.internal.io.ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
            }
            final KieRepository kieRepository = KieServices.Factory.get().getRepository();
            kieRepository.addKieModule(new KieModule() {
                @Override
                public ReleaseId getReleaseId() {
                    return kieRepository.getDefaultReleaseId();
                }
            });
            KieBuilder kieBuilder = KieServices.Factory.get().newKieBuilder(kieFileSystem);
            kieBuilder.buildAll();
            kieSession = KieServices.Factory.get().newKieContainer(kieRepository.getDefaultReleaseId()).newKieSession().getKieBase().newKieSession();
            return kieSession;
        } catch (Exception ex) {
            throw ex;
        }
    }

    /**
     * @description TODO (快速新建KieSession)
     * @param classPath 绝对路径
     * @return KieSession 有状态
     */
    public static KieSession newKieSession(String classPath) throws Exception {
        KieSession kieSession = getKieBase(classPath).newKieSession();
        kieSession.addEventListener(new DebugRuleRuntimeEventListener());
        return kieSession;

    }

    /**
     * @description TODO (快速新建StatelessKieSession)
     * @param classPath 绝对路径
     * @return StatelessKieSession 无状态
     */
    public static StatelessKieSession newStatelessKieSession(String classPath) throws Exception {
        StatelessKieSession kiesession = getKieBase(classPath).newStatelessKieSession();
        return kiesession;

    }

    /**
     * @description TODO (清空对象)
     * @title disposeKieSession 重置KieSession
     * @return void
     */
    public static void disposeKieSession() {
        if (kieSession != null) {
            kieSession.dispose();
            kieSession = null;
        }
    }

    protected static KieBase getKieBase(String classPath) throws Exception {
        KieServices kieServices = KieServices.Factory.get();
        KieFileSystem kfs = kieServices.newKieFileSystem();
        Resource resource = kieServices.getResources().newClassPathResource(classPath);
        resource.setResourceType(ResourceType.DRL);
        kfs.write(resource);
        KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();
        if (kieBuilder.getResults().getMessages(Message.Level.ERROR).size() > 0) {
            throw new Exception();
        }
        KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
        KieBase kBase = kieContainer.getKieBase();
        return kBase;
    }

    /**
     * 根据服务器真实路径下的xls文件生成drl文件内容
     */
    public static KieSession getKieSessionFromXLS(String realPath) throws FileNotFoundException {
        return createKieSessionFromDRL(getDRL(realPath));
    }

    // 把xls文件解析为String
    public static String getDRL (String realPath) throws FileNotFoundException {
        File file = new File(realPath); // 例如：C:\\abc.xls
        InputStream is = new FileInputStream(file);
        SpreadsheetCompiler compiler = new SpreadsheetCompiler();
        return compiler.compile(is, InputType.XLS);
    }

    // drl为含有内容的字符串
    public static KieSession createKieSessionFromDRL(String drl) {
        KieHelper kieHelper = new KieHelper();
        kieHelper.addContent(drl, ResourceType.DRL);
        Results results = kieHelper.verify();
        if (results.hasMessages(Message.Level.WARNING, Message.Level.ERROR)) {
            List<Message> messages = results.getMessages(Message.Level.WARNING, Message.Level.ERROR);
            for (Message message : messages) {
                System.out.println("Error: "+message.getText());
            }
            throw new IllegalStateException("Compilation errors were found. Check the logs.");
        }
        return kieHelper.build().newKieSession();
    }



}
  1. 创建一个测试实体类，以及一个rule.drl规则文件：
@Data
public class UserInfo {

    private String name;

    private Integer age;

    private List<String> interests;

    private Map<String, String> tags;
}

关于rule.drl文件放置的位置，工具类KieSessionUtils 的getAllRules()方法会解析工程resource目录下rules文件夹下的所有drl文件，你可以放在这里。在这里插入图片描述
newKieSession()里面参数是绝对路径，解析单一的drl文件，测试的rule.drl：

package rules;
dialect "java"

import com.gaolang.entity.*;


rule "评估用户"
when
  $u : UserInfo(name == "张" || name == "李")
then
  System.err.println("用户"+$u);
 end
  1. 测试代码：
    @Test
    public void test01() throws Exception {
        UserInfo userInfo = new UserInfo();
        userInfo.setName("李");
        KieSession kieSession = KieSessionUtils.getAllRules();
        kieSession.insert(userInfo);
//        kieSession.getAgenda().getAgendaGroup("abc").setFocus();
        kieSession.fireAllRules();
        kieSession.dispose();

    }

测试的结果：它是与关系式匹配的，会看到输出：
在这里插入图片描述

快速整合

  1. 创建一个springboot项目，不会创建的可以参考这篇博客：【Spring Boot】快速上手SpringBoot

  2. 引入我们的drools依赖：
    关于这个依赖的网址：https://github.com/hongwen1993/fast-drools-spring-boot-starter

        <dependency>
            <groupId>com.github.hongwen1993</groupId>
            <artifactId>fast-drools-spring-boot-starter</artifactId>
            <version>8.0.8</version>
        </dependency>

配合测试可能还需要引入的依赖：

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
  1. 官方的配置文件，放到项目的application.properties中：
################## 必填属性 ##################
# 指定规则文件目录，会自动扫描该目录下所有规则文件，决策表，以及CSV文件
# 支持classpath资源目录，如：classpath:drools/**/*.drl
# win 系统注意使用反斜杠，如：C:\\DRL\\
# linux 系统注意使用斜杠，如：/usr/local/drl/
spring.drools.path = C:\\DRL\\
################## 可选属性 ##################
# 也可以指定全局的mode，选择stream或cloud（默认stream模式）
spring.drools.mode = stream
# 自动更新，on 或 off（默认开启）
spring.drools.auto-update = on
# 指定规则文件自动更新的周期，单位秒（默认30秒扫描偶一次）
spring.drools.update = 10
# 规则监听日志，on 或 off（默认开启）
spring.drools.listener = on
# 开启 drl 语法检查，on 或 off（默认关闭）
spring.drools.verify = off

上面配置文件的修改spring.drools.path部分

# 支持classpath资源目录，如：classpath:drools/**/*.drl
# win 系统注意使用反斜杠，如：C:\\DRL\\
# linux 系统注意使用斜杠，如：/usr/local/drl/
  1. 和上面相同的测试实体类和drl文件：
    @Autowired
    private KieTemplate kieTemplate;


    @Before
    public void before() throws InterruptedException {
        Thread.sleep(1000);
    }

    @Test
    void test02() throws Exception {
        KieSession session = kieTemplate.getKieSession("rule01.drl");
        UserInfo userInfo = new UserInfo();
        userInfo.setName("李");
        session.insert(userInfo);
        session.fireAllRules();
        session.dispose();
    }

测试结果是相同的。

高 朗
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Drools（6）：Spring Boot整合Drools
u013938578的博客
07-28 695
代码】Drools（6）SpringBoot整合Drools。
SpringBoot2整合Drools规则引擎及案例详解
08-25
主要介绍了SpringBoot2整合Drools规则引擎及案例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot整合drools规则引擎
m0_68705273的博客
08-03 564
在这个示例中，我们定义了一个名为DroolsService的类，它包含一个executeRules方法，用于加载规则文件并执行规则。在这个示例中，我们定义了一个名为PersonController的控制器，它包含一个名为checkEligibility的方法，用于调用规则引擎服务。现在，我们可以使用POST请求向/person端点发送一个Person对象，规则引擎服务将会根据规则文件中的规则来判断该Person对象是否满足条件，并将eligibleForVoting属性设置为true或false。
springboot项目引入了doris数据，建表模式如何选？_springboot 使用doris
最新发布
2401_84435838的博客
04-21 1010
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！
Java-springboot集成+drools规则引擎集成，动态化编程
lvyuanj的专栏
03-25 1530
Java-springboot集成+drools规则引擎集成，可以通过界面化大的方式动态化编程
springboot集成规则引擎drools
qq_14946371的博客
05-23 1657
规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模板编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。欢迎关注个人公众号【好好学技术】交流学习drools是一款由JBoss组织提供的基于java语言开发的开源规则引擎，可以将复杂且多变的业务规则从硬编码中解放出来，以规则脚本的形式存放在文件或特定的存储介质中（如存放在数据库中），使得业务规则的变更不需要修改项目代码、重启服务器就可以在线上环境立即生效。Drools中文网 | 基于java的功能强大的开源规则引擎。
Spring Boot整合Drools规则引擎实例
言尭的博客
08-09 2591
1、DRools介绍 官网：https://www.drools.org/ 规则引擎主要完成的就是将业务规则从代码中分离出来。 DRools一款由JBoss组织提供的基于Java语言开发的开源规则引擎，目前由 Redhat 开源的规则引擎，它是 Redhat 的 KIE Group 中的组件之一，可以比较方便的跟另一个组件 JBPM 工作流配合用于管理复杂的规则流；同时 Drools 的推理策略算法在经典 Rete 算法以及其它算法的基础上做了多个版本的增强。DRools是一个具有基于前向链接和后向链
drools －规则语法
热门推荐
哎幽的成长
12-25 3万+
文章结构1. 基础api2. FACT对象3. 规则4. 函数1. 基础api在 Drools 当中，规则的编译与运行要通过Drools 提供的各种API 来实现，这些API 总体来讲可以分为三类：规则编译、规则收集和规则的执行。完成这些工作的API 主要有KnowledgeBuilder、KnowledgeBase、StatefulKnowledgeSession、StatelessKnowled
Spring Boot集成规则引擎Drools
08-01 658
本文演示了Spring Boot如何集成规则引擎Drools，文章中有全部的代码即配置文件，即测试过程，测试数据和测试结果。文中所有代码均测试通过。
springboot整合drools7.0规则引擎 #资源达人分享计划#
08-08
springboot整合drools7.0规则引擎，适合有规则引擎需求的开发者
springboot整合drools代码+文档.zip
05-29
里面包含springboot与drools的整合代码以及文档.
drools集成springboot demo
07-18
drools集成springboot demo
Spring Boot+Drools规则引擎整合详解
08-29
本篇文章主要介绍了Spring Boot+Drools规则引擎整合，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
规则引擎Drools 之 springboot 集成、热加载
12-22
前言：   如果对drools还不是特别熟悉的，可以看下 《规则引擎Drools 之 初识drools》这篇文章；   本文源码，github 传送门：https://github.com/vincent9309/drools：   系统架构如下： 二、项目目录结构 三、springboot集成drools  1.pom文件引入依赖 org.drools drools-core 7.0.0.Final org.drools drools-compiler 7.0.0.Final org.drools drools-decisiontabl
springboot-drools
04-25
springboot 与drools整合——本代码中实现了简单的spring boot与drools整合的简单实例
springboot集成drools实现重新加载规则
08-02
springboot集成drools实现重新加载规则
SpringBoot集成Drools
人不风流枉少年
08-18 435
规则引擎全称为业务规则管理系统（Business Rule Manage System），英文名为BRMS，其实就是将计算逻辑写在脚本中，通过Java调用脚本获取计算结果，目的是。一般脚本都是非编译型的，这就意味着脚本随时改随时生效，不需要重启服务，也就是计算逻辑可以随时动态调整，这是将计算逻辑硬编码到Java中所达不到的实时生效的效果。应用场景：计算逻辑改动比较频繁，计算逻辑可以让业务人员在页面上任意配。是使用最广泛并且开源的规则引擎。Drools最大的特点是在脚本中可以写Java代码。
springboot项目整合Drools实战问题
shenyu0009csdn的博客
04-11 420
SpringBoot项目整合Drools实战问题 java.lang.IllegalStateException: Failed to load ApplicationContext
Spring Boot集成Drools规则引擎
m0_71777195的博客
03-24 579
Drools 是一个基于Charles Forgy’s的RETE算法的，易于访问企业策略、易于调整以及易于管理的开源业务规则引擎，符合业内标准，速度快、效率高。业务分析师人员或审核人员可以利用它轻松查看业务规则，从而检验是否已编码的规则执行了所需的业务规则。本文详细Spring Boot集成Drools，但是存在如下问题drools规则文件需要和业务工程进行分离，目前是耦合在同一项目中。业务人员如何动态编写业务规则？关于这些问题将在后续的文章中进行详细讲解。
springboot整合drools
06-28
### 回答1： Spring Boot是一个快速开发的框架，而Drools是一个规则引擎，可以用于业务规则的管理和执行。将两者整合可以实现更加灵活的业务逻辑控制。 具体实现步骤如下： 1. 引入Drools依赖 在pom.xml文件中添加Drools的依赖： ``` <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>7.54..Final</version> </dependency> ``` 2. 创建Drools规则文件 在resources目录下创建一个名为rules的文件夹，用于存放Drools规则文件。例如，创建一个名为rule.drl的文件，内容如下： ``` package com.example.rule rule "rule1" when $p : Person(age > 18) then System.out.println("Hello, " + $p.getName() + "!"); end ``` 3. 创建Drools配置类 创建一个Drools配置类，用于加载Drools规则文件和创建Drools的KieSession。例如： ``` @Configuration public class DroolsConfig { @Autowired private KieFileSystem kieFileSystem; @Autowired private KieRepository kieRepository; @Autowired private KieBuilder kieBuilder; @Autowired private KieContainer kieContainer; @PostConstruct public void init() { try { kieFileSystem.write(ResourceFactory.newClassPathResource("rules/rule.drl")); kieBuilder.buildAll(); } catch (Exception e) { e.printStackTrace(); } } @Bean public KieFileSystem kieFileSystem() { return KieServices.Factory.get().newKieFileSystem(); } @Bean public KieRepository kieRepository() { return KieServices.Factory.get().getRepository(); } @Bean public KieBuilder kieBuilder() { return KieServices.Factory.get().newKieBuilder(kieFileSystem()); } @Bean public KieContainer kieContainer() { return KieServices.Factory.get().newKieContainer(kieRepository().getDefaultReleaseId()); } @Bean public KieSession kieSession() { return kieContainer().newKieSession(); } } ``` 4. 创建业务类 创建一个业务类，例如Person类，用于测试Drools规则的执行。例如： ``` public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } ``` 5. 测试Drools规则的执行 在Controller中注入KieSession，然后创建一个Person对象，将其插入到KieSession中，最后执行KieSession的fireAllRules方法，即可执行Drools规则。例如： ``` @RestController public class TestController { @Autowired private KieSession kieSession; @GetMapping("/test") public String test() { Person person = new Person("Tom", 20); kieSession.insert(person); kieSession.fireAllRules(); return "success"; } } ``` 以上就是Spring Boot整合Drools的基本步骤。 ### 回答2： Spring Boot与Drools的整合是在实现业务规则引擎方面非常有用的一种方式。Spring Boot是一个基于Spring框架的快速开发应用程序的工具，而Drools则是一款常用的业务规则引擎，通过它可以轻松实现业务逻辑的灵活处理。 整合Spring Boot与Drools Spring Boot使用Java语言进行开发，而Drools使用DRL（Drools Rule Language）语言进行业务规则的编写。在整合的过程中，我们需要定义规则的模型，创建Drools的KieSession，将模型与规则引擎进行交互。具体步骤如下： 1. 引入依赖 在pom.xml文件中添加Drools的依赖，如下所示： ``` <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>7.37.0.Final</version> </dependency> ``` 2. 定义规则模型 使用DRL语言定义业务规则的模型，如下所示： ``` package com.example.droolsdemo import com.example.droolsdemo.Person import com.example.droolsdemo.Result rule "Person age rule" when $p: Person(age > 18) then Result result = new Result(); result.setMessage("You are an adult now!"); insert(result); System.out.println(result.toString()); end ``` 3. 加载规则 在启动Spring Boot应用程序时，从DRL文件中加载规则并创建KieSession，以便后续与规则引擎进行交互。示例如下： ``` @Autowired private KieContainer kieContainer; public KieSession getKieSession () { KieSession kieSession = kieContainer.newKieSession(); kieSession.getAgenda().getAgendaGroup("person-group").setFocus(); return kieSession; } ``` 4. 执行规则 在业务逻辑中调用上述方法获取KieSession，使用Drools提供的API执行对应的规则。示例代码如下： ``` KieSession kieSession = getKieSession(); Person person = new Person(); person.setAge(20); kieSession.insert(person); kieSession.fireAllRules(); ``` 总结 Spring Boot和Drools是两个非常强大的工具，在进行业务规则引擎整合时，可以让规则引擎的开发更加快速和灵活。通过上述方法，可以使用Spring Boot轻松实现Drools的加载和规则执行，提高产品质量、业务效率和效益。 ### 回答3： Drools是一个规则引擎，用于逻辑推理和复杂的事件处理。而Spring Boot是现代化的Java开发框架，它提供了快速开发应用程序所需的所有组件，包括自动配置、依赖注入等。将这两个框架整合起来可以帮助我们快速开发具有复杂业务逻辑的应用程序。 Spring Boot和Drools的整合需要以下步骤： 1. 添加Drools的依赖项到Spring Boot项目中。 2. 创建一个Drools配置文件，Drools的规则定义在该文件中。 3. 在Spring Boot应用程序中创建一个Drools的会话，用于执行规则。 4. 将对象（Fact）插入到Drools会话中，并执行规则。 下面是一个Spring Boot程序整合Drools的简单例子： 首先，在Spring Boot项目中添加Drools的Maven依赖项，可以在pom.xml文件中添加以下内容： ``` <dependency> <groupId>org.kie</groupId> <artifactId>kie-ci</artifactId> <version>7.0.0.Final</version> </dependency> ``` 接下来，在项目中创建一个Drools的配置文件，例如rules.drl文件，用于定义规则。在该文件中，可以定义所有需要执行的规则。例如： ``` rule "discount rule" when $order : Order(discount == 0) then $order.setDiscount(10); update($order); end ``` 然后，在Spring Boot应用程序中创建一个Drools会话，用于执行规则。示例代码如下： ``` @Service public class DroolsService { KieSession kieSession; @Autowired public DroolsService(KieContainer kieContainer) { kieSession = kieContainer.newKieSession(); } public void execute(Order order) { kieSession.insert(order); kieSession.fireAllRules(); } } ``` 如上所述，我们在DroolsService类中创建了一个Drools会话对象，并将要执行的对象（Fact）插入到该会话中。然后，我们执行规则（fireAllRules()）来处理订单对象并更新它。 最后，在Spring Boot应用程序中调用DroolsService对象的execute方法，传递要执行规则的对象。例如： ``` @RestController @RequestMapping("/order") public class OrderController { @Autowired private DroolsService droolsService; @PostMapping("/discount") public Order applyDiscount(@RequestBody Order order) { droolsService.execute(order); return order; } } ``` 如上所述，我们在OrderController类中定义了一个applyDiscount方法，用于接收订单对象并调用DroolsService对象的execute方法，来处理订单并更新它。最后返回处理后的订单对象。 总而言之，使用Spring Boot整合Drools，可以让我们快速开发具有复杂业务逻辑的应用程序。将Drools的规则引擎和Spring Boot的自动配置、依赖注入等特性结合起来，可以有效地提高代码的可维护性和可扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值