浅析Java中的SPI原理

package cn.com.wwh;
/**
 * 
 * @FileName Logger.java
 * @version:1.0
 * @Description: 服务提供者接口
 * @author: wwh
 * @date: 2022年9月19日 上午10:31:53
 */
public interface Logger {
    
    /**
     * 
     * @Description:(功能描述)
     * @param msg
     */
    public void info(String msg);
    
    /**
     * 
     * @Description:(功能描述)
     * @param msg
     */
    public void debug(String msg);
}

package cn.com.wwh;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ServiceLoader;

/**
 * 
 * @FileName LoggerService.java
 * @version:1.0
 * @Description: 为服务的调用者提供特定的功能，是SPI的核心功能
 * @author: wwh
 * @date: 2022年9月19日 上午10:33:30
 */
public class LoggerService {

    private static final LoggerService INSTANCE = new LoggerService();

    private final Logger logger;                          

    private final List<Logger> loggers = new ArrayList<>();

    private LoggerService() {
　　　　　//ServiceLoader是实现SPI的核心类
        ServiceLoader<Logger> sl = ServiceLoader.load(Logger.class);
        Iterator<Logger> it = sl.iterator();
        while (it.hasNext()) {
            loggers.add(it.next());
        }

        if (!loggers.isEmpty()) {
            logger = loggers.get(0);
        } else {
            logger = null;
        }
    }

    /**
     * @Description:(功能描述)
     * @return
     */
    public static LoggerService getLoggerService() {
        return INSTANCE;
    }

    /**
     * 
     * @Description:(功能描述)
     * @param msg
     */
    public void info(String msg) {
        if (logger == null) {
            System.err.println("在info方法中没有找到Logger的实现类...");
        } else {
            logger.info(msg);
        }
    }

    /**
     * 
     * @Description:(功能描述)
     * @param msg
     */
    public void debug(String msg) {
        if (logger == null) {
            System.err.println("在debug方法中没有找到Logger的实现类...");
        } else {
            logger.info(msg);
        }
    }
}

package cn.com.wwh;

import cn.com.pep.Logger;

/**
 * 
 * @FileName Logback.java
 * @version:1.0
 * @Description: 服务接口的实现类
 * @author: wwh
 * @date: 2022年9月19日 上午10:50:31
 */
public class Logback implements Logger {

    @Override
    public void debug(String msg) {
        System.err.println("调用Logback的debug方法，输出的日志为：" + msg);
    }

    @Override
    public void info(String msg) {
        System.err.println("调用Logback的info方法，输出的日志为：" + msg);
    }

}

package cn.com.wwh;

import cn.com.pep.LoggerService;

/**
 * 
 * @FileName SpiTest.java
 * @version:1.0
 * @Description: 
 * @author: wwh
 * @date: 2022年9月19日 上午10:56:31
 */
public class SpiTest {
    
    public static void main(String[] args) {
        LoggerService logger = LoggerService.getLoggerService();
        logger.info("我是中国人");
        logger.debug("白菜多少钱一斤");
    }
}

public Iterator<S> iterator() {
        //通过匿名内部类方式提供了一个迭代器
        return new Iterator<S>() {
            //获取缓存的服务实现者的迭代器
            Iterator<Map.Entry<String, S>> knownProviders = providers.entrySet().iterator();

            //判断迭代器中是否还有元素
            public boolean hasNext() {
                //缓存的服务实现者的迭代器中已经没有元素了
                if (knownProviders.hasNext())
                    return true;
                return lookupIterator.hasNext();//判断延迟加载的迭代器中是否还有元素
            }

            //获取迭代其中的下一个元素
            public S next() {
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();//获取延迟加载的迭代器中的下一个元素
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
   }

public boolean hasNext() {
        if (nextName != null) {//存在下一个元素
            return true;
        }
        if (configs == null) {//配置文件为空
            try {
                String fullName = PREFIX + service.getName();//获取配置文件路径
                if (loader == null)
                    configs = ClassLoader.getSystemResources(fullName);
                else
                    configs = loader.getResources(fullName);//加载配置文件
            } catch (IOException x) {
                fail(service, "Error locating configuration files", x);
            }
        }
        //遍历配置文件内容
        while ((pending == null) || !pending.hasNext()) {
            if (!configs.hasMoreElements()) {
                return false;
            }
            pending = parse(service, configs.nextElement());//配置文件内容解析
        }
        nextName = pending.next();//获取服务实现类的全路径名
        return true;
    }

public S next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        String cn = nextName;//文件中保存的服务接口实现类的全路径名
        nextName = null;
        Class<?> c = null;
        try {
            //获取全限定名的Class对象
            c = Class.forName(cn, false, loader);
        } catch (ClassNotFoundException x) {
            fail(service, "Provider " + cn + " not found");
        }
            //判断实现类和服务接口是否是同一类型
        if (!service.isAssignableFrom(c)) {
            fail(service, "Provider " + cn + " not a subtype");
        }
        try {
            //通过反射生成服务接口的实现类，并判断这个实例是否是接口的实现
            S p = service.cast(c.newInstance());
            //将服务接口的实现缓存起来，并返回
            providers.put(cn, p);
            return p;
        } catch (Throwable x) {
            fail(service, "Provider " + cn + " could not be instantiated", x);
        }
        throw new Error(); // This cannot happen
    }