org.springframework.context.ApplicationContext.getBeansOfType()

/**
 * 根据bean的clreplaced来查找所有的对象（包括子类）
 * @param <T>
 * @param c
 * @return
 */
public static <T> Map<String, T> getBeansByClreplaced(Clreplaced<T> c) {
    return applicationContext.getBeansOfType(c);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> clreplacedz) {
    return applicationContext.getBeansOfType(clreplacedz);
}

public static <T> Map<String, T> getBeansByClreplaced(Clreplaced<T> tClreplaced) {
    if (applicationContext == null) {
        return null;
    }
    return applicationContext.getBeansOfType(tClreplaced);
}

public <T> Map<String, T> getInterfaces(Clreplaced<T> beanClreplaced) {
    return applicationContext.getBeansOfType(beanClreplaced);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> requiredType) throws BeansException {
    return context.getBeansOfType(requiredType);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    return applicationContext.getBeansOfType(type);
}

@GetMapping("/{cacheManager}")
public Object getAllCache(@PathVariable("cacheManager") String cacheManager) {
    return applicationContext.getBeansOfType(CacheManager.clreplaced).entrySet().stream().filter(en -> en.getKey().equals(cacheManager)).map(en -> en.getValue().getCacheNames()).findFirst().orElseGet(ArrayDeque::new);
}

/**
 * 加载插件实例
 *
 * @param clazz 插件类型
 * @return 插件Map, key为bean名称, value为插件实例对象
 */
protected Map<String, InterceptorPlugin> getPlugins(Clreplaced<InterceptorPlugin> clazz) {
    return applicationContext.getBeansOfType(clazz);
}

Set<String> getCalendarNames() {
    return context.getBeansOfType(CalendarCLIAdapter.clreplaced).keySet();
}

private Set<Map.Entry<String, InjectorService>> getInjectorEntrySet() {
    return context.getBeansOfType(InjectorService.clreplaced).entrySet();
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> clazz) {
    return applicationContext.getBeansOfType(clazz);
}

public <T> Map<String, T> getRunner(Clreplaced<T> type) {
    return context.getBeansOfType(type);
}

/**
 * 根据类型获取容器中实例的集合
 *
 * @param requiredType
 * @return
 * @date 2015年11月17日
 * @since V2.1.0
 * @author Ternence
 */
public static <T> Map<String, T> getBeans(Clreplaced<T> requiredType) {
    checkApplicationContext();
    return applicationContext.getBeansOfType(requiredType);
}

/**
 * 以Collection形式获取T的所有实例
 *
 * @param clazz
 * @param <T>
 * @return
 */
public static <T> Collection<T> getBeansByTypeToCollection(Clreplaced<T> clazz) {
    return applicationContext.getBeansOfType(clazz).values();
}

/**
 * 以Map形式获取T的所有实例
 *
 * @param clazz
 * @param <T>
 * @return
 */
public static <T> Map<String, T> getBeansByTypeToMap(Clreplaced<T> clazz) {
    return applicationContext.getBeansOfType(clazz);
}

/**
 * 根据bean类型获取spring ioc管理的bean实例
 * @param type bean类型，clreplaced或interface
 * @return bean实例集合
 */
public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    return applicationContext.getBeansOfType(type);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    return context.getBeansOfType(type);
}

/**
 * 使用spring上下文环境获取bean
 * @param klreplaced bean的类型
 * @author Frodez
 * @param <T>
 * @date 2018-12-21
 */
public static <T> Map<String, T> beans(Clreplaced<T> klreplaced) {
    return context.getBeansOfType(klreplaced);
}

public static Map<String, Object> getBeansOfType(Clreplaced clz) {
    return context.getBeansOfType(clz);
}

/**
 * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的Map集合.
 */
public static <T> Map<String, T> getBeanMap(Clreplaced<T> clazz) {
    checkApplicationContext();
    return applicationContext.getBeansOfType(clazz);
}

private void fireDeployContextAware() {
    context.getBeansOfType(RestlightDeployContextAware.clreplaced).values().forEach(aware -> aware.setDeployContext(deployments().deployContext()));
}

/**
 * 根据类型获取beanMap
 *
 * @param clz
 * @return
 */
public static <T> Map<String, T> getBeansOfType(Clreplaced<T> clz) {
    if (applicationContext == null) {
        return null;
    }
    return applicationContext.getBeansOfType(clz);
}

public static Map getBeansByClreplaced(Clreplaced c) {
    return applicationContext.getBeansOfType(c);
}

/**
 * 获取指定类型对应的所有Bean，包括子类
 *
 * @param <T>  Bean类型
 * @param type 类、接口，null表示获取所有bean
 * @return 类型对应的bean，key是bean注册的name，value是Bean
 */
public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    return applicationContext.getBeansOfType(type);
}

public static <T> Map<String, T> getBeans(Clreplaced<T> clazz) throws BeansException {
    return applicationContext.getBeansOfType(clazz);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) throws BeansException {
    return applicationContext.getBeansOfType(type);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException {
    return applicationContext.getBeansOfType(type, includeNonSingletons, allowEagerInit);
}

public static <T> Map<String, T> getBeans(Clreplaced<T> clazz) {
    return context.getBeansOfType(clazz);
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> baseType) {
    if (applicationContext != null) {
        return applicationContext.getBeansOfType(baseType);
    } else {
        return new HashMap<>();
    }
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    replacedert.notNull(type, "SpringUtil type is null");
    try {
        return applicationContext.getBeansOfType(type);
    } catch (Exception e) {
        return parentApplicationContext.getBeansOfType(type);
    }
}

/**
 * 注册配置项预处理器
 *
 * @return
 */
private void registerConfigItemPostProcessors() {
    List<ConfigItemPostProcessor> configItemPostProcessors = new ArrayList<>();
    configItemPostProcessors.addAll(applicationContext.getBeansOfType(ConfigItemPostProcessor.clreplaced).values());
    AnnotationAwareOrderComparator.sort(configItemPostProcessors);
    this.configItemPostProcessors.addAll(configItemPostProcessors);
}

@Override
protected <T> Iterable<T> findCandidatesByType(Clreplaced<T> beanClreplaced) {
    return applicationContext.getBeansOfType(beanClreplaced).values();
}

/**
 * 获取Bean
 */
private <T> T getBean(Clreplaced<T> clazz) {
    T bean = null;
    Collection<T> beans = applicationContext.getBeansOfType(clazz).values();
    while (beans.iterator().hasNext()) {
        bean = beans.iterator().next();
        if (bean != null)
            break;
    }
    return bean;
}

/**
 * 获取Bean
 */
private <T> T getBean(Clreplaced<T> clazz) {
    T bean = null;
    Collection<T> beans = applicationContext.getBeansOfType(clazz).values();
    while (beans.iterator().hasNext()) {
        bean = beans.iterator().next();
        if (bean != null) {
            break;
        }
    }
    return bean;
}

@Test
public void testContextConfiguration() {
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced).values()).hasAtLeastOneElementOfType(TracingCamelContextConfiguration.clreplaced);
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced)).hreplacedize(2);
    replacedertThat(applicationContext.getBeansOfType(Tracer.clreplaced)).hreplacedize(1);
    replacedertThat(camelContext.getLogListeners()).hasAtLeastOneElementOfType(TracingLogListener.clreplaced);
}

@Test
public void testDisabledContextConfiguration() {
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced).values()).doesNotHaveAnyElementsOfTypes(TracingCamelContextConfiguration.clreplaced);
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced)).hreplacedize(1);
    replacedertThat(camelContext.getLogListeners()).have(new Condition<LogListener>() {

        @Override
        public boolean matches(LogListener value) {
            return !(value instanceof TracingLogListener);
        }
    });
}

@Test
public void testContextConfiguration() {
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced)).hreplacedize(2);
    replacedertThat(applicationContext.getBeansOfType(ActivityTracker.clreplaced)).hreplacedize(1);
    replacedertThat(applicationContext.getBeansOfType(ActivityTracker.clreplaced).values()).hasAtLeastOneElementOfType(ActivityTracker.SysOut.clreplaced);
    replacedertThat(camelContext.getLogListeners()).hasAtLeastOneElementOfType(IntegrationLoggingListener.clreplaced);
    replacedertThat(camelContext.getUuidGenerator()).isNotInstanceOf(DefaultUuidGenerator.clreplaced);
}

@Test
public void testDisabledContextConfiguration() {
    replacedertThat(applicationContext.getBeansOfType(CamelContextConfiguration.clreplaced)).is(new Condition<Map<String, CamelContextConfiguration>>() {

        @Override
        public boolean matches(Map<String, CamelContextConfiguration> value) {
            return value.size() == 1 && value.containsKey("integrationContextRuntimeConfiguration");
        }
    });
    replacedertThat(camelContext.getLogListeners()).have(new Condition<LogListener>() {

        @Override
        public boolean matches(LogListener value) {
            return !(value instanceof IntegrationLoggingListener);
        }
    });
    replacedertThat(camelContext.getUuidGenerator()).isInstanceOf(DefaultUuidGenerator.clreplaced);
}

@Test
public void testApplicationSetup() {
    replacedertThat(applicationContext.getBeansOfType(IntegrationRuntimeAutoConfiguration.clreplaced)).hreplacedize(1);
    replacedertThat(applicationContext.getBeansOfType(IntegrationMetadataAutoConfiguration.clreplaced)).hreplacedize(1);
    replacedertThat(applicationContext.getBeansOfType(IntegrationLoggingAutoConfiguration.clreplaced)).hreplacedize(1);
    replacedertThat(applicationContext.getBeansOfType(SyndesisHttpConfiguration.clreplaced)).hreplacedize(1);
}

protected <T> List<T> getBeans(Clreplaced<T> cls) {
    Map<String, T> beans = cxt.getBeansOfType(cls);
    return new ArrayList<>(beans.values());
}

@GetMapping()
public Object getAllCacheManager() {
    return applicationContext.getBeansOfType(CacheManager.clreplaced).entrySet().stream().map((entry) -> {
        entry.getKey();
        Map<String, Object> cm = new HashMap<>();
        cm.put("name", entry.getKey());
        cm.put("caches", entry.getValue().getCacheNames());
        return cm;
    }).collect(Collectors.toList());
}

@Override
public <W extends Wizard<?, ?>> Collection<W> getWizardsOfType(Clreplaced<W> wizardClreplaced) {
    return _applicationContext.getBeansOfType(wizardClreplaced).values();
}

/**
 * 获取拦截类的所有钩子
 */
@PostConstruct
private void init() {
    Map<String, InterceptorHook> map = applicationContext.getBeansOfType(InterceptorHook.clreplaced);
    Iterator<Map.Entry<String, InterceptorHook>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, InterceptorHook> entry = it.next();
        InterceptorHook interceptorHook = entry.getValue();
        String[] names = interceptorHook.getInterceptor();
        addInterceptorHook(names, interceptorHook);
    }
}

@Test
public void should_replace_single_bean_with_mock() {
    replacedertSame(aMock, mock);
    replacedertEquals(1, applicationContext.getBeansOfType(ServiceToMock.clreplaced).size());
}

@Test
public void should_replace_single_bean_with_spy() {
    replacedertSame(aSpy, spy);
    replacedertEquals(1, applicationContext.getBeansOfType(ServiceToSpy.clreplaced).size());
}

@Test
public void test() {
    replacedertEquals(2, applicationContext.getBeansOfType(TracingChannelInterceptor.clreplaced).size());
}

public static <T> Map<String, T> getBeansOfType(Clreplaced<T> type) {
    replacedert.notNull(type, "SpringContextHolder type is null");
    try {
        return applicationContext.getBeansOfType(type);
    } catch (Exception var2) {
        return parentApplicationContext.getBeansOfType(type);
    }
}

@Deprecated
public static <T> Map<String, T> getBeansOfType(Clreplaced<T> clazz) {
    return CONTEXT.getBeansOfType(clazz);
}

/**
 * {@inheritDoc}<BR/>
 * This implementation works only if this clreplaced has been loaded as a Spring Component.
 */
@Override
public void registerAllDirectives() {
    for (Directive type : ctx.getBeansOfType(Directive.clreplaced).values()) {
        registerDirective(type);
    }
}

private void loadSmartModules() {
    logger.info("SMART MODULES LOADING");
    Map<String, SmartModule> modulesMap = context.getBeansOfType(SmartModule.clreplaced);
    this.smartModules = modulesMap.values().stream().sorted(Comparator.comparingInt(SmartModule::order)).collect(Collectors.toList());
    for (SmartModule module : smartModules) {
        logger.info("Found SMART Module {} with dependecies {}", module.getName(), module.getDependencies());
    }
}

See More Examples