Java基础14-网络编程

柔光的暖阳◎ 2024-02-19 13:00 26阅读 0赞

1.网络编程的概述

1.网络编程的目的
        直接或间接地通过网络协议与其它计算机进行通讯。
    2.解决两个问题
        1.如何准备定位网络上的一台主机
        2.如何可靠、高效进行数据传输
    3.网络编程的要素
        1.使用IP地址定位互联网上的一台主机；端口号：定位一台主机上的不同进程
        2.网络协议
    网络通信接口：
        为了使两个节点之间能进行对话，必须在它们之间建立通信工具（即接口），使彼此之间能进行信息交换。
    接口包括两部分：
       硬件装置：实现节点之间的信息传送
       软件装置：规定双方进行通信的约定协议
    网络编程中有三个主要的问题：
      如何准确地定位网络上一台或多台主机。（IP/房子）
      如何定位到某主机中的特定的应用。（端口号/房门号）
      找到主机后如何可靠高效地进行数据传输。（网络协议

2.InetAddress类的使用

一个InetAddress类的对象就对应着一个ip地址
            本地回路地址：127.0.0.1
    如何实例化？
        getByName(String host)
                host形式一：提供一个ip地址。比如：192.168.10.165
                host形式二：提供一个域名。比如：String host = "www.qq.com";
        getLocalHost():获取本地ip地址
    两个方法的使用
            getHostName():得到域名
            getHostAddress()：获取ip地址 
    IP地址：
       唯一的标识 Internet 上的计算机
       本地回环地址(hostAddress)：127.0.0.1      主机名(hostName)：localhost
       不易人记忆，IP地址是定长的32位二进制数字则非常便于机器进行处理。
    端口号：
       端口号标识正在计算机上运行的进程（程序），不同的进程有不同的端口号
       在同一台主机上，同一个协议下，端口号不能重复。不同协议可以重复。
       被规定为一个 16 位的整数 0~65535。其中，0~1023被预先定义的服务通信占用比如FTP服务（21）， 
       HTTP（80），HTTPS（443），Telnet（远程登录23），Tomcat(8080)，JBOSS(8080)， 
       Oracle（1521）,MySQL(3306)，SQL Server(1433)，QQ（1080）

3.网络通信协议

计算机网络中实现通信必须有一些约定即通信协议，对速率、传输代码、代码结构、传输控制步骤、
    出错控制等制定标准。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][] ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 2][]

4.TCP/UDP网络编程  
1.两种协议的区别

TCP协议
    TCP(Transmission Control Protocol，传输控制协议)：是一种面向连接的、可靠的、基于字节流的传输层的通信协议。
       使用TCP协议前，须先建立TCP连接，形成传输数据通道。传输前，采用“三次握手”方式，是可靠的。
       TCP协议进行通信的两个应用进程：客户端、服务端
       在连接中可进行大数据量的传输
       传输完毕，需释放已建立的连接，效率低
       类似于电话
    UDP协议
    UDP(User Datagram Protocol，用户数据报协议)：是一个无连接的传输层协议、提供面向事务的简单不可靠的信息传送服务。
        将数据、源、目的封装成数据包，不需要建立连接
        每个数据报的大小限制在64K内
        因无需连接，故是不可靠的，数据可能丢失
        发送数据结束时无需释放资源，速度快
        类似于短信

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 3][]

2.TCP网络编程

1.客户端发送内容给服务端，服务端将内容打印到控制台上。
    
    2.客户端发送内容给服务端，服务端给予反馈。
    
    3.从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。并关闭相应的连接。

3.UDP网络编程

//发送端
    	@Test
    	public void send() throws IOException{
    		DatagramSocket socket = new DatagramSocket();
    		
    		byte[] buffer = "人家是发送端".getBytes();
    		InetAddress inetAddress = InetAddress.getByName("192.168.10.165");
    		//创建一个数据包。封装了要发送的数据，以及要发送到的对方的ip地址和端口号
    		DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length, inetAddress, 8989);
    		//发送数据
    		socket.send(packet);
    		
    		socket.close();
    		
    		
    	}
    	
    	//接收端
    	@Test
    	public void receive() throws IOException{
    		
    		DatagramSocket socket = new DatagramSocket(8989);
    		//存储数据的容器。
    		byte[] buffer = new byte[1024];
    		
    		DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
    		//接收数据
    		socket.receive(packet);
    		//获取发送端的信息
    		//显示数据在控制台上
    //		String str = new String(buffer,0,buffer.length);
    		String str = new String(packet.getData(),0,packet.getLength());
    		System.out.println(str);
    		
    		System.out.println(packet.getAddress().getHostAddress());
    		socket.close();
    	}

5.URL网络编程

1.URL:统一资源定义符，对应着互联网上的某一个资源。
    2.URL的使用
       2.1掌握如何创建URL对象，熟悉URL对应着的资源的表示方式
       2.2 URL中的常用方法
       2.3如何联网下载数据

url对应的资源的格式：

http://127.0.0.1:8080/examples/hello.txt  
网络协议:// ip地址:服务器端口号/web工程/某一个资源

URL的常用方法：
     public String getProtocol(  ) 获取该URL的协议名
     public String getHost(  )    获取该URL的主机名
     public String getPort(  )    获取该URL的端口号
     public String getPath(  )    获取该URL的文件路径，即tomcat的webapps目录下级目录名也就是资源路径名
     public String getFile(  )     获取该URL的文件名
     public String getRef(  )     获取该URL在文件中的相对位置
     public String getQuery(   )  获取该URL的查询名

**获取资源:**

package com.net.url;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.URL;
    
    public class TestGetData2 {
    
    	public static void main(String[] args) throws Exception {
    		URL url = new URL("http://www.baidu.com:80/index.html");
    		/*使用转换流解决乱码*/
    		BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(),"utf-8"));
    		String str;
    		while((str=br.readLine())!=null){
    			System.out.println(str);
    		}
    		br.close();
    	}
    
    }
    package com.net.url;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.URL;
    
    public class TestGetData3 {
    
    	public static void main(String[] args) throws Exception {
    		URL url = new URL("http://www.baidu.com:80/index.html");
    		/*写到本地文件中，使用浏览器查看*/
    		BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(),"utf-8"));
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("down/index.html")),"utf-8"));
    		String str;
    		while((str=br.readLine())!=null){
    			System.out.println(str);
    			bw.write(str);
    			bw.newLine();
    		}
    		br.close();
    		bw.close();
    	}
    }

6.**套接字Socket**

此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。 
    通信的两端都要有Socket，是两台机器间通信的端点。网络通信其实就是Socket间的通信。
    Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
    Socket分类：
       流套接字（stream socket）：使用TCP提供可依赖的字节流服务
       数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 4][]

Socket类的常用构造方法：
    1.public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
    2.public Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号。
    Socket类的常用方法：
    3.public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息
    4.public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息
    5.public InetAddress getInetAddress()此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
    6.public InetAddress getLocalAddress()获取套接字绑定的本地地址。 即本端的IP地址
    7.public int getPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
    8.public int getLocalPort()返回此套接字绑定到的本地端口。 如果尚未绑定套接字，则返回 -1。即本端的端口号。
    9.public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。 
    10.public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
    11.public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。
    注意：先后调用Socket的shutdownInput()和shutdownOutput()方法，仅仅关闭了输入流和输出流，并不等于调用Socket的close()方法。在通信结束后，仍然要调用Scoket的close()方法，因为只有该方法才会释放Socket占用的资源，比如占用的本地端口号等。

7.**TCP网络编程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 6][]

#### **服务器端** ####

服务器程序的工作过程包含以下五个基本的步骤：
    
    1.使用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
    2.调用 accept()方法：监听连接请求，如果客户端请求连接，则接受连接，创建与该客户端的通信套接字对象。
    3.调用 该Socket对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
    4.关闭Socket对象：某客户端访问结束，关闭与之通信的套接字。
    5.关闭ServerSocket：如果不再接收任何客户端的连接的话。
    ServerSocket类的常用方法：
    
    1.public ServerSocket(int port)创建绑定到特定端口的服务器套接字。如果指定 0表示在所有空闲端口上创建套接字。
    2.public Socket accept()侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。每一个客户端对服务器的连接
    都将创建独立的一个Socket套接字与之通信。
    3.public void close() 关闭监听Socket
    4.public InetAddress getInetAddress() 返回此服务器套接字的本地地址
    5.public int getLocalPort() 返回此套接字在其上监听的端口号

#### **客户端** ####

客户端Socket的工作过程包含以下四个基本的步骤：
    
    1.创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象，创建的同时会自动向服务器方发起连接。若服务器端
    响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
    2.打开连接到 Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，
    进行数据传输
    3.按照一定的协议（规则）对 Socket  进行读/写操作：通过输入流读取服务器发送的信息，通过输出流将信息发送给服务器。
    4.关闭 Socket：断开客户端到服务器的连接

**示例：一个客户端与服务器单次通信**

package com.tcp.onetoone;
    
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
    
    	public static void main(String[] args)throws Exception {
    		//1、准备一个ServerSocket
    		ServerSocket server =  new ServerSocket(8888);
    		
    		//2、监听一个客户端的连接
    		Socket socket = server.accept();//该方法是个阻塞的方法，如果没有客户端连接，将一直等待
    		System.out.println("一个客户端连接成功！！");
    		
    		//3、（1）获取输出流，用来发送数据给该客户端
    		OutputStream out = socket.getOutputStream();
    		//（2）获取输入流，用来接收该客户端发送给服务器的数据
    		InputStream input = socket.getInputStream();
    		
    		//4、通信
    		//接收数据
    		byte[] data = new byte[1024];
    		int len;
    		while((len=input.read(data))!=-1){
    			System.out.println(new String(data,0,len));
    		}
    		//发送数据
    		out.write("欢迎登录".getBytes());
    		out.flush();
    		
    		
    		//5、关闭socket，不再与该客户端通信
    		//socket关闭，意味着InputStream和OutputStream也关闭了
    		socket.close();
    		
    		//6、如果不再接收任何客户端通信，可以关闭ServerSocket
    		server.close();
    	}
    }
    package com.tcp.onetoone;
    
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    public class Client {
    
    	public static void main(String[] args) throws Exception {
    		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
    		Socket socket = new Socket("127.0.0.1", 8888);
    
    		// 3、（1）获取输出流，用来发送数据给服务器
    		OutputStream out = socket.getOutputStream();
    		// （2）获取输入流，用来接收服务器发送给该客户端的数据
    		InputStream input = socket.getInputStream();
    
    		// 4、接收数据
    		// 发送数据
    		out.write("lalala".getBytes());
    		out.flush();
    		socket.shutdownOutput();//会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
    		
    		// 接收数据
    		byte[] data = new byte[1024];
    		int len;
    		while ((len = input.read(data)) != -1) {
    			System.out.println(new String(data, 0, len));
    		}
    		
    		//5、关闭socket，不再与服务器通信，即断开与服务器的连接
    		//socket关闭，意味着InputStream和OutputStream也关闭了
    		socket.close();
    	}
    }

**UDP网络编程**

#### **“发送端”** ####

流  程：
    1、建立发送端的DatagramSocket，需要指定本端的端口号
    
    2、建立数据包DatagramPacket
    
       数据
       接收端的IP地址
       接收端的端口号
    3、调用Socket的发送方法
    
    4、关闭Socket

package com.udp.nofeedback;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    public class Send {
    
    	public static void main(String[] args)throws Exception {
    //		1、建立发送端的DatagramSocket，需要指定本端的端口号
    		DatagramSocket ds = new DatagramSocket(8888);
    //		2、建立数据包DatagramPacket
    //		数据
    //		接收端的IP地址
    //		接收端的端口号
    		byte[] data = "新年好".getBytes();
    		InetAddress ip = InetAddress.getByName("127.0.0.1");
    		DatagramPacket dp = new DatagramPacket(data, data.length, ip, 9999);
    		
    //		3、调用Socket的发送方法
    		ds.send(dp);
    		
    //		4、关闭Socket
    		ds.close();
    	}
    }

#### **“接收端”** ####

流 程：

1、建立接收端的DatagramSocket，需要指定本端的IP地址和端口号
    
    2、建立数据包DatagramPacket
    
        装数据的数组
    3.调用Socket的接收方法
    4.拆封数据
    5、关闭Socket

package com.udp.nofeedback;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    public class Receiver {
    
    	public static void main(String[] args) throws Exception{
    //		1、建立接收端的DatagramSocket，需要指定本端的IP地址和端口号
    		DatagramSocket ds = new DatagramSocket(9999);
    		
    //		2、建立数据包DatagramPacket
    //		装数据的数组
    		byte[] buffer = new byte[1024];
    		DatagramPacket dp = new DatagramPacket(buffer , buffer.length);
    		
    //		3、调用Socket的接收方法
    		ds.receive(dp);
    		
    		//4、拆封数据
    		String str = new String(dp.getData(),0,dp.getLength());
    		System.out.println(str);
    		
    //		5、关闭Socket
    		ds.close();
    	}
    }

### **扩展：TCP编程** ###

一个客户端与服务器多次通信

package com.tcp.onetoone.manytimes;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
    
    	public static void main(String[] args)throws Exception {
    		// 1、准备一个ServerSocket
    		ServerSocket server = new ServerSocket(8888);
    
    		// 2、监听一个客户端的连接
    		Socket socket = server.accept();// 该方法是个阻塞的方法，如果没有客户端连接，将一直等待
    		System.out.println("一个客户端连接成功！！");
    
    		// 3、（1）获取输出流，用来发送数据给该客户端
    		OutputStream out = socket.getOutputStream();
    		// （2）获取输入流，用来接收该客户端发送给服务器的数据
    		InputStream input = socket.getInputStream();
    
    		// 4、通信
    		// 接收数据
    		BufferedReader br = new BufferedReader(new InputStreamReader(input));
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
    		String str;
    		while ((str = br.readLine()) != null) {
    			// 发送数据
    			bw.write("好的，我收到了你的消息\""+str+"\"");
    			bw.newLine();//有了这个，对方可以按行读
    			bw.flush();
    		}
    
    		// 5、关闭socket，不再与该客户端通信
    		// socket关闭，意味着InputStream和OutputStream也关闭了
    		socket.close();
    
    		// 6、如果不再接收任何客户端通信，可以关闭ServerSocket
    		server.close();
    	}
    
    }

package com.tcp.onetoone.manytimes;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class Client {
    
    	public static void main(String[] args) throws Exception {
    		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
    		Socket socket = new Socket("127.0.0.1", 8888);
    
    		// 3、（1）获取输出流，用来发送数据给服务器
    		OutputStream out = socket.getOutputStream();
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
    		
    		// （2）获取输入流，用来接收服务器发送给该客户端的数据
    		InputStream input = socket.getInputStream();
    		BufferedReader br = new BufferedReader(new InputStreamReader(input));
    		
    		//(3)准备从键盘输入的Scanner
    		Scanner scanner = new Scanner(System.in);
    		
    		// 4、 发送数据
    		while(true){
    			System.out.println("输入发送给服务器的消息内容：");
    			String message = scanner.nextLine();
    			bw.write(message);
    			bw.newLine();//有了这个，对方可以按行读
    			bw.flush();
    			
    			if(message.equals("bye")){
    				break;
    			}
    			
    			// 接收数据
    			String feedback  = br.readLine();
    			System.out.println("从服务器收到的反馈是：" + feedback);
    		}
    		
    		//5、关闭socket，不再与服务器通信，即断开与服务器的连接
    		//socket关闭，意味着InputStream和OutputStream也关闭了
    		scanner.close();
    		socket.close();
    	}
    }

#### **多个客户端与服务器连接:** ####

package com.tcp.manytoone.manytimes;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
    
    	public static void main(String[] args)throws Exception {
    		// 1、准备一个ServerSocket
    		ServerSocket server = new ServerSocket(8888);
    
    		while(true){
    			// 2、监听一个客户端的连接
    			final Socket socket = server.accept();// 该方法是个阻塞的方法，如果没有客户端连接，将一直等待
    			System.out.println("一个客户端连接成功！！");
    			
    			new Thread(){
    				public void run(){
    					// 3、（1）获取输出流，用来发送数据给该客户端
    					// （2）获取输入流，用来接收该客户端发送给服务器的数据
    					try{
    						BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    						BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    						// 4、通信
    						String str;
    						// 接收数据
    						while ((str = br.readLine()) != null) {
    							// 发送数据
    							bw.write("好的，我收到了你的消息\""+str+"\"");
    							bw.newLine();//有了这个，对方可以按行读
    							bw.flush();
    						}
    					}catch(Exception  e){
    						
    					}finally{
    						// 5、关闭socket，不再与该客户端通信
    						CloseUtil.close(socket);
    					}
    				}
    			}.start();
    		}
    
    		// 6、如果不再接收任何客户端通信，可以关闭ServerSocket
    //		server.close();
    	}
    
    }
    
    package com.tcp.manytoone.manytimes;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class Client {
    
    	public static void main(String[] args) throws Exception {
    		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
    		Socket socket = new Socket("127.0.0.1", 8888);
    
    		// 3、（1）获取输出流，用来发送数据给服务器
    		OutputStream out = socket.getOutputStream();
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
    		
    		// （2）获取输入流，用来接收服务器发送给该客户端的数据
    		InputStream input = socket.getInputStream();
    		BufferedReader br = new BufferedReader(new InputStreamReader(input));
    		
    		//(3)准备从键盘输入的Scanner
    		Scanner scanner = new Scanner(System.in);
    		
    		// 4、 发送数据
    		while(true){
    			System.out.println("输入发送给服务器的消息内容：");
    			String message = scanner.nextLine();
    			bw.write(message);
    			bw.newLine();//有了这个，对方可以按行读
    			bw.flush();
    			
    			if(message.equals("bye")){
    				break;
    			}
    			
    			// 接收数据
    			String feedback  = br.readLine();
    			System.out.println("从服务器收到的反馈是：" + feedback);
    		}
    		
    		//5、关闭socket，不再与服务器通信，即断开与服务器的连接
    		//socket关闭，意味着InputStream和OutputStream也关闭了
    		scanner.close();
    		socket.close();
    	}
    
    }
    
    package com.tcp.manytoone.manytimes;
    
    import java.io.Closeable;
    import java.io.IOException;
    
    public class CloseUtil {
    	public static void close(Closeable... cs){
    		for(Closeable c: cs){
    			try {
    				c.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

#### **多个客户端群聊:** ####

package com.tcp.chatroom;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.Vector;
    
    public class Server {
    	private Vector<Socket> online = new Vector<Socket>();
    	
    	@SuppressWarnings("resource")
    	public void start()throws Exception{
    		// 1、准备一个ServerSocket
    		ServerSocket server = new ServerSocket(8888);
    		while(true){
    			// 2、监听一个客户端的连接
    			final Socket socket = server.accept();// 该方法是个阻塞的方法，如果没有客户端连接，将一直等待
    			System.out.println("一个客户端连接成功！！");
    			online.add(socket);
    			
    			new Thread(new UserMessageHandler(socket)).start();
    		}
    	}
    	
    	class UserMessageHandler implements Runnable{
    		private Socket socket;
    		private String ip;
    		
    		public UserMessageHandler(Socket socket) {
    			super();
    			this.socket = socket;
    		}
    
    		@Override
    		public void run() {
    			ip = socket.getInetAddress().getHostAddress();
    			sendOthers(ip+"进入了聊天室!");
    			
    			//收到消息，给其他人转发
    			try{
    				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    				String str;
    				while ((str = br.readLine()) != null) {
    					sendOthers(ip+"说："+str);
    				}
    			}catch(Exception  e){
    //				e.printStackTrace();
    			}finally{
    				CloseUtil.close(socket);
    			}
    			
    			//当前客户端结束，从在线人员列表中移除
    			exit(socket);
    		}
    		
    		public void exit(Socket s){
    			online.remove(socket);
    			sendOthers(s.getInetAddress().getHostAddress()+"退出了聊天室");
    		}
    		
    		public void sendOthers(String message){
    			ArrayList<Socket> offline = new ArrayList<Socket>();
    			for(Socket socket : online){
    				if(socket!= this.socket){
    					try {
    						BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    						// 发送数据
    						bw.write(message);
    						bw.newLine();//有了这个，对方可以按行读
    						bw.flush();
    					} catch (IOException e) {
    						e.printStackTrace();
    						offline.add(socket);
    					}
    				}
    			}
    			for(Socket s : offline){
    				exit(s);
    			}
    		}
    		
    	}
    
    	public static void main(String[] args)throws Exception {
    		new Server().start();
    	}
    
    }
    
    package com.tcp.chatroom;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class Client {
    	private boolean flag = true;
    	private Socket socket;
    
    	public static void main(String[] args) throws Exception {
    		new Client().start();
    	}
    	
    	public void start() throws Exception{
    		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
    		socket = new Socket("127.0.0.1", 8888);
    		Thread s = new Thread(new Send());
    		Thread r = new Thread(new Receive());
    		
    		s.start();
    		r.start();
    		
    		s.join();
    		r.join();
    		socket.close();
    	}
    
    	class Receive implements Runnable{
    		@Override
    		public void run() {
    			try {
    				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    				while(flag){
    					// 接收数据
    					String feedback  = br.readLine();
    					System.out.println(feedback);
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    				flag=false;
    			}
    		}
    	}
    	
    	class Send implements Runnable{
    		@Override
    		public void run() {
    			Scanner scanner = new Scanner(System.in);
    			
    			try {
    				BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    				while(true){
    					System.out.println("输入消息内容：");
    					String message = scanner.nextLine();
    					bw.write(message);
    					bw.newLine();//有了这个，对方可以按行读
    					bw.flush();
    					
    					if(message.equals("bye")){
    						flag = false;
    						break;
    					}
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    				flag=false;
    			}
    			
    			scanner.close();
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2018111000475089.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/a80dd279e848427182c8be6541845fe3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/355d925b66c24180bde9dd8394436c54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/a5a433e1b61d4d608d7dffcb156491b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/35ea46f5ed974ac1825ce646dbdb6a20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/9c70ad3fbf094cc6b4b3c2762de50215.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/68c85fa4ef214af2abc6332aa8d67212.png