import java.io.*;
import java.net.*;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
 
 
public class TCPServer { 
 
 private ServerSocket serverSocket;
 
 /**
 * 創(chuàng)建線程池來管理客戶端的連接線程
 * 避免系統(tǒng)資源過度浪費(fèi)
 */
 private ExecutorService exec;
 
 // 存放客戶端之間私聊的信息
 private Map<String,PrintWriter> storeInfo;
 
 public TCPServer() {
 try {
 
 serverSocket = new ServerSocket(6789);
 storeInfo = new HashMap<String, PrintWriter>();
 exec = Executors.newCachedThreadPool();
 
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 
 // 將客戶端的信息以Map形式存入集合中
 private void putIn(String key,PrintWriter value) {
 synchronized(this) {
 storeInfo.put(key, value);
 }
 }
 
 // 將給定的輸出流從共享集合中刪除
 private synchronized void remove(String key) {
 storeInfo.remove(key);
 System.out.println("當(dāng)前在線人數(shù)為："+ storeInfo.size());
 }
 
 // 將給定的消息轉(zhuǎn)發(fā)給所有客戶端
 private synchronized void sendToAll(String message) {
 for(PrintWriter out: storeInfo.values()) {
 out.println(message);
 }
 }
 
 // 將給定的消息轉(zhuǎn)發(fā)給私聊的客戶端
 private synchronized void sendToSomeone(String name,String message) {
 PrintWriter pw = storeInfo.get(name); //將對應(yīng)客戶端的聊天信息取出作為私聊內(nèi)容發(fā)送出去
 if(pw != null) pw.println(message); 
 }
 
 public void start() {
 try {
 while(true) {
 System.out.println("等待客戶端連接... ... ");
 Socket socket = serverSocket.accept();
 
 // 獲取客戶端的ip地址
 InetAddress address = socket.getInetAddress();
 System.out.println("客戶端：“" + address.getHostAddress() + "”連接成功！ ");
 /**
 * 啟動(dòng)一個(gè)線程，由線程來處理客戶端的請求，這樣可以再次監(jiān)聽
 * 下一個(gè)客戶端的連接
 */
 exec.execute(new ListenrClient(socket)); //通過線程池來分配線程
 }
 } catch(Exception e) {
 e.printStackTrace();
 }
 }
 
 /**
 * 該線程體用來處理給定的某一個(gè)客戶端的消息，循環(huán)接收客戶端發(fā)送
 * 的每一個(gè)字符串，并輸出到控制臺
 */
 class ListenrClient implements Runnable {
 
 private Socket socket;
 private String name;
 
 public ListenrClient(Socket socket) {
 this.socket = socket;
 }
 
 // 創(chuàng)建內(nèi)部類來獲取昵稱
 private String getName() throws Exception {
 try {
 //服務(wù)端的輸入流讀取客戶端發(fā)送來的昵稱輸出流
 BufferedReader bReader = new BufferedReader(
 new InputStreamReader(socket.getInputStream(), "UTF-8"));
 //服務(wù)端將昵稱驗(yàn)證結(jié)果通過自身的輸出流發(fā)送給客戶端
 PrintWriter ipw = new PrintWriter(
 new OutputStreamWriter(socket.getOutputStream(), "UTF-8"),true);
 
 //讀取客戶端發(fā)來的昵稱
 while(true) {
 String nameString = bReader.readLine();
 if ((nameString.trim().length() == 0) || storeInfo.containsKey(nameString)) {
 ipw.println("FAIL");
 } else {
 ipw.println("OK");
 return nameString;
 }
 }
 } catch(Exception e) {
 throw e;
 }
 }
 
 @Override 
 public void run() {
 try {
 /*
 * 通過客戶端的Socket獲取客戶端的輸出流
 * 用來將消息發(fā)送給客戶端
 */
 PrintWriter pw = new PrintWriter(
 new OutputStreamWriter(socket.getOutputStream(), "UTF-8"), true);
 
 /*
 * 將客戶昵稱和其所說的內(nèi)容存入共享集合HashMap中
 */
 name = getName();
 putIn(name, pw);
 Thread.sleep(100);
 
 // 服務(wù)端通知所有客戶端，某用戶上線
 sendToAll("[系統(tǒng)通知] “" + name + "”已上線");
 
 /*
 * 通過客戶端的Socket獲取輸入流
 * 讀取客戶端發(fā)送來的信息
 */
 BufferedReader bReader = new BufferedReader(
 new InputStreamReader(socket.getInputStream(), "UTF-8"));
 String msgString = null;
 
 
 while((msgString = bReader.readLine()) != null) {
 // 檢驗(yàn)是否為私聊（格式：@昵稱：內(nèi)容）
 if(msgString.startsWith("@")) {
 int index = msgString.indexOf(":");
 if(index >= 0) {
 //獲取昵稱
 String theName = msgString.substring(1, index);
 String info = msgString.substring(index+1, msgString.length());
 info = name + "："+ info;
 //將私聊信息發(fā)送出去
 sendToSomeone(theName, info);
 continue;
 }
 }
 // 遍歷所有輸出流，將該客戶端發(fā)送的信息轉(zhuǎn)發(fā)給所有客戶端
 System.out.println(name+"："+ msgString);
 sendToAll(name+"："+ msgString);
 } 
 } catch (Exception e) {
 // e.printStackTrace();
 } finally {
 remove(name);
 // 通知所有客戶端，某某客戶已經(jīng)下線
 sendToAll("[系統(tǒng)通知] "+name + "已經(jīng)下線了。");
 
 if(socket!=null) {
 try {
 socket.close();
 } catch(IOException e) {
 e.printStackTrace();
 }
 } 
 }
 }
 }
 
 public static void main(String[] args) {
 TCPServer server = new TCPServer();
 server.start();
 }
}

import java.io.*;
import java.net.*;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
 
public class TCPClient {
 
 static private Socket clientSocket;
 
 public TCPClient() {}
 
 public static void main(String[] args) throws Exception {
 Scanner scanner = new Scanner(System.in);
 String serverIP;
 
 System.out.println("請?jiān)O(shè)置服務(wù)器IP：");
 serverIP = scanner.next();
 clientSocket = new Socket(serverIP, 6789);
 TCPClient client = new TCPClient();
 client.start();
 }
 
 public void start() {
 try {
 Scanner scanner = new Scanner(System.in);
 setName(scanner);
 
 // 接收服務(wù)器端發(fā)送過來的信息的線程啟動(dòng)
 ExecutorService exec = Executors.newCachedThreadPool();
  exec.execute(new ListenrServser());
 
 // 建立輸出流，給服務(wù)端發(fā)信息
 PrintWriter pw = new PrintWriter(
 new OutputStreamWriter(clientSocket.getOutputStream(), "UTF-8"), true);
 
 while(true) {
 pw.println(scanner.nextLine());
 }
 } catch(Exception e) {
 e.printStackTrace();
 } finally {
 if (clientSocket !=null) {
 try {
 clientSocket.close();
 } catch(IOException e) {
 e.printStackTrace();
 }
 }
 }
 }
 
 private void setName(Scanner scan) throws Exception {
 String name;
 //創(chuàng)建輸出流
 PrintWriter pw = new PrintWriter(
 new OutputStreamWriter(clientSocket.getOutputStream(), "UTF-8"),true);
 //創(chuàng)建輸入流
 BufferedReader br = new BufferedReader(
 new InputStreamReader(clientSocket.getInputStream(),"UTF-8"));
 
 while(true) { 
 System.out.println("請創(chuàng)建您的昵稱：");
 name = scan.nextLine();
 if (name.trim().equals("")) {
 System.out.println("昵稱不得為空");
 } else { 
 pw.println(name);
 String pass = br.readLine();
 if (pass != null && (!pass.equals("OK"))) {
 System.out.println("昵稱已經(jīng)被占用，請重新輸入：");
 } else {
 System.out.println("昵稱“"+name+"”已設(shè)置成功，可以開始聊天了");
 break;
 }
 }
 }
 }
 
 // 循環(huán)讀取服務(wù)端發(fā)送過來的信息并輸出到客戶端的控制臺
 class ListenrServser implements Runnable {
 
 @Override
 public void run() {
 try {
 BufferedReader br = new BufferedReader(
 new InputStreamReader(clientSocket.getInputStream(), "UTF-8"));
 String msgString;
 while((msgString = br.readLine())!= null) {
 System.out.println(msgString);
 }
 } catch(Exception e) {
 e.printStackTrace();
 }
 }
 }
 
}