@SPI
public interface ExtensionFactory {

/** 
 * Get extension. 
 *  
 * @param type object type. 
 * @param name object name. 
 * @return object instance. 
 */  
<T> T getExtension(Class<T> type, String name);  

}

@SuppressWarnings("unchecked")  
private T createExtension(String name) {  
Class<?> clazz = getExtensionClasses().get(name);  
    if (clazz == null) {  
        throw findException(name);  
    }  
    try {  
        T instance = (T) EXTENSION_INSTANCES.get(clazz);  
        if (instance == null) {  
            EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());  
            instance = (T) EXTENSION_INSTANCES.get(clazz);  
        }  
        injectExtension(instance);  
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;  
if (wrapperClasses != null && wrapperClasses.size() > 0) {  
for (Class<?> wrapperClass : wrapperClasses) {  
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));  
}  
}  
return instance;  
} catch (Throwable t) {  
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +  
type + ")  could not be instantiated: " + t.getMessage(), t);  
}  
}

private T injectExtension(T instance) {  
try {  
if (objectFactory != null) {  
for (Method method : instance.getClass().getMethods()) {  
if (method.getName().startsWith("set")  
&& method.getParameterTypes().length == 1  
&& Modifier.isPublic(method.getModifiers())) {  
Class<?> pt = method.getParameterTypes()[0];  
try {  
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";  
Object object = objectFactory.getExtension(pt, property);  
if (object != null) {  
method.invoke(instance, object);  
}  
} catch (Exception e) {  
logger.error("fail to inject via method " + method.getName()  
+ " of interface " + type.getName() + ": " + e.getMessage(), e);  
}  
}  
}  
}  
} catch (Exception e) {  
logger.error(e.getMessage(), e);  
}  
return instance;  
}

/**
* Compiler. (SPI, Singleton, ThreadSafe)
* 
* @author william.liangf
*/  
@SPI("javassist")  
public interface Compiler {

/**
  * Compile java source code.
  *
  * @param code Java source code
  * @param classLoader TODO
  * @return Compiled class
    */  
    Class<?> compile(String code, ClassLoader classLoader);

  }

catch (Throwable t) { // 防御性容错  
logger.warn(t.getMessage(), t);  
return super.toString();  
}

public Object postProcessAfterInitialization(Object bean, String beanName)  
throws BeansException {  
if (! isMatchPackage(bean)) {  
return bean;  
}  
Class<?> clazz = bean.getClass();  
if(isProxyBean(bean)){  
clazz = AopUtils.getTargetClass(bean);  
}  
Service service = clazz.getAnnotation(Service.class);  
if (service != null) {  
ServiceBean<Object> serviceConfig = new ServiceBean<Object>(service);  
if (void.class.equals(service.interfaceClass())  
&& "".equals(service.interfaceName())) {  
if (clazz.getInterfaces().length > 0) {  
serviceConfig.setInterface(clazz.getInterfaces()[0]);  
} else {  
throw new IllegalStateException("Failed to export remote service class " + clazz.getName() + ", cause: The @Service undefined interfaceClass or interfaceName, and the service class unimplemented any interfaces.");  
}  
}  
if (applicationContext != null) {  
serviceConfig.setApplicationContext(applicationContext);  
if (service.registry() != null && service.registry().length > 0) {  
List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();  
for (String registryId : service.registry()) {  
if (registryId != null && registryId.length() > 0) {  
registryConfigs.add((RegistryConfig)applicationContext.getBean(registryId, RegistryConfig.class));  
}  
}  
serviceConfig.setRegistries(registryConfigs);  
}  
if (service.provider() != null && service.provider().length() > 0) {  
serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(),ProviderConfig.class));  
}  
if (service.monitor() != null && service.monitor().length() > 0) {  
serviceConfig.setMonitor((MonitorConfig)applicationContext.getBean(service.monitor(), MonitorConfig.class));  
}  
if (service.application() != null && service.application().length() > 0) {  
serviceConfig.setApplication((ApplicationConfig)applicationContext.getBean(service.application(), ApplicationConfig.class));  
}  
if (service.module() != null && service.module().length() > 0) {  
serviceConfig.setModule((ModuleConfig)applicationContext.getBean(service.module(), ModuleConfig.class));  
}  
if (service.provider() != null && service.provider().length() > 0) {  
serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(), ProviderConfig.class));  
} else {

        }  
        if (service.protocol() != null && service.protocol().length > 0) {  
            List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();  
            // modified by lishen; fix dubbo's bug  
            for (String protocolId : service.protocol()) {  
                if (protocolId != null && protocolId.length() > 0) {  
                    protocolConfigs.add((ProtocolConfig)applicationContext.getBean(protocolId, ProtocolConfig.class));  
                }  
            }  
            serviceConfig.setProtocols(protocolConfigs);  
        }  
        try {  
            serviceConfig.afterPropertiesSet();  
        } catch (RuntimeException e) {  
            throw (RuntimeException) e;  
        } catch (Exception e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        }  
    }  
    serviceConfig.setRef(bean);  
    serviceConfigs.add(serviceConfig);  
    serviceConfig.export();  
}  
return bean;  
}

String key = reference.group() + "/" + interfaceName + ":" + reference.version();  
ReferenceBean<?> referenceConfig = referenceConfigs.get(key);

// 调用过程拦截  
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {  
//异步获取serviceId，没获取到不进行采样  
String serviceId = tracer.getServiceId(RpcContext.getContext().getUrl().getServiceInterface());  
if (serviceId == null) {  
Tracer.startTraceWork();  
return invoker.invoke(invocation);  
}        
long start = System.currentTimeMillis();  
RpcContext context = RpcContext.getContext();  
boolean isConsumerSide = context.isConsumerSide();  
Span span = null;  
Endpoint endpoint = null;  
try {  
endpoint = tracer.newEndPoint();  
endpoint.setServiceName(serviceId);  
endpoint.setIp(context.getLocalAddressString());  
endpoint.setPort(context.getLocalPort());  
if (context.isConsumerSide()) { //是否是消费者  
Span span1 = tracer.getParentSpan();  
if (span1 == null) { //为rootSpan  
span = tracer.newSpan(context.getMethodName(), endpoint, serviceId);//生成root Span  
} else {  
span = tracer.genSpan(span1.getTraceId(), span1.getId(), tracer.genSpanId(), context.getMethodName(), span1.isSample(), null);  
}  
} else if (context.isProviderSide()) {  
Long traceId, parentId, spanId;  
traceId = TracerUtils.getAttachmentLong(invocation.getAttachment(TracerUtils.TID));  
parentId = TracerUtils.getAttachmentLong(invocation.getAttachment(TracerUtils.PID));  
spanId = TracerUtils.getAttachmentLong(invocation.getAttachment(TracerUtils.SID));  
boolean isSample = (traceId != null);  
span = tracer.genSpan(traceId, parentId, spanId, context.getMethodName(), isSample, serviceId);  
}  
invokerBefore(invocation, span, endpoint, start);//记录annotation  
RpcInvocation invocation1 = (RpcInvocation) invocation;  
setAttachment(span, invocation1);//设置需要向下游传递的参数  
Result result = invoker.invoke(invocation);  
if (result.getException() != null){  
catchException(result.getException(), endpoint);  
}  
return result;  
}catch (RpcException e) {  
if (e.getCause() != null && e.getCause() instanceof TimeoutException){  
catchTimeoutException(e, endpoint);  
}else {  
catchException(e, endpoint);  
}  
throw e;  
}finally {  
if (span != null) {  
long end = System.currentTimeMillis();  
invokerAfter(invocation, endpoint, span, end, isConsumerSide);//调用后记录annotation  
}  
}  
}

/**
* Container. (SPI, Singleton, ThreadSafe)
* 
* @author william.liangf
*/  
@SPI("spring")  
public interface Container {

/**
  * start.
    */  
    void start();

/**
  * stop.
    */  
    void stop();
}

    
    /**
    * SpringContainer. (SPI, Singleton, ThreadSafe)
    * 
    * @author william.liangf  
    */  
    public class SpringContainer implements Container {

    private static final Logger logger = LoggerFactory.getLogger(SpringContainer.class);

    public static final String SPRING_CONFIG = "dubbo.spring.config";

    public static final String DEFAULT_SPRING_CONFIG = "classpath*:META-INF/spring/*.xml";

    static ClassPathXmlApplicationContext context;

    public static ClassPathXmlApplicationContext getContext() {  
    return context;  
    }

    public void start() {  
    String configPath = ConfigUtils.getProperty(SPRING_CONFIG);  
    if (configPath == null || configPath.length() == 0) {  
    configPath = DEFAULT_SPRING_CONFIG;  
    }  
    context = new ClassPathXmlApplicationContext(configPath.split("[,\\s]+"));  
    context.start();  
    }

    public void stop() {  
    try {  
    if (context != null) {  
    context.stop();  
    context.close();  
    context = null;  
    }  
    } catch (Throwable e) {  
    logger.error(e.getMessage(), e);  
    }  
    }

}

    public static void main(String[] args) {  
    try {  
    if (args == null || args.length == 0) {  
    String config = ConfigUtils.getProperty(CONTAINER_KEY, loader.getDefaultExtensionName());  
    args = Constants.COMMA_SPLIT_PATTERN.split(config);  
    }

     final List<Container> containers = new ArrayList<Container>();  
     for (int i = 0; i < args.length; i ++) {  
         containers.add(loader.getExtension(args[i]));  
     }  
     logger.info("Use container type(" + Arrays.toString(args) + ") to run dubbo serivce.");  
       
     if ("true".equals(System.getProperty(SHUTDOWN_HOOK_KEY))) {  
      Runtime.getRuntime().addShutdownHook(new Thread() {  
          public void run() {  
              for (Container container : containers) {  
                  try {  
                      container.stop();  
                      logger.info("Dubbo " + container.getClass().getSimpleName() + " stopped!");  
                  } catch (Throwable t) {  
                      logger.error(t.getMessage(), t);  
                  }  
                  synchronized (Main.class) {  
                      running = false;  
                      Main.class.notify();  
                  }  
              }  
          }  
      });  
     }  
       
     for (Container container : containers) {  
         container.start();  
         logger.info("Dubbo " + container.getClass().getSimpleName() + " started!");  
     }  
     System.out.println(new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss]").format(new Date()) + " Dubbo service server started!");  
 } catch (RuntimeException e) {  
     e.printStackTrace();  
     logger.error(e.getMessage(), e);  
     System.exit(1);  
 }  
 synchronized (Main.class) {  
     while (running) {  
         try {  
             Main.class.wait();  
         } catch (Throwable e) {  
         }  
     }  
 }  
}

public AbstractRegistry(URL url) {  
setUrl(url);  
// 启动文件保存定时器  
syncSaveFile = url.getParameter(Constants.REGISTRY_FILESAVE_SYNC_KEY, false);  
String filename = url.getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/.dubbo/dubbo-registry-" + url.getHost() + ".cache");  
File file = null;  
if (ConfigUtils.isNotEmpty(filename)) {  
file = new File(filename);  
if(! file.exists() && file.getParentFile() != null && ! file.getParentFile().exists()){  
if(! file.getParentFile().mkdirs()){  
throw new IllegalArgumentException("Invalid registry store file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");  
}  
}  
}  
this.file = file;  
loadProperties();  
notify(url.getBackupUrls());  
}

public void doSaveProperties(long version) {  
if(version < lastCacheChanged.get()){  
return;  
}  
if (file == null) {  
return;  
}  
Properties newProperties = new Properties();  
// 保存之前先读取一遍，防止多个注册中心之间冲突  
InputStream in = null;  
try {  
if (file.exists()) {  
in = new FileInputStream(file);  
newProperties.load(in);  
}  
} catch (Throwable e) {  
logger.warn("Failed to load registry store file, cause: " + e.getMessage(), e);  
} finally {  
if (in != null) {  
try {  
in.close();  
} catch (IOException e) {  
logger.warn(e.getMessage(), e);  
}  
}  
}       
// 保存  
try {  
newProperties.putAll(properties);  
File lockfile = new File(file.getAbsolutePath() + ".lock");  
if (!lockfile.exists()) {  
lockfile.createNewFile();  
}  
RandomAccessFile raf = new RandomAccessFile(lockfile, "rw");  
try {  
FileChannel channel = raf.getChannel();  
try {  
FileLock lock = channel.tryLock();  
if (lock == null) {  
throw new IOException("Can not lock the registry cache file " + file.getAbsolutePath() + ", ignore and retry later, maybe multi java process use the file, please config: dubbo.registry.file=xxx.properties");  
}  
// 保存  
try {  
if (! file.exists()) {  
file.createNewFile();  
}  
FileOutputStream outputFile = new FileOutputStream(file);    
try {  
newProperties.store(outputFile, "Dubbo Registry Cache");  
} finally {  
outputFile.close();  
}  
} finally {  
lock.release();  
}  
} finally {  
channel.close();  
}  
} finally {  
raf.close();  
}  
} catch (Throwable e) {  
if (version < lastCacheChanged.get()) {  
return;  
} else {  
registryCacheExecutor.execute(new SaveProperties(lastCacheChanged.incrementAndGet()));  
}  
logger.warn("Failed to save registry store file, cause: " + e.getMessage(), e);  
}  
}

public FailbackRegistry(URL url) {  
super(url);  
int retryPeriod = url.getParameter(Constants.REGISTRY_RETRY_PERIOD_KEY, Constants.DEFAULT_REGISTRY_RETRY_PERIOD);  
this.retryFuture = retryExecutor.scheduleWithFixedDelay(new Runnable() {  
public void run() {  
// 检测并连接注册中心  
try {  
retry();  
} catch (Throwable t) { // 防御性容错  
logger.error("Unexpected error occur at failed retry, cause: " + t.getMessage(), t);  
}  
}  
}, retryPeriod, retryPeriod, TimeUnit.MILLISECONDS);  
}  

@Override  
public void register(URL url) {  
super.register(url);  
failedRegistered.remove(url);  
failedUnregistered.remove(url);  
try {  
// 向服务器端发送注册请求  
doRegister(url);  
} catch (Exception e) {  
Throwable t = e;

    // 如果开启了启动时检测，则直接抛出异常  
    boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)  
            && url.getParameter(Constants.CHECK_KEY, true)  
            && ! Constants.CONSUMER_PROTOCOL.equals(url.getProtocol());  
    boolean skipFailback = t instanceof SkipFailbackWrapperException;  
    if (check || skipFailback) {  
        if(skipFailback) {  
            t = t.getCause();  
        }  
        throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);  
    } else {  
        logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);  
    }  
 
    // 将失败的注册请求记录到失败列表，定时重试  
    failedRegistered.add(url);  
}  
}

@SuppressWarnings("unchecked")  
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {  
if (type == null)  
throw new IllegalArgumentException("Extension type == null");  
if(!type.isInterface()) {  
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");  
}  
if(!withExtensionAnnotation(type)) {  
throw new IllegalArgumentException("Extension type(" + type +   
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");  
}

ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);  
if (loader == null) {  
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));  
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);  
}  
return loader;  
}

public T getExtension(String name) {  
if (name == null || name.length() == 0)  
throw new IllegalArgumentException("Extension name == null");  
if ("true".equals(name)) {  
return getDefaultExtension();  
}  
Holder<Object> holder = cachedInstances.get(name);  
if (holder == null) {  
cachedInstances.putIfAbsent(name, new Holder<Object>());  
holder = cachedInstances.get(name);  
}  
Object instance = holder.get();  
if (instance == null) {  
synchronized (holder) {  
instance = holder.get();  
if (instance == null) {  
instance = createExtension(name);  
holder.set(instance);  
}  
}  
}  
return (T) instance;  
}