flex与java之间socket通信的教程5

服务端代码：Server5.java

1. /*
2. * 自定义的协议　
3. * 收到消息： 11开头表示新加入了聊天用户；22开头表示公聊；33开头表示私聊
4. * 发送消息：11开头表示更新用户列表；22开头表示发送到屏幕上;44发送在线人数
5. *
6. */
8. import java.net.*;
9. import java.io.*;
10. import java.util.*;
11. public class Server5 {
13.         private ServerSocket server;
14.         private BManager bMan=new BManager();  //消息广播者
15.         //Map接口的HashMap类，元素拥有固定key值，key值不重复，这里用来存放在线用户
16.         Map clientList = new HashMap();
17.         public Server5(){}  //构造函数
18.         void startServer()  //启动服务器
19.         {
20.                 try{
21.                         server=new ServerSocket(8888);  //创建服务器套接字
22.                         System.out.println("服务器套接字建立完毕");
23.                         while(true)
24.                         {
25.                                 Socket socket=server.accept();  //若客户机提出请求，使用socket进行连接
26.                                 //String strIP = socket.getInetAddress().toString();//登陆者的ip
27.                                 Chat_Thread ct=new Chat_Thread(socket);
28.                                 ct.start();  //启动线程
29.                                 bMan.add(socket);  //添加套接字
30.                                 bMan.sendClientInfo();//使用套接字输出当前聊天人数
31.                                 //funList(clientList);
32.                                 //bMan.sendToAll(strIP+"/加入聊天室");
33.                         }
34.                 }catch(Exception e){
35.                         System.out.println(e);
36.                 }
37.         }
38.         public static void main(String[] args) {
39.                 Server5 server=new Server5();
40.                 server.startServer();
41.         }
42.         class Chat_Thread extends Thread  //与客户机进行通讯的线程类
43.         {
44.                 Socket socket;//x1
45.                 private BufferedReader reader;  //套接字输入流；
46.                 private PrintWriter writer;   //套接字输出流
47.                 Chat_Thread(Socket socket)
48.                 {
49.                         this.socket=socket;//this.socket就是x1处的socket
50.                 }
51.                 public void run()
52.                 {
53.                        
54.                         try
55.                         {
56.                                 reader=new BufferedReader(new InputStreamReader(socket.getInputStream(),"utf8"));
57.                                 writer=new PrintWriter(socket.getOutputStream(),true);
58.                                 String msg;
59.                                 //msg获取消息
60.                                 while((msg=reader.readLine())!=null)
61.                                 {
62.                                         System.out.println(msg);//服务器屏幕输出消息
63.                                         String str=msg.substring(0, 2);//截取前两个个字符
64.                                         int a=Integer.parseInt(str);//强制转换成int
65.                                         String[] arrMsg=msg.split("--");//将获取的消息以"--"符号为标志分解成数组
66.                                         switch(a)
67.                                         {
68.                                                 case 11 : //当消息以11开头的时候，将登陆者的信息储存到hashmap之中，并向客户端发送新的在线列表
69.                                                         String strName=msg.substring(2);//获取登陆者名字，消息格式“11eko”
70.                                                         System.out.println(strName+"登陆了");//服务器屏幕输出谁登陆了
71.                                                         bMan.sendToAll("22"+strName+"登陆了");//广播谁登陆了
72.                                                         clientList.put(this.socket,strName);//加入到HashMap中
73.                                                         funList(clientList);//广播在线列表
74.                                                         break;
75.                                                 case 22://当消息以22开头的时候，内容为“22--eko--内容”
76.                                                         System.out.println("公聊");
77.                                                         //构造消息，arrMsg[0]=消息头，arrMsg[1]消息发送者，arrMsg[2]消息内容
78.                                                         msg=arrMsg[0]+arrMsg[1]+"说："+arrMsg[2];
79.                                                         bMan.sendToAll(msg);//向所有人广播消息
80.                                                         break;
81.                                                 case 33://消息以33开头时候，内容为“33--sandal--eko--内容”
82.                                                         //arrMsg[1]为说话对象，arrMsg[２]为说话人，arrMsg[３]为消息内容
83.                                                         if(arrMsg[1].equals("所有人"))//当说话对象为＂所有人＂的时候
84.                                                         {
85.                                                                 //构造消息＂22eko说：内容＂
86.                                                                 msg="22"+arrMsg[2]+"说："+arrMsg[3];
87.                                                                 //向所有人发送消息
88.                                                                 bMan.sendToAll(msg);
89.                                                         }else //其他情况就是向具体的某个人发送消息了
90.                                                         {
91.                                                                 Socket socketOne;
92.                                                                 System.out.println("私聊");
93.                                                                 Set set = clientList.keySet();//使用keySet方法获取所有key值
94.                                                                 Iterator it = set.iterator();//使用Iterator（迭代器）来遍历数据
95.                                                                 while (it.hasNext()) {        //返回是否还有没被访问过的对象
96.                                                                         Object ok=it.next();//返回下一个没被访问过的对象
97.                                                                         Object ov=clientList.get(ok);//get方法返回拥有key的元素
98.                                                                         if(ov.equals(arrMsg[1]))//如果在client中找到"消息发给谁"的时候，发给对方
99.                                                                         {
100.                                                                                 socketOne=(Socket)ok;//强制转换成key值类型；
101.                                                                                 bMan.sendToONE(socketOne,"22（悄悄话）"+arrMsg[2]+"对你说："+arrMsg[3]);
102.                                                                         }else if(ov.equals(arrMsg[2]))//如果在client中找到"发消息的人"的时候，发给他自己
103.                                                                         {
104.                                                                                 socketOne=(Socket)ok;
105.                                                                                 bMan.sendToONE(socketOne,"22（悄悄话）你对"+arrMsg[1]+"说："+arrMsg[3]);
106.                                                                         }
107.                                                                 }
108.                                                         }
109.                                                        
110.                                                         break;
111.                                         }
112.                                         //bMan.sendToAll(msg);
113.                                 }
114.                         }catch(Exception e)
115.                         {
116.                                
117.                         }finally
118.                         {
119.                                 try {
120.                                         bMan.remove(socket);
121.                                         if(reader !=null) reader.close();
122.                                         if(writer !=null) writer.close();
123.                                         if(socket !=null) socket.close();
124.                                         if(clientList.containsKey(socket))
125.                                         {
126.                                                 bMan.sendToAll("22"+clientList.get(socket)+"离开了...");//广播消息，谁离开了
127.                                                 clientList.remove(socket);//删除socket
128.                                                 funList(clientList);//广播在线列表
129.                                                
130.                                         }
131.                                         reader=null;
132.                                         writer=null;
133.                                         socket=null;
134.                                         System.out.println("客户机离开");
135.                                         bMan.sendClientInfo();//广播在线人数
136.                                 } catch (Exception e) {}
137.                         }
138.                        
139.                 }
140.         }
141.         void funList(Map clientList) // 广播在线列表
142.         {
143.                 String strList="";//在线列表
144.                 Set set = clientList.keySet();//使用keySet方法获取所有key值
145.                 System.out.println(set);
146.                 Iterator it = set.iterator();//使用Iterator（迭代器）来遍历数据
147.                 System.out.println(it);
148.                 while (it.hasNext()) {//把用户名称发给在线所有客户端       
149.                         //构造在线列表格式strList=11--one--two--three
150.                         strList+="--";
151.                         strList+=clientList.get(it.next());
152.                 }
153.                 bMan.sendToAll("11"+strList);
154.         }
155. }
157. class BManager extends Vector
158. {
159.         BManager (){}
160.         void add(Socket sock)
161.         {
162.                 super.add(sock);
163.         }
164.         void remove(Socket sock)
165.         {
166.                 super.remove(sock);
167.         }
168.         synchronized void sendToAll(String msg)//给所有人广播函数
169.         {
170.                 PrintWriter writer=null;
171.                 Socket sock;
172.                 for(int i=0;i                {
173.                         sock=(Socket)elementAt(i);//获取第i个套接字
174.                         try
175.                         {
176.                                 //获取第i个套接字输出流
177.                                 writer=new PrintWriter(sock.getOutputStream(),true);
178.                         }catch(Exception ie){}
179.                         //使用第i各套接字输出流，输出消息
180.                         if(writer!=null)writer.println(msg);
181.                 }
182.         }
183.         synchronized void sendToONE(Socket socket,String msg)//私聊函数
184.         {
185.                 PrintWriter writer=null;
186.                 Socket sock;
187.                 for(int i=0;i                {
188.                         sock=(Socket)elementAt(i);
189.                         if(socket==sock)//与给所有人广播函数类似，仅加入了判断，只有当socket管理器中的socket等于传入的socket的时候才发送消息
190.                         {
191.                                
192.                                 try
193.                                 {
194.                                         writer=new PrintWriter(sock.getOutputStream(),true);
195.                                 }catch(Exception ie){}
196.                                 if(writer!=null)writer.println(msg);
197.                         }
198.                 }
199.                
200.         }
201.         synchronized void sendClientInfo()
202.         {
203.                 String info="44当前聊天人数："+size();
204.                 //System.out.println(info);
205.                 sendToAll(info);
206.         }
207. }

复制代码

知识点：

 

实现在线列表的思路：每当有新的用户登陆的时候就像服务器发送用户名，服务器收到用户明后就会存在clientList中，然后再提取所有的用户名广播出去。

 

实现私聊的思路，利用hashmap来储存数据，通过name找到socket，然后把消息发给找到的socket

 

关于map，首先就要说说Collection接口，它位于与数据结构有关的

API

的最上部。构成Collection的单位，我们称之为元素(element)，此接口提供了添加，删除元素等管理数据的功能，根据管理方法的不同，可将Collection接口分为Set,List,Map三种接口。

 

实现Map接口的类也有3个，分别是HashMap类，TreeMap类和Hashtable类。这些类具有如下几个特征：元素拥有固定的key值；key值不允许重复。

 

下面就说说这次说用道德HashMap类的常用方法。

 

添加一个拥有key的元素：put(Object key,Object value);

 

删除拥有key的元素:remove(Object key);

 

返回拥有key的元素:get(Object key);

 

通过get方法可以通过key查找value，那反过来呢？如何通过HashMap中的value找到key。似乎并没有现成的方法。这里提供一个思路。关于关于Iterator和Set大家可以自行查查java文档，这里就浪费论坛的空间了。

1. pritnkey(HashMap hm,String value)
2. {
3.         ArrayList a=new Array();
4.         Set key =hm.keySet();
5.         Iterator it=key.iterator();
6.         while(it.hasNext())
7.         {
8.                 Object ok=it.next();
9.                 Object ov=hm.get(ok);
10.                 if(ov.equals(value))
11.                 {
12.                         a.add(ok);
13.                 }
14.                 if(a.size()!=0)
15.                 {
16.                         System.out.println(a);
17.                 }
18.         }
19. }

复制代码

客户端：myLogin.mxml;Client5.mxml

 

没什么好讲的，知识点在前四节中已经反复的提过了，这里就不再累叙了。

 

所要注意的无非就是通过字符串操作来分割服务器传来的消息，经过判断然后进行归类。

 

所要注意的一点是，在登陆的时候要做好验证工作，确保用户列表不重名。