01-netty基础 - 传统的BIO编程

1. 网络编程的基本模型是 Client/Server 模型。其中服务端提供位置信息（IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，双方可以通过网络套接字Socket进行通信。

2 在基于传统同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口，Socket负责发起连接操作，连接成功后，双方通过输入输出流进行同步阻塞式通信。

3 经典时间服务器 为例进行BIO编程：

4.TimeServer.java

package com.pats.file.io;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TimeServer {

	public static void main(String[] args) {
		int port = 8080;
		if(args!=null && args.length > 0) {
			port = Integer.valueOf(args[0]);
		}
		ServerSocket server = null;
		  
		   try {
			server = new ServerSocket(port);
			System.out.println("the time server is start in port:" + port);
			Socket socket = null;
            while(true){
            socket = server.accept();
            new Thread(new TimeServerHandler(socket)).start();
            }			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(server != null) {
		   System.out.println("The time server close");
		   try {
			server.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		   server = null;
			}
		}
	}
	
}

TimeServer 根据传入的参数设置监听端口，如果没有传参，默认是8080，通过一个无限循环来监听客户端连接，如果没有客户端接入，则主线程阻塞在ServerSocket的accept上。

 

5.TimeServerHandler.java

当有客户接入的时候，以Socket为参数构造TimeServerHandler对象，TimeServerHandler是一个Runnable，使用它为构造函数的参数创建一个新的客户端线程处理这条Socket链路。

package com.pats.file.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Date;

public class TimeServerHandler implements Runnable{

	private Socket socket;
	
	public TimeServerHandler(Socket socket) {
		this.socket = socket;
	}
	@Override
	public void run() {

		BufferedReader in = null;
		PrintWriter out = null;
		
		try {
			in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
			out = new PrintWriter(this.socket.getOutputStream(),true);
			String currentTime = null;
			String body = null;
			while(true) {
			body = in.readLine();
			if(body == null) {
			break;
			}
			System.out.println("The time server receive order:"+body);
			currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body)? new Date(System.currentTimeMillis()).toString() :"BAD ORDER";
			out.println(currentTime);
				
			}
		} catch (IOException e) {

			if(in != null) {
				try {
					in.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			}
			if(out != null) {
				out.close();
				out = null;
			}
			if(this.socket != null) {
			  
				try {
					this.socket.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}	
				this.socket = null;	
			}
		}
		
	}

	
}

通过BufferedRead 读取一行的方式，如果已经读到了输入流的尾部，则返回值为null，退出循环。如果读到了非空值，则对内容进行判断，如果请求消息为查询时间指令，则通过PrintWriter的println函数发送给客户端，最后退出循环。

 

6.TimeClient.java

客户端通过Socket创建，发送查询时间服务器指令，然后读取服务端响应并打印，关闭连接，释放资源，退出程序。

package com.pats.file.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.ByteBuffer;

public class TimeClient {

	public static void main(String[] args) {
		
		int port = 8080;
		if(args!=null && args.length > 0) {
			port = Integer.valueOf(args[0]);
		}
		Socket socket = null;
		BufferedReader in = null;
		PrintWriter out = null;
		try {
			socket = new Socket("127.0.0.1",port);
			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			out = new PrintWriter(socket.getOutputStream(),true);
			out.println("QUERY TIME ORDER");
			System.out.println("Send order 2 server succeed");
			String resp = in.readLine();
			System.out.println("Now is: " + resp);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(out != null) {
				out.close();
			}
			if(in != null) {
				try {
					in.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(socket != null) {
				try {
					socket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		
	}
}

7，结果：

服务端

客户端

 

8.上述为同步阻塞式 I/O 开发的时间服务器的全部代码，可以发现BIO主要问题在于每当有一个新的客户端请求进来时，服务端必须创建一个新的线程来处理客户端请求，一个线程只能处理一个客户端的请求，这种模式无法满足高性能，高并发的需求。