SPI扩展点在业务中的使用及原理分析

这篇具有很好参考价值的文章主要介绍了SPI扩展点在业务中的使用及原理分析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1 什么是SPI

SPI 全称Service Provider Interface。面向接口编程中,我们会根据不同的业务抽象出不同的接口,然后根据不同的业务实现建立不同规则的类,因此一个接口会实现多个实现类,在具体调用过程中,指定对应的实现类,当业务发生变化时会导致新增一个新的实现类,亦或是导致已经存在的类过时,就需要对调用的代码进行变更,具有一定的侵入性。
整体机制图如下:

Java SPI 实际上是“基于接口的编程+策略模式+配置文件”组合实现的动态加载机制。

2 SPI在京喜业务中的使用

2.1 简介

目前仓储中台和京喜BP的合作主要通过SPI扩展点的方式。好处就是对修改封闭、对扩展开放,中台不需要关心BP的业务实现细节,通过对不同BP配置扩展点的接口来达到个性化的目的。目前京喜BP主要提供两种方式的接口实现,一种是jar包的方式,一种是提供jsf接口。
下边来分别介绍下两种方式的定义和实现。

2.2 jar包方式

2.2.1 说明及示例

扩展点接口继承IDomainExtension,这个接口是dddplus包中的一个插件化接口,实现类要使用Extension(io.github.dddplus.annotation)注解,标记BP业务方和接口识别名称,用来做个性化的区分实现。
以在库库存盘点扩展点为例,接口定义在调用方提供的jar中,定义如下:

public interface IProfitLossEnrichExt extends IDomainExtension {
    @Valid
    @Comment({"批量盘盈亏数据丰富扩展", "扩展的属性请放到对应明细的 extendContent.extendAttr Map字段中:profitLossBatchDetail.putExtendAttr(key, value)"})
    List<ProfitLossBatchDetailExt> enrich(@NotEmpty List<ProfitLossBatchDetailExt> var1);
}

实现类定义在服务提供方的jar中,如下:

实现类:/**
 * ProfitLossEnrichExtImpl
 * 批量盘盈亏数据丰富扩展
 *
 * @author jiayongqiang6
 * @date 2021-10-15 11:30
 */
@Extension(code = IPartnerIdentity.JX_CODE, value = "jxProfitLossEnrichExt")
@Slf4j
public class ProfitLossEnrichExtImpl implements IProfitLossEnrichExt {
    private SkuInfoQueryService skuInfoQueryService;

    @Override
    public @Valid @Comment({"批量盘盈亏数据丰富扩展", "扩展的属性请放到对应明细的 extendContent.extendAttr Map字段中:profitLossBatchDetail" +
            ".putExtendAttr(key, value)"}) List<ProfitLossBatchDetailExt> enrich(@NotEmpty List<ProfitLossBatchDetailExt> list) {
        ...
        return list;
    }

    @Autowired
    public void setSkuInfoQueryService(SkuInfoQueryService skuInfoQueryService) {
        this.skuInfoQueryService = skuInfoQueryService;
    }
}

这个实现类会依赖主数据的jsf服务SkuQueryService,SkuInfoQueryService对SkuQueryService进行rpc封装调用。通过Autowired的方式注入进来,消费者需要定义在xml文件中,这个跟我们通常引入jsf消费者是一样的。示例如下:jx/spring-jsf-consumer.xml

<?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:jsf="http://jsf.jd.com/schema/jsf"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://jsf.jd.com/schema/jsf
       http://jsf.jd.com/schema/jsf/jsf.xsd"
       default-lazy-init="false" default-autowire="byName">
    <jsf:consumer id="skuQueryService" interface="com.jdwl.wms.masterdata.api.sku.SkuQueryService"
                  alias="${jsf.consumer.masterdata.alias}" protocol="jsf" check="false" timeout="10000"  retries="3"/>
</beans>

jar包的使用方可以直接加载consumer资源文件,也可以依赖得服务直接手动加到工程目录下。第一种方式更加方便,但是容易引起冲突,第二种方式虽然麻烦,但能够避免冲突。

2.2.2 扩展点的测试

因为扩展点依赖杰夫的关系,所以需要在配置文件中添加注册中心的配置和依赖服务的相关配置。示例如下:application-config.properties

jsf.consumer.masterdata.alias=wms6-test
jsf.registry.index=i.jsf.jd.com

通过在单元测试中加载consumer资源文件和配置文件把相关的依赖都加载进来,就能够实现对接口的贯穿调用测试。如下代码所示:

package com.zhongyouex.wms.spi.inventory;

import com.alibaba.fastjson.JSON;
import com.jdwl.wms.inventory.spi.difference.entity.ProfitLossBatchDetailExt;
import com.zhongyouex.wms.spi.inventory.service.SkuInfoQueryService;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.PropertySource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:jx/spring-jsf-consumer.xml"})
@PropertySource(value = {"classpath:application-config.properties"})
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
@ComponentScan(basePackages = {"com.zhongyouex.wms"})
public class ProfitLossEnrichExtImplTest {
    @Resource
    SkuInfoQueryService skuInfoQueryService;

    ProfitLossEnrichExtImpl profitLossEnrichExtImpl = new ProfitLossEnrichExtImpl();

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testEnrich() throws Exception {
        profitLossEnrichExtImpl.setSkuInfoQueryService(skuInfoQueryService);
        ProfitLossBatchDetailExt ext = new ProfitLossBatchDetailExt();
        ext.setSku("100008483105");
        ext.setWarehouseNo("6_6_618");
        ProfitLossBatchDetailExt ext1 = new ProfitLossBatchDetailExt();
        ext1.setSku("100009847591");
        ext1.setWarehouseNo("6_6_618");
        List<ProfitLossBatchDetailExt> list = new ArrayList<>();
        list.add(ext);
        list.add(ext1);
        profitLossEnrichExtImpl.enrich(list);
        System.out.write(JSON.toJSONBytes(list));
    }
}

//Generated with love by TestMe :) Please report issues and submit feature requests at: http://weirddev.com/forum#!/testme

2.3 jsf接口方式

jsf方式的扩展点实现和jar包方式是一样的,区别是这种方式不需要依赖服务提供方实现的jar,无需加载具体的实现类。通过配置jsf接口的杰夫别名来识别扩展点并进行扩展点的调用。

3 SPI原理分析

3.1dddplus

dddplus-runtime包中ExtensionDef主要是用来加载扩展点bean到InternalIndexer:

public void prepare(@NotNull Object bean) {
    this.initialize(bean);
    InternalIndexer.prepare(this);
}

private void initialize(Object bean) {
    Extension extension = (Extension)InternalAopUtils.getAnnotation(bean, Extension.class);
    this.code = extension.code();
    this.name = extension.name();
    if (!(bean instanceof IDomainExtension)) {
        throw BootstrapException.ofMessage(new String[]{bean.getClass().getCanonicalName(), " MUST implement IDomainExtension"});
    } else {
        this.extensionBean = (IDomainExtension)bean;
        Class[] var3 = InternalAopUtils.getTarget(this.extensionBean).getClass().getInterfaces();
        int var4 = var3.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            Class extensionBeanInterfaceClazz = var3[var5];
            if (extensionBeanInterfaceClazz.isInstance(this.extensionBean)) {
                this.extClazz = extensionBeanInterfaceClazz;
                log.debug("{} has ext instance:{}", this.extClazz.getCanonicalName(), this);
                break;
            }
        }

    }
}

3.2 java spi

通过上面简单的demo,可以看到最关键的实现就是ServiceLoader这个类,可以看下这个类的源码,如下:

public final class ServiceLoader<S> implements Iterable<S> {
 2 3 4     //扫描目录前缀 5     private static final String PREFIX = "META-INF/services/";
 6 7     // 被加载的类或接口 8     private final Class<S> service;
 910     // 用于定位、加载和实例化实现方实现的类的类加载器11     private final ClassLoader loader;
1213     // 上下文对象14     private final AccessControlContext acc;
1516     // 按照实例化的顺序缓存已经实例化的类17     private LinkedHashMap<String, S> providers = new LinkedHashMap<>();
1819     // 懒查找迭代器20     private java.util.ServiceLoader.LazyIterator lookupIterator;
2122     // 私有内部类,提供对所有的service的类的加载与实例化23     private class LazyIterator implements Iterator<S> {
24         Class<S> service;
25         ClassLoader loader;
26         Enumeration<URL> configs = null;
27         String nextName = null;
2829         //...30         private boolean hasNextService() {
31             if (configs == null) {
32                 try {
33                     //获取目录下所有的类34                     String fullName = PREFIX + service.getName();
35                     if (loader == null)
36                         configs = ClassLoader.getSystemResources(fullName);
37                     else38                         configs = loader.getResources(fullName);
39                 } catch (IOException x) {
40                     //...41                 }
42                 //....43             }
44         }
4546         private S nextService() {
47             String cn = nextName;
48             nextName = null;
49             Class<?> c = null;
50             try {
51                 //反射加载类52                 c = Class.forName(cn, false, loader);
53             } catch (ClassNotFoundException x) {
54             }
55             try {
56                 //实例化57                 S p = service.cast(c.newInstance());
58                 //放进缓存59                 providers.put(cn, p);
60                 return p;
61             } catch (Throwable x) {
62                 //..63             }
64             //..65         }
66     }
67 }

上面的代码只贴出了部分关键的实现,有兴趣的读者可以自己去研究,下面贴出比较直观的spi加载的主要流程供参考:

4 总结

SPI的两种提供方式各有优缺点,jar包方式部署成本低、依赖多,增加调用方的配置成本;jsf接口方式部署成本高,但调用方依赖少,只需要通过别名识别不同的BP。

总结下spi能带来的好处:

  • 不需要改动源码就可以实现扩展,解耦。
  • 实现扩展对原来的代码几乎没有侵入性。
  • 只需要添加配置就可以实现扩展,符合开闭原则。

作者:京东物流 贾永强

来源:京东云开发者社区 自猿其说Tech 转载请注明来源文章来源地址https://www.toymoban.com/news/detail-747633.html

到了这里,关于SPI扩展点在业务中的使用及原理分析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring Boot 中的 RedisCacheManager 是什么,原理,如何使用

    在现代应用程序中,缓存是提高应用程序性能的重要组成部分。Spring Boot 提供了一个强大的缓存框架,它支持多种缓存提供程序,包括 Redis、Ehcache、Caffeine 等。在本文中,我们将重点介绍 Spring Boot 中的 RedisCacheManager,并探讨它的原理和如何使用它来提高应用程序的性能。

    2024年02月10日
    浏览(49)
  • Spring Boot 中的 WebSocketSession 是什么,原理,如何使用

    在现代 Web 应用程序中,实时通信是一个非常常见的需求。传统的 HTTP 协议是无法支持实时通信的,因为它是一种无状态协议,每次请求都是独立的,无法保持连接。为了解决这个问题,WebSocket 协议被引入。WebSocket 协议是一种双向通信协议,它允许服务器和客户端之间建立持

    2024年02月12日
    浏览(45)
  • Spring Boot 中的 WebMvc 是什么,原理,如何使用

    在 Spring Boot 中,WebMvc 是非常重要的一个模块。它提供了一系列用于处理 Web 请求的组件和工具。在本文中,我们将介绍 Spring Boot 中的 WebMvc 是什么,其原理以及如何使用它来处理 Web 请求。 WebMvc 是 Spring 框架中的一个模块,它提供了一系列用于处理 Web 请求的组件和工具。它

    2024年02月11日
    浏览(48)
  • Spring Boot 中的 @RabbitListener 注解是什么,原理,如何使用

    在 RabbitMQ 中,消息的接收需要通过监听队列来实现。在 Spring Boot 应用程序中,可以使用 @RabbitListener 注解来监听队列,并在接收到消息时执行指定的方法。本文将介绍 @RabbitListener 注解的原理、使用方法和常见应用场景。 @RabbitListener 注解是 Spring AMQP 框架中的一个关键组件,

    2024年02月09日
    浏览(57)
  • Spring Boot 中的 @RefreshScope 注解是什么,原理,如何使用

    在 Spring Boot 中,@RefreshScope 注解是一个非常有用的注解。它可以让 Spring Boot 应用程序在运行时重新加载配置。这意味着您可以在不停止和重新启动应用程序的情况下更改配置。在本文中,我们将介绍 @RefreshScope 注解的原理和如何在 Spring Boot 应用程序中使用它。 @RefreshScope 是

    2024年02月13日
    浏览(35)
  • Spring Boot中的SimpMessagingTemplate是什么,原理,以及如何使用

    SimpMessagingTemplate是Spring Framework中的一个类,用于向WebSocket客户端发送消息。在Spring Boot应用程序中,可以使用SimpMessagingTemplate来实现WebSocket通信的消息发送功能。本文将介绍SimpMessagingTemplate的原理和使用方法。 SimpMessagingTemplate是Spring Framework中的一个类,用于向WebSocket客户端

    2024年02月09日
    浏览(46)
  • Spring Boot 中的 @ComponentScan 注解是什么,原理,如何使用

    在 Spring Boot 中,@ComponentScan 是一种注解,它可以让 Spring 自动扫描指定的包及其子包中的组件,并将这些组件自动装配到 Spring 容器中。本文将介绍 @ComponentScan 的原理以及如何在 Spring Boot 中使用它。 在 Spring 中,组件是指那些被 Spring 管理的对象,比如 Bean、Controller、Servic

    2024年02月11日
    浏览(44)
  • Spring Boot 中的 @FeignClient 注解是什么,原理,如何使用

    在微服务架构中,服务之间的调用是非常频繁的。为了简化服务之间的调用,Spring Boot 提供了一个叫做 Feign 的组件。Feign 可以帮助我们定义和实现服务之间的 RESTful 接口,使得服务之间的调用更加方便和可靠。在本文中,我们将深入探讨 Spring Boot 中的 @FeignClient 注解是什么,

    2024年02月09日
    浏览(55)
  • Spring Boot 中的服务注册是什么,原理,如何使用

    Spring Boot 是一个非常流行的 Java 后端框架,它提供了许多便捷的功能和工具,使得开发者可以更加高效地开发微服务应用。其中,服务注册是 Spring Boot 微服务架构中非常重要的一环。在本文中,我们将深入探讨 Spring Boot 中的服务注册是什么,原理以及如何使用。 服务注册是

    2024年02月12日
    浏览(48)
  • Spring Boot 中的 @PutMapping 注解是什么,原理,如何使用

    在 Spring Boot 中,@PutMapping 是一种注解,它可以将 HTTP PUT 请求映射到指定的处理方法上。本文将介绍 @PutMapping 的原理以及如何在 Spring Boot 中使用它。 在 RESTful API 中,PUT 请求常用于更新资源。例如,我们可以使用 PUT 请求将一个用户的信息更新到服务器上。在 Spring Boot 中,我

    2024年02月08日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包