JAVA聊天软件源码

[java]代码库

package at.ac.uni_linz.tk.vchat;

import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.image.*;

/**
 * Implements the methods for the client side's networking. Opens a socket
 * connection and Input- and OutputStreams to the ChatServer, sends and receives
 * data. It also includes the functionality for User logins and logouts.
 * 
 * @author Arno Huetter (C)opyright by the Institute for Computer Science,
 *         Telecooperation Department, University of Linz
 */

public class ChatClient implements Runnable {

	private Socket clientSocket;
	private Thread clientThread;
	private String host;
	private boolean connected;
	private ChatApplet chatApplet;

	private ObjectOutputStream output;
	private ObjectInputStream input;

	private UserLoginRequest userLogin;

	/**
	 * Constructs the ChatClient.
	 * 
	 * @param hostParam
	 *            the host where the ChatApplet descends from (that is also
	 *            where the ChatServer ought to be running)
	 * @param portParam
	 *            the standard port where the ChatServer is listening
	 * @param chatParam
	 *            the ChatApplet which administrates the users
	 */

	public ChatClient(String hostParam, ChatApplet chatParam) {
		host = hostParam;
		chatApplet = chatParam;
	}

	/**
	 * Connects to the ChatServer.
	 * 
	 * @param portParam
	 *            the port where the ChatServer is listening
	 */

	public void connect(int portParam) {
		try {
			chatApplet.setStatus("Connecting...", true);
			clientSocket = new Socket(host, portParam);

			/*
			 * Open Input- and OutputStreams
			 */
			input = new ObjectInputStream(clientSocket.getInputStream());
			output = new ObjectOutputStream(clientSocket.getOutputStream());

			try {
				Thread.sleep(1000);
			} catch (InterruptedException excpt) {
			}

			/*
			 * Start the thread that is receiving data
			 */
			clientThread = new Thread(this);
			clientThread.start();
			connected = true;
			chatApplet.setStatus("Connected", true);
		} catch (Exception excpt) {
			connected = false;
			System.out.println("Exception while connecting: " + excpt);
			chatApplet
					.setStatus(
							"Exception while connecting. Server down, firewall config or file-URL applet.",
							true);
		}
	}

	/**
	 * Waits for the ChatServer's reply to a login request.
	 */

	public void waitForLoginReply() {
		while (userLogin.status == UserLoginRequest.REQUESTED && connected()) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException excpt) {
			}
		}
	}

	/**
	 * Connects to the ChatServer and sends a login request for an existing
	 * User.
	 * 
	 * @param userNameParam
	 *            the name of the User to login
	 * @param userPasswordParam
	 *            the password of the User to login
	 * @param portParam
	 *            the port where the ChatServer is listening
	 */

	public void connectAsExistingUser(String userNameParam,
			String userPasswordParam, int portParam) {
		int lastUserId;

		connect(portParam);
		if (connected) {
			chatApplet.setStatus("Connecting as existing user...", true);
			chatApplet.stopSimulator();
			chatApplet.removeAllExceptDefaultRoom();
			userLogin = new ExistingUserLoginRequest(userNameParam,
					userPasswordParam);
			send(userLogin);
			chatApplet.setStatus("Waiting for server reply...", true);
			waitForLoginReply();
			if (userLogin.status == UserLoginRequest.ACCEPTED) {
				lastUserId = chatApplet.getCurrentUserId();
				chatApplet.setCurrentUser(userLogin.user);

				if (userLogin.user.getId() != lastUserId)
					chatApplet.removeUser(lastUserId);

				chatApplet.restartHistory();
				chatApplet.setStatus("Login accepted: "
						+ userLogin.statusString, true);
				chatApplet.setFrameVisibility(true);
			} else {
				disconnect();
				chatApplet.setStatus("Login denied: " + userLogin.statusString,
						true);
			}
		}
	}

	/**
	 * Connects to the ChatServer and sends a login request for a new User.
	 * 
	 * @param userParam
	 *            the User to login
	 * @param portParam
	 *            the port where the ChatServer is listening
	 */

	public void connectAsNewUser(User userParam, int portParam) {
		int lastUserId;

		connect(portParam);
		if (connected) {
			chatApplet.setStatus("Connecting as new user...", true);
			chatApplet.stopSimulator();
			chatApplet.removeAllExceptDefaultRoom();

			userLogin = new NewUserLoginRequest(userParam);
			send(userLogin);
			chatApplet.setStatus("Waiting for server reply...", true);
			waitForLoginReply();
			if (userLogin.status == UserLoginRequest.ACCEPTED) {
				lastUserId = chatApplet.getCurrentUserId();
				chatApplet.setCurrentUser(userLogin.user);

				if (userLogin.user.getId() != lastUserId)
					chatApplet.removeUser(lastUserId);

				chatApplet.restartHistory();
				chatApplet.setStatus("Login accepted: "
						+ userLogin.statusString, true);
				chatApplet.setFrameVisibility(true);
			} else {
				disconnect();
				chatApplet.setStatus("Login denied: " + userLogin.statusString,
						true);
			}
		}
	}

	/**
	 * Disconnects from the ChatServer.
	 */

	public void disconnect() {
		try {
			send(new UserLogoutEvent(chatApplet.getCurrentUserId()));
			if (clientThread != null && clientThread.isAlive())
				clientThread.stop();
			if (output != null)
				output.close();
			if (input != null)
				input.close();
			if (clientSocket != null)
				clientSocket.close();
			chatApplet.setStatus("Disconnected", true);
		} catch (IOException excpt) {
			System.out.println("Exception while disconnecting: " + excpt);
			chatApplet.setStatus("Exception while disconnecting", true);
		} finally {
			connected = false;
			chatApplet.removeAllExceptCurrentUser();
			chatApplet.removeAllExceptDefaultRoom();
		}
	}

	/**
	 * Runs a thread that is receiving data from the InpuStream openend to the
	 * ChatServer.
	 */

	public void run() {
		Object receivedObject;
		User user;
		while (connected) {
			try {
				receivedObject = input.readObject();
				chatApplet.setStatus("Receiving data");
				if (receivedObject instanceof UserPositionEvent)
					chatApplet.setUserPosition(
							((UserPositionEvent) receivedObject).userId,
							((UserPositionEvent) receivedObject).userPosition,
							false);
				else if (receivedObject instanceof UserHeadingEvent)
					chatApplet.setUserHeading(
							((UserHeadingEvent) receivedObject).userId,
							((UserHeadingEvent) receivedObject).userHeading,
							false);
				else if (receivedObject instanceof UserMessageEvent)
					chatApplet.setUserMessage(
							((UserMessageEvent) receivedObject).userId,
							((UserMessageEvent) receivedObject).userMessage,
							false);
				else if (receivedObject instanceof UserMoodEvent)
					chatApplet.setUserMood(
							((UserMoodEvent) receivedObject).userId,
							((UserMoodEvent) receivedObject).userMood, false);
				else if (receivedObject instanceof UserRoomEvent) {
					chatApplet.moveUserToRoom(
							((UserRoomEvent) receivedObject).userId,
							((UserRoomEvent) receivedObject).roomId, false);
					chatApplet.setUserPosition(
							((UserRoomEvent) receivedObject).userId,
							((UserRoomEvent) receivedObject).position, false);
				} else if (receivedObject instanceof UserUpdateEvent) {
					chatApplet.updateUser(
							((UserUpdateEvent) receivedObject).user, false);
					if (((UserUpdateEvent) receivedObject).user.getId() == chatApplet
							.getCurrentUserId()) {
						chatApplet
								.setStatus(
										((UserUpdateEvent) receivedObject).statusString,
										false);
					}
				} else if (receivedObject instanceof UserLoginEvent)
					chatApplet.addUser(((UserLoginEvent) receivedObject).user);
				else if (receivedObject instanceof UserLogoutEvent) {
					chatApplet
							.removeUser(((UserLogoutEvent) receivedObject).userId);
				} else if (receivedObject instanceof NewUserLoginRequest) {
					chatApplet.setStatus("Received login", true);
					userLogin = (NewUserLoginRequest) receivedObject;
				} else if (receivedObject instanceof ExistingUserLoginRequest) {
					chatApplet.setStatus("Received login", true);
					userLogin = (ExistingUserLoginRequest) receivedObject;
				} else if (receivedObject instanceof RoomUpdateEvent) {
					chatApplet.setStatus("Received room update", true);
					chatApplet.updateRoom(
							((RoomUpdateEvent) receivedObject).room, false);
				} else if (receivedObject instanceof RoomCreateEvent) {
					chatApplet.setStatus("Received room creation", true);
					chatApplet.updateRoom(
							((RoomCreateEvent) receivedObject).room, false);
				} else if (receivedObject instanceof RoomListEvent) {
					chatApplet.setStatus("Received room list", true);
					chatApplet
							.setRoomTable(((RoomListEvent) receivedObject).roomTable);
				} else if (receivedObject instanceof RoomRemoveEvent) {
					chatApplet.setStatus("Received room removal", true);
					chatApplet.forceRoomRemoval(
							((RoomRemoveEvent) receivedObject).roomId, false);
				}
			} catch (Exception excpt) {
				System.out.println("Exception while receiving data: " + excpt
						+ ". Going offline...");
				chatApplet.setStatus(
						"Exception while receiving data. Going offline...",
						true);
				disconnect();
			}
		}
	}

	/**
	 * Sends data over the OutputStream openend to the ChatServer.
	 * 
	 * @param sendObject
	 *            the object to be sent
	 */

	public void send(Object sendObject) {
		try {
			if (connected) {
				chatApplet.setStatus("Sending data");
				output.writeObject(sendObject);
			}
		} catch (IOException excpt) {
			System.out.println("Exception while sending data: " + excpt
					+ ". Going offline...");
			chatApplet.setStatus(
					"Exception while sending data. Going offline...", true);
			disconnect();
		}
	}

	/**
	 * Sends data over the OutputStream openend to the ChatServer.
	 * 
	 * @param sendObject
	 *            the object to be sent
	 */

	public boolean connected() {
		return connected;
	}

	/**
	 * Returns the host where the ChatClient is opening connections to.
	 */

	public String getHost() {
		return host;
	}

}

[源代码打包下载]