2019独角兽企业重金招聘Python工程师标准>>> 
简介
dubbo框架spring Schema扩展机制与Spring集成，在spring初始化时候加载dubbo的配置类。 dubbo服务导出的入口类是ServiceBean的onApplicationEvent方法 ServiceBean的继承关系如下 
public class ServiceBean extends ServiceConfig implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware {
private static final long serialVersionUID = 213195494150089726L;
private static transient ApplicationContext SPRING_CONTEXT;
private final transient Service service;
private transient ApplicationContext applicationContext;
private transient String beanName;
private transient boolean supportedApplicationListener;
public ServiceBean() {
this.service = null;
}
public ServiceBean(Service service) {
super(service);
this.service = service;
}
public static ApplicationContext getSpringContext() {
return SPRING_CONTEXT;
}
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
SpringExtensionFactory.addApplicationContext(applicationContext);
if (applicationContext != null) {
SPRING_CONTEXT = applicationContext;
try {
Method method = applicationContext.getClass().getMethod("addApplicationListener", ApplicationListener.class);
method.invoke(applicationContext, this);
this.supportedApplicationListener = true;
} catch (Throwable var5) {
if (applicationContext instanceof AbstractApplicationContext) {
try {
Method method = AbstractApplicationContext.class.getDeclaredMethod("addListener", ApplicationListener.class);
if (!method.isAccessible()) {
method.setAccessible(true);
}
method.invoke(applicationContext, this);
this.supportedApplicationListener = true;
} catch (Throwable var4) {
;
}
}
}
}
}
public void setBeanName(String name) {
this.beanName = name;
}
public Service getService() {
return this.service;
}
public void onApplicationEvent(ContextRefreshedEvent event) {
//如果不延迟导出且exported和unexported都为false 执行导出
if (this.isDelay() && !this.isExported() && !this.isUnexported()) {
if (logger.isInfoEnabled()) {
logger.info("The service ready on spring started. service: " + this.getInterface());
}
this.export();
}
}
private boolean isDelay() {
//调用父类`AbstractServiceConfig`中方法
Integer delay = this.getDelay();
ProviderConfig provider = this.getProvider();
if (delay == null && provider != null) {
//调用父类`AbstractServiceConfig`中getDelay方法
delay = provider.getDelay();
}
//delay == -1表示不需要延迟导出
return this.supportedApplicationListener && (delay == null || delay == -1);
}
}
public ProviderConfig getProvider() {
return this.provider;
}
supportedApplicationListener 变量含义，该变量用于表示当前的 Spring 容器是否支持 ApplicationListener，这个值初始为 false。在 Spring 容器将自己设置到 ServiceBean 中时，ServiceBean 的 setApplicationContext 方法会检测 Spring 容器是否支持 ApplicationListener。若支持，则将 supportedApplicationListener 置为 true。
this.export()调用ServiceConfig中方法
public synchronized void export() {
//如果provider存在，从provider中取export和delay属性
if (this.provider != null) {
if (this.export == null) {
this.export = this.provider.getExport();
}
if (this.delay == null) {
this.delay = this.provider.getDelay();
}
}
//如果未导出 判断delay决定立即导出 还是延迟导出
if (this.export == null || this.export) {
if (this.delay != null && this.delay > 0) {
delayExportExecutor.schedule(new Runnable() {
public void run() {
ServiceConfig.this.doExport();
}
}, (long)this.delay, TimeUnit.MILLISECONDS);
} else {
this.doExport();
}
}
}
doExport
protected synchronized void doExport() {
if (this.unexported) {
throw new IllegalStateException("Already unexported!");
} else if (!this.exported) {
this.exported = true;
if (this.interfaceName != null && this.interfaceName.length() != 0) {
this.checkDefault();
if (this.provider != null) {
if (this.application == null) {
this.application = this.provider.getApplication();
}
if (this.module == null) {
this.module = this.provider.getModule();
}
if (this.registries == null) {
this.registries = this.provider.getRegistries();
}
if (this.monitor == null) {
this.monitor = this.provider.getMonitor();
}
if (this.protocols == null) {
this.protocols = this.provider.getProtocols();
}
}
if (this.module != null) {
if (this.registries == null) {
this.registries = this.module.getRegistries();
}
if (this.monitor == null) {
this.monitor = this.module.getMonitor();
}
}
if (this.application != null) {
if (this.registries == null) {
this.registries = this.application.getRegistries();
}
if (this.monitor == null) {
this.monitor = this.application.getMonitor();
}
}
// 检测 ref 是否为泛化服务类型
if (this.ref instanceof GenericService) {
this.interfaceClass = GenericService.class;
if (StringUtils.isEmpty(this.generic)) {
// 设置 generic = "true"
this.generic = Boolean.TRUE.toString();
}
} else {
try {
this.interfaceClass = Class.forName(this.interfaceName, true, Thread.currentThread().getContextClassLoader());
} catch (ClassNotFoundException var5) {
throw new IllegalStateException(var5.getMessage(), var5);
}
//检查接口中是否有MethodConfig中定义的方法名称，没有抛异常
this.checkInterfaceAndMethods(this.interfaceClass, this.methods);
//检查ref类型是否合法
this.checkRef();
// 设置 generic = "true"
this.generic = Boolean.FALSE.toString();
}
//如果loal = true 或stub = true 加载并检查本地实现是否合法
Class stubClass;
if (this.local != null) {
if ("true".equals(this.local)) {
this.local = this.interfaceName + "Local";
}
try {
stubClass = ClassHelper.forNameWithThreadContextClassLoader(this.local);
} catch (ClassNotFoundException var4) {
throw new IllegalStateException(var4.getMessage(), var4);
}
if (!this.interfaceClass.isAssignableFrom(stubClass)) {
throw new IllegalStateException("The local implementation class " + stubClass.getName() + " not implement interface " + this.interfaceName);
}
}
if (this.stub != null) {
if ("true".equals(this.stub)) {
this.stub = this.interfaceName + "Stub";
}
try {
stubClass = ClassHelper.forNameWithThreadContextClassLoader(this.stub);
} catch (ClassNotFoundException var3) {
throw new IllegalStateException(var3.getMessage(), var3);
}
if (!this.interfaceClass.isAssignableFrom(stubClass)) {
throw new IllegalStateException("The stub implementation class " + stubClass.getName() + " not implement interface " + this.interfaceName);
}
}
// 检测各种对象是否为空，为空则新建，或者抛出异常
//检查dubbo.application.name 设置系统属性dubbo.service.shutdown.wait和dubbo.service.shutdown.wait.seconds
this.checkApplication();
//检查RegistryConfig并使用set方法反射设置属性（先从系统属性中取）
this.checkRegistry();
//设置ProtocalConfig并使用set方法反射设置属性（先从系统属性中取）
this.checkProtocol();
//设置当前ServiceConfig并使用set方法反射设置属性（先从系统属性中取）
appendProperties(this);
this.checkStubAndMock(this.interfaceClass);
if (this.path == null || this.path.length() == 0) {
this.path = this.interfaceName;
}
this.doExportUrls();
// ProviderModel 表示服务提供者模型，此对象中存储了与服务提供者相关的信息。
// 比如服务的配置信息，服务实例等。每个被导出的服务对应一个 ProviderModel。
// ApplicationModel 持有所有的 ProviderModel。
ProviderModel providerModel = new ProviderModel(this.getUniqueServiceName(), this, this.ref);
ApplicationModel.initProviderModel(this.getUniqueServiceName(), providerModel);
} else {
throw new IllegalStateException(" methods) {
if (interfaceClass == null) {
throw new IllegalStateException("interface not allow null!");
} else if (!interfaceClass.isInterface()) {
throw new IllegalStateException("The interface class " + interfaceClass + " is not a interface!");
} else {
if (methods != null && methods.size() > 0) {
Iterator i$ = methods.iterator();
while(i$.hasNext()) {
MethodConfig methodBean = (MethodConfig)i$.next();
String methodName = methodBean.getName();
if (methodName == null || methodName.length() == 0) {
throw new IllegalStateException(" name attribute is required! Please check: doExportUrls
loadRegistries 加载注册中心链接，然后再遍历 ProtocolConfig 集合导出每个服务。并在导出服务的过程中，将服务注册到注册中心。 loadRegistries 方法主要包含如下的逻辑： 检测是否存在注册中心配置类，不存在则抛出异常 构建参数映射集合，也就是 map 构建注册中心链接列表 遍历链接列表，并根据条件决定是否将其添加到 registryList 中
private void doExportUrls() {
List registryURLs = this.loadRegistries(true);
Iterator i$ = this.protocols.iterator();
while(i$.hasNext()) {
ProtocolConfig protocolConfig = (ProtocolConfig)i$.next();
this.doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}
}
protected List loadRegistries(boolean provider) {
//检查注册中心配置
this.checkRegistry();
List registryList = new ArrayList();
if (this.registries != null && this.registries.size() > 0) {
Iterator i$ = this.registries.iterator();
label75:
while(true) {
RegistryConfig config;
String address;
do {
do {
do {
if (!i$.hasNext()) {
return registryList;
}
config = (RegistryConfig)i$.next();
address = config.getAddress();
// 若 address 为空，则将其设为 0.0.0.0
if (address == null || address.length() == 0) {
address = "0.0.0.0";
}
// 从系统属性中加载注册中心地址
String sysaddress = System.getProperty("dubbo.registry.address");
if (sysaddress != null && sysaddress.length() > 0) {
address = sysaddress;
}
} while(address == null);
} while(address.length() <= 0);
} while("N/A".equalsIgnoreCase(address));
Map map = new HashMap();
// 添加 ApplicationConfig 中的字段信息到 map 中
appendParameters(map, this.application);
// 添加 RegistryConfig 字段信息到 map 中
appendParameters(map, config);
// 添加 path、pid，protocol 等信息到 map 中
map.put("path", RegistryService.class.getName());
map.put("dubbo", Version.getVersion());
map.put("timestamp", String.valueOf(System.currentTimeMillis()));
if (ConfigUtils.getPid() > 0) {
map.put("pid", String.valueOf(ConfigUtils.getPid()));
}
if (!map.containsKey("protocol")) {
if (ExtensionLoader.getExtensionLoader(RegistryFactory.class).hasExtension("remote")) {
map.put("protocol", "remote");
} else {
map.put("protocol", "dubbo");
}
}
// 解析得到 URL 列表，address 可能包含多个注册中心 ip，
// 因此解析得到的是一个 URL 列表
List urls = UrlUtils.parseURLs(address, map);
Iterator i$ = urls.iterator();
while(true) {
URL url;
do {
if (!i$.hasNext()) {
continue label75;
}
url = (URL)i$.next();
url = url.addParameter("registry", url.getProtocol());
// 将 URL 协议头设置为 registry
url = url.setProtocol("registry");
} while((!provider || !url.getParameter("register", true)) && (provider || !url.getParameter("subscribe", true)));
registryList.add(url);
}
}
} else {
return registryList;
}
}
//解析address 如果address以;或|符号分隔 则拆分后解析 返回List
public static List parseURLs(String address, Map defaults) {
if (address != null && address.length() != 0) {
String[] addresses = Constants.REGISTRY_SPLIT_PATTERN.split(address);
if (addresses != null && addresses.length != 0) {
List registries = new ArrayList();
String[] arr$ = addresses;
int len$ = addresses.length;
for(int i$ = 0; i$ < len$; ++i$) {
String addr = arr$[i$];
registries.add(parseURL(addr, defaults));
}
return registries;
} else {
return null;
}
} else {
return null;
}
}
public static URL parseURL(String address, Map defaults) {
if (address != null && address.length() != 0) {
String url;
//1 如果包含:// 直接返回url
//2 否则用，拆分成address数组 后拼接url
// 以172.19.103.55:2181,172.19.103.57:2181,172.19.103.54:2181为例
// 返回172.19.103.55:2181?backup=172.19.103.57:2181,172.19.103.54:2181
if (address.indexOf("://") >= 0) {
url = address;
} else {
String[] addresses = Constants.COMMA_SPLIT_PATTERN.split(address);
url = addresses[0];
if (addresses.length > 1) {
StringBuilder backup = new StringBuilder();
for(int i = 1; i < addresses.length; ++i) {
if (i > 1) {
backup.append(",");
}
backup.append(addresses[i]);
}
url = url + "?backup=" + backup.toString();
}
}
String defaultProtocol = defaults == null ? null : (String)defaults.get("protocol");
if (defaultProtocol == null || defaultProtocol.length() == 0) {
defaultProtocol = "dubbo";
}
String defaultUsername = defaults == null ? null : (String)defaults.get("username");
String defaultPassword = defaults == null ? null : (String)defaults.get("password");
int defaultPort = StringUtils.parseInteger(defaults == null ? null : (String)defaults.get("port"));
String defaultPath = defaults == null ? null : (String)defaults.get("path");
Map defaultParameters = defaults == null ? null : new HashMap(defaults);
if (defaultParameters != null) {
defaultParameters.remove("protocol");
defaultParameters.remove("username");
defaultParameters.remove("password");
defaultParameters.remove("host");
defaultParameters.remove("port");
defaultParameters.remove("path");
}
//构造URL
URL u = URL.valueOf(url);
boolean changed = false;
String protocol = u.getProtocol();
String username = u.getUsername();
String password = u.getPassword();
String host = u.getHost();
int port = u.getPort();
String path = u.getPath();
Map parameters = new HashMap(u.getParameters());
if ((protocol == null || protocol.length() == 0) && defaultProtocol != null && defaultProtocol.length() > 0) {
changed = true;
protocol = defaultProtocol;
}
if ((username == null || username.length() == 0) && defaultUsername != null && defaultUsername.length() > 0) {
changed = true;
username = defaultUsername;
}
if ((password == null || password.length() == 0) && defaultPassword != null && defaultPassword.length() > 0) {
changed = true;
password = defaultPassword;
}
if (port <= 0) {
if (defaultPort > 0) {
changed = true;
port = defaultPort;
} else {
changed = true;
port = 9090;
}
}
if ((path == null || path.length() == 0) && defaultPath != null && defaultPath.length() > 0) {
changed = true;
path = defaultPath;
}
if (defaultParameters != null && defaultParameters.size() > 0) {
Iterator i$ = defaultParameters.entrySet().iterator();
label119:
while(true) {
String key;
String defaultValue;
String value;
do {
do {
do {
if (!i$.hasNext()) {
break label119;
}
Entry entry = (Entry)i$.next();
key = (String)entry.getKey();
defaultValue = (String)entry.getValue();
} while(defaultValue == null);
} while(defaultValue.length() <= 0);
value = (String)parameters.get(key);
} while(value != null && value.length() != 0);
changed = true;
parameters.put(key, defaultValue);
}
}
//如果URL中有username等有一个未指定 则从默认配置读取缺失的配置
if (changed) {
u = new URL(protocol, username, password, host, port, path, parameters);
}
return u;
} else {
return null;
}
}
doExportUrlsFor1Protocol
private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
String name = protocolConfig.getName();
//设置dubbo为默认协议
if (name == null || name.length() == 0) {
name = "dubbo";
}
// 添加 side、版本、时间戳以及进程号等信息到 map 中
Map map = new HashMap();
map.put("side", "provider");
map.put("dubbo", Version.getVersion());
map.put("timestamp", String.valueOf(System.currentTimeMillis()));
if (ConfigUtils.getPid() > 0) {
map.put("pid", String.valueOf(ConfigUtils.getPid()));
}
// 通过反射将对象的字段信息添加到 map 中
appendParameters(map, this.application);
appendParameters(map, this.module);
appendParameters(map, this.provider, "default");
appendParameters(map, protocolConfig);
appendParameters(map, this);
//这段代码用于检测 标签中的配置信息，并将相关配置添加到 map 中。
if (this.methods != null && this.methods.size() > 0) {
Iterator i$ = this.methods.iterator();
label188:
while(true) {
MethodConfig method;
List arguments;
do {
do {
if (!i$.hasNext()) {
break label188;
}
method = (MethodConfig)i$.next();
appendParameters(map, method, method.getName());
String retryKey = method.getName() + ".retry";
if (map.containsKey(retryKey)) {
String retryValue = (String)map.remove(retryKey);
if ("false".equals(retryValue)) {
map.put(method.getName() + ".retries", "0");
}
}
arguments = method.getArguments();
} while(arguments == null);
} while(arguments.size() <= 0);
Iterator i$ = arguments.iterator();
while(true) {
ArgumentConfig argument;
Method[] methods;
do {
do {
while(true) {
if (!i$.hasNext()) {
continue label188;
}
argument = (ArgumentConfig)i$.next();
if (argument.getType() != null && argument.getType().length() > 0) {
methods = this.interfaceClass.getMethods();
break;
}
if (argument.getIndex() == -1) {
throw new IllegalArgumentException("argument config must set index or type attribute.eg: Invoker创建
Invoker 是由 ProxyFactory 创建而来，Dubbo 默认的 ProxyFactory 实现类是 JavassistProxyFactory
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.alibaba.dubbo.rpc.proxy.javassist;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.bytecode.Proxy;
import com.alibaba.dubbo.common.bytecode.Wrapper;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.proxy.AbstractProxyFactory;
import com.alibaba.dubbo.rpc.proxy.AbstractProxyInvoker;
import com.alibaba.dubbo.rpc.proxy.InvokerInvocationHandler;
public class JavassistProxyFactory extends AbstractProxyFactory {
public JavassistProxyFactory() {
}
public T getProxy(Invoker invoker, Class[] interfaces) {
return Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}
public Invoker getInvoker(T proxy, Class type, URL url) {
// 为目标类创建 Wrapper
final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf(36) < 0 ? proxy.getClass() : type);
// 创建匿名 Invoker 类对象，并实现 doInvoke 方法。
return new AbstractProxyInvoker(proxy, type, url) {
protected Object doInvoke(T proxy, String methodName, Class[] parameterTypes, Object[] arguments) throws Throwable {
return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
}
};
}
}
JavassistProxyFactory 创建了一个继承自 AbstractProxyInvoker 类的匿名对象，并覆写了抽象方法 doInvoke。覆写后的 doInvoke 逻辑比较简单，仅是将调用请求转发给了 Wrapper 类的 invokeMethod 方法。Wrapper 用于“包裹”目标类，Wrapper 是一个抽象类，仅可通过 getWrapper(Class) 方法创建子类。在创建 Wrapper 子类的过程中，子类代码生成逻辑会对 getWrapper 方法传入的 Class 对象进行解析，拿到诸如类方法，类成员变量等信息。以及生成 invokeMethod 方法代码和其他一些方法代码。代码生成完毕后，通过 Javassist 生成 Class 对象，最后再通过反射创建 Wrapper 实例
Wrapper
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.alibaba.dubbo.common.bytecode;
import com.alibaba.dubbo.common.utils.ClassHelper;
import com.alibaba.dubbo.common.utils.ReflectUtils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.regex.Matcher;
public abstract class Wrapper {
private static final Map, Wrapper> WRAPPER_MAP = new ConcurrentHashMap();
private static final String[] EMPTY_STRING_ARRAY = new String[0];
private static final String[] OBJECT_METHODS = new String[]{"getClass", "hashCode", "toString", "equals"};
//Object对象的Wrapper实现
private static final Wrapper OBJECT_WRAPPER = new Wrapper() {
public String[] getMethodNames() {
return Wrapper.OBJECT_METHODS;
}
public String[] getDeclaredMethodNames() {
return Wrapper.OBJECT_METHODS;
}
public String[] getPropertyNames() {
return Wrapper.EMPTY_STRING_ARRAY;
}
public Class getPropertyType(String pn) {
return null;
}
public Object getPropertyValue(Object instance, String pn) throws NoSuchPropertyException {
throw new NoSuchPropertyException("Property [" + pn + "] not found.");
}
public void setPropertyValue(Object instance, String pn, Object pv) throws NoSuchPropertyException {
throw new NoSuchPropertyException("Property [" + pn + "] not found.");
}
public boolean hasProperty(String name) {
return false;
}
public Object invokeMethod(Object instance, String mn, Class[] types, Object[] args) throws NoSuchMethodException {
if ("getClass".equals(mn)) {
return instance.getClass();
} else if ("hashCode".equals(mn)) {
return instance.hashCode();
} else if ("toString".equals(mn)) {
return instance.toString();
} else if ("equals".equals(mn)) {
if (args.length == 1) {
return instance.equals(args[0]);
} else {
throw new IllegalArgumentException("Invoke method [" + mn + "] argument number error.");
}
} else {
throw new NoSuchMethodException("Method [" + mn + "] not found.");
}
}
};
private static AtomicLong WRAPPER_CLASS_COUNTER = new AtomicLong(0L);
public Wrapper() {
}
public static Wrapper getWrapper(Class c) {
while(ClassGenerator.isDynamicClass(c)) {
c = c.getSuperclass();
}
//如果是object类型 返回Object的Wrapper
if (c == Object.class) {
return OBJECT_WRAPPER;
} else {
//从缓存取，没有的话创建Wrapper，并放入缓存
Wrapper ret = (Wrapper)WRAPPER_MAP.get(c);
if (ret == null) {
ret = makeWrapper(c);
WRAPPER_MAP.put(c, ret);
}
return ret;
}
}
private static Wrapper makeWrapper(Class c) {
//如果是primitive类型 抛异常
if (c.isPrimitive()) {
throw new IllegalArgumentException("Can not create wrapper for primitive type: " + c);
} else {
String name = c.getName();
ClassLoader cl = ClassHelper.getClassLoader(c);
// c1 用于存储 setPropertyValue 方法代码
StringBuilder c1 = new StringBuilder("public void setPropertyValue(Object o, String n, Object v){ ");
// c2 用于存储 getPropertyValue 方法代码
StringBuilder c2 = new StringBuilder("public Object getPropertyValue(Object o, String n){ ");
// c3 用于存储 invokeMethod 方法代码
StringBuilder c3 = new StringBuilder("public Object invokeMethod(Object o, String n, Class[] p, Object[] v) throws " + InvocationTargetException.class.getName() + "{ ");
// 生成类型转换代码及异常捕捉代码，比如：
// DemoService w; try { w = ((DemoServcie) $1); }}catch(Throwable e){ throw new IllegalArgumentException(e); }
c1.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
c2.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
c3.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
// pts 用于存储成员变量名和类型
Map> pts = new HashMap();
// ms 用于存储方法描述信息（可理解为方法签名）及 Method 实例
Map ms = new LinkedHashMap();
// mns 为方法名列表
List mns = new ArrayList();
// dmns 用于存储“定义在当前类中的方法”的名称
List dmns = new ArrayList();
Field[] arr$ = c.getFields();
int len$ = arr$.length;
for(int i$ = 0; i$ < len$; ++i$) {
Field f = arr$[i$];
String fn = f.getName();
Class ft = f.getType();
// 生成条件判断及赋值语句，比如：
// if( $2.equals("name") ) { w.name = (java.lang.String) $3; return;}
// if( $2.equals("age") ) { w.age = ((Number) $3).intValue(); return;}
if (!Modifier.isStatic(f.getModifiers()) && !Modifier.isTransient(f.getModifiers())) {
c1.append(" if( $2.equals(\"").append(fn).append("\") ){ w.").append(fn).append("=").append(arg(ft, "$3")).append("; return; }");
// 生成条件判断及返回语句，比如：
// if( $2.equals("name") ) { return ($w)w.name; }
c2.append(" if( $2.equals(\"").append(fn).append("\") ){ return ($w)w.").append(fn).append("; }");
pts.put(fn, ft);
}
}
Method[] methods = c.getMethods();
// 检测 c 中是否包含在当前类中声明的方法
boolean hasMethod = hasMethods(methods);
if (hasMethod) {
c3.append(" try{");
}
Method[] arr$ = methods;
int len$ = methods.length;
int ix;
for(int i$ = 0; i$ < len$; ++i$) {
Method m = arr$[i$];
if (m.getDeclaringClass() != Object.class) {
String mn = m.getName();
c3.append(" if( \"").append(mn).append("\".equals( $2 ) ");
ix = m.getParameterTypes().length;
// 生成“运行时传入的参数数量与方法参数列表长度”判断语句，比如：
// && $3.length == 2
c3.append(" && ").append(" $3.length == ").append(ix);
boolean override = false;
Method[] arr$ = methods;
int len$ = methods.length;
for(int i$ = 0; i$ < len$; ++i$) {
Method m2 = arr$[i$];
// 检测方法是否存在重载情况，条件为：方法对象不同 && 方法名相同
if (m != m2 && m.getName().equals(m2.getName())) {
override = true;
break;
}
}
if (override && ix > 0) {
for(int l = 0; l < ix; ++l) {
c3.append(" && ").append(" $3[").append(l).append("].getName().equals(\"").append(m.getParameterTypes()[l].getName()).append("\")");
}
}
c3.append(" ) { ");
if (m.getReturnType() == Void.TYPE) {
c3.append(" w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4")).append(");").append(" return null;");
} else {
c3.append(" return ($w)w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4")).append(");");
}
c3.append(" }");
mns.add(mn);
if (m.getDeclaringClass() == c) {
dmns.add(mn);
}
ms.put(ReflectUtils.getDesc(m), m);
}
}
if (hasMethod) {
c3.append(" } catch(Throwable e) { ");
c3.append(" throw new java.lang.reflect.InvocationTargetException(e); ");
c3.append(" }");
}
c3.append(" throw new " + NoSuchMethodException.class.getName() + "(\"Not found method \\\"\"+$2+\"\\\" in class " + c.getName() + ".\"); }");
Iterator i$ = ms.entrySet().iterator();
while(i$.hasNext()) {
Entry entry = (Entry)i$.next();
String md = (String)entry.getKey();
Method method = (Method)entry.getValue();
Matcher matcher;
String pn;
if ((matcher = ReflectUtils.GETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
pn = propertyName(matcher.group(1));
c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName()).append("(); }");
pts.put(pn, method.getReturnType());
} else if ((matcher = ReflectUtils.IS_HAS_CAN_METHOD_DESC_PATTERN.matcher(md)).matches()) {
pn = propertyName(matcher.group(1));
c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName()).append("(); }");
pts.put(pn, method.getReturnType());
} else if ((matcher = ReflectUtils.SETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
Class pt = method.getParameterTypes()[0];
String pn = propertyName(matcher.group(1));
c1.append(" if( $2.equals(\"").append(pn).append("\") ){ w.").append(method.getName()).append("(").append(arg(pt, "$3")).append("); return; }");
pts.put(pn, pt);
}
}
c1.append(" throw new " + NoSuchPropertyException.class.getName() + "(\"Not found property \\\"\"+$2+\"\\\" filed or setter method in class " + c.getName() + ".\"); }");
c2.append(" throw new " + NoSuchPropertyException.class.getName() + "(\"Not found property \\\"\"+$2+\"\\\" filed or setter method in class " + c.getName() + ".\"); }");
long id = WRAPPER_CLASS_COUNTER.getAndIncrement();
ClassGenerator cc = ClassGenerator.newInstance(cl);
cc.setClassName((Modifier.isPublic(c.getModifiers()) ? Wrapper.class.getName() : c.getName() + "$sw") + id);
cc.setSuperClass(Wrapper.class);
cc.addDefaultConstructor();
cc.addField("public static String[] pns;");
cc.addField("public static " + Map.class.getName() + " pts;");
cc.addField("public static String[] mns;");
cc.addField("public static String[] dmns;");
int i = 0;
for(ix = ms.size(); i < ix; ++i) {
cc.addField("public static Class[] mts" + i + ";");
}
cc.addMethod("public String[] getPropertyNames(){ return pns; }");
cc.addMethod("public boolean hasProperty(String n){ return pts.containsKey($1); }");
cc.addMethod("public Class getPropertyType(String n){ return (Class)pts.get($1); }");
cc.addMethod("public String[] getMethodNames(){ return mns; }");
cc.addMethod("public String[] getDeclaredMethodNames(){ return dmns; }");
cc.addMethod(c1.toString());
cc.addMethod(c2.toString());
cc.addMethod(c3.toString());
try {
Class wc = cc.toClass();
wc.getField("pts").set((Object)null, pts);
wc.getField("pns").set((Object)null, pts.keySet().toArray(new String[0]));
wc.getField("mns").set((Object)null, mns.toArray(new String[0]));
wc.getField("dmns").set((Object)null, dmns.toArray(new String[0]));
ix = 0;
Iterator i$ = ms.values().iterator();
while(i$.hasNext()) {
Method m = (Method)i$.next();
wc.getField("mts" + ix++).set((Object)null, m.getParameterTypes());
}
Wrapper var50 = (Wrapper)wc.newInstance();
return var50;
} catch (RuntimeException var27) {
throw var27;
} catch (Throwable var28) {
throw new RuntimeException(var28.getMessage(), var28);
} finally {
cc.release();
ms.clear();
mns.clear();
dmns.clear();
}
}
}
private static String arg(Class cl, String name) {
if (cl.isPrimitive()) {
if (cl == Boolean.TYPE) {
return "((Boolean)" + name + ").booleanValue()";
} else if (cl == Byte.TYPE) {
return "((Byte)" + name + ").byteValue()";
} else if (cl == Character.TYPE) {
return "((Character)" + name + ").charValue()";
} else if (cl == Double.TYPE) {
return "((Number)" + name + ").doubleValue()";
} else if (cl == Float.TYPE) {
return "((Number)" + name + ").floatValue()";
} else if (cl == Integer.TYPE) {
return "((Number)" + name + ").intValue()";
} else if (cl == Long.TYPE) {
return "((Number)" + name + ").longValue()";
} else if (cl == Short.TYPE) {
return "((Number)" + name + ").shortValue()";
} else {
throw new RuntimeException("Unknown primitive type: " + cl.getName());
}
} else {
return "(" + ReflectUtils.getName(cl) + ")" + name;
}
}
private static String args(Class[] cs, String name) {
int len = cs.length;
if (len == 0) {
return "";
} else {
StringBuilder sb = new StringBuilder();
for(int i = 0; i < len; ++i) {
if (i > 0) {
sb.append(',');
}
sb.append(arg(cs[i], name + "[" + i + "]"));
}
return sb.toString();
}
}
private static String propertyName(String pn) {
return pn.length() != 1 && !Character.isLowerCase(pn.charAt(1)) ? pn : Character.toLowerCase(pn.charAt(0)) + pn.substring(1);
}
private static boolean hasMethods(Method[] methods) {
if (methods != null && methods.length != 0) {
Method[] arr$ = methods;
int len$ = methods.length;
for(int i$ = 0; i$ < len$; ++i$) {
Method m = arr$[i$];
if (m.getDeclaringClass() != Object.class) {
return true;
}
}
return false;
} else {
return false;
}
}
public abstract String[] getPropertyNames();
public abstract Class getPropertyType(String var1);
public abstract boolean hasProperty(String var1);
public abstract Object getPropertyValue(Object var1, String var2) throws NoSuchPropertyException, IllegalArgumentException;
public abstract void setPropertyValue(Object var1, String var2, Object var3) throws NoSuchPropertyException, IllegalArgumentException;
public Object[] getPropertyValues(Object instance, String[] pns) throws NoSuchPropertyException, IllegalArgumentException {
Object[] ret = new Object[pns.length];
for(int i = 0; i < ret.length; ++i) {
ret[i] = this.getPropertyValue(instance, pns[i]);
}
return ret;
}
public void setPropertyValues(Object instance, String[] pns, Object[] pvs) throws NoSuchPropertyException, IllegalArgumentException {
if (pns.length != pvs.length) {
throw new IllegalArgumentException("pns.length != pvs.length");
} else {
for(int i = 0; i < pns.length; ++i) {
this.setPropertyValue(instance, pns[i], pvs[i]);
}
}
}
public abstract String[] getMethodNames();
public abstract String[] getDeclaredMethodNames();
public boolean hasMethod(String name) {
String[] arr$ = this.getMethodNames();
int len$ = arr$.length;
for(int i$ = 0; i$ < len$; ++i$) {
String mn = arr$[i$];
if (mn.equals(name)) {
return true;
}
}
return false;
}
public abstract Object invokeMethod(Object var1, String var2, Class[] var3, Object[] var4) throws NoSuchMethodException, InvocationTargetException;
}
通过 ClassGenerator 为刚刚生成的代码构建 Class 类，并通过反射创建对象。ClassGenerator 是 Dubbo 自己封装的，该类的核心是 toClass() 的重载方法 toClass(ClassLoader, ProtectionDomain)，该方法通过 javassist 构建 Class
服务远程导出
- 调用 doLocalExport 导出服务
- 向注册中心注册服务
- 向注册中心进行订阅 override 数据
- 创建并返回 DestroyableExporter
public Exporter export(Invoker originInvoker) throws RpcException {
// 导出服务
RegistryProtocol.ExporterChangeableWrapper exporter = this.doLocalExport(originInvoker);
// 获取注册中心 URL，以 zookeeper 注册中心为例，得到的示例 URL 如下：
// zookeeper://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=demo-provider&dubbo=2.0.2&export=dubbo%3A%2F%2F172.17.48.52%3A20880%2Fcom.alibaba.dubbo.demo.DemoService%3Fanyhost%3Dtrue%26application%3Ddemo-provider
URL registryUrl = this.getRegistryUrl(originInvoker);
Registry registry = this.getRegistry(originInvoker);
URL registedProviderUrl = this.getRegistedProviderUrl(originInvoker);
boolean register = registedProviderUrl.getParameter("register", true);
ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registedProviderUrl);
if (register) {
this.register(registryUrl, registedProviderUrl);
ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);
}
URL overrideSubscribeUrl = this.getSubscribedOverrideUrl(registedProviderUrl);
RegistryProtocol.OverrideListener overrideSubscribeListener = new RegistryProtocol.OverrideListener(overrideSubscribeUrl, originInvoker);
this.overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
return new RegistryProtocol.DestroyableExporter(exporter, originInvoker, overrideSubscribeUrl, registedProviderUrl);
}
如果是dubbo协议，调用DubboProtocal的export()
public Exporter export(Invoker invoker) throws RpcException {
URL url = invoker.getUrl();
String key = serviceKey(url);
// 创建 DubboExporter
DubboExporter exporter = new DubboExporter(invoker, key, this.exporterMap);
this.exporterMap.put(key, exporter);
Boolean isStubSupportEvent = url.getParameter("dubbo.stub.event", false);
Boolean isCallbackservice = url.getParameter("is_callback_service", false);
if (isStubSupportEvent && !isCallbackservice) {
String stubServiceMethods = url.getParameter("dubbo.stub.event.methods");
if (stubServiceMethods != null && stubServiceMethods.length() != 0) {
this.stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
} else if (this.logger.isWarnEnabled()) {
this.logger.warn(new IllegalStateException("consumer [" + url.getParameter("interface") + "], has set stubproxy support event ,but no stub methods founded."));
}
}
// 启动服务器
this.openServer(url);
return exporter;
}
private void openServer(URL url) {
// 获取 host:port，并将其作为服务器实例的 key，用于标识当前的服务器实例
String key = url.getAddress();
boolean isServer = url.getParameter("isserver", true);
if (isServer) {
ExchangeServer server = (ExchangeServer)this.serverMap.get(key);
if (server == null) {
// 创建服务器实例
this.serverMap.put(key, this.createServer(url));
} else {
// 服务器已创建，则根据 url 中的配置重置服务器
server.reset(url);
}
}
}
server = Exchangers.bind(url, this.requestHandler);
} catch (RemotingException var5) {
throw new RpcException("Fail to start server(url: " + url + ") " + var5.getMessage(), var5);
}
str = url.getParameter("client");
if (str != null && str.length() > 0) {
Set supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
if (!supportedTypes.contains(str)) {
throw new RpcException("Unsupported client type: " + str);
}
}
return server;
}
}
调用Exchanger的实现类HeaderExchanger
public class HeaderExchanger implements Exchanger {
public static final String NAME = "header";
public HeaderExchanger() {
}
public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
return new HeaderExchangeClient(Transporters.connect(url, new ChannelHandler[]{new DecodeHandler(new HeaderExchangeHandler(handler))}), true);
}
public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
return new HeaderExchangeServer(Transporters.bind(url, new ChannelHandler[]{new DecodeHandler(new HeaderExchangeHandler(handler))}));
}
}
Transporters.bind()如下
public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
} else if (handlers != null && handlers.length != 0) {
Object handler;
if (handlers.length == 1) {
handler = handlers[0];
} else {
handler = new ChannelHandlerDispatcher(handlers);
}
return getTransporter().bind(url, (ChannelHandler)handler);
} else {
throw new IllegalArgumentException("handlers == null");
}
}
//获取自适应的Transporter扩展 默认NettyTransporter
public static Transporter getTransporter() {
return (Transporter)ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}
public class NettyTransporter implements Transporter {
public static final String NAME = "netty";
public NettyTransporter() {
}
public Server bind(URL url, ChannelHandler listener) throws RemotingException {
return new NettyServer(url, listener);
}
public Client connect(URL url, ChannelHandler listener) throws RemotingException {
return new NettyClient(url, listener);
}
}
NettyServer继承AbstractServer，在AbstractServer定义了模板方法doOpen()和doClose(),NettyServer的实现如下
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.alibaba.dubbo.remoting.transport.netty;
import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.logger.Logger;
import com.alibaba.dubbo.common.logger.LoggerFactory;
import com.alibaba.dubbo.common.utils.ExecutorUtil;
import com.alibaba.dubbo.common.utils.NamedThreadFactory;
import com.alibaba.dubbo.common.utils.NetUtils;
import com.alibaba.dubbo.remoting.Channel;
import com.alibaba.dubbo.remoting.ChannelHandler;
import com.alibaba.dubbo.remoting.RemotingException;
import com.alibaba.dubbo.remoting.Server;
import com.alibaba.dubbo.remoting.transport.AbstractServer;
import com.alibaba.dubbo.remoting.transport.dispatcher.ChannelHandlers;
import java.net.InetSocketAddress;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
public class NettyServer extends AbstractServer implements Server {
private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);
private Map channels;
private ServerBootstrap bootstrap;
private org.jboss.netty.channel.Channel channel;
public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, "DubboServerHandler")));
}
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, this.getUrl().getPositiveParameter("iothreads", Constants.DEFAULT_IO_THREADS));
this.bootstrap = new ServerBootstrap(channelFactory);
final NettyHandler nettyHandler = new NettyHandler(this.getUrl(), this);
this.channels = nettyHandler.getChannels();
this.bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
NettyCodecAdapter adapter = new NettyCodecAdapter(NettyServer.this.getCodec(), NettyServer.this.getUrl(), NettyServer.this);
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", adapter.getDecoder());
pipeline.addLast("encoder", adapter.getEncoder());
pipeline.addLast("handler", nettyHandler);
return pipeline;
}
});
this.channel = this.bootstrap.bind(this.getBindAddress());
}
protected void doClose() throws Throwable {
try {
if (this.channel != null) {
this.channel.close();
}
} catch (Throwable var8) {
logger.warn(var8.getMessage(), var8);
}
try {
Collection channels = this.getChannels();
if (channels != null && channels.size() > 0) {
Iterator i$ = channels.iterator();
while(i$.hasNext()) {
Channel channel = (Channel)i$.next();
try {
channel.close();
} catch (Throwable var7) {
logger.warn(var7.getMessage(), var7);
}
}
}
} catch (Throwable var9) {
logger.warn(var9.getMessage(), var9);
}
try {
if (this.bootstrap != null) {
this.bootstrap.releaseExternalResources();
}
} catch (Throwable var6) {
logger.warn(var6.getMessage(), var6);
}
try {
if (this.channels != null) {
this.channels.clear();
}
} catch (Throwable var5) {
logger.warn(var5.getMessage(), var5);
}
}
public Collection getChannels() {
Collection chs = new HashSet();
Iterator i$ = this.channels.values().iterator();
while(i$.hasNext()) {
Channel channel = (Channel)i$.next();
if (channel.isConnected()) {
chs.add(channel);
} else {
this.channels.remove(NetUtils.toAddressString(channel.getRemoteAddress()));
}
}
return chs;
}
public Channel getChannel(InetSocketAddress remoteAddress) {
return (Channel)this.channels.get(NetUtils.toAddressString(remoteAddress));
}
public boolean isBound() {
return this.channel.isBound();
}
}