java实现网络聊天室-什么是网络编程？套接字的网络程序开发

网络编程

为什么需要网络编程？

现在网络普及程序越来越高，网络上保存着我们日常生活中需要的各种资源，使用程序通过网络来获取这些资源的过程就需要网络编程来实现。

什么是网络编程？

网络编程，指网络上的主机，通过不同的进程以程序的方式实现网络通信(网络数据传输）。

注意也可以是同一个主机的不同进程，比如，MySQL的服务端也客户端，在开发环境一般都是在同一台主机上运行的两个不同的程序。

怎么进行网络编程？

针对网络编程，操作系统提供了用于网络编程的技术，称为Socket套接字，是系统提供的专门用来实现网络编程的一套API。Java对每种操作系统做了进一步的封装。应用程序在应用层，操作系统工作在传输层，Socket套接字就是传输层对应用层提供的API支持。传输层中最知名的协议就是TCP和 UDP。

客户端和服务器

客户端：服务的使用方。请求一般是客户端主动发起，表示目的。

服务器：服务的提供方。响应一般是服务器根据客户端的请求计算出来的结果。

Socket套接字

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

流套接字TCP

使用传输层TCP协议

TCP，即Transmission Control Protocol (传输控制协议) ，传输层协议。

TCP协议的特点:

1.有连接

2.可靠传输

3.面向字节流

4.全双工(有接收缓冲区，也有发送缓冲区)

5.大小不限

传输数据是基于IO流，没有边界多次发送，多次接收。

数据报套接字UDP

使用传输层UDP协议

UDP，即User Datagram Protocol (用户数据报协议)，传输层协议。

UDP协议的特点：

1无连接

2.不可靠传输

3.面向数据报

4.全双式(有接收缓冲区，也有发送缓冲区)

5.大小受限，一次最多传输64K

传输数据是一个整体一个整体，不能分开发送。

对比TCP与UDP

1.有无连接:TCP相当于打电话,接听方必须要接通电话双方才能通信。UDP相当于发短信，对方有没有开机都不重要。

2.可靠传输: 打电话时必须要经过拨号，接听后才可以通话，发短信发出去就不管了。如果数据包在传输的过程中丢了，TCP会有重传机制，UDP没有。

3.面向字节流和面向数据报: 打电话说一个字对方就可以听到一个字，发短信发一条条的信息对接收到才可以阅读。

4.全双工(有接收缓冲区，也有发送缓冲区): 可以打电话也可以接电话，可以发短信也可以收短信。

5.大小是否受限:电话打完了说好了我挂了啊，时间不受限，短信的大小有限制比如150个字。

UDP编程 DatagramSocket

DatagramSocket API：DatagramSocket 是UDP Socket，用于发送和接收UDP数据报。

构造方法: 方法说明

DatagramSocket()

创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口(一般用于客户端，客户端的端口一般是系统随机分配的）

DatagramSocket(int port)

创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口(一般用于服务端）

普通方法： 方法说明

void receive(DatagramPacket p)

从此套接字接收数据报(如果没有接收到数据报，该方法会阻塞待)

void send(DatagramPacket p)

从此套接字接收数据报(不会阻塞等待，直接发送)

void close()

关闭此数据报套接字

Socket的本质也是文件，之前介绍了狭义上的文件是硬盘上的文件，广义上的文件是计算机上的各种硬盘设备。

Socket对应到网卡这个硬件设备，操作系统把网卡也当做一个文件来管理。

通过网卡发数据就是写文件， 通过网卡接收数据就是读文件。

DatagramPacket

DatagramPacket是UDP Socket发送和接收的数据报，存放消息的具体内容。

构造方法: 方法说明

DatagramPacket(bytel] buf, int length)

构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组(第一个参数buf)中，接收指定长度(第二个参数length)

DatagramPacket(bytel] buf，int offset, int length，SocketAddress address)

构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组(第一个参数buf)中，从0到指定长度(第二个参数length)。address指定目的主机的IP和端口号。

普通方法： 方法说明

lnetAddress getAddress()

从接收的数据报中，获取发送端主机IP地址;或从发送的数据报中java实现网络聊天室，获取接收端主机IP地址

int getPort()

从接收的数据报中，获取发送端主机的端口号;或从发送的数据报中java实现网络聊天室，获取接收端主机端口号

bytell getData()

获取数据报中的数据

构造UDP发送的数据报时，需要传入 SocketAddress，该对象可以使用InetSocketAddress来创建。

实现

实现一个简单的UDP回显服务器与客户端(发送什么就接收什么)。

服务端：

public class UDPEchoServer {
    // 定义一个用于服务器端的DatagramSocket
    private DatagramSocket server;
    /**
     * 构造方法，完成服务器的初始化
     * @param port 端口号
     */
    public UDPEchoServer (int port) throws Exception {
        if (port > 65535 || port < 1024) {
            throw new Exception("端口号必须在1024 ~ 65535之间");
        }
        // 初始化服务器端的UDP服务
        this.server = new DatagramSocket(port);
    }
    /**
     * 对外提供服务
     */
    public void start () throws IOException {
        System.out.println("服务器已启动....");
        // 循环接收用户的请求
        while (true) {
            // 1. 创建一个用于接收请求数据的DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
            // 2. 接收请求, 把真实的内容填充到requestPacket
            server.receive(requestPacket);
            // 3. 从requestPacket获取数据
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
            // 4. 根据请求获取响应
            String response = processor (request);
            // 5. 把响应封装到DatagramPacket
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
                    response.getBytes().length, requestPacket.getSocketAddress());
            // 6. 发送数据
            server.send(responsePacket);
            // 7. 打印日志
            System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }
    public String processor(String request) {
        return request;
    }
    public static void main(String[] args) throws Exception {
        // 初始化服务器
        UDPEchoServer server = new UDPEchoServer(9999);
        // 启动服务
        server.start();
    }
}

词典服务端：

public class UDPDicServer extends UDPEchoServer {
    private Map<String, String> map = new HashMap<>();
    /**
     * 构造方法，完成服务器的初始化
     *
     * @param port 端口号
     */
    public UDPDicServer(int port) throws Exception {
        super(port);
        map.put("dog", "小狗");
        map.put("cat", "小猫");
        map.put("pig", "小猪");
        map.put("tiger", "大老虎");
        map.put("veryGood", "牛P");
    }
    @Override
    public String processor(String request) {
        return map.getOrDefault(request, "查无此词");
    }
    public static void main(String[] args) throws Exception {
        UDPDicServer server = new UDPDicServer(9999);
        server.start();
    }
}

客户端：

public class UDPEchoClient {
    // 定义一个用于客户端的DatagramSocket
    private DatagramSocket client;
    // 定义服务器的IP地址
    private String serverIp;
    // 定义服务器的端口号
    private int port;
    private SocketAddress address;
    /**
     * 构造方法,指定服务器的Ip地址和端口号
     *
     * @param serverIp 服务器IP
     * @param port 端口号
     */
    public UDPEchoClient (String serverIp, int port) throws SocketException {
        this.client = new DatagramSocket();
        this.serverIp = serverIp;
        this.port = port;
        this.address = new InetSocketAddress(serverIp, port);
    }
    public void start () throws IOException {
        System.out.println("客户端已启动.");
        // 循环接收用户的输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("->");
            // 接收用户输入
            String request = scanner.next();
            // 1. 把请求内容包装成DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),
                    request.getBytes().length, address);
            // 2. 发送数据
            client.send(requestPacket);
            // 3. 接收响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
            // 4. 在receive方法中填充响应数据
            client.receive(responsePacket);
            // 5. 解析响应数据
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
            // 6. 打印日志
            System.out.printf("request: %s, response: %s.\n", request, response);
        }
    }
    public static void main(String[] args) throws IOException {
        UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9999);
        // 启动服务
        client.start();
    }
}

服务端与客户端的执行关系：

服务端服务端

构造Socket对象，启动Socket服务

socket.receive()进入接收状态，阻塞等待请求到来

启动客户端

指定服务器IP和端口，构造packet，socket.sent()发送请求

receive得到数据，线程唤醒，开始处理

等待服务端响应socket.receive()，进入阻塞，等待服务器响应。

响应处理结果socket.sent()

receive接收响应，线程唤醒

进入下一次循环，继续在receive阻塞等待请求

展示结果

阻塞等待：

TCP编程 ServerSocket

ServerSocket 是创建TCP服务端Socket的API。

构造方法 方法说明

ServerSocket(int port)

创建一个服务端流套接字Socket，并绑定到指定端口。操作系统中端口号会和进程绑定。

普通方法 方法说明

Socket accept()

开始监听指定端口(创建时绑定的端口)，有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户进行连接，否则阻塞等待。返回的Socket对象包含了封装好的数据。

void close()

关闭此套接字

Socket

socket 是客户端Socket，或服务端中接收到客户端建立连接 (accept方法)的请求后，返回的服务端Socket。不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

构造方法 方法方法

Socket(String host, intport)

创建一个客户端流套接字Socket，并与对应IP的主机和对应端口的进程建立连接

普通方法 方法说明

lnetAddress getlnetAddress()

返回套接字所连接的地址

InputStream getlnputStream()

返回此套接字的输入流

OutputStream getOutputStream()

返回此套接字的输出流

InputStream输入流，从网卡缓冲区读取数据；OutputStream输出流，把数据写到网卡缓冲区，相当于发数据。

实现

实现一个简单的TCP聊天服务器与客户端。

服务端：

public class TCPEchoServer {
    // 声明一个用于服务端的Socket对象
    private ServerSocket server;
    /**
     * 通过指定端口号实例化服务
     *
     * @param port 端口号
     * @throws IOException
     */
    public TCPEchoServer(int port) throws IOException {
        if (port < 1025 || port > 65535) {
            throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
        }
        // 实例化ServerSocket并指定端口号
        this.server = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动成功...");
        // 循环接收客户端的连接
        while (true) {
            Socket clientSocket = server.accept();
            // 处理Socket中的数据
            processConnections(clientSocket);
        }
    }
    // 处理数据
    private void processConnections(Socket clientSocket) throws IOException {
        // 打印日志
        String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
                clientSocket.getPort());
        System.out.println(clientInfo);
        // 处理数据之前要获取一下输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 循环处理用户的请求
            while (true) {
                // 通过Scanner读取用户请求中的数据
                Scanner requestScanner = new Scanner(inputStream);
                if (!requestScanner.hasNextLine()) {
                    // 日志
                    clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 获取真实的用户请求数据
                String request = requestScanner.nextLine();
                // 根据请求计算响应
                String response = process(request);
                // 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 写入输出流
                printWriter.println(response);
                // 强制刷新缓冲区
                printWriter.flush();
                // 打印日志
                clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
                        clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
                System.out.println(clientInfo);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }
    private String process(String request) {
        System.out.println("收到新消息："  + request);
        Scanner scanner = new Scanner(System.in);
        String response = scanner.nextLine();
        return response;
    }
    public static void main(String[] args) throws IOException {
        TCPEchoServer server = new TCPEchoServer(9999);
        server.start();
    }
}

客户端：

public class TCPEchoClient {
    // 定义一个用于客户端的Socket对象
    private Socket clientSocket;
    /**
     * 初始化客户端的Socket
     *
     * @param serverIp 服务器IP地址
     * @param serverPort 服务器的端口号
     * @throws IOException
     */
    public TCPEchoClient (String serverIp, int serverPort) throws IOException {
        this.clientSocket = new Socket(serverIp, serverPort);
    }
    public void start () throws IOException {
        System.out.println("客户端已启动...");
        // 获取Socket中的输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 循环处理用户的输入
            while (true) {
                System.out.println("->");
                // 接收用户的输入内容
                Scanner requestScanner = new Scanner(System.in);
                String request = requestScanner.nextLine();
                // 发送用户的请求
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                // 强制刷新缓冲区
                printWriter.flush();
                // 接收服务器的响应
                Scanner responseScanner = new Scanner(inputStream);
                // 获取响应数据
                String response = responseScanner.nextLine();
                // 打印响应内容
                System.out.println("接收到服务器的响应：" + response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }
    public static void main(String[] args) throws IOException {
        TCPEchoClient client = new TCPEchoClient("127.0.0.1", 9999);
        client.start();
    }
}

当打开多个客户端时，发现服务器并不能同时处理多个请求。为了解决这个问题，可以先让客户端1断开连接。为了实现服务器可以处理多个客户端连接，那么可以为每一个客户端连接创建一个新的线程，让请求的处理在单独的子线程中去执行。但是如果说每接收到客户端连接就创建新的线程，当有1万个连接就要创建1万个线程，会消耗非常大的系统资源。所以为了优化这个问题，可以使用线程池的方式。

客户端start()方法优化:

    public void start() throws IOException {
        System.out.println("服务器启动成功...");
        // 创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10));
        // 循环接收客户端的连接
        while (true) {
            Socket clientSocket = server.accept();
            // 每接收到一个新连接请求，就创建一个新的子线程
//            Thread thread = new Thread(() -> {
//                // 处理Socket中的数据
//                try {
//                    processConnections(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            // 启动线程
//            thread.start();
            // 提交任务到线程池中
            poolExecutor.submit(() -> {
                try {
                    processConnections(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }

继续加油~