io.paradoxical.dropwizard.guice.GuiceEnvironmentConfiguration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dropwizard-guice Show documentation
Simple library for using Guice DI in a dropwizard service forked from hubspot/dropwizard-guice.
There is a newer version: 1.0.0-rc3
package io.paradoxical.dropwizard.guice;

import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.inject.Injector;
import com.google.inject.Module;
import com.google.inject.Stage;
import io.dropwizard.Configuration;
import io.dropwizard.setup.Bootstrap;
import io.dropwizard.setup.Environment;
import io.paradoxical.dropwizard.guice.jersey.JerseyModule;
import io.paradoxical.dropwizard.guice.jersey.JerseyUtil;
import lombok.Builder;
import lombok.NonNull;
import lombok.Singular;
import lombok.Value;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nonnull;
import java.util.Optional;
import java.util.function.Supplier;

@Value
public class GuiceEnvironmentConfiguration {
    private static final Logger logger = LoggerFactory.getLogger(GuiceEnvironmentConfiguration.class);

    private final AutoConfig autoConfig;
    private final ImmutableList modules;

    private final Supplier injectorSupplier;

    private final DropwizardEnvironmentModule environmentModule;

    public Injector getInjector() {
        return injectorSupplier.get();
    }

    @Builder(builderClassName = "GuiceEnvironmentConfigurationBuilder")
    private GuiceEnvironmentConfiguration(
        final AutoConfig autoConfig,
        @Singular
        final ImmutableList modules,
        final Class configurationClass,
        final InjectorFactory injectorFactory,
        final Stage guiceStage) {

        this.autoConfig = autoConfig;

        if (configurationClass == null) {
            environmentModule = new DropwizardEnvironmentModule<>(Configuration.class);
        }
        else {
            environmentModule = new DropwizardEnvironmentModule<>((Class) configurationClass);
        }

        this.modules = ImmutableList.builder()
            .add(new JerseyModule())
            .add(environmentModule)
            .addAll(modules)
            .build();

        final Stage stage = Optional.ofNullable(guiceStage).orElse(Stage.PRODUCTION);

        final com.google.common.base.Supplier lazySupplier =
            Suppliers.memoize(() -> initInjector(stage,
                                                 Optional.ofNullable(injectorFactory)
                                                         .orElseGet(DefaultInjectorFactory::new),
                                                 this.modules));

        this.injectorSupplier = lazySupplier::get;
    }

    private static Injector initInjector(
        final Stage stage,
        final InjectorFactory injectorFactory,
        final ImmutableList modules) {

        try {
            return injectorFactory.create(stage, ImmutableList.copyOf(modules));
        }
        catch (Exception ie) {
            logger.error("Exception occurred when creating Guice Injector", ie);
            throw new RuntimeException("Exception occurred when creating Guice Injector", ie);
        }
    }

    public void addBundles(final Bootstrap bootstrap) {
        if (autoConfig != null) {
            autoConfig.addDiscoveredBundles(bootstrap, getInjector());
        }
    }

    public void configureEnvironment(
        @NonNull @Nonnull final Configuration configuration,
        @NonNull @Nonnull final EnvironmentData environmentData) {

        final Injector injector = getInjector();

        JerseyUtil.registerGuiceBound(injector, environmentData.jerseyEnvironment()::register);
        JerseyUtil.registerGuiceFilter(environmentData.servletEnvironment(), environmentData.serverContext());

        setEnvironment(configuration, environmentData.environment());

        if (autoConfig != null) {
            autoConfig.run(environmentData.environment(), environmentData.jerseyEnvironment(), injector);
        }
    }

    private void setEnvironment(final Configuration configuration, final Environment environment) {
        environmentModule.setEnvironmentData(configuration, environment);
    }
}