All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.github.dxee.dject.event.ApplicationEventModule Maven / Gradle / Ivy

Go to download

A collection of guice extensions, help to improve the developer experience of guice.

There is a newer version: 1.5.1
Show newest version
package com.github.dxee.dject.event;

import com.github.dxee.dject.event.guava.GuavaApplicationEventModule;
import com.google.inject.AbstractModule;
import com.google.inject.TypeLiteral;
import com.google.inject.matcher.Matchers;
import com.google.inject.spi.InjectionListener;
import com.google.inject.spi.ProvisionListener;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;

import javax.inject.Provider;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * Adds support for passing {@link ApplicationEvent}s. Default (Guava-based) implementation
 * can be found in {@link GuavaApplicationEventModule}
 * 

 * See {@link EventListener} and {@link ApplicationEventDispatcher} for usage.
 */
public final class ApplicationEventModule extends AbstractModule {

    private static class ApplicationEventSubscribingTypeListener implements TypeListener {
        private final Provider dispatcherProvider;

        public ApplicationEventSubscribingTypeListener(Provider dispatcherProvider) {
            this.dispatcherProvider = dispatcherProvider;
        }

        @Override
        public  void hear(TypeLiteral type, TypeEncounter encounter) {
            final Class clazz = type.getRawType();
            final List handlerMethods = getAllDeclaredHandlerMethods(clazz);
            if (!handlerMethods.isEmpty()) {
                encounter.register((InjectionListener) injectee -> {
                    for (final Method handlerMethod : handlerMethods) {
                        dispatcherProvider.get().registerListener(injectee, handlerMethod,
                                (Class) handlerMethod.getParameterTypes()[0]);
                    }
                });
            }
        }

        private List getAllDeclaredHandlerMethods(Class clazz) {
            final List handlerMethods = new ArrayList<>();
            while (clazz != null && !Collection.class.isAssignableFrom(clazz) && !clazz.isArray()) {
                for (final Method handlerMethod : clazz.getDeclaredMethods()) {
                    if (handlerMethod.isAnnotationPresent(EventListener.class)) {
                        if (handlerMethod.getReturnType().equals(Void.TYPE)
                                && handlerMethod.getParameterTypes().length == 1
                                && ApplicationEvent.class.isAssignableFrom(handlerMethod.getParameterTypes()[0])) {
                            handlerMethods.add(handlerMethod);
                        } else {
                            throw new IllegalArgumentException(
                                    "@EventListener " + clazz.getName() + "." + handlerMethod.getName()
                                    + "skipped. Methods must be public, void, and accept exactly"
                                    + " one argument extending ApplicationEvent.");
                        }
                    }
                }
                clazz = clazz.getSuperclass();
            }
            return handlerMethods;
        }
    }

    private static class ApplicationEventSubscribingProvisionListener implements ProvisionListener {

        private final Provider dispatcherProvider;

        public ApplicationEventSubscribingProvisionListener(Provider dispatcherProvider) {
            this.dispatcherProvider = dispatcherProvider;
        }

        @Override
        public  void onProvision(ProvisionInvocation provision) {
            T provisioned = provision.provision();
            if (provisioned != null && provisioned instanceof ApplicationEventListener) {
                dispatcherProvider.get().registerListener((ApplicationEventListener) provisioned);
            }
        }
    }

    @Override
    protected void configure() {
        com.google.inject.Provider dispatcherProvider =
                binder().getProvider(ApplicationEventDispatcher.class);
        bindListener(Matchers.any(), new ApplicationEventSubscribingTypeListener(dispatcherProvider));
        bindListener(Matchers.any(), new ApplicationEventSubscribingProvisionListener(dispatcherProvider));
    }

    @Override
    public boolean equals(Object obj) {
        return getClass().equals(obj.getClass());
    }

    @Override
    public int hashCode() {
        return getClass().hashCode();
    }

    @Override
    public String toString() {
        return "ApplicationEventModule[]";
    }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy