四、
Message.java
         定义的字符串消息。 
 
    
     
         
  1. public class Message { 
    2.  
         
  2.   
    3.  
         
  3.     static class MessageHolder { 
    4.  
         
  4.        static Message instance = new Message(); 
    5.  
         
  5.     } 
    6.  
         
  6.   
    7.  
         
  7.     public static Message getInstance() { 
    8.  
         
  8.        return MessageHolder.instance; 
    9.  
         
  9.     } 
    10.  
         
  10.   
    11.  
         
  11.     public static final String SEPARATOR = "`"; 
    12.  
         
  12.   
    13.  
         
  13.     /** 客户端登录服务器的消息类型，用以通知登录名等 */ 
    14.  
         
  14.     public static final int MSG_1 = 1; // 1`msg 
    15.  
         
  15.     /** 服务器通知各客户端新登录者信息的消息类型 */ 
    16.  
         
  16.     public static final int MSG_2 = 2; // 2`msg`fromIp 
    17.  
         
  17.     /** 服务器回复新登录者所有在线客户端信息的消息类型 */ 
    18.  
         
  18.     public static final int MSG_3 = 3; // 3`ip`msg`ip`msg`... 
    19.  
         
  19.     /** 客户端发送所有人信息的消息类型（或服务器发送消息） */ 
    20.  
         
  20.     public static final int MSG_4 = 4; // 4`msg 
    21.  
         
  21.     /** 客户端发送指定人信息的消息类型 */ 
    22.  
         
  22.     public static final int MSG_5 = 5; // 5`msg`toIp`toIp`... 
    23.  
         
  23.     /** 服务器转发发送者信息的消息类型 */ 
    24.  
         
  24.     public static final int MSG_6 = 6; // 6`msg`fromIp 
    25.  
         
  25.     /** 客户端通知服务器退出的消息类型 */ 
    26.  
         
  26.     public static final int MSG_7 = 7; // 7 
    27.  
         
  27.     /** 服务器通知各客户端退出者信息的消息类型 */ 
    28.  
         
  28.     public static final int MSG_8 = 8; // 8`fromIp 
    29.  
         
  29.   
    30.  
         
  30.     // 构造和解析方式详细参见附件工程了 
    31.  
         
  31.   
    32.  
         
  32. } 
    33.  
        
 
    
        
    
 
    
 
     五、 
     ChatServerTest.java 
    
 
    
               服务器消息处理实现。 
    
 
    
 
     
 
    
 
    
 
    
     
         
  1. public class ChatServerTest implements Observer, Runnable { 
    2.  
         
  2.   
    3.  
         
  3.     private static final String BLANK = " "; 
    4.  
         
  4.   
    5.  
         
  5.     /** 在线客户端信息 */ 
    6.  
         
  6.     private HashMap<InetSocketAddress, String> onLineMap; 
    7.  
         
  7.   
    8.  
         
  8.     private ChatServer server; 
    9.  
         
  9.   
    10.  
         
  10.     public ChatServerTest() { 
    11.  
         
  11.        server = new ChatServer(8899); 
    12.  
         
  12.        server.addObserver(this); 
    13.  
         
  13.        server.start(); 
    14.  
         
  14.        new Thread(this).start(); 
    15.  
         
  15.     } 
    16.  
         
  16.   
    17.  
         
  17.     @Override 
    18.  
         
  18.     public void update(Observable o, Object arg) { 
    19.  
         
  19.        ChatServer server = (ChatServer) o; 
    20.  
         
  20.        switch (server.getStatus()) { 
    21.  
         
  21.        case ChatServer.SEV_ON: 
    22.  
         
  22.            System.out.println("服务器开启了"); 
    23.  
         
  23.            onLineMap = new HashMap<InetSocketAddress, String>(); 
    24.  
         
  24.            break; 
    25.  
         
  25.        case ChatServer.SEV_OFF: 
    26.  
         
  26.            System.out.println("服务器关闭了"); 
    27.  
         
  27.            onLineMap = null; 
    28.  
         
  28.            break; 
    29.  
         
  29.        case ChatServer.CLT_CONNECT: 
    30.  
         
  30.            // InetSocketAddress address = (InetSocketAddress) arg; 
    31.  
         
  31.  
    32.  
         
  32.            break; 
    33.  
         
  33.        case ChatServer.CLT_DISCONNECT: 
    34.  
         
  34.            quit((InetSocketAddress) arg); 
    35.  
         
  35.            break; 
    36.  
         
  36.        case ChatServer.MSG_SEND: 
    37.  
         
  37.            // System.out.println("通知：" 
    38.  
         
  38.  
    39.  
         
  39.            // + ((String) arg).split(Message.SEPARATOR)[1]); 
    40.  
         
  40.            break; 
    41.  
         
  41.        case ChatServer.MSG_RECEIVE: 
    42.  
         
  42.            Message msg = Message.getInstance(); 
    43.  
         
  43.            msg.create(server.getReceiveMessage()); 
    44.  
         
  44.            msg.setFromIp((InetSocketAddress) arg); 
    45.  
         
  45.            handleMsg(msg); // 处理消息 
    46.  
         
  46.            break; 
    47.  
         
  47.        case ChatServer.ERROR: 
    48.  
         
  48.            System.out.println("error : " + ((Exception) arg).getMessage()); 
    49.  
         
  49.  
    50.  
         
  50.            break; 
    51.  
         
  51.        } 
    52.  
         
  52.     } 
    53.  
         
  53.   
    54.  
         
  54.     private void handleMsg(Message msg) { 
    55.  
         
  55.        int type = msg.getType(); 
    56.  
         
  56.        InetSocketAddress formIp = msg.getFromIp(); 
    57.  
         
  57.        switch (type) { 
    58.  
         
  58.        case Message.MSG_1: 
    59.  
         
  59.            System.out.println(msg.getMsg() + BLANK + msg.toIpString(formIp) 
    60.  
         
  60.                   + BLANK + "登录了"); 
    61.  
         
  61.            onLineMap.put(formIp, msg.getMsg()); 
    62.  
         
  62.            /* 通知所有客户端新登录者信息 */ 
    63.  
         
  63.            msg.setType(Message.MSG_2); 
    64.  
         
  64.            // msg.setFromIp(address); 
    65.  
         
  65.  
    66.  
         
  66.            server.send(msg.toString()); 
    67.  
         
  67.            /* 返回登录客户端所有在线客户端信息（会覆盖前一个发送给address的信息） */ 
    68.  
         
  68.            msg.setType(Message.MSG_3); 
    69.  
         
  69.            msg.setOnLineMap(onLineMap); 
    70.  
         
  70.            server.send(msg.toString(), formIp); 
    71.  
         
  71.            break; 
    72.  
         
  72.        case Message.MSG_4: 
    73.  
         
  73.            System.out.println(onLineMap.get(msg.getFromIp()) + BLANK + "said" 
    74.  
         
  74.                   + BLANK + msg.getMsg()); 
    75.  
         
  75.            msg.setType(Message.MSG_6); 
    76.  
         
  76.            server.send(msg.toString()); 
    77.  
         
  77.            break; 
    78.  
         
  78.        case Message.MSG_7: 
    79.  
         
  79.            quit(formIp); 
    80.  
         
  80.            break; 
    81.  
         
  81.        } 
    82.  
         
  82.     } 
    83.  
         
  83.   
    84.  
         
  84.     private void quit(InetSocketAddress address) { 
    85.  
         
  85.        if (onLineMap.get(address) != null) { 
    86.  
         
  86.            System.out 
    87.  
         
  87.                   .println(onLineMap.get(address) + BLANK 
    88.  
         
  88.                          + Message.getInstance().toIpString(address) + BLANK 
    89.  
         
  89.  
    90.  
         
  90.                          + "退出了"); 
    91.  
         
  91.            onLineMap.remove(address); 
    92.  
         
  92.            Message msg = Message.getInstance(); 
    93.  
         
  93.            msg.setType(Message.MSG_8); 
    94.  
         
  94.            msg.setFromIp(address); 
    95.  
         
  95.            server.send(msg.toString()); 
    96.  
         
  96.        } 
    97.  
         
  97.     } 
    98.  
         
  98.   
    99.  
         
  99.     @Override 
    100.  
         
  100.     public void run() { 
    101.  
         
  101.        BufferedReader br = null; 
    102.  
         
  102.        try { 
    103.  
         
  103.            br = new BufferedReader(new InputStreamReader(System.in)); 
    104.  
         
  104.            while (true) { 
    105.  
         
  105.               String inputLine = br.readLine(); 
    106.  
         
  106.               if (inputLine.trim().toLowerCase().equals("off")) { 
    107.  
         
  107.                   server.close(); 
    108.  
         
  108.                   break; 
    109.  
         
  109.               } else { 
    110.  
         
  110.                   // 键盘输入为GBK编码，需要转成UTF-8才可显示。或者变为GBK工程。 
    111.  
         
  111.                   // 这么转码仍是有问题的。例如奇数汉字“大家好”时，显示为“大家�?”。可以看下如下网址： 
    112.  
         
  112.                   // http://www.blogjava.net/pengpenglin/archive/2010/02/22/313669.html 
    113.  
         
  113.  
    114.  
         
  114.                   inputLine = new String(inputLine.getBytes("gbk"), "utf-8"); 
    115.  
         
  115.                   server.send(Message.MSG_4 + Message.SEPARATOR + inputLine); 
    116.  
         
  116.                   System.out.println("通知：" + inputLine); 
    117.  
         
  117.               } 
    118.  
         
  118.            } 
    119.  
         
  119.         } catch (IOException e) { 
    120.  
         
  120.            e.printStackTrace(); 
    121.  
         
  121.        } finally { 
    122.  
         
  122.            try { 
    123.  
         
  123.               if (br != null) { 
    124.  
         
  124.                   br.close(); 
    125.  
         
  125.               } 
    126.  
         
  126.            } catch (IOException e) { 
    127.  
         
  127.               e.printStackTrace(); 
    128.  
         
  128.            } 
    129.  
         
  129.        } 
    130.  
         
  130.     } 
    131.  
         
  131.   
    132.  
         
  132.     public static void main(String[] args) { 
    133.  
         
  133.        new ChatServerTest(); 
    134.  
         
  134.     } 
    135.  
         
  135.   
    136.  
         
  136. } 
    137.  
        
 
    
        
    
 
    
 
     六、 
     ChatClientTest.java 
    
 
    
               客户端消息处理实现。 
    
 
    
 
     
 
    
 
    
 
    
     
         
  1. public class ChatClientTest implements Observer, Runnable { 
    2.  
         
  2.   
    3.  
         
  3.     private static final String BLANK = " "; 
    4.  
         
  4.   
    5.  
         
  5.     /** 在线客户端信息 */ 
    6.  
         
  6.     private HashMap<InetSocketAddress, String> onLineMap; 
    7.  
         
  7.   
    8.  
         
  8.     private String name; 
    9.  
         
  9.     private ChatClient client; 
    10.  
         
  10.   
    11.  
         
  11.     public ChatClientTest(String name) { 
    12.  
         
  12.        this.onLineMap = new HashMap<InetSocketAddress, String>(); 
    13.  
         
  13.        this.name = name; 
    14.  
         
  14.        client = new ChatClient("192.168.1.107", 8899); 
    15.  
         
  15.        // client = new ChatClient("127.0.0.1", 8899); 
    16.  
         
  16.  
    17.  
         
  17.        client.addObserver(this); 
    18.  
         
  18.         client.start(); 
    19.  
         
  19.        new Thread(this).start(); 
    20.  
         
  20.     } 
    21.  
         
  21.   
    22.  
         
  22.     @Override 
    23.  
         
  23.     public void update(Observable o, Object arg) { 
    24.  
         
  24.        ChatClient client = (ChatClient) o; 
    25.  
         
  25.        switch (client.getStatus()) { 
    26.  
         
  26.        case ChatClient.CLT_CONNECT: 
    27.  
         
  27.            // 发送登录消息 
    28.  
         
  28.            Message msg1 = Message.getInstance(); 
    29.  
         
  29.            msg1.setType(Message.MSG_1); 
    30.  
         
  30.            msg1.setMsg(name); 
    31.  
         
  31.            client.send(msg1.toString()); 
    32.  
         
  32.            break; 
    33.  
         
  33.        case ChatClient.CLT_DISCONNECT: 
    34.  
         
  34.            System.out.println("断开服务器连接"); 
    35.  
         
  35.            System.exit(1); 
    36.  
         
  36.            break; 
    37.  
         
  37.        case ChatClient.MSG_SEND: 
    38.  
         
  38.            break; 
    39.  
         
  39.        case ChatClient.MSG_RECEIVE: 
    40.  
         
  40.            Message msg = Message.getInstance(); 
    41.  
         
  41.            msg.create((String) arg); 
    42.  
         
  42.            handleMsg(msg); // 处理消息 
    43.  
         
  43.            break; 
    44.  
         
  44.        case ChatClient.ERROR: 
    45.  
         
  45.            System.out.println("error : " + ((Exception) arg).getMessage()); 
    46.  
         
  46.  
    47.  
         
  47.            break; 
    48.  
         
  48.        } 
    49.  
         
  49.     } 
    50.  
         
  50.   
    51.  
         
  51.     private void handleMsg(Message msg) { 
    52.  
         
  52.        int type = msg.getType(); 
    53.  
         
  53.        switch (type) { 
    54.  
         
  54.        case Message.MSG_2: 
    55.  
         
  55.            System.out.println(msg.getMsg() + BLANK 
    56.  
         
  56.                   + msg.toIpString(msg.getFromIp()) + BLANK + "登录了"); 
    57.  
         
  57.            onLineMap.put(msg.getFromIp(), msg.getMsg()); 
    58.  
         
  58.            break; 
    59.  
         
  59.        case Message.MSG_3: 
    60.  
         
  60.            onLineMap = msg.getOnLineMap(); 
    61.  
         
  61.            System.out.println("连接上了服务器"); 
    62.  
         
  62.            System.out.println("/***在线成员***/"); 
    63.  
         
  63.            Iterator<Entry<InetSocketAddress, String>> it = onLineMap 
    64.  
         
  64.  
    65.  
         
  65.                   .entrySet().iterator(); 
    66.  
         
  66.            while (it.hasNext()) { 
    67.  
         
  67.               Entry<InetSocketAddress, String> entry = it.next(); 
    68.  
         
  68.  
    69.  
         
  69.               InetSocketAddress address = entry.getKey(); 
    70.  
         
  70.               System.out.println(entry.getValue() + BLANK 
    71.  
         
  71.                      + address.getAddress().getHostAddress() + ":" 
    72.  
         
  72.                      + address.getPort()); 
    73.  
         
  73.            } 
    74.  
         
  74.            System.out.println("/***在线成员***/"); 
    75.  
         
  75.            break; 
    76.  
         
  76.        case Message.MSG_4: 
    77.  
         
  77.            System.out.println("通知：" + msg.getMsg()); 
    78.  
         
  78.            break; 
    79.  
         
  79.        case Message.MSG_6: 
    80.  
         
  80.            System.out.println(onLineMap.get(msg.getFromIp()) + BLANK + "said" 
    81.  
         
  81.                   + BLANK + msg.getMsg()); 
    82.  
         
  82.            break; 
    83.  
         
  83.        case Message.MSG_8: 
    84.  
         
  84.            InetSocketAddress address = msg.getFromIp(); 
    85.  
         
  85.            System.out 
    86.  
         
  86.                   .println(onLineMap.get(address) + BLANK 
    87.  
         
  87.                          + Message.getInstance().toIpString(address) + BLANK 
    88.  
         
  88.  
    89.  
         
  89.                          + "退出了"); 
    90.  
         
  90.            onLineMap.remove(address); 
    91.  
         
  91.            break; 
    92.  
         
  92.        } 
    93.  
         
  93.     } 
    94.  
         
  94.   
    95.  
         
  95.     @Override 
    96.  
         
  96.     public void run() { 
    97.  
         
  97.        BufferedReader br = null; 
    98.  
         
  98.        try { 
    99.  
         
  99.            br = new BufferedReader(new InputStreamReader(System.in)); 
    100.  
         
  100.            while (true) { 
    101.  
         
  101.               String inputLine = br.readLine(); 
    102.  
         
  102.               if (inputLine.trim().toLowerCase().equals("quit")) { 
    103.  
         
  103.                   client.send(Message.MSG_7 + ""); 
    104.  
         
  104.                   client.close(); 
    105.  
         
  105.                   break; 
    106.  
         
  106.               } else { 
    107.  
         
  107.                   // 参见ChatServerTest注释 
    108.  
         
  108.                   inputLine = new String(inputLine.getBytes("gbk"), "utf-8"); 
    109.  
         
  109.                   client.send(Message.MSG_4 + Message.SEPARATOR + inputLine); 
    110.  
         
  110.               } 
    111.  
         
  111.            } 
    112.  
         
  112.        } catch (IOException e) { 
    113.  
         
  113.            e.printStackTrace(); 
    114.  
         
  114.        } finally { 
    115.  
         
  115.            try { 
    116.  
         
  116.               if (br != null) { 
    117.  
         
  117.                   br.close(); 
    118.  
         
  118.               } 
    119.  
         
  119.            } catch (IOException e) { 
    120.  
         
  120.               e.printStackTrace(); 
    121.  
         
  121.            } 
    122.  
         
  122.        } 
    123.  
         
  123.     } 
    124.  
         
  124.   
    125.  
         
  125.     public static void main(String[] args) { 
    126.  
         
  126.        new ChatClientTest("用户" + new Random().nextInt(100)); 
    127.  
         
  127.     } 
    128.  
         
  128.   
    129.  
         
  129. } 
    130.  
        
 
    
        
    
 
    
 
     七、其他 
    
 
    
               客户端记录用的Map，消息就简单定义的字符串，指定某些IP发送消息没写。总之不影响主要功能的，能偷懒的都尽可能偷懒了==。 
    
 
    
        
    
 
    
               至于服务器设计上的，挺麻烦。一些开源框架，恩，IBM developerWorks里的一些文章都可以学习借鉴。