Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
cn.hutool.setting.Setting Maven / Gradle / Ivy
package cn.hutool.setting;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.io.resource.FileResource;
import cn.hutool.core.io.resource.Resource;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.io.resource.UrlResource;
import cn.hutool.core.io.watch.SimpleWatcher;
import cn.hutool.core.io.watch.WatchMonitor;
import cn.hutool.core.io.watch.WatchUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.StaticLog;
import cn.hutool.setting.dialect.Props;
import java.io.File;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.WatchEvent;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.function.Consumer;
/**
* 设置工具类。 用于支持设置（配置）文件
* 1、支持变量，默认变量命名为 ${变量名}，变量只能识别读入行的变量，例如第6行的变量在第三行无法读取
* 2、支持分组，分组为中括号括起来的内容，中括号以下的行都为此分组的内容，无分组相当于空字符分组，若某个key是name，加上分组后的键相当于group.name
* 3、注释以#开头，但是空行和不带“=”的行也会被跳过，但是建议加#
* 4、store方法不会保存注释内容，慎重使用
*
*
* @author looly
*/
public class Setting extends AbsSetting implements Map {
private static final long serialVersionUID = 3618305164959883393L;
/**
* 默认字符集
*/
public static final Charset DEFAULT_CHARSET = CharsetUtil.CHARSET_UTF_8;
/**
* 默认配置文件扩展名
*/
public static final String EXT_NAME = "setting";
/**
* 构建一个空的Setting，用于手动加入参数
*
* @return Setting
* @since 5.4.3
*/
public static Setting create() {
return new Setting();
}
/**
* 附带分组的键值对存储
*/
private final GroupedMap groupedMap = new GroupedMap();
/**
* 本设置对象的字符集
*/
protected Charset charset;
/**
* 是否使用变量
*/
protected boolean isUseVariable;
/**
* 设定文件的资源
*/
protected Resource resource;
private SettingLoader settingLoader;
private WatchMonitor watchMonitor;
// ------------------------------------------------------------------------------------- Constructor start
/**
* 空构造
*/
public Setting() {
this.charset = DEFAULT_CHARSET;
}
/**
* 构造
*
* @param path 相对路径或绝对路径
*/
public Setting(String path) {
this(path, false);
}
/**
* 构造
*
* @param path 相对路径或绝对路径
* @param isUseVariable 是否使用变量
*/
public Setting(String path, boolean isUseVariable) {
this(path, DEFAULT_CHARSET, isUseVariable);
}
/**
* 构造，使用相对于Class文件根目录的相对路径
*
* @param path 相对路径或绝对路径
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(String path, Charset charset, boolean isUseVariable) {
Assert.notBlank(path, "Blank setting path !");
this.init(ResourceUtil.getResourceObj(path), charset, isUseVariable);
}
/**
* 构造
*
* @param configFile 配置文件对象
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(File configFile, Charset charset, boolean isUseVariable) {
Assert.notNull(configFile, "Null setting file define!");
this.init(new FileResource(configFile), charset, isUseVariable);
}
/**
* 构造，相对于classes读取文件
*
* @param path 相对ClassPath路径或绝对路径
* @param clazz 基准类
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(String path, Class clazz, Charset charset, boolean isUseVariable) {
Assert.notBlank(path, "Blank setting path !");
this.init(new ClassPathResource(path, clazz), charset, isUseVariable);
}
/**
* 构造
*
* @param url 设定文件的URL
* @param charset 字符集
* @param isUseVariable 是否使用变量
*/
public Setting(URL url, Charset charset, boolean isUseVariable) {
Assert.notNull(url, "Null setting url define!");
this.init(new UrlResource(url), charset, isUseVariable);
}
/**
* 构造
*
* @param resource Setting的Resource
* @param charset 字符集
* @param isUseVariable 是否使用变量
* @since 5.4.4
*/
public Setting(Resource resource, Charset charset, boolean isUseVariable) {
this.init(resource, charset, isUseVariable);
}
// ------------------------------------------------------------------------------------- Constructor end
/**
* 初始化设定文件
*
* @param resource {@link Resource}
* @param charset 字符集
* @param isUseVariable 是否使用变量
* @return 成功初始化与否
*/
public boolean init(Resource resource, Charset charset, boolean isUseVariable) {
Assert.notNull(resource, "Setting resource must be not null!");
this.resource = resource;
this.charset = charset;
this.isUseVariable = isUseVariable;
return load();
}
/**
* 重新加载配置文件
*
* @return 是否加载成功
*/
synchronized public boolean load() {
if (null == this.settingLoader) {
settingLoader = new SettingLoader(this.groupedMap, this.charset, this.isUseVariable);
}
return settingLoader.load(this.resource);
}
/**
* 在配置文件变更时自动加载
*
* @param autoReload 是否自动加载
*/
public void autoLoad(boolean autoReload) {
autoLoad(autoReload, null);
}
/**
* 在配置文件变更时自动加载
*
* @param callback 加载完成回调
* @param autoReload 是否自动加载
*/
public void autoLoad(boolean autoReload, Consumer callback) {
if (autoReload) {
Assert.notNull(this.resource, "Setting resource must be not null !");
if (null != this.watchMonitor) {
// 先关闭之前的监听
this.watchMonitor.close();
}
this.watchMonitor = WatchUtil.createModify(resource.getUrl(), new SimpleWatcher() {
@Override
public void onModify(WatchEvent event, Path currentPath) {
boolean success = load();
// 如果有回调，加载完毕则执行回调
if (callback != null) {
callback.accept(success);
}
}
});
this.watchMonitor.start();
StaticLog.debug("Auto load for [{}] listenning...", this.resource.getUrl());
} else {
IoUtil.close(this.watchMonitor);
this.watchMonitor = null;
}
}
/**
* 获得设定文件的URL
*
* @return 获得设定文件的路径
* @since 5.4.3
*/
public URL getSettingUrl() {
return (null == this.resource) ? null : this.resource.getUrl();
}
/**
* 获得设定文件的路径
*
* @return 获得设定文件的路径
*/
public String getSettingPath() {
final URL settingUrl = getSettingUrl();
return (null == settingUrl) ? null : settingUrl.getPath();
}
/**
* 键值总数
*
* @return 键值总数
*/
@Override
public int size() {
return this.groupedMap.size();
}
@Override
public String getByGroup(String key, String group) {
return this.groupedMap.get(group, key);
}
/**
* 获取并删除键值对，当指定键对应值非空时，返回并删除这个值，后边的键对应的值不再查找
*
* @param keys 键列表，常用于别名
* @return 值
* @since 3.1.2
*/
public Object getAndRemove(String... keys) {
Object value = null;
for (String key : keys) {
value = remove(key);
if (null != value) {
break;
}
}
return value;
}
/**
* 获取并删除键值对，当指定键对应值非空时，返回并删除这个值，后边的键对应的值不再查找
*
* @param keys 键列表，常用于别名
* @return 字符串值
* @since 3.1.2
*/
public String getAndRemoveStr(String... keys) {
String value = null;
for (String key : keys) {
value = remove(key);
if (null != value) {
break;
}
}
return value;
}
/**
* 获得指定分组的所有键值对，此方法获取的是原始键值对，获取的键值对可以被修改
*
* @param group 分组
* @return map
*/
public Map getMap(String group) {
final LinkedHashMap map = this.groupedMap.get(group);
return (null != map) ? map : new LinkedHashMap<>(0);
}
/**
* 获取group分组下所有配置键值对，组成新的Setting
*
* @param group 分组
* @return Setting
*/
public Setting getSetting(String group) {
final Setting setting = new Setting();
setting.putAll(this.getMap(group));
return setting;
}
/**
* 获取group分组下所有配置键值对，组成新的{@link Properties}
*
* @param group 分组
* @return Properties对象
*/
public Properties getProperties(String group) {
final Properties properties = new Properties();
properties.putAll(getMap(group));
return properties;
}
/**
* 获取group分组下所有配置键值对，组成新的{@link Props}
*
* @param group 分组
* @return Props对象
* @since 4.1.21
*/
public Props getProps(String group) {
final Props props = new Props();
props.putAll(getMap(group));
return props;
}
// --------------------------------------------------------------------------------- Functions
/**
* 持久化当前设置，会覆盖掉之前的设置> groupEntry : this.groupedMap.entrySet()) {
group = groupEntry.getKey();
for (Entry entry : groupEntry.getValue().entrySet()) {
properties.setProperty(StrUtil.isEmpty(group) ? entry.getKey() : group + CharUtil.DOT + entry.getKey(), entry.getValue());
}
}
return properties;
}
/**
* 获取GroupedMap
*
* @return GroupedMap
* @since 4.0.12
*/
public GroupedMap getGroupedMap() {
return this.groupedMap;
}
/**
* 获取所有分组
*
* @return 获得所有分组名
*/
public List getGroups() {
return CollUtil.newArrayList(this.groupedMap.keySet());
}
/**
* 设置变量的正则> e : setting.getGroupedMap().entrySet()) {
this.putAll(e.getKey(), e.getValue());
}
return this;
}
/**
* 清除指定分组下的所有键值对
*
* @param group 分组
* @return this
*/
public Setting clear(String group) {
this.groupedMap.clear(group);
return this;
}
/**
* 指定分组所有键的Set
*
* @param group 分组
* @return 键Set
*/
public Set keySet(String group) {
return this.groupedMap.keySet(group);
}
/**
* 指定分组下所有值
*
* @param group 分组
* @return 值
*/
public Collection values(String group) {
return this.groupedMap.values(group);
}
/**
* 指定分组下所有键值对
*
* @param group 分组
* @return 键值对
*/
public Set> entrySet(String group) {
return this.groupedMap.entrySet(group);
}
/**
* 设置值
*
* @param key 键
* @param value 值
* @return this
* @since 3.3.1
*/
public Setting set(String key, String value) {
this.put(key, value);
return this;
}
/**
* 将键值对加入到对应分组中 keySet() {
return this.groupedMap.keySet(DEFAULT_GROUP);
}
/**
* 获取默认分组（空分组）中的所有值列表
*
* @return 默认分组（空分组）中的所有值列表
*/
@SuppressWarnings("NullableProblems")
@Override
public Collection values() {
return this.groupedMap.values(DEFAULT_GROUP);
}
/**
* 获取默认分组（空分组）中的所有键值对列表
*
* @return 默认分组（空分组）中的所有键值对列表
*/
@SuppressWarnings("NullableProblems")
@Override
public Set> entrySet() {
return this.groupedMap.entrySet(DEFAULT_GROUP);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((charset == null) ? 0 : charset.hashCode());
result = prime * result + groupedMap.hashCode();
result = prime * result + (isUseVariable ? 1231 : 1237);
result = prime * result + ((this.resource == null) ? 0 : this.resource.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Setting other = (Setting) obj;
if (charset == null) {
if (other.charset != null) {
return false;
}
} else if (false == charset.equals(other.charset)) {
return false;
}
if (false == groupedMap.equals(other.groupedMap)) {
return false;
}
if (isUseVariable != other.isUseVariable) {
return false;
}
if (this.resource == null) {
return other.resource == null;
} else {
return resource.equals(other.resource);
}
}
@Override
public String toString() {
return groupedMap.toString();
}
}
