java中利用TCP/IP协议演示聊天室

版权声明：本篇文章由IT_CREATE整理 https://blog.csdn.net/IT_CREATE/article/details/83338937

客户端部分：客户端部分对读写进行分离，避免读写（接发消息互相干扰，进行读操作时阻塞不能进行写操作，写时不能进行读操作）

1、客户端的执行主线程ClientTest

package com.work.socketTest.testmain;
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 com.work.socketTest.createThread.AcceptThread;
import com.work.socketTest.createThread.SendThread;

public class ClientTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		System.out.println("欢迎来到聊天室，请输入登录名");
		BufferedReader console = new BufferedReader(new InputStreamReader(System.in));//定义接收控制台数据的流
		Socket socket = null;
		BufferedReader reader = null;
		BufferedWriter writer = null;
		
		try {
			socket = new Socket("127.0.0.1", 7777);
			
			String loginName = console.readLine();//对控制台输入的登录名进行读取
			if(loginName == null || "".equals(loginName)) return;//如果没有读取到数据，则直接返回，结束进程
			
			/*
			  *创建用于客户端与服务器之间进行数据读写的流的实体 
			 */
			reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
			
			/**
			 * 将用于读和写的操作进行分离，用不同的线程去执行，避免读写操作互相干扰，也就是避免读写的等待，因为读写都是阻塞IO，避免在读的时候不能进行写的操作
			 *在创建本次发送数据线程时就先把客户端输入的登录名发送给服务器，
		            * 在服务器端会单独为每个客户端创建一个socket并将这个客户端的连接加入线程池进行处理，并将登录名保存在为其分配的线程中实现并发
			 */
			new Thread(new SendThread(writer,socket,loginName)).start();//建立一个发送线程
			new Thread(new AcceptThread(reader,socket)).start();//建立一个接收线程
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

2、客户端进行读写分离后读数据线程AcceptThread

package com.work.socketTest.createThread;
import java.io.BufferedReader;
import java.io.IOException;
import java.net.Socket;
import com.work.socketTest.util.CloseUtil;


public class AcceptThread implements Runnable{
	private BufferedReader reader = null;//创建用于接收本客户端主线程创建的用于从服务器读取数据的流
	private boolean isRunning = true;//本次线程的状态，ture表示运行，false表示关闭
	private Socket socket = null;//创建用于接收本次客户端主线程创建的套接字，后面用于判断套接字是否处于连接状态
	
	public AcceptThread(BufferedReader reader,Socket socket) {
		super();
		this.reader = reader;//保存本客户端用于从服务器读取数据的流
		this.socket = socket;//保存本客户端用于客户端与服务器之间进行通信的套接字
	}

	/**
	 * 读取传输过来的数据方法并返回内容
	 * @return
	 */
	@SuppressWarnings("unused")
	private String accept() {
		String accept = "";
		try {
			accept = reader.readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			isRunning = false;//出现异常将本线程关闭
			CloseUtil.close(reader);//关闭读取服务器发过来数据的流
		}
		return accept;
		
	}
	@Override
	public void run() {
		/**
		 * 当线程状态为运行的时候执行while里面的语句
		 */
		while (isRunning) {
			/**
			 * 判断socket通道是否处于连接状态
			 */
			if(socket.isConnected()) {
				System.out.println(accept());//控制台打印从服务器接收到的数据
			}else {
				isRunning = false;//当套接字处于断开连接，则将本次发送数据的线程关闭
				CloseUtil.close(reader);//同时关闭读取服务器发过来数据的流
			}
			
		}	
	}

}

3、客户端进行读写分离后发送数据线程SendThread

package com.work.socketTest.createThread;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import com.work.socketTest.util.CloseUtil;


public class SendThread implements Runnable {

	private BufferedWriter write = null;// 接收本客户端用于向服务器发送的数据的写入流
	private BufferedReader console = null;// 接收本客户端的从控制台读取数据的流
	private Socket socket = null;// 接收本次客户端创建的套接字，后面用于判断套接字是否处于连接状态
	private boolean isRunning = true;// 本次线程的状态，ture表示运行，false表示关闭

	/**
	 * 当调用此线程时，将主线程的数据进行保存
	 * 
	 * @param write
	 * @param socket
	 * @param loginName
	 */
	public SendThread(BufferedWriter write, Socket socket, String loginName) {
		super();
		this.write = write;// 将本客户端用于向服务器发送数据的写入流进行保存
		this.socket = socket;// 将本次客户端的套结字进行保存
		console = new BufferedReader(new InputStreamReader(System.in));// 对本客户端的从控制台读取数据的流进行赋值
		/*
		 * 在创建本次发送数据线程时就先把客户端输入的登录名发送给服务器，
		 * 在服务器端会单独为每个客户端创建一个socket并将这个客户端的连接加入线程池进行处理，实现并发
		 */
		send(loginName);
	}

	/**
	 * 获取控制台的数据
	 * 
	 * @return
	 */
	private String getMgsConsole() {
		try {
			return console.readLine();// 返回控制台获取的数据
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			isRunning = false;// 发生异常将线程状态关闭
			CloseUtil.close(console, write);// 发生异常将用于读取控制台数据的流，和向服务器写数据的流关闭
		}
		return null;
	}
    

    /**
	 * 向服务器发送数据方法
	 * 
	 */
	private void send(String send) {
		if (send == null && "".equals(send))
			return;
		try {
			write.write(send);
			write.newLine();
			write.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			isRunning = false;// 发生异常将线程状态关闭
			CloseUtil.close(console, write);// 发生异常将用于读取控制台数据的流，和向服务器写数据的流关闭
		}
	}

	@Override
	public void run() {
		/**
		 * 当本次发送数据线程处于运行状态，执行while里面的操作
		 */
		while (isRunning) {
			if (socket.isConnected())
				send(getMgsConsole());// 如果套接字处于连接状态，则向服务器发送控制台信息
			else {
				isRunning = false;// 当套接字处于断开连接，则将本次发送数据的线程关闭
				CloseUtil.close(console, write);// 同时关闭读取控制台数据的流和向服务器写数据的流
			}
		}
	}

}

服务器部分：为每个客户端创建单独的Socket套接字，并开启单独的线程实现并发

服务器执行主线程及分配的单独执行线程，分配线程用的内部类实现

package com.work.socketTest.testmain;

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.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.work.socketTest.util.CloseUtil;

@SuppressWarnings("all")
public class ServieceTest {

	ArrayList<ServerThread> serverThreadList = new ArrayList<ServerThread>();

	public static void main(String[] args) {
		new ServieceTest().start();
	}

	/**
	 * 主线程执行的内容的封装
	 */
	private void start() {
		ServerSocket serverSocket = null;
		try {
			serverSocket = new ServerSocket(7777);// 设置监听套接字监听客户端
			System.out.println("启动服务，监听中。。。");
			while (true) {
				Socket client = serverSocket.accept();// 为每个监听到的客户端设置socket
				ExecutorService executorService = Executors.newFixedThreadPool(20);// 创建一个拥有20个线程线程的线程池
				ServerThread severThread = new ServerThread(client);// 给每个客户端创建一个线程
				serverThreadList.add(severThread);// 将创建好了的服务线程装进集合中备用，因为需要向其他客户端同时发消息
				executorService.execute(severThread);// 将实现了Runable接口的ServerThread的对象扔进线程池执行
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 为每个客户端分配单独线程的内部类
	 * @author Administrator
	 *
	 */
	class ServerThread implements Runnable {
		private String loginName = null;
		private Socket socket = null;
		BufferedReader reader = null;
		BufferedWriter writer = null;
		boolean isRunning = true;

		public ServerThread(Socket socket) {
			super();
			this.socket = socket;
			try {
				// 创建读取客户端发送过来数据的读取流
				this.reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				// 创建往客户端发送数据的写入流
				this.writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
				loginName = reader.readLine();// 接收客户端第一次发送过来的登录名，并保存起来
				send("欢迎进入聊天室");// 当发送了登录名过来后，向客户端发送欢迎信息
				sendOther(this.loginName + "进入聊天室", true);// 当发送了登录名过来后，同时向其他客户端发送信息
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		/**
		 * 向连接到服务器的本客户端发送消息
		 * 
		 * @param str
		 */
		private void send(String str) {
			if (str == null && "".equals(str))
				return;
			try {
				this.writer.write(str);
				this.writer.newLine();
				this.writer.flush();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				isRunning = false;
				CloseUtil.close(writer);
			}

		}

		/**
		 * 发送给其他人消息方法，isSystemInformation判断是不是系统消息，也就是不是其他人发的消息
		 * @param str
		 * @param isSystemInformation
		 */
		private void sendOther(String str, boolean isSystemInformation) {
			/**
			 * 以@xxx:sssssssssss的形式进行私聊操作，xxx表示要发送人的姓名，sssssss表示内容
			 */
			if (str.contains("：") && str.startsWith("@")) {
				String name = str.substring(1, str.indexOf("："));// 返回一个姓名的字符串
				String info = str.substring(str.indexOf("：") + 1);// 返回发送过来的内容的字符串
				for (ServerThread serverThread : serverThreadList) {
					/**
					 * 当发送给指定人的登录名配对成功，并且套结字处于连接状态，执行操作
					 */
					if (serverThread.loginName.equals(name) && serverThread.socket.isConnected()) {
						serverThread.send(this.loginName + "悄悄对你说：" + info);
					}
				}

			}
			/**
			 * 这是向除了自己以外的其他人发送消息，就是群聊
			 */
			else {
				for (ServerThread serverThreads : serverThreadList) {
					if (serverThreads == this)
						continue;
					if (isSystemInformation)
						serverThreads.send("系统消息  :" + str);
					else
						serverThreads.send(this.loginName + "对大家说：" + str);
				}
			}
		}

		/**
		 * 读取数据方法，并返回内容
		 * 
		 * @return
		 */
		private String receive() {
			String msg = "";
			try {
				msg = reader.readLine();//读取客户端发过来的数据
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
				isRunning = false;
				serverThreadList.remove(this);// 移除自身
				CloseUtil.close(reader);
			}
			return msg;
		}

		public void run() {
			while (isRunning) {
				sendOther(receive(), false);
			}
		}

	}

}

工具类部分

这里写了个工具类用于关闭各种IO流，CloseUtil类

package com.work.socketTest.util;

import java.io.Closeable;
import java.io.IOException;


public class CloseUtil {

	public static void close(Closeable... close) {
		try {
			for (Closeable closeable : close) {
				if (closeable != null)
					closeable.close();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}