org.zalando.riptide.spring.Registry Maven / Gradle / Ivy

Go to download
package org.zalando.riptide.spring;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.BeanReference;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.AutowireCandidateQualifier;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.ManagedList;

import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;

import static com.google.common.base.CaseFormat.LOWER_CAMEL;
import static com.google.common.base.CaseFormat.LOWER_HYPHEN;
import static com.google.common.base.CaseFormat.UPPER_CAMEL;
import static org.springframework.beans.factory.support.BeanDefinitionBuilder.genericBeanDefinition;

final class Registry {

    private static final Logger LOG = LoggerFactory.getLogger(Registry.class);

    private final BeanDefinitionRegistry registry;

    Registry(final BeanDefinitionRegistry registry) {
        this.registry = registry;
    }

    public boolean isRegistered(final Class type) {
        return isRegistered(generateBeanName(type));
    }

    public boolean isRegistered(final String id, final Class type) {
        return isRegistered(generateBeanName(id, type));
    }

    public boolean isRegistered(final String name) {
        return registry.isBeanNameInUse(name);
    }

    public  String registerIfAbsent(final Class type, final Supplier factory) {
        final String name = generateBeanName(type);

        if (isRegistered(name)) {
            LOG.debug("Bean [{}] is already registered, skipping it.", name);
            return name;
        }

        registry.registerBeanDefinition(name, factory.get().getBeanDefinition());

        return name;
    }

    public  String registerIfAbsent(final String id, final Class type) {
        return registerIfAbsent(id, type, () -> genericBeanDefinition(type));
    }

    public  String registerIfAbsent(final String id, final Class type,
            final Supplier factory) {

        final String name = generateBeanName(id, type);

        if (isRegistered(name)) {
            LOG.debug("Bean [{}] is already registered, skipping it.", name);
            return name;
        }

        final AbstractBeanDefinition definition = factory.get().getBeanDefinition();

        definition.addQualifier(new AutowireCandidateQualifier(Qualifier.class, id));

        registry.registerBeanDefinition(name, definition);

        return name;
    }

    public static  String generateBeanName(final Class type) {
        return UPPER_CAMEL.to(LOWER_CAMEL, type.getSimpleName());
    }

    public static  String generateBeanName(final String id, final Class type) {
        return LOWER_HYPHEN.to(LOWER_CAMEL, id) + type.getSimpleName();
    }

    public static BeanReference ref(final String beanName) {
        return new RuntimeBeanReference(beanName);
    }

    @SafeVarargs
    public static  List list(final T... elements) {
        final ManagedList list = new ManagedList<>();
        Collections.addAll(list, elements);
        return list;
    }

}