Java高级编程-NIO

package cn.zzu.wcj.nio;

import static org.junit.Assert.*;

import java.nio.ByteBuffer;

import org.junit.Test;
/*
* 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
*
* 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
* ByteBuffer
* CharBuffer
* ShortBuffer
* IntBuffer
* LongBuffer
* FloatBuffer
* DoubleBuffer
*
* 上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区
*
* 二、缓冲区存取数据的两个核心方法：
* put() : 存入数据到缓冲区中
* get() : 获取缓冲区中的数据
*
* 三、缓冲区中的四个核心属性：
* capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
* limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
* position : 位置，表示缓冲区中正在操作数据的位置。
*
* mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置
*
* 0 <= mark <= position <= limit <= capacity
*
* 四、直接缓冲区与非直接缓冲区：
* 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
* 直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
*/
public class BufferTest {

@Test
public void test1() {
String str="abcde"   ;
//1.分配一个指定大小的缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024)  ;
System.out.println("-----------------allocate()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
//2.利用put()方法存入数据
buf.put(str.getBytes())  ;
System.out.println("-----------------put()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
//3.切换到读取模式
buf.flip()   ;
System.out.println("-----------------flip()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
//4.利用get()读取缓冲区中的数据
byte[] dst=new byte[buf.limit()]  ;
buf.get(dst,buf.position(),buf.limit())  ;
System.out.println("-----------------get()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
//5.rewind()可重复读
buf.rewind()   ;
System.out.println("-----------------rewind()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
//6.clear():清空缓冲区,但是缓冲区中的数据依然存在,但是处于‘被遗忘’状态
buf.clear()   ;
System.out.println("-----------------clear()------------------");
System.out.println("position="+buf.position());
System.out.println("limit="+buf.limit());
System.out.println("capacity="+buf.capacity());
System.out.println((char)buf.get(0));

}

@Test
public void test2(){
String str="abcde"    ;
ByteBuffer buf=ByteBuffer.allocate(1024)   ;
byte[] source=str.getBytes()   ;
buf.put(source, 0,2)   ;
System.out.println("position="+buf.position());
buf.mark()  ;
System.out.println("-------------mark()@2--------------");
buf.put(source, 2, 2)   ;
System.out.println("position="+buf.position());
System.out.println("----------------reset()--------------------");
buf.reset() ;
System.out.println("position="+buf.position());
//       System.out.println("len="+source.length);
if(buf.hasRemaining()){
System.out.println(buf.remaining());
}

}

@Test
public void test3(){
ByteBuffer buf=ByteBuffer.allocateDirect(1024)  ;
assertSame(true, buf.isDirect());
}

}

package cn.zzu.wcj.nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;
/*
* 一、通道（Channel）：用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。
*
* 二、通道的主要实现类
*  java.nio.channels.Channel 接口：
*      |--FileChannel
*      |--SocketChannel
*      |--ServerSocketChannel
*      |--DatagramChannel
*
* 三、获取通道
* 1. Java 针对支持通道的类提供了 getChannel() 方法
*      本地 IO：
*      FileInputStream/FileOutputStream
*      RandomAccessFile
*
*      网络IO：
*      Socket
*      ServerSocket
*      DatagramSocket
*
* 2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()
* 3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()
*
* 四、通道之间的数据传输
* transferFrom()
* transferTo()
*
* 五、分散(Scatter)与聚集(Gather)
* 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
* 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中
*
* 六、字符集：Charset
* 编码：字符串 -> 字节数组
* 解码：字节数组  -> 字符串
*
*/
public class ChannelTest {

@Test
public void testEncDec() throws Exception{
Charset charset = Charset.forName("GBK")   ;
CharsetEncoder encoder = charset.newEncoder();
CharsetDecoder decoder = charset.newDecoder()  ;
CharBuffer charBuf=CharBuffer.allocate(1024)   ;
charBuf.put("HelloWorld,世界你好!");
charBuf.flip()  ;
ByteBuffer byteBuffer = encoder.encode(charBuf);
for(int x=0;x<byteBuffer.limit();x++){
System.out.print(byteBuffer.get()+"、");
}
System.out.println();
byteBuffer.flip()   ;
CharBuffer charBuffer = decoder.decode(byteBuffer);
System.out.println(charBuffer.toString());
System.out.println("-----------------------------");
//          Charset charset2 = Charset.forName("UTF-8")   ;
Charset charset2 = Charset.forName("GBK")   ;
byteBuffer.flip()  ;
CharBuffer charBuffer2 = charset2.decode(byteBuffer)  ;
System.out.println(charBuffer2.toString());
}

@Test
public void testCharset(){
Map<String,Charset> charsets = Charset.availableCharsets()  ;
Set<Entry<String,Charset>> set = charsets.entrySet()  ;
for(Entry<String,Charset> e : set ){
System.out.println(e.getKey()+"="+e.getValue());
}
}

@Test
public void testScatterAndGather()throws Exception{
RandomAccessFile raf=new RandomAccessFile("1.txt", "rw")  ;
FileChannel inChannel = raf.getChannel()  ;

ByteBuffer buf=ByteBuffer.allocate(100)   ;
ByteBuffer buf2=ByteBuffer.allocate(1024)   ;
ByteBuffer bufs[]={buf,buf2}   ;

inChannel.read(bufs)   ;
for(ByteBuffer byteBuf : bufs){
byteBuf.flip()  ;   //切换到读取模式
}
System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
System.out.println("------------------------------------------------");
System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));

RandomAccessFile raf2=new RandomAccessFile("2.txt", "rw")  ;
FileChannel outChannel = raf2.getChannel()  ;
outChannel.write(bufs)  ;

outChannel.close();
inChannel.close();
raf.close();
raf2.close();

}

@Test
public void testChannel() throws Exception{
long start=System.currentTimeMillis()   ;
FileInputStream fis=null ;
FileOutputStream fos=null ;

fis=new FileInputStream("1.jpg");
fos=new FileOutputStream("2.jpg") ;

//1.获取通道
FileChannel inChannel = fis.getChannel();
FileChannel outChannel = fos.getChannel();

//2.准备缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024)   ;

//3.读写
while(inChannel.read(buf) != -1){  //读
buf.flip()   ;      //切换到读取模式
outChannel.write(buf)  ;   //写
buf.clear()   ;           //清空缓冲区,准备再次读取
}

//4.关闭流
outChannel.close();
inChannel.close();
fos.close();
fis.close();

long end=System.currentTimeMillis()   ;
System.out.println("拷贝任务耗时:"+(end-start)+" 毫秒");

}

@Test
public void testDirectChannel()throws Exception{
long start=System.currentTimeMillis()   ;
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ)       ;
FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE )    ;
//内存映射文件
MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size())   ;
MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size())   ;

//直接对缓冲区中的数据进行读写操作
byte[] temp=new byte[1024]   ;
inMappedBuf.get(temp)   ;
outMappedBuf.put(temp)    ;

inChannel.close();
outChannel.close();

long end=System.currentTimeMillis()   ;
System.out.println("拷贝任务耗时:"+(end-start)+" 毫秒");

}

@Test
public void testTransform()throws Exception{
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ)  ;
FileChannel outChannel = FileChannel.open(Paths.get("4.jpg"), StandardOpenOption.READ,
StandardOpenOption.WRITE,
StandardOpenOption.CREATE )    ;
//inChannel.transferTo(0, inChannel.size(), outChannel)   ;
outChannel.transferFrom(inChannel, 0, inChannel.size())   ;
inChannel.close();
outChannel.close();
}

}

package cn.zzu.wcj.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;
/*
* 一、使用 NIO 完成网络通信的三个核心：
*
* 1. 通道（Channel）：负责连接
*
*     java.nio.channels.Channel 接口：
*          |--SelectableChannel
*              |--SocketChannel
*              |--ServerSocketChannel
*              |--DatagramChannel
*
*              |--Pipe.SinkChannel
*              |--Pipe.SourceChannel
*
* 2. 缓冲区（Buffer）：负责数据的存取
*
* 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
*
*/
public class BlockingNIOTest {

@Test
public void testClient() throws Exception {
//1.创建通道
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8989));
//2.准备缓冲区
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ)  ;
ByteBuffer buf=ByteBuffer.allocate(1024)   ;
//3.读取本地文件,发送到客户端
while(inChannel.read(buf) != -1){
buf.flip()  ;
socketChannel.write(buf)   ;
buf.clear()  ;
}
//4.关闭通道
inChannel.close();
socketChannel.close();

}

@Test
public void testServer() throws Exception{
//1.创建通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()  ;
//2.绑定端口号
serverSocketChannel.bind(new InetSocketAddress(8989))   ;
//3.准备Channel和Buffer
FileChannel outChannel=FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE,StandardOpenOption.CREATE)  ;
ByteBuffer buf=ByteBuffer.allocate(1024)   ;
//4.接收客户端请求
SocketChannel socketChannel = serverSocketChannel.accept()  ;
while(socketChannel.read(buf) != -1){
buf.flip()    ;
outChannel.write(buf)   ;
buf.clear()   ;
}
//5.关闭流
socketChannel.close();
outChannel.close();
serverSocketChannel.close();
}

}

package cn.zzu.wcj.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;

public class BlockingNIOTestPlus {

@Test
public void testClent() throws Exception{
SocketChannel client = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999))   ;
FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ)   ;
ByteBuffer buf=ByteBuffer.allocate(1024)     ;
while(inChannel.read(buf) != -1){
buf.flip()    ;
client.write(buf)    ;
buf.clear()    ;
}
client.shutdownOutput()    ;    //结束输出

//接收服务器反馈
while(client.read(buf) != -1){
buf.flip()    ;
System.out.println(new String(buf.array(),0,buf.limit()));
buf.clear()   ;
}

inChannel.close()  ;
client.close()  ;

}

@Test
public void testServer() throws Exception{
ServerSocketChannel server = ServerSocketChannel.open()   ;
server.bind(new InetSocketAddress(9999))   ;
FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"),
StandardOpenOption.WRITE,
StandardOpenOption.CREATE   )   ;
ByteBuffer buf=ByteBuffer.allocate(1024)  ;
SocketChannel client = server.accept();
while(client.read(buf)!=-1){
buf.flip()    ;
outChannel.write(buf)    ;
buf.clear()   ;
}
//发送反馈给客户端
buf.put("乖儿子,爸爸接收到黄图啦！！！".getBytes())  ;
buf.flip()   ;
client.write(buf)   ;

client.close();
outChannel.close();
server.close();
}

}

package cn.zzu.wcj.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.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

/*
* 一、使用 NIO 完成网络通信的三个核心：
*
* 1. 通道（Channel）：负责连接
*
*     java.nio.channels.Channel 接口：
*          |--SelectableChannel
*              |--SocketChannel
*              |--ServerSocketChannel
*              |--DatagramChannel
*
*              |--Pipe.SinkChannel
*              |--Pipe.SourceChannel
*
* 2. 缓冲区（Buffer）：负责数据的存取
*
* 3. 选择器（Selector）：是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况
*
*/
public class TestNonBlockingChannel {

@Test
public void testClient() throws Exception{
//创建客户端通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",6666))   ;
//配置为非阻塞式NIO
sChannel.configureBlocking(false)   ;
//准备缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024)   ;
Scanner sc=new Scanner(System.in)   ;
while(sc.hasNext()){
buffer.put((new Date().toString()+" : "+sc.next()).getBytes())    ;
buffer.flip()  ;   //切换成读模式
//向服务器端发送消息
sChannel.write(buffer)  ;
buffer.clear()    ;
}
//关闭通道
sChannel.close();

}

@Test
public void testServer() throws Exception{
//1.创建服务器端通道
ServerSocketChannel ssChannel = ServerSocketChannel.open()   ;
//2.绑定端口号
ssChannel.bind(new InetSocketAddress(6666))    ;
//3.设置非阻塞模式
ssChannel.configureBlocking(false)    ;
//4.获取选择器
Selector selector = Selector.open()  ;
//5.将选择器注册到通道上
ssChannel.register(selector,SelectionKey.OP_ACCEPT)  ;
//6.以轮训的方式获取选择器上已经准备就绪的事件
while(selector.select() > 0){
//7.接收全部选择键
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while(iterator.hasNext()){
//8.接收选择键
SelectionKey selectionKey = iterator.next();
//9.根据键值判断具体是什么事件
if(selectionKey.isAcceptable()){
//10.接收就绪,获取客户端连接
SocketChannel sChannel = ssChannel.accept()  ;
//11.切换到非阻塞模式
sChannel.configureBlocking(false)   ;
//12.将通道注册到选择器上
sChannel.register(selector, SelectionKey.OP_READ)   ;
}else if(selectionKey.isReadable()){
//13.获取读状态的通道
SocketChannel sChannel=(SocketChannel) selectionKey.channel()   ;
ByteBuffer dst=ByteBuffer.allocate(1024)  ;
//14.读取数据
Integer length=0  ;
while( (length=sChannel.read(dst))> 0){
dst.flip()    ;
System.out.println(new String(dst.array(),0,length));
dst.clear()   ;
}

}
//15.取消选择键
iterator.remove();
}

}
}

}

package cn.zzu.wcj.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

public class TestNonBlockingNIOPlus {

@Test
public void testSend() throws Exception{
DatagramChannel dc=DatagramChannel.open()   ;
dc.configureBlocking(false)    ;
ByteBuffer buf=ByteBuffer.allocate(1024)    ;
Scanner sc=new Scanner(System.in)  ;
while(sc.hasNext()){
String msg=sc.next()    ;
buf.put((new Date().toString()+" : "+msg).getBytes())  ;
buf.flip()   ;
dc.send(buf, new InetSocketAddress("127.0.0.1",9999))  ;
buf.clear()    ;
}
dc.close();
}

@Test
public void testReceive() throws Exception{
DatagramChannel dc = DatagramChannel.open()  ;
dc.configureBlocking(false)    ;
dc.bind(new InetSocketAddress(9999))   ;
Selector selector = Selector.open()  ;
dc.register(selector, SelectionKey.OP_READ)   ;
while(selector.select()>0){
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator()  ;
while(iterator.hasNext()){
SelectionKey selectionKey = iterator.next();
if(selectionKey.isReadable()){
ByteBuffer buf=ByteBuffer.allocate(1024)  ;
dc.receive(buf)   ;
buf.flip()   ;
System.out.println(new String(buf.array(),0,buf.limit()));
buf.clear()  ;
}
}
iterator.remove();
}
}

}

package cn.zzu.wcj.nio;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;
import java.nio.channels.Pipe.SinkChannel;
import java.nio.channels.Pipe.SourceChannel;

import org.junit.Test;

public class PipeTest {

@Test
public void testPipe() throws Exception{
//1.获取管道
Pipe pipe = Pipe.open()  ;
SinkChannel sinkChannel = pipe.sink();
//2.准备缓冲区
ByteBuffer buf=ByteBuffer.allocate(1024)   ;
buf.put("单向管道发送数据".getBytes())   ;
buf.flip()   ;
//4.发送数据
sinkChannel.write(buf)   ;
buf.clear()    ;
//5.接收数据
SourceChannel sourceChannel = pipe.source()  ;
sourceChannel.read(buf)   ;
buf.flip()  ;
System.out.println(new String(buf.array(),0,buf.limit()));
}

}