互联网技术17——socket编程之BIO

TCP直连接Socket与ServerSocket，先看代码

服务端：Server.java

package com.socketBio;

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

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class Server {
    final static int PORT = 8765;
    public static void main(String[] args) {
        ServerSocket server = null;

        while(true){
            try {
                //创建服务端
                server = new ServerSocket(PORT);
                System.out.println("server start");
                //服务端阻塞，监听客户端连接，一旦有客户端连接就能获取到这个客户端的socket
                Socket socket = server.accept();
                //每当有客户端请求的时候就创建一个线程，这个线程启动色事先设计好的ServerHandler的run方法
                new Thread( new ServerHandler(socket)).start();

            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(server != null){
                    try {
                        //关闭
                        server.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                server = null;
            }
        }

    }
}

 

服务端处理程序：ServerHdndler.java

package com.socketBio;

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

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class ServerHandler implements Runnable {

    private Socket socket;

    public ServerHandler(Socket socket) {
        //构造方法中一定要传入客户端请求的socket才能读取其中的信息或向其写入
        this.socket = socket;
    }

    @Override
    public void run() {
        System.out.println("运行hanndler的run方法");
        //缓冲字符流
        BufferedReader reader = null;
        //打印输出流
        PrintWriter out = null;

        try {
            //使用输入流声明一个缓冲字节输入流再包装成一个缓冲字符输入流
            reader = new BufferedReader( new InputStreamReader( this.socket.getInputStream() ));
            //通过输出字符流声明一个打印输出流
            out = new PrintWriter(this.socket.getOutputStream(),true);
            String body = null;
            while(true){//轮询的关键点1
                body = reader.readLine();//轮询的关键点2
                if(body == null) break;
                System.out.println("Server :" + body);
                out.println("服务器端返回给客户端的响应数据.");
            }

           
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            socket = null;

        }
    }
}

 

客户端：Client.java

package com.socketBio;

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

/**
 * Created by BaiTianShi on 2018/8/29.
 */
public class Client {

    final static String ADDRESS = "127.0.0.1";
    final static int PORT = 8765;

    public static void main(String[] args) {
        Socket socket= null;
        BufferedReader in = null;
        PrintWriter out = null;

        try {
            socket = new Socket(ADDRESS,PORT);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("客户端client1向服务器发送请求测试数据");
            String response = in.readLine();
            System.out.println("Client:"+ response);


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in != null) try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if(out != null)out.close();
            if(socket != null) try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            socket = null;
        }
    }
}

启动server：

启动client：

server端监测到client建立连接后：

 

但是，这样的的运行过程是每当有客户端请求的时候都会启动一个线程，会占用过多的资源。如果client与server建立的连接很多，可能耗尽机器资源。

 

补充知识：

网络编程的基本模型是client/server模型，即服务端 绑定某个端口进行监听，而客户端通过制定ip和端口号向服务端发送连接请求。通过三次握手建立连接若连接成功，则客户端就可与服务端进行通信。

三次握手：参见:  https://mp.csdn.net/postedit/82230273

 

在jdk105之前，采用伪异步的方式避免Server Scoket建立过多的线程处理客户端的请求，其内部维护着一个线程池，将客户端请求建立的socket封装成一个任务Task(实现Runnable)对象，把任务对象交给线程池管理，并配置响应的阻塞队列BlockingQueue用于缓冲任务对象。可以在线程中设置处理Client建立连接Scoket的线程池最大数量，这样就避免了无线创建子线程而造成系统资源耗尽。

Clien.java

package com.scoketExecutorBio;

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

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class Client {

    private final static String ADDRESS="127.0.0.1";
    private final static int PORT= 8764;
    public static void main(String[] args) {
        BufferedReader in = null;
        PrintWriter  out = null;
        Socket socket = null;
        try {
            socket = new Socket(ADDRESS,PORT);

            in= new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("客户端发送的请求");

            String body = in.readLine();
            System.out.println("客户端接收到的响应："+body);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in != null){
                try {
                    in.close();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (Exception e3) {
                    e3.printStackTrace();
                }
            }
            socket = null;
        }
    }
}

 

server.java

在srever使用自定义HandlerExeuctorPool，通过构造函数core和max设置核心线程数和最大线程数。服务端监听客户端请求连接的方式是通过ServerScoket.accept(）方法监听，一旦有连接，马上获取到次客户端套接字（Scoket），并将此Socket传入封装好的Task任务中，开启线程通过处理Scoket，可读客户端传过来的数据，亦可向客户端写数据。

package com.scoketExecutorBio;

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

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class Server {
     static final String ADDRESS = "127.0.0.1";
     static final int PORT = 8764;

    public static void main(String[] args) {
        Socket socket = null;
        ServerSocket server = null;

        System.out.println("服务端:"+ADDRESS+":"+PORT+"等待客户端连接中");
        HandlerExecutor executorService = new HandlerExecutor(Runtime.getRuntime().availableProcessors(),20);
        try {
            server = new ServerSocket(PORT);
            while (true){
                socket = server.accept();
                System.out.println("服务端接收到客户端连接");
                executorService.execute( new ServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(null != socket){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            server = null;
        }


    }
}

 

HandlerExeuctorPool.java

package com.scoketExecutorBio;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by BaiTianShi on 2018/8/30.
 */
public class HandlerExecutor{

    private ExecutorService executorService;
    public HandlerExecutor(int core, int max) {
        executorService = new ThreadPoolExecutor(core,max,120L, TimeUnit.SECONDS, new LinkedBlockingDeque());
    }


    public void execute(Runnable command) {
        executorService.execute(command);
    }
}

其中涉及的 new threadPoolExecutor()的方法使用详解见：https://mp.csdn.net/postedit/81917146

 

serverHandler.java

在server.java代码中，通过new ServerHandler(socket)将监听到的客户端socket传递给了ServerHandler，ServerHandler实现了Runnable接口，在run()方法中获取Client端传递给来的数据流,经过处理转换后输出。

启动server：

启动client：

启动clinet后，服务端的相应