更新

src/main/java/com/ilummc/tlib/inject/TConfigInjector.java

@@ -1,5 +1,25 @@
 package com.ilummc.tlib.inject;
 
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.Validate;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.plugin.Plugin;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.io.Files;
@@ -9,24 +29,10 @@ import com.google.gson.annotations.SerializedName;
 import com.ilummc.tlib.TLib;
 import com.ilummc.tlib.annotations.Config;
 import com.ilummc.tlib.bean.Property;
-import org.apache.commons.lang3.Validate;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.configuration.serialization.ConfigurationSerialization;
-import org.bukkit.plugin.Plugin;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.Yaml;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.nio.charset.Charset;
-import java.util.*;
-import java.util.stream.Collectors;
 
 public class TConfigInjector {
 
-    public static void fixUnicode(YamlConfiguration configuration) {
+    public static void fixUnicode(FileConfiguration configuration) {
         try {
             Field field = YamlConfiguration.class.getDeclaredField("yamlOptions");
             field.setAccessible(true);

src/main/java/com/ilummc/tlib/inject/TConfigWatcher.java

@@ -1,11 +1,12 @@
 package com.ilummc.tlib.inject;
 
-import com.ilummc.tlib.TLib;
-import org.apache.commons.lang3.tuple.Triple;
-
 import java.io.File;
 import java.io.IOException;
-import java.nio.file.*;
+import java.nio.file.FileSystems;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -14,6 +15,8 @@ import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
+import org.apache.commons.lang3.tuple.Triple;
+
 public class TConfigWatcher {
 
     private ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

src/main/java/com/ilummc/tlib/inject/TDependencyInjector.java

@@ -0,0 +1,173 @@
+package com.ilummc.tlib.inject;
+
+import java.io.File;
+import java.lang.reflect.Field;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.ilummc.tlib.TLib;
+import com.ilummc.tlib.annotations.Config;
+import com.ilummc.tlib.annotations.Dependencies;
+import com.ilummc.tlib.annotations.Dependency;
+import com.ilummc.tlib.annotations.Logger;
+import com.ilummc.tlib.annotations.PluginInstance;
+import com.ilummc.tlib.dependency.TDependency;
+import com.ilummc.tlib.resources.TLocaleLoader;
+import com.ilummc.tlib.util.Ref;
+import com.ilummc.tlib.util.TLogger;
+
+public class TDependencyInjector {
+
+    public static void inject(Plugin plugin, Object o) {
+        injectDependencies(plugin, o);
+        injectLogger(plugin, o);
+        injectConfig(plugin, o);
+        injectPluginInstance(plugin, o);
+        TLocaleLoader.load(plugin, true);
+    }
+
+    static void injectOnEnable(Plugin plugin) {
+        inject(plugin, plugin);
+    }
+
+    static void onDisable(Plugin plugin) {
+        eject(plugin, plugin);
+    }
+
+    public static void eject(Plugin plugin, Object o) {
+        try {
+            ejectConfig(plugin, o);
+        } catch (Throwable ignored) {
+        }
+    }
+
+    private static void ejectConfig(Plugin plugin, Object o) {
+        for (Field field : Ref.getDeclaredFields(o.getClass())) {
+            Config config;
+            if ((config = field.getType().getAnnotation(Config.class)) != null && config.saveOnExit()) {
+                try {
+                    field.setAccessible(true);
+                    TConfigInjector.saveConfig(plugin, field.get(o));
+                    TLib.getTLib().getLogger().info("插件 " + plugin + " 的配置 " + config.name() + " 已保存");
+                } catch (Exception e) {
+                    TLib.getTLib().getLogger().warn("插件 " + plugin + " 的配置 " + config.name() + " 保存失败");
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    private static void injectConfig(Plugin plugin, Object o) {
+        for (Field field : Ref.getDeclaredFields(o.getClass())) {
+            try {
+                Config config;
+                if ((config = field.getType().getAnnotation(Config.class)) != null) {
+                    field.setAccessible(true);
+                    Object obj = TConfigInjector.loadConfig(plugin, field.getType());
+                    if (obj != null) {
+                        TLib.getTLib().getLogger().info("插件 " + plugin.getName() + " 的 " + config.name() + " 配置文件成功加载");
+                        field.set(o, obj);
+                        if (config.listenChanges()) {
+                            TLib.getTLib().getLogger().info("开始监听插件 " + plugin.getName() + " 的 " + config.name() + " 配置文件");
+                            TLib.getTLib().getConfigWatcher().addOnListen(
+                                    new File(plugin.getDataFolder(), config.name()),
+                                    obj,
+                                    object -> {
+                                        try {
+                                            Object newObj = TConfigInjector.loadConfig(plugin, object.getClass());
+                                            for (Field f : newObj.getClass().getDeclaredFields()) {
+                                                f.setAccessible(true);
+                                                f.set(obj, f.get(newObj));
+                                            }
+                                            TLib.getTLib().getLogger().info("插件 " + plugin.getName() + " 的 " + config.name() + " 配置文件成功重载");
+                                        } catch (Exception ignored) {
+                                            TLib.getTLib().getLogger().warn("插件 " + plugin.getName() + " 的 " + config.name() + " 配置文件重载时发生错误");
+                                        }
+                                    }
+                            );
+                        }
+                    }
+                }
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    private static void injectLogger(Plugin plugin, Object o) {
+        for (Field field : Ref.getDeclaredFields(o.getClass())) {
+            try {
+                Logger logger;
+                if ((logger = field.getAnnotation(Logger.class)) != null) {
+                    field.getType().asSubclass(TLogger.class);
+                    TLogger tLogger = new TLogger(logger.value(), plugin, logger.level());
+                    if (!field.isAccessible())
+                        field.setAccessible(true);
+                    field.set(o, tLogger);
+                }
+            } catch (Exception ignored2) {
+            }
+        }
+    }
+
+    private static void injectPluginInstance(Plugin plugin, Object o) {
+        for (Field field : Ref.getDeclaredFields(o.getClass())) {
+            try {
+                PluginInstance instance;
+                if ((instance = field.getAnnotation(PluginInstance.class)) != null) {
+                    if (!field.isAccessible())
+                        field.setAccessible(true);
+                    field.getType().asSubclass(JavaPlugin.class);
+                    Plugin pl;
+                    if ((pl = Bukkit.getPluginManager().getPlugin(instance.value())) == null) {
+                        if (!TDependency.requestPlugin(instance.value())) {
+                            TLib.getTLib().getLogger().warn(plugin.getName() + " 所需的依赖插件 " + instance.value() + " 自动加载失败");
+                            return;
+                        } else {
+                            pl = Bukkit.getPluginManager().getPlugin(instance.value());
+                        }
+                    }
+                    if (pl != null)
+                        field.set(o, pl);
+                }
+            } catch (Exception ignored) {
+            }
+        }
+    }
+
+    private static void injectDependencies(Plugin plugin, Object o) {
+        Dependency[] dependencies = new Dependency[0];
+        {
+            Dependencies d = o.getClass().getAnnotation(Dependencies.class);
+            if (d != null) {
+                dependencies = d.value();
+            }
+            Dependency d2 = o.getClass().getAnnotation(Dependency.class);
+            if (d2 != null) {
+                dependencies = new Dependency[]{d2};
+            }
+        }
+        if (dependencies.length != 0) {
+            TLib.getTLib().getLogger().info("正在加载 " + plugin.getName() + " 插件所需的依赖");
+            for (Dependency dependency : dependencies) {
+                if (dependency.type() == Dependency.Type.PLUGIN) {
+                    if (TDependency.requestPlugin(dependency.plugin())) {
+                        TLib.getTLib().getLogger().info("  " + plugin.getName() + " 请求的插件 " + dependency.plugin() + " 加载成功。");
+                    } else {
+                        TLib.getTLib().getLogger().warn("  " + plugin.getName() + " 请求的插件 " + dependency.plugin() + " 加载失败。");
+                    }
+                }
+                if (dependency.type() == Dependency.Type.LIBRARY) {
+                    if (TDependency.requestLib(dependency.maven(), dependency.mavenRepo(), dependency.url())) {
+                        TLib.getTLib().getLogger().info("  " + plugin.getName() + " 请求的库文件 " + String.join(":", dependency.maven()) + " 加载成功。");
+                    } else {
+                        TLib.getTLib().getLogger().warn("  " + plugin.getName() + " 请求的库文件 " + String.join(":", dependency.maven()) + " 加载失败。");
+                    }
+                }
+            }
+            TLib.getTLib().getLogger().info("依赖加载完成");
+        }
+    }
+
+}

src/main/java/com/ilummc/tlib/inject/TPluginManager.java

@@ -0,0 +1,181 @@
+package com.ilummc.tlib.inject;
+
+import java.io.File;
+import java.util.Set;
+
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.permissions.Permissible;
+import org.bukkit.permissions.Permission;
+import org.bukkit.plugin.EventExecutor;
+import org.bukkit.plugin.InvalidDescriptionException;
+import org.bukkit.plugin.InvalidPluginException;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginLoader;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.UnknownDependencyException;
+
+import me.skymc.taboolib.Main;
+
+public class TPluginManager implements PluginManager {
+
+    private final PluginManager instance;
+
+    private final Main main = (Main) Main.getInst();
+
+    public TPluginManager() {
+        instance = Bukkit.getPluginManager();
+    }
+
+    @Override
+    public void registerInterface(Class<? extends PluginLoader> aClass) throws IllegalArgumentException {
+        instance.registerInterface(aClass);
+    }
+
+    @Override
+    public Plugin getPlugin(String s) {
+        return instance.getPlugin(s);
+    }
+
+    @Override
+    public Plugin[] getPlugins() {
+        return instance.getPlugins();
+    }
+
+    @Override
+    public boolean isPluginEnabled(String s) {
+        return instance.isPluginEnabled(s);
+    }
+
+    @Override
+    public boolean isPluginEnabled(Plugin plugin) {
+        return instance.isPluginEnabled(plugin);
+    }
+
+    @Override
+    public Plugin loadPlugin(File file) throws InvalidPluginException, InvalidDescriptionException, UnknownDependencyException {
+        return instance.loadPlugin(file);
+    }
+
+    @Override
+    public Plugin[] loadPlugins(File file) {
+        return instance.loadPlugins(file);
+    }
+
+    @Override
+    public void disablePlugins() {
+        for (Plugin plugin : getPlugins()) {
+            if (plugin != main) disablePlugin(plugin);
+        }
+        disablePlugin(main);
+    }
+
+    @Override
+    public void clearPlugins() {
+        instance.clearPlugins();
+    }
+
+    @Override
+    public void callEvent(Event event) throws IllegalStateException {
+        instance.callEvent(event);
+    }
+
+    @Override
+    public void registerEvents(Listener listener, Plugin plugin) {
+        instance.registerEvents(listener, plugin);
+    }
+
+    @Override
+    public void registerEvent(Class<? extends Event> aClass, Listener listener, EventPriority eventPriority, EventExecutor eventExecutor, Plugin plugin) {
+        instance.registerEvent(aClass, listener, eventPriority, eventExecutor, plugin);
+    }
+
+    @Override
+    public void registerEvent(Class<? extends Event> aClass, Listener listener, EventPriority eventPriority, EventExecutor eventExecutor, Plugin plugin, boolean b) {
+        instance.registerEvent(aClass, listener, eventPriority, eventExecutor, plugin, b);
+    }
+
+    @Override
+    public void enablePlugin(Plugin plugin) {
+        TDependencyInjector.injectOnEnable(plugin);
+        instance.enablePlugin(plugin);
+    }
+
+    @Override
+    public void disablePlugin(Plugin plugin) {
+        TDependencyInjector.onDisable(plugin);
+        instance.disablePlugin(plugin);
+    }
+
+    @Override
+    public Permission getPermission(String s) {
+        return instance.getPermission(s);
+    }
+
+    @Override
+    public void addPermission(Permission permission) {
+        instance.addPermission(permission);
+    }
+
+    @Override
+    public void removePermission(Permission permission) {
+        instance.removePermission(permission);
+    }
+
+    @Override
+    public void removePermission(String s) {
+        instance.removePermission(s);
+    }
+
+    @Override
+    public Set<Permission> getDefaultPermissions(boolean b) {
+        return instance.getDefaultPermissions(b);
+    }
+
+    @Override
+    public void recalculatePermissionDefaults(Permission permission) {
+        instance.recalculatePermissionDefaults(permission);
+    }
+
+    @Override
+    public void subscribeToPermission(String s, Permissible permissible) {
+        instance.subscribeToPermission(s, permissible);
+    }
+
+    @Override
+    public void unsubscribeFromPermission(String s, Permissible permissible) {
+        instance.unsubscribeFromPermission(s, permissible);
+    }
+
+    @Override
+    public Set<Permissible> getPermissionSubscriptions(String s) {
+        return instance.getPermissionSubscriptions(s);
+    }
+
+    @Override
+    public void subscribeToDefaultPerms(boolean b, Permissible permissible) {
+        instance.subscribeToDefaultPerms(b, permissible);
+    }
+
+    @Override
+    public void unsubscribeFromDefaultPerms(boolean b, Permissible permissible) {
+        instance.unsubscribeFromDefaultPerms(b, permissible);
+    }
+
+    @Override
+    public Set<Permissible> getDefaultPermSubscriptions(boolean b) {
+        return instance.getDefaultPermSubscriptions(b);
+    }
+
+    @Override
+    public Set<Permission> getPermissions() {
+        return instance.getPermissions();
+    }
+
+    @Override
+    public boolean useTimings() {
+        return instance.useTimings();
+    }
+}