文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

一文读懂微内核架构

2024-12-03 14:31

关注

本文转载自微信公众号「 JAVA日知录」,作者 JAVA日知录 。转载本文请联系 JAVA日知录公众号。

什么是微内核架构?

微内核是一种典型的架构模式 ,区别于普通的设计模式,架构模式是一种高层模式,用于描述系统级的结构组成、相互关系及相关约束。微内核架构在开源框架中的应用非常广泛,比如常见的 ShardingSphere 还有Dubbo都实现了自己的微内核架构。那么,在介绍什么是微内核架构之前,我们有必要先阐述这些开源框架会使用微内核架构的原因。

为什么要使用微内核架构?

微内核架构本质上是为了提高系统的扩展性 。所谓扩展性,是指系统在经历不可避免的变更时所具有的灵活性,以及针对提供这样的灵活性所需要付出的成本间的平衡能力。也就是说,当在往系统中添加新业务时,不需要改变原有的各个组件,只需把新业务封闭在一个新的组件中就能完成整体业务的升级,我们认为这样的系统具有较好的可扩展性。

就架构设计而言,扩展性是软件设计的永恒话题。而要实现系统扩展性,一种思路是提供可插拔式的机制来应对所发生的变化。当系统中现有的某个组件不满足要求时,我们可以实现一个新的组件来替换它,而整个过程对于系统的运行而言应该是无感知的,我们也可以根据需要随时完成这种新旧组件的替换。

比如在 ShardingSphere 中提供的分布式主键功能,分布式主键的实现可能有很多种,而扩展性在这个点上的体现就是, 我们可以使用任意一种新的分布式主键实现来替换原有的实现,而不需要依赖分布式主键的业务代码做任何的改变 。

微内核架构模式为这种实现扩展性的思路提供了架构设计上的支持,ShardingSphere 基于微内核架构实现了高度的扩展性。在介绍如何实现微内核架构之前,我们先对微内核架构的具体组成结构和基本原理做简要的阐述。

什么是微内核架构?

从组成结构上讲, 微内核架构包含两部分组件:内核系统和插件 。这里的内核系统通常提供系统运行所需的最小功能集,而插件是独立的组件,包含自定义的各种业务代码,用来向内核系统增强或扩展额外的业务能力。在 ShardingSphere 中,前面提到的分布式主键就是插件,而 ShardingSphere 的运行时环境构成了内核系统。

那么这里的插件具体指的是什么呢?这就需要我们明确两个概念,一个概念就是经常在说的 API ,这是系统对外暴露的接口。而另一个概念就是 SPI(Service Provider Interface,服务提供接口),这是插件自身所具备的扩展点。就两者的关系而言,API 面向业务开发人员,而 SPI 面向框架开发人员,两者共同构成了 ShardingSphere 本身。

可插拔式的实现机制说起来简单,做起来却不容易,我们需要考虑两方面内容。一方面,我们需要梳理系统的变化并把它们抽象成多个 SPI 扩展点。另一方面, 当我们实现了这些 SPI 扩展点之后,就需要构建一个能够支持这种可插拔机制的具体实现,从而提供一种 SPI 运行时环境 。

如何实现微内核架构?

事实上,JDK 已经为我们提供了一种微内核架构的实现方式,就是JDK SPI。这种实现方式针对如何设计和实现 SPI 提出了一些开发和配置上的规范,ShardingSphere、Dubbo 使用的就是这种规范,只不过在这基础上进行了增强和优化。所以要理解如何实现微内核架构,我们不妨先看看JDK SPI 的工作原理。

JDK SPI

SPI(Service Provider Interface)主要是被框架开发人员使用的一种技术。例如,使用 Java 语言访问数据库时我们会使用到 java.sql.Driver 接口,不同数据库产品底层的协议不同,提供的 java.sql.Driver 实现也不同,在开发 java.sql.Driver 接口时,开发人员并不清楚用户最终会使用哪个数据库,在这种情况下就可以使用 Java SPI 机制在实际运行过程中,为 java.sql.Driver 接口寻找具体的实现。

下面我们通过一个简单的示例演示一下JDK SPI的使用方式:

首先我们定义一个生成id键的接口,用来模拟id生成

  1. public interface IdGenerator { 
  2.      
  3.     String generateId(); 

然后创建两个接口实现类,分别用来模拟uuid和序列id的生成

  1. public class UuidGenerator implements IdGenerator { 
  2.     @Override 
  3.     public String generateId() { 
  4.         return UUID.randomUUID().toString(); 
  5.     } 
  6.  
  7. public class SequenceIdGenerator implements IdGenerator { 
  8.     private final AtomicLong atomicId = new AtomicLong(100L); 
  9.     @Override 
  10.     public String generateId() { 
  11.         long leastId = this.atomicId.incrementAndGet(); 
  12.         return String.valueOf(leastId); 
  13.     } 

在项目的resources/META-INF/services 目录下添加一个名为com.github.jianzh5.spi.IdGenerator的文件,这是 JDK SPI 需要读取的配置文件,内容如下:

  1. com.github.jianzh5.spi.impl.UuidGenerator 
  2. com.github.jianzh5.spi.impl.SequenceIdGenerator 

创建main方法,让其加载上述的配置文件,创建全部IdGenerator 接口实现的实例,并执行生成id的方法。

  1. public class GeneratorMain { 
  2.     public static void main(String[] args) { 
  3.         ServiceLoader serviceLoader = ServiceLoader.load(IdGenerator.class); 
  4.         Iterator iterator = serviceLoader.iterator(); 
  5.         while(iterator.hasNext()){ 
  6.             IdGenerator generator = iterator.next(); 
  7.             String id = generator.generateId(); 
  8.             System.out.println(generator.getClass().getName() + "  >>id:" + id); 
  9.         } 
  10.     } 

执行结果如下:

JDK SPI 源码分析

通过上述示例,我们可以看到 JDK SPI 的入口方法是 ServiceLoader.load() 方法,在这个方法中首先会尝试获取当前使用的 ClassLoader,然后调用 reload() 方法,调用关系如下图所示:

调用关系

在 reload() 方法中,首先会清理 providers 缓存(LinkedHashMap 类型的集合),该缓存用来记录 ServiceLoader 创建的实现对象,其中 Key 为实现类的完整类名,Value 为实现类的对象。之后创建 LazyIterator 迭代器,用于读取 SPI 配置文件并实例化实现类对象。

  1. public void reload() { 
  2.  providers.clear(); 
  3.  lookupIterator = new LazyIterator(service, loader); 

在前面的示例中,main() 方法中使用的迭代器底层就是调用了 ServiceLoader.LazyIterator 实现的。Iterator 接口有两个关键方法:hasNext() 方法和 next() 方法。这里的 LazyIterator 中的 next() 方法最终调用的是其 nextService() 方法,hasNext() 方法最终调用的是 hasNextService() 方法,我们来看看 hasNextService()方法的具体实现:

  1. private static final String PREFIX = "META-INF/services/";  
  2. Enumeration configs = null;  
  3. Iterator pending = null;  
  4. String nextName = null;  
  5. private boolean hasNextService() { 
  6.  if (nextName != null) { 
  7.   return true
  8.  } 
  9.  if (configs == null) { 
  10.   try { 
  11.    //META-INF/services/com.github.jianzh5.spi.IdGenerator 
  12.    String fullName = PREFIX + service.getName(); 
  13.    if (loader == null
  14.     configs = ClassLoader.getSystemResources(fullName); 
  15.    else 
  16.     configs = loader.getResources(fullName); 
  17.   } catch (IOException x) { 
  18.    fail(service, "Error locating configuration files", x); 
  19.   } 
  20.  } 
  21.  // 按行SPI遍历配置文件的内容  
  22.  while ((pending == null) || !pending.hasNext()) { 
  23.   if (!configs.hasMoreElements()) { 
  24.    return false
  25.   } 
  26.   // 解析配置文件  
  27.   pending = parse(service, configs.nextElement()); 
  28.  } 
  29.  // 更新 nextName字段  
  30.  nextName = pending.next(); 
  31.  return true

在 hasNextService() 方法中完成 SPI 配置文件的解析之后,再来看 LazyIterator.nextService() 方法,该方法「负责实例化 hasNextService() 方法读取到的实现类」,其中会将实例化的对象放到 providers 集合中缓存起来,核心实现如下所示:

  1. private S nextService() {  
  2.     String cn = nextName;  
  3.     nextName = null;  
  4.     // 加载 nextName字段指定的类  
  5.     Class c = Class.forName(cn, false, loader);  
  6.     if (!service.isAssignableFrom(c)) { // 检测类型  
  7.         fail(service, "Provider " + cn  + " not a subtype");  
  8.     }  
  9.     S p = service.cast(c.newInstance()); // 创建实现类的对象  
  10.     providers.put(cn, p); // 将实现类名称以及相应实例对象添加到缓存  
  11.     return p;  
  12. }  

以上就是在 main() 方法中使用的迭代器的底层实现。最后,我们再来看一下 main() 方法中使用 ServiceLoader.iterator() 方法拿到的迭代器是如何实现的,这个迭代器是依赖 LazyIterator 实现的一个匿名内部类,核心实现如下:

  1. public Iterator iterator() {  
  2.     return new Iterator() {  
  3.         // knownProviders用来迭代providers缓存  
  4.         Iterator> knownProviders  
  5.             = providers.entrySet().iterator();  
  6.         public boolean hasNext() {  
  7.             // 先走查询缓存,缓存查询失败,再通过LazyIterator加载  
  8.             if (knownProviders.hasNext())   
  9.                 return true;  
  10.             return lookupIterator.hasNext();  
  11.         }  
  12.         public S next() {  
  13.             // 先走查询缓存,缓存查询失败,再通过 LazyIterator加载  
  14.             if (knownProviders.hasNext())  
  15.                 return knownProviders.next().getValue();  
  16.             return lookupIterator.next();  
  17.         }  
  18.         // 省略remove()方法  
  19.     };  
  20. }  

JDK SPI 在 JDBC 中的应用

了解了 JDK SPI 实现的原理之后,我们再来看实践中 JDBC 是如何使用 JDK SPI 机制加载不同数据库厂商的实现类。

JDK 中只定义了一个 java.sql.Driver 接口,具体的实现是由不同数据库厂商来提供的。这里我们就以 MySQL 提供的 JDBC 实现包为例进行分析。

在 mysql-connector-java-*.jar 包中的 META-INF/services 目录下,有一个 java.sql.Driver 文件中只有一行内容,如下所示:

  1. com.mysql.cj.jdbc.Driver 

在使用 mysql-connector-java-*.jar 包连接 MySQL 数据库的时候,我们会用到如下语句创建数据库连接:

  1. String url = "jdbc:xxx://xxx:xxx/xxx";  
  2. Connection conn = DriverManager.getConnection(url, username, pwd);  

「DriverManager 是 JDK 提供的数据库驱动管理器」,其中的代码片段,如下所示:

  1. static {  
  2.     loadInitialDrivers(); 
  3.     println("JDBC DriverManager initialized");  
  4. }  

在调用 getConnection() 方法的时候,DriverManager 类会被 Java 虚拟机加载、解析并触发 static 代码块的执行;在 loadInitialDrivers()方法中通过 JDK SPI 扫描 Classpath 下 java.sql.Driver 接口实现类并实例化,核心实现如下所示:

  1. private static void loadInitialDrivers() {  
  2.     String drivers = System.getProperty("jdbc.drivers")  
  3.     // 使用 JDK SPI机制加载所有 java.sql.Driver实现类  
  4.     ServiceLoader loadedDrivers =   
  5.            ServiceLoader.load(Driver.class);  
  6.     Iterator driversIterator = loadedDrivers.iterator();  
  7.     while(driversIterator.hasNext()) {  
  8.         driversIterator.next();  
  9.     }  
  10.     String[] driversList = drivers.split(":");  
  11.     for (String aDriver : driversList) { // 初始化Driver实现类  
  12.         Class.forName(aDriver, true,  
  13.             ClassLoader.getSystemClassLoader());  
  14.     }  
  15. }  

在 MySQL 提供的 com.mysql.cj.jdbc.Driver 实现类中,同样有一段 static 静态代码块,这段代码会创建一个 com.mysql.cj.jdbc.Driver 对象并注册到 DriverManager.registeredDrivers 集合中(CopyOnWriteArrayList 类型),如下所示:

  1. static {  
  2.    java.sql.DriverManager.registerDriver(new Driver());  

在 getConnection() 方法中,DriverManager 从该 registeredDrivers 集合中获取对应的 Driver 对象创建 Connection,核心实现如下所示:

  1. private static Connection getConnection(String url, java.util.Properties info, Class caller) throws SQLException {  
  2.     // 省略 try/catch代码块以及权限处理逻辑  
  3.     for(DriverInfo aDriver : registeredDrivers) {  
  4.         Connection con = aDriver.driver.connect(url, info);  
  5.         return con;  
  6.     }  
  7. }  

小结

本文我们详细讲述了微内核架构的一些基本概念并通过一个示例入手,介绍了 JDK 提供的 SPI 机制的基本使用,然后深入分析了 JDK SPI 的核心原理和底层实现,对其源码进行了深入剖析,最后我们以 MySQL 提供的 JDBC 实现为例,分析了 JDK SPI 在实践中的使用方式。

 

掌握了JDK的SPI机制就等于掌握了微内核架构的核心,以上,希望对你有所帮助!

 

 

来源:JAVA日知录内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯