微内核（插件式）架构在JAVA业务开辟中的应用

前言

    微内核这个词一听就好像是操纵体系层面的东西，不过我个人觉得这种架构思想也可以应用在java的一样平常业务开辟中，本文就以我对微内核架构的理解，讨论一下微内核架构在java业务开辟中怎样应用，也当作是自己的一个学习过程，说的不对的，希望各位大佬指正。
什么是微内核

    微内核（Micro kernel）是提供操纵体系焦点功能的内核的精简版本，它设计成在很小的内存空间内增加移植性，提供模块化设计，以利用户安装不同的接口，如DOS、Workplace OS、Workplace UNIX等。IBM、Microsoft、开放软件基金会(OSF)和UNIX体系实验室(USL)、鸿蒙OS等新操纵体系都采用了这一研究成果的优点。
    以上是来自百度百科的解释。我说一下我的理解，微内核架构，还有另外一个叫法：插件式架构。与微内核架构相反的，是宏内核架构，按我的理解，宏内核结构就是把所有业务都放到一个地方执行，而微内核架构是将不同的业务交给不同的插件去做，内核负责管理插件、调度插件和消息传递。两者各有什么优缺点呢？
    宏内核：业务间相互影响，一个业务出问题，可能影响整个内核，面临个性化需求，会有代码堆叠和难维护的问题。正常来说，它的性能会比微内核要快。
    微内核：高度灵活，业务由插件去处理，可以根据必要加载不同插件以适应不同的需求，乃至可以对插件次序灵活调整。但是性能会比宏内核要差，内存开销也会比宏内核高。
微内核的角色：

   一、 内核：根本不包含业务代码，只有少量和内核有关的代码，一旦完成，几乎不会再有变更。
    内核的职责：

• 插件管理：负责管理插件的生命周期，好比插件的注册、加载、卸载等。
  
• 插件链接：我的理解，其实就是调用插件提供的服务。
  
• 插件通信：负责在插件间传递信息。
  

    二、插件：真正负责处理业务的模块，有高度内聚的特点，每个插件尽量独立，不依赖其他模块、插件等。

Java代码模拟微内核架构：

定内核规范：

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. import java.util.*;
7. /**
8. * 类描述：
9. * 核心服务类
10. *  微内核架构（插件式架构）
11. *  本类为内核，职责是：
12. *  1、插件管理：插件的注册、加载、卸载等。
13. *  2、插件连接：指插件链接到核心，按照插件接口规范，由核心调用插件接口进行使用
14. *  3、插件通信：由核心作为通信中介，在插件之间传递信息
15. * @Author: dyc
16. * @Date:2024/5/6 15:58
17. */
18. public abstract class CoreService {
20.     //注册表
21.     LinkedHashSet<String> registerTable;
23.     // 插件池
24.     Map<String,Plugin> pluginPool;
27.     /**
28.      * 插件注册
29.      * @param pluginKey 插件的完整类名
30.      */
31.     public void registerPlugin(String pluginKey) {
32.         if (registerTable==null) {
33.             registerTable = new LinkedHashSet<>();
34.         }
35.         if (registerTable.contains(pluginKey)) {
36.             //已经注册过，不再重复注册，如果允许重复注册的话，此处不需要
37.             return;
38.         }
39.         registerTable.add(pluginKey);
40.     }
42.     /**
43.      * 加载插件
44.      * @throws Exception
45.      */
46.     public void loadPlugins() throws Exception {
47.         for (String key:registerTable) {
48.             try {
49.                 //获取类信息
50.                 Class cla = Class.forName(key);
51.                 //获取实例对象
52.                 Plugin plugin = (Plugin)cla.newInstance();
53.                 if (pluginPool==null) {
54.                     pluginPool = new HashMap<>();
55.                 }
56.                 //加载
57.                 pluginPool.put(key,plugin);
58.             } catch (Exception e) {
59.                 e.printStackTrace();
60.                 throw new Exception("加载插件【"+key+"】失败");
61.             }
62.         }
63.     }
65.     /**
66.      * 卸载插件
67.      * @param key 插件名称，插件的完整类名
68.      */
69.     public void unloadPlugin(String key) {
70.         registerTable.remove(key);
71.         pluginPool.remove(key);
72.     }
74.     /**
75.      * 卸载全部插件
76.      */
77.     public void unloadPlugins() {
78.         registerTable.clear();
79.         pluginPool.clear();
80.     }
82.     /**
83.      * 执行
84.      * 抽象此方法，是为了让子类能更加灵活
85.      * @param param
86.      * @return
87.      */
88.     public abstract JSONObject execute(JSONObject param);
90. }

复制代码

定插件规范：

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. /**
6. * 接口描述：
7. * 插件接口，可以理解为为所有插件制定了一套统一的规范
8. * 职责：真正负责具体业务的地方
9. * 建议实现此接口的类要高度内聚，尽量减少对其他类的依赖
10. *
11. * @Author: dyc
12. * @Date:2024/5/6 16:00
13. */
14. public interface Plugin {
16.     /**
17.      * 执行方法（干活的地方）
18.      * @param param 方法需要用到的参数
19.      * @param info 需要在插件之间传递的信息
20.      * @return 返回值
21.      */
22.     public JSONObject execute(JSONObject param,JSONObject info);
24. }

复制代码

随便写两个插件实现：

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. /**
6. * 类描述：
7. * 检查插件
8. * @Author: dyc
9. * @Date:2024/5/6 16:37
10. */
11. public class CheckPlugin implements Plugin{
14.     @Override
15.     public JSONObject execute(JSONObject param, JSONObject info) {
16.         //取用参数
17.         System.out.println("参数："+param);
18.         //取用通信信息
19.         System.out.println("上一个插件要传递的信息："+info);
20.         //执行具体逻辑
21.         System.out.println("我是CheckPlugin");
22.         //给下一个插件传递信息
23.         info.put("msg","我是checkPlugin要传递的信息");
24.         JSONObject res = new JSONObject();
25.         res.put("code",1);//1表示成功
26.         res.put("msg","成功");
27.         return res;
28.     }
29. }

复制代码

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. /**
6. * 类描述：
7. * 执行插件
8. * @Author: dyc
9. * @Date:2024/5/6 16:37
10. */
11. public class ExecutePlugin implements Plugin{
14.     @Override
15.     public JSONObject execute(JSONObject param, JSONObject info) {
16.         //取用参数
17.         System.out.println("参数："+param);
18.         //取用通信信息
19.         System.out.println("上一个插件要传递的信息："+info);
20.         //执行具体逻辑
21.         System.out.println("我是 ExecutePlugin");
22.         //给下一个插件传递信息
23.         info.put("msg","我是 ExecutePlugin 要传递的信息");
24.         JSONObject res = new JSONObject();
25.         res.put("code",1);//1表示成功
26.         res.put("msg","成功");
27.         return res;
28.     }
29. }

复制代码

写一个内核继续类：

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. /**
6. * 类描述：
7. * 继承内核服务，真正使用内核服务的地方
8. * @Author: dyc
9. * @Date:2024/5/6 16:44
10. */
11. public class DemoCoreService extends CoreService {
15.     @Override
16.     public JSONObject execute(JSONObject param) {
17.         //返回值
18.         JSONObject res = null;
19.         //按照一般的业务接口，流程一般是这样的：检查->执行
20.         //按顺序注册
21.         this.registerPlugin("com.example.demo.core.CheckPlugin");
22.         this.registerPlugin("com.example.demo.core.ExecutePlugin");
23.         //加载
24.         try {
25.             this.loadPlugins();
26.         } catch (Exception e) {
27.             res = new JSONObject();
28.             res.put("code",-1);//-1失败
29.             res.put("msg",e.getMessage());
30.             return res;
31.         }
32.         //执行
33.         JSONObject pluginInfo = new JSONObject();//插件通信信息
34.         for (String key:registerTable) {
35.             Plugin plugin = pluginPool.get(key);
36.             res = plugin.execute(param,pluginInfo);
37.             if (1!=res.getIntValue("code")) {
38.                 return res;
39.             }
40.         }
41.         return res;
42.     }
43. }

复制代码

调用测试：

1. package com.example.demo.core;
3. import com.alibaba.fastjson.JSONObject;
5. /**
6. * 类描述：
7. * 调用测试
8. * @Author: dyc
9. * @Date:2024/5/6 16:57
10. */
11. public class Test {
13.     public static void main(String[] args) {
14.         //调用测试
15.         DemoCoreService demo = new DemoCoreService();
16.         demo.execute(new JSONObject());
17.     }
19. }

复制代码

 收尾

        以上只是我按照自己的理解写的一种最简单的实现，其实还可以优化，好比注册插件可以采用数据库设置等方式增加灵活性，还可以在execute增加事务控制，增加插件革新接口等，能优化的地方还许多，我这里只是展示一下“微内核”架构的一种思想。真正业务用到的时候再去丰富它们。如果有什么不对的，欢迎指正，谢谢。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。