开篇
在设计模式中有一种叫做装饰者模式，刚好BufferedReader的源码是这个设计模式的最好例子，一并看下源码。
源码分析
构造函数
- BufferedReader的类变量的Reader in 用以构造函数参数中的Reader in参数，BufferedReader的所有读写操作都通过Reader对象进行操作。
- BufferedReader相当于针对内部的Reader对象进行了一层包装，可以理解为装饰者。
public class BufferedReader extends Reader {
private Reader in;
private char cb[];
//nextChar代表下次要读取的位置，nChars表示总共的字符个数
private int nChars, nextChar;
private static final int INVALIDATED = -2;
private static final int UNMARKED = -1;
private int markedChar = UNMARKED;
private int readAheadLimit = 0; /* Valid only when markedChar > 0 */
private boolean skipLF = false;
private boolean markedSkipLF = false;
private static int defaultCharBufferSize = 8192;
private static int defaultExpectedLineLength = 80;
public BufferedReader(Reader in, int sz) {
super(in);
if (sz <= 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.in = in;
cb = new char[sz];
nextChar = nChars = 0;
}
public BufferedReader(Reader in) {
this(in, defaultCharBufferSize);
}
}
加载数据
- 负责通过Reader in对象读取字符到指定数量的字符数据到cb数组当中。
- dst表示保存数据的起始位置，cb.length-dst表示读取字符的个数。
- 在执行read和readline操作的之前如果cb当中可读字符不足会先执行fill()读取字符。
private void fill() throws IOException {
int dst;
if (markedChar <= UNMARKED) {
/* No mark */
dst = 0;
} else {
// 省略一部分代码
}
int n;
do {
// 从底层input读取数据到cb，cb中起始位置是dst,
// 读取的长度是cb的lenght减去起始位置dst，理解剩余能够装的字符
n = in.read(cb, dst, cb.length - dst);
} while (n == 0);
if (n > 0) {
// 设置最大可读字符结束位置
nChars = dst + n;
// 设置可读字符的起始位置
nextChar = dst;
}
}
read过程
- 读取过程中如果满足条件（nextChar 表示下一个读取字符>= nChars可用字符），代表字符已经读取完毕那么就通过fill()进行预加载。
- 读取当前字符并累加当前可读取字符，执行nextChar++操作。
public int read() throws IOException {
synchronized (lock) {
ensureOpen();
for (;;) {
if (nextChar >= nChars) {
fill();
if (nextChar >= nChars)
return -1;
}
if (skipLF) {
skipLF = false;
if (cb[nextChar] == '\n') {
nextChar++;
continue;
}
}
// 读取当前字符并累加下一个读取位置
return cb[nextChar++];
}
}
}
readline过程
- 读取过程中如果满足条件（nextChar 表示下一个读取字符>= nChars可用字符），代表字符已经读取完毕那么就通过fill()进行预加载。
- 读取过程中如果遇到\r\n则中断循环，通过str = new String(cb, startChar, i - startChar)返回整行数据。
String readLine(boolean ignoreLF) throws IOException {
//读取的数据最终放在这个s中，
StringBuffer s = null;
int startChar;
synchronized (lock) {
ensureOpen();
boolean omitLF = ignoreLF || skipLF;
bufferLoop:
for (;;) {
if (nextChar >= nChars)
fill();
if (nextChar >= nChars) { /* EOF */
if (s != null && s.length() > 0)
//从这里返回，可能是因为读取的数据最后没有以\n或\r结束
return s.toString();
else
// 从这里返回，是因为开始读的时候，就已经是input的末尾了，
// 所以s本身就没有被初始化，只能返回null
return null;
}
boolean eol = false;
char c = 0;
int i;
/* Skip a leftover '\n', if necessary */
if (omitLF && (cb[nextChar] == '\n'))
nextChar++;
skipLF = false;
omitLF = false;
charLoop:
for (i = nextChar; i < nChars; i++) {
c = cb[i];
if ((c == '\n') || (c == '\r')) {
eol = true;
break charLoop;
}
}
startChar = nextChar;
nextChar = i;
if (eol) {
String str;
// 运行到这，s为null，说明是第一次循环中就读到了行尾。
if (s == null) {
str = new String(cb, startChar, i - startChar);
} else {
// 运行到这，起码说明是第二次循环了，s里已经有了第一次读取的数据
s.append(cb, startChar, i - startChar);
str = s.toString();
}
nextChar++;
if (c == '\r') {
skipLF = true;
}
// 运行到这说明读到了行尾，返回str
return str;
}
if (s == null)
s = new StringBuffer(defaultExpectedLineLength);
// 运行到这说明，读取了整个cb的数据，发现一直没有\n或者\r,
// 之后回到最初循环继续读取。
s.append(cb, startChar, i - startChar);
}
}
}
类依赖图
-
BufferedReader的类依赖图如下图，所有的io reader都是继承自Reader作为基类。
装饰设计模式
装饰设计模式：javaIO技术中的装饰设计模式，对一组对象的功能进行增强时，就可以使用该设计模式
