无聊时写的DOS聊天工具

在公司没聊天工具，为了方便与同事即时联系，写了此程序。
已有很多注释，就不做多解释了。


Main.java

Java代码

1. /**  
2.  * 主入口  
3.  * @author xKF24276 ruilin.xie  
4.  *  
5.  */  
6. public class Main {   
7.   
8.   
9.     //程序主入口   
10.     public static void main(String[] args)    
11.     {   
12.         //实例服务端   
13.         Services s = new Services();   
14.            
15.         //设置服务端监听端口   
16.         s.open(88);   
17.            
18.         //开始监听   
19.         s.start();   
20.     }   
21.   
22. }  

/**
 * 主入口
 * @author xKF24276 ruilin.xie
 *
 */
public class Main {


	//程序主入口
	public static void main(String[] args) 
	{
		//实例服务端
		Services s = new Services();
		
		//设置服务端监听端口
		s.open(88);
		
		//开始监听
		s.start();
	}

}

Services.java

Java代码

1. import java.io.BufferedReader;   
2. import java.io.IOException;   
3. import java.io.InputStream;   
4. import java.io.InputStreamReader;   
5. import java.io.OutputStream;   
6. import java.io.OutputStreamWriter;   
7. import java.net.ServerSocket;   
8. import java.net.Socket;   
9. import java.util.ArrayList;   
10. import java.util.List;   
11.   
12. /**  
13.  * 服务  
14.  *   
15.  * @author xKF24276 ruilin.xie  
16.  *   
17.  */  
18.   
19. public class Services extends Thread    
20. {   
21.   
22.     // 用于存放所有用户的集合   
23.     public static List<UserInfo> allUser = new ArrayList<UserInfo>();   
24.   
25.     // 服务器开启端口   
26.     private int port = 80;   
27.   
28.     // 设置服务器监听端口   
29.     public void open(int port)    
30.     {   
31.         this.port = port;   
32.     }   
33.   
34.     // 主线程，用于监听用户上线   
35.     public void run()    
36.     {   
37.         System.out.println("聊天室服务端启动成功,正在监听用户登录信息...");   
38.   
39.         // 服务端   
40.         ServerSocket srvSocket = null;   
41.   
42.         // 客户端套接字   
43.         Socket client = null;   
44.   
45.         // 客户端输出流   
46.         OutputStream out = null;   
47.   
48.         // 客户端输入流   
49.         InputStream in = null;   
50.   
51.         // 用户名字   
52.         String yourname = null;   
53.   
54.         try    
55.         {   
56.             // 打开服务   
57.             srvSocket = new ServerSocket(port);   
58.         } catch (IOException e) {   
59.             e.printStackTrace();   
60.         }   
61.   
62.         while (true)    
63.         {   
64.             try    
65.             {   
66.                 // 休眠0.5s   
67.                 Thread.sleep(500);   
68.             } catch (InterruptedException e1) {   
69.                 e1.printStackTrace();   
70.             }   
71.   
72.             try    
73.             {   
74.                 // 等待客户机登录   
75.                 client = srvSocket.accept();   
76.                 out = client.getOutputStream();   
77.   
78.                 // 发送欢迎信息   
79.                 OutputStreamWriter writer = new OutputStreamWriter(out);   
80.                 writer.write("/t/tWelcome ! /r/nInput YourName : ");   
81.                 writer.flush();   
82.   
83.                 // 获取用户输入用户名   
84.                 in = client.getInputStream();   
85.                 InputStreamReader inreader = new InputStreamReader(in);   
86.                 BufferedReader reader = new BufferedReader(inreader);   
87.                 yourname = reader.readLine();   
88.   
89.                 // 初始化用户信息   
90.                 UserInfo uinfo = new UserInfo();   
91.                 uinfo.setClient(client);   
92.                 uinfo.setUip(client.getInetAddress().getHostAddress());   
93.   
94.                 if (yourname != null)    
95.                 {   
96.                     yourname = checkYourName(yourname);   
97.                     uinfo.setUname(yourname);   
98.   
99.                     // 用户存入集合   
100.                     allUser.add(uinfo);   
101.   
102.                     System.out.println("〖系统消息:" + yourname + " 上线 !〗");   
103.   
104.                     // 发送提示登录成功   
105.                     writer.write("〖系统消息: Login Success, OnLine Count : "  
106.                             + allUser.size() + "〗/r/n");   
107.                     writer.flush();   
108.   
109.                     // 启动该用户监听线程   
110.                     SrvBuss sb = new SrvBuss();   
111.                     // 设置用户信息   
112.                     sb.setUserInfo(uinfo);   
113.                     sb.start();   
114.   
115.                     // 向其他用户提示有用户上线   
116.                     sb.sendAllMsg("〖系统消息: " + yourname + " 上线 !〗/r/n");   
117.                 }   
118.   
119.             }    
120.             catch (IOException e)    
121.             {   
122.                 e.printStackTrace();   
123.             }   
124.         }   
125.     }   
126.   
127.     // 用户如果存在，那么给新用户新标识   
128.     public String checkYourName(String uname)    
129.     {   
130.         for (int i = 0; i < allUser.size(); i++)   
131.         {   
132.             UserInfo uinfo = allUser.get(i);   
133.             if (uinfo.getUname().equals(uname.trim()))    
134.             {   
135.                 return uname + "_" + StrUtil.NumStr(5);   
136.             }   
137.   
138.         }   
139.         return uname;   
140.     }   
141.   
142. }  

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 服务
 * 
 * @author xKF24276 ruilin.xie
 * 
 */

public class Services extends Thread 
{

	// 用于存放所有用户的集合
	public static List<UserInfo> allUser = new ArrayList<UserInfo>();

	// 服务器开启端口
	private int port = 80;

	// 设置服务器监听端口
	public void open(int port) 
	{
		this.port = port;
	}

	// 主线程，用于监听用户上线
	public void run() 
	{
		System.out.println("聊天室服务端启动成功,正在监听用户登录信息...");

		// 服务端
		ServerSocket srvSocket = null;

		// 客户端套接字
		Socket client = null;

		// 客户端输出流
		OutputStream out = null;

		// 客户端输入流
		InputStream in = null;

		// 用户名字
		String yourname = null;

		try 
		{
			// 打开服务
			srvSocket = new ServerSocket(port);
		} catch (IOException e) {
			e.printStackTrace();
		}

		while (true) 
		{
			try 
			{
				// 休眠0.5s
				Thread.sleep(500);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}

			try 
			{
				// 等待客户机登录
				client = srvSocket.accept();
				out = client.getOutputStream();

				// 发送欢迎信息
				OutputStreamWriter writer = new OutputStreamWriter(out);
				writer.write("/t/tWelcome ! /r/nInput YourName : ");
				writer.flush();

				// 获取用户输入用户名
				in = client.getInputStream();
				InputStreamReader inreader = new InputStreamReader(in);
				BufferedReader reader = new BufferedReader(inreader);
				yourname = reader.readLine();

				// 初始化用户信息
				UserInfo uinfo = new UserInfo();
				uinfo.setClient(client);
				uinfo.setUip(client.getInetAddress().getHostAddress());

				if (yourname != null) 
				{
					yourname = checkYourName(yourname);
					uinfo.setUname(yourname);

					// 用户存入集合
					allUser.add(uinfo);

					System.out.println("〖系统消息:" + yourname + " 上线 !〗");

					// 发送提示登录成功
					writer.write("〖系统消息: Login Success, OnLine Count : "
							+ allUser.size() + "〗/r/n");
					writer.flush();

					// 启动该用户监听线程
					SrvBuss sb = new SrvBuss();
					// 设置用户信息
					sb.setUserInfo(uinfo);
					sb.start();

					// 向其他用户提示有用户上线
					sb.sendAllMsg("〖系统消息: " + yourname + " 上线 !〗/r/n");
				}

			} 
			catch (IOException e) 
			{
				e.printStackTrace();
			}
		}
	}

	// 用户如果存在，那么给新用户新标识
	public String checkYourName(String uname) 
	{
		for (int i = 0; i < allUser.size(); i++)
		{
			UserInfo uinfo = allUser.get(i);
			if (uinfo.getUname().equals(uname.trim())) 
			{
				return uname + "_" + StrUtil.NumStr(5);
			}

		}
		return uname;
	}

}

SrvBuss.java

Java代码

1. import java.io.BufferedReader;   
2. import java.io.IOException;   
3. import java.io.InputStream;   
4. import java.io.InputStreamReader;   
5. import java.io.OutputStream;   
6. import java.io.OutputStreamWriter;   
7. import java.net.Socket;   
8.   
9. /**  
10.  * 单用户线程处理  
11.  *   
12.  * @author xKF24276 ruilin.xie  
13.  *   
14.  */  
15.   
16. public class SrvBuss extends Thread    
17. {   
18.   
19.     // 登录用户信息   
20.     private UserInfo uinfo = null;   
21.   
22.     public void setUserInfo(UserInfo uinfo)    
23.     {   
24.         this.uinfo = uinfo;   
25.     }   
26.   
27.     public UserInfo getUserInfo()    
28.     {   
29.         return this.uinfo;   
30.     }   
31.   
32.     // 副线程，用于单用户监听   
33.     public void run()    
34.     {   
35.         // 得到单用户信息   
36.         Socket client = uinfo.getClient();   
37.         String line = null;   
38.         while (true)    
39.         {   
40.   
41.             try    
42.             {   
43.                 // 监控用户是否有输入信息   
44.                 InputStream in = client.getInputStream();   
45.   
46.                 // 如果用户有输入，则获取输入内容   
47.                 InputStreamReader inreader = new InputStreamReader(in);   
48.                 BufferedReader reader = new BufferedReader(inreader);   
49.                 line = reader.readLine();   
50.   
51.                 // 如果用户关闭聊天窗口   
52.                 if (line == null)    
53.                 {   
54.                     // remove该用户，关闭线程   
55.                     removeMyself();   
56.                     return;   
57.                 }   
58.   
59.                 // 如果该用户有输入数据,则发送给其他用户   
60.                 sendAllMsg("【" + uinfo.getUname() + " " + uinfo.getUip()   
61.                         + " 】 Say : " + line + "/r/n");   
62.             }    
63.             catch (IOException e)    
64.             {   
65.                 e.printStackTrace();   
66.             }   
67.   
68.         }   
69.     }   
70.   
71.     // 将消息散布   
72.     public void sendAllMsg(String msg) throws IOException    
73.     {   
74.         OutputStream out = null;   
75.         for (int i = 0; i < Services.allUser.size(); i++)    
76.         {   
77.   
78.             UserInfo user = Services.allUser.get(i);   
79.   
80.             // 如果是自己，则不需发送消息   
81.             if (uinfo.getUname().equals(user.getUname()))    
82.             {   
83.                 continue;   
84.             }   
85.             Socket client = user.getClient();   
86.             out = client.getOutputStream();   
87.             OutputStreamWriter writer = new OutputStreamWriter(out);   
88.             writer.write(msg);   
89.             writer.flush();   
90.         }   
91.     }   
92.   
93.     // 删除下线用户   
94.     public void removeMyself() throws IOException    
95.     {   
96.         for (int i = 0; i < Services.allUser.size(); i++)    
97.         {   
98.             UserInfo user = Services.allUser.get(i);   
99.             // 如果当前用户关闭聊天窗口   
100.             if (user.getUname().equals(uinfo.getUname()))   
101.             {   
102.                 // 向其他用户提示该用户下线   
103.                 sendAllMsg("〖系统消息: " + user.getUname() + " 下线 !〗/r/n");   
104.                 System.out.println("〖系统消息: " + user.getUname() + " 下线 !〗/r/n");   
105.   
106.                 // remove当前用户   
107.                 Services.allUser.remove(i);   
108.             }   
109.         }   
110.     }   
111. }  

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

/**
 * 单用户线程处理
 * 
 * @author xKF24276 ruilin.xie
 * 
 */

public class SrvBuss extends Thread 
{

	// 登录用户信息
	private UserInfo uinfo = null;

	public void setUserInfo(UserInfo uinfo) 
	{
		this.uinfo = uinfo;
	}

	public UserInfo getUserInfo() 
	{
		return this.uinfo;
	}

	// 副线程，用于单用户监听
	public void run() 
	{
		// 得到单用户信息
		Socket client = uinfo.getClient();
		String line = null;
		while (true) 
		{

			try 
			{
				// 监控用户是否有输入信息
				InputStream in = client.getInputStream();

				// 如果用户有输入，则获取输入内容
				InputStreamReader inreader = new InputStreamReader(in);
				BufferedReader reader = new BufferedReader(inreader);
				line = reader.readLine();

				// 如果用户关闭聊天窗口
				if (line == null) 
				{
					// remove该用户，关闭线程
					removeMyself();
					return;
				}

				// 如果该用户有输入数据,则发送给其他用户
				sendAllMsg("【" + uinfo.getUname() + " " + uinfo.getUip()
						+ " 】 Say : " + line + "/r/n");
			} 
			catch (IOException e) 
			{
				e.printStackTrace();
			}

		}
	}

	// 将消息散布
	public void sendAllMsg(String msg) throws IOException 
	{
		OutputStream out = null;
		for (int i = 0; i < Services.allUser.size(); i++) 
		{

			UserInfo user = Services.allUser.get(i);

			// 如果是自己，则不需发送消息
			if (uinfo.getUname().equals(user.getUname())) 
			{
				continue;
			}
			Socket client = user.getClient();
			out = client.getOutputStream();
			OutputStreamWriter writer = new OutputStreamWriter(out);
			writer.write(msg);
			writer.flush();
		}
	}

	// 删除下线用户
	public void removeMyself() throws IOException 
	{
		for (int i = 0; i < Services.allUser.size(); i++) 
		{
			UserInfo user = Services.allUser.get(i);
			// 如果当前用户关闭聊天窗口
			if (user.getUname().equals(uinfo.getUname()))
			{
				// 向其他用户提示该用户下线
				sendAllMsg("〖系统消息: " + user.getUname() + " 下线 !〗/r/n");
				System.out.println("〖系统消息: " + user.getUname() + " 下线 !〗/r/n");

				// remove当前用户
				Services.allUser.remove(i);
			}
		}
	}
}

StrUtil.java

Java代码

1. import java.util.Random;   
2.   
3. /**  
4.  * 工具类  
5.  *   
6.  * @author xKF24276 ruilin.xie  
7.  *   
8.  */  
9. public class StrUtil    
10. {   
11.     public static String NumStr(int length)    
12.     {   
13.         StringBuffer numstr = new StringBuffer();   
14.   
15.         char[] cwords = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',   
16.                 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',   
17.                 'w', 'x', 'y', 'z', 'A', 'B', 'V', 'D', 'E', 'F', 'G', 'H',   
18.                 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',   
19.                 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5',   
20.                 '6', '7', '8', '9' };   
21.   
22.         for (int i = 0; i < length; i++)    
23.         {   
24.             int ran = new Random().nextInt(cwords.length);   
25.             numstr.append(cwords[ran]);   
26.         }   
27.   
28.         return numstr.toString();   
29.     }   
30. }  

import java.util.Random;

/**
 * 工具类
 * 
 * @author xKF24276 ruilin.xie
 * 
 */
public class StrUtil 
{
	public static String NumStr(int length) 
	{
		StringBuffer numstr = new StringBuffer();

		char[] cwords = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
				'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
				'w', 'x', 'y', 'z', 'A', 'B', 'V', 'D', 'E', 'F', 'G', 'H',
				'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
				'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5',
				'6', '7', '8', '9' };

		for (int i = 0; i < length; i++) 
		{
			int ran = new Random().nextInt(cwords.length);
			numstr.append(cwords[ran]);
		}

		return numstr.toString();
	}
}

UserInfo.java

Java代码

1. import java.net.Socket;   
2.   
3. /**  
4.  * 用户信息  
5.  *   
6.  * @author xKF24276 ruilin.xie  
7.  *   
8.  */  
9.   
10. public class UserInfo    
11. {   
12.   
13.     // 用户名   
14.     private String uname;   
15.   
16.     // 用户IP   
17.     private String uip;   
18.   
19.     // 客户端套接字   
20.     private Socket client;   
21.   
22.     public String getUname()    
23.     {   
24.         return uname;   
25.     }   
26.   
27.     public void setUname(String uname)    
28.     {   
29.         this.uname = uname;   
30.     }   
31.   
32.     public String getUip()    
33.     {   
34.         return uip;   
35.     }   
36.   
37.     public void setUip(String uip)    
38.     {   
39.         this.uip = uip;   
40.     }   
41.   
42.     public Socket getClient()    
43.     {   
44.         return client;   
45.     }   
46.   
47.     public void setClient(Socket client)    
48.     {   
49.         this.client = client;   
50.     }   
51. }