ServiceLoader解读

SPI的全名为Service Provider Interface.普通开发人员可能不熟悉，因为这个是针对厂商或者插件的。在java.util.ServiceLoader的文档里有比较详细的介绍。

简单来说就是通过配置文件指定接口的实现类。

当我们开发一套框架、一套机制、一个插件或一套API时候，如果需要第三方的服务支持，可以直接写死到代码里面，但这种方式耦合太强，不利于切换到其它服务，好的方法是写一个配置文件指定服务的实现方，幸运的是java的spi机制已经帮我们做好了，示例用法如下：

一个接口：

package com.service;
 
public interface IService {
    String service();
}

两个实现类：

package com.service;
 
public class ServiceImplA implements IService {
    public String service() {
        return "invoke ServiceImplA";
    }
}

package com.service;
 
public class ServiceImplB implements IService {
    public String service() {
        return "invoke ServiceImplB";
    }
}　　

然后创建com.service.IService文件，写入如下内容：

com.service.ServiceImplA
com.service.ServiceImplB

其在Idea中的结构如下：

其中的mazhimazh-1.0-SNAPSHOT.jar是打包后的jar。然后放到Java项目的classpath中。

创建ServiceIterator，代码如下：

package com.test2;
 
import java.lang.reflect.Method;
import java.util.Iterator;
 
import com.service.IService;
 
/**
 * Use a service loader appropriate for the platform to provide an
 * iterator over annotations processors.  If
 * java.util.ServiceLoader is present use it, otherwise, use
 * sun.misc.Service, otherwise fail if a loader is needed.
 */
public  class ServiceIterator implements Iterator<IService> {
    // The to-be-wrapped iterator.
    private Iterator<?> iterator;
    private Class<?> loaderClass;
    private boolean jusl; // java util service loader
    private Object loader;
 
    ServiceIterator() {
    	 ClassLoader classLoader = getClass().getClassLoader();
        String loadMethodName;
        try {
            try {
                loaderClass = Class.forName("java.util.ServiceLoader");
                loadMethodName = "load";
                jusl = true;
            } catch (ClassNotFoundException cnfe) {
                try {
                    loaderClass = Class.forName("sun.misc.Service");
                    loadMethodName = "providers";
                    jusl = false;
                } catch (ClassNotFoundException cnfe2) {
                    // Fail softly if a loader is not actually needed.
                    return;
                }
            }
 
            // java.util.ServiceLoader.load or sun.misc.Service.providers
            // 获得对象所声明的公开方法，在这里获取ServiceLoader的load方法
            // 该方法的第一个参数name是要获得方法的名字，第二个参数parameterTypes是按声明顺序标识该方法形参类型。
            Method loadMethod = loaderClass.getMethod(loadMethodName,
                    Class.class,
                    ClassLoader.class);
 
            // 调用方法 public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader)
            Object result = loadMethod.invoke(null,
            		IService.class,
                    classLoader);
 
            // For java.util.ServiceLoader, we have to call another
            // method to get the iterator.
            if (jusl) {
                loader = result; // Store ServiceLoader to call reload later
                Method m = loaderClass.getMethod("iterator");
                result = m.invoke(result); // serviceLoader.iterator();
            }
 
            // The result should now be an iterator.
            this.iterator = (Iterator<?>) result;
        } catch (Throwable t) {
            throw new Error(t);
        }
    }
 
    public boolean hasNext() {
        try {
            return iterator.hasNext();
        } catch (Throwable t) {
            throw new Error(t);
        }
    }
 
    public IService next() {
        try {
            return (IService)(iterator.next());
        } catch (Throwable t) {
            throw new Error(t);
        }
    }
 
    public void remove() {
        throw new UnsupportedOperationException();
    }
 
    public void close() {
        if (jusl) {
            try {
                // Call java.util.ServiceLoader.reload
                Method reloadMethod = loaderClass.getMethod("reload");
                reloadMethod.invoke(loader);
            } catch(Exception e) {
                ; // Ignore problems during a call to reload.
            }
        }
    }
}

然后调用，如下：

package com.test2;
 
import java.util.ServiceLoader;
import com.service.IService;
 
public class Test {
 
	public static void main(String[] args) {
		// 使用1
		ServiceIterator s = new ServiceIterator();
		while (s.hasNext()) {
			IService x = s.next();
			System.out.println(x.service());
		}
		// 使用2
		ServiceLoader<IService> serviceLoader = ServiceLoader.load(IService.class);
		for (IService service : serviceLoader) {
			System.out.println(service.service());
		}
	}
}

运行结果如下：

invoke ServiceImplA
invoke ServiceImplB
invoke ServiceImplA
invoke ServiceImplB