chatroomclient.java

j2se开发的即时聊天系统

/**
 * 客户端
 * 
 * @author Yang
 * 
 */
package com.wczy.chatroom.client;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

import com.wczy.chatroom.Protocal;
import com.wczy.chatroom.client.PublicMessageListener;
import com.wczy.chatroom.client.OnlineListListener;

public class ChatRoomClient {
	private String serverAddress;

	private int port;
	

	private Socket socket;


	private List<String> nickNameList = new ArrayList<String>();//**********************

	private String sendFileFullName = null;

	private List<OnlineListListener> onlineListListeners = new ArrayList<OnlineListListener>();//**********************

	private List<PublicMessageListener> publicMessageListeners = new ArrayList<PublicMessageListener>();//**********************

	private List<PrivateMessageListener> privateMessageListeners = new ArrayList<PrivateMessageListener>();

	private List<SendFileAcceptListener> sendFileAcceptListeners = new ArrayList<SendFileAcceptListener>();

	private List<SendFileRejectListener> sendFileRejectListeners = new ArrayList<SendFileRejectListener>();

	private List<SendFileRequestListener> sendFileRequestListeners = new ArrayList<SendFileRequestListener>();

	private List<FileSendOverListener> fileSendOverListeners = new ArrayList<FileSendOverListener>();//文件发送完毕监听器

	private List<FileSaveOverListener> fileSaveOverListeners = new ArrayList<FileSaveOverListener>();//文件保存完毕监听器

	public void addOnlineListListener(OnlineListListener listener) {
		onlineListListeners.add(listener);
	}//**********************每个客户端都有在线列表监听器

	public void addPublicMessageListener(PublicMessageListener listener) {
		publicMessageListeners.add(listener);
	}//**********************

	public void addPrivateMessageListener(PrivateMessageListener listener) {
		privateMessageListeners.add(listener);
	}

	public void addSendFileAcceptListener(SendFileAcceptListener listener) {
		sendFileAcceptListeners.add(listener);
	}

	public void addSendFileRejectListener(SendFileRejectListener listener) {
		sendFileRejectListeners.add(listener);
	}

	public void addSendFileRequestListener(SendFileRequestListener listener) {
		sendFileRequestListeners.add(listener);
	}

	public void addFileSendOverListener(FileSendOverListener listener) {
		fileSendOverListeners.add(listener);
	}

	public void addFileSaveOverListener(FileSaveOverListener listener) {
		fileSaveOverListeners.add(listener);
	}

	public ChatRoomClient(String serverAddress, int port) {
		this.port = port;
		this.serverAddress = serverAddress;
	}//**********************

	// 登陆
	public boolean login(String nickName, String password) {
		try {
			socket = new Socket(serverAddress, port);
			sendData(Protocal.LOGIN_FLAG + nickName + Protocal.SEPARATOR
					+ password);
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					socket.getInputStream()));
			if (reader.readLine().equals(Protocal.LOGIN_SUCCEED_FLAG)) {
				return true;
			} else {
				return false;
			}
		} catch (Exception e) {
			return false;
		}
	}

	public boolean register(String nickName, String password) {
		try {
			socket = new Socket(serverAddress, port);
			sendData(Protocal.REGISTER_FLAG + nickName + Protocal.SEPARATOR
					+ password);
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					socket.getInputStream()));
			String loginFlag = reader.readLine();
			reader.close();
			socket.close();
			if (loginFlag.startsWith(Protocal.REGISTER_SUCCEED_FLAG)) {
				return true;
			} else {
				return false;
			}

		} catch (Exception e) {
			return false;
		}

	}

	// 退出
	public void logout() {
		try {
			sendData(Protocal.BYE_FLAG);
			socket.close();
			nickNameList.clear();
			for (OnlineListListener listener : onlineListListeners) {
				listener.receive(nickNameList);
			}
		} catch (IOException e) {
		}
	}

	// 负责接受服务器发回的数据(登陆成功标志、消息和在线列表)
	public void getDataFromServer() {
		Thread thread = new Thread() {
			@Override
			public void run() {
				try {
					BufferedReader reader = new BufferedReader(
							new InputStreamReader(socket.getInputStream()));
					while (true ) {
						String data = reader.readLine();
						if (data.startsWith(Protocal.PUBLIC_MESSAGE_FLAG)) {// 收到公聊消息
							// 格式： PUBLIC_MESSAGE_FLAGfrom#message
							String[] arr = data.substring(
									Protocal.PUBLIC_MESSAGE_FLAG.length())
									.split(Protocal.SEPARATOR);
							for (PublicMessageListener listener : publicMessageListeners) {
								listener.receive(arr[0], arr[1]);
							}//**********************
						} else if (data
								.startsWith(Protocal.PRIVATE_MESSAGE_FLAG)) {// 收到私聊消息
							// 格式： PRIVATE_MESSAGE_FLAGfrom#message
							String[] arr = data.substring(
									Protocal.PRIVATE_MESSAGE_FLAG.length())
									.split(Protocal.SEPARATOR);//Split是用来拆分的
							for (PrivateMessageListener listener : privateMessageListeners) {
								listener.receive(arr[0], arr[1]);
							}
						} else if (data.startsWith(Protocal.ONLINELIST_FLAG)) {// 收到在线列表
							// 格式：
							// ONLINELIST_FLAGnickName#nickName#nickName#.....
							nickNameList.clear();
							for (String nickName : data.substring(
									Protocal.ONLINELIST_FLAG.length()).split(
									Protocal.SEPARATOR)) {
								nickNameList.add(nickName);
							}
							for (OnlineListListener listener : onlineListListeners) {
								listener.receive(nickNameList);
							}//**********************
						} else if (data.startsWith(Protocal.ACCEPT_FILE_FLAG)) {// 收到对方同意文件传送消息
							// 格式： ACCEPT_FILE_FLAGip#port#接受方昵称
							final String[] arr = data.substring(
									Protocal.ACCEPT_FILE_FLAG.length()).split(
									Protocal.SEPARATOR);
							for (SendFileAcceptListener listener : sendFileAcceptListeners) {
								listener.receive(arr[2]);
							}

							Thread thread = new Thread() {
								@Override
								public void run() {
									sendFile(arr[0], Integer.parseInt(arr[1]));

									for (FileSendOverListener listener : fileSendOverListeners) {
										listener.sendOver(arr[2], sendFileFullName);
									}
								}
							};
							thread.setDaemon(true);
							thread.start();
						} else if (data.startsWith(Protocal.REJECT_FILE_FLAG)) {// 收到对方拒绝文件传送消息
							// 格式： REJECT_FILE_FLAG接受方昵称
							for (SendFileRejectListener listener : sendFileRejectListeners) {
								listener.receive(data
										.substring(Protocal.REJECT_FILE_FLAG
												.length()));
							}
						} else if (data
								.startsWith(Protocal.SEND_FILE_REQUEST_FLAG)) {// 收到对方请求文件传送消息
							// 格式： SEND_FILE_REQUEST_FLAGfrom#filename
							String[] arr = data.substring(
									Protocal.SEND_FILE_REQUEST_FLAG.length())
									.split(Protocal.SEPARATOR);
							for (SendFileRequestListener listener : sendFileRequestListeners) {
								listener.receive(arr[0], arr[1]);
							}
						}

					}
				} catch (Exception e) {
				}
			}
		};
		thread.setDaemon(true);
		thread.start();
	}

	// 客户端发送数据到服务器
	private void sendData(String data) {
		try {
			PrintWriter writer = new PrintWriter(socket.getOutputStream());
			writer.println(data);
			writer.flush();
		} catch (IOException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
	}//**********************

	// 发送公聊信息
	public void sendPublicMessage(String message) {
		sendData(Protocal.PUBLIC_MESSAGE_FLAG + message);
	}//**********************

	// 发送私聊信息
	public void sendPrivateMessage(String to, String message) {
		sendData(Protocal.PRIVATE_MESSAGE_FLAG + to + Protocal.SEPARATOR
				+ message);
	}

	// 发送文件传送请求
	public void sendFileRequest(String to, String sendFileFullName) {
		this.sendFileFullName = sendFileFullName;
		sendData(Protocal.SEND_FILE_REQUEST_FLAG + to + Protocal.SEPARATOR
				+ new File(sendFileFullName).getName());
	}

	// 表示接受由from发送的文件，并保存至fileFullName
	public void receiveFile(final String from, final String fileFullName) {
		Thread thread = new Thread() {
			@Override
			public void run() {
				ServerSocket fileServer = null;
				int port = 10000;
				while (fileServer == null) {
					try {
						fileServer = new ServerSocket(port);
						break;
					} catch (IOException e) {
						port += 10;
					}
				}
				sendData(Protocal.ACCEPT_FILE_FLAG + from 
						+ Protocal.SEPARATOR + fileServer.getLocalPort());
				
				saveFile(from,fileFullName, fileServer);
			}
		};
		thread.setDaemon(true);
		thread.start();

	}

	// 存储文件
	private void saveFile(String from,String fileFullName, ServerSocket fileServer) {

		try {
			Socket socket = fileServer.accept();
			InputStream input = socket.getInputStream();
			FileOutputStream output = new FileOutputStream(fileFullName);//网络到文件
			int count;
			byte[] buf = new byte[1024];
			while ((count = input.read(buf)) > 0) {
				output.write(buf, 0, count);
			}
			output.flush();
			output.close();
			input.close();
			socket.close();
			fileServer.close();

			for (FileSaveOverListener listener : fileSaveOverListeners) {
				listener.saveOver(from,fileFullName);
			}
		} catch (IOException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
	}

	// 发送拒绝文件请求消息
	public void sendFileReject(String to) {
		sendData(Protocal.REJECT_FILE_FLAG + to);
	}

	// 发送文件
	private void sendFile(String ip, int port) {
		try {
			Socket socket = new Socket(ip, port);
			OutputStream output = socket.getOutputStream();
			FileInputStream input = new FileInputStream(sendFileFullName);//文件到到网络
			int count;
			byte[] buf = new byte[1024];
			while ((count = input.read(buf)) > 0) {
				output.write(buf, 0, count);
			}
			output.flush();
			output.close();
			input.close();
			socket.close();

		} catch (UnknownHostException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		} catch (IOException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
	}
}