开发过Web应用的同学应该都会使用session。由于HTTP协议本身是无状态的，所以一个客户端多次访问这个web应用的多个页面，服务器无法判断多次访问的客户端是否是同一个客户端。有了session就可以设置一些和客户端相关的属性，用于保持这种连接状态。例如用户登录系统后，设置session标记这个客户端已登录，那么访问别的页面时就不用再次登录了。
不过本文的内容不是Web应用的session，而是TCP连接的session，实际上二者还是有很大区别的。Web应用的session实现方式并不是基于同一个TCP连接，而是通过cookie实现，这里不再详细展开。上面讲到Web应用的session只是让大家理解session的概念。
在同步阻塞的网络编程中，代码都是按照TCP操作顺序编写的，即创建连接、多次读写、关闭连接，这样很容易判断这一系列操作是否是同一个连接。而在事件驱动的异步网络编程框架中，IO操作都会触发一个事件调用相应的事件函数，例如接收到客户端的新数据，会调用messageReceived（MINA）、channelRead（Netty）、dataReceived（Twisted），同一个TCP连接的多次请求和多个客户端请求都是一样的。
那么如何判断多次请求到底是不是同一个TCP连接，如何保存连接相关的信息？针对这个问题，MINA、Netty、Twisted都提供了相应的解决方案。
下面分别用MINA、Netty、Twisted实现一个请求次数计数器，用于记录同一个连接多次请求的请求次数。
**MINA：
**
在MINA中，每当一个客户端连接到服务器，就会创建一个新的IoSession，直到客户端断开连接才会销毁。IoSession可以用setAttribute和getAttribute来存储和获取一个TCP连接的相关信息。
MINA官方文档对IoSession的解释：
The Session is at the heart of MINA : every time a client connects to the server, a new session is created, and will be kept in memory until the client is disconnected.
A session is used to store persistent informations about the connection, plus any kind of information the server might need to use during the request processing, and eventually during the whole session life.
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
2
3 public static void main(String[] args) throws IOException {
4 IoAcceptor acceptor = new NioSocketAcceptor();
5
6 acceptor.getFilterChain().addLast("codec",
7 new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"), "\r\n", "\r\n")));
8
9 acceptor.setHandler(new TcpServerHandle());
10 acceptor.bind(new InetSocketAddress(8080));
11 }
12
13}
14
15class TcpServerHandle extends IoHandlerAdapter {
16
17 @Override
18 public void exceptionCaught(IoSession session, Throwable cause)
19 throws Exception {
20 cause.printStackTrace();
21 }
22
23 // 接收到新的数据
24 @Override
25 public void messageReceived(IoSession session, Object message)
26 throws Exception {
27
28 int counter = 1;
29
30 // 第一次请求，创建session中的counter
31 if(session.getAttribute("counter") == null) {
32 session.setAttribute("counter", 1);
33 } else {
34 // 获取session中的counter，加1后再存入session
35 counter = (Integer) session.getAttribute("counter");
36 counter++;
37 session.setAttribute("counter", counter);
38 }
39
40 String line = (String) message;
41 System.out.println("第" + counter + "次请求:" + line);
42 }
43}
44
Netty：
Netty中分为两种情况，一种是针对每个TCP连接创建一个新的ChannelHandler实例，另一种是所有TCP连接共用一个ChannelHandler实例。这两种方式的区别在于ChannelPipeline的addLast方法中添加的是否是新的ChannelHandler实例。
**针对每个TCP连接创建一个新的ChannelHandler实例：
**
针对每个TCP连接创建一个新的ChannelHandler实例是最常用的一种方式。这种情况非常简单，直接在ChannelHandler的实现类中加入一个成员变量即可保存连接相关的信息。
这也是Netty官方文档中推荐的一种方式，不过要保证针对每个连接创建新的ChannelHandler实例：
A ChannelHandler often needs to store some stateful information. The simplest and recommended approach is to use member variables.
Because the handler instance has a state variable which is dedicated to one connection, you have to create a new handler instance for each new channel to avoid a race condition where a unauthenticated client can get the confidential information.
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
2
3 public static void main(String[] args) throws InterruptedException {
4 EventLoopGroup bossGroup = new NioEventLoopGroup();
5 EventLoopGroup workerGroup = new NioEventLoopGroup();
6 try {
7 ServerBootstrap b = new ServerBootstrap();
8 b.group(bossGroup, workerGroup)
9 .channel(NioServerSocketChannel.class)
10 .childHandler(new ChannelInitializer<SocketChannel>() {
11 @Override
12 public void initChannel(SocketChannel ch) throws Exception {
13 ChannelPipeline pipeline = ch.pipeline();
14 pipeline.addLast(new LineBasedFrameDecoder(80));
15 pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
16 pipeline.addLast(new TcpServerHandler()); // 针对每个TCP连接创建一个新的ChannelHandler实例
17 }
18 });
19 ChannelFuture f = b.bind(8080).sync();
20 f.channel().closeFuture().sync();
21 } finally {
22 workerGroup.shutdownGracefully();
23 bossGroup.shutdownGracefully();
24 }
25 }
26
27}
28
29class TcpServerHandler extends ChannelInboundHandlerAdapter {
30
31 // 连接相关的信息直接保存在TcpServerHandler的成员变量中
32 private int counter = 0;
33
34 @Override
35 public void channelRead(ChannelHandlerContext ctx, Object msg) {
36
37 counter++;
38
39 String line = (String) msg;
40 System.out.println("第" + counter + "次请求:" + line);
41 }
42
43 @Override
44 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
45 cause.printStackTrace();
46 ctx.close();
47 }
48}
49
所有TCP连接共用一个ChannelHandler实例：
在这种情况下，就不能把连接相关的信息放在ChannelHandler实现类的成员变量中了，否则这些信息会被其他连接共用。这里就要使用到ChannelHandlerContext的Attribute了。
Netty文档节选：
Although it's recommended to use member variables to store the state of a handler, for some reason you might not want to create many handler instances. In such a case, you can use AttributeKeys which is provided by ChannelHandlerContext.
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
2
3 public static void main(String[] args) throws InterruptedException {
4 EventLoopGroup bossGroup = new NioEventLoopGroup();
5 EventLoopGroup workerGroup = new NioEventLoopGroup();
6 try {
7 ServerBootstrap b = new ServerBootstrap();
8 b.group(bossGroup, workerGroup)
9 .channel(NioServerSocketChannel.class)
10 .childHandler(new ChannelInitializer<SocketChannel>() {
11
12 private TcpServerHandler tcpServerHandler = new TcpServerHandler();
13
14 @Override
15 public void initChannel(SocketChannel ch) throws Exception {
16 ChannelPipeline pipeline = ch.pipeline();
17 pipeline.addLast(new LineBasedFrameDecoder(80));
18 pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
19 pipeline.addLast(tcpServerHandler); // 多个连接使用同一个ChannelHandler实例
20 }
21 });
22 ChannelFuture f = b.bind(8080).sync();
23 f.channel().closeFuture().sync();
24 } finally {
25 workerGroup.shutdownGracefully();
26 bossGroup.shutdownGracefully();
27 }
28 }
29
30}
31
32@Sharable // 多个连接使用同一个ChannelHandler，要加上@Sharable注解
33class TcpServerHandler extends ChannelInboundHandlerAdapter {
34
35 private AttributeKey<Integer> attributeKey = AttributeKey.valueOf("counter");
36
37 @Override
38 public void channelRead(ChannelHandlerContext ctx, Object msg) {
39
40 Attribute<Integer> attribute = ctx.attr(attributeKey);
41
42 int counter = 1;
43
44 if(attribute.get() == null) {
45 attribute.set(1);
46 } else {
47 counter = attribute.get();
48 counter++;
49 attribute.set(counter);
50 }
51
52 String line = (String) msg;
53 System.out.println("第" + counter + "次请求:" + line);
54 }
55
56 @Override
57 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
58 cause.printStackTrace();
59 ctx.close();
60 }
61}
62
Twisted：
在Twisted中，每个TCP连接都会创建一个新的Protocol实例，这样也就很简单了，直接将连接相关的信息保存为Protocol继承类的属性。
Twisted文档节选：
An instance of the protocol class is instantiated per-connection, on demand, and will go away when the connection is finished.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3from twisted.protocols.basic import LineOnlyReceiver
4from twisted.internet.protocol import Factory
5from twisted.internet import reactor
6
7class TcpServerHandle(LineOnlyReceiver):
8
9 # 连接相关的信息直接保存为Protocol继承类TcpServerHandle的属性
10 counter = 0;
11
12 def lineReceived(self, data):
13 self.counter += 1
14 print "第" + str(self.counter) + "次请求:" + data
15
16factory = Factory()
17factory.protocol = TcpServerHandle
18reactor.listenTCP(8080, factory)
19reactor.run()
20
下面是一个Java实现的客户端，代码中发起了3次TCP连接，在每个连接中发送两次请求数据到服务器：
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
2
3 public static void main(String[] args) throws IOException, InterruptedException {
4
5 // 3次TCP连接，每个连接发送2个请求数据
6 for(int i = 0; i < 3; i++) {
7
8
9 Socket socket = null;
10 OutputStream out = null;
11
12 try {
13
14 socket = new Socket("localhost", 8080);
15 out = socket.getOutputStream();
16
17 // 第一次请求服务器
18 String lines1 = "Hello\r\n";
19 byte[] outputBytes1 = lines1.getBytes("UTF-8");
20 out.write(outputBytes1);
21 out.flush();
22
23 // 第二次请求服务器
24 String lines2 = "World\r\n";
25 byte[] outputBytes2 = lines2.getBytes("UTF-8");
26 out.write(outputBytes2);
27 out.flush();
28
29 } finally {
30 // 关闭连接
31 out.close();
32 socket.close();
33 }
34
35 Thread.sleep(1000);
36 }
37 }
38}
39
分别测试上面的4个服务器，输出结果都是：
第1次请求:Hello
第2次请求:World
第1次请求:Hello
第2次请求:World
第1次请求:Hello
第2次请求:World
MINA、Netty、Twisted一起学系列
MINA、Netty、Twisted一起学（一）：实现简单的TCP服务器
MINA、Netty、Twisted一起学（二）：TCP消息边界问题及按行分割消息
MINA、Netty、Twisted一起学（三）：TCP消息固定大小的前缀(Header)
MINA、Netty、Twisted一起学（四）：定制自己的协议
MINA、Netty、Twisted一起学（五）：整合protobuf
MINA、Netty、Twisted一起学（六）：session
MINA、Netty、Twisted一起学（七）：发布/订阅（Publish/Subscribe）
MINA、Netty、Twisted一起学（八）：HTTP服务器
MINA、Netty、Twisted一起学（九）：异步IO和回调函数
MINA、Netty、Twisted一起学（十）：线程模型
MINA、Netty、Twisted一起学（十一）：SSL/TLS
MINA、Netty、Twisted一起学（十二）：HTTPS
