• 聊聊基于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

  • 相关阅读:
    一天时间用python写门语言
    360以安全之名做搜索,可信,还是欺世盗名?
    Servicemix,Karaf和Camel
    Struts2>action 小强斋
    解决JBoss只能通过localhost(127.0.0.1)而不能通过IP访问 小强斋
    java.sql.SQLException: 关闭的连接 小强斋
    Struts2>action 小强斋
    flex>MXML语法 小强斋
    jsp>tomcat配置虚拟目录 小强斋
    解决JBoss只能通过localhost(127.0.0.1)而不能通过IP访问 小强斋
  • 原文地址:https://www.cnblogs.com/linyb-geek/p/15151407.html
Copyright © 2020-2023  润新知