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

前置常识

什么是 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

6、启动类上加 @EnableSpi(basePackages = “com.github.lybgeek.spi”)

注： basePackages 用来指定扫描 spi 的包

7、测试

• 当 @SpiAutowired(“helloServiceCnImpl”) 时，页面渲染为

• 当 @SpiAutowired(“helloServiceEnImpl”) 时，页面渲染为

• 当指定 @Autowired @Spi(“com.github.lybgeek.spi.cn.HelloServiceCnImpl”)

此时页面渲染为

注： 这边没有用 @SpiAutowired，是因为 @SpiAutowired 须要指定名称

总结

本文基于 spi 按需加载是依赖 spring，在某种程度上和 spring 耦合，有机会的话，再讲下如何实现自定义键值对 SPI

demo 链接

https://github.com/lyb-geek/springboot-learning/tree/master/springboot-spi-ioc