Chinaunix首页 | 论坛 | 博客

VibeXie

首页　| 　博文目录　| 　关于我

vibe26

  • 博客访问： 417493
  • 博文数量： 121
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1393
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-11 12:17
个人简介

www.vibexie.com vibexie@qq.com

文章分类

全部博文（121）

文章存档

2015年（55）

2014年（66）

我的朋友
最近访客
推荐博文
相关博文
Java实现C/S客户端间聊天

分类： Java

2015-03-22 15:33:08

用了一天半的时间，终于还是把客户端聊天的功能实现了，刚开始的时侯，考虑客户端处于内网和外网的因素，肯定不能用UDP通过IP地址来传送消息，
不过也可以通过UDP打洞的方式来实现穿透NAT，QQ就是用UDP打洞的方式，不过还有先进的方法保证UDP的可靠性。但是UDP打洞也是很难实现的。
经过半天的思考，还是决定用一种简单的方法实现 客户端-服务器-客户端 的通信，基于Socket,在服务端保存一张Map，map键值分别为username,socket。
再通过服务器的并发实现客户端间的通信，客户端发送的所有数据都先传到服务器，服务器再把数据解析发送到对应的接收端。

架构是这样的：
    客户端连接服务器，服务端start一个服务线程，用户输入自己的名字，发送给服务器端，服务器将username和当前连接的socket保存到一张hashmap中。
    如果已经有用户使用了该名字，服务器查询map中已经有这个用户吗，有的话通知用户重新输入用户名。
    确定username后，再选择要发送信息的好友，服务器再从map中拿出好友的socket，再把消息转发至好友的socket
    客户端接收方面，启用一个后台进程，去read自己的socket获取消息。
    更重要的是，后台线程和客户端主线程间用一个单向的管道，传送一些必要的信息。
整个架构中都没有忙等待，都是通过阻塞的方式进行数据的传递。所以在性能上是很强的。

由于只是为了实现这个功能，代码写好后就没有改过，代码还是挺粗糙的，经过测试，剩下一个Bug就是linux端和windows端进行中文通信的时候就会有乱码，这个就不去处理了。

附源码：
    SmallQQClient.zip SmallQQServer.zip
给出服务器端代码：

QQServer.java

  1. package cn.com.xiebiao.smallQQServer;

  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;

  7. /**
  8.  *
  9.  * Title : QQServer.java 
  10.  * Author : Vibe Xie @
  11.  * Time : Mar 22, 2015 3:24:07 PM
  12.  * Copyright: Copyright (c) 2015
  13.  * Description:
  14.  */

  16. public class QQServer {
  17.     private static ServerSocket serverSocket=null;
  18.     private static Socket socket=null;
  19.     //服务器端口
  20.     private static int SERVER_PORT=8999;
  21.     //服务次数
  22.     private static int SERVER_TIMES=1;
  23.     
  24.     public static void main(String[] args) {
  25.         // TODO Auto-generated method stub    
  26.         try {
  27.             serverSocket=new ServerSocket(SERVER_PORT);
  28.             System.out.println("QQ服务器启动...");
  29.             while(true){
  30.                 socket=serverSocket.accept();
  31.                 System.out.println("服务器第"+(SERVER_TIMES++)+"次连接");
  32.                 new Thread(new ServerThread(socket)).start();
  33.             }
  34.             
  35.         } catch (IOException e) {
  36.             // TODO Auto-generated catch block
  37.             e.printStackTrace();
  38.         }finally{
  39.             try {
  40.                 serverSocket.close();
  41.             } catch (IOException e) {
  42.                 // TODO Auto-generated catch block
  43.                 e.printStackTrace();
  44.             }
  45.         }

  47.     }
  48. }

ServerThread.java

  1. package cn.com.xiebiao.smallQQServer;

  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedReader;
  5. import java.io.BufferedWriter;
  6. import java.io.IOException;
  7. import java.io.InputStreamReader;
  8. import java.io.OutputStreamWriter;
  9. import java.net.Socket;
  10. import java.util.Iterator;
  11. import java.util.Map;
  12. import java.util.Set;

  14. /**
  15.  *
  16.  * Title : ClientThread.java 
  17.  * Author : Vibe Xie @
  18.  * Time : Mar 21, 2015 2:34:04 PM
  19.  * Copyright: Copyright (c) 2015
  20.  * Description: ClientThread接收发送端发来的消息，再把消息通过WriteThead线程发送给接收端
  21.  */
  22. public class ServerThread implements Runnable {
  23.     private Socket socket;
  24.     private boolean flag=true;
  25.     //msg的格式是 "senderreceiver"+正文
  26.     private String msg=null;
  27.     private MsgAnalyseUtil msgAnalyse;
  28.     //将msg拆解为sender,receiver,message
  29.     private String sender;
  30.     private String receiver;
  31.     private String message;
  32.     
  33.     private BufferedReader bufferedReader;
  34.     private BufferedWriter writer;
  35.     public ServerThread(Socket socket) {
  36.         // TODO Auto-generated constructor stub
  37.         this.socket=socket;
  38.     }
  39.     
  40.     @Override
  41.     public void run() {
  42.         // TODO Auto-generated method stub
  43.         try {
  44.             
  45.             /******************登录验证模块，用户名已存在，则放回fail,否则返回success************************/
  46.             bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
  47.             writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  48.             //连接成功则从socket读取用户名
  49.             sender=bufferedReader.readLine();
  50.             //用户已存在，返回登录失败信息
  51.             while(UserTable.isUserExist(sender)==true){
  52.                 writer.write("fail");
  53.                 writer.newLine();
  54.                 writer.flush();
  55.                 sender=bufferedReader.readLine();
  56.             }
  57.             
  58.             //将用户名和socket保存到用户表中
  59.             UserTable.userAdd(sender, socket);
  60.             //收到的用户名不存在，返回登录成功
  61.             writer.write("success");
  62.             writer.newLine();
  63.             writer.flush();
  64.             /******************登录验证模块*************************************************************/
  65.             
  66.             while(flag==true){
  67.                 msg=bufferedReader.readLine();
  68.                 //进行拆解
  69.                 System.out.println("服务器接收"+msg);
  70.                 msgAnalyse=new MsgAnalyseUtil(msg);
  71.                 sender=msgAnalyse.getSender();
  72.                 receiver=msgAnalyse.getReceiver();
  73.                 message=msgAnalyse.getMessage();
  74.                 
  75.                 //接收到验证好友是否在线指令
  76.                 if(sender.equals("/instruction")){
  77.                     //在UserTable表中查询好友是否在线，并重新包装消息，返回给请求者
  78.                     if(UserTable.isUserExist(receiver)){
  79.                         message="y";
  80.                     }else {
  81.                         message="n";
  82.                     }
  83.                     //包装消息
  84.                     msg=sender+""+"tmp"+message;
  85.                     writer.write(msg);
  86.                     writer.newLine();
  87.                     writer.flush();
  88.                 }else{
  89.                     //未接收到指令，进行消息转发
  90.                     //服务器输出消息
  91.                     System.out.println("解析为 发送者:"+sender+" 接收者:"+receiver+" 信息:"+message);
  92.                     
  93.                     if(message.equals("bye")){
  94.                         System.out.println("用户退出");
  95.                         
  96.                         //退出是通知客户端后台线程结束
  97.                         msg="/instruction"+""+"tmp"+"bye";
  98.                         writer.write(msg);
  99.                         writer.newLine();
  100.                         writer.flush();
  101.                         
  102.                         //从UserTable中删除该用户
  103.                         UserTable.deleteUser(sender);
  104.                         
  105.                         //结束服务器线程
  106.                         flag=false;
  107.                     }else {
  108.                         //转发消息给接收者
  109.                         writer=new BufferedWriter(new OutputStreamWriter(UserTable.getSocket(receiver).getOutputStream()));
  110.                         writer.write(msg);
  111.                         writer.newLine();
  112.                         writer.flush();
  113.                     }
  114.                 }
  115.             }
  116.         } catch (Exception e) {
  117.             // TODO: handle exception
  118.             e.printStackTrace();
  119.         }
  120.         
  121.     }
  122. }

UserTable.java

  1. package cn.com.xiebiao.smallQQServer;

  3. import java.net.Socket;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. /**
  7.  *
  8.  * Title : UserTable.java 
  9.  * Author : Vibe Xie @
  10.  * Time : Mar 22, 2015 3:25:35 PM
  11.  * Copyright: Copyright (c) 2015
  12.  * Description:
  13.  */
  14. class UserTable{
  15.     private static Map<String, Socket> userTable=new HashMap<String, Socket>();
  16.     
  17.     public static void userAdd(String user,Socket socket){
  18.         userTable.put(user,socket);
  19.     }
  20.     
  21.     public static void deleteUser(String user){
  22.         for(Map.Entry<String,Socket> entry:UserTable.returnUserTable().entrySet()){
  23.             if(entry.getKey().equals(user)){
  24.                 userTable.remove(entry.getKey());
  25.             }
  26.         }
  27.     }
  28.     
  29.     public static boolean isUserExist(String user){
  30.         boolean flag=false;
  31.         for(Map.Entry<String,Socket> entry:UserTable.returnUserTable().entrySet()){
  32.             if(entry.getKey().equals(user)){
  33.                 flag=true;
  34.                 return flag;
  35.             }
  36.         }
  37.         return flag;
  38.     }
  39.     public static Map<String , Socket> returnUserTable(){
  40.         return userTable;
  41.     }
  42.     public static Socket getSocket(String user){
  43.         return userTable.get(user);
  44.     }

  46. }


MsgAnalyseUtil.java

  1. package cn.com.xiebiao.smallQQServer;

  3. import java.util.regex.Pattern;
  4. /**
  5.  *
  6.  * Title : MsgAnalyseUtil.java 
  7.  * Author : Vibe Xie @
  8.  * Time : Mar 21, 2015 3:35:16 PM
  9.  * Copyright: Copyright (c) 2015
  10.  * Description:分析message的工具类
  11.  */
  12. public class MsgAnalyseUtil {
  13.     private String msg;
  14.     private String sender;
  15.     private String receiver;
  16.     private String message;
  17.     String[] tmp=new String[3];
  18.     
  19.     public MsgAnalyseUtil(String msg){
  20.         this.msg=msg;
  21.         tmp=Pattern.compile("").split(msg,3);
  22.         sender=tmp[0];
  23.         receiver=tmp[1];
  24.         message=tmp[2];
  25.     }
  26.     
  27.     public String getSender() {
  28.         return sender;
  29.     }
  30.     
  31.     public String getReceiver() {
  32.         return receiver;
  33.     }
  34.     
  35.     public String getMessage() {
  36.         return message;
  37.     }
  38. }

客户端代码：

QQClient.java

  1. package cn.com.xiebiao.smallQQClient;

  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.io.OutputStreamWriter;
  8. import java.io.PipedReader;
  9. import java.net.Socket;
  10. /**
  11.  *
  12.  * Title : QQClient.java 
  13.  * Author : Vibe Xie @
  14.  * Time : Mar 22, 2015 3:27:29 PM
  15.  * Copyright: Copyright (c) 2015
  16.  * Description:
  17.  */
  18. public class QQClient {
  19.     //服务器域名
  20.     private static String DOMAIN="localhost";
  21.     //服务器端口
  22.     private static int SERVER_PORT=8999;
  23.     //socket
  24.     private static Socket socket;
  25.     //发送者
  26.     private static String sender;
  27.     //接收者
  28.     private static String recerver;
  29.     //消息
  30.     private static String msg;
  31.     //用户是否想退出
  32.     private static String isLoginOut="n";
  33.     //接收后台返回好友是否存在指令的管道
  34.     private static PipedReader pipedReader;
  35.     //好友是否在线
  36.     private static boolean isFriendOnline=false;
  37.     public static void main(String[] args) {
  38.         // TODO Auto-generated method stub
  39.         try{
  40.             socket=new Socket(DOMAIN,SERVER_PORT);
  41.             
  42.             BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  43.             BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  44.             //reader仅仅为了用户验证，不用作后台接收消息
  45.             BufferedReader reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
  46.             boolean flag=true;
  47.             
  48.             System.out.printf("/********************************************\n"
  49.                             + "/*************SmallQQ version1.0*************\n"
  50.                             + "/*************@Author VibeXie *************\n"
  51.                             + "/*************@Email vibexie@qq.com**********\n"
  52.                             + "/********************************************\n");
  53.             /******************登录验证模块，用户名已存在，则放回fail,否则返回success************************/
  54.             //开启客户端，发送用户名
  55.             System.out.print("请输入用户名(临时):");
  56.             sender=msg=in.readLine();
  57.             writer.write(msg);
  58.             writer.newLine();
  59.             writer.flush();
  60.             while(reader.readLine().equals("fail")){
  61.                 System.out.print("用户已存在，请输入用户名(临时):");
  62.                 sender=msg=in.readLine();
  63.                 writer.write(msg);
  64.                 writer.newLine();
  65.                 writer.flush();
  66.             }
  67.             System.out.println("登录成功,您的用户名为:"+sender);
  68.             
  69.             //启动接收消息线程
  70.             new Thread(new ClientThread(socket)).start();
  71.             //连接管道
  72.             pipedReader=new PipedReader(ClientThread.getPipedWriter());
  73.             /******************登录验证模块*************************************************************/
  74.             
  75.             /******************聊天模块************************/
  76.             
  77.             while(isLoginOut.equals("n")){
  78.                 
  79.                 /************************好友在线验证，在线则开始聊天，否则重新输入好友*****************************************/
  80.                 while(isFriendOnline==false){
  81.                     System.out.print("请输入好友:");
  82.                     recerver=in.readLine();
  83.                     //规范判断好友在线指令格式
  84.                     String instruction="/instruction"+recerver+"tmp";
  85.                     //发送指令
  86.                     writer.write(instruction);
  87.                     writer.newLine();
  88.                     writer.flush();
  89.                     //通过管道接收后台线程的返回值
  90.                     char[] charReader=new char[1];
  91.                     pipedReader.read(charReader,0,1);
  92.                     
  93.                     msg=new String(charReader);
  94.                     //分解消息
  95.                     if(msg.equals("n")){
  96.                         isFriendOnline=false;
  97.                         System.out.println("Sorry,好友"+recerver+"现在不在线，请重新输入好友...");
  98.                     }else {
  99.                         isFriendOnline=true;
  100.                     }
  101.                 }
  102.                 
  103.                 System.out.println("与"+recerver+"连接成功，开始聊天!");
  104.                 /************************好友在线验证，在线则开始聊天，否则重新输入好友*****************************************/
  105.     
  106.                 while(flag){
  107.                     
  108.                     System.out.print("向"+recerver+"发送消息:");
  109.                     msg=in.readLine();
  110.                     
  111.                     if(msg.equalsIgnoreCase("bye") || msg==null){
  112.                         //规范消息格式
  113.                         msg=sender+""+recerver+""+msg;
  114.                         writer.write(msg);
  115.                         writer.newLine();
  116.                         writer.flush();
  117.                         
  118.                         //判断是否退出
  119.                         System.out.print("结束与"+sender+"的聊天?(y/n):");
  120.                         isLoginOut=in.readLine();
  121.                         while(isLoginOut.equals("n")==false && isLoginOut.equals("y")==false){
  122.                             System.out.printf("您的输入错误，请重新输入\n结束与"+sender+"的聊天?(y/n):");
  123.                             isLoginOut=in.readLine();
  124.                         }
  125.                         if(isLoginOut.equals("n")){
  126.                             flag=true;
  127.                         }else {
  128.                             System.out.println("已退出！！！");
  129.                             flag=false;
  130.                         }
  131.                         
  132.                     }else {
  133.                         //规范消息格式
  134.                         msg=sender+""+recerver+""+msg;
  135.                         
  136.                         writer.write(msg);
  137.                         writer.newLine();
  138.                         writer.flush();
  139.                     }
  140.                 }
  141.             }
  142.             /******************聊天模块************************/
  143.         }catch(Exception ex){
  144.             ex.printStackTrace();
  145.         }finally{
  146.             try {
  147.                 socket.close();
  148.                 pipedReader.close();
  149.             } catch (IOException e) {
  150.                 // TODO Auto-generated catch block
  151.                 e.printStackTrace();
  152.             }
  153.         }
  154.     }
  155. }

ClientThread.java

  1. package cn.com.xiebiao.smallQQClient;

  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PipedWriter;
  7. import java.net.Socket;

  9. /**
  10.  *
  11.  * Title : ClientThread.java 
  12.  * Author : Vibe Xie @
  13.  * Time : Mar 22, 2015 3:28:08 PM
  14.  * Copyright: Copyright (c) 2015
  15.  * Description:
  16.  */
  17. public class ClientThread implements Runnable{
  18.     private Socket socket;
  19.     private static String sender;
  20.     private static String msg;
  21.     private static String message;
  22.     private static boolean running=true;
  23.     //通往QQClient的管道
  24.     private static PipedWriter pipedWriter=new PipedWriter();
  25.     public static PipedWriter getPipedWriter() {
  26.         return pipedWriter;
  27.     }
  28.     
  29.     public ClientThread(Socket socket) {
  30.         // TODO Auto-generated constructor stub
  31.         this.socket=socket;
  32.     }
  33.     
  34.     @Override
  35.     public void run() {
  36.         // TODO Auto-generated method stub
  37.         try {
  38.             BufferedReader reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
  39.             while(running){
  40.                 msg=reader.readLine();
  41.                 MsgAnalyseUtil msgAnalyseUtil=new MsgAnalyseUtil(msg);
  42.                 sender=msgAnalyseUtil.getSender();
  43.                 message=msgAnalyseUtil.getMessage();
  44.                 
  45.                 //得到回复用户是否在线的指令，通过管道回写给QQClient
  46.                 if(sender.equals("/instruction")){
  47.                     if(message.equals("bye")){
  48.                         running=false;
  49.                     }else {
  50.                         pipedWriter.write(message);
  51.                     }
  52.                 }else {
  53.                     System.out.printf("\n来自"+sender+"的信息:"+message+"\n");
  54.                 }
  55.             }
  56.         } catch (IOException e) {
  57.             // TODO Auto-generated catch block
  58.             e.printStackTrace();
  59.         }

  61.     }
  62. }
另外客户端还有一个文件MsgAnalyseUtil.java是服务器端是一样的。



阅读(2040) | 评论(0) | 转发(0) |
0

上一篇：Andriod Camra的简单使用

下一篇：Servlet中使用json的一些问题

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6