com.zusmart.basic.extension.ExtensionLoader Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of zusmart-basic Show documentation
基础模块,提供配置,日志,SPI,图排序,路径匹配,资源扫描,包扫描,常用工具类
There is a newer version: 0.0.3
package com.zusmart.basic.extension;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import com.zusmart.basic.logging.Logger;
import com.zusmart.basic.logging.LoggerFactory;
import com.zusmart.basic.toolkit.AnnotationUtils;
import com.zusmart.basic.toolkit.ClassUtils;
import com.zusmart.basic.toolkit.GenericUtils;
import com.zusmart.basic.toolkit.StringUtils;

/**
 * 参考Dubbo实现的SPI机制,部分代码进行调整
 * 
 * @author Administrator
 *
 * @param 
 *            扩展点接口对象
 */
public class ExtensionLoader {

	private static final String PATH_SERVICES = "META-INF/services/";
	private static final String PATH_INTERNAL = "META-INF/internal/";
	private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
	private static final ConcurrentMap, ExtensionLoader> LOADERS = new ConcurrentHashMap, ExtensionLoader>();

	private static class Holder {
		private volatile H value;

		private H get() {
			return this.value;
		}

		private void set(H value) {
			this.value = value;
		}
	}

	private static ClassLoader getClassLoader() {
		return ClassUtils.getClassLoader(ExtensionLoader.class);
	}

	private static void assertExtension(Class type) {
		if (null == type) {
			throw new IllegalArgumentException("extension type must not be null");
		}
		if (!type.isInterface()) {
			throw new IllegalArgumentException(String.format("extension type is not interface (%s)", type));
		}
		if (!AnnotationUtils.hasAnnotation(type, Extension.class)) {
			throw new IllegalArgumentException(String.format("extension type missing @Extension annotation (%s)", type));
		}
	}

	public static  ExtensionLoader getExtensionLoader(Class type) {
		assertExtension(type);
		ExtensionLoader loader = GenericUtils.parse(LOADERS.get(type));
		if (null == loader) {
			LOADERS.putIfAbsent(type, new ExtensionLoader(type));
			loader = GenericUtils.parse(LOADERS.get(type));
		}
		return loader;
	}

	public static  E getExtension(Class type, String name) {
		ExtensionLoader loader = getExtensionLoader(type);
		return loader.getExtension(name);
	}

	public static  E getDefaultExtension(Class type) {
		ExtensionLoader loader = getExtensionLoader(type);
		return loader.getDefaultExtension();
	}

	private final String name;
	private final Class type;
	private final ExtensionScope scope;
	private final Holder>> cacheClasses = new Holder>>();
	private final ConcurrentMap> cachedData = new ConcurrentHashMap>();

	private ExtensionLoader(Class type) {
		assertExtension(type);
		Extension extension = type.getAnnotation(Extension.class);
		this.name = extension.value();
		this.type = type;
		this.scope = extension.scope();
	}

	/**
	 * 获取指定名称的扩展点对象
	 * 
	 * @param name
	 *            扩展点名称
	 * @return 扩展点对象
	 */
	public T getExtension(String name) {
		if (StringUtils.isBlank(name)) {
			throw new IllegalArgumentException("extension name must not be blank");
		}
		Holder