import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T extends Event> Class<T> getEventClass(EventListener<? super T> listener) {
    Class<? extends EventListener> listenerClass = listener.getClass();
    // We can't just do this:
    // Method handleMethod = listenerClass.getMethod(EVENT_LISTENER_HANDLE_METHOD_NAME, Event.class);
    // so we do this:
    Method[] methods = listenerClass.getMethods();
    List<Method> handleMethods = Arrays.asList(methods).stream()
            .filter(m -> !m.getDeclaringClass().equals(EventListener.class))
            .filter(m -> m.getName().equals(EVENT_LISTENER_HANDLE_METHOD_NAME))
            .collect(Collectors.toList());
    if (handleMethods.size() == 2) {
        if (handleMethods.get(0).getParameterTypes()[0].equals(Event.class)) {
            return (Class<T>) handleMethods.get(1).getParameterTypes()[0];
        } else {
            return (Class<T>) handleMethods.get(0).getParameterTypes()[0];
        }
    } if (handleMethods.size() == 1) {
        return (Class<T>) handleMethods.get(0).getParameterTypes()[0];
    } else if (handleMethods.size() > 2) {
        throw new IllegalStateException("Finding best matching Event not yet implemented: " + handleMethods);
    } else {
        throw new IllegalArgumentException("Failed to obtain 'handle' Method from listener: " + listener);
    }
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    // System.out.println("STDOUT started!");
    LOG.info("starting and registering command..");
    try {
        // new CommandsSetUp().register();
        // TODO remove this when switching to annotation-based declarative services..
        context.registerService(CommandRegistration.class, new HelloWorldCommand(), null);
        // TODO un-comment when https://github.com/SpongePowered/SpongeCommon/pull/1090 is merged
        // context.registerService(Listeners.class, new ExampleListeners(), null);
        context.registerService(EventListener.class, new ExampleEventListener(), null);
    } catch (Throwable t) {
        // we MUST catch and log, because Felix itself does not, and this gets lost..
        LOG.error("boum", t);
        // we rethrow, to fail the Bundle start
        throw t;
    }
    LOG.info("started!");
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    ServiceReference<BundleManager> ref = context.getServiceReference(BundleManager.class);
    if (ref != null) {
        bundleManager = context.getService(ref);
        PlayerJoinListener playerJoinListener = new PlayerJoinListener(bundleManager);
        context.registerService(EventListener.class, playerJoinListener, null);
    } else {
        throw new IllegalStateException("SourceInstallService not found (yet, change start order; DS SCR later)");
    }
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
public void start(BundleContext bundleContext, PluginContainer pluginContainer) {
    listenersTracker = CommandRegistrationTrackerCustomizer.setUp(bundleContext, Listeners.class,
            new ListenersTrackerCustomizer(bundleContext, pluginContainer));
    eventListenerTracker = CommandRegistrationTrackerCustomizer.setUp(bundleContext, EventListener.class,
            new EventListenerTrackerCustomizer(bundleContext, pluginContainer));
    commandRegistrationTracker = CommandRegistrationTrackerCustomizer.setUp(bundleContext, CommandRegistration.class,
            new CommandRegistrationTrackerCustomizer(bundleContext, pluginContainer));
    LOG.info("started tracking Minecraft services for CommandRegistration, EventListener & Listeners");
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
// protected Optional<EventListener<? extends Event>> getRegistration(EventListener<? extends Event> service) {
protected Optional<EventListener> getRegistration(EventListener service) {
    Class eventClass = EventListenerUtil.getEventClass(service);
    Sponge.getEventManager().registerListener(pluginContainer, eventClass, service);
    LOG.info("EventListener registered for event class {} : {}", eventClass.getName(), service);
    return Optional.of(service);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
public void start(BundleContext context) throws Exception {
    // TODO make directory of File("news.txt") more configurable ...
    NewsRepository newsRepository = new FileNewsRepository(new File("config/news/news.txt"),
            TextSerializers.JSON, Sponge.getServer(),
            Sponge.getServiceManager().provideUnchecked(UserStorageService.class));
    NewsService newsService = new NewsServiceImpl(newsRepository);
    context.registerService(EventListener.class, new PlayerJoinListener(newsRepository), null);
    context.registerService(CommandRegistration.class, new NewsCommand(newsService), null);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
private <T extends ClickInventoryEvent> EventListener<T> slotFilter(Predicate<Slot> filter,
        BiConsumer<SlotTransaction, Transaction<ItemStackSnapshot>> fn) {
    return event -> {
        Transaction<ItemStackSnapshot> cursor = event.getCursorTransaction();
        this.wasChange = false;
        this.ignoreChange = true;
        for (SlotTransaction tr : event.getTransactions()) {
            if (!tr.isValid() || !filter.test(tr.getSlot())) {
                continue;
            }
            // Ignore the crap where output slot changes even when not clicking on it
            if (ImplUtil.slotNumber(tr.getSlot()) == 0) {
                if (!tr.getOriginal().createStack().equalTo(cursor.getFinal().createStack())) {
                    System.out.println("ignore");
                    continue;
                }
            }
            fn.accept(tr, cursor);
            // cursor = new Transaction<>(cursor.getCustom().orElse(cursor.getOriginal()),
            // cursor.getFinal());
        }
        if (this.wasChange) {
            onGridChange();
        }
        this.ignoreChange = false;
        this.wasChange = false;
        checkZero();
    };
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
public <E extends DataHolder> void registerEvent(Class<E> holderFilter,
        EventListener<ChangeDataHolderEvent.ValueChange> listener) {
    checkNotNull(holderFilter, "holderFilter");
    checkNotNull(listener, "listener");
    final KeyEventListener keyEventListener = new KeyEventListener(listener, holderFilter::isInstance, this);
    final PluginContainer plugin = CauseStack.current().first(PluginContainer.class).get();
    final RegisteredListener<ChangeDataHolderEvent.ValueChange> registeredListener = Lantern.getGame().getEventManager().register(
            plugin, valueChangeEventTypeToken, Order.DEFAULT, keyEventListener);
    this.listeners.add(registeredListener);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
public <T extends Event> RegisteredListener<T> register(Object plugin, TypeToken<T> eventType, Order order, EventListener<? super T> listener) {
    final PluginContainer pluginContainer = checkPlugin(plugin, "plugin");
    checkNotNull(eventType, "eventType");
    checkNotNull(order, "order");
    checkNotNull(listener, "listener");
    registerListenerInstance(pluginContainer, listener);
    final RegisteredListener<T> registeredListener = createRegistration(pluginContainer, eventType, order, listener);
    register(Collections.singletonList(registeredListener));
    return registeredListener;
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
private static <T extends Event> RegisteredListener<T> createRegistration(PluginContainer plugin, TypeToken<T> eventType,
        Order order, EventListener<? super T> handler) {
    TypeToken<?> genericType = null;
    if (GenericEvent.class.isAssignableFrom(eventType.getRawType())) {
        genericType = eventType.resolveType(GENERIC_EVENT_TYPE);
    }
    return new RegisteredListener(plugin, new EventType(eventType.getRawType(), genericType), order, handler);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
// protected void removeRegistration(EventListener<? extends Event> registration) {
protected void removeRegistration(EventListener registration) {
    Sponge.getEventManager().unregisterListeners(registration);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T extends TargetInventoryEvent> void on(Class<T> eventClass, EventListener<T> handler) {
    this.handlers.put(eventClass, (EventListener<Event>) (Object) handler);
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
KeyEventListener(EventListener<ChangeDataHolderEvent.ValueChange> listener,
        Predicate<DataHolder> dataHolderPredicate, Key<?> key) {
    this.dataHolderPredicate = dataHolderPredicate;
    this.listener = listener;
    this.key = key;
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
RegisteredListener(PluginContainer plugin, EventType<T> eventType, Order order, EventListener<? super T> handler) {
    this.plugin = plugin;
    this.eventType = eventType;
    this.order = order;
    this.handler = handler;
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
public EventListener<? super T> getHandler() {
    return this.handler;
}
 

import org.spongepowered.api.event.EventListener; //导入依赖的package包/类
@Override
public <T extends Event> void registerListener(Object plugin, Class<T> eventClass, Order order, boolean beforeModifications,
        EventListener<? super T> listener) {
    // Ignore the "beforeModifications" property, this is only used in combination with mods
    registerListener(plugin, eventClass, order, listener);
}