import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
private List<P> getPlugins(String[] pluginFolders) {
    PluginManager pm = PluginManagerFactory.createPluginManager();
    pm.addPluginsFrom(ClassURI.CLASSPATH, new OptionReportAfter());
    Arrays.asList(pluginFolders).stream().forEach(folder -> {
        pm.addPluginsFrom(new File(folder).toURI(), new OptionReportAfter());
    });
    PluginManagerUtil pmu= new PluginManagerUtil(pm);
    return pmu.getPlugins(Plugin.class).stream().filter(selector).map(p->(P)p).collect(Collectors.toList());
}
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
/**
 * Allows you to get the plugin you want if it's installed. Advise : put it in the dependencies
 *
 * @param plugin_name String The name of the wanted plugin
 * @return Corpoplugins The plugin with the given name
 */
public static Corpoplugins thisPlugin(String plugin_name) {
    // Setting up the PluginManager from jspf
    PluginManager pm = PluginManagerFactory.createPluginManager();
    try {
        configString = getConfig();
        if (Install.isInstalled(plugin_name))
            pm.addPluginsFrom(new File(PLUGINDIRECTORY + plugin_name.toLowerCase() + System.getProperty("file.separator")).toURI());
        return pm.getPlugin(Corpoplugins.class);
    } catch (IOException e) {
        System.err.println(e.getMessage());
    }
    return null;
}
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
@Override
public <T extends Plugin> List<T> loadPlugins(Class<T> cls) {
	// register plugins from plugins directory
	PluginManager pm = PluginManagerFactory.createPluginManager();
	pm.addPluginsFrom(new File("." + File.separator + "plugins").toURI());
	PluginManagerUtil pmu = new PluginManagerUtil(pm);	
	ArrayList<T> ret = new ArrayList<T>();
	Collection<T> plugins = pmu.getPlugins(cls);
	if(plugins!=null){
		ret.addAll(plugins);
	}
	return ret;
}
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
public static PluginManagerUtil registerPluginDirectory(File dir) {
	PluginManager pm = PluginManagerFactory.createPluginManager();
	pm.addPluginsFrom(dir.toURI());
	PluginManagerUtil pmu = new PluginManagerUtil(pm);		
	for(ODLComponent component : pmu.getPlugins(ODLComponent.class)){
		logger.info("Found component " + component.getId() + " in directory " + dir.getAbsolutePath());
		register(component);
	}
	return pmu;
}
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
/**
 * Will update the given plugin. Will check if the plugin is already installed, compare its version,
 * if its dependencies are present (will execute a dry run of install for it).
 * And then use Delete and Install to reinstall the plugin.
 *
 * @param path_to_update String The plugin which will be updated.
 * @param debug          boolean Will display the progression of the action if true.
 * @see core.Install
 * @see Delete
 */
public static void updatePlugin(String path_to_update, boolean debug) {
    File plugin_path = new File(path_to_update);

    try {
        if (!plugin_path.exists() || !plugin_path.isFile())
            throw new IsNotFileException(path_to_update);

        // Setting up the PluginManger from jspf
        PluginManager pm = PluginManagerFactory.createPluginManager();
        // adding the path to verify
        pm.addPluginsFrom(plugin_path.toURI());
        // getting the class which implements our plugin interface
        Corpoplugins extension = pm.getPlugin(Corpoplugins.class);
        Pluginspecs new_plugin_specs;

        configString = ActionBase.getConfig(); // Get the configuration file
        new_plugin_specs = extension.getClass()
                .getAnnotation(Pluginspecs.class); // Get the Pluginspecs from jar

        if (debug) System.out.print(Flags.getString("install.plugin-specs")
                + extension.getClass());
        if (new_plugin_specs == null)
            throw new PluginSpecsNotFoundException(extension.getClass()
                    .toString()); // if there is no annotations
        if (debug) {
            System.out.println(Flags.getString("done"));
            System.out.print(Flags.getString("update.verification"));
        }
        if (!Install.isInstalled(new_plugin_specs.name()))
            throw new PluginNotFoundException(new_plugin_specs.name()); // if the plugin is NOT installed
        if (debug) {
            System.out.println(Flags.getString("done"));
            System.out.print(Flags.getString("install.dependencies"));
        }
        Install.hasDependencies(new_plugin_specs); // if all the dependencies are present
        if (debug) {
            System.out.println(Flags.getString("done"));
            System.out.print(Flags.getString("update.version"));
        }
        if (!compareVersion(new_plugin_specs))//if the plugin installed is newer
            throw new PluginIsNewer(new_plugin_specs.name());
        if (debug) {
            System.out.println(Flags.getString("done"));
        }
        Delete.deletePlugin(new_plugin_specs.name(), debug);
        Install.installPlugin(path_to_update, debug);

    } catch (IOException | PluginNotFoundException | PluginSpecsNotFoundException |
            PluginDependenciesNotPresentException | IsNotFileException | PluginIsNewer e) {
        System.err.println(e.getMessage());
    }
}
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
/**
     * Gives the specifications of the given plugin, used in --help
     *
     * @param plugin_name String the name of the plugin.
     * @param debug       true to display debug information
     * @return The plugin specifications.
     */
    public static String pluginDetails(String plugin_name, boolean debug) {

        String plugin = EMPTYSTRING;
        // Setting up the PluginManger from jspf
        PluginManager pm = PluginManagerFactory.createPluginManager();
// adding the path to verify
        pm.addPluginsFrom(new File(PLUGINDIRECTORY + plugin_name.toLowerCase() + System.getProperty("file.separator")).toURI());
// getting the class which implements our plugin interface
        Corpoplugins extension = pm.getPlugin(Corpoplugins.class);

        try {
            configString = getConfig();
            Delete.findPluginLine(plugin_name);

            if (debug) System.out.print(Flags.getString("install.plugin-specs")
                    + extension.getClass());
            Pluginspecs plugin_specs = extension.getClass()
                    .getAnnotation(Pluginspecs.class);
            if (plugin_specs == null)
                throw new PluginSpecsNotFoundException(extension.getClass()
                        .toString()); // if there is no annotations
            if (debug) System.out.println(Flags.getString("done"));

            plugin += "Plugin name: " + plugin_specs.name() + System.lineSeparator();
            plugin += "Description: " + plugin_specs.description() + System.lineSeparator();
            plugin += "Version: " + plugin_specs.version() + System.lineSeparator();
            plugin += "Author: " + plugin_specs.author() + System.lineSeparator();
            plugin += "Supported formats: ";
            for (String format : plugin_specs.extensions()) {
                plugin += " ." + format;
            }
            plugin += System.lineSeparator() + "Dependencies: ";
            for (String dependency : plugin_specs.dependencies()) {
                plugin += dependency + ", ";
            }

        } catch (PluginSpecsNotFoundException | IOException | PluginNotFoundException e) {
            System.err.println(e.getMessage());
        }
        return plugin;
    }
 

import net.xeoh.plugins.base.PluginManager; //导入依赖的package包/类
/**
     * Will install the specified plugin. Will if the plugin is extended from the Corpoplugin interface,
     * check if it's aready installed, then will copy it under : installation_folder/plugin_name/
     *
     * @param path_to_install String Is the path to the plugin to install
     * @param debug           boolean Will display the progression of the action if true.
     * @see Delete
     */
    public static void installPlugin(String path_to_install, boolean debug) {
        File plugin_path = new File(path_to_install);

        try {
            if (!plugin_path.exists() || !plugin_path.isFile())
                throw new IsNotFileException((path_to_install));

            // Setting up the PluginManger from jspf
            PluginManager pm = PluginManagerFactory.createPluginManager();
// adding the path to verify
            pm.addPluginsFrom(plugin_path.toURI());
// getting the class which implements our plugin interface
            Corpoplugins extension = pm.getPlugin(Corpoplugins.class);
            Pluginspecs plugin_specs;

            configString = ActionBase.getConfig(); // Get the configuration file
            plugin_specs = extension.getClass()
                    .getAnnotation(Pluginspecs.class); // Get the Pluginspecs from jar

            if (debug) System.out.print(Flags.getString("install.plugin-specs")
                    + extension.getClass());
            if (plugin_specs == null)
                throw new PluginSpecsNotFoundException(extension.getClass()
                        .toString()); // if there is no annotations
            if (debug) System.out.println(Flags.getString("done"));

            if (debug) System.out.print(Flags.getString("install.verification"));
            if (isInstalled(plugin_specs.name()))
                throw new PluginIsInstalledException(plugin_specs.name()); // if the plugin is already installed
            if (debug) System.out.println(Flags.getString("done"));

            if (debug) System.out.print(Flags.getString("install.dependencies"));
            hasDependencies(plugin_specs); // if all the dependencies are present
            if (debug) System.out.println(Flags.getString("done"));

            if (debug) System.out.print(Flags.getString("install.copyjar")
                    + plugin_specs.name().toLowerCase()
                    + Flags.getString("install.copyjar2"));
            copyPlugintoDirectory(plugin_specs.name(), plugin_path);
            if (debug) System.out.println(Flags.getString("done"));

            if (debug) System.out.print(Flags.getString("install.adding-properties"));
            addPlugintoConfig(plugin_specs);
            if (debug) System.out.println(Flags.getString("done"));

            System.out.println(Flags.getString("install.success"));
        } catch (IOException | PluginDependenciesNotPresentException | PluginIsInstalledException
                | PluginSpecsNotFoundException | IsNotJarException | IsNotFileException e) {
            System.err.println(e.getMessage());
        }
    }