【日常积累】Java 网络功能之Sockets

目录

1.前言

1、概念：Socket 英文愿意是孔或插座。作为BSD UNIX的进程通信机制，取后一种意思，通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。

2、理解：

客户端如果要链接服务器，首先要知道服务器的IP地址，但服务器中有很多应用程序，光知道IP地址是不够的，因为客户端不知道链接哪一个程序，所以还需要知道一个服务器的端口号。有了服务器的IP地址和端口号，才能建立Socket连接。

3、传输的过程中还需要一个协议，协议有两种：TCP、 UDP

TCP特点：安全稳定，不会发生数据丢失，效率低，要求必须有一个服务器。因为要经历三次握手过程：1）客户端请求； 2）服务器响应 3）客户端得知服务器响应。

然后才开始传输

UDP特点：效率高，但有可能会发生数据丢失（不稳定）。不用经过服务器响应是否有空闲接受消息，自主传输

举例：视频聊天时，TCP肯定会很清晰，但有可能会卡，因为服务器可能会忙；而UDP不会很清晰，但不会卡，所以视频聊天一般使用UDP协议

2.Java Sockets 通信

Sockets使用TCP协议实现网络通信的Socket相关的类,与之前接触的微服务的REST通信不同，Sockets依赖于TCP协议（TCP协议是面向连接、可靠的、有序的, 以字节流的方式发送数据），而REST是依赖于HTTP/HTTPS协议。

2.1一对一

2.1.1服务器端代码

public class ServerTest {

    public static void main(String[] args) {
        try {
            //1.创建服务端Socket,即ServerSocket,指定绑定的端口，并监听（accept）
            ServerSocket serverSocket = new ServerSocket(8888);
            
            //2. 调用accept()方法开始监听, 等待客户端的连接
            System.out.println("Server started,wait client connect=========");
            Socket socket = serverSocket.accept();
            
            //3. 获取输入流, 并读取客户端信息
            InputStream inputStream = socket.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String info;
            while((info = bufferedReader.readLine()) != null){
                System.out.println("Client connnect success");
                System.out.println("I am Server , Client say: " + info);
            }
            //关闭输入流
            socket.shutdownInput();
            
            //4. 获取输出流, 响应客户端的请求
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter printWriter = new PrintWriter(outputStream);
            printWriter.write("Welcome!");
            printWriter.flush();
            
            
            //5. 关闭资源
            printWriter.close();
            outputStream.close();
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            socket.close();
            serverSocket.close();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.1.2客户端代码

public class ClientTest {
    public static void main(String[] args) {
        try {
            //1. 创建客户端Socket, 指定服务器地址和端口
            Socket socket = new Socket("localhost",8888);
            
            //2. 获取输出流, 向服务器端发送信息
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter printWriter = new PrintWriter(outputStream);
            printWriter.write("用户名: admin; 密码: 123");
            printWriter.flush();
            socket.shutdownOutput();
            
            //3. 获取输入流, 并读取服务器端的响应信息
            InputStream inputStream = socket.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String info = null;
            while((info = bufferedReader.readLine()) != null){
                System.out.println("I am client,Server say:" + info);
            }

            //4. 关闭资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            printWriter.close();
            outputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.1.3运行

启动Server后启动Client

在这里插入代码片

2.2 一对多

2.2.1基本步骤

基本步骤

1. 服务器端创建ServerSocket, 循环调用accept()等待客户端连接
2. 客户端创建一个socket并请求和服务器端连接
3. 服务器端接受客户端请求, 创建socket与该客户建立专线连接
4. 建立连接的两个socket在一个单独的线程上对话
5. 服务器端继续等待新的连接

2.2.2多线程服务器

package com.linewell.gov.hoox.uop.run;

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

/**
 * @author wjieyang
 * @version 1.0
 * @date 2023/3/28 15:33
 */

/**
 * 服务器端
 */
public class ServerTest2 {
    public static void main(String[] args) {
        try {
            //1. 创建一个服务器端Socket, 即ServerSocket, 指定绑定的端口, 并监听此端口
            ServerSocket serverSocket = new ServerSocket(8888);

            System.out.println("*** 服务器即将启动, 等待客户端的连接 *** ");
            Socket socket = null;
            //记录客户端的数量
            int count=0;
            //循环监听等待客户端的连接
            while (true){
                //2. 调用accept()方法开始监听, 等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新的线程
                ThreadServerTest threadServerTest= new ThreadServerTest(socket);
                //启动线程
                threadServerTest.start();
                count++;  //统计客户端的数量
                System.out.println("客户端的数量: "+count);
                InetAddress address = socket.getInetAddress();
                System.out.println("当前客户端的IP: "+address.getHostAddress());
            }

            //serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2.3 多线程服务器线程处理类

public class ServerThread extends Thread{
    Socket socket = null;
    
    public ServerThread(Socket socket){
        this.socket = socket;
    }

    
    @Override
    @SneakyThrows
    public void run() {
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        OutputStream outputStream = null;
        PrintWriter printWriter = null;


        try {
            inputStream  = socket.getInputStream();
            inputStreamReader = new InputStreamReader(inputStream);
            bufferedReader = new BufferedReader(inputStreamReader);
            String info  =null;
            while((info = bufferedReader.readLine()) != null){
                System.out.println("i am server ,clent say" + info);
            }
            
            outputStream = socket.getOutputStream();
            printWriter = new PrintWriter(outputStream);
            printWriter.write("welcome");
            printWriter.flush();
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(printWriter != null){
                printWriter.close();
            }
            if(outputStream != null){
                outputStream.close();
            }
            if(bufferedReader != null){
                bufferedReader.close();
            }
            if(inputStreamReader != null){
                inputStreamReader.close();
            }
            if(inputStream != null ){
                inputStream.close();
            }
            if(socket != null){
                socket.close();
            }
        }
        
        

    }
}

客户端代码通用，主要就是多个客户端去和一个服务器通信。

2.2.4多线程服务器运行

文档参考

Java Socket应用

socket编程函数和步骤

ocket 编程基础

给个三连吧 谢谢谢谢谢谢了