ChopperBot
  • 指南
  • 开发指南
  • 快速开发
Genius
2023-07-31
目录

模块与插件

# 模块与插件 Module & Plugin

说明

ChopperBot是由多个模块组成的，模块中又包含了各种各样的插件。每一个模块和插件都有着自己的启动器，插件由插件注册表进行管理，同时配置文件的pluginStart管理着 插件的开机启动，在项目运行的过程中，插件可以随时开启随时启动（依赖插件启动的前提下）。模块和插件时ChopperBot的灵魂，我们来详细了解如何编写创建一个自己的模块和插件

什么是依赖?

在ChopperBot中有许多的插件，而有些插件需要依赖另一个插件的功能，此时这两个插件便构成了依赖关系。
在ChopperBot中依赖是插件很重要的关联，它决定了一个插件的开启，关闭以及启动顺序。一旦出现依赖插件缺少或者循环依赖都会导致 ChopperBot停止该插件的运行。

# 启动器 InitMachine

每个插件和模块都拥有着属于自己的启动器，而使用启动器启动的好处有以下几点：

  1. 对插件进行依赖检测
  2. 插件启动日志声明
  3. 为插件提供了出生到死亡的一条龙方法
  • 模块启动器需要继承ModuleInitMachine
  • 插件启动器需要继承CommonInitMachine

# InitMachine通用方法介绍

方法名 方法介绍
init() boolean 初始化操作
afterInit() void 初始化之后进行的操作(在整个项目启动时，是在所有模块启动完后才会执行)
shutdown() void 关闭操作

# 模块

# 模块的创建

模块的创建很简单，只需简单的遵循以下两步~

  • 在当前的项目下创建 init/module 文件夹，在文件夹下创建模块启动类
+-- 模块
|   +-- init
|   |  +-- module
|   |  |  +-- 模块启动类
1
2
3
4
  • 继承ModuleInitMachine
public class GeniusModuleInitMachine extends ModuleInitMachine {
    
    //这里要是无参构造函数
    public GeniusModuleInitMachine() {
        super(
                List.of(ConstPool.FILE),                        // 依赖的模块名称
                ChopperLogFactory.getLogger("Genius"),          // 依赖的模块日志名称
                "Genius"                                        // 模块名称
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11

只需这两步，在启动项目后会自动检测到该模块，并进行模块的启动队列中，十分方便🎉~

# 插件

# 插件的种类

目前ChopperBot的插件类型分为三种:

插件类型 插件类 说明
普通插件 CommonPlugin ChopperBot最为常见的插件，和MC中的泥土一样常见，如果没有特殊需求就使用它
守卫插件 GuardPlugin 守卫插件指的是，单线程且需要不停运行的插件，该插件将放入系统的守卫线程池ChopperBotGuardPool运行
文件插件 ConfigFile ChopperBot中的文件，继承该类后，进行插件初始化将自动创建并放入FileCacheManager进行管理
文件插件 SpringBootPlugin 基于SpringBoot自动注入初始化的插件

# 插件的创建

插件的创建分为两个大步骤:1,插件的编写 2,插件启动器的编写

# 1,CommonPlugin的创建

  • 构造方法目前必须重写，而且参数顺序不能变，也不能增加
  • 重写初始化操作，把插件各个参数的初始化放入init或者放入构造方法都可
public class GeniusPlugin extends CommonPlugin {
    //重写构造方法 且参数顺序不能变
    public GeniusPlugin(String module, String pluginName, List<String> needPlugins, boolean isAutoStart) {
        super(module, pluginName, needPlugins, isAutoStart);
    }
    
    //初始化操作
    @Override
    public boolean init() {
        
    }
    
    //关闭操作
    @Override
    public void shutdown() {
    }
    
    //初始化后的操作
    @Override
    public void afterInit() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 2,GuardPlugin的创建

GuardPlugin

GuardPlugin插件启动后，会自动交给到ChopperBotGuardPool运行，正因为此时它的运行时机和关闭机制都要与其他的插件不同，主要由以下参数控制

参数 参数说明
isStop 负责关闭在线程池中运行的GuardPlugin插件
afterDo false是在初始化的时候就运行,true在初始化结束后才运行
  • 构造方法目前必须重写，而且参数顺序不能变，也不能增加
  • 重写初始化操作，把插件各个参数的初始化放入init或者放入构造方法都可，需要使用父类的init()
  • 重写start方法，不需要在方法上嵌套while循环，GuardPlugin自带了
start(){
    print()
}
同等于
while{
    print() 
}
1
2
3
4
5
6
7
  • 如果要重写shutdown方法，需要调用父类的shutdown()
public class GeniusGuardPlugin extends GuardPlugin {
    public GeniusGuardPlugin(String module, String pluginName, List<String> needPlugins, boolean isAutoStart) {
        super(module, pluginName, needPlugins, isAutoStart);
        //afterDo = true; 初始化后运行
    }

    //初始化操作。重写时请使用父类的init
    @Override
    public boolean init() {
        super.init();
        //代码
    }
    
    //运行方法，ChopperBotGuardPool将会不断运行这个方法
    @Override
    public void start(){
        
    }

    //关闭操作,请使用父类的shutdown，或者自行进行isStop的更改
    @Override
    public void shutdown() {
        super.shutdown();
        //代码
    }
    
    //初始化后操作，请使用父类afterInit()
    @Override
    public void afterInit() {
        super.afterInit();
        //代码
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 3,ConfigFile的创建

配置文件插件运用很简单，关于具体配置文件该如何定义请见配置文件 👈

public class GeniusConfigFile extends ConfigFile<数据类型> {
    public GeniusConfigFile(String module, String pluginName, List<String> needPlugins, boolean isAutoStart) {
        super(module,pluginName,needPlugins,isAutoStart
                ,filePath, fileName,//文件路径 文件名
                Map.of("taskCenter",new TaskCenterConfig(10,50,1000)),  //文件内容
                FileType.CREEPER);  //文件类型
    }
}
1
2
3
4
5
6
7
8

# 4,SpringBootPlugin的创建

SpringBootPlugin顾名思义就是可以兼容SpringBoot框架下的一系列注解的插件，让ChopperBotPlugin使用更加自由，摒弃了笨重的构造方法后，初始化更加方便。 注意: SpringBootPlugin启动器与其他插件不同


@Component
public class Plugin extends SpringBootPlugin {
    @Override
    public boolean init() {
        //代码
    }
}
1
2
3
4
5
6
7
8

# 启动器创建

# CommonInitMachine

适用插件

适用于CommonPlugin,GuardPlugin,ConfigFile插件的启动器

启动器的创建分为两步骤

  • 继承CommonInitMachine
  • 重写构造方法
  • 表上Plugin注解
@Plugin(moduleName = 所属模块名,
        pluginName = 插件名称,
        pluginName_CN = 插件中文名(不必要),
        pluginDescription = 插件描述(不必要),
        needPlugin = {所依赖的插件},
        pluginClass= 要初始化的插件类 )
public class HotGuardInitMachine extends CommonInitMachine {


    public HotGuardInitMachine(List<String> needPlugins, boolean isAutoStart, String moduleName, String name, Class<? extends CommonPlugin> clazz) {
        super(needPlugins, isAutoStart, moduleName, name, clazz);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
  • 如果需要重写init(),afterInit(),shutdown()。请在其中使用super中对应的方法。

# SpringPluginInitMachine

适用插件

适用于SpringBootPlugin插件的启动器

@Plugin(moduleName = 所属模块名,
        pluginName = 插件名称,
        needPlugin = {所依赖的插件},
        pluginName_CN = 插件中文名(不必要),
        pluginDescription = 插件描述(不必要),
        pluginClass= 要初始化的插件类,
        springBootPlugin = true
)
@Component
public class PluginInitMachine extends SpringPlugInitMachine{


}
1
2
3
4
5
6
7
8
9
10
11
12
13
  • 如果需要重写init(),afterInit(),shutdown()。请在其中使用super中对应的方法。

# 插件注册表

ChopperBot中的所有插件信息，都存放在InitPluginRegister全局类中，我们可以使用一些方法获取插件信息

//获得全部插件
InitPluginRegister.allPlugin;
//获取某模块下所有插件
InitPluginRegister.modulePlugin.get(模块名);

//获取某插件的所有子插件
InitPluginRegister.fatherAndSonPlugin.get(插件名);

//获得某插件自身模块下的所有子插件
InitPluginRegister.moduleFatherAndSonPlugin.get(插件名);

//判断插件是否注册
InitPluginRegister.isRegister(插件名);

//获取正在运行的插件
InitPluginRegister.getPlugin插件名);

//注册插件
InitPluginRegister.register(CommonInitMachine);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 其他用法

# PluginCheckAndDo

PluginCheckAndDo

有的插件可能在某些插件启动时有不同的功能，为了检测目标插件是否存在，并根据存在情况使用不同的方法，你可以使用PluginCheckAndDo工具类下的以下方法

方法名 参数介绍 方法介绍
CheckAndDo success(成功后的方法函数),pluginName:String(检查的插件名) 检查插件是否存在，存在则进行success操作
CheckAndDo success(成功后的方法函数),fail(失败后的方法函数),pluginName:String(检查的插件名) 检查插件是否存在，存在则进行success操作，否正进行fail操作
CheckAndGet success(成功后的方法函数),pluginName:String(检查的插件名),resClazz:Class(返回值的类型) 检查插件是否存在，存在则进行success操作，并返回值
  • CheckAndDo
 PluginCheckAndDo.CheckAndDo(
        (plugin)->{
            //存在时执行的方法
        },
        ()->{
            //不存在时执行的方法
        },
        pluginName
);
1
2
3
4
5
6
7
8
9
  • CheckAndGet
PluginCheckAndDo.CheckAndGet(
        (plugin)->{
            //存在时执行的方法
          return new User();
        },
       pluginName,User.class
);
1
2
3
4
5
6
7
帮助我们改善此页面！ (opens new window)
上次更新: 2023/08/31, 18:25:32
系统架构
如何编写爬虫

← 如何编写爬虫→

Theme by Vdoing | Copyright © 2016-2023 TimeMachine Lab | Sponsored by JetBrains | 渝ICP备2021000141号-1

友情链接：GeniusBlog