二、java网络io编程（BIO、NIO）

网络编程的基本模型是c/s模型，即客户端和服务端进行通信。

服务端通过监听自身ip和绑定的端口提供服务，客服端通过制定的ip和端口发起请求，经过三次握手请求，确认连接成功，然后进行通信；而在Java发展的历程上来看主要分为三个模式

BIO：阻塞同步通信

NIO：非阻塞同步通信 

AIO：非阻塞异步通信

1.传统IO编程（同步阻塞模式）：

由图可以看出来：(上图是引用别人的图)

每一个client的访问在服务端都会产生一个线程用来处理，并在处理完后再返回clent端，最后线程销毁

缺点就是在访问量大的时候服务端的线程数量会快速增加，系统的性能则会急剧下降，最后系统崩溃（线程是操作系统宝贵的资源，windows 线程上线大于在1000左右，而Linux上线大约在2000左右，所以在连接数量大的时候，系统死的会很快，即系统无法满足高并发，高性能应用）

BIO serverSocket端

ServerSocket端方法实现

（1）.创建绑定监听端口的 SeverSocket对象，用于服务端和客户端之间请求链接

（2）.server.accept()  程序阻塞等待客户端的访问并返回socket对象

（3）.利用 accept()返回的socket  对象进行IO的读写操作（获取数据和发送数据）

（4）.完成后关闭IO流 和  释放socket对象

1. ServerSocket server = null;

2. Integer PORT= 9999; 

3.    try {

4.      //1、绑定固定的端口

5.       server = new ServerSocket(PROT);//

6.       System.out.println(" server start .. ");

7.       //2、进行阻塞（防止程序启动后直接执行到底，等待客户端的链接）

8.       Socket socket = server.accept();

9.       

10.     //3、获取输入流，并读取客户端信息

11.     InputStream is = socket.getInputStream();

12.     InputStreamReader isr =newInputStreamReader(is);

13.     BufferedReader br =newBufferedReader(isr);

14.     String info =null;

15.     while((info=br.readLine())!=null){

16.     System.out.println("Hello,我是服务器，客户端说："+info)；

17.     }

18.     socket.shutdownInput();//关闭输入流

19.     //4、获取输出流，响应客户端的请求

20.     OutputStream os = socket.getOutputStream();

21.     PrintWriter pw = new PrintWriter(os);

22.     pw.write("Hello World！");

23.     pw.flush(); 

24.     } catch (Exception e) {

25.       e.printStackTrace();

26.     } finally {

27.         if(server != null){

28.            try {

29.                server.close();

30.            } catch (IOException e) {

31.                 e.printStackTrace();

32.            }

33.      }

34.        server = null;

35.    }

clent端代码

（1）.用服务器的IP地址和端口号实例化Socket对象。

（2）.获得Socket上的流，把流封装进BufferedReader/PrintWriter的实例，以进行读写

（3）.利用Socket提供的getInputStream和getOutputStream方法，通过IO流对象，向服务器发送数据流

（4）.关闭打开的流和Socket。

1.  Socket socket = null;

2.     BufferedReader in = null;

3.     PrintWriter out = null;

4.    // 尽量使用try catch 模块执行

5.     socket = new Socket("127.0.0.1", "9999");

6.     in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

7.     out = new PrintWriter(socket.getOutputStream(), true);

8.     

9.     //向服务器端发送数据

10.     out.println("接收到客户端的请求数据...");

11.     out.println("接收到客户端的请求数据1111...");

12.     String response = in.readLine();

13.     System.out.println("Client: " + response);

14.     //下面的关闭查找放在   finally 中，保证程序完整执行

15.     in.close();

16.     out.close();

17.     socket.close();

为了解决这种情况 ，可以利用线程池来管理（限制线程最大请求数量，来减少对线程的消耗，但是连接超过最大数是只能等待有空余的线程可以复用的时候才能执行）

---

---

2、NIO编程（同步非阻塞模式）

NIO在表面上看来就是在请求和服务处理中间加了个缓冲区，即

请求数据是先将数据保存到缓冲区  然后传递个处理程序 ，处理程序再将返回值保存到缓冲区中，最后在传递给请求客户端

clent请求                ------>  |server--->   缓存buff----->   程序处理Handler

程序处理Handler    ------>  |server--->   缓存buff----->   clent请求 

其核心组件有三个

Channels

Buffers

Selectors

Channel ：通道，是指客服端和服务端之间的连接通道，用来判断服务端和客户端的链接以及两者之间的数据流传输。

Buffers : 缓存，存在与服务端一个组件，用于缓存接收客户端发来的数据，或者缓存服务端处理完后要发往客户端的数据，当数据完全缓存到buffers 的时候在传递给业务逻辑处理，或者将数据传输给客户端。

Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

dmo

Server端

1. public class NIOService {

2.     //绑定监听的端口

3.     private static int DEFAULT_PORT = 12345;  

4.     //单例的ServerSocket  

5.     private static ServerSocket server;  

6.     //线程池 懒汉式的单例  

7.     private static ExecutorService executorService = Executors.newFixedThreadPool(60);  

8.     //根据传入参数设置监听端口，如果没有参数调用以下方法并使用默认值  

9.     public static void start() throws IOException{  

10.         //使用默认值  

11.         start(DEFAULT_PORT);  

12.     }  

13.     //使用同步synchroized 

14.     public synchronized static void start(int port) throws IOException{  

15.         if(server != null) return;  

16.         try{  

17.             //通过构造函数创建ServerSocket  

18.             //如果端口合法且空闲，服务端就监听成功  

19.             server = new ServerSocket(port);  

20.             System.out.println("服务器已启动，监听端口为：" + port);  

21.             Socket socket;  

22.             //如果没有客户端接入，将阻塞在accept操作上。  

23.             while(true){  

24.                 socket = server.accept();  

25.                 //当有新的客户端接入时，会执行下面的代码  

26.                 //然后创建一个新的线程处理这条Socket链路  

27.                 executorService.execute(new DoSothingHandler(socket));  

28.             }  

29.         }finally{  

30.             //一些必要的清理工作  

31.             if(server != null){  

32.                 System.out.println("服务器已关闭。");  

33.                 server.close();  

34.                 server = null;  

35.             }  

36.         }  

37.     }  

38. }

clent端代码

1. public class NClient {  

2.     //定义检测SocketChannel的Selector对象  

3.     private Selector selector=null;  

4.     //定义处理编码和解码的字符集  

5.     private Charset charset=Charset.forName("UTF-8");  

6.     //客户端SocketChannel  

7.     private SocketChannel sc=null;  

8.     public void init() throws IOException{  

9.         selector=Selector.open();  

10.         InetSocketAddress isa=new InetSocketAddress("127.0.0.1",12345);  

11.         //调用open静态方法创建连接到指定主机的SocketChannel  

12.         sc=SocketChannel.open(isa);  

13.         //设置该sc以非阻塞方式工作  

14.         sc.configureBlocking(false);  

15.         //将Socketchannel对象注册到指定Selector  

16.         sc.register(selector, SelectionKey.OP_READ);  

17.         //启动读取服务器端数据的线程  

18.         new ClientThread().start();  

19.         //创建键盘输入流  

20.         Scanner scan=new Scanner(System.in);  

21.         while(scan.hasNextLine()){  

22.             //读取键盘输入  

23.             String line=scan.nextLine();  

24.             //将键盘输入的内容输出到SocketChannel中  

25.             sc.write(charset.encode(line));  

26.         }  

27.     }  

未完待续（如有不足之处请指出）