NIO（十）—— NIO的几个例子

1. FileChannel写入文件

package com.mycom.test.nio;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * FileChannel写入文件
 * 
 * @author guweiqiang
 */
public class TestFileChannelWrite {

	public static void main(String[] args) {
		try {
			// 新建一个File对象
			File file = new File("e:/writeData.txt");
			// 将文件读取到文件输出流中
			FileOutputStream outputStream = new FileOutputStream(file);
			// 获取FileChannel通道对象
			FileChannel fileChannel = outputStream.getChannel();
			// 新建缓冲区
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			String testStr = "hello world!";
			// 将内容写入到缓冲区
			buffer.put(testStr.getBytes());
			buffer.flip(); //此处必须要调用buffer的flip方法
			// 将缓冲区内容写入到fileChannel通道
			fileChannel.write(buffer);
			// 关闭fileChannel通道
			fileChannel.close();
			// 关闭文件输出流
			outputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}

}

 

 

2. FileChannel读取文件

package com.mycom.test.nio;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * FileChannel读取文件
 * 
 * @author guweiqiang
 */
public class TestFileChannelRead {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		try {
			// 新建一个RandomAccessFile对象
			RandomAccessFile file = new RandomAccessFile("e:/readData.txt", "rw"); // rw表示以读写方式打开文件，r表示只读方式打开
			// 获取FileChannel通道对象
			FileChannel fileChannel = file.getChannel();
			// 新建缓冲区
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			// 将fileChannel中的数据读取到buffer中
			fileChannel.read(buffer);
			// 再将buffer中的数据读取到String对象中
			byte[] data = buffer.array();
			String ss = new String(data).trim();
			System.out.println(ss);
			// 关闭fileChannel通道
			fileChannel.close();
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}

}

 （前提是存在以下文件：e:/readData.txt）

 

 

 3. Server与Cilent通信

NIO 服务端：

package com.mycom.test.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO 服务端
 * 
 * @author guweiqiang
 */
public class NIOServer {
	// 通道管理器
	private Selector selector;
	
	/**
	 * 获取一个服务端通道ServerSocket，并进行初始化
	 */
	public void initServer(int port) throws IOException{
		// 获取一个ServerSocket服务端通道
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		// 设置通道为非阻塞模式
		serverChannel.configureBlocking(false);
		// 绑定端口
		serverChannel.socket().bind(new InetSocketAddress(port));
		// 获取一个通道管理器
		this.selector = Selector.open();
		// 将通道管理器和通道进行绑定，并为该通道注册SelectionKey.OP_ACCEPT事件
		// 当事件到达时，selector.select()就会返回；如果事件没有到达，则selector.select()就会一直阻塞
		serverChannel.register(selector, SelectionKey.OP_ACCEPT);
	}
	
	/**
	 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有则进行处理
	 */
	@SuppressWarnings("rawtypes")
	public void listen() throws IOException{
		System.out.println("服务端启动成功！");
		
		// 轮询访问selector
		while(true){
			// 当有已注册的事件到达时，方法返回，否则就一直阻塞到有注册的事件到达为止
			selector.select();
			
			// 获取selector中选中项的迭代器，选中项为注册的事件
			Iterator it = this.selector.selectedKeys().iterator();
			while(it.hasNext()){
				SelectionKey key = (SelectionKey)it.next();
				// 删除已选的key，防止重复处理
				it.remove();
				
				if(key.isAcceptable()){ // 有客户端请求连接的事件
					// 获取服务端通道
					ServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();
					// 获取与客户端连接的通道
					SocketChannel clientChannel = serverChannel.accept();
					// 设置为非阻塞
					clientChannel.configureBlocking(false);
					// 给客户端发送消息
					clientChannel.write(ByteBuffer.wrap(new String("hello client, i'm server!").getBytes("utf-8")));
					// 在和客户端连接成功之后，为了可以接收到客户端的消息，需要给通道设置读权限
					clientChannel.register(this.selector, SelectionKey.OP_READ);
					
				} else if(key.isReadable()){ // 有读取事件发生
					readKey(key);
				}
			}
		}
	}

	/**
	 * 处理读取客户端发来的消息
	 */
	private void readKey(SelectionKey key) throws IOException {
		// 服务器可读取消息:得到事件发生的Socket通道 
		SocketChannel channel = (SocketChannel)key.channel();
		
		// 读取通道里的消息
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		channel.read(buffer);
		byte[] data = buffer.array();
		String receivedMsg = new String(data).trim();
		System.out.println("服务端收到客户端发来的的消息：" + receivedMsg);
		
		// 向通道写入消息
		String sendMsg = "hello client!";
		ByteBuffer outBuffer = ByteBuffer.wrap(sendMsg.getBytes("utf-8")); 
		channel.write(outBuffer);// 将消息回送给客户端  
	}
	
	/**
	 * 启动服务端测试
	 */
	public static void main(String[] args) {
		try {
			NIOServer server = new NIOServer();
			server.initServer(8000);
			server.listen();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

 NIO 客户端：

package com.mycom.test.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO 客户端
 * 
 * @author guweiqiang
 */
public class NIOClient {
	// 通道管理器
	private Selector selector;
	
	/**
	 * 获取一个客户端通道，并进行初始化
	 * @throws IOException 
	 */
	public void initClient(String ip, int port) throws IOException{
		// 获取一个Socket客户端通道
		SocketChannel clientChannel = SocketChannel.open();
		// 设置通道为非阻塞模式
		clientChannel.configureBlocking(false);
		// 获取一个通道管理器
		this.selector = Selector.open();
		// 客户端连接服务器
		clientChannel.connect(new InetSocketAddress(ip, port));
		// 将通道管理器和通道进行绑定，并为该通道注册SelectionKey.OP_CONNECT事件
		clientChannel.register(selector, SelectionKey.OP_CONNECT);
	}

	/**
	 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有则进行处理
	 */
	@SuppressWarnings("rawtypes")
	public void listen() throws IOException{
		// 轮询访问selector
		while(true){
			// 当有已注册的事件到达时，方法返回，否则就一直阻塞到有注册的事件到达为止
			selector.select();
			
			// 获取selector中选中项的迭代器，选中项为注册的事件
			Iterator it = this.selector.selectedKeys().iterator();
			while(it.hasNext()){
				SelectionKey key = (SelectionKey)it.next();
				// 删除已选的key，防止重复处理
				it.remove();
				
				if(key.isConnectable()){ // 有连接事件发生
					// 获取客户端通道
					SocketChannel clientChannel = (SocketChannel)key.channel();
					// 如果正在连接，则设置连接完成
					if(clientChannel.isConnectionPending()){
						clientChannel.finishConnect();
					}
					// 设置通道为非阻塞模式
					clientChannel.configureBlocking(false);
					// 给服务端发送消息
					clientChannel.write(ByteBuffer.wrap(new String("hello server, i'm client！").getBytes("utf-8")));
					// 在和服务端连接之后，为了可以接收到服务端的消息，需要给客户端设置读权限
					clientChannel.register(selector, SelectionKey.OP_READ);
					
				} else if(key.isReadable()){ // 有读取事件发生
					this.readKey(key);
				}
			}
		}
	}
	
	/**
	 * 处理读取服务端发来的消息
	 */
	private void readKey(SelectionKey key) throws IOException {
		// 服务器可读取消息:得到事件发生的Socket通道 
		SocketChannel channel = (SocketChannel)key.channel();
		
		// 读取通道里的消息
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		channel.read(buffer);
		byte[] data = buffer.array();
		String receivedMsg = new String(data).trim();
		System.out.println("客户端收到服务端发来的消息：" + receivedMsg);
		
		// 向通道写入消息
		String sendMsg = "hello server!";
		ByteBuffer outBuffer = ByteBuffer.wrap(sendMsg.getBytes("utf-8")); 
		channel.write(outBuffer);// 将消息回送给服务端  
	}
	
	/**
	 * 启动客户端测试
	 */
	public static void main(String[] args) {
		try {
			NIOClient client = new NIOClient();
			client.initClient("127.0.0.1", 8000);
			client.listen();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}