java 网络编程基础 TCP/IP协议：服务端ServerSocket；客户端Socket; 采用多线程方式处理网络请求

1、Java中客户端和服务器端通信的简单实例

Java中能接收其他通信实体连接请求的类是ServerSocket，ServerSocket对象用于监听来自客户端的Socket连接，如果没有连接，它将一直处于等待状态 ServerSocket包含一个监听来自客户端连接请求的方法。

ServerSocket accept():  接收到一个客户端Socket的连接请求，该方法将返回一个与客户端Socket对应的Socket。如果没有客户端连接上来，该方法将一直处于等待状态，线程也被阻

塞。

客户端：Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。  

服务端：ServerSocket(int port, int backlog) 创建服务器套接字并使用指定的待办事项将其绑定到指定的本地端口号。 

 

 服务器端ServerSocket代码：

public class ServerTest {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        /**
         * 死循环接收客户端请求,accept会阻塞
         */
        while (true){
            //阻塞等待客户端连接
            Socket clientSocket = serverSocket.accept();
            try(PrintStream outputStream = new PrintStream(clientSocket.getOutputStream())) {
                outputStream.println("Hello，请求已收到。");
            }finally {
                clientSocket.close();
            }
        }
    }
}

客户端Socket：

public class ClientTest {
    public static void main(String[] args) throws IOException {
        try (Socket clientSocket = new Socket("127.0.0.1",12345);
             BufferedReader clientIn = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));){
            String line = clientIn.readLine();
            System.out.println("收到服务端返回：" + line);
        }

    }
}

2、采用多线程方式处理网络请求

前面的Server,Client程序只是进行了简单的通信操作，服务器端接收到客户端连接之后，服务器端向客户端输出了一个字符串，而客户端也只是读取服务器端的字符串后就退出了。实际应用中的客户端则可能需要和服务器端保持长时间通信，即服务器端需要不断地读取客户端数据，并向客户端写入数据，户端也需要不断地读取服务器端数据，并向服务器端写入数据。

比如我们的QQ群发消息，比如群里面有100个人上线，就有100个客户端连上了服务器，我们读取到用户发上来的消息之后，我们还要同步给剩余的99个人。这个时候如果我们使用同步的方式处理，会造成在处理我们具体的业务逻辑的时候（如果耗时比较长），我们无法获取到其他用户连接上来的Socket。

群发消息服务器端：

package tcpandudp.threadssockettest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * @ClassName Server
 * @projectName: object1
 * @author: Zhangmingda
 * @description： 群发消息
 * date: 2021/5/11.
 */
public class Server {
    private static Set<Socket> sockets = Collections.synchronizedSet(new HashSet<>());
    private static class MyRunnable implements Runnable {
        /**
         * 当前线程要处理的客户端Socket
         */
        private Socket socket;

        /**
         * @param socket 构造客户端socket
         */
        public MyRunnable(Socket socket) {
            this.socket = socket;
        }

        /**
         * 具体处理每个客户端连接请求的逻辑，封装到线程run方法中
         */
        @Override
        public void run() {
            //获取客户端发送来的数据
            String content = null;
            try (BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
                /**
                 * 每次读取一行，读取一行就广播给所有客户端，直到读尽，阻塞住，
                 */
                while ((content = br.readLine()) != null){
                    //广播给所有客端 通过socket.getOutputStream()获取输出流OutputStream
                    for (Socket s : sockets){
                        PrintStream printStream = new PrintStream(s.getOutputStream());
                        printStream.println(content);
                    }
                }
            }catch (SocketException e){
                System.out.println(socket.getInetAddress() + "已断开");;
            }
            catch (IOException e) {
                e.printStackTrace();
            }finally {
                /**
                 * 当客户端断开连接while循环跳出，关闭客户端连接，从客户端Set集合中移除客户端Socket
                 */
                sockets.remove(this.socket);
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    this.socket = null;
                }
            }
        }
    }
    public static void main(String[] args) throws IOException {
        /**
         * 服务端监听端口
         */
        ServerSocket serverSocket = new ServerSocket(8888);
        /**
         * 启动后一直等待客户端连接，获取到一个客户端就保存到客户端集合中,
         * 然后启动一个新的线程处理对应客户端请求，
         * 主线程再次等待新的客户端建联
         */
        while (true){
            Socket  client = serverSocket.accept();
            sockets.add(client);
            new Thread(new MyRunnable(client)).start();
        }
    }
}

客户端：

package tcpandudp.threadssockettest;

import java.io.*;
import java.net.Socket;


/**
 * @ClassName ClientTest
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/5/11.
 */
public class ClientTest {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",8888);
        /**
         * 启动一个线程持续读取服务端返回的数据
         */
        new Thread(){
            @Override
            public void run() {
                String content = null;
                try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()))){
                    //阻塞式等待服务端回复的数据
                    while ((content = bufferedReader.readLine()) != null){
                        System.out.println("收到服务端返回数据：" + content);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        /**
         * 主线程发送数据
         */
        try (PrintStream printStream = new PrintStream(socket.getOutputStream());
             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in))
        ){
            String line = null;
            /**
             * 如果输入的不是exit字符串，就发送输入的数据，然后一直死循环阻塞等待再次输入数据
             * 获取到了字符，内容是exit while循环false 退出
             */
            while ((line = bufferedReader.readLine()) != null && !line.equals("exit")){
                printStream.println(line);
            }
        }
    }
}

 

 

使用线程安全的ConcurrentHashMap记录客户端Socket信息(要求客户端连接后提供用户名，否则不加入群聊)：

package tcpandudp.threadssockettest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @ClassName Server
 * @projectName: object1
 * @author: Zhangmingda
 * @description： 群发消息
 * date: 2021/5/11.
 */
public class ServerRemberUsername {
    /**
     * 记录客户端信息的线程安全Map
     */
    private static ConcurrentHashMap<Socket,String> sockets = new ConcurrentHashMap<>();

    /**
     * 单线程处理逻辑
     */
    private static class MyRunnable implements Runnable {
        /**
         * 当前线程要处理的客户端Socket
         */
        private Socket socket;

        /**
         * @param socket 构造客户端socket
         */
        public MyRunnable(Socket socket) {
            this.socket = socket;
        }

        /**
         * 具体处理每个客户端连接请求的逻辑，封装到线程run方法中
         */
        @Override
        public void run() {
            //获取客户端发送来的数据
            String content = null;
            try (BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
                /**
                 * 每次读取一行，读取一行就广播给所有客户端，直到读尽，阻塞住，
                 */
                while ((content = br.readLine()) != null){
                    /**
                     * 判断是否要设置用户名
                     */
                    if (content.startsWith("username:")){
                        PrintStream printStream = new PrintStream(socket.getOutputStream());
                        if (sockets.keySet().contains(socket)){
                            printStream.println("您已设置用户名：" +sockets.get(socket) + "无需重新设置");
                        }else {
                            String username = "";
                            //格式正确
                            if (content.split(":").length > 1){
                                //获取用户名并去除前后空格
                                username = content.split(":")[1].trim();
                                System.out.println("username:"+username);
                                //用户名不为空设置用户名
                                if (! "".equals(username)){
                                    sockets.put(socket,username);
                                    printStream.println("成功设置用户名："+username);
                                }else {
                                    printStream.println("用户名不允许为空");
                                }
                            }
                            else {
                                printStream.println("用户名设置有误，格式为username:XXXXX");
                            }
                        }
                    }else {
                        /**
                         * 普通消息判断是否已登录，登录后发消息否则提示先登录
                         */
                        if (sockets.keySet().contains(socket)){
                            //广播给所有客端 通过socket.getOutputStream()获取输出流OutputStream
                            for (Socket s : sockets.keySet()){
                                PrintStream printStream = new PrintStream(s.getOutputStream());
                                printStream.println(sockets.get(socket) + ":" + content);
                            }
                        }else {
                            //未登录提示先登录
                            PrintStream printStream = new PrintStream(socket.getOutputStream());
                            printStream.println("请先登录");
                        }
                    }
                }
            }catch (SocketException e){
                System.out.println(socket.getInetAddress() + "已断开");;
            }
            catch (IOException e) {
                e.printStackTrace();
            }finally {
                /**
                 * 当客户端断开连接while循环跳出，关闭客户端连接，从客户端Set集合中移除客户端Socket
                 */
                sockets.remove(this.socket);
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    this.socket = null;
                }
            }
        }
    }
    public static void main(String[] args) throws IOException {
        /**
         * 服务端监听端口
         */
        ServerSocket serverSocket = new ServerSocket(8888);
        /**
         * 启动后一直等待客户端连接，获取到一个客户端就保存到客户端集合中,
         * 然后启动一个新的线程处理对应客户端请求，
         * 主线程再次等待新的客户端建联
         */
        while (true){
            Socket  client = serverSocket.accept();
            new Thread(new MyRunnable(client)).start();
        }
    }
}