android aio java,\(^)/ Java AIO 通讯例子

服务器端：

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.AsynchronousChannelGroup;

import java.nio.channels.AsynchronousServerSocketChannel;

import java.nio.channels.AsynchronousSocketChannel;

import java.nio.channels.CompletionHandler;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class AIOServer

{

static final int PORT = 30000;

final static String UTF_8 = "utf-8";

static List channelList

= new ArrayList<>();

public void startListen() throws InterruptedException,

Exception

{

// 创建一个线程池

ExecutorService executor = Executors.newFixedThreadPool(20);

// 以指定线程池来创建一个AsynchronousChannelGroup

AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup

.withThreadPool(executor);

// 以指定线程池来创建一个AsynchronousServerSocketChannel

AsynchronousServerSocketChannel serverChannel

= AsynchronousServerSocketChannel.open(channelGroup)

// 指定监听本机的PORT端口

.bind(new InetSocketAddress(PORT));

// 使用CompletionHandler接受来自客户端的连接请求

serverChannel.accept(null, new AcceptHandler(serverChannel)); //①

}

public static void main(String[] args)

throws Exception

{

AIOServer server = new AIOServer();

server.startListen();

}

}

// 实现自己的CompletionHandler类

class AcceptHandler implements

CompletionHandler

{

private AsynchronousServerSocketChannel serverChannel;

public AcceptHandler(AsynchronousServerSocketChannel sc)

{

this.serverChannel = sc;

}

// 定义一个ByteBuffer准备读取数据

ByteBuffer buff = ByteBuffer.allocate(1024);

// 当实际IO操作完成时候触发该方法

@Override

public void completed(final AsynchronousSocketChannel sc

, Object attachment)

{

// 记录新连接的进来的Channel

AIOServer.channelList.add(sc);

// 准备接受客户端的下一次连接

serverChannel.accept(null , this);

sc.read(buff , null

, new CompletionHandler() //②

{

@Override

public void completed(Integer result

, Object attachment)

{

buff.flip();

// 将buff中内容转换为字符串

String content = StandardCharsets.UTF_8

.decode(buff).toString();

// 遍历每个Channel，将收到的信息写入各Channel中

for(AsynchronousSocketChannel c : AIOServer.channelList)

{

try

{

c.write(ByteBuffer.wrap(content.getBytes(

AIOServer.UTF_8))).get();

}

catch (Exception ex)

{

ex.printStackTrace();

}

}

buff.clear();

// 读取下一次数据

sc.read(buff , null , this);

}

@Override

public void failed(Throwable ex, Object attachment)

{

System.out.println("读取数据失败: " + ex);

// 从该Channel读取数据失败，就将该Channel删除

AIOServer.channelList.remove(sc);

}

});

}

@Override

public void failed(Throwable ex, Object attachment)

{

System.out.println("连接失败: " + ex);

}

}

客户端：

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.AsynchronousChannelGroup;

import java.nio.channels.AsynchronousSocketChannel;

import java.nio.channels.CompletionHandler;

import java.nio.charset.StandardCharsets;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.KeyStroke;

public class AIOClient {

final static String UTF_8 = "utf-8";

final static int PORT = 30000;

// 与服务器端通信的异步Channel

AsynchronousSocketChannel clientChannel;

JFrame mainWin = new JFrame("多人聊天");

JTextArea jta = new JTextArea(16, 48);

JTextField jtf = new JTextField(40);

JButton sendBn = new JButton("发送");

public void init() {

mainWin.setLayout(new BorderLayout());

jta.setEditable(false);

mainWin.add(new JScrollPane(jta), BorderLayout.CENTER);

JPanel jp = new JPanel();

jp.add(jtf);

jp.add(sendBn);

// 发送消息的Action,Action是ActionListener的子接口

Action sendAction = new AbstractAction() {

public void actionPerformed(ActionEvent e) {

String content = jtf.getText();

if (content.trim().length() > 0) {

try {

// 将content内容写入Channel中

clientChannel.write(ByteBuffer.wrap(content.trim().getBytes(UTF_8))).get(); // ①

} catch (Exception ex) {

ex.printStackTrace();

}

}

// 清空输入框

jtf.setText("");

}

};

sendBn.addActionListener(sendAction);

// 将Ctrl+Enter键和"send"关联

jtf.getInputMap().put(KeyStroke.getKeyStroke('\n', java.awt.event.InputEvent.CTRL_MASK), "send");

// 将"send"和sendAction关联

jtf.getActionMap().put("send", sendAction);

mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

mainWin.add(jp, BorderLayout.SOUTH);

mainWin.pack();

mainWin.setVisible(true);

}

public void connect() throws Exception {

// 定义一个ByteBuffer准备读取数据

final ByteBuffer buff = ByteBuffer.allocate(1024);

// 创建一个线程池

ExecutorService executor = Executors.newFixedThreadPool(80);

// 以指定线程池来创建一个AsynchronousChannelGroup

AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup.withThreadPool(executor);

// 以channelGroup作为组管理器来创建AsynchronousSocketChannel

clientChannel = AsynchronousSocketChannel.open(channelGroup);

// 让AsynchronousSocketChannel连接到指定IP、指定端口

clientChannel.connect(new InetSocketAddress("127.0.0.1", PORT)).get();

jta.append("---与服务器连接成功---\n");

buff.clear();

clientChannel.read(buff, null, new CompletionHandler() // ②

{

@Override

public void completed(Integer result, Object attachment) {

buff.flip();

// 将buff中内容转换为字符串

String content = StandardCharsets.UTF_8.decode(buff).toString();

// 显示从服务器端读取的数据

jta.append("某人说：" + content + "\n");

buff.clear();

clientChannel.read(buff, null, this);

}

@Override

public void failed(Throwable ex, Object attachment) {

System.out.println("读取数据失败: " + ex);

}

});

}

public static void main(String[] args) throws Exception {

AIOClient client = new AIOClient();

client.init();

client.connect();

}

}