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

Android与Java NIO实现简单Echo服务器与客户端_用 nio技术替代一客户一线程技术改写 echo 项目的客户机/服务器设计。

作者：Monodyee | 2024-02-28 18:01:41

赞

踩

用 nio技术替代一客户一线程技术改写 echo 项目的客户机/服务器设计。

上一篇用Java IO来做了个Demo，于是乎进一步，用Java NIO来做一个。

NIO的优势在于非阻塞。使用了Selector在一个线程里进行轮询，就能够完成接入、收\发消息的操作，不需要每建立一个连接都新启动一个线程的方式。


Server端代码：

  1. public class EchoServer {
  2.     private static final int MAX_SIZE = 256; // max size 256
  3.     private static Charset mCharSet = Charset.forName("UTF-8"); //encode and decode charset
  4.  
  5.     public static void main(String args[]) {
  6.         try {
  7.             Selector selector = Selector.open();    // init an selector
  8.             initServerChannel(selector);
  9.             startSelector(selector);
  10.         } catch (IOException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  14.  
  15.     private static void initServerChannel(Selector selector) {
  16.         ServerSocketChannel serverChannel = null;
  17.         try {
  18.             serverChannel = ServerSocketChannel.open();
  19.             serverChannel.configureBlocking(false); // not blocking
  20.             serverChannel.socket().bind(new InetSocketAddress(8999));
  21.  
  22.             serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 将ServerChannl注册为accept感兴趣类型
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }
  27.  
  28.     private static void startSelector(Selector selector) {
  29.         int loopCount = 0;
  30.         while (true) {
  31.             int n = 0;    // Selector轮询注册来的Channel, 阻塞到至少有一个通道在你注册的事件上就绪了。
  32.             try {
  33.                 n = selector.select();
  34.             } catch (IOException e) {
  35.                 e.printStackTrace();
  36.             }
  37.             if (n == 0) {
  38.                 continue;
  39.             }
  40.             System.out.println("loopCount:" + loopCount);
  41.             Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  42.             while (iterator.hasNext()) {
  43.                 SelectionKey selectionKey = iterator.next();    // 获取SelectionKey
  44.                 SocketChannel socketChannel = null;
  45.                 SelectableChannel selectableChannel = selectionKey.channel();
  46.  
  47.                 // 每一步都要判断selectionKey.isValid()，避免断开连接产生的java.nio.channels.CancelledKeyException
  48.                 if (selectionKey.isValid() && selectionKey.isAcceptable()) {
  49.                     System.out.println("selectionKey isAcceptable");
  50.                     acceptClient(selectionKey, (ServerSocketChannel) selectableChannel);
  51.                 }
  52.                 if (selectionKey.isValid() && selectionKey.isReadable()) {
  53.                     // a channel is ready for reading
  54.                     System.out.println("selectionKey isReadable");
  55.                     socketChannel = (SocketChannel) selectableChannel;// 返回为之创建此键的通道。
  56.                     readMsg(selectionKey, socketChannel);
  57.                 }
  58.                 if (selectionKey.isValid() && selectionKey.isWritable()) {
  59.                     // a channel is ready for writing
  60.                     System.out.println("selectionKey isWritable");
  61.                     socketChannel = (SocketChannel) selectableChannel;
  62.                     writeMsg(selectionKey, socketChannel);
  63.                 }
  64.                 iterator.remove();
  65.             }
  66.             loopCount++;
  67.         }
  68.     }
  69.  
  70.     private static void acceptClient(SelectionKey selectionKey, ServerSocketChannel serverChannel) {
  71.         // 此方法返回的套接字通道（如果有）将处于阻塞模式。
  72.         try {
  73.             SocketChannel socketChannel = serverChannel.accept();
  74.             socketChannel.configureBlocking(false);
  75.  
  76.             // 向Selector注册Channel，设置读取为感兴趣操作，此类操作将会在下一次选择器select操作时被交付。同时附加byteBuffer对象作为数据传递的容器
  77.             socketChannel.register(selectionKey.selector(), SelectionKey.OP_READ);
  78.  
  79.             System.out.println("connected from:" + socketChannel.getRemoteAddress());
  80.         } catch (IOException e) {
  81.             e.printStackTrace();
  82.             selectionKey.cancel();
  83.         }
  84.     }
  85.  
  86.     private static void readMsg(SelectionKey selectionKey, SocketChannel socketChannel) {
  87.         if (selectionKey == null || socketChannel == null) {
  88.             return;
  89.         }
  90.         ByteBuffer dataBuffer = ByteBuffer.allocate(MAX_SIZE);
  91.         int count = 0;
  92.         try {
  93.             count = socketChannel.read(dataBuffer);
  94.         } catch (IOException e) {
  95.             e.printStackTrace();
  96.             selectionKey.cancel();
  97.             try {
  98.                 socketChannel.close();
  99.             } catch (IOException e1) {
  100.                 e1.printStackTrace();
  101.             }
  102.         }
  103.  
  104.         if (count > 0) {
  105.             dataBuffer.flip();
  106.             byte[] bytes = new byte[dataBuffer.remaining()];
  107.             dataBuffer.get(bytes);
  108.             String data = new String(bytes, mCharSet);
  109.             System.out.println("received: " + data);
  110.             selectionKey.attach(dataBuffer);    // 给SelectionKey附加上的DataBuffer对象
  111.             selectionKey.interestOps(SelectionKey.OP_WRITE);    // 读取完，设置写入为感兴趣操作，这样在接下来一个循环会触发到服务端写操作，给用户返回数据
  112.         }
  113.         if (count == -1) {
  114.             selectionKey.cancel();
  115.             try {
  116.                 socketChannel.close();
  117.             } catch (IOException e) {
  118.                 e.printStackTrace();
  119.             }
  120.         }
  121.     }
  122.  
  123.     private static void writeMsg(SelectionKey selectionKey, SocketChannel socketChannel) {
  124.         if (selectionKey == null || socketChannel == null) {
  125.             return;
  126.         }
  127.         ByteBuffer dataBuffer = (ByteBuffer) selectionKey.attachment();
  128.  
  129.         String data = new String(dataBuffer.array(), mCharSet);
  130.         String result = "response: " + data.trim();
  131.         dataBuffer.flip();
  132.         System.out.println("send back: " + result);
  133.         dataBuffer = ByteBuffer.wrap(result.getBytes(mCharSet));
  134.         //输出到通道
  135.         try {
  136.             while (dataBuffer.hasRemaining()) {
  137.                 socketChannel.write(dataBuffer);
  138.             }
  139.             //将缓冲区的当前位置和界限之间的字节（如果有）复制到缓冲区的开始处
  140.             dataBuffer.compact();
  141.             selectionKey.interestOps(SelectionKey.OP_READ); // 写入完毕，设置读取为感兴趣操作
  142.         } catch (IOException e) {
  143.             e.printStackTrace();
  144.             selectionKey.cancel();
  145.             try {
  146.                 socketChannel.close();
  147.             } catch (IOException e1) {
  148.                 e1.printStackTrace();
  149.             }
  150.         }
  151.     }
  152. }

Android客户端：

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     private static final String TAG = MainActivity.class.getSimpleName();
  4.  
  5.     private EditText mIpEt;
  6.     private EditText mPortEt;
  7.     private Button mConnBtn;
  8.     private TextView mScreenTv;
  9.     private EditText mInputEt;
  10.  
  11.     private Button mSendBtn;
  12.  
  13.     private SocketThread mSocketThread;
  14.     private static Handler mMainHander;
  15.  
  16.     private static final int MSG_CONNECT = 0x001;
  17.     private static final int MSG_RECEIVE = 0x002;
  18.     private static final int MSG_SEND_ERROR = 0x003;
  19.  
  20.     private static final String DATA_RECEIVE = "data_receive";
  21.  
  22.     @Override
  23.     protected void onCreate(Bundle savedInstanceState) {
  24.         super.onCreate(savedInstanceState);
  25.         setContentView(R.layout.activity_main);
  26.  
  27.         mIpEt = findViewById(R.id.main_ip_et);
  28.         mPortEt = findViewById(R.id.main_port_et);
  29.         mConnBtn = findViewById(R.id.main_connect_btn);
  30.         mScreenTv = findViewById(R.id.main_screen_tv);
  31.         mInputEt = findViewById(R.id.main_input_et);
  32.         mSendBtn = findViewById(R.id.main_send_btn);
  33.  
  34.         // defalut value. Change it to your own server ip
  35.         mIpEt.setText("172.16.62.65");
  36.         mPortEt.setText("8999");
  37.  
  38.         mConnBtn.setOnClickListener(new View.OnClickListener() {
  39.             @Override
  40.             public void onClick(View v) {
  41.                 String ip = mIpEt.getText().toString();
  42.                 String port = mPortEt.getText().toString();
  43.                 if (TextUtils.isEmpty(ip) || TextUtils.isEmpty(port)) {
  44.                     Toast.makeText(MainActivity.this, "ip or port is null", Toast.LENGTH_SHORT).show();
  45.                 } else {
  46.                     connectToServer(ip, Integer.valueOf(port));
  47.                 }
  48.             }
  49.         });
  50.  
  51.         mSendBtn.setOnClickListener(new View.OnClickListener() {
  52.             @Override
  53.             public void onClick(View v) {
  54.                 String data = mInputEt.getText().toString();
  55.                 if (!TextUtils.isEmpty(data)) {
  56.                     mSocketThread.sendMsgToServer(data);
  57.                 }
  58.             }
  59.         });
  60.  
  61.         // TODO handler may cause memory leaks
  62.         mMainHander = new Handler() {
  63.             @Override
  64.             public void handleMessage(Message msg) {
  65.                 switch (msg.what) {
  66.                     case MSG_CONNECT:
  67.                         Toast.makeText(MainActivity.this, "Connect to Server Success", Toast.LENGTH_SHORT).show();
  68.                         mConnBtn.setText("Connected");
  69.                         mConnBtn.setEnabled(false);
  70.                         break;
  71.                     case MSG_RECEIVE:
  72.                         Bundle data = msg.getData();
  73.                         String dataStr = data.getString(DATA_RECEIVE);
  74.                         Log.i(TAG, "received data:" + dataStr);
  75.                         CharSequence originData = mScreenTv.getText();
  76.                         String result = originData + "\n" + dataStr;
  77.                         mScreenTv.setText(result);
  78.                         break;
  79.                     case MSG_SEND_ERROR:
  80.                         Toast.makeText(MainActivity.this, "Send Error, Connection may be Closed", Toast.LENGTH_SHORT).show();
  81.                         break;
  82.                 }
  83.             }
  84.         };
  85.     }
  86.  
  87.     private void connectToServer(String ip, int port) {
  88.         mSocketThread = new SocketThread(ip, port);
  89.         mSocketThread.start();
  90.     }
  91.  
  92.     private static class SocketThread extends Thread {
  93.         private static final int MAX_SIZE = 256; // max size 256
  94.         private static Charset mCharSet = Charset.forName("UTF-8"); //encode and decode charset
  95.         private String mIp;
  96.         private int mPort;
  97.         private SocketChannel mClientChannel;
  98.         private Selector mSelector;
  99.  
  100.         public SocketThread(String ip, int port) {
  101.             this.mIp = ip;
  102.             this.mPort = port;
  103.             try {
  104.                 mSelector = Selector.open();
  105.             } catch (IOException e) {
  106.                 e.printStackTrace();
  107.             }
  108.         }
  109.  
  110.         @Override
  111.         public void run() {
  112.             initClientChannel(mSelector);
  113.             startSelector(mSelector);
  114.         }
  115.  
  116.         private void initClientChannel(Selector selector) {
  117.             try {
  118.                 mClientChannel = SocketChannel.open();
  119.                 mClientChannel.configureBlocking(false);
  120.                 mClientChannel.connect(new InetSocketAddress(mIp, mPort));
  121.                 mClientChannel.register(selector, SelectionKey.OP_CONNECT);
  122.             } catch (IOException e) {
  123.                 e.printStackTrace();
  124.             }
  125.         }
  126.  
  127.         private void startSelector(Selector selector) {
  128.             while (true) {
  129.                 int n = 0;    // Selector轮询注册来的Channel, 阻塞到至少有一个通道在你注册的事件上就绪了。
  130.                 try {
  131.                     n = selector.select();
  132.                 } catch (IOException e) {
  133.                     e.printStackTrace();
  134.                 }
  135.                 if (n == 0) {
  136.                     continue;
  137.                 }
  138.                 Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  139.                 while (iterator.hasNext()) {
  140.                     SelectionKey selectionKey = iterator.next();    // 获取SelectionKey
  141.  
  142.                     // 每一步都要判断selectionKey.isValid()，避免断开连接产生的java.nio.channels.CancelledKeyException
  143.                     if (selectionKey.isValid() && selectionKey.isConnectable()) {
  144.                         connectServer(selectionKey);
  145.                     }
  146.                     if (selectionKey.isValid() && selectionKey.isReadable()) {
  147.                         // a channel is ready for reading
  148.                         readMsg(selectionKey);
  149.                     }
  150.                     if (selectionKey.isValid() && selectionKey.isWritable()) {
  151.                         // a channel is ready for writing
  152.                     }
  153.                     iterator.remove();
  154.                 }
  155.             }
  156.         }
  157.  
  158.         private void connectServer(SelectionKey selectionKey) {
  159.             try {
  160.                 mClientChannel.finishConnect();
  161.                 mMainHander.sendEmptyMessage(MSG_CONNECT);
  162.                 selectionKey.interestOps(SelectionKey.OP_READ);
  163.                 Log.i(TAG, "connected to:" + mClientChannel.socket().getInetAddress());
  164.             } catch (IOException e) {
  165.                 e.printStackTrace();
  166.                 selectionKey.cancel();
  167.                 try {
  168.                     mClientChannel.close();
  169.                 } catch (IOException e1) {
  170.                     e1.printStackTrace();
  171.                 }
  172.             }
  173.         }
  174.  
  175.         private void readMsg(SelectionKey selectionKey) {
  176.             if (selectionKey == null || mClientChannel == null) {
  177.                 return;
  178.             }
  179.             ByteBuffer dataBuffer = ByteBuffer.allocate(MAX_SIZE); // 从SelectionKey中取出注册时附加上的DataBuffer对象
  180.             int count = 0;
  181.             try {
  182.                 count = mClientChannel.read(dataBuffer);
  183.             } catch (IOException e) {
  184.                 e.printStackTrace();
  185.                 selectionKey.cancel();
  186.                 try {
  187.                     mClientChannel.close();
  188.                 } catch (IOException e1) {
  189.                     e1.printStackTrace();
  190.                 }
  191.             }
  192.             if (count > 0) {
  193.                 dataBuffer.flip();
  194.                 byte[] bytes = new byte[dataBuffer.remaining()];
  195.                 dataBuffer.get(bytes);
  196.                 String data = new String(bytes, mCharSet);
  197.                 Message message = mMainHander.obtainMessage();
  198.                 message.what = MSG_RECEIVE;
  199.                 Bundle bundle = new Bundle();
  200.                 bundle.putString(DATA_RECEIVE, data);
  201.                 message.setData(bundle);
  202.                 mMainHander.sendMessage(message);
  203.             }
  204.         }
  205.  
  206.         public void sendMsgToServer(final String data) {
  207.             new Thread(new Runnable() {
  208.                 @Override
  209.                 public void run() {
  210.                     ByteBuffer dataBuffer = ByteBuffer.allocate(data.length());
  211.                     dataBuffer.put(data.getBytes(mCharSet));
  212.                     dataBuffer.flip();
  213.                     //输出到通道
  214.                     try {
  215.                         while (dataBuffer.hasRemaining()) {
  216.                             mClientChannel.write(dataBuffer);
  217.                         }
  218.                         Log.i(TAG, "send data" + data);
  219.                     } catch (IOException e) {
  220.                         e.printStackTrace();
  221.                         mMainHander.sendEmptyMessage(MSG_SEND_ERROR);
  222.                         try {
  223.                             if (mClientChannel != null) {
  224.                                 mClientChannel.close();
  225.                             }
  226.                         } catch (IOException e1) {
  227.                             e1.printStackTrace();
  228.                         }
  229.                     }
  230.                 }
  231.             }).start();
  232.         }
  233.     }
  234. }

MainActivity的布局文件：

  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>

最后，同样不要忘记清单文件中声明网络权限。

NIO的使用比IO要复杂一些，但是它非阻塞的特性，极大减少线程使用这些优势，还是很值得研究的。毕竟真正到了项目级别的代码，不可能用Java IO去实现，一定是基于NIO的网络框架。


Java NIO相关例子网上不太多，自己做的时候也踩了一些坑，尤其要注意ByteBuffer的使用方式，Java IO数据是面向流的，而NIO是面向Buffer的，Buffer的读写是基本功，如果有疑惑可以去查阅相关资料。也欢迎大家一起来探讨、学习~

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

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

  

闽ICP备14008679号