Plugin Manager

The Plugin Manager is what your plugin gets sent to after being loaded by the server at startup. The server loads your plugin by finding its main class, annotated by the Plugin annotation that holds its general information, and sends a new instance of it to the manager. The manager then keeps that instance in its own collection that you can look into and pull from using methods provided by itself, thus allowing you to easily interact with another loaded plugin if you so desire.

Die PluginManager-Klasse

Public methods inside the PluginManager are used to grab information about the current collection of loaded plugins, alongside their instances. The plugins are stored inside a PluginContainer (discussed in next section) to allow for an easy center of information about the specific plugin. As an example, you can use the PluginManager to communicate with another plugin, grabbing its instance and using the methods it offers to provide compability or extended features by means of your calling plugin.

Wie kommt man an den Plugin-Manager

Du kannst an die Instanz des PluginManager\s über mehrere Wege kommen.

1. Dependency Injection


See the Dependency Injection guide for help on using dependency injection.

Der Plugin-Manager ist eine der wenigen API-Instanzen, die in die Main-Klasse eingefügt werden, während diese geladen wird. Um eine Referenz zu erhalten, erstelle eine neue Variable, die die Plugin-Manager-Instanz enthalte soll und schreibe @Inject darüber.

import org.spongepowered.api.plugin.PluginManager;

private PluginManager pluginManager;

2. The Service Manager


Schau dir Services für einen ausführlichen Guide über den Service-Manager an.

The service manager also holds an instance of the server’s PluginManager. Simply use the method ServiceManager#provide(Class), passing the PluginManager’s class (PluginManager.class) as a parameter.

private PluginManager pluginManager = serviceManager.provide(PluginManager.class);

3. The Game Instance


See the JavaDocs for Game for full information about the class, as well as its methods and their usage.

Eine Game-Instanz kann auch eine Referenz zu dem PluginManager bieten, um den Zugriff zu erleichtern.

private PluginManager pluginManager = game.getPluginManager();

Jetzt wo du eine Instanz des Plugin-Managers hast, lass sie uns benutzen.

4. Using the Sponge Class

The Sponge class works similarly to Game, with the exception that since Sponge contains static methods. It can be accessed anywhere throughout your plugin. You also do not need to store an instance of it, as you would need to do with Game.

import org.spongepowered.api.Sponge;

private PluginManager pluginManager = Sponge.getPluginManager();

Den Plugin-Manager benutzen

Der Plugin-Manager bietet viele Methoden, um mit Plugins zu arbeiten.

Viele Methoden geben einen sog. Plugin-Container zurück, auf dessen Methoden in dem nächsten Abschnitt eingegangen wird. Diese sog. Plugin-Container sind im Grunde selbsterklärend, denn diese beinhalten eine Plugin-Instanz.

Mit dem Plugin-Manager bekommst du Zugriff auf alle bereits geladene Plugins, die durch diesen Plugin-Manager geladen wurden:

import org.spongepowered.api.plugin.PluginContainer;

import java.util.List;

private List<PluginContainer> plugins = pluginManager.getPlugins();

Oder man holt sich direkt die Instanz eines Plugins in einen PluginContainer. Ein Beispiel dazu findest du direkt unter diesem Text:

private PluginContainer myOtherPlugin = pluginManager.getPlugin("myOtherPluginId").orNull();

Die PluginContainer-Klasse

Wenn du ein Plugin von dem PluginManager holst, dann hast du bestimmt schnell gemerkt, dass du keine unmittelbare Instanz des Plugins bekommen hast, sondern einen PluginContainer der Informationen über das Plugin enthält. Diese Informationen kommen von der @Plugin Annotation in der Hauptklasse des Plugins und aus der geladenen Instanz.

The PluginContainer will hold any generic information about the plugin set by its owning developer. You can use information from here instead of hard-coding what you know about it in your supporting plugin. An example scenario would be if the owning developer changes the name of the plugin, references to the latter in the supporting plugin would not become wrong as a result of this change, provided you’ve used the method PluginContainer#getName() to get its name.

private PluginContainer myOtherPlugin = pluginManager.getPlugin("myOtherPluginId").orNull();
private MyOtherPlugin pluginInstance = (MyOtherPlugin) myOtherPlugin.getInstance();


PluginContainer#getInstance() will return as an Object. You need to cast it as the target plugin after obtaining it from the container.