<project>
    ...
    <repositories>
            <!-- 先配置私服仓库地址 -->
            <repository>
                <id>legend</id>
                <url>http://www.legendrpg.top/nexus/repository/legend/</url>
            </repository>
        </repositories>
    <dependencies>
        <!-- 导入legendframework-core -->
        <dependency>
          <groupId>com.legendframework</groupId>
          <artifactId>legendframework-core</artifactId>
          <version>1.0.2</version>
        </dependency>
    </dependencies>
    ...
</project>

@Component()
public class Utils {
    
    @Bean("id_prop")
    public Prop xxx(){
        Prop prop = new Prop();
        prop.setName("xxx");
        return prop;
    }
}

@Bean
public PlayerInfo ccc(@com.legendframework.core.ioc.annotation.Resource(name = "id_prop") Prop prop){
    PlayerInfo playerInfo = new PlayerInfo();
    playerInfo.setLevel(prop.getShortcutKey());
    return playerInfo;
}

@Component("utils")
public class Utils {}

@Component
public class Utils{
    
    @Resource
    private Prop prop;
    
}

@Component
public class Utils{
    
    @Bean
    public Object getBean(@com.legendframework.core.ioc.annotation.Resource() Prop prop){
        return new String();
    }
    
}

public void getBean(){
    //其中plugin对象为主类对象
    com.legendframework.core.ioc.BeansFactory beansFactory = plugin.store.getBeansFactory();
    Prop bean = beansFactory.getBean(Prop.class);
}

    /**
     * 插件被启动时执行
     * 执行此方法的时候，框架已经初始化完成，所有可用Bean已经装配完毕
     */
    void start();

    /**
     * 插件被卸载时执行
     */
    void end();

    /**
     * 获取当前插件的根指令
     * 如果这个方法你返回NULL，请务必再你插件的plugin.yml中添加一个项：commands:
     * @return
     */
    String getRootCmd();

    /**
     * 当插件被载入的时调用
     * 该方法比 start() 更早执行
     * 不强制要求实现
     *
     * 框架启动前的初始化操作初始化
     * 或许你能想到实现这个方法后修改一下框架的一些参数，再让框架启动
     */
    void load() {
    }

	/**
     * 配置文件保存路径
     * 希望获取到的是类似：D:/server/plugins/ 这样的绝对目录，就是插件所在目录，当然你可以对其覆写修改
     * @return
     */
    String getSavePath();

	/**
     * 是否自动代替在plugin.yml中写入指令配置
     * @return 默认是true
     */
    default boolean isAutowiredRegister(){
        return true;
    }

    /**
     * 获取根指令配置
     * @return
     */
    com.legendframework.core.cmd.CommandRootConfig getCommandRootConfig();

/**
 * 指令相关配置
 *
 * 参考plugin.yml 中 commands: 配置项, 具体类见 {@link org.bukkit.command.Command}
 */
public class CommandRootConfig {

    /**
     * 根指令的介绍
     */
    protected String description;

    /**
     * 当指令管理器没找到用户输入的指令时，向用户提示该信息
     * 注意，该参数与{@link org.bukkit.command.Command#usageMessage} 不同
     */
    protected String usageMessage;

    /**
     * 使用根指令的权限
     */
    private String permission;

    /**
     * 当用户无上方权限时提示该信息
     */
    private String permissionMessage;
}

@MainPlugin
public class TestPlugin extends LegendPlugin {
    
    @Resource
    private Prop prop;

    @Override
    public void start() {
        System.out.println(prop);
    }

    @Override
    public void end() {

    }

    @Override
    public String getRootCmd() {
        return null;
    }
}

//plugin是主类对象
plugin.getDataFolder().getParentFile().getAbsolutePath();

#声明这个插件加载后,生成的配置文件在什么目录
configPath: "D://ddd/ddd/ddd"

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Entity {
    /**
     * 实体类存储类型
     * 定义后,该类只按照该值定义的类型来存储
     *
     * DataType.UNDEFINED 用于说明现目前不确定该实体类的存储类型，确切的存储类型由配置文件动态定义
     * 如果在@Entity.type()中提前定义了数据存储类型例如:DataType.MYSQL ，则该实体类会无视外部配置文件的动态配置
     * 每次始终使用实体类@Entity.type()中定义的存储方式
     * @return
     */
    DataType type() default DataType.UNDEFINED;
    /**
     * SQL表名 
     * 如果不指定，默认为本类类名驼峰转下划线，
     * 例如：UserTable -> user_table
     * @return
     */
    String sqlTableName() default "";
    /**
     * yaml文件相对路径
     * 如果 {@link Entity#yamlStorageType()} 取值为: YamlStorageType.MANY_TO_ONE
     * 则该值应该返回一个目录(文件夹)名称,如果为其他，这个值应该为一个".yml" 后缀的文件名称，但是".yml"后缀可以不用填写
     *
     * @return
     */
    String yamlFileName();
    /**
     * Yaml文件的存储类型
     *
     * 单个文件存储
     * 一个对象代表一个Yaml文件
     * ONE_TO_ONE
     *
     * 单个文件存储
     * 一个文件存储一个集合对象
     * ONE_TO_MANY
     *
     * 多个文件存储
     * 多个文件存储，每个文件存储一个对象
     * 指定目录下的所有文件，包括递归层级的文件都会读取
     * MANY_TO_ONE,
     *
     * @return
     */
    YamlStorageType yamlStorageType();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    /**
     * 字段别名
     * 条件查询会取这个字段名
     */
    String value() default "";
    /**
     * 是否映射到表中
     * @return
     */
    boolean exist() default true;
    
    /**
     * 字段注释
     * value()是一个数组，所对应的就是多行注释
     */
    String[] value() default "";
    /**
     * 是否安装字段类型来输出可选值范围
     *
     * 目前仅支持两种字段类型 Boolean | Enum
     *
     * Enum 类型字段必须实现如下接口
     * @see com.legendframework.core.dao.enums.IEnum
     *
     * @return
     */
    boolean isOutPutOptionalRange() default true;
    /**
     * 排序 值越小越靠前
     *
     * 小于1的值 代表永远排在最后
     * @return
     */
    int sort() default -1;
}

#无意义主键
id: "1"
#数据类型
#可选值: UNDEFINED : 不确定的类型 | YAML : yml文件存储 | MYSQL : mysql数据库存储
dataType: "YAML"
#Mysql主机地址
sqlHost: 
#Mysql端口
sqlPort: 
#Mysql数据库名
databaseName: 
#Mysql用户名
username: 
#Mysql密码
password: 

public interface IDao<T> extends IConfigDao<T> , IReload , CacheFlush{

    /**
     * 获取实体类类型
     * @return
     */
    Class<T> getEntityClass();

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    int deleteById(Serializable id);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param wrapper 实体对象封装操作类（可以为 null）
     */
    int delete(Wrapper<T> wrapper);

    /**
     * 删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(Collection<? extends Serializable> idList);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    int updateById(T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(T entity, Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(Collection<? extends Serializable> idList);

    /**
     * 根据 entity 条件，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @param throwEx      有多个 result 是否抛出异常
     */
    T selectOne(Wrapper<T> queryWrapper, boolean throwEx);

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    long selectCount(Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Page<T> selectPage(Page<T> page, Wrapper<T> queryWrapper);
}

eq(); //等于
ne(); //不等于
gt(); //大于
ge(); //大于等于
lt(); //小于
le(); //小于等于
in(); //指当前查询的值是否包含给定的一个比较值的集合,同等于SQL语法中的 IN (value1,value2,value3....)
notIn(); //与in()含义相同，不过这个是取反，指当前查询的值是否均不包含在给定一个比较值的集合中
like(); //模糊比较，比较提供的值，是否包含在值中，同等于SQL语法中的 LIKE
notLike(); //模糊比较取反
likeLeft(); //比较是否值是否以某值开头
likeRight(); //比较值只是否以某值结尾
isNull(); //是否为NULL
isNotNull; //是否不为NULL

eq(R column, Object val)
eq(boolean condition, R column, Object val)

ne(R column, Object val)
ne(boolean condition, R column, Object val)

gt(R column, Object val)
gt(boolean condition, R column, Object val)

ge(R column, Object val)
ge(boolean condition, R column, Object val)

lt(R column, Object val)
lt(boolean condition, R column, Object val)

le(R column, Object val)
le(boolean condition, R column, Object val)

in(R column, Object... values)
in(boolean condition, R column, Object... values)

notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

like(R column, Object val)
like(boolean condition, R column, Object val)

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

isNull(R column)
isNull(boolean condition, R column)

isNotNull(R column)
isNotNull(boolean condition, R column)

and()
and(boolean condition)

and(Function<Param, Param> func)
and(boolean condition, Function<Param, Param> func)

or()
or(boolean condition)

or(Function<Param, Param> func)
or(boolean condition, Function<Param, Param> func)

//首先从Wrappers类中获取条件构造器
//普通方式
QueryWrapper<T> query();
//lambda方式
LambdaQueryWrapper<T> lambdaQuery();

// 等价示例：
query().eq("id", value);
lambdaQuery().eq(Entity::getId, value);

//获取QueryWrapper条件构造器
QueryWrapper<T> queryWrapper = com.legendframework.core.dao.wrapper.defaults.Wrappers.query();
//获取LambdaQueryWrapper条件构造器
LambdaQueryWrapper<T> queryWrapper = com.legendframework.core.dao.wrapper.defaults.Wrappers.lambdaQuery();

/**
 * 根据 entity 条件，查询全部记录（并翻页）
 *
 * @param page         分页查询条件
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
Page<T> selectPage(Page<T> page, Wrapper<T> queryWrapper);

public class Page<T> implements Serializable {
    /*页码(1开始)*/
    private long currentPage
    /*每页条目数*/
    private long itemNum;
    /*总页数*/
    private long totalPage;
    /*总记录数*/
    private long totalSum;
    /*分页后数据*/
    private List<T> list;
    
    getset.....
}   

import com.legendframework.core.dao.annotation.EntityDao;
import com.legendframework.core.dao.IDao;
@EntityDao
public interface LogConfigDao extends IDao<LogConfig> {
}

@MainPlugin
public class TestPlugin extends LegendPlugin {

    @Resource
    private LogConfigDao logConfigDao;

    @Override
    public void start() {
        //这里就可以调用dao接口中的方法，选择你要调用的方法进行使用了
        LambdaQueryWrapper<LogConfig> warpper = Wrappers.lambdaQuery();
        LogConfig logConfig = logConfigDao.selectOne(warpper.eq(LogConfig::getLogLevel, LoggerLevelEnum.DEBUG),false);
    }
	........
}

public interface IService<T> extends IConfigService<T> , IReload {

    /**
     * 插入一条记录（选择字段，策略插入）
     *
     * @param entity 实体对象
     */
    boolean save(T entity);
    
    /**
     * 插入一条具有默认数据的记录 (主动触发)
     *
     * 如果这个ID的记录不存在，则获取去获取这个实体类的默认配置，然后进行赋值ID插入
     *
     * 适用于玩家初次进入服务器，进而生成玩家配置文件
     *
     * @param id
     * @return
     */
    boolean saveDefault(Serializable id);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    boolean removeById(Serializable id);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体包装类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    boolean remove(Wrapper<T> queryWrapper);

    /**
     * 删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表
     */
    boolean removeByIds(Collection<? extends Serializable> idList);

    /**
     * 根据 ID 选择修改
     *
     * @param entity 实体对象
     */
    boolean updateById(T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象
     */
    boolean update(T entity, Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T getById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表
     */
    List<T> listByIds(Collection<? extends Serializable> idList);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    default T getOne(Wrapper<T> queryWrapper) {
        return getOne(queryWrapper, false);
    }

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     * @param throwEx      有多个 result 是否抛出异常
     */
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    Object getObj(Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    long count(Wrapper<T> queryWrapper);

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    List<T> list(Wrapper<T> queryWrapper);

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    Page<T> page(Page<T> page, Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.legendframework.core.dao.wrapper.defaults.QueryWrapper}
     */
    List<Object> listObjs(Wrapper<T> queryWrapper);
}

public abstract class BaseService<T,D extends IDao<T>> implements IService<T> {...}

public abstract class VagueService<T> extends BaseService<T, IDao<T>> {...}

@Service
public class PropService extends VagueService<Prop> {...}

@Service
public class PropService extends VagueService<Prop> {
    @Transactional
    public void account(){
        Prop prop = getOne();
        prop.setName("修改值1");
        updateById(prop);
        //制造异常
        throw new RuntimeException("手动异常");
    }
}

@Event
public class MyPlayerJoinEvent implements Listener {
    /**
     * 玩家进入服务器事件
     * @param e
     */
    @EventHandler
    public void event(PlayerJoinEvent e){
        e.setJoinMessage("你好,欢迎进入服务器!");
    }
}

public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
    if (args.length == 0){
        //当前输入的是根指令
        return true;
    }
    if (args.length == 1){
        if (StringUtils.equals(args[0],"info")){
            //xxx info
            //查看玩家个人信息
        } else if (StringUtils.equals(args[0], "reload")) {
            //xxx reload
            //重载插件
        }
        return true;
    }
    if (args.length == 2){
        if (StringUtils.equals(args[0],"info")){
            //xxx info <玩家名称>
            //查看指定玩家的个人信息
            String name = args[1];
        }
        return true;
    }
    return false;
}

@Command(cmd = "my",title = "我的指令")
public class MyCommand extends BaseCommand {
    
    @Cmd(value = "info",title = "查看玩家信息",desc = "",isAsyn = true)
    public void info(@CmdParam(
            title = "玩家",
            desc = "如果不传入参数则查询自己信息",
            demo = "196",
            required = false) Player player){
        if (player == null) {
            //查询自己的信息
        }else {
            //查询指定玩家信息
        }
    }
    
    @Cmd(value = "reload",title = "重载插件")
    public void reload(){
        System.out.println("重载插件...");
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Command {
    /**Bean名称*/
    String value() default "";
    /**
     * 指令前缀
     * 设置了这个参数的指令类中的指令方法的cmd前缀都会加上这个参数的值
     * @return
     */
    String cmd();
    /**指令类标题*/
    String title();
}

/**
 * 指令帮助的树形结构节点注解
 * 使用它框架能帮助您实现指令help的树形图
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CommandParentNode {
    /**父节点*/
    Class<? extends BaseCommand>[] value();
}

@Target(ElementType.METHOD)
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Cmd {
    /**指令*/
    String[] value();

    /**指令标题信息*/
    String title() default "";

    /**指令描述信息*/
    String desc() default "";

    /**是否异步执行*/
    boolean isAsyn() default true;
 }

@Cmd(value="test",title="测试指令")
@OnlyOp
public void test(){...}

@Cmd(value="test",title="测试指令")
@OnlyPlayer
public void test(){...}

@Cmd(value="test",title="测试指令")
@OnlyServer
public void test(){...}

/**
 * 例根指令为 'test'
 */
@Command(title = "玩家相关指令" , cmd = "player")
@CommandParentNode(MyRootCommand.class)
public class MyPlayerCommand extends BaseCommand {
    @Cmd(value="info",title="查看信息")
    @Permission
    public void info(@CmdParam(title="玩家名称") String name){...}
    
    @Cmd(value="give",title="给予玩家物品")
    @Permission("abc.give")
    public void give(){...}
}

@Target({ElementType.FIELD,ElementType.PARAMETER})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CmdParam {
    /**参数标题信息*/
    String title() default "";

    /**参数描述信息*/
    String desc() default "";

    /**参数示例*/
    String demo() default "";

    /**是否必须*/
    boolean required() default true;
}

public class PlayerUpExpParam {
    @CmdParam(title="给予的经验") 
    private Long exp;
    
    @CmdParam(title="玩家名称",desc="不传默认为自己",required=false) 
    private String name;
    
    getset...
}

/**
 * 例根指令为 'test'
 */
@Command(title = "玩家相关指令" , cmd = "player")
@CommandParentNode(MyRootCommand.class)
public class MyPlayerCommand extends BaseCommand {
    
    @Cmd(value="upExp",title="给一个玩家提升经验值")
    @OnlyOp
    @Permission
    public void upExp(@CmdCmdEntityParam PlayerUpExpParam param){...}
    
}

@Target({ElementType.FIELD,ElementType.PARAMETER})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Size {

    /**最小值*/
    long min() default 0;

    /**最大值*/
    long max() default Long.MAX_VALUE;

    /**超过范围后的提示内容*/
    String message() default "取值范围有误";
}

@Target({ElementType.FIELD,ElementType.PARAMETER})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface CollectionSize {

    /**最大值*/
    int max() default Integer.MAX_VALUE;

    /**超过范围后的提示内容*/
    String message() default "集合大小超过了给定的最大值";
}

@Component
public class PlayerParamerConverter implements ParamerConverter<Player> {
    /**
     * 校验这个行参是否符合这个转换器
     * @return
     */
    @Override
    public boolean check(Class<?> cls) {
        return Player.class == cls;
    }
    /**
     * 转换类型
     *
     * 不要以 {@link IParameter} 为需转换的类型
     * 真实的需要转换类型取 type , 因为考虑到泛型List等情况
     * {@link IParameter} 作用是取其注解进行扩展功能
     *
     * @param sender 发送者
     * @param message 消息
     * @param type 需要转换的类
     * @param parameter parameter
     * @return
     */
    @Override
    public Player castParameter(CommandSender sender, String message, Class<Player> type, IParameter parameter) {
        return Bukkit.getPlayer(message);
    }
}

/**
 * 通一的执行成功处理器
 * 当某指令方法上被标识了@CmdSuccessHandle时，会触发该处理器
 *
 * @param sender 指令发送者
 * @param method 执行成功的指令方法
 * @param params 执行这个指令方法所传入的参数
 */
void successHandle(CommandSender sender , Method method , Object... params);

/**
 * 当方法执行异常的处理器，方法执行异常时触发
 *
 * @param sender 指令发送者
 * @param e 异常信息
 * @param method 执行失败的指令方法
 */
void failHandle(CommandSender sender ,Throwable e , Method method);

/**
 * 当指令参数的个数正确，但与方法所匹配的类型不一致时，会调用该处理器
 *
 * 例如：参数类型为int类型， 玩家输入的这个参数为 "abc" ，则会调用该处理器
 *
 * @param sender 指令发送者
 * @param e 异常信息
 * @param method 封装入参失败的指令方法
 * @param parameter 导致参数错误的这个参数，它可能是一个入参 {@link Parameter} 也可能是一个字段 {@link Field}
 * @param param 导致错误方法实参
 * @param index 参数的索引
 */
void paramsErrorHandle(CommandSender sender , Throwable e, Method method , IParameter parameter , Object param, int index);

/**
 * 为子类提供的help公用方法
 *
 * @param page 页码
 * {@link Cmd} 中的指令前会拼接子类 {@link Command#cmd()} 参数
 * <p>
 * 例如有两个子类 分别为：PlayerCmd ，ServerCmd
 * 其类上的 {@link Command#cmd()} 参数分别为 'p' , 's'
 * 那么这两个子类的help指令的调用为：
 * 1. PlayerCmd : '/根指令 p help' or '/根指令 p'
 * 2. ServerCmd : '/根指令 s help' or '/根指令 s'
 * 执行的help指令会进入到不同的子类对象的该方法 help() 中 ， 子类可以复写这个方法
 */
@Cmd({"help", ""})
@CmdFailHandle
@Permission()
public void help(
        CommandSender sender,
        org.bukkit.command.Command command,
        @CmdParam(title = "页码", desc = "数字", demo = "1", required = false) Integer page
) {
    page = page == null ? 1 : page;
    Command thisCommand = getThisCommandAnnotation();
    List<CmdHelp> cmdHelps = getHelps();
    try {
        CmdHelp help = createCmdhelp(
                BaseCommand.class.getMethod("help", CommandSender.class, org.bukkit.command.Command.class, Integer.class),
                thisCommand,
                this
        );
        //分页且渲染
        renderingHelp(sender, command, help, PageUtil.page(cmdHelps, page, helpItemNum()));
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
}

    /**
     * 获取指令帮助的每页显示条目数
     */
    int helpItemNum();

	/**
     * 渲染指令help前缀
     *
     * @param sender      指令执行者
     * @param command     org.bukkit.command.Command 指令
     * @param help        当前准备渲染的指令封装类
     * @param cmdHelpPage 需要渲染的指令帮助列表
     */
    protected void renderingHelpPrefix(CommandSender sender, Command command, CmdHelp help, Page<CmdHelp> cmdHelpPage);

	/**
     * 展示指令帮助的内容部分
	 *
     * 无需关注分页逻辑，只需要自定渲染风格
     *
     * @param sender      指令执行者
     * @param command     org.bukkit.command.Command 指令
     * @param help        当前准备渲染的指令封装类
     * @param cmdHelpPage 需要渲染的指令帮助列表
     */
    protected void renderingHelpBody(CommandSender sender, Command command, CmdHelp help, Page<CmdHelp> cmdHelpPage);

	/**
     * 渲染指令help后缀
     *
     * @param sender      指令执行者
     * @param command     指令
     * @param help        当前准备渲染的指令封装类
     * @param cmdHelpPage 需要渲染的指令帮助列表
     */
    protected void renderingHelpSuffix(CommandSender sender, org.bukkit.command.Command command, CmdHelp help, Page<CmdHelp> cmdHelpPage);

/**
 * 默认渲染风格
 *
 * @param cmdHelpPage 需要渲染的指令帮助列表
 */
@Override
public void renderingHelp(CommandSender sender, org.bukkit.command.Command command, CmdHelp help, Page<CmdHelp> cmdHelpPage) {
    if (cmdHelpPage.getTotalSum() == 0) {
        sender.sendMessage("当前注册的指令: [" + command.getName() + "] , 没有绑定任何子指令");
        return;
    } else if (cmdHelpPage.getList().size() == 0) {
        sender.sendMessage("当前页没有任何数据");
    }
    renderingHelpPrefix(sender, command, help, cmdHelpPage);
    renderingHelpBody(sender, command, help, cmdHelpPage);
    renderingHelpSuffix(sender, command, help, cmdHelpPage);
}

/test player {这是一句 含有空 格 的话 这段话 如果指令 方法中的参数是集合 这段话会以空格进行 分割 填充到集合中}