Java-IO流

一、流分类

功能分类

输入流：数据源到程序（InputStream、Reader读进来）输出流：程序到目的地（OutputStream、Writer写出去）
类型分类

字节流：按照字节读取数据（InputStream,OutputStream）字符流：按照字符读取数据（Reader、Writer）,因为文件编码的不同，从而有了对字符进行高效操作的字符流对象，原理还是基于字节流操作，自动搜寻的指定的码表
二、内核空间

我们的应用程序是不能直接访问硬盘的，我们程序没有权限直接访问，但是操作系统（Windows、Linux…）会给我们一部分权限较高的内存空间，他叫内核空间，和我们的实际硬盘空间是有区别的

三、BIO、NIO、AIO、Netty 1、什么是IO

Java中I/O是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入输出)写入输出流。简单来说就是java通过io流方式和外部设备进行交互在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛：标准输入输出，文件的操作，网络上的数据传输流，字符串流，对象流等等等 2、同步与异步，阻塞与非阻塞

同步，一个任务的完成之前不能做其他操作，必须等待（等于在打电话）异步，一个任务的完成之前，可以进行其他操作（等于在聊QQ）阻塞，是相对于CPU来说的，挂起当前线程，不能做其他操作只能等待非阻塞,，无须挂起当前线程，可以去执行其他操作 3、BIO

同步并阻塞，服务器实现一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，没处理完之前此线程不能做其他操作（如果是单线程的情况下，我传输的文件很大呢？），当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解

4、是NIO

同步非阻塞，服务器实现一个连接一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4之后开始支持

4.1 通道（Channel）

Channel是一个对象，可以通过它读取和写入数据。通常我们都是将数据写入包含一个或者多个字节的缓冲区,然后再将缓存区的数据写入到通道中，数据从通道读入缓冲区，再从缓冲区获取数据Channel 类似于原I/O中的流（Stream），但有所区别

流是单向的，通道是双向的，可读可写流读写是阻塞的，通道可以异步读写 4.2 选择器（Selector）

Selector可以称他为通道的集合，每次客户端来了之后我们会把Channel注册到Selector中并且我们给他一个状态，在用死循环来环判断( 判断是否做完某个操作，完成某个操作后改变不一样的状态 )状态是否发生变化，知道IO操作完成后在退出死循环

4.3 Buffer（缓冲区）

Buffer 是一个缓冲数据的对象，它包含一些要写入或者刚读出的数据在普通的面向流的 I/O 中，一般将数据直接写入或直接读到 Stream 对象中。当是有了Buffer（缓冲区）后，数据第一步到达的是Buffer（缓冲区）中缓冲区实质上是一个数组( 底层完全是数组实现的，感兴趣可以去看一下 )。通常它是一个字节数组，
内部维护几个状态变量，可以实现在同一块缓冲区上反复读写（不用清空数据再写） 5、AIO

异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由操作系统先完成了再通知服务器应用去启动线程进行处理，AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用操作系统参与并发操作，编程比较复杂，JDK1.7之后开始支持AIO属于NIO包中的类实现，其实IO主要分为BIO和NIO，AIO只是附加品，解决IO不能异步的实现在以前很少有Linux系统支持AIO，Windows的IOCP就是该AIO模型。但是现在的服务器一般都是支持AIO操作

6、Netty

Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发四、IO基础 1、比特(Bit),字节(Byte),字符(Char)

Bit 是最小单位计算机他只能认识0或者1Bit最小的二进制单位，是计算机的操作部分取值0或者1Byte是8个字节是给计算机看的Byte是计算机中存储数据的单元，是一个8位的二进制数，（计算机内部，一个字节可表示一个英文字母，两个字节可表示一个汉字。）取值（-128-127）Char是用户的可读写的最小单位，他只是抽象意义上的一个符号。如‘5’，‘中’，‘￥’ 。在java里面由16位bit组成Char 取值（0-65535）一个字符=二个字节 2、对象序列化、反序列化

对象序列化，将对象以二进制的形式保存在硬盘反序列化；将二进制的文件转化为对象读取实现serializable接口，不想让字段放在硬盘上就加transient 3、实现序列化接口，serialVersionUID字段

实现序列化接口是时候一般要生成一个serialVersionUID字段烈建议用户自定义一个serialVersionUID,因为默认的serialVersinUID对于class的细节非常敏感，反序列化时可能会导致InvalidClassException这个异常（比如说先进行序列化，然后在反序列化之前修改了类，那么就会报错。因为修改了类，对应的SerialversionUID也变化了，而序列化和反序列化就是通过对比其SerialversionUID来进行的，一旦SerialversionUID不匹配，反序列化就无法成功。 4、BufferedReader

BufferedReader属于处理流中的缓冲流，可以将读取的内容存在内存里面，有readLine（）方法

5、 Java中流类的超类

超类代表顶端的父类（都是抽象类）java.io.InputStreamjava.io.OutputStreamjava.io.Readerjava.io.Writer 五、IO的常用类和方法，以及如何使用

1、按字符流读取文件

字符流：以字符为单位，每次次读入或读出是16位数据。其只能读取字符类型数据。 (Java代码接收数据为一般为 char数组，也可以是别的字节流：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据，图片、文件、音乐视频等。 (Java代码接收数据只能为 byte数组 )FileReader 类：（字符输入流）注意：new FileReader(“D:test.txt”);//文件必须存在

import java.io.FileReader;
import java.io.IOException;
public class TestFileReader {
public static void main(String[] args) throws IOException {
int num=0;
//字符流接收使用的char数组
char[] buf=new char[1024];
//字符流、节点流打开文件类
FileReader fr = new FileReader("D:\test.txt");//文件必须存在
//FileReader.read()：取出字符存到buf数组中,如果读取为-1代表为空即结束读取。
//FileReader.read()：读取的是一个字符，但是java虚拟机会自动将char类型数据转换为int数据，
//如果你读取的是字符A，java虚拟机会自动将其转换成97，如果你想看到字符可以在返回的字符数前加
//（char）强制转换如
while((num=fr.read(buf))!=-1) { }
//检测一下是否取到相应的数据
for(int i=0;i 
运行结果
  
2、 按字符流的·处理流方式读取 
进行了一个小封装，加缓冲功能，避免频繁读写硬
 盘。我这只是简单演示，处理流其实还有很多操作BufferedReader 类： 字符输入流使用的类，加缓冲功能，避免频繁读写硬盘 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException
public class TestBufferedReader {
public static void main(String[] args) throws IOException {
int num=0;
//字符流接收使用的String数组
String[] bufstring=new String[1024];
//字符流、节点流打开文件类
FileReader fr = new FileReader("D:\test.txt");//文件必须存在
//字符流、处理流读取文件类
BufferedReader br = new BufferedReader(fr);
//临时接收数据使用的变量
String line=null;
//BufferedReader.readLine()：单行读取，读取为空返回null
while((line=br.readLine())!=null) {
bufstring[num]=line;
num++;
}
br.close();//关闭文件
for(int i=0;i 
运行结果
  
六、BIO、NIO、Netty代码实现 
1、BIO单线程 
TCP协议Socket使用BIO进行通信：服务端（先执行）服务端 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//TCP协议Socket使用BIO进行通信：服务端
public class BIOServer {
// 在main线程中执行下面这些代码
public static void main(String[] args) {
//使用Socket进行网络通信
ServerSocket server = null;
Socket socket = null;
//基于字节流
InputStream in = null;
OutputStream out = null;
try {
server = new ServerSocket(8000);
System.out.println("服务端启动成功，监听端口为8000，等待客户端连接...");
while (true){
socket = server.accept(); //等待客户端连接
System.out.println("客户连接成功，客户信息为：" +
socket.getRemoteSocketAddress());
in = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = 0;
//读取客户端的数据
while ((len = in.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, len));
}
//向客户端写数据
out = socket.getOutputStream();
out.write("hello!".getBytes());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
 
客户端 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//TCP协议Socket使用BIO进行通信：客户端
public class Client01 {
public static void main(String[] args) throws IOException {
//创建套接字对象socket并封装ip与port
Socket socket = new Socket("127.0.0.1", 8000);
TCP协议Socket使用BIO进行通信：客户端（第三执行）
为了解决堵塞问题，可以使用多线程，请看下面
2 多线程解决BIO编程会出现的问题
这时有人就会说，我多线程不就解决了吗?
使用多线程是可以解决堵塞等待时间很长的问题，因为他可以充分发挥CPU
然而系统资源是有限的，不能过多的新建线程，线程过多带来线程上下文的切换，从来带来更大的
性能损耗
//根据创建的socket对象获得一个输出流
//基于字节流
OutputStream outputStream = socket.getOutputStream();
//控制台输入以IO的形式发送到服务器
System.out.println("TCP连接成功 n请输入：");
String str = new Scanner(System.in).nextLine();
byte[] car = str.getBytes();
outputStream.write(car);
System.out.println("TCP协议的Socket发送成功");
//刷新缓冲区
outputStream.flush();
//关闭连接
socket.close();
}
}
 
客户端2 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//TCP协议Socket：客户端
public class Client02 {
public static void main(String[] args) throws IOException {
//创建套接字对象socket并封装ip与port
Socket socket = new Socket("127.0.0.1", 8000);
//根据创建的socket对象获得一个输出流
//基于字节流
OutputStream outputStream = socket.getOutputStream();
//控制台输入以IO的形式发送到服务器
System.out.println("TCP连接成功 n请输入：");
String str = new Scanner(System.in).nextLine();
byte[] car = str.getBytes();
outputStream.write(car);
System.out.println("TCP协议的Socket发送成功");
//刷新缓冲区
outputStream.flush();
//关闭连接
socket.close();
}
}

 
启动服务端
 启动第一个客户端，发现服务器显示连接成功
 启动第二个客户端， 发现服务端没效果 ，而客户端连接成功（在堵塞当中）
 第一个客户控制台输入，输入完后就会关闭第一个客户端， 在看服务端发现第二个客户端连接上来了 
 
2、多线程BIO代码示例 
服务端 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//TCP协议Socket使用多线程BIO进行通行：服务端
public class BIOThreadService {
public static void main(String[] args) {
try {
ServerSocket server = new ServerSocket(8000);
System.out.println("服务端启动成功，监听端口为8000，等待客户端连接... ");
while (true) {
Socket socket = server.accept();//等待客户连接
System.out.println("客户连接成功，客户信息为：" +
socket.getRemoteSocketAddress());
//针对每个连接创建一个线程， 去处理I0操作
//创建多线程创建开始
Thread thread = new Thread(new Runnable() {
public void run() {
try {
InputStream in = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = 0;
//读取客户端的数据
while ((len = in.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, len));
}
//向客户端写数据
OutputStream out = socket.getOutputStream();
out.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
});
thread.start();
}
} catch (IOException e) {
e.printStackTrace();
                       }
             }
}
 
客户端
 复用之前的代码，四个客户端 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//TCP协议Socket：客户端
public class Client02 {
public static void main(String[] args) throws IOException {
//创建套接字对象socket并封装ip与port
Socket socket = new Socket("127.0.0.1", 8000);
//根据创建的socket对象获得一个输出流
//基于字节流
OutputStream outputStream = socket.getOutputStream();
//控制台输入以IO的形式发送到服务器
System.out.println("TCP连接成功 n请输入：");
String str = new Scanner(System.in).nextLine();
byte[] car = str.getBytes();
outputStream.write(car);
System.out.println("TCP协议的Socket发送成功");
//刷新缓冲区
outputStream.flush();
//关闭连接
socket.close();
}
}

 
测试运行
 四个客户端，这次我多复制了俩个一样客户端类 

  
3、 线程池BIO代码示例 
服务端的代码，客户端的代码还是上面的代码 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//TCP协议Socket使用线程池BIO进行通行：服务端
public class BIOThreadPoolService {
public static void main(String[] args) {
//创建线程池
ExecutorService executorService = Executors.newFixedThreadPool(30);
try {
ServerSocket server = new ServerSocket(8000);
System.out.println("服务端启动成功，监听端口为8000，等待客户端连接...");
while (true) {
Socket socket = server.accept();//等待客户连接
System.out.println("客户连接成功，客户信息为：" +
socket.getRemoteSocketAddress());
//使用线程池中的线程去执行每个对应的任务
executorService.execute(new Thread(new Runnable() {
public void run() {
try {
InputStream in = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = 0;
//读取客户端的数据
while ((len = in.read(buffer)) > 0) {
System.out.println(new String(buffer, 0, len));
}
//向客户端写数据
OutputStream out = socket.getOutputStream();
out.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
})
);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
 
5、使用NIO实现网络通信 
服务端 
import com.lijie.iob.RequestHandler;
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;
import java.util.Set;
public class NIOServer {
public static void main(String[] args) throws IOException {
//111111111
//Service端的Channel，监听端口的
ServerSocketChannel serverChannel = ServerSocketChannel.open();
//设置为非阻塞
serverChannel.configureBlocking(false);
//nio的api规定这样赋值端口
serverChannel.bind(new InetSocketAddress(8000));
//显示Channel是否已经启动成功，包括绑定在哪个地址上
System.out.println("服务端启动成功，监听端口为8000，等待客户端连接..."+
serverChannel.getLocalAddress());
//22222222
//声明selector选择器
Selector selector = Selector.open();
//这句话的含义，是把selector注册到Channel上面，
//每个客户端来了之后，就把客户端注册到Selector选择器上,默认状态是Accepted
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
//33333333
//创建buffer缓冲区，声明大小是1024，底层使用数组来实现的
ByteBuffer buffer = ByteBuffer.allocate(1024);
RequestHandler requestHandler = new RequestHandler();
//444444444
//轮询，服务端不断轮询，等待客户端的连接
//如果有客户端轮询上来就取出对应的Channel，没有就一直轮询
while (true) {
int select = selector.select();
if (select == 0) {
continue;
}
//有可能有很多，使用Set保存Channel
Set selectionKeys = selector.selectedKeys();
Iterator iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
//使用SelectionKey来获取连接了客户端和服务端的Channel
SelectionKey key = iterator.next();
//判断SelectionKey中的Channel状态如何，如果是OP_ACCEPT就进入
if (key.isAcceptable()) {
//从判断SelectionKey中取出Channel
ServerSocketChannel channel = (ServerSocketChannel)
key.channel();
//拿到对应客户端的Channel
SocketChannel clientChannel = channel.accept();
//把客户端的Channel打印出来
System.out.println("客户端通道信息打印：" + clientChannel.getRemoteAddress());
//设置客户端的Channel设置为非阻塞
clientChannel.configureBlocking(false);
//操作完了改变SelectionKey中的Channel的状态OP_READ
clientChannel.register(selector, SelectionKey.OP_READ);
}
//到此轮训到的时候，发现状态是read，开始进行数据交互
if (key.isReadable()) {
//以buffer作为数据桥梁
SocketChannel channel = (SocketChannel) key.channel();
//数据要想读要先写，必须先读取到buffer里面进行操作
channel.read(buffer);
//进行读取
String request = new String(buffer.array()).trim();
buffer.clear();
//进行打印buffer中的数据
System.out.println(String.format("客户端发来的消息： %s : %s",
channel.getRemoteAddress(), request));
//要返回数据的话也要先返回buffer里面进行返回
String response = requestHandler.handle(request);
//然后返回出去
channel.write(ByteBuffer.wrap(response.getBytes()));
}
iterator.remove();
}
}
}
}
 
客户端 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//TCP协议Socket：客户端
public class Client01 {
public static void main(String[] args) throws IOException {
//创建套接字对象socket并封装ip与port
Socket socket = new Socket("127.0.0.1", 8000);
//根据创建的socket对象获得一个输出流
OutputStream outputStream = socket.getOutputStream();
//控制台输入以IO的形式发送到服务器
System.out.println("TCP连接成功 n请输入：");
while(true){
byte[] car = new Scanner(System.in).nextLine().getBytes();
outputStream.write(car);
System.out.println("TCP协议的Socket发送成功");
//刷新缓冲区
outputStream.flush();
}
}
}

 
运行示例，先运行服务端，在运行所有客户端控制台输入消息
  
 
6、使用Netty实现网络通信 
1、 先添加依赖 

io.netty
netty-all
4.1.16.Final

 
2、NettyServer 模板 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectEncoder;
import io.netty.handler.codec.string.StringDecoder;
public class NettyServer {
public static void main(String[] args) throws InterruptedException {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer() {
@Override
protected void initChannel(SocketChannel socketChannel)
throws Exception {
ChannelPipeline pipeline = socketChannel.pipeline();
pipeline.addLast(new StringDecoder());
pipeline.addLast("encoder", new ObjectEncoder());
pipeline.addLast(" decoder", new
io.netty.handler.codec.serialization.ObjectDecoder(Integer.MAX_VALUE,
ClassResolvers.cacheDisabled(null)));
//重点，其他的都是复用的
//这是真正的I0的业务代码，把他封装成一个个的个Hand1e类就行了
//把他当成 SpringMVC的Controller
pipeline.addLast(new NettyServerHandler());
}
})
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
ChannelFuture f = b.bind(8000).sync();
System.out.println("服务端启动成功，端口号为:" + 8000);
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}
 
3、需要做的IO操作，重点是继承ChannelInboundHandlerAdapter类 
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
RequestHandler requestHandler = new RequestHandler();
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
Channel channel = ctx.channel();
System.out.println(String.format("客户端信息： %s",
channel.remoteAddress()));
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws
Exception {
Channel channel = ctx.channel();
String request = (String) msg;
System.out.println(String.format("客户端发送的消息 %s : %s",
channel.remoteAddress(), request));
String response = requestHandler.handle(request);
ctx.write(response);
ctx.flush();
}
}
 
4、客户端 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//TCP协议Socket：客户端
public class Client01 {
public static void main(String[] args) throws IOException {
//创建套接字对象socket并封装ip与port
Socket socket = new Socket("127.0.0.1", 8000);
//根据创建的socket对象获得一个输出流
OutputStream outputStream = socket.getOutputStream();
//控制台输入以IO的形式发送到服务器
System.out.println("TCP连接成功 n请输入：");
while(true){
byte[] car = new Scanner(System.in).nextLine().getBytes();
outputStream.write(car);
System.out.println("TCP协议的Socket发送成功");
//刷新缓冲区
outputStream.flush();
}
}
}
 
5、运行测试

Java-IO流

Java相关栏目本月热门文章