java核心知识点整理--io流及动态代理

最新推荐文章于 2022-03-07 14:27:44 发布

小猫吃鱼灬

最新推荐文章于 2022-03-07 14:27:44 发布

阅读量410

点赞数

分类专栏：基础整理常见面试 io流

原文链接：https://gitbook.cn/gitchat/column/5d493b4dcb702a087ef935d9/topic/5d4e136669004b174cd0013d

版权

基础整理同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

常见面试

7 篇文章 0 订阅

订阅专栏

io流

1 篇文章 0 订阅

订阅专栏

1、java.io 包下的类有哪些
IO 介绍
IO 是 Input/Output 的缩写，它是基于流模型实现的，比如操作文件时使用输入流和输出流来写入和读取文件等。

IO 分类
传统的 IO，按照流类型我们可以分为：

字符流
字节流
其中，字符流包括 Reader、Writer；字节流包括 InputStream、OutputStream。
传统 IO 的类关系图，如下图所示：

avatar

IO 使用
了解了 IO 之间的关系，下面我们正式进入实战环节，分别来看字符流（Reader、Writer）和字节流（InputStream、OutputStream）的使用。

① Writer 使用
Writer 可用来写入文件，请参考以下代码：

// 给指定目录下的文件追加信息
Writer writer = new FileWriter(“d:\io.txt”,true);
writer.append(“老王”);
writer.close();
这几行简单的代码就可以实现把信息老王追加到 d:\io.txt 的文件下，参数二表示的是覆盖文字还是追加文字。

② Reader 使用
Reader 可用来读取文件，请参考以下代码：

Reader reader = new FileReader(“d:\io.txt”);
BufferedReader bufferedReader = new BufferedReader(reader);
String str = null;
// 逐行读取信息
while (null != (str = bufferedReader.readLine())) {
System.out.println(str);
}
bufferedReader.close();
reader.close();
③ InputStream 使用
InputStream 可用来读取文件，请参考以下代码：

InputStream inputStream = new FileInputStream(new File(“d:\io.txt”));
byte[] bytes = new byte[inputStream.available()];
// 读取到 byte 数组
inputStream.read(bytes);
// 内容转换为字符串
String content = new String(bytes, “UTF-8”);
inputStream.close();
④ OutputStream 使用
OutputStream 可用来写入文件，请参考以下代码：

OutputStream outputStream = new FileOutputStream(new File(“d:\io.txt”),true);
outputStream.write(“老王”.getBytes());
outputStream.close();
NIO 介绍
上面讲的内容都是 java.io 包下的知识点，但随着 Java 的不断发展，在 Java 1.4 时新的 IO 包出现了 java.nio，NIO（Non-Blocking IO）的出现解决了传统 IO，也就是我们经常说的 BIO（Blocking IO）同步阻塞的问题，NIO 提供了 Channel、Selector 和 Buffer 等概念，可以实现多路复用和同步非阻塞 IO 操作，从而大大提升了 IO 操作的性能。
前面提到同步和阻塞的问题，那下面来看看同步和阻塞结合都有哪些含义。

组合方式性能分析
同步阻塞最常用的一种用法，使用也是最简单的，但是 I/O 性能一般很差，CPU 大部分在空闲状态
同步非阻塞提升 I/O 性能的常用手段，就是将 I/O 的阻塞改成非阻塞方式，尤其在网络 I/O 是长连接，同时传输数据也不是很多的情况下，提升性能非常有效。这种方式通常能提升 I/O 性能，但是会增加 CPU 消耗，要考虑增加的 I/O 性能能不能补偿 CPU 的消耗，也就是系统的瓶颈是在 I/O 还是在 CPU 上
异步阻塞这种方式在分布式数据库中经常用到。例如，在往一个分布式数据库中写一条记录，通常会有一份是同步阻塞的记录，而还有两至三份是备份记录会写到其他机器上，这些备份记录通常都是采用异步阻塞的方式写 I/O；异步阻塞对网络 I/O 能够提升效率，尤其像上面这种同时写多份相同数据的情况
异步非阻塞这种组合方式用起来比较复杂，只有在一些非常复杂的分布式情况下使用，像集群之间的消息同步机制一般用这种 I/O 组合方式。例如，Cassandra 的 Gossip 通信机制就是采用异步非阻塞的方式。它适合同时要传多份相同的数据到集群中不同的机器，同时数据的传输量虽然不大，但是却非常频繁。这种网络 I/O 用这个方式性能能达到最高
了解了同步和阻塞的含义，下面来看 NIO 的具体使用，请参考以下代码：

int port = 6666;
new Thread(new Runnable() {
@Override
public void run() {
try (Selector selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()? {
serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select(); // 阻塞等待就绪的 Channel
Set selectionKeys = selector.selectedKeys();
Iterator iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
try (SocketChannel channel = ((ServerSocketChannel) key.channel()).accept()) {
channel.write(Charset.defaultCharset().encode(“老王，你好~”));
}
iterator.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();

new Thread(new Runnable() {
@Override
public void run() {
// Socket 客户端 1（接收信息并打印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
bufferedReader.lines().forEach(s -> System.out.println(“客户端 1 打印：” + s));
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();

new Thread(new Runnable() {
@Override
public void run() {
// Socket 客户端 2（接收信息并打印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
bufferedReader.lines().forEach(s -> System.out.println(“客户端 2 打印：” + s));
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
以上代码创建了两个 Socket 客户端，用于收取和打印服务器端的消息。
其中，服务器端通过 SelectionKey（选择键）获取到 SocketChannel（通道），而通道都注册到 Selector（选择器）上，所有的客户端都可以获得对应的通道，而不是所有客户端都排队堵塞等待一个服务器连接，这样就实现多路复用的效果了。多路指的是多个通道（SocketChannel），而复用指的是一个服务器端连接重复被不同的客户端使用。

AIO 介绍
AIO（Asynchronous IO）是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。
AIO 实现简单的 Socket 服务器，代码如下：

int port = 8888;
new Thread(new Runnable() {
@Override
public void run() {
AsynchronousChannelGroup group = null;
try {
group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4));
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() {
@Override
public void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) {
server.accept(null, this); // 接收下一个请求
try {
Future f = result.write(Charset.defaultCharset().encode(“Hi, 老王”));
f.get();
System.out.println(“服务端发送时间：” + DateFormat.getDateTimeInstance().format(new Date()));
result.close();
} catch (InterruptedException | ExecutionException | IOException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
}
});
group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}).start();

// Socket 客户端
AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
Future future = client.connect(new InetSocketAddress(InetAddress.getLocalHost(), port));
future.get();
ByteBuffer buffer = ByteBuffer.allocate(100);
client.read(buffer, null, new CompletionHandler<Integer, Void>() {
@Override
public void completed(Integer result, Void attachment) {
System.out.println(“客户端打印：” + new String(buffer.array()));
}

@Override
public void failed(Throwable exc, Void attachment) {
    exc.printStackTrace();
    try {
        client.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

});
Thread.sleep(10 * 1000);
相关面试题
1.使用以下哪个方法来判断一个文件是否存在？
A：createFile
B：exists
C：read
D：exist

答：B

2.以下说法错误的是？
A：同步操作不一定会阻塞
B：异步操作不一定会阻塞
C：阻塞一定是同步操作
D：同步或异步都可能会阻塞

答：C

题目解析：异步操作也可能会阻塞，比如分布式集群消息同步，采用的就是异步阻塞的方式。

3.BIO、NIO、AIO 的区别是什么？
答：它们三者的区别如下。

BIO 就是传统的 java.io 包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。它的优点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。
NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer 等新的抽象，可以构建多路复用的、同步非阻塞 IO 程序，同时提供了更接近操作系统底层高性能的数据操作方式。
AIO 是 Java 1.7 之后引入的包，是 NIO 的升级版本，提供了异步非堵塞的 IO 操作方式，因此人们叫它 AIO（Asynchronous IO），异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
简单来说 BIO 就是传统 IO 包，产生的最早；NIO 是对 BIO 的改进提供了多路复用的同步非阻塞 IO，而 AIO 是 NIO 的升级，提供了异步非阻塞 IO。

4.读取和写入文件最简洁的方式是什么？
答：使用 Java 7 提供的 Files 读取和写入文件是最简洁，请参考以下代码：

// 读取文件
byte[] bytes = Files.readAllBytes(Paths.get(“d:\io.txt”));
// 写入文件
Files.write(Paths.get(“d:\io.txt”), “追加内容”.getBytes(), StandardOpenOption.APPEND);
读取和写入都是一行代码搞定，可以说很简洁了。

5.Files 常用方法都有哪些？
答：Files 是 Java 1.7 提供的，使得文件和文件夹的操作更加方便，它的常用方法有以下几个：

Files. exists()：检测文件路径是否存在
Files. createFile()：创建文件
Files. createDirectory()：创建文件夹
Files. delete()：删除一个文件或目录
Files. copy()：复制文件
Files. move()：移动文件
Files. size()：查看文件个数
Files. read()：读取文件
Files. write()：写入文件
6.FileInputStream 可以实现什么功能？
答：FileInputStream 可以实现文件的读取。

题目解析：因为 FileInputStream 和 FileOutputStream 很容易被记反，FileOutputStream 才是用来写入文件的，所以也经常被面试官问到。

7.不定项选择：为了提高读写性能，可以采用什么流？
A：InputStream
B：DataInputStream
C：BufferedReader
D：BufferedInputStream
E：OutputStream
F：BufferedOutputStream

答：D、F

题目解析：BufferedInputStream 是一种带缓存区的输入流，在读取字节数据时可以从底层流中一次性读取多个字节到缓存区，而不必每次都调用系统底层；同理，BufferedOutputStream 也是一种带缓冲区的输出流，通过缓冲区输出流，应用程序先把字节写入缓冲区，缓存区满后再调用操作系统底层，从而提高系统性能，而不必每次都去调用系统底层方法。

8.FileInputStream 和 BufferedInputStream 的区别是什么？
答：FileInputStream 在小文件读写时性能较好，而在大文件操作时使用 BufferedInputStream 更有优势。

9.以下这段代码运行在 Windwos 平台，执行的结果是？
Files.createFile(Paths.get(“c:\pf.txt”), PosixFilePermissions.asFileAttribute(
EnumSet.of(PosixFilePermission.OWNER_READ)));
A：在指定的盘符产生了对应的文件，文件只读
B：在指定的盘符产生了对应的文件，文件只写
C：在指定的盘符产生了对应的文件，文件可读写
D：程序报错

答：D

题目解析：本题目考察的是 Files.createFile 参数传递的问题，PosixFilePermissions 不支持 Windows，因此在 Windows 执行会报错 java.lang.UnsupportedOperationException: ‘posix:permissions’ not supported as initial attribute。

总结
在 Java 1.4 之前只有 BIO（Blocking IO）可供使用，也就是 java.io 包下的那些类，它的缺点是同步阻塞式运行的。随后在 Java 1.4 时，提供了 NIO（Non-Blocking IO）属于 BIO 的升级，提供了同步非阻塞的 IO 操作方式，它的重要组件是 Selector（选择器）、Channel（通道）、Buffer（高效数据容器）实现了多路复用的高效 IO 操作。而 AIO（Asynchronous IO）也叫 NIO 2.0，属于 NIO 的补充和升级，提供了异步非阻塞的 IO 操作。

还有另一个重要的知识点，是 Java 7.0 时新增的 Files 类，极大地提升了文件操作的便利性，比如读、写文件 Files.write()、Files.readAllBytes() 等，都是非常简便和实用的方法。

2、JDK 原生动态代理是怎么实现的

反射
反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect）的能力。简单来说就是通过反射，可以在运行期间获取、检测和调用对象的属性和方法。

反射的使用场景
在现实中反射的使用场景有很多，比如以下几个。

使用场景一：编程工具 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，就是因为使用了反射。

使用场景二：很多知名的框架，为了让程序更优雅更简洁，也会使用到反射。

例如，Spring 可以通过配置来加载不同的类，调用不同的方法，代码如下所示：

例如，MyBatis 在 Mapper 使用外部类的 SQL 构建查询时，代码如下所示：

@SelectProvider(type = PersonSql.class, method = “getListSql”)
List getList();
class PersonSql {
public String getListSql() {
String sql = new SQL() {{
SELECT("*");
FROM(“person”);
}}.toString();
return sql;
}
}
使用场景三：数据库连接池，也会使用反射调用不同类型的数据库驱动，代码如下所示：

String url = “jdbc:mysql://127.0.0.1:3306/mydb”;
String username = “root”;
String password = “root”;
Class.forName(“com.mysql.jdbc.Driver”);
Connection connection = DriverManager.getConnection(url, username, password);
当然反射还有其他很多类似的使用场景，这里就不一一列举，读者可以举一反三，想想在平常的开发中，还有哪些使用了反射功能的场景。

反射的基本使用
下来我们通过反射调用类中的某个方法，来学习反射的基本使用。

使用反射调用类中的方法，分为三种情况：

调用静态方法
调用公共方法
调用私有方法
假设有一个实体类 MyReflect 包含了以上三种方法，代码如下：

package com.interview.chapter4;
class MyReflect {
// 静态方法
public static void staticMd() {
System.out.println(“Static Method”);
}
// 公共方法
public void publicMd() {
System.out.println(“Public Method”);
}
// 私有方法
private void privateMd() {
System.out.println(“Private Method”);
}
}
下面分别来看，使用反射如何调用以上三种类型的方法。

① 反射调用静态方法
Class myClass = Class.forName(“com.interview.chapter4.MyReflect”);
Method method = myClass.getMethod(“staticMd”);
method.invoke(myClass);
② 反射调用公共方法
Class myClass = Class.forName(“com.interview.chapter4.MyReflect”);
// 创建实例对象（相当于 new ）
Object instance = myClass.newInstance();
Method method2 = myClass.getMethod(“publicMd”);
method2.invoke(instance);
③ 反射调用私有方法
Class myClass = Class.forName(“com.interview.chapter4.MyReflect”);
// 创建实例对象（相当于 new ）
Object object = myClass.newInstance();
Method method3 = myClass.getDeclaredMethod(“privateMd”);
method3.setAccessible(true);
method3.invoke(object);
反射使用总结
反射获取调用类可以通过 Class.forName()，反射获取类实例要通过 newInstance()，相当于 new 一个新对象，反射获取方法要通过 getMethod()，获取到类方法之后使用 invoke() 对类方法进行调用。如果是类方法为私有方法的话，则需要通过 setAccessible(true) 来修改方法的访问限制，以上的这些操作就是反射的基本使用。

动态代理
动态代理可以理解为，本来应该自己做的事情，却交给别人代为处理，这个过程就叫做动态代理。

动态代理的使用场景
动态代理被广为人知的使用场景是 Spring 中的面向切面编程（AOP）。例如，依赖注入 @Autowired 和事务注解 @Transactional 等，都是利用动态代理实现的。

动态代理还可以封装一些 RPC 调用，也可以通过代理实现一个全局拦截器等。

动态代理和反射的关系
JDK 原生提供的动态代理就是通过反射实现的，但动态代理的实现方式还可以是 ASM（一个短小精悍的字节码操作框架）、cglib（基于 ASM）等，并不局限于反射。

下面我们分别来看：JDK 原生动态代理和 cglib 的实现。

1）JDK 原生动态代理
interface Animal {
void eat();
}
class Dog implements Animal {
@Override
public void eat() {
System.out.println(“The dog is eating”);
}
}
class Cat implements Animal {
@Override
public void eat() {
System.out.println(“The cat is eating”);
}
}

// JDK 代理类
class AnimalProxy implements InvocationHandler {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
// 取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(“调用前”);
Object result = method.invoke(target, args); // 方法调用
System.out.println(“调用后”);
return result;
}
}

public static void main(String[] args) {
// JDK 动态代理调用
AnimalProxy proxy = new AnimalProxy();
Animal dogProxy = (Animal) proxy.getInstance(new Dog());
dogProxy.eat();
}
以上代码，我们实现了通过动态代理，在所有请求前、后都打印了一个简单的信息。

注意： JDK Proxy 只能代理实现接口的类（即使是 extends 继承类也是不可以代理的）。

2）cglib 动态代理
要是用 cglib 实现要添加对 cglib 的引用，如果是 maven 项目的话，直接添加以下代码：

cglib cglib 3.2.12 cglib 的具体实现，请参考以下代码：

class Panda {
public void eat() {
System.out.println(“The panda is eating”);
}
}
class CglibProxy implements MethodInterceptor {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
// 设置父类为实例类
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println(“调用前”);
Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
System.out.println(“调用后”);
return result;
}
}
public static void main(String[] args) {
// cglib 动态代理调用
CglibProxy proxy = new CglibProxy();
Panda panda = (Panda)proxy.getInstance(new Panda());
panda.eat();
}
以上程序执行的结果：

调用前

The panda is eating

调用后

由以上代码可以知道，cglib 的调用通过实现 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 进行动态代理的。它可以直接对普通类进行动态代理，并不需要像 JDK 代理那样，需要通过接口来完成，值得一提的是 Spring 的动态代理也是通过 cglib 实现的。

注意：cglib 底层是通过子类继承被代理对象的方式实现动态代理的，因此代理类不能是最终类（final），否则就会报错 java.lang.IllegalArgumentException: Cannot subclass final class xxx。

相关面试题
1.动态代理解决了什么问题？
答：首先它是一个代理机制，如果熟悉设计模式中的代理模式，我们会知道，代理可以看作是对调用目标的一个包装，这样我们对目标代码的调用不是直接发生的，而是通过代理完成，通过代理可以让调用者与实现者之间解耦。比如进行 RPC 调用，通过代理，可以提供更加友善的界面；还可以通过代理，做一个全局的拦截器。

2.动态代理和反射的关系是什么？
答：反射可以用来实现动态代理，但动态代理还有其他的实现方式，比如 ASM（一个短小精悍的字节码操作框架）、cglib 等。

3.以下描述错误的是？
A：cglib 的性能更高
B：Spring 中有使用 cglib 来实现动态代理
C：Spring 中有使用 JDK 原生的动态代理
D：JDK 原生动态代理性能更高

答：D

题目解析：Spring 动态代理的实现方式有两种：cglib 和 JDK 原生动态代理。

4.请补全以下代码？
class MyReflect {
// 私有方法
private void privateMd() {
System.out.println(“Private Method”);
}
}
class ReflectTest {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
Class myClass = Class.forName(“MyReflect”);
Object object = myClass.newInstance();
// 补充此行代码
method.setAccessible(true);
method.invoke(object);
}
}
答：Method method = myClass.getDeclaredMethod(“privateMd”);

题目解析：此题主要考的是私有方法的获取，私有方法的获取并不是通过 getMethod() 方式，而是通过 getDeclaredMethod() 获取的。

5.cglib 可以代理任何类这句话对吗？为什么？
答：这句话不完全对，因为 cglib 只能代理可以有子类的普通类，对于像最终类（final），cglib 是不能实现动态代理的，因为 cglib 的底层是通过继承代理类的子类来实现动态代理的，所以不能被继承类无法使用 cglib。

6.JDK 原生动态代理和 cglib 有什么区别？
答：JDK 原生动态代理和 cglib 区别如下：

JDK 原生动态代理是基于接口实现的，不需要添加任何依赖，可以平滑的支持 JDK 版本的升级；
cglib 不需要实现接口，可以直接代理普通类，需要添加依赖包，性能更高。
7.为什么 JDK 原生的动态代理必须要通过接口来完成？
答：这是由于 JDK 原生设计的原因，来看动态代理的实现方法 newProxyInstance() 的源码：

/**

…
@param loader the class loader to define the proxy class
@param interfaces the list of interfaces for the proxy class to implement
…
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 省略其他代码
来看前两个参数的声明：

loader：为类加载器，也就是 target.getClass().getClassLoader()
interfaces：接口代理类的接口实现列表
看了上面的参数说明，我们就明白了，要使用 JDK 原生的动态只能通过实现接口来完成。

总结
通过本文可以知道 JDK 原生动态代理是使用反射实现的，但动态代理的实现方式不止有反射，还可以是 ASM（一个短小精悍的字节码操作框架）、cglib（基于 ASM）等。其中 JDK 原生的动态代理是通过接口实现的，而 cglib 是通过子类实现的，因此 cglib 不能代理最终类（final）。而反射不但可以反射调用静态方法，还可以反射调用普通方法和私有方法，其中调用私有方法时要设置 setAccessible 为 true。