Java网络套接字

在Java的开发中，有一个很重要！很重要！很重要！的东西，叫做网络套接字，它被广泛的用来二次开发服务，比如大数据中台的服务链路调用等。

它的实现原理是依靠三次握手来完成通信的建立，也是TCP（传输控制协议）连接建立过程中的一个重要机制。TCP是一种可靠的、面向连接的传输层协议，它在正式传输数据之前，需要通过三次握手来建立一个可靠的连接。这个过程涉及到客户端和服务器之间的交互，具体步骤如下：、
第一次握手：客户端向服务器发送一个SYN（同步序列编号）报文段，请求建立连接。这个报文段中，SYN标志位被设置为1，同时客户端会随机生成一个初始序列号（seq）作为自己的起始序号，并将其发送给服务器。此时，客户端进入SYN_SEND状态，等待服务器的确认。

第二次握手：服务器收到客户端的SYN报文段后，会回复一个SYN-ACK（同步-确认）报文段给客户端。在这个报文段中，SYN和ACK标志位都被设置为1，表示服务器同意建立连接，并同步自己的序列号。同时，服务器会确认客户端的序列号，即在ACK字段中填写客户端的序列号加1（作为确认号ack）。此时，服务器进入SYN_RCVD状态。

第三次握手：客户端收到服务器的SYN-ACK报文段后，会发送一个ACK（确认序列编号）报文段给服务器，以确认连接建立。在这个报文段中，ACK标志位被设置为1，同时确认号ack为服务器的序列号加1。此时，客户端和服务器都进入ESTABLISHED状态，表示连接已经成功建立，可以开始传输数据了。

三次握手的目的和意义在于：
确保双方通信能力正常：通过三次握手，客户端和服务器可以相互确认对方的发送和接收能力是否正常，从而确保连接的可靠性。
同步双方初始序列号：在三次握手过程中，双方会交换并确认各自的初始序列号，这是为了后续数据传输时能够正确地进行序号匹配和确认。
防止已失效的连接请求：三次握手还可以防止因网络延迟或丢包等原因导致的已失效的连接请求被错误地接受。

总的来说，三次握手是TCP连接建立过程中的一个关键步骤，它确保了连接的可靠性和双方通信能力的正常性。在开发Java网络套接字时，理解并掌握三次握手的原理和实现方式是非常重要的。

涉及到的类都在java.net包下，如果你是刚接触套接字，你可以用下面这个最简单的案例来感受一下套接字的能力

首先准备一个服务端：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的服务端，用来处理所有客户端的链接请求 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerSoc
 */
public class ServerSoc {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9000);
            System.out.println("等待连接。。。。。");
            //accept方法会阻塞进程，检测到有客户端连接则放行
            Socket s1 = ss.accept();
            System.out.println("连接成功");
            //向客户端输出一句话，因此这里获取对客户端的输出流
            OutputStream os = s1.getOutputStream(); //获得输出流
            byte[] b = "客户端，客户端，我是服务器，收到请回答".getBytes();
            os.write(b);
            os.flush();//必须刷一下，不然写不进去
            //关闭资源
            os.close();
            s1.close(); 
            ss.close();//关闭自己
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

然后是客户端：

package one;

import java.io.InputStream;
import java.net.Socket;

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的客户端，用来链接服务端，面向用户操作 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ClientSoc
 */
public class ClientSoc {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 9000);
            //客户端要读取服务端的信息，所以这里获取连接中的输入流
            InputStream is = s.getInputStream();
            byte[] b = new byte[100];
            //读取
            int num = is.read(b);
            String msg = new String(b, 0, num);
            System.out.println(msg);
            //关资源
            is.close();
            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

启动的时候，要先启动服务端，然后在启动客户端，你就可以看到如下的输出

同样的，客户端也可以在接收完信息后，给服务端也写一句话，你只需要在上面的代码中加上各自的输入和输出流即可

服务端：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的服务端，用来处理所有客户端的链接请求 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerSoc
 */
public class ServerSoc {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9000);
            System.out.println("等待连接。。。。。");
            //accept方法会阻塞进程，检测到有客户端连接则放行
            Socket s1 = ss.accept();
            System.out.println("连接成功");
            //向客户端输出一句话，因此这里获取对客户端的输出流
            OutputStream os = s1.getOutputStream(); //获得输出流
            byte[] b = "客户端，客户端，我是服务器，收到请回答".getBytes();
            os.write(b);
            os.flush();//必须刷一下，不然写不进去

            /*
            服务端这里多了从客户端读消息的输入流
            也就是上面的代码向客户端写一句话之后
            服务端从连接的客户端中获取输入流
            从而等待客户端给服务端发送的信息
             */
            InputStream in = s1.getInputStream();
            byte[] b1 = new byte[100];
            int read = in.read(b1);
            String msg = new String(b1, 0, read);
            System.out.println(msg);

            //关闭资源
            in.close();
            os.close();
            s1.close();
            ss.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

客户端：

package one;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的客户端，用来链接服务端，面向用户操作 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ClientSoc
 */
public class ClientSoc {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 9000);
            //客户端要读取服务端的信息，所以这里获取连接中的输入流
            InputStream is = s.getInputStream();
            byte[] b = new byte[100];
            //读取
            int num = is.read(b);
            String msg = new String(b, 0, num);
            System.out.println(msg);

            /*
            客户端这里在接收完服务端的信息后
            向服务端写入一条信息
             */
            OutputStream out = s.getOutputStream();
            byte[] b1 = "服务器，服务器，我是客户端，收到请回答".getBytes();
            out.write(b1);
            out.flush();//必须刷一下，不然写不进去

            //关资源
            out.close();
            is.close();
            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

同样的，先启动服务端，然后启动客户端连接，就会得到如下输出

上面这两个案例，可以让你很方便的了解到Java提供的网络套接字能力，当然这不是全部，你还可以获取客户端的ip等等，这些都可以办到。但是上面的案例中有着写入顺序的限制，也就是无论那边都不能同时先发信息或接受，不然流就拥堵了

那么怎么能够实现基本的双向通道？来实现一对一正常对话的效果，可以用如下的代码实现

服务端：

package one;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的服务端，用来处理所有客户端的链接请求 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerSoc
 */
public class ServerSoc {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9000);
            System.out.println("等待连接。。。。。");
            //accept方法会阻塞进程，检测到有客户端连接则放行
            Socket s1 = ss.accept();
            System.out.println("连接成功");

            //获取来自客户端的输入和输出流，向客户端发送与接收信息
            BufferedReader in = new BufferedReader(new InputStreamReader(s1.getInputStream()));
            PrintWriter out = new PrintWriter(s1.getOutputStream());

            Scanner input = new Scanner(System.in);//服务端获取控制台输入的扫描器

            while(true){
            	//服务端先开始写信息发给客户端
                String serverMsg = input.nextLine();
                out.println(serverMsg);
                out.flush();
                
                //发送完消息后，进入等待发消息的状态
                String clientMsg = in.readLine();
                System.out.println(clientMsg);
            }


            //关闭资源
//            in.close();
//            out.close();
//            s1.close();
//            ss.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

客户端：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的客户端，用来链接服务端，面向用户操作 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ClientSoc
 */
public class ClientSoc {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 9000);

            //客户端一样，获取服务端的输入和输出流，向服务端端发送与接收信息
            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            PrintWriter out = new PrintWriter(s.getOutputStream());

            Scanner input = new Scanner(System.in);//服务端获取控制台输入的扫描器

            while(true){
            	//等待服务端发来的消息
                String serverMsg = in.readLine();
                System.out.println(serverMsg);
                
                //接收完消息，进入向服务端写数据的状态
                String clientMsg = input.nextLine();
                out.println(clientMsg);
                out.flush();

            }

            //关资源
//            out.close();
//            in.close();
//            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

启动还是一样的顺序，先器服务端，并先由服务端发送消息

上面的案例，虽然初步的让服务端和客户端都能发送和接收消息，但是很明显，仍然没有摆脱需要有一方先写，不能一起先写的限制，而且还是只能一句一句的来，因为用的是死循环，当然至于那一方先写是你自己决定的。那么怎么能够彻底摆脱这个问题，这就要用到多线程了，你可以把接收信息的流程放在子线程里面，如下

服务端：

package one;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的服务端，用来处理所有客户端的链接请求 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerSoc
 */
public class ServerSoc {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9000);
            System.out.println("等待连接。。。。。");
            //accept方法会阻塞进程，检测到有客户端连接则放行
            Socket s1 = ss.accept();
            System.out.println("连接成功");

            //获取客户端的输入和输出流，向客户端发送与接收信息
            BufferedReader in = new BufferedReader(new InputStreamReader(s1.getInputStream()));
            PrintWriter out = new PrintWriter(s1.getOutputStream());

            Scanner input = new Scanner(System.in);//服务端获取控制台输入的扫描器

            /*
            将双方的接收放在子线程中
             */
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String clientMsg = null;
                    try {
                        while (true){
                            clientMsg = in.readLine();
                            System.out.println(clientMsg);
                        }
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }).start();

            //主线程正常进入死循环写信息
            while(true){
                String serverMsg = input.nextLine();
                out.println(serverMsg);
                out.flush();
            }


            //关闭资源
//            in.close();
//            out.close();
//            s1.close();
//            ss.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

客户端：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的客户端，用来链接服务端，面向用户操作 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ClientSoc
 */
public class ClientSoc {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 9000);

            //客户端一样，获取服务端的输入和输出流，向服务端端发送与接收信息
            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            PrintWriter out = new PrintWriter(s.getOutputStream());

            Scanner input = new Scanner(System.in);//服务端获取控制台输入的扫描器

            /*
            将双方的接收放在子线程中
             */
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String clientMsg = null;
                    try {
                        while (true){
                            clientMsg = in.readLine();
                            System.out.println(clientMsg);
                        }
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }).start();

            //主线程正常进入死循环写信息
            while(true){
                String clientMsg = input.nextLine();
                out.println(clientMsg);
                out.flush();
            }

            //关资源
//            out.close();
//            in.close();
//            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

这次启动服务端和客户端后，就可以实现畅通无阻的对话了

上面的案例始终是但对单的，那么怎么实现群聊呢？其实现在就很简单了，不需要动客户端，让它保持现状，只需要改造一下服务端即可。上面的所有案例中，服务端其实有点不务正业了，只不过为了简化代码，强行给它写了手动输入并发送的代码，兼职一个客户端的身份相互直接对话，但其实它只需要负责接收客户端的消息，并按照要求发给所有客户端连接即可，要完成这样的流程需要对服务端做出如下更改

首先抽离服务端中所有的客户端流程，并编写所有服务端业务

package one;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的服务端，用来处理所有客户端的链接请求 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerSoc
 */
public class ServerSoc {

    //服务端持有一个所有链接的容器集合
    public static ArrayList<Socket> connections = new ArrayList<Socket>();

    //服务端群发信息方法，参数是要发送的消息
    public static void sendAll(String s) throws IOException {
        if (connections != null) {
            for (int i = 0;i<connections.size();i++) { //遍历Socket集合
                //获取每个socket的输出流
                PrintWriter pw = new PrintWriter( connections.get(i).getOutputStream() );
                //使用每个输出流发送同一条消息
                pw.println(s);
                pw.flush();
                //这里有个重点！！不能关流，因为要不停的监听消息并发送，所以不能再这里关流
            }
        }
    }

    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9000);

            //服务端等待所有的连接
            while (true){
                System.out.println("等待新连接。。。。。");
                //accept检测到链接之后将这个套接字对象放入容器并且为每个连接启动一个监听读取的线程
                Socket s1 = ss.accept();
                connections.add(s1);
                new ServerThreadForClient(s1).start();
                System.out.println("连接成功,当前所以连接如下--》");
                System.out.println(connections);
            }

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

}

为每一个连接启动一个监听消息的线程类：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ServerThreadForClient 用来承载服务端对每个连接的发送消息处理
 */
public class ServerThreadForClient extends Thread{

    private Socket s = null;

    public ServerThreadForClient(Socket adds){
        this.s = adds;
    }

    /**
     * 描述: 为一个连接启动发出消息的监听 <br/>
     * 作者: wangyang <br/>
     * 创建时间: 2025/1/2 <br/>
     * 参数: <br/>
     * 返回值:  <br/>
     */
    @Override
    public void run() {
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            String clientMsg = null;
            while (true){
                clientMsg = in.readLine();
                //调用服务端的方法向所有的客户端发送消息
                ServerSoc.sendAll(clientMsg);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

客户端保持不变：

package one;

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

/**
 * 作者: wangyang <br/>
 * 创建时间: 2025/1/2 <br/>
 * 描述: 网络套接字的客户端，用来链接服务端，面向用户操作 <br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;ClientSoc
 */
public class ClientSoc {
    public static void main(String[] args) {
        try {
            Socket s = new Socket("127.0.0.1", 9000);
            System.out.println("客户端连接服务器成功");

            //客户端一样，获取服务端的输入和输出流，向服务端端发送与接收信息
            BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
            PrintWriter out = new PrintWriter(s.getOutputStream());

            Scanner input = new Scanner(System.in);//服务端获取控制台输入的扫描器

            /*
            将双方的接收放在子线程中
             */
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String clientMsg = null;
                    try {
                        while (true){
                            clientMsg = in.readLine();
                            System.out.println(clientMsg);
                        }
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }).start();

            //主线程正常进入死循环写信息
            while(true){
                String clientMsg = input.nextLine();
                out.println(clientMsg);
                out.flush();
            }

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

}

启动服务端后，启动多个客户端，就可以看到如下效果



到此，Java套接字的基本应用就介绍完了，可以自己以此为基础衍生很多有意思的小程序，市面上也有很多现成的类库和架构，来完成不同的能力，比如上面的socket其实是一种二进制接口，想要完成丰富的能力需要写很复杂的代码，而Springboot提供了websocket用来在web的基础上完成套接字的实现，从而实现在线客服等能力的支持