Java聊天室（上课代码）

#Client端

package socket;

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.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 聊天室客户端
 * @author jin
 *
 */
public class Client {
	/**
	 * java.net.Socket
	 * 封装了TCP通讯协议的操作细节。java中想完成TCP通讯协议就依靠这个API即可。
	 * 使用它与服务端连接之后，通过两个流即可完成与服务端的数据交换。
	 */
	private Socket socket;
	
	/**
	 * 定义构造方法用来初始化客户端
	 */
	public Client() {
		try {
			/*
			 * 实例化Socket时传入两个参数：
			 * 1：服务端的IP地址信息，本机的就用localhost即可
			 * 2：服务端的服务端口号
			 * 通过IP地址可以找到服务端的计算机，
			 * 通过端口号可以找到运行在计算机上的服务端应用程序
			 * 
			 * 实例化的过程就是连接的过程，若连接失败就会抛出异常
			 */
			System.out.println("正在连接服务端...");
			socket = new Socket("localhost",8091);
			System.out.println("连接成功!");
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 客户端开始的工作方法
	 */
	public void start() {
		try {
			
			//启动用于读取服务端消息的线程
			ServerHandler handler = new ServerHandler();
			Thread t = new Thread(handler);
			t.start();
			/*
			 * Socket提供的方法：
			 * OutputStream getOutputStream()
			 * 该方法可以获取一条字节输出流，通过这个流写出的数据将会被发送到
			 * 远端（这里相当于发送给了服务端）
			 */
			OutputStream out = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
			BufferedWriter bw = new BufferedWriter(osw);
			PrintWriter pw = new PrintWriter(bw,true);
			Scanner scan = new Scanner(System.in);
			
			while(true) {
				String line = scan.nextLine();
				pw.println(line);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Client client = new Client();
		client.start();
	}
	
	/*
	 * 该线程负责循环读取服务端发送过来的消息
	 */
	private class ServerHandler implements Runnable{
		public void run() {
			try {
				/*
				 * 通过Socket获取输入流读取服务端发送过来的消息
				 */
				InputStream in = socket.getInputStream();
				InputStreamReader isr = new InputStreamReader(in,"UTF-8");
				BufferedReader br = new BufferedReader(isr);
				
				String message = null;
				//循环读取服务端发送过来的一行字符串
				while((message = br.readLine())!=null) {
					System.out.println(message);
				}
				
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	
	
	
}

Server端

package socket;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;

/**
 * 聊天室服务端
 * @author jin
 *
 */
public class Server {
	/*
	 * 运行在服务端的java.net.ServerSocket
	 * 主要由两个作用：
	 * 1：向系统申请服务端口，客户端就是通过该端口与服务端建立连接的。
	 * 2：监听服务端口，一旦客户端发起连接则会自动创建一个Socket与客户端进行交互
	 */
	private ServerSocket server;
	
	/*
	 * 该数组用于保存所有ClientHandler对应的输出流，便于所有ClientHandler
	 * 获取以广播消息给所有的客户端。
	 * 由于内部类可以访问外部类的属性，对此经常可以再外部类上定义属性作为内部类
	 * 的公共区域来共享他们的信息使用。
	 */
	private PrintWriter[] allOut = {};
	
	/**
	 * 初始化服务端
	 */
	public Server() {
		try {
			/*
			 * 实例化ServerSocket的同时向系统申请服务端口，
			 * 若端口已经被占用就会抛出地址被使用的异常
			 */
			System.out.println("正在启动服务端...");
			server = new ServerSocket(8091);
			System.out.println("服务器启动完毕！");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 服务端开始工作的方法
	 * @throws IOException 
	 */
	public void start() throws IOException {
			while(true) {
			System.out.println("主线程：等待客户端连接！");
			/*
			 * 该方法是一个阻塞方法，当调用后就开始等待客户端的连接，知道一个客户端连接，那么该方法会返回
			 * 一个Socket，服务端可以通过这个Socket与刚建立连接的客户端进行交互。
			 */
			Socket socket = server.accept();
			System.out.println("主线程：一个客户端连接完毕！");
			
			//启动一个线程来处理客户端交互
			ClientHandler handler = new ClientHandler(socket);
			Thread t = new Thread(handler);
			t.start();
			}
	}
	public static void main(String[] args) throws Exception {
		Server server = new Server();
		server.start();
	}
	/**
	 * 该线程的任务是与指定客户端进行交互
	 * @author jin
	 *
	 */
	private	class ClientHandler implements Runnable{
		//客户端地址信息
		private String host;
		
		private Socket socket;
		public ClientHandler(Socket socket) {
			this.socket = socket;
			InetAddress address = socket.getInetAddress();
			host = address.getHostAddress();
		}
		public void run() {
			PrintWriter pw = null;
			try {
			/*
			 * 通过socket获取输出流，用于给客户端发送消息
			 */
			OutputStream out = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
			BufferedWriter bw = new BufferedWriter(osw);
			pw = new PrintWriter(bw,true);
			
			/*
			 * 同步锁
			 * 多个ClientHandler不能同时向数组中添加元素
			 * 否则会出现并发安全问题，对此下面的代码要保证同步运行
			 */
			synchronized(allOut) {
			/*
			 * 将该输出流存入allOut数组中，以便其他ClientHandler
			 * 也可以将消息转发给当前用户
			 */
			//1.扩容数组
			allOut = Arrays.copyOf(allOut,allOut.length+1);
			//2将当前输出流存入数组
			allOut[allOut.length-1] = pw;
			}
			
			/*
			 * 通过Socket获取输入流：
			 * InputStream getInputStream()
			 * 通过这个流就可以读取到客户端发送过来的消息
			 */
			InputStream in = socket.getInputStream();
			InputStreamReader isr 
				= new InputStreamReader(in,"UTF-8");
			BufferedReader br
				= new BufferedReader(isr);
			/*
			 * 当通过br.readLine方法读取客户端发送的字符串时，
			 * 客户端断开时，不同操作系统的反应是
			 * 不同的：windows断开时服务端通过readline方法直接抛出异常。
			 * linux断开时服务端时将readline方法返回null
			 */
			String line = null;
			while( ( line = br.readLine() ) != null ) {
			System.out.println(host+"："+line);
			synchronized(allOut) {
			//回复客户端
			//pw.println(host+"说"+line);
			//遍历allOut数组，给所有客户端发送
			for(int i = 0; i <allOut.length; i++) {
				allOut[i].println(host+"说"+line);
			}
			}
			}
		}catch (Exception e) {
			e.printStackTrace();
		}finally {
			//处理当前客户端断开连接后的操作
			try {
				//从数组中删除元素
				for(int i = 0; i < allOut.length; i++) {
					if(pw == allOut[i]) {
						//将其与最后一个元素交换
						allOut[i] = allOut[allOut.length - 1];
						break;
					}
				}
				
				//缩容
				allOut = Arrays.copyOf(allOut, allOut.length - 1);
				//关闭socket释放资源
				socket.close();
				
			} catch (IOException e) {
				e.printStackTrace();
				
			}
			
		}
		}
			
		}
	}