概述
Springboot-application.properties中文乱码
Springboot-application.properties编码问题 设置application.properties为utf-8读取配置的中文结果打印分析
设置application.properties为utf-8
UTF-8,这样在windows和linux服务器中查看配置文件都能正常显示中文。否则可能中文无法正常显示。
application.properties中配置如下：
demo.to-who=张三
读取配置的中文
@RestController
public class TestController {
@Value("${demo.to-who}")
private String toWho;
@RequestMapping("/test2")
public Object test2() throws UnsupportedEncodingException {
System.out.println(toWho);
System.out.println(new String(toWho.getBytes("iso8859-1")));
System.out.println(new String(toWho.getBytes("iso8859-1"), "utf-8"));
return null;
}
}
结果打印
需要将数据编码从iso8859-1转为utf-8才可正常使用。
å¼ ä¸‰
张三
张三
分析
源码中
private static class CharacterReader implements Closeable {
// 其他代码省略
CharacterReader(Resource resource) throws IOException {
this.reader = new LineNumberReader(new InputStreamReader(
resource.getInputStream(), StandardCharsets.ISO_8859_1));
}
// 其他代码省略
}
也就是说不论application.properties文件被设置为哪种编码格式，最终还是以ISO-8859-1的编码格式进行加载。
而yml/yaml默认以UTF-8加载
Springboot配置文件application.properties支持中文
版本说明
本文不完全基于springboot-2.4.5，各版本需要重写类的逻辑各有不同，本文的代码只可模仿，不可复制
为什么不支持中文
PropertySourceLoader接口
先看读取配置文件的接口 org.springframework.boot.env.PropertySourceLoader
Strategy interface located via {@link SpringFactoriesLoader} and used to load a {@link PropertySource}.
意思是说通过META-INF/spring.factories配置文件加载
PropertiesPropertySourceLoader类
接口 org.springframework.boot.env.PropertySourceLoader下有两个默认实现
org.springframework.boot.env.YamlPropertySourceLoader负责读取yml文件，
org.springframework.boot.env.PropertiesPropertySourceLoader负责读取properties和xml文件
OriginTrackedPropertiesLoader类
可以看出org.springframework.boot.env.OriginTrackedPropertiesLoader.CharacterReader类
以ISO_8859_1编码方式读取properties文件
重写读取application.properties文件的逻辑
使SpringBoot配置文件application.properties支持中文
1.创建OriginTrackedPropertiesLoader文件
复制org.springframework.boot.env.OriginTrackedPropertiesLoader文件内容，并修改ISO_8859_1编码为UTF_8编码
package com.xxx.config;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BooleanSupplier;
import org.springframework.boot.origin.Origin;
import org.springframework.boot.origin.OriginTrackedValue;
import org.springframework.boot.origin.TextResourceOrigin;
import org.springframework.boot.origin.TextResourceOrigin.Location;
import org.springframework.core.io.Resource;
import org.springframework.util.Assert;
/**
* Class to load {@code .properties} files into a map of {@code String} ->
* {@link OriginTrackedValue}. Also supports expansion of {@code name[]=a,b,c} list style
* values.
*
* @author Madhura Bhave
* @author Phillip Webb
* @author Thiago Hirata
*/
public class MyOriginTrackedPropertiesLoader {
private final Resource resource;
/**
* Create a new {@link OriginTrackedPropertiesLoader} instance.
* @param resource the resource of the {@code .properties} data
*/
MyOriginTrackedPropertiesLoader(Resource resource) {
Assert.notNull(resource, "Resource must not be null");
this.resource = resource;
}
/**
* Load {@code .properties} data and return a list of documents.
* @return the loaded properties
* @throws IOException on read error
*/
List<Document> load() throws IOException {
return load(true);
}
/**
* Load {@code .properties} data and return a map of {@code String} ->
* {@link OriginTrackedValue}.
* @param expandLists if list {@code name[]=a,b,c} shortcuts should be expanded
* @return the loaded properties
* @throws IOException on read error
*/
List<Document> load(boolean expandLists) throws IOException {
List<Document> documents = new ArrayList<>();
Document document = new Document();
StringBuilder buffer = new StringBuilder();
try (CharacterReader reader = new CharacterReader(this.resource)) {
while (reader.read()) {
if (reader.isPoundCharacter()) {
if (isNewDocument(reader)) {
if (!document.isEmpty()) {
documents.add(document);
}
document = new Document();
}
else {
if (document.isEmpty() && !documents.isEmpty()) {
document = documents.remove(documents.size() - 1);
}
reader.setLastLineComment(true);
reader.skipComment();
}
}
else {
reader.setLastLineComment(false);
loadKeyAndValue(expandLists, document, reader, buffer);
}
}
}
if (!document.isEmpty() && !documents.contains(document)) {
documents.add(document);
}
return documents;
}
private void loadKeyAndValue(boolean expandLists, Document document, CharacterReader reader, StringBuilder buffer)
throws IOException {
String key = loadKey(buffer, reader).trim();
if (expandLists && key.endsWith("[]")) {
key = key.substring(0, key.length() - 2);
int index = 0;
do {
OriginTrackedValue value = loadValue(buffer, reader, true);
document.put(key + "[" + (index++) + "]", value);
if (!reader.isEndOfLine()) {
reader.read();
}
}
while (!reader.isEndOfLine());
}
else {
OriginTrackedValue value = loadValue(buffer, reader, false);
document.put(key, value);
}
}
private String loadKey(StringBuilder buffer, CharacterReader reader) throws IOException {
buffer.setLength(0);
boolean previousWhitespace = false;
while (!reader.isEndOfLine()) {
if (reader.isPropertyDelimiter()) {
reader.read();
return buffer.toString();
}
if (!reader.isWhiteSpace() && previousWhitespace) {
return buffer.toString();
}
previousWhitespace = reader.isWhiteSpace();
buffer.append(reader.getCharacter());
reader.read();
}
return buffer.toString();
}
private OriginTrackedValue loadValue(StringBuilder buffer, CharacterReader reader, boolean splitLists)
throws IOException {
buffer.setLength(0);
while (reader.isWhiteSpace() && !reader.isEndOfLine()) {
reader.read();
}
Location location = reader.getLocation();
while (!reader.isEndOfLine() && !(splitLists && reader.isListDelimiter())) {
buffer.append(reader.getCharacter());
reader.read();
}
Origin origin = new TextResourceOrigin(this.resource, location);
return OriginTrackedValue.of(buffer.toString(), origin);
}
private boolean isNewDocument(CharacterReader reader) throws IOException {
if (reader.isLastLineComment()) {
return false;
}
boolean result = reader.getLocation().getColumn() == 0 && reader.isPoundCharacter();
result = result && readAndExpect(reader, reader::isHyphenCharacter);
result = result && readAndExpect(reader, reader::isHyphenCharacter);
result = result && readAndExpect(reader, reader::isHyphenCharacter);
if (!reader.isEndOfLine()) {
reader.read();
reader.skipWhitespace();
}
return result && reader.isEndOfLine();
}
private boolean readAndExpect(CharacterReader reader, BooleanSupplier check) throws IOException {
reader.read();
return check.getAsBoolean();
}
/**
* Reads characters from the source resource, taking care of skipping comments,
* handling multi-line values and tracking {@code ''} escapes.
*/
private static class CharacterReader implements Closeable {
private static final String[] ESCAPES = { "trnf", "trnf" };
private final LineNumberReader reader;
private int columnNumber = -1;
private boolean escaped;
private int character;
private boolean lastLineComment;
CharacterReader(Resource resource) throws IOException {
this.reader = new LineNumberReader(
new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8));
}
@Override
public void close() throws IOException {
this.reader.close();
}
boolean read() throws IOException {
return read(false);
}
boolean read(boolean wrappedLine) throws IOException {
this.escaped = false;
this.character = this.reader.read();
this.columnNumber++;
if (this.columnNumber == 0) {
skipWhitespace();
if (!wrappedLine) {
if (this.character == '!') {
skipComment();
}
}
}
if (this.character == '\') {
this.escaped = true;
readEscaped();
}
else if (this.character == 'n') {
this.columnNumber = -1;
}
return !isEndOfFile();
}
private void skipWhitespace() throws IOException {
while (isWhiteSpace()) {
this.character = this.reader.read();
this.columnNumber++;
}
}
private void setLastLineComment(boolean lastLineComment) {
this.lastLineComment = lastLineComment;
}
private boolean isLastLineComment() {
return this.lastLineComment;
}
private void skipComment() throws IOException {
while (this.character != 'n' && this.character != -1) {
this.character = this.reader.read();
}
this.columnNumber = -1;
}
private void readEscaped() throws IOException {
this.character = this.reader.read();
int escapeIndex = ESCAPES[0].indexOf(this.character);
if (escapeIndex != -1) {
this.character = ESCAPES[1].charAt(escapeIndex);
}
else if (this.character == 'n') {
this.columnNumber = -1;
read(true);
}
else if (this.character == 'u') {
readUnicode();
}
}
private void readUnicode() throws IOException {
this.character = 0;
for (int i = 0; i < 4; i++) {
int digit = this.reader.read();
if (digit >= '0' && digit <= '9') {
this.character = (this.character << 4) + digit - '0';
}
else if (digit >= 'a' && digit <= 'f') {
this.character = (this.character << 4) + digit - 'a' + 10;
}
else if (digit >= 'A' && digit <= 'F') {
this.character = (this.character << 4) + digit - 'A' + 10;
}
else {
throw new IllegalStateException("Malformed \uxxxx encoding.");
}
}
}
boolean isWhiteSpace() {
return !this.escaped && (this.character == ' ' || this.character == 't' || this.character == 'f');
}
boolean isEndOfFile() {
return this.character == -1;
}
boolean isEndOfLine() {
return this.character == -1 || (!this.escaped && this.character == 'n');
}
boolean isListDelimiter() {
return !this.escaped && this.character == ',';
}
boolean isPropertyDelimiter() {
return !this.escaped && (this.character == '=' || this.character == ':');
}
char getCharacter() {
return (char) this.character;
}
Location getLocation() {
return new Location(this.reader.getLineNumber(), this.columnNumber);
}
boolean isPoundCharacter() {
return this.character == '#';
}
boolean isHyphenCharacter() {
return this.character == '-';
}
}
/**
* A single document within the properties file.
*/
static class Document {
private final Map<String, OriginTrackedValue> values = new LinkedHashMap<>();
void put(String key, OriginTrackedValue value) {
if (!key.isEmpty()) {
this.values.put(key, value);
}
}
boolean isEmpty() {
return this.values.isEmpty();
}
Map<String, OriginTrackedValue> asMap() {
return this.values;
}
}
}
2.创建PropertiesPropertySourceLoader文件
复制org.springframework.boot.env.PropertiesPropertySourceLoader文件内容，并将调用org.springframework.boot.env.OriginTrackedPropertiesLoader类改为调用com.xxx.config.MyOriginTrackedPropertiesLoader类
package com.xxx.config;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.springframework.boot.env.OriginTrackedMapPropertySource;
import org.springframework.boot.env.PropertySourceLoader;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import com.xxx.config.MyOriginTrackedPropertiesLoader.Document;
/**
* Strategy to load '.properties' files into a {@link PropertySource}.
*
* @author Dave Syer
* @author Phillip Webb
* @author Madhura Bhave
* @since 1.0.0
*/
public class MyPropertiesPropertySourceLoader implements PropertySourceLoader {
private static final String XML_FILE_EXTENSION = ".xml";
@Override
public String[] getFileExtensions() {
return new String[] { "properties", "xml" };
}
@Override
public List<PropertySource<?>> load(String name, Resource resource) throws IOException {
List<Map<String, ?>> properties = loadProperties(resource);
if (properties.isEmpty()) {
return Collections.emptyList();
}
List<PropertySource<?>> propertySources = new ArrayList<>(properties.size());
for (int i = 0; i < properties.size(); i++) {
String documentNumber = (properties.size() != 1) ? " (document #" + i + ")" : "";
propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber,
Collections.unmodifiableMap(properties.get(i)), true));
}
return propertySources;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private List<Map<String, ?>> loadProperties(Resource resource) throws IOException {
String filename = resource.getFilename();
List<Map<String, ?>> result = new ArrayList<>();
if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) {
result.add((Map) PropertiesLoaderUtils.loadProperties(resource));
}
else {
List<Document> documents = new MyOriginTrackedPropertiesLoader(resource).load();
documents.forEach((document) -> result.add(document.asMap()));
}
return result;
}
}
3.创建spring.factories文件
在resources资源目录下创建/META-INF/spring.factories文件
文件内容为
org.springframework.boot.env.PropertySourceLoader= com.xxx.config.MyPropertiesPropertySourceLoader
测试
创建application.properties文件
abc=中文测试
创建service类，使用@Value注入abc变量
@Value("${abc}")
private String abc;
分别在com.xxx.config.MyPropertiesPropertySourceLoader类、org.springframework.boot.env.PropertiesPropertySourceLoader类、org.springframework.boot.env.YamlPropertySourceLoader类的load方法打断点
以debug方式运行项目，可以看到只加载了com.xxx.config.MyPropertiesPropertySourceLoader类和org.springframework.boot.env.YamlPropertySourceLoader类，
发请求查看abc变量的值为：中文测试，已经不乱码了
最后
配置中心properties文件的中文属性也没有了乱码
以上为个人经验，希望能给大家一个参考，也希望大家多多支持靠谱客。
最后
以上就是调皮帆布鞋为你收集整理的解决Springboot-application.properties中文乱码问题的全部内容，希望文章能够帮你解决解决Springboot-application.properties中文乱码问题所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复