String s = "helloworld";
boolean b = true;
int i = 123;
long l = 123456789;

public static FileConfiguration extraConfigs(Plugin plugin, String config) {
    return YamlConfiguration.loadConfiguration(
        // 从插件目录下获取
        new File(plugin.getDataFolder(), config)
    );
}

/*
 plugin是你的插件对象
 config是你的配置文件名字，如果需要读子目录就要写相对于插件目录的绝对路径
*/
extraConfigs(Plugin plugin, String config);

// 需要先定义插件对象Plugin plugin
FileConfiguration Config = YamlConfiguration.loadConfiguration(
    new File(plugin.getDataFolder(), "文件名")
);

// 例子1
extraConfigs(Bukkit.getPlugin("Demo"), "custom-config.yml").getString("demo");
// 例子2
Plugin plugin = Bukkit.getPlugin("Demo");
FileConfiguration Config = YamlConfiguration.loadConfiguration(
    new File(plugin.getDataFolder(), "demo")
);
Config.getString("demo");

package moe.xmcn.example;

import java.sql.*;
import java.util.Arrays;
import java.util.UUID;
import java.util.logging.Level;

public class Database {

    public static class UUIDDatabase {
        private static Connection getDatabase() {
            Connection c = null;
            try {
                Class.forName("org.sqlite.JDBC");
                c = DriverManager.getConnection("jdbc:sqlite:" + Config.plugin.getDataFolder() + "/database.db");
            } catch (Exception e) {
                Config.plugin.getLogger().log(Level.WARNING, "连接数据库发生异常:\n" + Arrays.toString(e.getStackTrace()));
            }
            return c;
        }

        public static void intTable() throws SQLException {
            Statement cs = getDatabase().createStatement();
            String ct = "CREATE TABLE IF NOT EXISTS UUIDTableMap" +
                        "(NAME TEXT     NOT NULL, " +
                        " UUID TEXT     NOT NULL)";
            cs.executeUpdate(ct);
            cs.close();
        }

        public static void insertTable(String player_name, UUID player_uuid) throws SQLException {
            Statement cs = getDatabase().createStatement();
            String ct = "INSERT INTO UUIDTableMap (NAME, UUID)" +
                        " VALUES ('" + player_name + "', '" + player_uuid + "')";
            cs.executeUpdate(ct);
            cs.close();
        }

        public static class readTable {
            public static UUID getUUID(String name) throws SQLException {
                UUID uuid = null;

                Statement cs = getDatabase().createStatement();
                ResultSet rs = cs.executeQuery("SELECT * FROM UUIDTableMap;");
                while (rs.next()) {
                    uuid = UUID.fromString(rs.getString(name));
                }
                rs.close();
                cs.close();
                return uuid;
            }

            public static String getName(UUID uuid) throws SQLException {
                String name = null;

                Statement cs = getDatabase().createStatement();
                ResultSet rs = cs.executeQuery("SELECT * FROM UUIDTableMap;");
                while (rs.next()) {
                    name = rs.getString(String.valueOf(uuid));
                }
                rs.close();
                cs.close();
                return name;
            }
        }
    }

}

Plugin plugin = Main.getPlugin(Main.class);

package moe.xmcn.example;

import moe.xmcn.catsero.utils.Config;
import moe.xmcn.catsero.utils.Database;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;

import java.sql.SQLException;
import java.util.UUID;
import java.util.logging.Level;

public class PlayerRecord {

    public static class UUIDRecord implements Listener {
        @EventHandler
        public void record(PlayerJoinEvent pje) {
            String player_name = pje.getPlayer().getName();
            UUID player_uuid = pje.getPlayer().getUniqueId();
            try {
                Database.UUIDDatabase.insertTable(player_name, player_uuid);
            } catch (SQLException e) {
                Config.plugin.getLogger().log(Level.WARNING, "无法写入数据库");
            }
        }
    }
}

Database.UUIDDatabase.readTable.getUUID(String name);

Database.UUIDDatabase.readTable.getName(String name);

package moe.xmcn.example;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * @author  XiaMoHuaHuo_CN
 * @author  zh32 <zh32 at zh32.de>
 * @author  猫车车
 */
public class ServerListPing {

    private InetSocketAddress host;
    private int timeout = 7000;
    public void setAddress(InetSocketAddress host) {
        this.host = host;
    }

    public InetSocketAddress getAddress() {
        return host;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public int getTimeout() {
        return this.timeout;
    }

    public int readVarInt(DataInputStream in) throws IOException {
        int i = 0;
        int j = 0;
        while (true) {
            int k = in.readByte();
            i |= (k & 0x7F) << j++ * 7;
            if (j > 5) throw new RuntimeException("VarInt too big");
            if ((k & 0x80) != 128) break;
        }
        return i;
    }

    public void writeVarInt(DataOutputStream out, int paramInt) throws IOException {
        while (true) {
            if ((paramInt & 0xFFFFFF80) == 0) {
                out.writeByte(paramInt);
                return;
            }

            out.writeByte(paramInt & 0x7F | 0x80);
            paramInt >>>= 7;
        }
    }

    public void fetchData() throws IOException {

        Socket socket = new Socket();
        OutputStream outputStream;
        DataOutputStream dataOutputStream;
        InputStream inputStream;
        InputStreamReader inputStreamReader;

        socket.setSoTimeout(this.timeout);

        socket.connect(host, timeout);

        outputStream = socket.getOutputStream();
        dataOutputStream = new DataOutputStream(outputStream);

        inputStream = socket.getInputStream();
        inputStreamReader = new InputStreamReader(inputStream);

        ByteArrayOutputStream b = new ByteArrayOutputStream();
        DataOutputStream handshake = new DataOutputStream(b);
        handshake.writeByte(0x00); //packet id for handshake
        writeVarInt(handshake, 4); //protocol version
        writeVarInt(handshake, host.getHostString().length()); //host length
        handshake.writeBytes(host.getHostString()); //host string
        handshake.writeShort(host.getPort()); //port
        writeVarInt(handshake, 1); //state (1 for handshake)

        writeVarInt(dataOutputStream, b.size()); //prepend size
        dataOutputStream.write(b.toByteArray()); //write handshake packet


        dataOutputStream.writeByte(0x01); //size is only 1
        dataOutputStream.writeByte(0x00); //packet id for ping
        DataInputStream dataInputStream = new DataInputStream(inputStream);
        int size = readVarInt(dataInputStream); //size of packet
        int id = readVarInt(dataInputStream); //packet id

        if (id == -1) {
            throw new IOException("Premature end of stream.");
        }

        if (id != 0x00) { //we want a status response
            throw new IOException("Invalid packetID");
        }
        int length = readVarInt(dataInputStream); //length of json string

        if (length == -1) {
            throw new IOException("Premature end of stream.");
        }

        if (length == 0) {
            throw new IOException("Invalid string length.");
        }

        byte[] in = new byte[length];
        dataInputStream.readFully(in);  //read json string
        String json = new String(in);


        long now = System.currentTimeMillis();
        dataOutputStream.writeByte(0x09); //size of packet
        dataOutputStream.writeByte(0x01); //0x01 for ping
        dataOutputStream.writeLong(now); //time!?

        readVarInt(dataInputStream);
        id = readVarInt(dataInputStream);
        if (id == -1) {
            throw new IOException("Premature end of stream.");
        }

        if (id != 0x01) {
            throw new IOException("Invalid packetID");
        }
        //read response

        JSONObject object = JSON.parseObject(json);
        JSONObject players = JSON.parseObject(object.get("players").toString());
        JSONObject description = JSON.parseObject(object.get("description").toString());
        JSONObject version = JSON.parseObject(object.get("version").toString());
        List<Object> list = new ArrayList<Object>(JSON.parseArray(String.valueOf(description.get("extra"))));

        StringBuilder Motd = new StringBuilder();
        for (Object o : list) {
            JSONObject text = JSON.parseObject(o.toString());
            Motd.append(text.get("text"));
        }

        if (object.get("favicon").toString() != null) {
            ServerListPing.Response.setIcon(object.get("favicon").toString());
        } else {
            ServerListPing.Response.setIcon("");
        }

        ServerListPing.Response.setPlayerMax(players.get("max").toString());
        ServerListPing.Response.setPlayerOnline(players.get("online").toString());
        ServerListPing.Response.setProtocol(version.get("protocol").toString());
        ServerListPing.Response.setVersion(version.get("name").toString());
        ServerListPing.Response.setMOTD(Motd.toString());

        dataOutputStream.close();
        outputStream.close();
        inputStreamReader.close();
        inputStream.close();
        socket.close();
    }

    /**
     * 获取请求结果
     */
    public static class Response {

        private static String player_max;
        private static String protocol;
        private static String player_online;
        private static String version;
        private static String motd;
        private static String favicon;
        public static String getPlayerMax() {
            return Response.player_max;
        }

        public static String getPlayerOnline() {
            return Response.player_online;
        }

        public static String getProtocol() {
            return Response.protocol;
        }

        public static String getVersion() {
            return Response.version;
        }

        public static String getMOTD() {
            return Response.motd;
        }

        public static String getIcon() {
            return favicon;
        }

        // 内部变量 设置结果
        private static void setPlayerMax(String player_max) {
            Response.player_max = player_max;
        }

        private static void setPlayerOnline(String player_online) {
            Response.player_online = player_online;
        }

        private static void setProtocol(String protocol) {
            Response.protocol = protocol;
        }

        private static void setVersion(String version) {
            Response.version = version;
        }

        private static void setMOTD(String motd) {
            Response.motd = motd;
        }

        private static void setIcon(String favicon) {
            Response.favicon = favicon;
        }

    }

}

InetSocketAddress isa = new InetSocketAddress(String host, int port);
ServerListPing slp = new ServerListPing();
slp.setAddress(isa);

// 也可以手动设置延迟，单位ms，不设置默认是7000
//slp.setTimeout(int timeout);

slp.fetchData();

// 获得服务器版本
ServerListPing.Response.getVersion();

// 获得服务器协议版本
ServerListPing.Response.getProtocol();

// 获得服务器在线玩家数量
ServerListPing.Response.getPlayerOnline();

// 获得服务器最大玩家数量
ServerListPing.Response.getPlayerMax();

// 获得服务器MOTD
ServerListPing.Response.getMOTD();

// 获得服务器图标
ServerListPing.Response.getIcon();

public class ServerTPS implements Runnable {
    public static final long[] TICKS = new long[600];
    public static int TICK_COUNT = 0;

    public static double getTPS() {
        return getTPS(100);
    }

    public static double getTPS(int ticks) {
        if (TICK_COUNT < ticks) {
            return 20.0D;
        }
        int target = (TICK_COUNT - 1 - ticks) % TICKS.length;
        long elapsed = System.currentTimeMillis() - TICKS[target];

        return ticks / (elapsed / 1000.0D);
    }

    public static long getElapsed(int tickID) {
        long time = TICKS[(tickID % TICKS.length)];
        return System.currentTimeMillis() - time;
    }

    public void run() {
        TICKS[(TICK_COUNT % TICKS.length)] = System.currentTimeMillis();
        TICK_COUNT += 1;
    }
}

// 我这里类名叫ServerTPS，所以用的是new ServerTPS()
// 用的时候注意改成自己的类名
Bukkit.getServer().getScheduler().scheduleSyncRepeatingTask(this, new ServerTPS(), 100L, 1L);

// 记得引入类
import example.ServerTPS;

ServerTPS.getTPS();

// 记得引入类
import example.ServerTPS;

ServerTPS.getElapsed()