释放双眼，带上耳机，听听看~！
配置
Xml配置
| 配置项说明 详细配置项，请参见：配置参考手册 (+) |
1 | 1 |
| API使用说明 如果不想使用Spring配置，而希望通过API的方式进行调用，请参见：API配置 (+) |
1 | 1 |
| 配置使用说明 想知道如何使用配置，请参见：快速启动 (+) |
1 | 1 |
示例：
provider.xml
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
2 xml
3 version
4 =
5 "1.0"
6 encoding
7 =
8 "UTF-8"
9 ?>
10
11
12
13
14
15 <
16 beans
17 xmlns
18 =
19 "http://www.springframework.org/schema/beans"
20
21
22
23
24
25
26 xmlns:xsi
27 =
28 "http://www.w3.org/2001/XMLSchema-instance"
29
30
31
32
33
34
35 xmlns:dubbo
36 =
37 "http://code.alibabatech.com/schema/dubbo"
38
39
40
41
42
43
44 xsi:schemaLocation
45 =
46 "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
47 >
48
49
50
51
52
53
54
55
56
57
58
59
60 <
61 dubbo:application
62 name
63 =
64 "hello-world-app"
65 />
66
67
68
69
70
71
72
73
74
75
76
77
78 <
79 dubbo:registry
80 address
81 =
82 "multicast://224.5.6.7:1234"
83 />
84
85
86
87
88
89
90
91
92
93
94
95
96 <
97 dubbo:protocol
98 name
99 =
100 "dubbo"
101 port
102 =
103 "20880"
104 />
105
106
107
108
109
110
111
112
113
114
115
116
117 <
118 dubbo:service
119 interface
120 =
121 "com.alibaba.dubbo.demo.DemoService"
122 ref
123 =
124 "demoServiceLocal"
125 />
126
127
128
129
130
131
132
133
134
135
136
137
138 <
139 dubbo:reference
140 id
141 =
142 "demoServiceRemote"
143 interface
144 =
145 "com.alibaba.dubbo.demo.DemoService"
146 />
147
148
149
150
151
152
153
154
155
156
157
158 </
159 beans
160 >
161
| 所有标签者支持自定义参数，用于不同扩展点实现的特殊配置。 |
1 | 1 |
如：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2 dubbo:protocol
3 name
4 =
5 "jms"
6 >
7
8
9
10
11
12
13 <
14 dubbo:parameter
15 key
16 =
17 "queue"
18 value
19 =
20 "http://10.20.160.198/wiki/display/dubbo/10.20.31.22"
21 />
22
23
24
25
26
27 </
28 dubbo:protocol
29 >
30
或：(2.1.0开始支持)
| 注意声明：xmlns:p="http://www.springframework.org/schema/p" |
1 | 1 |
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
2 beans
3 xmlns
4 =
5 "http://www.springframework.org/schema/beans"
6
7
8
9
10
11
12 xmlns:xsi
13 =
14 "http://www.w3.org/2001/XMLSchema-instance"
15
16
17
18
19
20
21 xmlns:dubbo
22 =
23 "http://code.alibabatech.com/schema/dubbo"
24
25
26
27
28
29
30 xmlns:p
31 =
32 "http://www.springframework.org/schema/p"
33
34
35
36
37
38
39 xsi:schemaLocation
40 =
41 "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
42 >
43
44
45
46
47
48
49
50
51
52
53
54
55 <
56 dubbo:protocol
57 name
58 =
59 "jms"
60 p:queue
61 =
62 "http://10.20.160.198/wiki/display/dubbo/10.20.31.22"
63 />
64
65
66
67
68
69
70
71
72
73
74
75 </
76 beans
77 >
78
Configuration Relation:
- dubbo:service/ 服务配置，用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。
- dubbo:reference/ 引用配置，用于创建一个远程服务代理，一个引用可以指向多个注册中心。
- dubbo:protocol/ 协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。
- dubbo:application/ 应用配置，用于配置当前应用信息，不管该应用是提供者还是消费者。
- dubbo:module/ 模块配置，用于配置当前模块信息，可选。
- dubbo:registry/ 注册中心配置，用于配置连接注册中心相关信息。
- dubbo:monitor/ 监控中心配置，用于配置连接监控中心相关信息，可选。
- dubbo:provider/ 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此缺省值，可选。
- dubbo:consumer/ 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值，可选。
- dubbo:method/ 方法配置，用于ServiceConfig和ReferenceConfig指定方法级的配置信息。
- dubbo:argument/ 用于指定方法参数配置。
Configuration Override:
-
上图中以timeout为例，显示了配置的查找顺序，其它retries, loadbalance, actives等类似。
-
方法级优先，接口级次之，全局配置再次之。
- 如果级别一样，则消费方优先，提供方次之。
-
其中，服务提供方配置，通过URL经由注册中心传递给消费方。
-
建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置。
-
理论上ReferenceConfig的非服务标识配置，在ConsumerConfig，ServiceConfig, ProviderConfig均可以缺省配置。
属性配置
| 如果公共配置很简单，没有多注册中心，多协议等情况，或者想多个Spring容器想共享配置，可以使用dubbo.properties作为缺省配置。 |
1 | 1 |
| Dubbo将自动加载classpath根目录下的dubbo.properties，可以通过JVM启动参数：-Ddubbo.properties.file=xxx.properties 改变缺省配置位置。 |
1 | 1 |
| 如果classpath根目录下存在多个dubbo.properties，比如多个jar包中有dubbo.properties，Dubbo会任意加载，并打印Error日志，后续可能改为抛异常。 |
1 | 1 |
映射规则：
-
将XML配置的标签名，加属性名，用点分隔，多个属性拆成多行：
-
比如：dubbo.application.name=foo等价于<dubbo:application name="foo" />
- 比如：dubbo.registry.address=10.20.153.10:9090等价于<dubbo:registry address="10.20.153.10:9090" />
-
如果XML有多行同名标签配置，可用id号区分，如果没有id号将对所有同名标签生效：
-
比如：dubbo.protocol.rmi.port=1234等价于<dubbo:protocol id="rmi" name="rmi" port="1099" /> (协议的id没配时，缺省使用协议名作为id)
- 比如：dubbo.registry.china.address=10.20.153.10:9090等价于<dubbo:registry id="china" address="10.20.153.10:9090" />
典型配置如：
dubbo.properties
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7 dubbo.application.owner=bar
8
9
10
11
12
13 dubbo.registry.address=
14 10.20
15 .
16 153.10
17 :
18 9090
19
覆盖策略：
- JVM启动-D参数优先，这样可以使用户在部署和启动时进行参数重写，比如在启动时需改变协议的端口。
- XML次之，如果在XML中有配置，则dubbo.properties中的相应配置项无效。
- Properties最后，相当于缺省值，只有XML没有配置时，dubbo.properties的相应配置项才会生效，通常用于共享公共配置，比如应用名。
注解配置
| 2.2.1以上版本支持 |
1 | 1 |
服务提供方注解：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
2 com.alibaba.dubbo.config.annotation.Service;
3
4
5
6
7
8
9
10
11
12
13
14 @Service
15 (version=
16 "1.0.0"
17 )
18
19
20
21
22
23 public
24 class
25 FooServiceImpl
26 implements
27 FooService {
28
29
30
31
32
33
34
35
36
37
38
39
40 // ......
41
42
43
44
45
46
47
48
49
50
51
52 }
53
服务提供方配置：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
2
3
4
5
6
7 <
8 dubbo:application
9 name
10 =
11 "annotation-provider"
12 />
13
14
15
16
17
18 <
19 dubbo:registry
20 address
21 =
22 "127.0.0.1:4548"
23 />
24
25
26
27
28
29
30
31
32
33
34
35 <!-- 扫描注解包路径，多个包用逗号分隔，不填pacakge表示扫描当前ApplicationContext中所有的类 -->
36
37
38
39
40
41 <
42 dubbo:annotation
43 package
44 =
45 "com.foo.bar.service"
46 />
47
服务消费方注解：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
2 com.alibaba.dubbo.config.annotation.Reference;
3
4
5
6
7
8 import
9 org.springframework.stereotype.Component;
10
11
12
13
14
15
16
17
18
19
20
21 @Component
22
23
24
25
26
27 public
28 class
29 BarAction {
30
31
32
33
34
35
36
37
38
39
40
41
42 @Reference
43 (version=
44 "1.0.0"
45 )
46
47
48
49
50
51
52 private
53 FooService fooService;
54
55
56
57
58
59
60
61
62
63
64
65 }
66
服务消费方配置：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
2
3
4
5
6
7 <
8 dubbo:application
9 name
10 =
11 "annotation-consumer"
12 />
13
14
15
16
17
18 <
19 dubbo:registry
20 address
21 =
22 "127.0.0.1:4548"
23 />
24
25
26
27
28
29
30
31
32
33
34
35 <!-- 扫描注解包路径，多个包用逗号分隔，不填pacakge表示扫描当前ApplicationContext中所有的类 -->
36
37
38
39
40
41 <
42 dubbo:annotation
43 package
44 =
45 "com.foo.bar.action"
46 />
47
也可以使用：(等价于前面的：<dubbo:annotation package="com.foo.bar.service" />)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
2 dubbo:annotation
3 />
4
5
6
7
8
9 <
10 context:component-scan
11 base-package
12 =
13 "com.foo.bar.service"
14 >
15
16
17
18
19
20
21 <
22 context:include-filter
23 type
24 =
25 "annotation"
26 expression
27 =
28 "com.alibaba.dubbo.config.annotation.Service"
29 />
30
31
32
33
34
35 </
36 context:component-scan
37 >
38
| Spring2.5及以后版本支持component-scan，如果用的是Spring2.0及以前版本，需配置： |
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7 <
8 dubbo:annotation
9 />
10
11
12
13
14
15 <
16 bean
17 id
18 =
19 "barService"
20 class
21 =
22 "com.foo.BarServiceImpl"
23 /> |
24
1 | 1 |
API配置
| API使用范围 API仅用于OpenAPI, ESB, Test, Mock等系统集成，普通服务提供方或消费方，请采用配置方式使用Dubbo，请参见：Xml配置 (+) |
1 | 1 |
| API属性含义参考 API属性与配置项一对一，各属性含义，请参见：配置参考手册 (+)， 比如：ApplicationConfig.setName("xxx") 对应 <dubbo:application name="xxx" /> |
1 | 1 |
(1) 服务提供者：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
2 com.alibaba.dubbo.rpc.config.ApplicationConfig;
3
4
5
6
7
8 import
9 com.alibaba.dubbo.rpc.config.RegistryConfig;
10
11
12
13
14
15 import
16 com.alibaba.dubbo.rpc.config.ProviderConfig;
17
18
19
20
21
22 import
23 com.alibaba.dubbo.rpc.config.ServiceConfig;
24
25
26
27
28
29 import
30 com.xxx.XxxService;
31
32
33
34
35
36 import
37 com.xxx.XxxServiceImpl;
38
39
40
41
42
43
44
45
46
47
48
49 // 服务实现
50
51
52
53
54
55 XxxService xxxService =
56 new
57 XxxServiceImpl();
58
59
60
61
62
63
64
65
66
67
68
69 // 当前应用配置
70
71
72
73
74
75 ApplicationConfig application =
76 new
77 ApplicationConfig();
78
79
80
81
82
83 application.setName(
84 "xxx"
85 );
86
87
88
89
90
91
92
93
94
95
96
97 // 连接注册中心配置
98
99
100
101
102
103 RegistryConfig registry =
104 new
105 RegistryConfig();
106
107
108
109
110
111 registry.setAddress(
112 "10.20.130.230:9090"
113 );
114
115
116
117
118
119 registry.setUsername(
120 "aaa"
121 );
122
123
124
125
126
127 registry.setPassword(
128 "bbb"
129 );
130
131
132
133
134
135
136
137
138
139
140
141 // 服务提供者协议配置
142
143
144
145
146
147 ProtocolConfig protocol =
148 new
149 ProtocolConfig();
150
151
152
153
154
155 protocol.setName(
156 "dubbo"
157 );
158
159
160
161
162
163 protocol.setPort(
164 12345
165 );
166
167
168
169
170
171 protocol.setThreads(
172 200
173 );
174
175
176
177
178
179
180
181
182
183
184
185 // 注意：ServiceConfig为重对象，内部封装了与注册中心的连接，以及开启服务端口
186
187
188
189
190
191
192
193
194
195
196
197 // 服务提供者暴露服务配置
198
199
200
201
202
203 ServiceConfig<XxxService> service =
204 new
205 ServiceConfig<XxxService>();
206 // 此实例很重，封装了与注册中心的连接，请自行缓存，否则可能造成内存和连接泄漏
207
208
209
210
211
212 service.setApplication(application);
213
214
215
216
217
218 service.setRegistry(registry);
219 // 多个注册中心可以用setRegistries()
220
221
222
223
224
225 service.setProtocol(protocol);
226 // 多个协议可以用setProtocols()
227
228
229
230
231
232 service.setInterface(XxxService.
233 class
234 );
235
236
237
238
239
240 service.setRef(xxxService);
241
242
243
244
245
246 service.setVersion(
247 "1.0.0"
248 );
249
250
251
252
253
254
255
256
257
258
259
260 // 暴露及注册服务
261
262
263
264
265
266 service.export();
267
(2) 服务消费者：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
2 com.alibaba.dubbo.rpc.config.ApplicationConfig;
3
4
5
6
7
8 import
9 com.alibaba.dubbo.rpc.config.RegistryConfig;
10
11
12
13
14
15 import
16 com.alibaba.dubbo.rpc.config.ConsumerConfig;
17
18
19
20
21
22 import
23 com.alibaba.dubbo.rpc.config.ReferenceConfig;
24
25
26
27
28
29 import
30 com.xxx.XxxService;
31
32
33
34
35
36
37
38
39
40
41
42 // 当前应用配置
43
44
45
46
47
48 ApplicationConfig application =
49 new
50 ApplicationConfig();
51
52
53
54
55
56 application.setName(
57 "yyy"
58 );
59
60
61
62
63
64
65
66
67
68
69
70 // 连接注册中心配置
71
72
73
74
75
76 RegistryConfig registry =
77 new
78 RegistryConfig();
79
80
81
82
83
84 registry.setAddress(
85 "10.20.130.230:9090"
86 );
87
88
89
90
91
92 registry.setUsername(
93 "aaa"
94 );
95
96
97
98
99
100 registry.setPassword(
101 "bbb"
102 );
103
104
105
106
107
108
109
110
111
112
113
114 // 注意：ReferenceConfig为重对象，内部封装了与注册中心的连接，以及与服务提供方的连接
115
116
117
118
119
120
121
122
123
124
125
126 // 引用远程服务
127
128
129
130
131
132 ReferenceConfig<XxxService> reference =
133 new
134 ReferenceConfig<XxxService>();
135 // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
136
137
138
139
140
141 reference.setApplication(application);
142
143
144
145
146
147 reference.setRegistry(registry);
148 // 多个注册中心可以用setRegistries()
149
150
151
152
153
154 reference.setInterface(XxxService.
155 class
156 );
157
158
159
160
161
162 reference.setVersion(
163 "1.0.0"
164 );
165
166
167
168
169
170
171
172
173
174
175
176 // 和本地bean一样使用xxxService
177
178
179
180
181
182 XxxService xxxService = reference.get();
183 // 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用
184
(3) 特殊场景
注：下面只列出不同的地方，其它参见上面的写法
(3.1) 方法级设置：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
2
3
4
5
6
7
8
9
10
11
12
13 // 方法级配置
14
15
16
17
18
19 List<MethodConfig> methods =
20 new
21 ArrayList<MethodConfig>();
22
23
24
25
26
27 MethodConfig method =
28 new
29 MethodConfig();
30
31
32
33
34
35 method.setName(
36 "createXxx"
37 );
38
39
40
41
42
43 method.setTimeout(
44 10000
45 );
46
47
48
49
50
51 method.setRetries(
52 0
53 );
54
55
56
57
58
59 methods.add(method);
60
61
62
63
64
65
66
67
68
69
70
71 // 引用远程服务
72
73
74
75
76
77 ReferenceConfig<XxxService> reference =
78 new
79 ReferenceConfig<XxxService>();
80 // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
81
82
83
84
85
86 ...
87
88
89
90
91
92 reference.setMethods(methods);
93 // 设置方法级配置
94
95
96
97
98
99
100
101
102
103
104
105 ...
106
(3.2) 点对点直连：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
2
3
4
5
6
7
8
9
10
11
12
13 ReferenceConfig<XxxService> reference =
14 new
15 ReferenceConfig<XxxService>();
16 // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
17
18
19
20
21
22 // 如果点对点直连，可以用reference.setUrl()指定目标地址，设置url后将绕过注册中心，
23
24
25
26
27
28 // 其中，协议对应provider.setProtocol()的值，端口对应provider.setPort()的值，
29
30
31
32
33
34 // 路径对应service.setPath()的值，如果未设置path，缺省path为接口名
35
36
37
38
39
40 reference.setUrl(
41 "dubbo://10.20.130.230:20880/com.xxx.XxxService"
42 );
43
44
45
46
47
48
49
50
51
52
53
54 ...
55
