Example usage for org.springframework.beans.factory.config BeanDefinition getDependsOn

List of usage examples for org.springframework.beans.factory.config BeanDefinition getDependsOn

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.config.*
  5. BeanDefinition
  6. getDependsOn

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config BeanDefinition getDependsOn.

Prototype

@Nullable
String[] getDependsOn();

Source Link

Document

Return the bean names that this bean depends on.

Usage

From source file:co.paralleluniverse.common.spring.SpringContainerHelper.java

public static Collection<String> getBeanDependencies(BeanDefinition beanDefinition) {
    Set<String> dependencies = new HashSet<String>();
    if (beanDefinition.getDependsOn() != null)
        dependencies.addAll(Arrays.asList(beanDefinition.getDependsOn()));

    for (ValueHolder value : beanDefinition.getConstructorArgumentValues().getGenericArgumentValues()) {
        if (value.getValue() instanceof BeanReference)
            dependencies.add(((BeanReference) value.getValue()).getBeanName());
    }//from w w  w .  java2  s .  c  om
    for (ValueHolder value : beanDefinition.getConstructorArgumentValues().getIndexedArgumentValues()
            .values()) {
        if (value.getValue() instanceof BeanReference)
            dependencies.add(((BeanReference) value.getValue()).getBeanName());
    }
    for (PropertyValue value : beanDefinition.getPropertyValues().getPropertyValueList()) {
        if (value.getValue() instanceof BeanReference)
            dependencies.add(((BeanReference) value.getValue()).getBeanName());
    }
    return dependencies;
}

From source file:org.synyx.hades.domain.auditing.support.AuditingBeanFactoryPostProcessorUnitTest.java

@Test
public void testname() throws Exception {

    processor.postProcessBeanFactory(beanFactory);

    BeanDefinition definition = beanFactory.getBeanDefinition("entityManagerFactory");

    assertTrue(Arrays.asList(definition.getDependsOn())
            .contains(AuditingBeanFactoryPostProcessor.BEAN_CONFIGURER_ASPECT_BEAN_NAME));
}

From source file:org.zalando.spring.data.businesskey.config.BusinessKeyBeanFactoryPostProcessor.java

public void postProcessBeanFactory(final ConfigurableListableBeanFactory beanFactory) throws BeansException {

    try {/*from   w  w  w. j  a v  a  2 s.  c om*/
        getBeanDefinition(BEAN_CONFIGURER_ASPECT_BEAN_NAME, beanFactory);
    } catch (NoSuchBeanDefinitionException o_O) {
        throw new IllegalStateException(
                "Invalid auditing setup! Make sure you've used @EnableJpaAuditing or <jpa:auditing /> correctly!",
                o_O);
    }

    for (String beanName : getEntityManagerFactoryBeanNames(beanFactory)) {
        BeanDefinition definition = getBeanDefinition(beanName, beanFactory);
        definition.setDependsOn(addStringToArray(definition.getDependsOn(), BEAN_CONFIGURER_ASPECT_BEAN_NAME));
    }

    // for (String beanName : beanNamesForTypeIncludingAncestors(beanFactory, BusinessKeyGenerator.class, true, false)) {
    // BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
    // definition.setLazyInit(true);
    // }
}

From source file:io.github.hzpz.spring.boot.autoconfigure.mongeez.MongoDbFactoryDependsOnPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    for (String beanName : getMongoDbFactoryBeanNames(beanFactory)) {
        BeanDefinition definition = getBeanDefinition(beanName, beanFactory);
        definition.setDependsOn(StringUtils.addStringToArray(definition.getDependsOn(), this.dependsOn));
    }//  ww w.  j a va 2s  . c  om

}

From source file:example.app.config.gemfire.GemFireDependsOnBeanFactoryPostProcessor.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    for (String beanName : gemfireCacheBeanNames(beanFactory)) {
        BeanDefinition bean = beanFactory.getBeanDefinition(beanName);
        List<String> beanDependencies = new ArrayList<>(asList(bean.getDependsOn()));
        beanDependencies.addAll(dependsOnBeanNames);
        bean.setDependsOn(beanDependencies.toArray(new String[beanDependencies.size()]));
    }/*w  w w. j av a2s . c o m*/
}

From source file:org.synyx.hades.domain.auditing.support.AuditingBeanFactoryPostProcessor.java

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

    if (!isSpringConfigured(beanFactory)) {
        return;// w w  w . ja va2s  . c  o  m
    }

    for (String beanName : beanFactory.getBeanDefinitionNames()) {

        BeanDefinition definition = beanFactory.getBeanDefinition(beanName);

        if (CLASSES_TO_DEPEND.contains(definition.getBeanClassName())) {
            definition.setDependsOn(
                    StringUtils.addStringToArray(definition.getDependsOn(), BEAN_CONFIGURER_ASPECT_BEAN_NAME));
        }
    }

    for (String beanName : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, AuditorAware.class,
            true, false)) {
        BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
        definition.setLazyInit(true);
    }
}

From source file:me.tfeng.play.plugins.StartablePlugin.java

public List<Startable> getStartables() {
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) getApplicationContext()
            .getAutowireCapableBeanFactory();
    Comparator<Entry<String, Startable>> beanDependencyComparator = (bean1, bean2) -> {
        String beanName1 = bean1.getKey();
        String beanName2 = bean2.getKey();
        BeanDefinition beanDefinition1 = registry.getBeanDefinition(beanName1);
        BeanDefinition beanDefinition2 = registry.getBeanDefinition(beanName2);
        if (beanDefinition1 == null || beanDefinition2 == null) {
            return 0;
        } else if (ArrayUtils.contains(beanDefinition1.getDependsOn(), beanName2)) {
            return 1;
        } else if (ArrayUtils.contains(beanDefinition2.getDependsOn(), beanName1)) {
            return -1;
        } else {/* w  w w .j  av a2  s .c o m*/
            return beanName1.compareTo(beanName2);
        }
    };
    Set<Entry<String, Startable>> entries = getApplicationContext().getBeansOfType(Startable.class).entrySet();
    List<Entry<String, Startable>> sortedEntries = DependencyUtils.dependencySort(entries,
            beanDependencyComparator);
    List<Startable> result = new ArrayList<>(startables.size() + sortedEntries.size());
    result.addAll(startables);
    for (Entry<String, Startable> entry : sortedEntries) {
        Startable startable = entry.getValue();
        if (!startables.contains(startable)) {
            result.add(startable);
        }
    }
    return result;
}

From source file:org.eclipse.gemini.blueprint.blueprint.container.support.internal.config.CycleOrderingProcessor.java

private void addSyntheticDependsOn(BeanDefinition definition, String beanName) {
    if (StringUtils.hasText(beanName)) {
        String[] dependsOn = definition.getDependsOn();
        if (dependsOn != null && dependsOn.length > 0) {
            for (String dependOn : dependsOn) {
                if (beanName.equals(dependOn)) {
                    return;
                }//from   ww  w .jav a 2s. com
            }
        }

        // add depends on
        dependsOn = (String[]) ObjectUtils.addObjectToArray(dependsOn, beanName);
        definition.setDependsOn(dependsOn);
        Collection<String> markers = (Collection<String>) definition.getAttribute(SYNTHETIC_DEPENDS_ON);
        if (markers == null) {
            markers = new ArrayList<String>(2);
            definition.setAttribute(SYNTHETIC_DEPENDS_ON, markers);
        }
        markers.add(beanName);
    }
}

From source file:org.opentestsystem.shared.test.listener.LifecycleResourceCombiner.java

private LifecycleResource[] getSortedResources() {
    // Build a doubly-linked tree of all Spring dependencies.
    final ApplicationContext context = getApplicationContext();
    final BeanDefinitionRegistry registry = (BeanDefinitionRegistry) context;
    final Map<String, BeanHolder> beanHolderMap = new HashMap<String, BeanHolder>();

    for (String key_i : registry.getBeanDefinitionNames()) {
        final BeanDefinition definition_i = registry.getBeanDefinition(key_i);

        // Make sure that there is a holder for this bean in the map.
        // The holder may exist already if this bean's name has appeared as a
        // dependency for another bean.
        BeanHolder beanHolder = beanHolderMap.get(key_i);
        if (beanHolder == null) {
            beanHolder = new BeanHolder(key_i);
            beanHolderMap.put(key_i, beanHolder);
        }/*from w  ww. j av  a  2  s .c  om*/
        beanHolder.bean = context.getBean(key_i);

        // Add the constructor arguments as antecedents
        BeanHolder antecedentHolder = null;
        String antecedentBeanName = null;
        for (final ValueHolder value_j : definition_i.getConstructorArgumentValues()
                .getGenericArgumentValues()) {
            final Object antecedentValue = value_j.getValue();
            if (antecedentValue instanceof RuntimeBeanReference) {
                antecedentBeanName = ((RuntimeBeanReference) antecedentValue).getBeanName();
                antecedentHolder = beanHolderMap.get(antecedentBeanName);
                if (antecedentHolder == null) {
                    antecedentHolder = new BeanHolder(antecedentBeanName);
                    beanHolderMap.put(antecedentBeanName, antecedentHolder);
                }
                beanHolder.beansIDependOn.add(antecedentHolder);
                antecedentHolder.beansWhoDependOnMe.add(beanHolder);
            }
        }

        // Add any factory bean as antecedent
        antecedentBeanName = definition_i.getFactoryBeanName();
        if (!StringUtils.isBlank(antecedentBeanName)) {
            antecedentHolder = beanHolderMap.get(antecedentBeanName);
            if (antecedentHolder == null) {
                antecedentHolder = new BeanHolder(antecedentBeanName);
                beanHolderMap.put(antecedentBeanName, antecedentHolder);
            }
            beanHolder.beansIDependOn.add(antecedentHolder);
            antecedentHolder.beansWhoDependOnMe.add(beanHolder);
        }

        // Add the properties as antecedents
        if (definition_i.getPropertyValues() != null
                && definition_i.getPropertyValues().getPropertyValueList() != null) {
            for (final PropertyValue value_j : definition_i.getPropertyValues().getPropertyValueList()) {
                final Object antecedentValue = value_j.getValue();
                if (antecedentValue instanceof RuntimeBeanReference) {
                    antecedentBeanName = ((RuntimeBeanReference) antecedentValue).getBeanName();
                    antecedentHolder = beanHolderMap.get(antecedentBeanName);
                    if (antecedentHolder == null) {
                        antecedentHolder = new BeanHolder(antecedentBeanName);
                        beanHolderMap.put(antecedentBeanName, antecedentHolder);
                    }
                    beanHolder.beansIDependOn.add(antecedentHolder);
                    antecedentHolder.beansWhoDependOnMe.add(beanHolder);
                }
            }
        }

        // Add explicitly identified antecedents
        if (definition_i.getDependsOn() != null) {
            for (String name_j : definition_i.getDependsOn()) {
                antecedentBeanName = name_j;
                antecedentHolder = beanHolderMap.get(antecedentBeanName);
                if (antecedentHolder == null) {
                    antecedentHolder = new BeanHolder(antecedentBeanName);
                    beanHolderMap.put(antecedentBeanName, antecedentHolder);
                }
                beanHolder.beansIDependOn.add(antecedentHolder);
                antecedentHolder.beansWhoDependOnMe.add(beanHolder);
            }
        }
    }

    // Prune the tree of all items that aren't LifecycleResource
    // This step is easier with a stable ordering, so we copy things into a
    // list.
    List<BeanHolder> beanHolderList = new ArrayList<BeanHolder>(beanHolderMap.values());
    int i = 0;
    while (i < beanHolderList.size()) {
        final BeanHolder beanHolder_i = beanHolderList.get(i);
        if (beanHolder_i.bean instanceof LifecycleResource) {
            i++;
        } else {
            for (final BeanHolder antecedent_j : beanHolder_i.beansIDependOn) {
                for (final BeanHolder dependent_k : beanHolder_i.beansWhoDependOnMe) {
                    dependent_k.beansIDependOn.add(antecedent_j);
                    antecedent_j.beansWhoDependOnMe.add(dependent_k);
                }
                antecedent_j.beansWhoDependOnMe.remove(beanHolder_i);
            }
            for (final BeanHolder dependent_j : beanHolder_i.beansWhoDependOnMe) {
                dependent_j.beansIDependOn.remove(beanHolder_i);
            }
            beanHolderList.remove(i);
        }
    }

    // Now do the topo sort.
    //
    // We cycle through the list repeatedly. Each time, we can pull out anyone
    // who doesn't have a dependency on anyone else who is still in the list.
    // This leads to everyone being pulled out before their dependencies.
    //
    // If at the end we still have people in the list who depend on each
    // other, we have a dependency cycle.

    i = 0;
    boolean found = true;
    int n = beanHolderList.size();
    LifecycleResource[] ans = new LifecycleResource[n];
    StringBuilder message = new StringBuilder(
            "Resolved sequence of LifecycleResource elements in Spring context:\r\n  ");
    while (i < n) {
        if (!found) {
            // We got all the way through the list without finding any with no
            // antecedents. There is a cycle
            StringBuilder beanNames = new StringBuilder();
            for (BeanHolder beanHolder_k : beanHolderList) {
                beanNames.append(beanHolder_k.beanName).append(" depends on ( ");
                for (BeanHolder beanHolder_l : beanHolder_k.beansIDependOn) {
                    beanNames.append(beanHolder_l.beanName).append(" ");
                }
                beanNames.append(")\r\n");
            }
            throw new RuntimeException(String.format(
                    "LifecycleResource beans have one or more reference cycles involving:\r\n   %s",
                    beanNames));
        }
        found = false;
        int j = 0;
        while (j < beanHolderList.size()) {
            final BeanHolder beanHolder_j = beanHolderList.get(j);
            if (beanHolder_j.beansIDependOn.size() == 0) {
                ans[i] = (LifecycleResource) beanHolder_j.bean;
                i++;
                found = true;
                beanHolderList.remove(j);
                for (final BeanHolder beanHolder_k : beanHolder_j.beansWhoDependOnMe) {
                    beanHolder_k.beansIDependOn.remove(beanHolder_j);
                }
                message.append(beanHolder_j.beanName).append(" ");
            } else {
                j++;
            }
        }
    }
    _logger.info(message.toString());
    return ans;
}