chessserver.java

Java五子棋编程

		{
			message = clientNameHash.get(clientSocket) + ">" + message;
			server.messageBoard.append(message + "\n");
			publicTalk(message);
			server.messageBoard.setCaretPosition(server.messageBoard.getText()
					.length());
		}
	}

	public void publicTalk(String publicTalkMessage)
	{

		synchronized (clientDataHash)
		{
			for (Enumeration enu = clientDataHash.elements(); enu
					.hasMoreElements();)
			{
				DataOutputStream outData = (DataOutputStream) enu.nextElement();
				try
				{
					outData.writeUTF(publicTalkMessage);
				}
				catch (IOException es)
				{
					es.printStackTrace();
				}
			}
		}
	}

	public boolean peerTalk(String peerTalk, String talkMessage)
	{
		for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();)
		{
			Socket userClient = (Socket) enu.nextElement();
			if (peerTalk.equals((String) clientNameHash.get(userClient))
					&& !peerTalk.equals((String) clientNameHash
							.get(clientSocket)))
			{
				synchronized (clientDataHash)
				{
					DataOutputStream peerOutData = (DataOutputStream) clientDataHash
							.get(userClient);
					try
					{
						peerOutData.writeUTF(talkMessage);
					}
					catch (IOException es)
					{
						es.printStackTrace();
					}
				}
				Feedback(talkMessage);
				return (false);
			}
			else
				if (peerTalk.equals((String) clientNameHash.get(clientSocket)))
				{
					Feedback(talkMessage);
					return (false);
				}
		}
		return (true);
	}

	public boolean chessPeerTalk(String chessPeerTalk, String chessTalkMessage)
	{
		for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();)
		{
			Socket userClient = (Socket) enu.nextElement();

			if (chessPeerTalk.equals((String) clientNameHash.get(userClient))
					&& !chessPeerTalk.equals((String) clientNameHash
							.get(clientSocket)))
			{
				synchronized (clientDataHash)
				{
					DataOutputStream peerOutData = (DataOutputStream) clientDataHash
							.get(userClient);
					try
					{
						peerOutData.writeUTF(chessTalkMessage);
					}
					catch (IOException es)
					{
						es.printStackTrace();
					}
				}
				return (false);
			}
		}
		return (true);
	}

	public void Feedback(String feedbackString)
	{
		synchronized (clientDataHash)
		{
			DataOutputStream outData = (DataOutputStream) clientDataHash
					.get(clientSocket);
			try
			{
				outData.writeUTF(feedbackString);
			}
			catch (Exception eb)
			{
				eb.printStackTrace();
			}
		}
	}

	public String getUserList()
	{
		String userList = "/userlist";

		for (Enumeration enu = clientNameHash.elements(); enu.hasMoreElements();)
		{
			userList = userList + " " + (String) enu.nextElement();
		}
		return (userList);
	}

	public Object getHashKey(Hashtable targetHash, Object hashValue)
	{
		Object hashKey;
		for (Enumeration enu = targetHash.keys(); enu.hasMoreElements();)
		{
			hashKey = (Object) enu.nextElement();
			if (hashValue.equals((Object) targetHash.get(hashKey)))
				return (hashKey);
		}
		return (null);
	}

	public void firstCome()
	{
		publicTalk(getUserList());
		Feedback("/yourname " + (String) clientNameHash.get(clientSocket));
		Feedback("Java五子棋聊天客户端");
		Feedback("/changename <你的名字> --更改名字");
		Feedback("/list --更新用户列表");
		Feedback("/<用户名> <要说的话> --私聊");
		Feedback("注意：用命令的时候，先把谈话的对象定为所有人");
	}

	public void clientClose()
	{
		server.messageBoard.append("用户断开:" + clientSocket + "\n");
		// 如果是游戏客户端主机
		synchronized (chessPeerHash)
		{
			if (chessPeerHash.containsKey(clientNameHash.get(clientSocket)))
			{
				chessPeerHash.remove((String) clientNameHash.get(clientSocket));
			}
			if (chessPeerHash.containsValue(clientNameHash.get(clientSocket)))
			{
				chessPeerHash.put((String) getHashKey(chessPeerHash,
						(String) clientNameHash.get(clientSocket)),
						"tobeclosed");
			}
		}
		synchronized (clientDataHash)
		{
			clientDataHash.remove(clientSocket);
		}
		synchronized (clientNameHash)
		{
			clientNameHash.remove(clientSocket);
		}
		publicTalk(getUserList());
		server.statusLabel.setText("当前连接数:" + clientDataHash.size());
		try
		{
			clientSocket.close();
		}
		catch (IOException exx)
		{
		}

		isClientClosed = true;

	}

	public void run()
	{
		DataInputStream inData;
		synchronized (clientDataHash)
		{
			server.statusLabel.setText("当前连接数:" + clientDataHash.size());
		}
		try
		{
			inData = new DataInputStream(clientSocket.getInputStream());
			firstCome();
			while (true)
			{
				String message = inData.readUTF();
				messageTransfer(message);
			}
		}
		catch (IOException esx)
		{
		}
		finally
		{
			if (!isClientClosed)
			{
				clientClose();
			}
		}
	}

}

public class chessServer extends Frame implements ActionListener
{

	Button messageClearButton = new Button("清除显示");

	Button serverStatusButton = new Button("服务器状态");

	Button serverOffButton = new Button("关闭服务器");

	Panel buttonPanel = new Panel();

	MessageServer server = new MessageServer();

	ServerSocket serverSocket;

	Hashtable clientDataHash = new Hashtable(50);

	Hashtable clientNameHash = new Hashtable(50);

	Hashtable chessPeerHash = new Hashtable(50);

	chessServer()
	{
		super("Java五子棋服务器");
		setBackground(Color.pink);

		buttonPanel.setLayout(new FlowLayout());
		messageClearButton.setSize(60, 25);
		buttonPanel.add(messageClearButton);
		messageClearButton.addActionListener(this);
		serverStatusButton.setSize(75, 25);
		buttonPanel.add(serverStatusButton);
		serverStatusButton.addActionListener(this);
		serverOffButton.setSize(75, 25);
		buttonPanel.add(serverOffButton);
		serverOffButton.addActionListener(this);

		add(server, BorderLayout.CENTER);
		add(buttonPanel, BorderLayout.SOUTH);

		addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);
			}
		});
		pack();
		setVisible(true);
		setSize(400, 450);
		setResizable(false);
		validate();
		try
		{
			makeMessageServer(4331, server);
		}
		catch (Exception e)
		{
			System.out.println("e");
		}
	}

	public void makeMessageServer(int port, MessageServer server)
			throws IOException
	{
		Socket clientSocket;
		long clientAccessNumber = 1;
		this.server = server;

		try
		{
			serverSocket = new ServerSocket(port);
			server.messageBoard.setText("服务器开始于:"
					+ serverSocket.getInetAddress().getLocalHost() + ":"
					+ serverSocket.getLocalPort() + "\n");

			while (true)
			{
				clientSocket = serverSocket.accept();
				server.messageBoard.append("用户连接:" + clientSocket + "\n");

				DataOutputStream outData = new DataOutputStream(clientSocket
						.getOutputStream());

				clientDataHash.put(clientSocket, outData);
				clientNameHash
						.put(clientSocket, ("新来客" + clientAccessNumber++));

				ServerThread thread = new ServerThread(clientSocket,
						clientDataHash, clientNameHash, chessPeerHash, server);

				thread.start();
			}
		}
		catch (IOException ex)
		{
			System.out.println("已经有服务器在运行. \n");
		}

	}

	public void actionPerformed(ActionEvent e)
	{
		if (e.getSource() == messageClearButton)
		{
			server.messageBoard.setText("");
		}
		if (e.getSource() == serverStatusButton)
		{
			try
			{
				server.messageBoard.append("服务器信息:"
						+ serverSocket.getInetAddress().getLocalHost() + ":"
						+ serverSocket.getLocalPort() + "\n");
			}
			catch (Exception ee)
			{
				System.out
						.println("serverSocket.getInetAddress().getLocalHost() error \n");
			}
		}
		if (e.getSource() == serverOffButton)
		{
			System.exit(0);
		}
	}

	public static void main(String args[])
	{
		chessServer chessServer = new chessServer();
	}
}