BIO模式下实现单发单收多发多收接受多个客户端的练习

Posted 2021-08-01 程序逸

最近在复习IO和NIO的相关知识点，我们先来练习一下传统的IO也就是BIO的同步阻塞通信。

目标：

1. 实现模拟服务器端和客户端的消息通信，首先实现单发单收。
2. 然后实现多发多收，并且实现一个稍微有趣的代码改进。
3. 以上两个练习是一个客户端往一个服务器端发送，最后实现多个客户端往服务器端发送，服务器端来实现接受数据。

1.单发单收的实现

• 打开idea,新建一个java项目，我们创建第一个包，并且新建两个类：Server,Client。
  
• 我们先写服务器端的代码，代码如下：

/**
 * 充当服务器端
 * 目标：客户端发送消息，服务器端接受消息
 * @author ctvit
 */
public class Server {
    public static void main(String[] args)  {

        try {

            System.out.println("=============服务端启动。。。。。============");
            //1.定义一个ServerSocket对象进行服务器端的端口注册
            ServerSocket serverSocket = new ServerSocket(8888);

            //2.监听客户端的socket连接请求
            Socket socket = serverSocket.accept();

            //3.从socket中获取一个字节输入流对象
            InputStream inputStream = socket.getInputStream();

            //4.把字节输入流包装成缓存字符输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

            //5.开始读取
            String msg="";
            if ((msg=bufferedReader.readLine())  != null){
                System.out.println("服务端接受到数据："+msg);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 通过上面的代码，我们实现读取一行数据的功能，也就是说客户端传入的数据也是一行来进行传输的，这里面有一点很值得学习，就是流的转换，将字节输入流包装成字符输入流。
• 服务器端写好了，此时就可以写客户端来模拟发送消息了，代码如下：

/**
 * 充当客户端
 * @author ctvit
 */
public class Client {
    public static void main(String[] args) {

        try {
            //1.创建socket对象请求服务器端连接
            Socket socket = new Socket("127.0.0.1",8888);
            ///2.从socket中获取字节输出流
            OutputStream outputStream = socket.getOutputStream();
            //3.把字节输出流包装成一个打印流
            PrintStream printStream = new PrintStream(outputStream);
            printStream.println("程序逸大帅哥！！！访问服务端");
            //刷新一次管道
            printStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 然后我们就可以启动服务端的主线程和客户端的主线程了，效果如下：
  

2.多发多收，实现输入两个数服务器端计算和。

• 要实现这个功能，只需要修改上面的单发单收就可以了，服务器端的话，通过if来接受一条改成while来循环读取客户端的数据，而客户端我们通过Scanner输入我们的数据来实现多次发送，具体修改代码如下：

/**
 * 充当服务器端
 * 目标：服务端可以反复的接受消息，客户端可以反复的发送消息
 * @author ctvit
 */
public class Server {
    public static void main(String[] args)  {

        try {

            System.out.println("=============服务端启动。。。。。============");
            //1.定义一个ServerSocket对象进行服务器端的端口注册
            ServerSocket serverSocket = new ServerSocket(8888);

            //2.监听客户端的socket连接请求
            Socket socket = serverSocket.accept();

            //3.从socket中获取一个字节输入流对象
            InputStream inputStream = socket.getInputStream();

            //4.把字节输入流包装成缓存字符输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));

            //5.开始读取
            String msg="";
            while ((msg=bufferedReader.readLine())  != null){
                String[] s = msg.split(" ");
                Integer sum = Integer.valueOf(s[0])+Integer.valueOf(s[1]);
                System.out.println("输入的两数之和是："+sum);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 客户端代码如下：

/**
 * 充当客户端,实现反复的向服务器端发送消息
 * @author ctvit
 */
public class Client {
    public static void main(String[] args) {

        try {
            //1.创建socket对象请求服务器端连接
            Socket socket = new Socket("127.0.0.1",8888);
            ///2.从socket中获取字节输出流
            OutputStream outputStream = socket.getOutputStream();

            Scanner scanner = new Scanner(System.in);
            while (true){
                System.out.println("请输入两个数，我们会自动求和返回给您！！！");
                String msg = scanner.nextLine();
                PrintStream printStream = new PrintStream(outputStream);
                printStream.println(msg);

                printStream.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 实现的效果：
  
  

3.服务端接受多个客户端输入消息。

• 整体思路：我们服务端通过一个死循环来持续接受客户端的socket请求，然后将这个socket连接放到一个新建的独立线程中去执行相对应响应代码，所有这里涉及到一个新的类，实现多线程。具体代码如下：
• 首先书写服务端类：

/**
 * @author ctvit
 *
 * 目标：实现服务器端可以实现和多个Socket进行通信
 * 思路：服务端每接受到一个socket就单独创建一个线程进行通信处理
 */
public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("============服务端启动了。。。。=========================");
            ServerSocket serverSocket = new ServerSocket(9999);
            while (true){
                //通过while循环不断接受socket
                Socket socket = serverSocket.accept();
                new ServerThreadReader(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 然后就是线程类，这里我获取了当前线程的id，这样可以方便辨识其是那个客户端发送的。

/**
 * @author ctvit
 */
public class ServerThreadReader extends Thread{
    private Socket socket;

    public ServerThreadReader(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        long id = Thread.currentThread().getId();
        //3.从socket中获取一个字节输入流对象
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            //4.把字节输入流包装成缓存字符输入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            //5.开始读取
            String msg="";
            while ((msg=bufferedReader.readLine())  != null){
                String[] s = msg.split(" ");
                Integer sum = Integer.valueOf(s[0])+Integer.valueOf(s[1]);
                System.out.println("客户端："+id+"的结果："+sum);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

• 然后就是客户端代码了：

/**
 * @author ctvit
 */
public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 9999);
            Scanner scanner = new Scanner(System.in);
            while (true){
                System.out.println("请输入两个数，我们会自动求和返回给您！！！");
                String msg = scanner.nextLine();
                PrintStream printStream = new PrintStream(socket.getOutputStream());
                printStream.println(msg);
                printStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

-最终的效果如下：