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

Android——Tcp服务端实现_android tcp servers

作者：码创造者 | 2024-07-26 16:16:05

赞

踩

android tcp servers

Android——Tcp服务端
        传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。
        Tcp分为服务端（网络应用程序）和客户端（网络应用程序），Tcp通信过程，首先打开服务器监听自己的网络通信端口（假设为7628），打开客户端，设置好要连接的ip地址和服务器的网络通信端口（7628），这样服务器监听到网络通信端口有连接，二者就建立了连接。
客户端：可以连接服务端、发送数据、接收数据、关闭连接等。
服务端：可以实现绑定通信端口，接收客户端连接、接收数据、发送数据等。

在java项目中我们可以较为快捷地使用TCP通讯，但想要在Android中使用还有很多要注意的地方。下面我们来学习下Tcp服务端在Android上的实现。

我之前做过一个项目里有个要通过Tcp获取智能手环上电量、心率，血压血氧、步数等基本数据的功能。（这里只是个功能一样的简单小Demo，报文需要处理才能看到想要的信息）

服务端ServerSocket的构造方法：
1、ServerSocket()：构造一个新的未绑定的ServerSocket。
2、ServerSocket(int port):构造一个新的ServerSocket并绑定到指定端口，如果port等于0，则端口由系统自动分配。
3、ServerSocket(int port,int backlog)：构造一个新的ServerSocket并绑定到指定端口以及指定进入队列的数目。如果port等于0，则端口由系统自动分配。
4、ServerSocket(int port,int backlog,InetAddress localAddress)：构造一个新的ServerSocket并绑定到指定端口以及指定进入队列的数目。如果port等于0，则端口由系统自动分配。如果localAddress为null，则可以使用任意地址。


Tcp服务端使用步骤为：

①创建ServerSocket，绑定指定端口

  1. try {
  2.     //开启服务、指定端口号
  3.     socket = new ServerSocket(mServerPort);
  4. } catch (IOException e) {
  5.     e.printStackTrace();
  6.     Toast.makeText(this, "服务开启失败", Toast.LENGTH_SHORT).show();
  7.     return;
  8. }

②调用ServerSocket的accept()，监听连接请求

③调用Socket类中的getInputStream()和getOutputStream()获取输入输出流

  1. class SocketAcceptThread extends Thread {
  2.     @Override
  3.     public void run() {
  4.         try {
  5.             //等待客户端的连接，Accept会阻塞，直到建立连接，
  6.             //所以需要放在子线程中运行。
  7.             mSocket = socket.accept();
  8.             //获取输入流
  9.             mInStream = mSocket.getInputStream();
  10.             //获取输出流
  11.             mOutStream = mSocket.getOutputStream();
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.             startAccept();
  15.             return;
  16.         }
  17.         Log.i(TAG, "accept success");
  18.         SocketReceive();
  19.     }
  20. }

 

​​​​​​​ ④接收、发送数据

  1. /**
  2.  * 发送
  3.  */
  4. private void sendText() {
  5.     if (mSocket == null) {
  6.         Toast.makeText(MainActivity.this, "没有客户端连接", Toast.LENGTH_LONG).show();
  7.         return;
  8.     }
  9.     String str = content.getText().toString();
  10.     if (str.length() == 0) {
  11.         return;
  12.     }
  13.     Message msg = new Message();
  14.     msg.what = Two;
  15.     msg.obj = str;
  16.     mSubThreadHandler.sendMessage(msg);
  17. }
  18.  
  19. private void writeMsg(String msg) {
  20.     if (msg.length() == 0 || mOutStream == null) {
  21.         return;
  22.     }
  23.     try {
  24.         //发送
  25.         mOutStream.write(msg.getBytes());
  26.         mOutStream.flush();
  27.     } catch (IOException e) {
  28.         e.printStackTrace();
  29.     }
  30. }
int count = mInStream.read(buffer);

 ⑤关闭服务

  1. if (socket != null) {
  2.     try {
  3.         socket.close();
  4.     } catch (IOException e) {
  5.         e.printStackTrace();
  6.     }
  7. }

注意： 在清单文件中添加权限

<uses-permission android:name="android.permission.INTERNET"/>

下面是MainActivity.java完整代码 ：

  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  2.     /**
  3.      * 设置
  4.      */
  5.     private Button setting;
  6.     /**
  7.      * 开启服务
  8.      */
  9.     private Button open_service;
  10.     /**
  11.      * 输入内容
  12.      */
  13.     private EditText content;
  14.     /**
  15.      * 发送
  16.      */
  17.     private Button send_out;
  18.     /**
  19.      * 接收到的数据
  20.      */
  21.     private EditText receive;
  22.     private final String TAG = "MainActivity";
  23.     private static final char HexCharArr[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  24.     /**
  25.      * 服务端端口
  26.      */
  27.     private int mServerPort;
  28.     private SharedPreferences sp;
  29.     private static final String PORT = "port";
  30.     public Socket mSocket;
  31.     private HandlerThread mHandlerThread;
  32.     /**
  33.      * 子线程中的Handler实例
  34.      */
  35.     private Handler mSubThreadHandler;
  36.     private SocketAcceptThread mAcceptThread;
  37.     private SocketReceiveThread mReceiveThread;
  38.     private ServerSocket socket;
  39.     /**
  40.      * 输出流
  41.      */
  42.     private OutputStream mOutStream;
  43.     /**
  44.      * 输入流
  45.      */
  46.     private InputStream mInStream;
  47.     private static final int One = 1;
  48.     private static final int Two = 2;
  49.     private Handler mHandler = new Handler() {
  50.         @Override
  51.         public void handleMessage(@NonNull Message msg) {
  52.             switch (msg.what) {
  53.                 case One:
  54.                     String sb = receive.getText().toString() + "\r\n" + (String) msg.obj;
  55.                     receive.setText(sb);
  56.                     break;
  57.                 default:
  58.                     break;
  59.             }
  60.         }
  61.     };
  62.  
  63.  
  64.     @Override
  65.     protected void onCreate(Bundle savedInstanceState) {
  66.         super.onCreate(savedInstanceState);
  67.         setContentView(R.layout.activity_main);
  68.         setting = findViewById(R.id.setting);
  69.         open_service = findViewById(R.id.open_service);
  70.         content = findViewById(R.id.content);
  71.         send_out = findViewById(R.id.send_out);
  72.         receive = findViewById(R.id.receive);
  73.         setting.setOnClickListener(this);
  74.         open_service.setOnClickListener(this);
  75.         send_out.setOnClickListener(this);
  76.         //获取sharedPreferences对象
  77.         sp = getSharedPreferences("settings", Context.MODE_PRIVATE);
  78.         //如果key不存在，则返回默认defValue
  79.         mServerPort = sp.getInt(PORT, 7628);
  80.         initHandlerThraed();
  81.     }
  82.  
  83.     @Override
  84.     protected void onDestroy() {
  85.         super.onDestroy();
  86.         Log.i(TAG, "onDestory");
  87.         closeConnect();
  88.         if (socket != null) {
  89.             try {
  90.                 socket.close();
  91.             } catch (IOException e) {
  92.                 e.printStackTrace();
  93.             }
  94.         }
  95.     }
  96.  
  97.     private void closeConnect() {
  98.         try {
  99.             if (mOutStream != null) {
  100.                 mOutStream.close();
  101.             }
  102.             if (mInStream != null) {
  103.                 mInStream.close();
  104.             }
  105.             if (mSocket != null) {
  106.                 mSocket.close();    //关闭socket
  107.                 mSocket = null;
  108.             }
  109.         } catch (IOException e) {
  110.             e.printStackTrace();
  111.         }
  112.         if (mReceiveThread != null) {
  113.             mReceiveThread.threadExit();
  114.             mReceiveThread = null;
  115.         }
  116.     }
  117.  
  118.     @Override
  119.     public void onClick(View v) {
  120.         switch (v.getId()) {
  121.             //设置
  122.             case R.id.setting:
  123.                 set();
  124.                 break;
  125.             //开启服务
  126.             case R.id.open_service:
  127.                 startServer();
  128.                 break;
  129.             //发送
  130.             case R.id.send_out:
  131.                 sendText();
  132.                 break;
  133.             default:
  134.                 break;
  135.         }
  136.     }
  137.  
  138.     /**
  139.      * 设置
  140.      */
  141.     private void set() {
  142.         //获取布局
  143.         View setview = LayoutInflater.from(this).inflate(R.layout.port, null);
  144.         //获取布局中的控件
  145.         final EditText editport = (EditText) setview.findViewById(R.id.server_port);
  146.         Button ensureBtn = (Button) setview.findViewById(R.id.server_ok);
  147.         editport.setText(sp.getInt(PORT, 7628) + "");
  148.  
  149.         final android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(this);
  150.         //设置dialog显示一个view
  151.         builder.setView(setview);
  152.         //dialog显示
  153.         final AlertDialog dialog = builder.show();
  154.         ensureBtn.setOnClickListener(new View.OnClickListener() {
  155.             @Override
  156.             public void onClick(View v) {
  157.                 String port = editport.getText().toString();
  158.                 if (port != null && port.length() > 0) {
  159.                     mServerPort = Integer.parseInt(port);//将内容转换成整数
  160.                 }
  161.                 SharedPreferences.Editor editor = sp.edit(); //SharedPreferences.Editor 简单的数据存储
  162.                 editor.putInt(PORT, mServerPort);   //存储数据
  163.                 editor.commit();                    //提交
  164.                 dialog.dismiss();                   //dialog消失
  165.             }
  166.         });
  167.     }
  168.  
  169.     /**
  170.      * 开启服务
  171.      */
  172.     void startServer() {
  173.         try {
  174.             //开启服务、指定端口号
  175.             socket = new ServerSocket(mServerPort);
  176.         } catch (IOException e) {
  177.             e.printStackTrace();
  178.             Toast.makeText(this, "服务开启失败", Toast.LENGTH_SHORT).show();
  179.             return;
  180.         }
  181.         startAccept();
  182.         Toast.makeText(this, "服务开启", Toast.LENGTH_LONG).show();
  183.     }
  184.  
  185.     /**
  186.      * 开启SocketAcceptThread()线程
  187.      */
  188.     private void startAccept() {
  189.         mAcceptThread = new SocketAcceptThread();
  190.         mAcceptThread.start();
  191.     }
  192.  
  193.     class SocketAcceptThread extends Thread {
  194.         @Override
  195.         public void run() {
  196.             try {
  197.                 //等待客户端的连接，Accept会阻塞，直到建立连接，
  198.                 //所以需要放在子线程中运行。
  199.                 mSocket = socket.accept();
  200.                 //获取输入流
  201.                 mInStream = mSocket.getInputStream();
  202.                 //获取输出流
  203.                 mOutStream = mSocket.getOutputStream();
  204.             } catch (IOException e) {
  205.                 e.printStackTrace();
  206.                 startAccept();
  207.                 return;
  208.             }
  209.             Log.i(TAG, "accept success");
  210.             SocketReceive();
  211.         }
  212.     }
  213.  
  214.     private void SocketReceive() {
  215.         mReceiveThread = new SocketReceiveThread();
  216.         mReceiveThread.start();
  217.     }
  218.  
  219.     class SocketReceiveThread extends Thread {
  220.         private boolean threadExit = false;
  221.  
  222.         @Override
  223.         public void run() {
  224.             byte[] buffer = new byte[1024];
  225.             while (threadExit == false) {
  226.                 try { //读取数据，返回值表示读到的数据长度。-1表示结束
  227.                     int count = mInStream.read(buffer);
  228.                     if (count == -1) {
  229.                         Log.i(TAG, "read read -1");
  230.                         startAccept();
  231.                         break;
  232.                     } else {
  233.                         String receiveData;
  234.                         receiveData = byteArrToHex(buffer);
  235.                         Log.i(TAG, "read buffer:" + receiveData + ",count=" + count);
  236.                         Message msg = new Message();
  237.                         msg.what = One;
  238.                         msg.obj = receiveData;
  239.  
  240.                         mHandler.sendMessage(msg);
  241.                     }
  242.                 } catch (IOException e) {
  243.                     e.printStackTrace();
  244.                 }
  245.             }
  246.         }
  247.  
  248.         void threadExit() {
  249.             threadExit = true;
  250.         }
  251.     }
  252.  
  253.     /**
  254.      * 发送
  255.      */
  256.     private void sendText() {
  257.         if (mSocket == null) {
  258.             Toast.makeText(MainActivity.this, "没有客户端连接", Toast.LENGTH_LONG).show();
  259.             return;
  260.         }
  261.         String str = content.getText().toString();
  262.         if (str.length() == 0) {
  263.             return;
  264.         }
  265.         Message msg = new Message();
  266.         msg.what = Two;
  267.         msg.obj = str;
  268.         mSubThreadHandler.sendMessage(msg);
  269.     }
  270.  
  271.     private void writeMsg(String msg) {
  272.         if (msg.length() == 0 || mOutStream == null) {
  273.             return;
  274.         }
  275.         try {
  276.             //发送
  277.             mOutStream.write(msg.getBytes());
  278.             mOutStream.flush();
  279.         } catch (IOException e) {
  280.             e.printStackTrace();
  281.         }
  282.     }
  283.  
  284.     /**
  285.      * 字节数组转换十六进制
  286.      */
  287.     public static String byteArrToHex(byte[] btArr) {
  288.         char strArr[] = new char[btArr.length * 2];
  289.         int i = 0;
  290.         for (byte bt : btArr) {
  291.             strArr[i++] = HexCharArr[bt >>> 4 & 0xf];
  292.             strArr[i++] = HexCharArr[bt & 0xf];
  293.         }
  294.         return new String(strArr);
  295.     }
  296.  
  297.     private void initHandlerThraed() {
  298.         //创建HandlerThread实例
  299.         mHandlerThread = new HandlerThread("handler_thread");
  300.         //开始运行线程
  301.         mHandlerThread.start();
  302.         //获取HandlerThread线程中的Looper实例
  303.         Looper loop = mHandlerThread.getLooper();
  304.         //创建Handler与该线程绑定。
  305.         mSubThreadHandler = new Handler(loop) {
  306.             @Override
  307.             public void handleMessage(Message msg) {
  308.                 Log.i(TAG, "mSubThreadHandler handleMessage thread:" + Thread.currentThread());
  309.                 switch (msg.what) {
  310.                     case Two:
  311.                         writeMsg((String) msg.obj);
  312.                         break;
  313.                     default:
  314.                         break;
  315.                 }
  316.             }
  317.         };
  318.     }
  319.  
  320. }

 

最后是运行效果：设置端口、开启服务、获取的数据（需要处理）

 

 

 Demo中用到的Handler、dialog对话框、SharedPreferences不理解的可以参考一下我之前的发布的文章。

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

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

  

闽ICP备14008679号