io.smallrye.config.inject.ConfigMappingInjectionBean Maven / Gradle / Ivy

Go to download
package io.smallrye.config.inject;

import static io.smallrye.config.inject.SecuritySupport.getContextClassLoader;
import static java.util.Optional.ofNullable;

import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.Collections;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;

import javax.enterprise.context.Dependent;
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.Default;
import javax.enterprise.inject.spi.Annotated;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.InjectionPoint;

import org.eclipse.microprofile.config.ConfigProvider;
import org.eclipse.microprofile.config.inject.ConfigProperties;

import io.smallrye.config.ConfigMapping;
import io.smallrye.config.SmallRyeConfig;

public class ConfigMappingInjectionBean implements Bean {
    private final BeanManager bm;
    private final Class klass;
    private final String prefix;
    private final Set qualifiers = new HashSet<>();

    public ConfigMappingInjectionBean(final BeanManager bm, final AnnotatedType type) {
        this.bm = bm;
        this.klass = type.getJavaClass();
        this.prefix = getPrefixFromType(type);
        this.qualifiers.add(Default.Literal.INSTANCE);
        if (type.isAnnotationPresent(ConfigProperties.class)) {
            this.qualifiers.add(ConfigProperties.Literal.of(prefix));
        }
    }

    @Override
    public Class getBeanClass() {
        return klass;
    }

    @Override
    public Set getInjectionPoints() {
        return Collections.emptySet();
    }

    @Override
    public boolean isNullable() {
        return false;
    }

    @Override
    public T create(final CreationalContext creationalContext) {
        InjectionPoint injectionPoint = (InjectionPoint) bm.getInjectableReference(new MetadataInjectionPoint(),
                creationalContext);

        SmallRyeConfig config = (SmallRyeConfig) ConfigProvider.getConfig(getContextClassLoader());
        return config.getConfigMapping(klass, getPrefixFromInjectionPoint(injectionPoint).orElse(prefix));
    }

    @Override
    public void destroy(final T instance, final CreationalContext creationalContext) {

    }

    @Override
    public Set getTypes() {
        return Collections.singleton(klass);
    }

    @Override
    public Set getQualifiers() {
        return qualifiers;
    }

    @Override
    public Class getScope() {
        return Dependent.class;
    }

    @Override
    public String getName() {
        return this.getClass() + "_" + klass.getName();
    }

    @Override
    public Set> getStereotypes() {
        return Collections.emptySet();
    }

    @Override
    public boolean isAlternative() {
        return false;
    }

    static String getPrefixFromType(final Annotated annotated) {
        final Optional prefixFromConfigMappingClass = ofNullable(annotated.getBaseType()).map(type -> (Class) type)
                .map(c -> c.getAnnotation(ConfigMapping.class))
                .map(ConfigMapping::prefix);

        final Optional prefixFromConfigPropertiesClass = ofNullable(annotated.getBaseType())
                .map(type -> (Class) type)
                .map(c -> c.getAnnotation(ConfigProperties.class))
                .map(ConfigProperties::prefix)
                .filter(prefix -> !prefix.equals(ConfigProperties.UNCONFIGURED_PREFIX));

        return Stream.of(prefixFromConfigMappingClass, prefixFromConfigPropertiesClass)
                .flatMap(s -> s.map(Stream::of).orElseGet(Stream::empty))
                .findFirst()
                .orElse("");
    }

    static Optional getPrefixFromInjectionPoint(final InjectionPoint injectionPoint) {
        final Optional prefixFromConfigMapping = Optional.ofNullable(injectionPoint.getAnnotated())
                .map(a -> a.getAnnotation(ConfigMapping.class))
                .map(ConfigMapping::prefix)
                .filter(prefix -> !prefix.isEmpty());

        final Optional prefixFromConfigProperties = Optional.ofNullable(injectionPoint.getAnnotated())
                .map(a -> a.getAnnotation(ConfigProperties.class))
                .map(ConfigProperties::prefix)
                .filter(prefix -> !prefix.equals(ConfigProperties.UNCONFIGURED_PREFIX));

        final Optional prefixFromQualifier = injectionPoint.getQualifiers().stream()
                .filter(ConfigProperties.class::isInstance)
                .map(ConfigProperties.class::cast)
                .map(ConfigProperties::prefix)
                .filter(prefix -> !prefix.equals(ConfigProperties.UNCONFIGURED_PREFIX))
                .findFirst();

        return Stream.of(prefixFromConfigMapping, prefixFromConfigProperties, prefixFromQualifier)
                .flatMap(s -> s.map(Stream::of).orElseGet(Stream::empty))
                .findFirst();
    }
}