基于Java Socket通信的聊天室

在实现聊天室之前，先来学习以下socket通信的基本知识

什么是socket

在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据
socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。
Socket就是该模式的一个实现：即socket是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）
Socket()函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

socket的基本操作

socket()函数

int socket(int domain, int type, int protocol);

socket()函数用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

参数含义：

domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议

bind()函数

bind()函数把一个地址族中的特定地址赋给socket

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数含义：

sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字
addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址
addrlen：对应的是地址的长度

listen()函数和connect()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求

int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求
connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接

accept()函数

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接

read()函数、write()函数

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。
write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

close()函数

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数

int close(int fd);

socket实现聊天室

思路

首先启动服务器（server), 服务器端程序代码会执行到accept方法, 这是一个阻塞函数，会阻塞等待一个socket连接，如果这个函数不执行完，函数所在线程就一直停止在这里不动。
然后再启动客户端，客户端启动后，服务器的程序代码会往下走，走到while(true)循环中的readline方法，它也是一个阻塞函数，可以阻塞等待获取的客户端socket中输入流的出现，同时，客户端也会被循环中的readline方法阻塞，等待控制台中的输入流的出现，整个项目就进入了等待中。
这时，我们在客户端的界面输入框中输入一串字符，客户端中的readline就会立刻读取到这段输入流，然后客户端通过PrintWriter将该输入流通过socket的输出流推送到服务器的socket中，然后进入下一个循环的等待。而服务器中的readline方法就会立刻读取到socket的输入流，然后打印到服务器的控制台中，之后又会进入下一个循环的等待。

之所以会进入循环等待，是因为在服务器端和客户端中都使用了while(true)语句，反之，如果不设置，则只能实现一次数据的通信

代码片段

客户端：

public Client(ClientUI ui){
        this.UI=ui;
        String IP=UI.Server_IP.getText().trim();     //获取IP地址
        int Port=Integer.parseInt(UI.Server_Port.getText().trim());   //获取端口号
        try {
            client_socket=new Socket(IP,Port);  //设置连接服务器的IP地址和端口号
            Println("连接成功！");
            //获取客户端socket的输入流
            Read=new BufferedReader(new InputStreamReader(client_socket.getInputStream()));
            Write=new PrintStream(client_socket.getOutputStream());
        } catch (IOException e) {
            Println("连接失败！请重新尝试！");
            e.printStackTrace();
        } 

        new Thread(new Runnable(){
            @Override
            public void run() {
                String  message="";
                while(true){
                    try {
                        message=Read.readLine();
                    } catch (IOException e) {
                        Println("连接服务器中断！");
                        e.printStackTrace();
                        break;
                    }
                    if(message!=null&&message.trim()!=""){
                        Println(message);
                    }
                }
            }
        }).start();
    }
    public void Println(String s){
        if(s!=null){
            this.UI.Text_Show.setText("server:"+this.UI.Text_Show.getText()+s+"\n"); 
            System.out.println(s + "\n");
        }
    }  
    public void SendMessage(String text){
        try{
            Write.println(text);
        }catch(Exception e){
            Println(e.toString());
        }
    }
}

服务器端：

public class Server extends Thread{
    ServerUI ui;
    BufferedReader Read;
    PrintStream  Write;
    ServerSocket server;
    public Server(ServerUI UI){
        this.ui=UI;
        //设置服务器的端口
        int port=Integer.parseInt(ui.Port_Msg.getText().trim());
        try {
            server=new ServerSocket(port);
            Println("端口设置成功！");
        } catch (IOException e) {
            Println("端口设置失败！");
            e.printStackTrace();
        }
        this.ui.clients=new ArrayList<Socket>();
        
        //创建一个线程，用来等待客户端的连接
        new Thread(new Runnable(){
            @Override
            public void run() {
                    while(true){
                        Println("等待客户端接入...");
                        Socket Client = null;
                        try {
                            //accept会阻塞等待一个socket连接，服务器代码到这暂停
                            Client = server.accept();
                            ui.clients.add(Client);
                            Println("成功连接到客户端"+Client.toString());
                            new ListenClient(ui,Client);
                        } catch (IOException e) {
                            Println("连接客户端失败！");
                            Println(Client.toString());
                            e.printStackTrace();
                        }
                    }
                    
            }
        }).start();
    }
    
    public synchronized void Send_Message(String s){
        for(int i=0;i<this.ui.clients.size();i++){
            Socket client=ui.clients.get(i);
            try {
            	//通过socket输出流创建write推送功能对象
                Write=new PrintStream(client.getOutputStream());
                Write.println(s);
            } catch (IOException e) {
                Println(e.toString());
                e.printStackTrace();
            }
        }
    }
    public void Println(String s){
        if(s!=null){
            this.ui.Text_show.setText(this.ui.Text_show.getText()+s+"\n");
            System.out.println(s + "\n");
        }
    }
}

class ListenClient extends Thread{
    public ServerUI ui;
    public Socket client;
    BufferedReader Read;
    PrintStream  Write;
    public ListenClient(ServerUI UI,Socket Client){
        this.ui=UI;
        this.client=Client;
        //创建一个接受数据的线程
        new Thread(new Runnable(){
            @Override
            public void run() {
                String message="";
                while(true){
                    try {
                    	//获取输入流
                        Read=new BufferedReader(new InputStreamReader(client.getInputStream()));
                        message=Read.readLine();
                        Println(message);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
            }
            
        }).start();
    }
    public void Println(String s){
        if(s!=null){
        	
            this.ui.Text_show.setText("client:"+this.ui.Text_show.getText()+s+"\n");
            System.out.println(s + "\n");
        }
    }
}

服务器端和客户端的UI界面可根据需要自行设计

最后

如果有帮助到你，请给这篇文章点个赞和收藏吧，让更多的人看到 ~ ("▔□▔)/

如果有异议的地方，欢迎在评论区留言，我都会逐一回复 ~

如果感兴趣的话，欢迎访问眼里要有光的博客