Dienste

In Sponge wird fast alles (Events, Berechtigungen etc.) durch Services umgesetzt. Der Zugriff auf Services erfolgt über den Services Manager:

import org.spongepowered.api.Sponge;

Sponge.getServiceManager().provide(EventManager.class);

Wenn eine Objektreferenz zu irgend etwas anderem benötigt wird, kann diese Referenz mit Hilfe des Service Managers gefunden werden.

Service Guidelines

• Services should be registered during the POST_INITIALIZATION game state at the latest.

• Services should be fully operational by the SERVER_ABOUT_TO_START game state.

You can read more about game states on the Der Plugin-Lebenszyklus page.

Bemerkung

It is a good practice to register services as soon as possible so that other plugins can note that the service will be provided.

Bereitstellen eines eigenen Services

Your plugin can provide the implementation for a core interface like PermissionService, or for a custom interface that is not part of SpongeAPI (e.g. economy, web server):

Sponge.getServiceManager().setProvider(Object plugin, Class<T> service, T provider);

Das provider Objekt muss das Service Interface oder die Service Klasse implementieren.

Die Sponge API so auszulegen, macht sie extrem modular.

Bemerkung

Plugins sollten Optionen bieten mit denen das Installieren ihrer Provider abgeschaltet werden kann, wenn es nicht für einen einzigen Zweck geschaffen wurde.

Example: Providing a simple warp service

Der erste Schritt ist empfohlen, aber optional. Die public Methoden der eigenen Service Klasse werden in einem Interface festgelegt:

import org.spongepowered.api.world.Location;
import org.spongepowered.api.world.World;
import java.util.Optional;

public interface WarpService {
    void setWarp(String name, Location<World> location);
    Optional<Location<World>> getWarp(String name);
}

Nun wird die Klasse, die das Interface implementiert, geschrieben:

import java.util.HashMap;

public class SimpleWarpService implements WarpService {
    HashMap<String, Location<World>> warpMap = new HashMap<String, Location<World>>();

    @Override
    public Optional<Location<World>> getWarp(String name) {
        if(!warpMap.containsKey(name)) {
            return Optional.empty();
        } else {
            return Optional.of(warpMap.get(name));
        }
    }

    @Override
    public void setWarp(String name, Location<World> location) {
        warpMap.put(name, location);
    }
}

Now we can register a new instance of the class in the service manager. We are using the interface WarpService.class as the service key.

Dies ermöglicht es anderen Plugin Entwicklern ihre eigenen Implementierungen deines Services (der dein Interface implementiert) zu schreiben und deine Version zu ersetzen.

PluginContainer plugin = ...;

Sponge.getServiceManager().setProvider(plugin, WarpService.class, new SimpleWarpService());

Andere Plugins können nun durch den Service Manager auf deinen Service zugreifen:

Sponge.getServiceManager().provide(WarpService.class);

Tipp

If you don’t want to use interfaces, just replace the service key with your class (SimpleWarpService.class in the example).