释放双眼，带上耳机，听听看~！
本站采用创作共用版权 CC BY-NC-ND/2.5/CN 许可协议，
如非特别注明，本站内容均为OneCoder原创，转载请务必注明作者和出处本文地址：链接地址
Java程序员-1群
(已满)：225893085：Java程序员-2群：206787481：
Java程序员群论坛，每天分享实用资源OneCoder的图传已从又拍图片管家迁移到七牛云存储，由于文章过多无法一一修改，如果文中图片无法显示，麻烦留言通知我。我会第一时间修改。邮箱地址：wushikezuo@gmail.com
先啰嗦两句，如果你还不知道Netty是做什么的能做什么。那可以先简单的搜索了解一下。我只能说Netty是一个NIO的框架，可以用于开发分布式的Java程序。具体能做什么，各位可以尽量发挥想象。技术，是服务于人而不是局限住人的。
Netty的简介和下载可参考：《 开源Java高性能NIO框架推荐 – Netty》。注意，此时的最新版已经为3.5.2.Final。
如果你已经万事具备，那么我们先从一段代码开始。程序员们习惯的上手第一步，自然是"Hello world"，不过Netty官网的例子却偏偏抛弃了"Hello world"。那我们就自己写一个最简单的"Hello world"的例子，作为上手。
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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
2
3
4
5
6
7
8 * Netty 服务端代码
9
10
11
12
13
14
15 *
16
17
18
19
20
21
22 * @author lihzh
23
24
25
26
27
28
29 * @alia OneCoder
30
31
32
33
34
35
36 * @blog http://www.coderli.com
37
38
39
40
41
42
43 */
44
45
46
47
48
49 public
50 class
51 HelloServer {
52
53
54
55
56
57
58
59
60
61
62
63
64 public
65 static
66 void
67 main(String args[]) {
68
69
70
71
72
73
74 // Server服务启动器
75
76
77
78
79
80
81 ServerBootstrap bootstrap =
82 new
83 ServerBootstrap(
84
85
86
87
88
89
90 new
91 NioServerSocketChannelFactory(
92
93
94
95
96
97
98 Executors.newCachedThreadPool(),
99
100
101
102
103
104
105 Executors.newCachedThreadPool()));
106
107
108
109
110
111
112 // 设置一个处理客户端消息和各种消息事件的类(Handler)
113
114
115
116
117
118
119 bootstrap
120
121
122
123
124
125
126 .setPipelineFactory(
127 new
128 ChannelPipelineFactory() {
129
130
131
132
133
134
135 @Override
136
137
138
139
140
141
142 public
143 ChannelPipeline getPipeline()
144
145
146
147
148
149
150 throws
151 Exception {
152
153
154
155
156
157
158 return
159 Channels
160
161
162
163
164
165
166 .pipeline(
167 new
168 HelloServerHandler());
169
170
171
172
173
174
175 }
176
177
178
179
180
181
182 });
183
184
185
186
187
188
189 // 开放8000端口供客户端访问。
190
191
192
193
194
195
196 bootstrap.bind(
197 new
198 InetSocketAddress(
199 8000
200 ));
201
202
203
204
205
206
207 }
208
209
210
211
212
213
214
215
216
217
218
219
220 private
221 static
222 class
223 HelloServerHandler
224 extends
225
226
227
228
229
230
231 SimpleChannelHandler {
232
233
234
235
236
237
238
239
240
241
242
243
244 /**
245
246
247
248
249
250
251 * 当有客户端绑定到服务端的时候触发，打印"Hello world, I'm server."
252
253
254
255
256
257
258 *
259
260
261
262
263
264
265 * @alia OneCoder
266
267
268
269
270
271
272 * @author lihzh
273
274
275
276
277
278
279 */
280
281
282
283
284
285
286 @Override
287
288
289
290
291
292
293 public
294 void
295 channelConnected(
296
297
298
299
300
301
302 ChannelHandlerContext ctx,
303
304
305
306
307
308
309 ChannelStateEvent e) {
310
311
312
313
314
315
316 System.out.println(
317 "Hello world, I'm server."
318 );
319
320
321
322
323
324
325 }
326
327
328
329
330
331
332 }
333
334
335
336
337
338 }
339
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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
2
3
4
5
6
7
8 * Netty 客户端代码
9
10
11
12
13
14
15 *
16
17
18
19
20
21
22 * @author lihzh
23
24
25
26
27
28
29 * @alia OneCoder
30
31
32
33
34
35
36 * @blog http://www.coderli.com
37
38
39
40
41
42
43 */
44
45
46
47
48
49 public
50 class
51 HelloClient {
52
53
54
55
56
57
58
59
60
61
62
63
64 public
65 static
66 void
67 main(String args[]) {
68
69
70
71
72
73
74 // Client服务启动器
75
76
77
78
79
80
81 ClientBootstrap bootstrap =
82 new
83 ClientBootstrap(
84
85
86
87
88
89
90 new
91 NioClientSocketChannelFactory(
92
93
94
95
96
97
98 Executors.newCachedThreadPool(),
99
100
101
102
103
104
105 Executors.newCachedThreadPool()));
106
107
108
109
110
111
112 // 设置一个处理服务端消息和各种消息事件的类(Handler)
113
114
115
116
117
118
119 bootstrap.setPipelineFactory(
120 new
121 ChannelPipelineFactory() {
122
123
124
125
126
127
128 @Override
129
130
131
132
133
134
135 public
136 ChannelPipeline getPipeline()
137 throws
138 Exception {
139
140
141
142
143
144
145 return
146 Channels.pipeline(
147 new
148 HelloClientHandler());
149
150
151
152
153
154
155 }
156
157
158
159
160
161
162 });
163
164
165
166
167
168
169 // 连接到本地的8000端口的服务端
170
171
172
173
174
175
176 bootstrap.connect(
177 new
178 InetSocketAddress(
179
180
181
182
183
184
185 "127.0.0.1"
186 ,
187 8000
188 ));
189
190
191
192
193
194
195 }
196
197
198
199
200
201
202
203
204
205
206
207
208 private
209 static
210 class
211 HelloClientHandler
212 extends
213 SimpleChannelHandler {
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 * 当绑定到服务端的时候触发，打印"Hello world, I'm client."
240
241
242
243
244
245
246 *
247
248
249
250
251
252
253 * @alia OneCoder
254
255
256
257
258
259
260 * @author lihzh
261
262
263
264
265
266
267 */
268
269
270
271
272
273
274 @Override
275
276
277
278
279
280
281 public
282 void
283 channelConnected(ChannelHandlerContext ctx,
284
285
286
287
288
289
290 ChannelStateEvent e) {
291
292
293
294
295
296
297 System.out.println(
298 "Hello world, I'm client."
299 );
300
301
302
303
304
305
306 }
307
308
309
310
311
312
313 }
314
315
316
317
318
319 }
320
既然是分布式的，自然要分多个服务。Netty中，需要区分Server和Client服务。所有的Client都是绑定在Server上的，他们之间是不能通过Netty直接通信的。（自己采用的其他手段，不包括在内。）。白话一下这个通信过程，Server端开放端口，供Client连接，Client发起请求，连接到Server指定的端口，完成绑定。随后便可自由通信。其实就是普通Socket连接通信的过程。
Netty框架是基于事件机制的，简单说，就是发生什么事，就找相关处理方法。就跟着火了找119，抢劫了找110一个道理。所以，这里，我们处理的是当客户端和服务端完成连接以后的这个事件。什么时候完成的连接，Netty知道，他告诉我了，我就负责处理。这就是框架的作用。Netty，提供的事件还有很多，以后会慢慢的接触和介绍。
你应该已经可以上手了：）
如非特别注明，本站内容均为OneCoder原创，转载请务必注明作者和原始出处。
本文地址：链接地址
