查看“用户:Laxcat”的源代码

== 个人信息 ==
*一个业余的插件作者 自称废柴的家伙
*能够熟练编写插件
*但是对于Java的了解不够深入
#MCBBS ID： q513902026
#Github ID: HopeAsd(q513902026)
#Github: [http://github.com/q513902026 我的GitHub页面]
== 代码预留地 ==
=== 自动搜索特定jar包中的特定包中的特定类(继承某个类)对其进行无参实例化 ===
ListenerFactory.java
<source lang="java">
package io.bilicraft.r6.bbs;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import io.bilicraft.r6.bbs.listener.BaseListener;

public class ListenerFactory {
    private static final boolean debug = false;
    
    public static void main(String[] args) throws Exception {
	for (Class<?> clazz : getBaseListenerClasses("io.bilicraft.r6.bbs")) {
	    if (debug) {
		System.out.println(clazz.getSimpleName());
	    }
	    
	    clazz.newInstance();
	}
    }

    /**
     * 从包package中获取所有的BaseListener Class
     * 
     * @param pack
     * @return
     */
    public static Set<Class<?>> getBaseListenerClasses(String pack) {

	// 第一个class类的集合
	Set<Class<?>> classes = new HashSet<Class<?>>();
	// 是否循环迭代
	boolean recursive = true;
	// 获取包的名字 并进行替换
	String packageName = pack;
	String packageDirName = packageName.replace('.', '/');
	JarFile jar;
	try {
	    // 获取jar
	    /**
	     * Magic Value 输出文件名如果更改 请在这里修改
	     */
	    jar = new JarFile(new File("." + File.separator + "plugins" + File.separator + "BiliBS.jar"));

	    // 从此jar包 得到一个枚举类
	    Enumeration<JarEntry> entries = jar.entries();
	    // 同样的进行循环迭代
	    while (entries.hasMoreElements()) {
		// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
		JarEntry entry = entries.nextElement();
		String name = entry.getName();
		// 如果是以/开头的
		if (name.charAt(0) == '/') {
		    // 获取后面的字符串
		    name = name.substring(1);
		}
		// 如果前半部分和定义的包名相同
		if (name.startsWith(packageDirName)) {
		    int idx = name.lastIndexOf('/');
		    // 如果以"/"结尾 是一个包
		    if (idx != -1) {
			// 获取包名 把"/"替换成"."
			packageName = name.substring(0, idx).replace('/', '.');
		    }
		    // 如果可以迭代下去 并且是一个包
		    if ((idx != -1) || recursive) {
			// 如果是一个.class文件 而且不是目录
			if (name.endsWith(".class") && !entry.isDirectory()) {
			    // 去掉后面的".class" 获取真正的类名
			    String className = name.substring(packageName.length() + 1, name.length() - 6);
			    try {
				Class<?> clasz = Class.forName(packageName + '.' + className);
				String superclazzName = BaseListener.class.getName();
				String superClasz = clasz.getSuperclass().getName();
				if (debug){
					System.out.println("super:"+superClasz);
				}	
				
				
				if (superClasz.equals(superclazzName)) {
				    if (!(clasz.getName().equals(superclazzName))) {
					
					classes.add(clasz);
				    }
				}
			    } catch (ClassNotFoundException e) {
				// log
				// .error("添加用户自定义视图类错误
				// 找不到此类的.class文件");
				System.out.println("找不到类");
			    }
			}
		    }
		}
	    }
	} catch (IOException e) {
	    // log.error("在扫描用户定义视图时从jar包获取文件出错");
	    System.out.println("IO错误 找不到");
	}

	return classes;
    }

    /**
     * 以文件的形式来获取包下的所有Class
     * 
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
	    Set<Class<?>> classes) {
	// 获取此包的目录 建立一个File
	File dir = new File(packagePath);
	// 如果不存在或者 也不是目录就直接返回
	if (!dir.exists() || !dir.isDirectory()) {
	    // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
	    return;
	}
	// 如果存在 就获取包下的所有文件 包括目录
	File[] dirfiles = dir.listFiles(new FileFilter() {
	    // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
	    public boolean accept(File file) {
		return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
	    }
	});
	// 循环所有文件
	for (File file : dirfiles) {
	    // 如果是目录 则继续扫描
	    if (file.isDirectory()) {
		findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
			classes);
	    } else {
		// 如果是java类文件 去掉后面的.class 只留下类名
		String className = file.getName().substring(0, file.getName().length() - 6);
		try {
		    // 添加到集合中去
		    // classes.add(Class.forName(packageName + '.' +
		    // className));
		    // 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
		    classes.add(
			    Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
		} catch (ClassNotFoundException e) {
		    System.out.println("找不到类");
		}
	    }
	}
    }

}
</source>
特定包 请把io.bilicraft.r6.bbs更改
特定jar文件 请把getBaseListenerClasses方法中的jar的FilePath更改为你需要检测的jar文件

=== 继承此类自动在实例化时注册监听器 ===
BaseListener.java
<source lang="java">package io.bilicraft.r6.bbs.listener;

import java.util.logging.Logger;

import org.bukkit.event.Listener;

import io.bilicraft.r6.bbs.BiliBS;

/**
 * 父类 继承后请设定为无参构造
 * 
 * @author HopeAsd
 *
 */
public class BaseListener implements Listener {
    private String name;
    private final String version;
    private Logger logger = BiliBS.getInstance().getLogger();
    private boolean debug = false;

    /**
     * 请务必保证构造为无参构造 否则会注册失败
     * 
     * @param name
     *            监听器的名字
     * @param version
     *            监听器的版本
     */
    public BaseListener(String name, final String version) {
	this.name = name;
	this.version = version;
	BiliBS.addListener(name, this);
    }

    /**
     * 调用此方法可以往服务端发送信息 自动标示监听器名字
     * 
     * @param strings
     */
    protected void sendConsoleMessage(String... strings) {
	StringBuilder sBuilder = new StringBuilder();
	for (String s : strings) {
	    sBuilder.append(s + "\n");
	}
	logger.info("[" + name + "]:" + sBuilder.toString());
    }

    /**
     * 获取监听器版本
     * 
     * @return 监听器的版本
     */
    public final String getVersion() {
	return version;
    }

    /**
     * 是否为debug输出模式
     * 
     * @return 是否为debug输出模式
     */
    public boolean isDebug() {
	return debug;
    }

    /**
     * 更改debug输出模式
     */
    public void setDebug() {
	debug = !debug;
    }

    /**
     * 使用此方法用于注册监听器和反注册监听器
     * 
     * @return 监听器名字
     */
    public String getName() {
	return this.name;
    }
}
</source>
==== Example BaseListener ====
<source  lang="java">
package io.bilicraft.r6.bbs.listener;

import org.bukkit.Chunk;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Zombie;
import org.bukkit.event.EventHandler;
import org.bukkit.event.world.ChunkUnloadEvent;
/**
 * 管理实体的监听器
 * @author HopeAsd
 *
 */
public class EntityListener extends BaseListener {
    private static boolean debug = false;
    public EntityListener() {
	super("EntityListener","v0.1.0");
    }
    @EventHandler
    public void onChunkUnloadEvent(ChunkUnloadEvent event) {
	Chunk chunk = event.getChunk();
	for (Entity entity : chunk.getEntities()) {
	    if (isClearEntity(entity)) {
		if (debug) {
		    sendConsoleMessage("Entity: " + entity.getType() + "Location:{x:" + (int) entity.getLocation().getX()
			    + ",y:" + (int) entity.getLocation().getY() + ",z:" + (int) entity.getLocation().getZ()
			    + "}");
		    ;
		}
		entity.remove();
	    }
	}
    }
    public static boolean isClearEntity(Entity entity) {
	    switch (entity.getType()) {

	    case ZOMBIE:
		if (((Zombie) entity).isVillager()) {
		    return false;
		}
	    case CREEPER:
	    case SKELETON:
	    case SPIDER:
	    case CAVE_SPIDER:
	    case SQUID:
	    case PIG_ZOMBIE:
		return true;
	    default:
		break;
	    }
	
	return false;
    }
}
</source>

=== 对所有继承BaseListener的实例进行操作 ===
BiliBS.java
<source lang="java">package io.bilicraft.r6.bbs;

import java.util.HashMap;

import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
import io.bilicraft.r6.bbs.listener.BaseListener;

public class BiliBS extends JavaPlugin implements Listener {
    private static BiliBS instance;
    private static HashMap<String, BaseListener> enableListenerList = new HashMap<String, BaseListener>();
    private static HashMap<String, BaseListener> disableListenerList = new HashMap<String, BaseListener>();

    @Override
    public void onEnable() {
	instance = this;
	try {
	    ListenerFactory.main(null);
	} catch (Exception e) {
	    getLogger().info("加载监听类错误" + e.getClass().getName());
	}
	;
	getServer().getPluginManager().registerEvents(this, this);
	// System.out.println("["+BiliBS.class.getName()+"]:
	// "+getServer().getBukkitVersion());
	registerListeners();
	registerCommands();
    }

    @Override
    public void onDisable() {
	instance = null;
    }

    public static BiliBS getInstance() {
	return instance;
    }
    
    private void registerCommands() {
	getCommand("bilibs").setExecutor(new BilibsCommand());
    }

    private void registerListeners() {
	for (BaseListener listener : enableListenerList.values()) {
	    getServer().getPluginManager().registerEvents(listener, instance);
	    getLogger().info("Listener:" + listener.getName() + "<" + listener.getVersion() + ">" + "注册完成 ,debug:"
		    + listener.isDebug());
	}
    }

    public static void registerListener(BaseListener baseListener) throws Exception {
	if (disableListenerList.containsKey(baseListener.getName())) {
	    disableListenerList.remove(baseListener.getName(), baseListener);

	    BaseListener listener = baseListener.getClass().newInstance();
	    BiliBS.getInstance().getServer().getPluginManager().registerEvents(listener, instance);
	    BiliBS.getInstance().getLogger().info("Listener:" + listener.getName() + "<" + listener.getVersion() + ">" + "注册完成 ,debug:"
		    + listener.isDebug());
	}
    }

    public static void addListener(String name, BaseListener baseListener) {
	enableListenerList.put(name, baseListener);
    }

    public static void removeListener(BaseListener baseListener) {
	if (enableListenerList.containsKey(baseListener.getName())) {
	    enableListenerList.remove(baseListener.getName(),baseListener);
	    disableListenerList.put(baseListener.getName(), baseListener);
	    HandlerList.unregisterAll(baseListener);
	}

    }

    public static StringBuilder getListenerList() {
	StringBuilder sBuilder = new StringBuilder(ChatColor.GREEN + "[BiliBS]: \nListenerList:");
	sBuilder.append("[");
	for (String listenerName : enableListenerList.keySet()) {
	    sBuilder.append(ChatColor.GREEN + listenerName + "<"+enableListenerList.get(listenerName).isDebug()+">,");
	}
	for (String listenerName : disableListenerList.keySet()) {
	    sBuilder.append(ChatColor.RED + listenerName + "<"+disableListenerList.get(listenerName).isDebug()+">,");
	}
	sBuilder.append("]");
	return sBuilder;
    }
    public static BaseListener getEnableListener(String key)
    {
	return enableListenerList.get(key);
    }
    public static BaseListener getDisableListener(String key)
    {
	return disableListenerList.get(key);
    }
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
	
	return super.onCommand(sender, command, label, args);

    }

}
</source>