1.demo
public class SimpleAIOServer {
static final int PORT = 30000;
public static void main(String[] args) throws Exception {
// ①创建AsynchronousServerSocketChannel对象。
AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
// ②指定在指定地址、端口监听。
serverChannel.bind(new InetSocketAddress(PORT));
while (true) {
// ③采用循环接受来自客户端的连接
Future<AsynchronousSocketChannel> future = serverChannel.accept();
// 获取连接完成后返回的AsynchronousSocketChannel
AsynchronousSocketChannel socketChannel = future.get();
// 执行输出。
socketChannel.write(ByteBuffer.wrap("欢迎你来自AIO的世界!".getBytes("UTF-8"))).get();
}
}
}
public class SimpleAIOClient {
static final int PORT = 30000;
public static void main(String[] args) throws Exception {
// 用于读取数据的ByteBuffer。
ByteBuffer buff = ByteBuffer.allocate(1024);
Charset utf = Charset.forName("utf-8");
// ①创建AsynchronousSocketChannel对象
AsynchronousSocketChannel clientChannel = AsynchronousSocketChannel.open();
// ②连接远程服务器
clientChannel.connect(new InetSocketAddress("127.0.0.1", PORT)).get(); // ④
buff.clear();
// ③从clientChannel中读取数据
clientChannel.read(buff).get(); // ⑤
buff.flip();
// 将buff中内容转换为字符串
String content = utf.decode(buff).toString();
System.out.println("服务器信息:" + content);
}
}
2.AIO版聊天程序
要注意的是要在服务端的completed方法中加if(result>0),否则客户端断开时会无限循环输出。
public class AIOServer {
static final int PORT = 30000;
final static String UTF_8 = "utf-8";
static List<AsynchronousSocketChannel> 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)); // ①
Thread.sleep(15000);
}
public static void main(String[] args) throws Exception {
AIOServer server = new AIOServer();
server.startListen();
}
}
// 实现自己的CompletionHandler类
class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, Object> {
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<Integer, Object>() // ②
{
@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);
}
}
public class AIOClient {
final static String UTF_8 = "utf-8";
final static int PORT = 30000;
// 与服务器端通信的异步Channel
AsynchronousSocketChannel clientChannel;
public void init() throws Exception {
Scanner scan = new Scanner(System.in);
while (scan.hasNextLine()) {
clientChannel.write(ByteBuffer.wrap(scan.nextLine().getBytes(UTF_8))).get(); // ①
}
}
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");
System.out.println("---与服务器连接成功---");
buff.clear();
clientChannel.read(buff, null, new CompletionHandler<Integer, Object>() // ②
{
@Override
public void completed(Integer result, Object attachment) {
buff.flip();
// 将buff中内容转换为字符串
String content = StandardCharsets.UTF_8.decode(buff).toString();
// 显示从服务器端读取的数据
// jta.append("某人说:" + content + "\n");
System.out.println("某人说:" + content);
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.connect();
client.init();
}
}
参考:
疯狂java讲义