Rpc框架dubbo

接上一篇 dubbo-server 之后，再来看一下 dubbo-client 是如何工作的。

dubbo提供者服务示例, 其结构是这样的！
dubbo://192.168.11.6:20880/com.alibaba.dubbo.demo.DemoService?anyhost=true&application=demo-provider&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=12720&side=provider&timestamp=1534902103892
dubbo消费者示例，其结构是这样的！
dubbo://192.168.11.6:20880/com.alibaba.dubbo.demo.DemoService?anyhost=true&application=demo-consumer&check=false&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=17400&qos.port=33333&register.ip=192.168.11.6&remote.timestamp=1537448440181&side=consumer&timestamp=1537871015998

官网可以运行起来的实例:

1// 提供者:
2public class Provider {
3    public static void main(String[] args) throws Exception {
4        //Prevent to get IPV6 address,this way only work in debug mode
5        //But you can pass use -Djava.net.preferIPv4Stack=true,then it work well whether in debug mode or not
6        System.setProperty("java.net.preferIPv4Stack", "true");
7        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-provider.xml"});
8        context.start();
9        
10        // 这个比较巧妙, 只需停留在当前点，不按下enter键，服务就会一直存在，等待消费者连接，而且无需真正提供一个监听服务
11        System.in.read(); // press any key to exit
12    }
13
14}
15
16// 消费者:
17public class Consumer {
18    public static void main(String[] args) {
19        //Prevent to get IPV6 address,this way only work in debug mode
20        //But you can pass use -Djava.net.preferIPv4Stack=true,then it work well whether in debug mode or not
21        System.setProperty("java.net.preferIPv4Stack", "true");
22        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"META-INF/spring/dubbo-demo-consumer.xml"});
23        context.start();
24        DemoService demoService = (DemoService) context.getBean("demoService"); // get remote service proxy
25        String hello = demoService.sayHello("world"); // call remote method, 调用远程服务和本地服务一样，这是其优势所在
26        System.out.println(hello); // get result
27        }
28    }
29}

以上代码可以直接运行起来，但是建议还是个搭建一个Zookeeper来用用，因为线上基本都是Zk的，搭建也很简单，可参考：ZooKeeper 搭建笔记

初始化Context，如上一篇server过程！ Rpc框架dubbo-server（v2.6.3） 源码阅读（一）

1// DubboNamespaceHandler, provider与consumer主要的差别在于xml标签的获取不一致，
2public class DubboNamespaceHandler extends NamespaceHandlerSupport {
3
4    static {
5        Version.checkDuplicate(DubboNamespaceHandler.class);
6    }
7
8    @Override
9    public void init() {
10        registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
11        registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
12        registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
13        registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
14        // provider解析
15        registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
16        // consumer解析
17        registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
18        registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
19        registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
20        registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
21        registerBeanDefinitionParser("annotation", new AnnotationBeanDefinitionParser());
22    }
23
24}

// 主要看获取bean的过程
DemoService demoService = (DemoService) context.getBean("demoService"); // get remote service proxy

1// spring, 获取bean, 通过 org.springframework.beans.factory.support.DefaultListableBeanFactory, 获取 
2    @Override
3    public Object getBean(String name) throws BeansException {
4        assertBeanFactoryActive();
5        return getBeanFactory().getBean(name);
6    }
7
8        protected <T> T doGetBean(
9            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
10            throws BeansException {
11
12        final String beanName = transformedBeanName(name);
13        Object bean;
14
15        // Eagerly check singleton cache for manually registered singletons.
16        // 通过该方法获取bean代理实例,com.alibaba.dubbo.config.spring.ReferenceBean
17        Object sharedInstance = getSingleton(beanName);
18        if (sharedInstance != null && args == null) {
19            if (logger.isDebugEnabled()) {
20                if (isSingletonCurrentlyInCreation(beanName)) {
21                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
22                            "' that is not fully initialized yet - a consequence of a circular reference");
23                }
24                else {
25                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
26                }
27            }
28            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
29        }
30
31        else {
32            // Fail if we're already creating this bean instance:
33            // We're assumably within a circular reference.
34            if (isPrototypeCurrentlyInCreation(beanName)) {
35                throw new BeanCurrentlyInCreationException(beanName);
36            }
37
38            // Check if bean definition exists in this factory.
39            BeanFactory parentBeanFactory = getParentBeanFactory();
40            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
41                // Not found -> check parent.
42                String nameToLookup = originalBeanName(name);
43                if (args != null) {
44                    // Delegation to parent with explicit args.
45                    return (T) parentBeanFactory.getBean(nameToLookup, args);
46                }
47                else {
48                    // No args -> delegate to standard getBean method.
49                    return parentBeanFactory.getBean(nameToLookup, requiredType);
50                }
51            }
52
53            if (!typeCheckOnly) {
54                markBeanAsCreated(beanName);
55            }
56
57            try {
58                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
59                checkMergedBeanDefinition(mbd, beanName, args);
60
61                // Guarantee initialization of beans that the current bean depends on.
62                String[] dependsOn = mbd.getDependsOn();
63                if (dependsOn != null) {
64                    for (String dep : dependsOn) {
65                        if (isDependent(beanName, dep)) {
66                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
67                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
68                        }
69                        registerDependentBean(dep, beanName);
70                        try {
71                            getBean(dep);
72                        }
73                        catch (NoSuchBeanDefinitionException ex) {
74                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
75                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
76                        }
77                    }
78                }
79
80                // Create bean instance.
81                if (mbd.isSingleton()) {
82                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
83                        @Override
84                        public Object getObject() throws BeansException {
85                            try {
86                                return createBean(beanName, mbd, args);
87                            }
88                            catch (BeansException ex) {
89                                // Explicitly remove instance from singleton cache: It might have been put there
90                                // eagerly by the creation process, to allow for circular reference resolution.
91                                // Also remove any beans that received a temporary reference to the bean.
92                                destroySingleton(beanName);
93                                throw ex;
94                            }
95                        }
96                    });
97                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
98                }
99
100                else if (mbd.isPrototype()) {
101                    // It's a prototype -> create a new instance.
102                    Object prototypeInstance = null;
103                    try {
104                        beforePrototypeCreation(beanName);
105                        prototypeInstance = createBean(beanName, mbd, args);
106                    }
107                    finally {
108                        afterPrototypeCreation(beanName);
109                    }
110                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
111                }
112
113                else {
114                    String scopeName = mbd.getScope();
115                    final Scope scope = this.scopes.get(scopeName);
116                    if (scope == null) {
117                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
118                    }
119                    try {
120                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
121                            @Override
122                            public Object getObject() throws BeansException {
123                                beforePrototypeCreation(beanName);
124                                try {
125                                    return createBean(beanName, mbd, args);
126                                }
127                                finally {
128                                    afterPrototypeCreation(beanName);
129                                }
130                            }
131                        });
132                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
133                    }
134                    catch (IllegalStateException ex) {
135                        throw new BeanCreationException(beanName,
136                                "Scope '" + scopeName + "' is not active for the current thread; consider " +
137                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
138                                ex);
139                    }
140                }
141            }
142            catch (BeansException ex) {
143                cleanupAfterBeanCreationFailure(beanName);
144                throw ex;
145            }
146        }
147
148        // Check if required type matches the type of the actual bean instance.
149        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
150            try {
151                return getTypeConverter().convertIfNecessary(bean, requiredType);
152            }
153            catch (TypeMismatchException ex) {
154                if (logger.isDebugEnabled()) {
155                    logger.debug("Failed to convert bean '" + name + "' to required type '" +
156                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
157                }
158                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
159            }
160        }
161        return (T) bean;
162    }

View Code

// ApplicationConfig 初始化时，调用dubbo实例进行初始化

1// org.springframework.beans.BeanUtils.instantiateClass 初始化 ReferenceConfig 类，通过反射调用
2    // public com.alibaba.dubbo.config.RegistryConfig()
3     public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
4        Assert.notNull(ctor, "Constructor must not be null");
5        try {
6            ReflectionUtils.makeAccessible(ctor);
7            // 生成新的实例
8            return ctor.newInstance(args);
9        }
10        catch (InstantiationException ex) {
11            throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
12        }
13        catch (IllegalAccessException ex) {
14            throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
15        }
16        catch (IllegalArgumentException ex) {
17            throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
18        }
19        catch (InvocationTargetException ex) {
20            throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
21        }
22    }

// 通过getBean, 转移到 ReferenceBean.getObject() 触发代理初始化

1//     org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean, 触发 创建bean操作,触发 getObject() 进行初始化
2    protected <T> T doGetBean(
3            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
4            throws BeansException {
5
6        final String beanName = transformedBeanName(name);
7        Object bean;
8
9        // Eagerly check singleton cache for manually registered singletons.
10        Object sharedInstance = getSingleton(beanName);
11        if (sharedInstance != null && args == null) {
12            if (logger.isDebugEnabled()) {
13                if (isSingletonCurrentlyInCreation(beanName)) {
14                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
15                            "' that is not fully initialized yet - a consequence of a circular reference");
16                }
17                else {
18                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
19                }
20            }
21            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
22        }
23
24        else {
25            // Fail if we're already creating this bean instance:
26            // We're assumably within a circular reference.
27            if (isPrototypeCurrentlyInCreation(beanName)) {
28                throw new BeanCurrentlyInCreationException(beanName);
29            }
30
31            // Check if bean definition exists in this factory.
32            BeanFactory parentBeanFactory = getParentBeanFactory();
33            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
34                // Not found -> check parent.
35                String nameToLookup = originalBeanName(name);
36                if (args != null) {
37                    // Delegation to parent with explicit args.
38                    return (T) parentBeanFactory.getBean(nameToLookup, args);
39                }
40                else {
41                    // No args -> delegate to standard getBean method.
42                    return parentBeanFactory.getBean(nameToLookup, requiredType);
43                }
44            }
45
46            if (!typeCheckOnly) {
47                markBeanAsCreated(beanName);
48            }
49
50            try {
51                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
52                checkMergedBeanDefinition(mbd, beanName, args);
53
54                // Guarantee initialization of beans that the current bean depends on.
55                String[] dependsOn = mbd.getDependsOn();
56                if (dependsOn != null) {
57                    for (String dep : dependsOn) {
58                        if (isDependent(beanName, dep)) {
59                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
60                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
61                        }
62                        registerDependentBean(dep, beanName);
63                        try {
64                            getBean(dep);
65                        }
66                        catch (NoSuchBeanDefinitionException ex) {
67                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
68                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
69                        }
70                    }
71                }
72
73                // Create bean instance.
74                if (mbd.isSingleton()) {
75                    // 此处进行bean创建
76                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
77                        @Override
78                        public Object getObject() throws BeansException {
79                            try {
80                                return createBean(beanName, mbd, args);
81                            }
82                            catch (BeansException ex) {
83                                // Explicitly remove instance from singleton cache: It might have been put there
84                                // eagerly by the creation process, to allow for circular reference resolution.
85                                // Also remove any beans that received a temporary reference to the bean.
86                                destroySingleton(beanName);
87                                throw ex;
88                            }
89                        }
90                    });
91                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
92                }
93
94                else if (mbd.isPrototype()) {
95                    // It's a prototype -> create a new instance.
96                    Object prototypeInstance = null;
97                    try {
98                        beforePrototypeCreation(beanName);
99                        prototypeInstance = createBean(beanName, mbd, args);
100                    }
101                    finally {
102                        afterPrototypeCreation(beanName);
103                    }
104                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
105                }
106
107                else {
108                    String scopeName = mbd.getScope();
109                    final Scope scope = this.scopes.get(scopeName);
110                    if (scope == null) {
111                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
112                    }
113                    try {
114                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
115                            @Override
116                            public Object getObject() throws BeansException {
117                                beforePrototypeCreation(beanName);
118                                try {
119                                    return createBean(beanName, mbd, args);
120                                }
121                                finally {
122                                    afterPrototypeCreation(beanName);
123                                }
124                            }
125                        });
126                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
127                    }
128                    catch (IllegalStateException ex) {
129                        throw new BeanCreationException(beanName,
130                                "Scope '" + scopeName + "' is not active for the current thread; consider " +
131                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
132                                ex);
133                    }
134                }
135            }
136            catch (BeansException ex) {
137                cleanupAfterBeanCreationFailure(beanName);
138                throw ex;
139            }
140        }
141
142        // Check if required type matches the type of the actual bean instance.
143        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
144            try {
145                return getTypeConverter().convertIfNecessary(bean, requiredType);
146            }
147            catch (TypeMismatchException ex) {
148                if (logger.isDebugEnabled()) {
149                    logger.debug("Failed to convert bean '" + name + "' to required type '" +
150                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
151                }
152                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
153            }
154        }
155        return (T) bean;
156    }
157
158    
159    // org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton
160    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
161        Assert.notNull(beanName, "'beanName' must not be null");
162        synchronized (this.singletonObjects) {
163            Object singletonObject = this.singletonObjects.get(beanName);
164            if (singletonObject == null) {
165                if (this.singletonsCurrentlyInDestruction) {
166                    throw new BeanCreationNotAllowedException(beanName,
167                            "Singleton bean creation not allowed while singletons of this factory are in destruction " +
168                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
169                }
170                if (logger.isDebugEnabled()) {
171                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
172                }
173                beforeSingletonCreation(beanName);
174                boolean newSingleton = false;
175                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
176                if (recordSuppressedExceptions) {
177                    this.suppressedExceptions = new LinkedHashSet<Exception>();
178                }
179                try {
180                    singletonObject = singletonFactory.getObject();
181                    newSingleton = true;
182                }
183                catch (IllegalStateException ex) {
184                    // Has the singleton object implicitly appeared in the meantime ->
185                    // if yes, proceed with it since the exception indicates that state.
186                    singletonObject = this.singletonObjects.get(beanName);
187                    if (singletonObject == null) {
188                        throw ex;
189                    }
190                }
191                catch (BeanCreationException ex) {
192                    if (recordSuppressedExceptions) {
193                        for (Exception suppressedException : this.suppressedExceptions) {
194                            ex.addRelatedCause(suppressedException);
195                        }
196                    }
197                    throw ex;
198                }
199                finally {
200                    if (recordSuppressedExceptions) {
201                        this.suppressedExceptions = null;
202                    }
203                    afterSingletonCreation(beanName);
204                }
205                if (newSingleton) {
206                    // ref是在此处进行初始化的，有点神奇
207                    addSingleton(beanName, singletonObject);
208                }
209            }
210            return (singletonObject != NULL_OBJECT ? singletonObject : null);
211        }
212    }
213
214    // org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.addSingleton
215    protected void addSingleton(String beanName, Object singletonObject) {
216        // 就是该 synchronized 方法，触发了 ReferenceConfig.ref 的初始化，实际上是触发了 AbstractConfig.toString() 方法
217        synchronized (this.singletonObjects) {
218            this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
219            this.singletonFactories.remove(beanName);
220            this.earlySingletonObjects.remove(beanName);
221            this.registeredSingletons.add(beanName);
222        }
223    }

View Code

通过 ReferenceBean.getObject() 方法，获取代理：

1// 由 com.alibaba.dubbo.config.spring.ReferenceBean.getObject 进行获取代理，从而进行代理创建
2    @Override
3    public Object getObject() throws Exception {
4        return get();
5    }
6    
7 // 调用父类 com.alibaba.dubbo.config.ReferenceConfig.get() 方法, 获取实例
8    public synchronized T get() {
9        if (destroyed) {
10            throw new IllegalStateException("Already destroyed!");
11        }
12        if (ref == null) {
13            // 未初始化时，触发一次初始化
14            init();
15        }
16        return ref;
17    }

真正的代理之路开始了：

1// 初始化代理，并设值到 ref 变量中
2    private void init() {
3        if (initialized) {
4            return;
5        }
6        initialized = true;
7        if (interfaceName == null || interfaceName.length() == 0) {
8            throw new IllegalStateException("<dubbo:reference interface=\"\" /> interface not allow null!");
9        }
10        // 在此处添加堆栈打印，排除路径，如下
11        new Throwable("*******************************ReferenceConfig.init trace dump").printStackTrace();
12        new Throwable().printStackTrace();
13        // get consumer's global configuration
14        checkDefault();
15        appendProperties(this);
16        if (getGeneric() == null && getConsumer() != null) {
17            setGeneric(getConsumer().getGeneric());
18        }
19        if (ProtocolUtils.isGeneric(getGeneric())) {
20            interfaceClass = GenericService.class;
21        } else {
22            try {
23                interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
24                        .getContextClassLoader());
25            } catch (ClassNotFoundException e) {
26                throw new IllegalStateException(e.getMessage(), e);
27            }
28            checkInterfaceAndMethods(interfaceClass, methods);
29        }
30        String resolve = System.getProperty(interfaceName);
31        String resolveFile = null;
32        if (resolve == null || resolve.length() == 0) {
33            resolveFile = System.getProperty("dubbo.resolve.file");
34            if (resolveFile == null || resolveFile.length() == 0) {
35                File userResolveFile = new File(new File(System.getProperty("user.home")), "dubbo-resolve.properties");
36                if (userResolveFile.exists()) {
37                    resolveFile = userResolveFile.getAbsolutePath();
38                }
39            }
40            if (resolveFile != null && resolveFile.length() > 0) {
41                Properties properties = new Properties();
42                FileInputStream fis = null;
43                try {
44                    fis = new FileInputStream(new File(resolveFile));
45                    properties.load(fis);
46                } catch (IOException e) {
47                    throw new IllegalStateException("Unload " + resolveFile + ", cause: " + e.getMessage(), e);
48                } finally {
49                    try {
50                        if (null != fis) fis.close();
51                    } catch (IOException e) {
52                        logger.warn(e.getMessage(), e);
53                    }
54                }
55                resolve = properties.getProperty(interfaceName);
56            }
57        }
58        if (resolve != null && resolve.length() > 0) {
59            url = resolve;
60            if (logger.isWarnEnabled()) {
61                if (resolveFile != null) {
62                    logger.warn("Using default dubbo resolve file " + resolveFile + " replace " + interfaceName + "" + resolve + " to p2p invoke remote service.");
63                } else {
64                    logger.warn("Using -D" + interfaceName + "=" + resolve + " to p2p invoke remote service.");
65                }
66            }
67        }
68        if (consumer != null) {
69            if (application == null) {
70                application = consumer.getApplication();
71            }
72            if (module == null) {
73                module = consumer.getModule();
74            }
75            if (registries == null) {
76                registries = consumer.getRegistries();
77            }
78            if (monitor == null) {
79                monitor = consumer.getMonitor();
80            }
81        }
82        if (module != null) {
83            if (registries == null) {
84                registries = module.getRegistries();
85            }
86            if (monitor == null) {
87                monitor = module.getMonitor();
88            }
89        }
90        if (application != null) {
91            if (registries == null) {
92                registries = application.getRegistries();
93            }
94            if (monitor == null) {
95                monitor = application.getMonitor();
96            }
97        }
98        checkApplication();
99        // 检查mock配置情况，尝试调用mock实例
100        checkStubAndMock(interfaceClass);
101        Map<String, String> map = new HashMap<String, String>();
102        Map<Object, Object> attributes = new HashMap<Object, Object>();
103        map.put(Constants.SIDE_KEY, Constants.CONSUMER_SIDE);
104        map.put(Constants.DUBBO_VERSION_KEY, Version.getProtocolVersion());
105        map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
106        if (ConfigUtils.getPid() > 0) {
107            map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
108        }
109        if (!isGeneric()) {
110            String revision = Version.getVersion(interfaceClass, version);
111            if (revision != null && revision.length() > 0) {
112                map.put("revision", revision);
113            }
114
115            // 获取wrapper方法
116            String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
117            if (methods.length == 0) {
118                logger.warn("NO method found in service interface " + interfaceClass.getName());
119                map.put("methods", Constants.ANY_VALUE);
120            } else {
121                map.put("methods", StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
122            }
123        }
124        map.put(Constants.INTERFACE_KEY, interfaceName);
125        appendParameters(map, application);
126        appendParameters(map, module);
127        appendParameters(map, consumer, Constants.DEFAULT_KEY);
128        appendParameters(map, this);
129        String prefix = StringUtils.getServiceKey(map);
130        if (methods != null && !methods.isEmpty()) {
131            for (MethodConfig method : methods) {
132                appendParameters(map, method, method.getName());
133                String retryKey = method.getName() + ".retry";
134                if (map.containsKey(retryKey)) {
135                    String retryValue = map.remove(retryKey);
136                    if ("false".equals(retryValue)) {
137                        map.put(method.getName() + ".retries", "0");
138                    }
139                }
140                appendAttributes(attributes, method, prefix + "." + method.getName());
141                checkAndConvertImplicitConfig(method, map, attributes);
142            }
143        }
144
145        String hostToRegistry = ConfigUtils.getSystemProperty(Constants.DUBBO_IP_TO_REGISTRY);
146        if (hostToRegistry == null || hostToRegistry.length() == 0) {
147            hostToRegistry = NetUtils.getLocalHost();
148        } else if (isInvalidLocalHost(hostToRegistry)) {
149            throw new IllegalArgumentException("Specified invalid registry ip from property:" + Constants.DUBBO_IP_TO_REGISTRY + ", value:" + hostToRegistry);
150        }
151        map.put(Constants.REGISTER_IP_KEY, hostToRegistry);
152
153        //attributes are stored by system context.
154        StaticContext.getSystemContext().putAll(attributes);
155        ref = createProxy(map);
156        ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
157        ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
158    }
159    

控制权留给mock，先检查下是否有设置，有则先检查是否正确。

1// AbstractInterfaceConfig.checkStubAndMock()
2    protected void checkStubAndMock(Class<?> interfaceClass) {
3        if (ConfigUtils.isNotEmpty(local)) {
4            Class<?> localClass = ConfigUtils.isDefault(local) ? ReflectUtils.forName(interfaceClass.getName() + "Local") : ReflectUtils.forName(local);
5            if (!interfaceClass.isAssignableFrom(localClass)) {
6                throw new IllegalStateException("The local implementation class " + localClass.getName() + " not implement interface " + interfaceClass.getName());
7            }
8            try {
9                ReflectUtils.findConstructor(localClass, interfaceClass);
10            } catch (NoSuchMethodException e) {
11                throw new IllegalStateException("No such constructor \"public " + localClass.getSimpleName() + "(" + interfaceClass.getName() + ")\" in local implementation class " + localClass.getName());
12            }
13        }
14        if (ConfigUtils.isNotEmpty(stub)) {
15            Class<?> localClass = ConfigUtils.isDefault(stub) ? ReflectUtils.forName(interfaceClass.getName() + "Stub") : ReflectUtils.forName(stub);
16            if (!interfaceClass.isAssignableFrom(localClass)) {
17                throw new IllegalStateException("The local implementation class " + localClass.getName() + " not implement interface " + interfaceClass.getName());
18            }
19            try {
20                ReflectUtils.findConstructor(localClass, interfaceClass);
21            } catch (NoSuchMethodException e) {
22                throw new IllegalStateException("No such constructor \"public " + localClass.getSimpleName() + "(" + interfaceClass.getName() + ")\" in local implementation class " + localClass.getName());
23            }
24        }
25        if (ConfigUtils.isNotEmpty(mock)) {
26            if (mock.startsWith(Constants.RETURN_PREFIX)) {
27                String value = mock.substring(Constants.RETURN_PREFIX.length());
28                try {
29                    MockInvoker.parseMockValue(value);
30                } catch (Exception e) {
31                    throw new IllegalStateException("Illegal mock json value in <dubbo:service ... mock=\"" + mock + "\" />");
32                }
33            } else {
34                Class<?> mockClass = ConfigUtils.isDefault(mock) ? ReflectUtils.forName(interfaceClass.getName() + "Mock") : ReflectUtils.forName(mock);
35                if (!interfaceClass.isAssignableFrom(mockClass)) {
36                    throw new IllegalStateException("The mock implementation class " + mockClass.getName() + " not implement interface " + interfaceClass.getName());
37                }
38                try {
39                    mockClass.getConstructor(new Class<?>[0]);
40                } catch (NoSuchMethodException e) {
41                    throw new IllegalStateException("No such empty constructor \"public " + mockClass.getSimpleName() + "()\" in mock implementation class " + mockClass.getName());
42                }
43            }
44        }
45    }
46    

获取wrapper，以备后续调用：

1// com.alibaba.dubbo.common.bytecode.Wrapper
2    public static Wrapper getWrapper(Class<?> c) {
3        while (ClassGenerator.isDynamicClass(c)) // can not wrapper on dynamic class.
4            c = c.getSuperclass();
5
6        if (c == Object.class)
7            return OBJECT_WRAPPER;
8
9        Wrapper ret = WRAPPER_MAP.get(c);
10        if (ret == null) {
11            ret = makeWrapper(c);
12            WRAPPER_MAP.put(c, ret);
13        }
14        return ret;
15    }
16    
17    private static Wrapper makeWrapper(Class<?> c) {
18        if (c.isPrimitive())
19            throw new IllegalArgumentException("Can not create wrapper for primitive type: " + c);
20
21        String name = c.getName();
22        ClassLoader cl = ClassHelper.getClassLoader(c);
23
24        StringBuilder c1 = new StringBuilder("public void setPropertyValue(Object o, String n, Object v){ ");
25        StringBuilder c2 = new StringBuilder("public Object getPropertyValue(Object o, String n){ ");
26        StringBuilder c3 = new StringBuilder("public Object invokeMethod(Object o, String n, Class[] p, Object[] v) throws " + InvocationTargetException.class.getName() + "{ ");
27
28        c1.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
29        c2.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
30        c3.append(name).append(" w; try{ w = ((").append(name).append(")$1); }catch(Throwable e){ throw new IllegalArgumentException(e); }");
31
32        Map<String, Class<?>> pts = new HashMap<String, Class<?>>(); // <property name, property types>
33        Map<String, Method> ms = new LinkedHashMap<String, Method>(); // <method desc, Method instance>
34        List<String> mns = new ArrayList<String>(); // method names.
35        List<String> dmns = new ArrayList<String>(); // declaring method names.
36
37        // get all public field.
38        for (Field f : c.getFields()) {
39            String fn = f.getName();
40            Class<?> ft = f.getType();
41            if (Modifier.isStatic(f.getModifiers()) || Modifier.isTransient(f.getModifiers()))
42                continue;
43
44            c1.append(" if( $2.equals(\"").append(fn).append("\") ){ w.").append(fn).append("=").append(arg(ft, "$3")).append("; return; }");
45            c2.append(" if( $2.equals(\"").append(fn).append("\") ){ return ($w)w.").append(fn).append("; }");
46            pts.put(fn, ft);
47        }
48
49        Method[] methods = c.getMethods();
50        // get all public method.
51        boolean hasMethod = hasMethods(methods);
52        if (hasMethod) {
53            c3.append(" try{");
54        }
55        for (Method m : methods) {
56            if (m.getDeclaringClass() == Object.class) //ignore Object's method.
57                continue;
58
59            String mn = m.getName();
60            c3.append(" if( \"").append(mn).append("\".equals( $2 ) ");
61            int len = m.getParameterTypes().length;
62            c3.append(" && ").append(" $3.length == ").append(len);
63
64            boolean override = false;
65            for (Method m2 : methods) {
66                if (m != m2 && m.getName().equals(m2.getName())) {
67                    override = true;
68                    break;
69                }
70            }
71            if (override) {
72                if (len > 0) {
73                    for (int l = 0; l < len; l++) {
74                        c3.append(" && ").append(" $3[").append(l).append("].getName().equals(\"")
75                                .append(m.getParameterTypes()[l].getName()).append("\")");
76                    }
77                }
78            }
79
80            c3.append(" ) { ");
81
82            if (m.getReturnType() == Void.TYPE)
83                c3.append(" w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4")).append(");").append(" return null;");
84            else
85                c3.append(" return ($w)w.").append(mn).append('(').append(args(m.getParameterTypes(), "$4")).append(");");
86
87            c3.append(" }");
88
89            mns.add(mn);
90            if (m.getDeclaringClass() == c)
91                dmns.add(mn);
92            ms.put(ReflectUtils.getDesc(m), m);
93        }
94        if (hasMethod) {
95            c3.append(" } catch(Throwable e) { ");
96            c3.append("     throw new java.lang.reflect.InvocationTargetException(e); ");
97            c3.append(" }");
98        }
99
100        c3.append(" throw new " + NoSuchMethodException.class.getName() + "(\"Not found method \\\"\"+$2+\"\\\" in class " + c.getName() + ".\"); }");
101
102        // deal with get/set method.
103        Matcher matcher;
104        for (Map.Entry<String, Method> entry : ms.entrySet()) {
105            String md = entry.getKey();
106            Method method = (Method) entry.getValue();
107            if ((matcher = ReflectUtils.GETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
108                String pn = propertyName(matcher.group(1));
109                c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName()).append("(); }");
110                pts.put(pn, method.getReturnType());
111            } else if ((matcher = ReflectUtils.IS_HAS_CAN_METHOD_DESC_PATTERN.matcher(md)).matches()) {
112                String pn = propertyName(matcher.group(1));
113                c2.append(" if( $2.equals(\"").append(pn).append("\") ){ return ($w)w.").append(method.getName()).append("(); }");
114                pts.put(pn, method.getReturnType());
115            } else if ((matcher = ReflectUtils.SETTER_METHOD_DESC_PATTERN.matcher(md)).matches()) {
116                Class<?> pt = method.getParameterTypes()[0];
117                String pn = propertyName(matcher.group(1));
118                c1.append(" if( $2.equals(\"").append(pn).append("\") ){ w.").append(method.getName()).append("(").append(arg(pt, "$3")).append("); return; }");
119                pts.put(pn, pt);
120            }
121        }
122        c1.append(" throw new " + NoSuchPropertyException.class.getName() + "(\"Not found property \\\"\"+$2+\"\\\" filed or setter method in class " + c.getName() + ".\"); }");
123        c2.append(" throw new " + NoSuchPropertyException.class.getName() + "(\"Not found property \\\"\"+$2+\"\\\" filed or setter method in class " + c.getName() + ".\"); }");
124
125        // make class
126        long id = WRAPPER_CLASS_COUNTER.getAndIncrement();
127        ClassGenerator cc = ClassGenerator.newInstance(cl);
128        cc.setClassName((Modifier.isPublic(c.getModifiers()) ? Wrapper.class.getName() : c.getName() + "$sw") + id);
129        cc.setSuperClass(Wrapper.class);
130
131        cc.addDefaultConstructor();
132        cc.addField("public static String[] pns;"); // property name array.
133        cc.addField("public static " + Map.class.getName() + " pts;"); // property type map.
134        cc.addField("public static String[] mns;"); // all method name array.
135        cc.addField("public static String[] dmns;"); // declared method name array.
136        for (int i = 0, len = ms.size(); i < len; i++)
137            cc.addField("public static Class[] mts" + i + ";");
138
139        cc.addMethod("public String[] getPropertyNames(){ return pns; }");
140        cc.addMethod("public boolean hasProperty(String n){ return pts.containsKey($1); }");
141        cc.addMethod("public Class getPropertyType(String n){ return (Class)pts.get($1); }");
142        cc.addMethod("public String[] getMethodNames(){ return mns; }");
143        cc.addMethod("public String[] getDeclaredMethodNames(){ return dmns; }");
144        cc.addMethod(c1.toString());
145        cc.addMethod(c2.toString());
146        cc.addMethod(c3.toString());
147
148        try {
149            Class<?> wc = cc.toClass();
150            // setup static field.
151            wc.getField("pts").set(null, pts);
152            wc.getField("pns").set(null, pts.keySet().toArray(new String[0]));
153            wc.getField("mns").set(null, mns.toArray(new String[0]));
154            wc.getField("dmns").set(null, dmns.toArray(new String[0]));
155            int ix = 0;
156            for (Method m : ms.values())
157                wc.getField("mts" + ix++).set(null, m.getParameterTypes());
158            return (Wrapper) wc.newInstance();
159        } catch (RuntimeException e) {
160            throw e;
161        } catch (Throwable e) {
162            throw new RuntimeException(e.getMessage(), e);
163        } finally {
164            cc.release();
165            ms.clear();
166            mns.clear();
167            dmns.clear();
168        }
169    }
170