聊聊基于jdk实现的spi如何与spring整合实现依赖注入

原创

lyb-geek

修改于 2021-08-17 18:11:01

1.2K0

修改于 2021-08-17 18:11:01

文章被收录于专栏：Linyb极客之路Linyb极客之路

前置知识

什么是SPI

之前有写过一篇文章-->java之spi机制简介不了解spi的朋友，可以先查阅这篇文章了解下，再阅读下文

前言

假设大家已经对SPI有一定的了解，有使用过JDK提供的SPI的朋友，应该会发现JDK的SPI是无法实现按需加载。那如何解决这个短板问题？

这边提供2种思路，一种是自己实现一套SPI，另外一种在实现组件很常用的手段，就是当前组件无法满足时，可以借助其他组件或者再加代理层。本文实现的思路，就是利用spring的IOC，spring的ioc本质上就是一个键值对map，将jdk spi生成的对象注入到spring ioc容器中，间接也拥有了key-->value的映射功能

实现思路

项目启动时，利用spi加载类并生成对象
将生成的对象注入到spring容器
在业务项目中，使用 @Autowired + @Qualifier注解，按需引用SPI生成的bean对象

核心代码片段

1、spi加载实现

 public Map<String,T> getSpiMap(Class<T> clz){
        listServicesAndPutMapIfNecessary(clz,true);
        return spiMap;
    }


    private List<T> listServicesAndPutMapIfNecessary(Class<T> clz,boolean isNeedPutMap){
        List<T> serviceList = new ArrayList();
        ServiceLoader<T> services = ServiceLoader.load(clz);
        Iterator<T> iterator = services.iterator();
        while(iterator.hasNext()){
            T service = iterator.next();
            serviceList.add(service);
            setSevices2Map(isNeedPutMap, service);
        }
        return serviceList;
    }

    @SneakyThrows
    private void setSevices2Map(boolean isNeedPutMap, T service) {
        if(isNeedPutMap){
            String serviceName = StringUtils.uncapitalize(service.getClass().getSimpleName());
            service = getProxyIfNecessary(service);

            spiMap.put(serviceName,service);
        }
    }

2、注入spring容器

public class SpiRegister implements ImportBeanDefinitionRegistrar,BeanFactoryAware {


    private DefaultListableBeanFactory beanFactory;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        registerSingleton(importingClassMetadata);

    }

    private void registerSingleton(AnnotationMetadata importingClassMetadata) {
        Class<?> spiInterface = getSpiInterface(importingClassMetadata);
        if(spiInterface != null){

            Map<String,?> spiMap = new SpiFactory().getSpiMap(spiInterface);
            if(MapUtil.isNotEmpty(spiMap)){
                spiMap.forEach((beanName,bean) -> {
                    registerSpiInterfaceSingleton(spiInterface, bean);
                    beanFactory.registerSingleton(beanName,bean);
                });
            }

        }
    }

    private void registerSpiInterfaceSingleton(Class<?> spiInterface, Object bean) {
        Spi spi = spiInterface.getAnnotation(Spi.class);
        String defalutSpiImplClassName = spi.defalutSpiImplClassName();
        if(StringUtils.isBlank(defalutSpiImplClassName)){
            defalutSpiImplClassName = spi.value();
        }

        String beanName = bean.getClass().getName();
        if(bean.toString().startsWith(SpiProxy.class.getName())){
            SpiProxy spiProxy = (SpiProxy) Proxy.getInvocationHandler(bean);
            beanName = spiProxy.getTarget().getClass().getName();
        }
        if(beanName.equals(defalutSpiImplClassName)){
            String spiInterfaceBeanName = StringUtils.uncapitalize(spiInterface.getSimpleName());
            beanFactory.registerSingleton(spiInterfaceBeanName,bean);
        }
    }

    private Class<?> getSpiInterface(AnnotationMetadata importingClassMetadata) {
        List<String> basePackages = getBasePackages(importingClassMetadata);
        for (String basePackage : basePackages) {
            Reflections reflections = new Reflections(basePackage);
            Set<Class<?>> spiClasses = reflections.getTypesAnnotatedWith(Spi.class);
            if(!CollectionUtils.isEmpty(spiClasses)){
                for (Class<?> spiClass : spiClasses) {
                    if(spiClass.isInterface()){
                        return spiClass;
                    }
                }
            }
        }

        return null;
    }

    private List<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
        Map<String, Object> enableSpi = importingClassMetadata.getAnnotationAttributes(EnableSpi.class.getName());
        String[] spiBackagepackages = (String[]) enableSpi.get("basePackages");
        List<String> basePackages =  Arrays.asList(spiBackagepackages);
        if(CollectionUtils.isEmpty(basePackages)){
            basePackages = new ArrayList<>();
            basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
        }
        return basePackages;
    }


    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = (DefaultListableBeanFactory)beanFactory;
    }
}

业务项目如何使用

示例

1、定义spi服务接口

@Spi
public interface HelloService {

    String sayHello(String username);
}

注： @Spi用来指定哪些spi服务接口需要注入到spring 容器中，同时@Spi还有一个defalutSpiImplClassName属性，用来指定默认注入spi实现类

2、定义具体实现类

public class HelloServiceCnImpl implements HelloService {

    @Override
    @InterceptorMethod(interceptorClasses = {HelloServiceCnInterceptor.class, HelloServiceCnOtherInterceptor.class})
    public String sayHello(String username) {
        return "你好：" + username;
    }
}

public class HelloServiceEnImpl implements HelloService {


    @Override
    @InterceptorMethod(interceptorClasses = HelloServiceEnInterceptor.class)
    public String sayHello(String username) {
        return "hello：" + username;
    }
}

注： @InterceptorMethod这个注解是用来做方法增强，和本文的关系不大，可以忽略

3、src/main/resources/下建立/META-INF/services 目录，新增一个以接口命名的文件

com.github.lybgeek.spi.HelloService

4、接口命名的文件填入如下内容

com.github.lybgeek.spi.en.HelloServiceEnImpl

com.github.lybgeek.spi.cn.HelloServiceCnImpl

5、编写业务controller

@RestController
@RequestMapping("/test")
public class SpiTestController {


    @SpiAutowired("helloServiceCnImpl")
    private HelloService helloService;


    @GetMapping(value="/{username}")
    public String sayHello(@PathVariable("username") String username){
        return helloService.sayHello(username);
    }
}

注： @SpiAutowired是一个自定义注解，该注解可以看成是@Autowired + @Qualifier