build(all): 项目结构优化

优化整体项目结构，优化Javadoc生成方式与部署方式。
2026-06-04 08:38:17 +08:00 · 2022-05-22 23:01:52 +08:00
parent 94c9cc382d
commit 226121c1df
54 changed files with 211 additions and 2114 deletions
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>easyplugin-parent</artifactId>
+        <groupId>cc.carm.lib</groupId>
+        <version>1.4.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <properties>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+    </properties>
+
+
+    <artifactId>easyplugin-main</artifactId>
+    <packaging>jar</packaging>
+
+    <name>EasyPlugin-Main</name>
+    <description>轻松插件主要接口模块，包含方便的插件入口类与相关工具类。</description>
+    <url>https://github.com/CarmJos/EasyPlugin</url>
+
+    <developers>
+        <developer>
+            <id>CarmJos</id>
+            <name>Carm Jos</name>
+            <email>carm@carm.cc</email>
+            <url>https://www.carm.cc</url>
+        </developer>
+    </developers>
+
+    <licenses>
+        <license>
+            <name>The MIT License</name>
+            <url>https://opensource.org/licenses/MIT</url>
+        </license>
+    </licenses>
+
+    <issueManagement>
+        <system>GitHub Issues</system>
+        <url>https://github.com/CarmJos/EasyPlugin/issues</url>
+    </issueManagement>
+
+    <ciManagement>
+        <system>GitHub Actions</system>
+        <url>https://github.com/CarmJos/EasyPlugin/actions/workflows/maven.yml</url>
+    </ciManagement>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.10.9</version>
+            <scope>provided</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
@@ -0,0 +1,44 @@
+package cc.carm.lib.easyplugin.utils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public class ColorParser {
+
+    public static final Pattern HEX_PATTERN = Pattern.compile("&\\(&?#([0-9a-fA-F]{6})\\)");
+
+    public static String parse(String text) {
+        return parseBaseColor(parseHexColor(text));
+    }
+
+    public static String[] parse(String... texts) {
+        return parse(Arrays.asList(texts)).toArray(new String[0]);
+    }
+
+    public static List<String> parse(List<String> texts) {
+        return texts.stream().map(ColorParser::parse).collect(Collectors.toList());
+    }
+
+    public static String parseBaseColor(final String text) {
+        return text.replaceAll("&", "§").replace("§§", "&");
+    }
+
+    public static String parseHexColor(String text) {
+        Matcher matcher = HEX_PATTERN.matcher(text);
+        while (matcher.find()) {
+            text = matcher.replaceFirst(buildHexColor(matcher.group(1)).toLowerCase());
+            matcher.reset(text);
+        }
+        return text;
+    }
+
+    private static String buildHexColor(String hexCode) {
+        return Arrays.stream(hexCode.split(""))
+                .map(s -> '§' + s)
+                .collect(Collectors.joining("", '§' + "x", ""));
+    }
+
+}
@@ -0,0 +1,144 @@
+package cc.carm.lib.easyplugin.utils;
+
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.Damageable;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ItemStackFactory {
+	ItemStack item;
+
+	private ItemStackFactory() {
+	}
+
+	public ItemStackFactory(ItemStack is) {
+		this.item = is.clone();
+	}
+
+	public ItemStackFactory(Material type) {
+		this(type, 1);
+	}
+
+	public ItemStackFactory(Material type, int amount) {
+		this(type, amount, (short) 0);
+	}
+
+	public ItemStackFactory(Material type, int amount, short data) {
+		this.item = new ItemStack(type, amount, data);
+	}
+
+	public ItemStackFactory(Material type, int amount, int data) {
+		this(type, amount, (short) data);
+	}
+
+	public ItemStack toItemStack() {
+		return this.item;
+	}
+
+	public ItemStackFactory setType(Material type) {
+		this.item.setType(type);
+		return this;
+	}
+
+	public ItemStackFactory setDurability(int i) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im instanceof Damageable) {
+			((Damageable) im).setDamage(i);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory setAmount(int a) {
+		this.item.setAmount(a);
+		return this;
+	}
+
+	public ItemStackFactory setDisplayName(@NotNull String name) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.setDisplayName(ColorParser.parse(name));
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory setLore(@NotNull List<String> loreList) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.setLore(
+					loreList.stream()
+							.map(ColorParser::parse)
+							.collect(Collectors.toList())
+			);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory addLore(@NotNull String s) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			List<String> lore = im.getLore() != null ? im.getLore() : new ArrayList<>();
+			lore.add(ColorParser.parse(s));
+			im.setLore(lore);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory addEnchant(@NotNull Enchantment enchant, int level, boolean ignoreLevelRestriction) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.addEnchant(enchant, level, ignoreLevelRestriction);
+			this.item.setItemMeta(im);
+		}
+
+		return this;
+	}
+
+	public ItemStackFactory removeEnchant(@NotNull Enchantment enchant) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.removeEnchant(enchant);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory addFlag(@NotNull ItemFlag flag) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.addItemFlags(flag);
+			this.item.setItemMeta(im);
+		}
+
+		return this;
+	}
+
+	public ItemStackFactory removeFlag(@NotNull ItemFlag flag) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.removeItemFlags(flag);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+
+	public ItemStackFactory setUnbreakable(boolean unbreakable) {
+		ItemMeta im = this.item.getItemMeta();
+		if (im != null) {
+			im.setUnbreakable(unbreakable);
+			this.item.setItemMeta(im);
+		}
+		return this;
+	}
+}
@@ -0,0 +1,105 @@
+package cc.carm.lib.easyplugin.utils;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+@SuppressWarnings("ResultOfMethodCallIgnored")
+public class JarResourceUtils {
+    public static final char JAR_SEPARATOR = '/';
+
+    public static @Nullable String[] readResource(@Nullable InputStream resourceStream) {
+        if (resourceStream == null) return null;
+        try (Scanner scanner = new Scanner(resourceStream, "UTF-8")) {
+            List<String> contents = new ArrayList<>();
+            while (scanner.hasNextLine()) {
+                contents.add(scanner.nextLine());
+            }
+            return contents.toArray(new String[0]);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public static void copyFolderFromJar(String folderName, File destFolder, CopyOption option)
+            throws IOException {
+        copyFolderFromJar(folderName, destFolder, option, null);
+    }
+
+    public static void copyFolderFromJar(String folderName, File destFolder,
+                                         CopyOption option, PathTrimmer trimmer) throws IOException {
+        if (!destFolder.exists())
+            destFolder.mkdirs();
+
+        byte[] buffer = new byte[1024];
+
+        File fullPath;
+        String path = JarResourceUtils.class.getProtectionDomain().getCodeSource().getLocation().getPath();
+        if (trimmer != null)
+            path = trimmer.trim(path);
+        try {
+            if (!path.startsWith("file"))
+                path = "file://" + path;
+
+            fullPath = new File(new URI(path));
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        ZipInputStream zis = new ZipInputStream(new FileInputStream(fullPath));
+
+        ZipEntry entry;
+        while ((entry = zis.getNextEntry()) != null) {
+            if (!entry.getName().startsWith(folderName + JAR_SEPARATOR))
+                continue;
+
+            String fileName = entry.getName();
+
+            if (fileName.charAt(fileName.length() - 1) == JAR_SEPARATOR) {
+                File file = new File(destFolder + File.separator + fileName);
+                if (file.isFile()) {
+                    file.delete();
+                }
+                file.mkdirs();
+                continue;
+            }
+
+            File file = new File(destFolder + File.separator + fileName);
+            if (option == CopyOption.COPY_IF_NOT_EXIST && file.exists())
+                continue;
+
+            if (!file.getParentFile().exists())
+                file.getParentFile().mkdirs();
+
+            if (!file.exists())
+                file.createNewFile();
+            FileOutputStream fos = new FileOutputStream(file);
+
+            int len;
+            while ((len = zis.read(buffer)) > 0) {
+                fos.write(buffer, 0, len);
+            }
+            fos.close();
+        }
+
+        zis.closeEntry();
+        zis.close();
+    }
+
+    public enum CopyOption {
+        COPY_IF_NOT_EXIST, REPLACE_IF_EXIST
+    }
+
+    @FunctionalInterface
+    public interface PathTrimmer {
+        String trim(String original);
+    }
+}
@@ -0,0 +1,355 @@
+package cc.carm.lib.easyplugin.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.Callable;
+
+@SuppressWarnings("DuplicatedCode")
+public class SchedulerUtils {
+
+	private final JavaPlugin plugin;
+
+	public SchedulerUtils(JavaPlugin plugin) {
+		this.plugin = plugin;
+	}
+
+	private JavaPlugin getPlugin() {
+		return plugin;
+	}
+
+
+	/**
+	 * 在服务端主线程中执行一个任务
+	 *
+	 * @param runnable 需要执行的任务
+	 */
+	public void run(Runnable runnable) {
+		Bukkit.getScheduler().runTask(getPlugin(), runnable);
+	}
+
+
+	/**
+	 * 异步执行一个任务。
+	 *
+	 * @param runnable 需要执行的任务
+	 */
+	public void runAsync(Runnable runnable) {
+		Bukkit.getScheduler().runTaskAsynchronously(getPlugin(), runnable);
+	}
+	
+	/**
+	 * 在主线程延时执行一个任务。
+	 *
+	 * @param delay    延迟的ticks
+	 * @param runnable 需要执行的任务
+	 */
+	public void runLater(long delay, Runnable runnable) {
+		Bukkit.getScheduler().runTaskLater(getPlugin(), runnable, delay);
+	}
+
+	/**
+	 * 异步延时执行一个任务。
+	 *
+	 * @param delay    延迟的ticks
+	 * @param runnable 需要执行的任务
+	 */
+	public void runLaterAsync(long delay, Runnable runnable) {
+		Bukkit.getScheduler().runTaskLaterAsynchronously(getPlugin(), runnable, delay);
+	}
+
+	/**
+	 * 间隔一段时间按顺序执行列表中的任务
+	 *
+	 * @param interval 间隔时间
+	 * @param tasks    任务列表
+	 */
+	public void runAtInterval(long interval, Runnable... tasks) {
+		runAtInterval(0L, interval, tasks);
+	}
+
+
+	/**
+	 * 间隔一段时间按顺序执行列表中的任务
+	 *
+	 * @param delay    延迟时间
+	 * @param interval 间隔时间
+	 * @param tasks    任务列表
+	 */
+	public void runAtInterval(long delay, long interval, Runnable... tasks) {
+		new BukkitRunnable() {
+			private int index;
+
+			@Override
+			public void run() {
+				if (this.index >= tasks.length) {
+					this.cancel();
+					return;
+				}
+
+				tasks[index].run();
+				index++;
+			}
+		}.runTaskTimer(getPlugin(), delay, interval);
+	}
+
+	/**
+	 * 间隔一段时间按顺序异步执行列表中的任务
+	 *
+	 * @param interval 间隔时间
+	 * @param tasks    任务列表
+	 */
+	public void runAtIntervalAsync(long interval, Runnable... tasks) {
+		runAtIntervalAsync(0L, interval, tasks);
+	}
+
+	/**
+	 * 间隔一段时间按顺序异步执行列表中的任务
+	 *
+	 * @param delay    延迟时间
+	 * @param interval 间隔时间
+	 * @param tasks    任务列表
+	 */
+	public void runAtIntervalAsync(long delay, long interval, Runnable... tasks) {
+		new BukkitRunnable() {
+			private int index;
+
+			@Override
+			public void run() {
+				if (this.index >= tasks.length) {
+					this.cancel();
+					return;
+				}
+
+				tasks[index].run();
+				index++;
+			}
+		}.runTaskTimerAsynchronously(getPlugin(), delay, interval);
+	}
+
+	/**
+	 * 重复执行一个任务。
+	 *
+	 * @param repetitions 重复次数
+	 * @param interval    间隔时间
+	 * @param task        任务
+	 * @param onComplete  结束时执行的任务
+	 */
+	public void repeat(int repetitions, long interval, Runnable task, Runnable onComplete) {
+		new BukkitRunnable() {
+			private int index;
+
+			@Override
+			public void run() {
+				index++;
+				if (this.index >= repetitions) {
+					this.cancel();
+					if (onComplete == null) {
+						return;
+					}
+
+					onComplete.run();
+					return;
+				}
+
+				task.run();
+			}
+		}.runTaskTimer(getPlugin(), 0L, interval);
+	}
+
+	/**
+	 * 重复执行一个任务。
+	 *
+	 * @param repetitions 重复次数
+	 * @param interval    间隔时间
+	 * @param task        任务
+	 * @param onComplete  结束时执行的任务
+	 */
+	public void repeatAsync(int repetitions, long interval, Runnable task, Runnable onComplete) {
+		new BukkitRunnable() {
+			private int index;
+
+			@Override
+			public void run() {
+				index++;
+				if (this.index >= repetitions) {
+					this.cancel();
+					if (onComplete == null) {
+						return;
+					}
+
+					onComplete.run();
+					return;
+				}
+
+				task.run();
+			}
+		}.runTaskTimerAsynchronously(getPlugin(), 0L, interval);
+	}
+
+	/**
+	 * 在满足某个条件时，重复执行一个任务。
+	 *
+	 * @param interval   重复间隔时间
+	 * @param predicate  条件
+	 * @param task       任务
+	 * @param onComplete 结束时执行的任务
+	 */
+	public void repeatWhile(long interval, Callable<Boolean> predicate, Runnable task, Runnable onComplete) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					if (!predicate.call()) {
+						this.cancel();
+						if (onComplete == null) {
+							return;
+						}
+
+						onComplete.run();
+						return;
+					}
+
+					task.run();
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskTimer(getPlugin(), 0L, interval);
+	}
+
+	/**
+	 * 在满足某个条件时，重复执行一个任务。
+	 *
+	 * @param interval   重复间隔时间
+	 * @param predicate  条件
+	 * @param task       任务
+	 * @param onComplete 结束时执行的任务
+	 */
+	public void repeatWhileAsync(long interval, Callable<Boolean> predicate, Runnable task, Runnable onComplete) {
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				try {
+					if (!predicate.call()) {
+						this.cancel();
+						if (onComplete == null) {
+							return;
+						}
+
+						onComplete.run();
+						return;
+					}
+
+					task.run();
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		}.runTaskTimerAsynchronously(getPlugin(), 0L, interval);
+	}
+
+	public interface Task {
+		void start(Runnable onComplete);
+	}
+
+	public class TaskBuilder {
+		private final Queue<Task> taskList;
+
+		public TaskBuilder() {
+			this.taskList = new LinkedList<>();
+		}
+
+		public TaskBuilder append(TaskBuilder builder) {
+			this.taskList.addAll(builder.taskList);
+			return this;
+		}
+
+		public TaskBuilder appendDelay(long delay) {
+			this.taskList.add(onComplete -> SchedulerUtils.this.runLater(delay, onComplete));
+			return this;
+		}
+
+		public TaskBuilder appendTask(Runnable task) {
+			this.taskList.add(onComplete ->
+			{
+				task.run();
+				onComplete.run();
+			});
+
+			return this;
+		}
+
+		public TaskBuilder appendTask(Task task) {
+			this.taskList.add(task);
+			return this;
+		}
+
+		public TaskBuilder appendDelayedTask(long delay, Runnable task) {
+			this.taskList.add(onComplete -> SchedulerUtils.this.runLater(delay, () ->
+			{
+				task.run();
+				onComplete.run();
+			}));
+
+			return this;
+		}
+
+		public TaskBuilder appendTasks(long delay, long interval, Runnable... tasks) {
+			this.taskList.add(onComplete ->
+			{
+				Runnable[] runnables = Arrays.copyOf(tasks, tasks.length + 1);
+				runnables[runnables.length - 1] = onComplete;
+				SchedulerUtils.this.runAtInterval(delay, interval, runnables);
+			});
+
+			return this;
+		}
+
+		public TaskBuilder appendRepeatingTask(int repetitions, long interval, Runnable task) {
+			this.taskList.add(onComplete -> SchedulerUtils.this.repeat(repetitions, interval, task, onComplete));
+			return this;
+		}
+
+		public TaskBuilder appendConditionalRepeatingTask(long interval, Callable<Boolean> predicate, Runnable task) {
+			this.taskList.add(onComplete -> SchedulerUtils.this.repeatWhile(interval, predicate, task, onComplete));
+			return this;
+		}
+
+		public TaskBuilder waitFor(Callable<Boolean> predicate) {
+			this.taskList.add(onComplete -> new BukkitRunnable() {
+				@Override
+				public void run() {
+					try {
+						if (!predicate.call()) {
+							return;
+						}
+
+						this.cancel();
+						onComplete.run();
+					} catch (Exception e) {
+						e.printStackTrace();
+					}
+				}
+			}.runTaskTimer(getPlugin(), 0L, 1L));
+			return this;
+		}
+
+		public void runTasks() {
+			this.startNext();
+		}
+
+		private void startNext() {
+			Task task = this.taskList.poll();
+			if (task == null) {
+				return;
+			}
+
+			task.start(this::startNext);
+		}
+	}
+}