Initial project

src/main/java/com/imyeyu/config/BaseConverter.java

@@ -0,0 +1,36 @@
+package com.imyeyu.config;
+
+import java.lang.reflect.Field;
+
+/**
+ * @author 夜雨
+ * @version 2024-04-12 00:44
+ */
+public abstract class BaseConverter<T, K> {
+
+	@SuppressWarnings("unchecked")
+	K serialize0(Field field, Object t) {
+		return serialize(field, (T) t);
+	}
+
+	@SuppressWarnings("unchecked")
+	T deserialize0(Field field, Object data) {
+		return deserialize(field, (K) data);
+	}
+
+	/**
+	 * 当组件值需要写入配置时的转换，默认直接 toString
+	 *
+	 * @param t 组件值类型
+	 * @return 配置值
+	 */
+	protected abstract K serialize(Field field, T t);
+
+	/**
+	 * 当获取配置并即将设置到组件时调用
+	 *
+	 * @param data 配置值
+	 * @return 返回值
+	 */
+	protected abstract T deserialize(Field field, K data);
+}

src/main/java/com/imyeyu/config/ConfigLoader.java

@@ -0,0 +1,237 @@
+package com.imyeyu.config;
+
+import com.imyeyu.io.IO;
+import com.imyeyu.java.TimiJava;
+import com.imyeyu.java.bean.timi.TimiCode;
+import com.imyeyu.java.bean.timi.TimiException;
+import com.imyeyu.java.ref.Ref;
+import com.imyeyu.java.ref.RefField;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.io.File;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author 夜雨
+ * @version 2024-04-10 00:44
+ */
+public class ConfigLoader<T> {
+
+	private final File file;
+	private final Yaml yaml;
+	private final Class<T> clazz;
+	private final List<RawMapper> rawMappingList = new ArrayList<>();
+	private final Map<Class<?>, BaseConverter<?, ?>> converterMap = new HashMap<>();
+
+	private T value;
+	private LinkedHashMap<String, Object> rawValue;
+
+	public ConfigLoader(String srcPath, Class<T> clazz) {
+		this(srcPath, srcPath, clazz);
+	}
+
+	public ConfigLoader(String srcPath, String distPath, Class<T> clazz) {
+		this.clazz = clazz;
+
+		LoaderOptions loaderOptions = new LoaderOptions();
+		Constructor constructor = new Constructor(loaderOptions);
+
+		DumperOptions dumperOptions = new DumperOptions();
+		dumperOptions.setIndent(4);
+		dumperOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		dumperOptions.setIndicatorIndent(4);
+		dumperOptions.setDefaultScalarStyle(DumperOptions.ScalarStyle.PLAIN);
+		dumperOptions.setIndentWithIndicator(true);
+		Representer representer = new ConfigRepresenter(dumperOptions);
+
+		yaml = new Yaml(constructor, representer, dumperOptions);
+
+		file = new File(distPath);
+
+		if (!file.exists()) {
+			try {
+				IO.resourceToDisk(getClass(), srcPath, distPath);
+			} catch (Exception e) {
+				throw new TimiException(TimiCode.ERROR, "load default config error", e);
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	public T load() {
+		try {
+			rawValue = yaml.load(IO.toString(file).replaceAll("\t", "    "));
+
+			if (clazz == null || clazz.equals(Object.class)) {
+				value = (T) rawValue;
+			} else {
+				// 解析配置对象
+				rawMappingList.clear();
+				value = clazz.getDeclaredConstructor().newInstance();
+				deserializeToValue(value, rawValue, "");
+			}
+			return this.value;
+		} catch (Exception e) {
+			throw new TimiException(TimiCode.ERROR, "load config error", e);
+		}
+	}
+
+	public void dump() {
+		try {
+			serializeToRawValue();
+			IO.toFile(file, yaml.dump(rawValue).replaceAll("( ){4}", "\t"));
+		} catch (Exception e) {
+			throw new TimiException(TimiCode.ERROR, "dump config error", e);
+		}
+	}
+
+	public void addConverter(Class<?> type, BaseConverter<?, ?> converter) {
+		converterMap.put(type, converter);
+	}
+
+	public void removeConverter(Class<?> type) {
+		converterMap.remove(type);
+	}
+
+	@SuppressWarnings("unchecked")
+	private void serializeToRawValue() throws Exception {
+		for (int i = 0; i < rawMappingList.size(); i++) {
+			RawMapper rawMapper = rawMappingList.get(i);
+			String[] bukkit = rawMapper.rawStack.split("#");
+
+			Map<String, Object> raw = rawValue;
+			String key;
+			if (bukkit.length == 1) {
+				key = bukkit[0];
+			} else {
+				for (int j = 0; j < bukkit.length - 1; j++) {
+					raw = (Map<String, Object>) rawValue.get(bukkit[j]);
+				}
+				key = bukkit[bukkit.length - 1];
+			}
+			Object value = rawMapper.refField.getGetter().invoke(rawMapper.owner);
+
+			// 字段注解序列化
+			Converter fieldConverter = rawMapper.refField.getType().getAnnotation(Converter.class);
+			if (fieldConverter != null) {
+				BaseConverter<?, ?> converter = Ref.newInstance(fieldConverter.value());
+				raw.put(key, converter.serialize0(rawMapper.refField.getField(), value));
+				continue;
+			}
+			// 类型序列化
+			if (converterMap.containsKey(rawMapper.refField.getType())) {
+				BaseConverter<?, ?> converter = converterMap.get(rawMapper.refField.getType());
+				raw.put(key, converter.serialize0(rawMapper.refField.getField(), value));
+				continue;
+			}
+			// 枚举序列化
+			if (Enum.class.isAssignableFrom(rawMapper.refField.getType())) {
+				raw.put(key, rawMapper.refField.getGetter().invoke(rawMapper.owner).toString());
+				continue;
+			}
+			// 默认序列化
+			raw.put(key, rawMapper.refField.getGetter().invoke(rawMapper.owner));
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private void deserializeToValue(Object object, Map<?, ?> map, String stack) throws Exception {
+		for (Map.Entry<?, ?> item : map.entrySet()) {
+			RefField refField = Ref.field(object.getClass(), item.getKey().toString());
+
+			if (!(item.getValue() instanceof Map<?, ?>)) {
+				// 缓存映射
+				RawMapper rawMapper = new RawMapper();
+				rawMapper.owner = object;
+				rawMapper.refField = refField;
+				rawMapper.rawStack = stack + item.getKey();
+				rawMappingList.add(rawMapper);
+			}
+
+			Class<?> type = refField.getType();
+			// 字段注解反序列化
+			Converter fieldConverter = refField.getType().getAnnotation(Converter.class);
+			if (fieldConverter != null) {
+				BaseConverter<?, ?> converter = Ref.newInstance(fieldConverter.value());
+				refField.getSetter().invoke(object, converter.deserialize0(refField.getField(), item.getValue()));
+				continue;
+			}
+			// 类型反序列化
+			if (converterMap.containsKey(type)) {
+				refField.getSetter().invoke(object, converterMap.get(type).deserialize0(refField.getField(), item.getValue()));
+				continue;
+			}
+			// 默认反序列化
+			if (item.getValue() instanceof Map<?, ?> valueMap) {
+				// 子级对象
+				Object newObject = type.getDeclaredConstructor().newInstance();
+				refField.getSetter().invoke(object, newObject);
+				deserializeToValue(newObject, valueMap, stack + item.getKey() + "#");
+				continue;
+			}
+			// 数组
+			if (item.getValue() instanceof List<?> valueList) {
+				// 数组
+				if (type.isArray()) {
+					Class<?> arrayType = type.getComponentType();
+					Object array = Array.newInstance(arrayType, valueList.size());
+					if (arrayType.isPrimitive()) {
+						// 基本类型数组
+						if (TimiJava.isNotEmpty(valueList)) {
+							Method method = Ref.getMethod(valueList.get(0).getClass(), arrayType.getName() + "Value");
+							for (int i = 0; i < valueList.size(); i++) {
+								Array.set(array, i, method.invoke(valueList.get(i)));
+							}
+						}
+					} else {
+						for (int i = 0; i < valueList.size(); i++) {
+							Array.set(array, i, arrayType.cast(valueList.get(i)));
+						}
+					}
+					refField.getSetter().invoke(object, array);
+					continue;
+				}
+				// 列表
+				refField.getSetter().invoke(object, valueList);
+				continue;
+			}
+			// 枚举
+			if (Enum.class.isAssignableFrom(type)) {
+				refField.getSetter().invoke(object, Ref.toType((Class<Enum<?>>) type, item.getValue().toString()));
+				continue;
+			}
+			refField.getSetter().invoke(object, item.getValue());
+		}
+	}
+
+	public T getValue() {
+		return value;
+	}
+
+	public Map<String, Object> getRawValue() {
+		return rawValue;
+	}
+
+	/**
+	 * @author 夜雨
+	 * @version 2024-04-10 00:45
+	 */
+	private static class RawMapper {
+
+		Object owner;
+
+		RefField refField;
+
+		String rawStack;
+	}
+}

src/main/java/com/imyeyu/config/ConfigRepresenter.java

@@ -0,0 +1,18 @@
+package com.imyeyu.config;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.representer.Representer;
+
+/**
+ * @author 夜雨
+ * @version 2024-05-01 14:03
+ */
+public class ConfigRepresenter extends Representer {
+
+	public ConfigRepresenter(DumperOptions options) {
+		super(options);
+
+		this.nullRepresenter = data -> representScalar(Tag.NULL, "");
+	}
+}

src/main/java/com/imyeyu/config/Converter.java

@@ -0,0 +1,14 @@
+package com.imyeyu.config;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * @author 夜雨
+ * @version 2024-04-26 00:30
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Converter {
+
+	Class<? extends BaseConverter<?, ?>> value();
+}

src/main/java/com/imyeyu/config/StringConverter.java

@@ -0,0 +1,15 @@
+package com.imyeyu.config;
+
+import java.lang.reflect.Field;
+
+/**
+ * @author 夜雨
+ * @version 2024-04-27 10:38
+ */
+public abstract class StringConverter<T> extends BaseConverter<T, String> {
+
+	@Override
+	protected String serialize(Field field, T t) {
+		return t.toString();
+	}
+}