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

Android与Java AIO实现简单Echo服务器与客户端_android aio

作者：很楠不爱3 | 2024-02-28 17:58:23

赞

踩

android aio

写完了NIO就来了AIO（NIO 2.0）吧~

Android需要sdk version  26及以上才支持了AIO。

AIO的优势是异步，全部的收发消息都是通过回调的方式来实现。


Server端，纯Java代码：

  1. public class EchoServer {
  2.     public static final int MAX_SIZE = 256; // max size 256
  3.     public static Charset mCharSet = Charset.forName("UTF-8"); //encode and decode charset
  4.     
  5.     public static void main(String args[]) {
  6.         AsyncServerThread serverHandler = new AsyncServerThread(8999);
  7.         new Thread(serverHandler).start();
  8.     }
  9. }

  1. public class AsyncServerThread implements Runnable {
  2.     private AsynchronousServerSocketChannel mServerChannel;
  3.     private static CountDownLatch serverStatus = new CountDownLatch(1);
  4.  
  5.     public AsyncServerThread(int port) {
  6.         try {
  7.             mServerChannel = AsynchronousServerSocketChannel.open();
  8.             mServerChannel.bind(new InetSocketAddress(port));
  9.         } catch (IOException e) {
  10.             e.printStackTrace();
  11.         }
  12.     }
  13.  
  14.     @Override
  15.     public void run() {
  16.         mServerChannel.accept(this, new AcceptHandler());
  17.         try {
  18.             // 在闭锁到达结束状态之前，这扇门一直是关闭着的，不允许任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。且当门打开了，就永远保持打开状态。
  19.             serverStatus.await();
  20.         } catch (InterruptedException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24.  
  25.     public AsynchronousServerSocketChannel getServerChannel() {
  26.         return mServerChannel;
  27.     }
  28. }

AcceptHandler负责处理客户端连接

  1. public class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, AsyncServerThread> {
  2.     @Override
  3.     public void completed(AsynchronousSocketChannel asynchronousSocketChannel, AsyncServerThread asyncServerThread) {
  4.         AsynchronousServerSocketChannel serverChannel = asyncServerThread.getServerChannel();
  5.         serverChannel.accept(asyncServerThread, this);
  6.         try {
  7.             System.out.println("connected from: " + asynchronousSocketChannel.getRemoteAddress());
  8.         } catch (IOException e) {
  9.             e.printStackTrace();
  10.         }
  11.         //创建新的Buffer
  12.         ByteBuffer buffer = ByteBuffer.allocate(EchoServer.MAX_SIZE);
  13.         //异步读  第三个参数为接收消息回调的业务Handler
  14.         asynchronousSocketChannel.read(buffer, buffer, new ReadHandler(asynchronousSocketChannel));
  15.     }
  16.  
  17.     @Override
  18.     public void failed(Throwable throwable, AsyncServerThread asyncServerThread) {
  19.  
  20.     }
  21. }

ReadHandler负责处理收到的消息。

  1. public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
  2.    
  3.     private AsynchronousSocketChannel mChannel;
  4.     public ReadHandler(AsynchronousSocketChannel channel) {
  5.         this.mChannel = channel;
  6.     }
  7.  
  8.     @Override
  9.     public void completed(Integer integer, ByteBuffer byteBuffer) {
  10.         //flip操作
  11.         byteBuffer.flip();
  12.         //根据
  13.         byte[] message = new byte[byteBuffer.remaining()];
  14.         byteBuffer.get(message);
  15.  
  16.         String data = new String(message, EchoServer.mCharSet);
  17.         System.out.println("received: " + data);
  18.         String response = "response:" + data;
  19.         //向客户端发送消息
  20.         doWrite(response);
  21.  
  22.     }
  23.  
  24.     @Override
  25.     public void failed(Throwable throwable, ByteBuffer byteBuffer) {
  26.  
  27.     }
  28.  
  29.     //发送消息
  30.     private void doWrite(String result) {
  31.         System.out.println("send back: " + result);
  32.         byte[] bytes = result.getBytes();
  33.         ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
  34.         writeBuffer.put(bytes);
  35.         writeBuffer.flip();
  36.         //异步写数据 参数与前面的read一样
  37.         mChannel.write(writeBuffer, writeBuffer, new CompletionHandler<Integer, ByteBuffer>() {
  38.             @Override
  39.             public void completed(Integer result, ByteBuffer buffer) {
  40.                 //如果没有发送完，就继续发送直到完成
  41.                 if (buffer.hasRemaining()) {
  42.                     mChannel.write(buffer, buffer, this);
  43.                 } else {
  44.                     //创建新的Buffer
  45.                     ByteBuffer readBuffer = ByteBuffer.allocate(1024);
  46.                     //异步读  第三个参数为接收消息回调的业务Handler
  47.                     mChannel.read(readBuffer, readBuffer, new ReadHandler(mChannel));
  48.                 }
  49.             }
  50.             @Override
  51.             public void failed(Throwable exc, ByteBuffer attachment) {
  52.                 try {
  53.                     mChannel.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.         });
  59.     }
  60. }

到这里服务端就完成了。代码会比Java NIO看起来更好理解一些。都是基于回调的方式来处理。


Client，Android来实现：

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     private static final String TAG = MainActivity.class.getSimpleName();
  4.     public static final int MAX_SIZE = 256; // max size 256
  5.     public static Charset mCharSet = Charset.forName("UTF-8"); //encode and decode charset
  6.  
  7.     private EditText mIpEt;
  8.     private EditText mPortEt;
  9.     private Button mConnBtn;
  10.     private TextView mScreenTv;
  11.     private EditText mInputEt;
  12.  
  13.     private Button mSendBtn;
  14.  
  15.     private SocketThread mSocketThread;
  16.     private static Handler mMainHandler;
  17.  
  18.     public static final int MSG_CONNECT = 0x001;
  19.     public static final int MSG_RECEIVE = 0x002;
  20.     public static final int MSG_SEND_ERROR = 0x003;
  21.  
  22.     public static final String DATA_RECEIVE = "data_receive";
  23.  
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.activity_main);
  28.  
  29.         mIpEt = findViewById(R.id.main_ip_et);
  30.         mPortEt = findViewById(R.id.main_port_et);
  31.         mConnBtn = findViewById(R.id.main_connect_btn);
  32.         mScreenTv = findViewById(R.id.main_screen_tv);
  33.         mInputEt = findViewById(R.id.main_input_et);
  34.         mSendBtn = findViewById(R.id.main_send_btn);
  35.  
  36.         // defalut value. Change it to your own server ip
  37.         mIpEt.setText("172.16.62.65");
  38.         mPortEt.setText("8999");
  39.  
  40.         mConnBtn.setOnClickListener(new View.OnClickListener() {
  41.             @Override
  42.             public void onClick(View v) {
  43.                 String ip = mIpEt.getText().toString();
  44.                 String port = mPortEt.getText().toString();
  45.                 if (TextUtils.isEmpty(ip) || TextUtils.isEmpty(port)) {
  46.                     Toast.makeText(MainActivity.this, "ip or port is null", Toast.LENGTH_SHORT).show();
  47.                 } else {
  48.                     connectToServer(ip, Integer.valueOf(port));
  49.                 }
  50.             }
  51.         });
  52.  
  53.         mSendBtn.setOnClickListener(new View.OnClickListener() {
  54.             @Override
  55.             public void onClick(View v) {
  56.                 String data = mInputEt.getText().toString();
  57.                 if (!TextUtils.isEmpty(data)) {
  58.                     mSocketThread.sendMsgToServer(data);
  59.                 }
  60.             }
  61.         });
  62.  
  63.         // TODO handler may cause memory leaks
  64.         mMainHandler = new Handler() {
  65.             @Override
  66.             public void handleMessage(Message msg) {
  67.                 switch (msg.what) {
  68.                     case MSG_CONNECT:
  69.                         Toast.makeText(MainActivity.this, "Connect to Server Success", Toast.LENGTH_SHORT).show();
  70.                         mConnBtn.setText("Connected");
  71.                         mConnBtn.setEnabled(false);
  72.                         break;
  73.                     case MSG_RECEIVE:
  74.                         Bundle data = msg.getData();
  75.                         String dataStr = data.getString(DATA_RECEIVE);
  76.                         Log.i(TAG, "received data:" + dataStr);
  77.                         CharSequence originData = mScreenTv.getText();
  78.                         String result = originData + "\n" + dataStr;
  79.                         mScreenTv.setText(result);
  80.                         break;
  81.                     case MSG_SEND_ERROR:
  82.                         Toast.makeText(MainActivity.this, "Send Error, Connection may be Closed", Toast.LENGTH_SHORT).show();
  83.                         break;
  84.                 }
  85.             }
  86.         };
  87.     }
  88.  
  89.     private void connectToServer(String ip, int port) {
  90.         mSocketThread = new SocketThread(ip, port);
  91.         mSocketThread.start();
  92.     }
  93.  
  94.     private static class SocketThread extends Thread {
  95.         private String mIp;
  96.         private int mPort;
  97.         private AsynchronousSocketChannel mClientChannel;
  98.         private CountDownLatch mLatch;
  99.  
  100.         public SocketThread(String ip, int port) {
  101.             this.mIp = ip;
  102.             this.mPort = port;
  103.             try {
  104.                 mClientChannel = AsynchronousSocketChannel.open();
  105.             } catch (IOException e) {
  106.                 e.printStackTrace();
  107.             }
  108.         }
  109.  
  110.         @Override
  111.         public void run() {
  112.             mLatch = new CountDownLatch(1);
  113.             AsyncClientHandler asyncClientHandler = new AsyncClientHandler(mClientChannel, mMainHandler);
  114.             mClientChannel.connect(new InetSocketAddress(mIp, mPort), asyncClientHandler, asyncClientHandler);
  115.             try {
  116.                 mLatch.await();
  117.             } catch (InterruptedException e1) {
  118.                 e1.printStackTrace();
  119.             }
  120.             try {
  121.                 mClientChannel.close();
  122.             } catch (IOException e) {
  123.                 e.printStackTrace();
  124.             }
  125.         }
  126.  
  127.         public void sendMsgToServer(final String data) {
  128.             new Thread(new Runnable() {
  129.                 @Override
  130.                 public void run() {
  131.                     byte[] bytes = data.getBytes(mCharSet);
  132.                     ByteBuffer dataBuffer = ByteBuffer.allocate(bytes.length);
  133.                     dataBuffer.put(bytes);
  134.                     dataBuffer.flip();
  135.                     Log.i(TAG, "send data" + data);
  136.                     //输出到通道
  137.                     mClientChannel.write(dataBuffer, dataBuffer, new CompletionHandler<Integer, ByteBuffer>() {
  138.                         @Override
  139.                         public void completed(Integer result, ByteBuffer buffer) {
  140.                             //如果没有发送完，就继续发送直到完成
  141.                             if (buffer.hasRemaining()) {
  142.                                 mClientChannel.write(buffer, buffer, this);
  143.                             }
  144.                         }
  145.                         @Override
  146.                         public void failed(Throwable exc, ByteBuffer attachment) {
  147.                             try {
  148.                                 mMainHandler.sendEmptyMessage(MSG_SEND_ERROR);
  149.                                 mClientChannel.close();
  150.                             } catch (IOException e) {
  151.                                 e.printStackTrace();
  152.                             }
  153.                         }
  154.                     });
  155.                 }
  156.             }).start();
  157.         }
  158.     }
  159. }

布局文件：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     android:orientation="vertical"
  6.     android:layout_margin="15dp">
  7.  
  8.     <EditText
  9.         android:id="@+id/main_ip_et"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="wrap_content"
  12.         android:hint="ip address"/>
  13.  
  14.     <EditText
  15.         android:id="@+id/main_port_et"
  16.         android:layout_width="match_parent"
  17.         android:layout_height="wrap_content"
  18.         android:hint="port"
  19.         android:inputType="number"/>
  20.  
  21.     <Button
  22.         android:id="@+id/main_connect_btn"
  23.         android:layout_width="wrap_content"
  24.         android:layout_height="wrap_content"
  25.         android:layout_gravity="center"
  26.         android:text="Connect"/>
  27.  
  28.     <EditText
  29.         android:id="@+id/main_input_et"
  30.         android:layout_width="match_parent"
  31.         android:layout_height="wrap_content"
  32.         android:hint="message to server"/>
  33.  
  34.     <Button
  35.         android:id="@+id/main_send_btn"
  36.         android:layout_width="wrap_content"
  37.         android:layout_height="wrap_content"
  38.         android:layout_gravity="center"
  39.         android:text="Send"/>
  40.  
  41.     <ScrollView
  42.         android:layout_width="match_parent"
  43.         android:layout_height="match_parent"
  44.         android:layout_marginTop="10dp">
  45.         <TextView
  46.             android:id="@+id/main_screen_tv"
  47.             android:layout_width="match_parent"
  48.             android:layout_height="wrap_content"
  49.             android:text="received message will be shown here"/>
  50.     </ScrollView>
  51.  
  52. </LinearLayout>

客户端的连接处理：

  1. public class AsyncClientHandler implements CompletionHandler<Void, AsyncClientHandler> {
  2.     private static final String TAG = AsyncClientHandler.class.getSimpleName();
  3.     private AsynchronousSocketChannel mClientChannel;
  4.     private Handler mMainHandler;
  5.  
  6.     public AsyncClientHandler(AsynchronousSocketChannel clientChannel, Handler mainHandler) {
  7.         mClientChannel = clientChannel;
  8.         mMainHandler = mainHandler;
  9.     }
  10.  
  11.     @Override
  12.     public void completed(Void result, AsyncClientHandler attachment) {
  13.         Log.i(TAG, "connect to server success!");
  14.         mMainHandler.sendEmptyMessage(MainActivity.MSG_CONNECT);
  15.  
  16.         ByteBuffer buffer = ByteBuffer.allocate(MainActivity.MAX_SIZE);
  17.         mClientChannel.read(buffer, buffer, new ReadHandler(mClientChannel, mMainHandler));
  18.     }
  19.  
  20.     @Override
  21.     public void failed(Throwable exc, AsyncClientHandler attachment) {
  22.         Log.i(TAG, "connect to server failed!");
  23.         exc.printStackTrace();
  24.         try {
  25.             mClientChannel.close();
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30. }

收消息处理：

  1. public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
  2.     private static final String TAG = "ReadHandler";
  3.  
  4.     private AsynchronousSocketChannel mClientChannel;
  5.     private Handler mMainHandler;
  6.  
  7.     public ReadHandler(AsynchronousSocketChannel clientChannel, Handler mainHandler) {
  8.         mMainHandler = mainHandler;
  9.         mClientChannel = clientChannel;
  10.     }
  11.  
  12.     @Override
  13.     public void completed(Integer integer, ByteBuffer byteBuffer) {
  14.         //flip操作
  15.         byteBuffer.flip();
  16.         //根据
  17.         byte[] data = new byte[byteBuffer.remaining()];
  18.         byteBuffer.get(data);
  19.  
  20.         String dataStr = new String(data, MainActivity.mCharSet);
  21.         Log.i(TAG, "received: " + dataStr);
  22.  
  23.         Message message = mMainHandler.obtainMessage();
  24.         message.what = MainActivity.MSG_RECEIVE;
  25.         Bundle bundle = new Bundle();
  26.         bundle.putString(MainActivity.DATA_RECEIVE, dataStr);
  27.         message.setData(bundle);
  28.         mMainHandler.sendMessage(message);
  29.  
  30.         ByteBuffer buffer = ByteBuffer.allocate(MainActivity.MAX_SIZE);
  31.         mClientChannel.read(buffer, buffer, new ReadHandler(mClientChannel, mMainHandler));
  32.     }
  33.  
  34.     @Override
  35.     public void failed(Throwable throwable, ByteBuffer byteBuffer) {
  36.  
  37.     }
  38. }

大功告成。

试验一下~


Server端打印的日志





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

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

  

闽ICP备14008679号