devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android实现基于TCP和UDP协议的即时通讯,含android端和服务器端_手机支持tcp加速吗

作者：酷酷是懒虫 | 2024-07-03 00:03:38

赞

踩

手机支持tcp加速吗
这几天学习了下在android中实现即时通讯的方法,一开始,自然是从基本的网络协议中开始尝试了,这样能够最大化的私人订制自己的应用,还能学习到更多的知识,好处多多,接下来就简单介绍下两种协议的不同点吧

TCP协议: 提供IP环境下的数据 可靠传输 ，它提供的服务包括 数据流 传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的 数据包 发送。就如给悬崖上的两人通信时,他必须先把桥建好,确认桥是没问题的情况下,才把信件交过去,以后大家每次通信时,都确认下桥没什么问题,再通过这座桥来回通信了。

UDP协议: 不为IP提供可靠性、流控或差错恢复功能, 在正式通信前不必与对方先建立连接，不管对方状态就直接发送。这个就是飞鸽传书了~

虽然UDP可靠性不如TCP协议,但是 通信效率高于TCP。在网速极差的情况下优先考虑UDP协议,网速好的话TCP还是很方便使用的。

在Java中使用TCP可以通过java.net.Socket;这个类

<span style="font-family:Microsoft YaHei;font-size:18px;">建立连接</span>
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">//实例化一个Socket对象
  2. socket = new Socket();
  3. //与对应的ip、端口进行连接,先要把桥建好
  4. socket.connect(new InetSocketAddress(ip, port), 3000);</span>
<span style="font-family:Microsoft YaHei;font-size:18px;">发送信息</span>
</pre><pre name="code" class="java"><span style="font-family:Microsoft YaHei;font-size:18px;">InputStream ois = socket.getInputStream();
DataInputStream dis = new DataInputStream(new BufferedInputStream(ois));
//读取服务器发过来的信息,如果没信息将会阻塞线程
msg =  dis.readUTF();</span>
<span style="font-family:Microsoft YaHei;font-size:18px;">发送信息</span>
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">//获得输出流
  2. DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
  3. //发送数据
  4. dos.writeUTF(msg);</span>

接下来上源码,为三个Thread的子类,分别对应上面三个

  1. <span style="font-family:Microsoft YaHei;font-size:18px;">public class SocketThread extends Thread{
  2.  
  3.   private Socket socket;
  4.   private Client client;
  5.   private String ip;
  6.   private int port;
  7.   private boolean isStart=false;
  8.   private MessageListener mMessageListener;
  9.   
  10.   /**
  11.    * 
  12.    * 使用TCP协议,连接访问
  13.    * @param ip 目标机器的IP
  14.    * @param port 端口
  15.    * @param mMessageListener 收到服务器端数据时将回调该接口内的
  16.    *  public void Message(String msg)方法
  17.    */
  18.   public SocketThread(String ip, int port,
  19.       MessageListener mMessageListener) {
  20.     this.ip = ip;
  21.     this.port = port;
  22.     this.mMessageListener = mMessageListener;
  23.   }
  24.  
  25.   public void run() {
  26.     try {
  27.       //实例化一个Socket对象
  28.       socket = new Socket();
  29.       //与对应的ip、端口进行连接,先要把桥建好
  30.       socket.connect(new InetSocketAddress(ip, port), 3000);
  31.       if (socket.isConnected()) {
  32.         System.out.println("Connected..");
  33.         client = new Client(socket,mMessageListener);
  34.         //打开对应的输入/输出流监听
  35.         client.start();
  36.         isStart=true;
  37.       }
  38.     } catch (IOException e) {
  39.       e.printStackTrace();
  40.       isStart=false;
  41.     }
  42.   }
  43.  
  44.   // 直接通过client得到读线程
  45.   public ClientInputThread getClientInputThread() {
  46.     return client.getIn();
  47.   }
  48.  
  49.   // 直接通过client得到写线程
  50.   public ClientOutputThread getClientOutputThread() {
  51.     return client.getOut();
  52.   }
  53.  
  54.   //返回Socket状态
  55.   public boolean isStart(){
  56.     return isStart;
  57.   }
  58.   
  59.   // 直接通过client停止读写消息
  60.   public void setIsStart(boolean isStart) {
  61.     this.isStart = isStart;
  62.     client.getIn().setStart(isStart);
  63.     client.getOut().setStart(isStart);
  64.   }
  65.   
  66.   //发送消息
  67.   public void sendMsg(String msg){
  68.     client.getOut().sendMsg(msg);
  69.   }
  70.   
  71.   public class Client {
  72.  
  73.     private ClientInputThread in;
  74.     private ClientOutputThread out;
  75.  
  76.     public Client(Socket socket,MessageListener mMessageListener) {
  77.       //用这个监听输入流线程来接收信息
  78.       in = new ClientInputThread(socket);
  79.       in.setMessageListener(mMessageListener);
  80.       //以后就用这个监听输出流的线程来发送信息了
  81.       out = new ClientOutputThread(socket);
  82.     }
  83.  
  84.     public void start() {
  85.       in.setStart(true);
  86.       out.setStart(true);
  87.       in.start();
  88.       out.start();
  89.     }
  90.  
  91.     // 得到读消息线程
  92.     public ClientInputThread getIn() {
  93.       return in;
  94.     }
  95.  
  96.     // 得到写消息线程
  97.     public ClientOutputThread getOut() {
  98.       return out;
  99.     }
  100.   }
  101. }</span>
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">public class ClientInputThread extends Thread {
  2.   private Socket socket;
  3.   private String msg;
  4.   private boolean isStart = true;
  5.   private InputStream ois;
  6.   private DataInputStream dis;
  7.   private MessageListener messageListener;// 消息监听接口对象
  8.  
  9.   public ClientInputThread(Socket socket) {
  10.     this.socket = socket;
  11.     try {
  12.       ois = socket.getInputStream();
  13.       dis = new DataInputStream(new BufferedInputStream(ois));
  14.     } catch (IOException e) {
  15.       e.printStackTrace();
  16.     }
  17.   }
  18.  
  19.   /**
  20.    * 提供给外部的消息监听方法
  21.    * 
  22.    * @param messageListener
  23.    *            消息监听接口对象
  24.    */
  25.   public void setMessageListener(MessageListener messageListener) {
  26.     this.messageListener = messageListener;
  27.   }
  28.  
  29.   public void setStart(boolean isStart) {
  30.     this.isStart = isStart;
  31.   }
  32.  
  33.   @Override
  34.   public void run() {
  35.     try {
  36.       while (isStart) {
  37.         //读取信息,如果没信息将会阻塞线程
  38.         msg =  dis.readUTF();
  39.         // 每收到一条消息，就调用接口的方法Message(String msg)
  40.         Log.v("收到消息", msg);
  41.         messageListener.Message(msg);
  42.       }
  43.       ois.close();
  44.       if (socket != null)
  45.         socket.close();
  46.     } catch (IOException e) {
  47.       e.printStackTrace();
  48.     }
  49.   }
  50.   
  51.   BufferedReader reader=null;
  52.   public String getInputStreamString() {
  53.     /*
  54.      * To convert the InputStream to String we use the
  55.      * BufferedReader.readLine() method. We iterate until the BufferedReader
  56.      * return null which means there's no more data to read. Each line will
  57.      * appended to a StringBuilder and returned as String.
  58.      */
  59.     if (ois != null) {
  60.       reader = new BufferedReader(new InputStreamReader(ois));
  61.     }
  62.     StringBuilder sb = new StringBuilder();
  63.  
  64.     String line = null;
  65.     try {
  66.       while ((line = reader.readLine()) != null) {
  67.         sb.append(line + "\n");
  68.       }
  69.     } catch (IOException e) {
  70.       e.printStackTrace();
  71.     } 
  72.  
  73.     return sb.toString();
  74.   }
  75. }</span>
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">public class ClientOutputThread extends Thread {
  2.   private Socket socket;
  3.   private DataOutputStream dos;
  4.   private boolean isStart = true;
  5.   private String msg;
  6.  
  7.   public ClientOutputThread(Socket socket) {
  8.     this.socket = socket;
  9.     try {
  10.       dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
  11.     } catch (IOException e) {
  12.       e.printStackTrace();
  13.     }
  14.   }
  15.  
  16.   public void setStart(boolean isStart) {
  17.     this.isStart = isStart;
  18.   }
  19.  
  20.   // 这里处理跟服务器是一样的
  21.   public void sendMsg(String msg) {
  22.     this.msg = msg;
  23.     synchronized (this) {
  24.       notifyAll();
  25.     }
  26.   }
  27.  
  28.   @Override
  29.   public void run() {
  30.     try {
  31.       while (isStart) {
  32.         if (msg != null) {
  33.           dos.writeUTF(msg);
  34.           dos.flush();
  35.           msg=null;
  36.           synchronized (this) {
  37.             wait();// 发送完消息后，线程进入等待状态
  38.           }
  39.         }
  40.       }
  41.       dos.close();// 循环结束后，关闭输出流和socket
  42.       if (socket != null)
  43.         socket.close();
  44.     } catch (InterruptedException e) {
  45.       e.printStackTrace();
  46.     } catch (IOException e) {
  47.       e.printStackTrace();
  48.     }
  49.   }
  50.  
  51. }</span>
<span style="font-family:Microsoft YaHei;font-size:18px;">//定义接收到消息时的,处理消息的接口
public interface MessageListener {
  public void Message(String msg);
}</span>

主界面,感觉很丑,将就吧

<span style="font-family:Microsoft YaHei;font-size:18px;"><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:paddingBottom="@dimen/activity_vertical_margin"
  android:paddingLeft="@dimen/activity_horizontal_margin"
  android:paddingRight="@dimen/activity_horizontal_margin"
  android:paddingTop="@dimen/activity_vertical_margin"
  tools:context="com.example.chatclient.MainActivity" >


  <ScrollView
    android:id="@+id/svMessage"
    android:layout_width="fill_parent"
    android:layout_height="100dp" >

    <TextView
      android:id="@+id/tvMessage"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="消息内容:\n" />
  </ScrollView>

  <EditText
    android:id="@+id/etMessage"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:layout_below="@+id/svMessage" />

  <TextView
    android:id="@+id/tvSend"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_below="@+id/svMessage"
    android:layout_marginLeft="10dp"
    android:layout_toRightOf="@+id/etMessage"
    android:text="发送消息"
    android:textSize="25sp" />
"

</RelativeLayout></span>
MainActivity代码 
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">public class MainActivity extends Activity {
  2.  
  3.   EditText etMessage;
  4.   TextView tvSend, tvMessage;
  5.   SocketThread client;
  6.   MyHandler myHandler;
  7.  
  8.   @Override
  9.   protected void onCreate(Bundle savedInstanceState) {
  10.     super.onCreate(savedInstanceState);
  11.     setContentView(R.layout.activity_main);
  12.     setup();
  13.   }
  14.  
  15.   public void setup() {
  16.     etMessage = (EditText) findViewById(R.id.etMessage);
  17.     tvSend = (TextView) findViewById(R.id.tvSend);
  18.     tvMessage = (TextView) findViewById(R.id.tvMessage);
  19.     tvSend.setOnClickListener(onClick);
  20.     myHandler = new MyHandler();
  21.  
  22.     //初始化
  23.     client = new SocketThread("10.21.56.226", 8888,new MessageListener() {
  24.  
  25.           //收到消息后调用此方法
  26.           @Override
  27.           public void Message(String msg) {
  28.             // TODO Auto-generated method stub
  29.             // tvMessage.append(msg);
  30.             Bundle bundle = new Bundle();
  31.             bundle.putString("input", msg);
  32.             Message isMessage = new Message();
  33.             isMessage.setData(bundle);
  34.             //使用handler转发
  35.             myHandler.sendMessage(isMessage);
  36.           }
  37.         });
  38.     //正式启动线程
  39.     client.start();
  40.  
  41.   }
  42.  
  43.   OnClickListener onClick = new OnClickListener() {
  44.     public void onClick(android.view.View v) {
  45.       String message = etMessage.getText().toString();
  46.       Log.v("发送消息", message);
  47.       if (client.isStart()) {
  48.         client.sendMsg(message);
  49.       }
  50.     };
  51.   };
  52.  
  53.   private class MyHandler extends Handler {
  54.     @Override
  55.     public void handleMessage(Message msg) {
  56.       // TODO Auto-generated method stub
  57.       Log.v("处理收到的消息", "  ");
  58.       tvMessage.append(msg.getData().getString("input"));
  59.     }
  60.   }
  61. }</span>
服务器端的代码,主要是使用ServerSocket监听一个端口,来与客户端链接和收发信息 
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">public class ChatServer {
  2.   boolean started = false;
  3.   ServerSocket ss = null;
  4.  
  5.   List<Client> clients = new ArrayList<Client>();
  6.  
  7.   public static void main(String[] args) {
  8.   new ChatServer().start();
  9.   }
  10.  
  11.   public void start() {
  12.   try {
  13.     //ServerSocket监听8888端口
  14.     ss = new ServerSocket(8888);
  15.     started = true;
  16.   } catch (BindException e) {
  17.     System.out.println("start....");
  18.     System.out.println("有问题");
  19.     e.printStackTrace();
  20.     System.exit(0);
  21.   } catch (IOException e) {
  22.     e.printStackTrace();
  23.   }
  24.  
  25.   try {
  26.  
  27.     while (started) {
  28.     Socket s = ss.accept();
  29.     Client c = new Client(s);
  30.     System.out.println("a client connected!");
  31.     new Thread(c).start();
  32.     clients.add(c);
  33.     // dis.close();
  34.     }
  35.   } catch (IOException e) {
  36.     e.printStackTrace();
  37.   } finally {
  38.     try {
  39.     ss.close();
  40.     } catch (IOException e) {
  41.     // TODO Auto-generated catch block
  42.     e.printStackTrace();
  43.     }
  44.   }
  45.   }
  46.  
  47.   class Client implements Runnable {
  48.   private Socket s;
  49.   private DataInputStream dis = null;
  50.   private DataOutputStream dos = null;
  51.   private boolean bConnected = false;
  52.  
  53.   public Client(Socket s) {
  54.     this.s = s;
  55.     try {
  56.     dis = new DataInputStream(s.getInputStream());
  57.     dos = new DataOutputStream(s.getOutputStream());
  58.     bConnected = true;
  59.     } catch (IOException e) {
  60.     e.printStackTrace();
  61.     }
  62.   }
  63.  
  64.   public void send(String str) {
  65.     try {
  66.     dos.writeUTF(str);
  67.     } catch (IOException e) {
  68.     clients.remove(this);
  69.     System.out.println("关闭一个连接");
  70.     // e.printStackTrace();
  71.     }
  72.   }
  73.  
  74.   public void run() {
  75.     try {
  76.     while (bConnected) {
  77.       String str = dis.readUTF();
  78.       System.out.println(str);
  79.       for (int i = 0; i < clients.size(); i++) {
  80.       Client c = clients.get(i);
  81.       c.send(str);
  82.       // System.out.println(" a string send !");
  83.       }
  84.       /*
  85.        * for(Iterator<Client> it = clients.iterator();
  86.        * it.hasNext(); ) { Client c = it.next(); c.send(str); }
  87.        */
  88.       /*
  89.        * Iterator<Client> it = clients.iterator();
  90.        * while(it.hasNext()) { Client c = it.next(); c.send(str);
  91.        * }
  92.        */
  93.     }
  94.     } catch (EOFException e) {
  95.     System.out.println("Client closed!");
  96.     } catch (IOException e) {
  97.     e.printStackTrace();
  98.     } finally {
  99.     try {
  100.       System.out.println("close All !");
  101.       if (dis != null)
  102.       dis.close();
  103.       if (dos != null)
  104.       dos.close();
  105.       if (s != null) {
  106.       s.close();
  107.       // s = null;
  108.       }
  109.  
  110.     } catch (IOException e1) {
  111.       e1.printStackTrace();
  112.     }
  113.  
  114.     }
  115.   }
  116.  
  117.   }
  118. }</span>

接下来先运行服务器代码,再运行手机端就可以了,多台手机可以互相发送信息了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/781356
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号