Java 字符编码(二)Java 中的编解码

时间:2021-03-14 15:34:51

Java 字符编码(二)Java 中的编解码

java.nio.charset 包中提供了一套处理字符编码的工具类,主要有 Charset、CharsetDecoder、CharsetEncoder、CoderResult、StandardCharsets 这几个类。

Java 中的字符使用 Unicode 编码,每个字符占用两个字节,16 个二进制位,向 ByteBuffer 中存放数据的时候需要考虑字符的编码,从中读取的时候也需要考虑字符的编码方式,也就是编码和解码。

一、CharSet

1.1 获取字符集

// 返回指定的字符集 CharSet
Charset charset = Charset.forName("utf8");
// 返回虚拟机默认的字符集 CharSet
Charset charset = Charset.defaultCharset();

forName -> lookup -> lookup2,其中 lookup 会缓存正在使用的 Charset 编码方式,lookup2 则真正用于获取对应的编码方式。

private static Charset lookup2(String charsetName) {
...
Charset cs;
if ((cs = standardProvider.charsetForName(charsetName)) != null ||
(cs = lookupExtendedCharset(charsetName)) != null ||
(cs = lookupViaProviders(charsetName)) != null) {
return cs;
}
return null;
}

可以看到 Charset 有三种定义方式:

  • standardProvider JDK 定义的标准格式,如 UTF-8,UTF-16
  • extendedProvider JDK 扩展的标准格式
  • CharsetProvider SPI,通过 java.nio.charset.spi.CharsetProvider 自定义的格式

1.2 编码和解码

// ThreadLocalCoders.decoderFor(this) 调用 newDecoder 缓存了正在使用的缓解码器
public final CharBuffer decode(ByteBuffer bb) {
try {
return ThreadLocalCoders.decoderFor(this)
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE)
.decode(bb);
} catch (CharacterCodingException x) {
throw new Error(x); // Can't happen
}
} public final ByteBuffer encode(CharBuffer cb) {
try {
return ThreadLocalCoders.encoderFor(this)
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE)
.encode(cb);
} catch (CharacterCodingException x) {
throw new Error(x); // Can't happen
}
}

1.3 编码器和解码器

newEncoder 和 newDecoder 是 Charset 中最重要的两个抽象方法:

//编码器
CharsetEncoder encoder = charset.newEncoder();
//解码器
CharsetDecoder decoder = charset.newDecoder();

CharsetDecoder 将 ByteBuffer 解码为 CharBuffer,而 CharsetEncoder 则相反,将 CharBuffer 编码为 ByteBuffer。

在讲解 CharsetDecoder 前先了解一下 CoderResult,这个类封装了编解码的结果,主要用于处理异常。

二、CoderResult

2.1 CoderResult 有以下几种状态

# ByteBuffer 解码完成
private static final int CR_UNDERFLOW = 0;
# CharBuffer 空间不足,解码完成
private static final int CR_OVERFLOW = 1;
private static final int CR_ERROR_MIN = 2;
# ByteBuffer 解码异常
private static final int CR_MALFORMED = 2;
# ByteBuffer 超出了 Unicode 定义的范围,eg: 0xD800-0xDFFF 或 >0x10FFFF
# Unicode 在编写的时候已经考虑了编解码的问题
private static final int CR_UNMAPPABLE = 3;

其中 CR_UNDERFLOW(解码完成) 和 CR_OVERFLOW(CharBuffer 空间不足) 属于正常状态,CR_MALFORMED(字节码出错) 和 CR_UNMAPPABLE(不能映射到 Unicode 上) 属性异常状态。

2.2 CoderResult 重要属性及方法

// 对应 CR_UNDERFLOW、CR_OVERFLOW、CR_MALFORMED、CR_UNMAPPABLE
private final int type;
// 如果解码正常(也就是前两种状态)为 0,如果异常(后两种状态)对应解码出错的长度
private final int length;

isUnderflow()、isOverflow()、isError()、isMalformed()、isUnmappable() 等方法用于判断解码的状态。下面四个静态方法则用于构建解码的结果。

// 解码正常
public static final CoderResult UNDERFLOW = new CoderResult(CR_UNDERFLOW, 0);
public static final CoderResult OVERFLOW = new CoderResult(CR_OVERFLOW, 0); // 解码异常
public static CoderResult malformedForLength(int length) {
return malformedCache.get(length);
}
public static CoderResult unmappableForLength(int length) {
return unmappableCache.get(length);
}

三、CharsetDecoder

CharsetDecoder 最重要的方法是 decode(in, out, endOfInput) ,控制了解码的流程,最重要的模板方法是 decodeLoop(in, out) ,由子类实现。CharsetDecoder 的实现类位于 sun.nio.cs 下,如 UTF_8、UTF_16、UTF_32 等。

CharsetDecoder 解码的流程如下,包含了四种状态:

  1. 首先执行 reset() 方法,将 state=ST_RESET
  2. (可选)多次执行 decode(in, out, false) 方法,注意此时传入 false
  3. 执行 decode(in, out, true) 方法,注意此时传入 true,此时解码完成
  4. (可选)执行 flush(out) 方法,更新内部状态

3.1 decode(in, out, endOfInput)

这个方法有 3 个参数,前两个参数不用解释,第三个参数用来控制解码是否完成,如按 UTF-8 解码时最后只剩下一下字节,这时可能是流读取还未结束,需要继续读取,此时不能算做异常,这时就需要有 endOfInput 来控制。针对流的编解码见 StreamDecoder。

public final CoderResult decode(ByteBuffer in, CharBuffer out,
boolean endOfInput) {
// 1. state 只能为 ST_RESET、ST_CODING 或 ST_END(endOfInput=true)
int newState = endOfInput ? ST_END : ST_CODING;
if ((state != ST_RESET) && (state != ST_CODING)
&& !(endOfInput && (state == ST_END)))
throwIllegalStateException(state, newState);
state = newState; for (;;) { CoderResult cr;
try {
// 2. decodeLoop 完成解码
cr = decodeLoop(in, out);
} catch (BufferUnderflowException x) {
throw new CoderMalfunctionError(x);
} catch (BufferOverflowException x) {
throw new CoderMalfunctionError(x);
} // 2. CharBuffer 空间不足
if (cr.isOverflow())
return cr; // 3. 解码完成,如果 endOfInput=false 则会先返回,由调用者继续调用该方法解码
if (cr.isUnderflow()) {
if (endOfInput && in.hasRemaining()) {
cr = CoderResult.malformedForLength(in.remaining());
// Fall through to malformed-input case
} else {
return cr;
}
} // 3. 解码出现异常时的处理,默认为 REPORT,即由上层处理异常
CodingErrorAction action = null;
if (cr.isMalformed())
action = malformedInputAction;
else if (cr.isUnmappable())
action = unmappableCharacterAction;
else
assert false : cr.toString(); // 3.1 REPORT 由上层处理异常
if (action == CodingErrorAction.REPORT)
return cr;
// 3.2 REPLACE 追加了 replacement 字符
if (action == CodingErrorAction.REPLACE) {
if (out.remaining() < replacement.length())
return CoderResult.OVERFLOW;
out.put(replacement);
}
// 3.3 IGNORE 和 REPLACE 都忽略这种异常继续解码
if ((action == CodingErrorAction.IGNORE)
|| (action == CodingErrorAction.REPLACE)) {
// Skip erroneous input either way
in.position(in.position() + cr.length());
continue;
} assert false;
} }

3.2 decode(ByteBuffer in)

CharsetDecoder 的 decode(ByteBuffer in) 方法将 ByteBuffer 解码为 CharBuffer,这个方法调用了上面的方法,传入的 endOfInput=true。但需要注意的是如果数据是从文件流等读取时,ByteBuffer 数据可能并不完整,出现半包的情况,进而导致解码异常,这时就需要使用上面的方法(参数 endOfInput)精确控制解码的流程了。

public final CharBuffer decode(ByteBuffer in) throws CharacterCodingException {
int n = (int)(in.remaining() * averageCharsPerByte());
CharBuffer out = CharBuffer.allocate(n); if ((n == 0) && (in.remaining() == 0))
return out;
reset();
for (;;) {
CoderResult cr = in.hasRemaining() ?
decode(in, out, true) : CoderResult.UNDERFLOW; // 1. 解码完成,调用 flush 并结束
if (cr.isUnderflow())
cr = flush(out);
if (cr.isUnderflow())
break; // 2. CharBuffer 空间不足,扩容,继续解码
if (cr.isOverflow()) {
n = 2*n + 1; // Ensure progress; n might be 0!
CharBuffer o = CharBuffer.allocate(n);
out.flip();
o.put(out);
out = o;
continue;
} // 3. 解码异常,直接抛出
cr.throwException();
}
out.flip();
return out;
}

每天用心记录一点点。内容也许不重要,但习惯很重要!