private <T> Optional<String> findComponent(Class<T> componentType) { String[] beans = beanFactory.getBeanNamesForType(componentType); if (beans.length == 1) { return Optional.of(beans[0]); } else if (beans.length > 1) { for (String bean : beans) { BeanDefinition beanDef = beanFactory.getBeanDefinition(bean); if (beanDef.isPrimary()) { return Optional.of(bean); } } logger.warn("Multiple beans of type {} found in application context: {}. Chose {}", componentType.getSimpleName(), beans, beans[0]); return Optional.of(beans[0]); } return Optional.empty(); }
private Optional<ParameterResolver> findQualifiedBean(Map<String, ?> beansFound, ConfigurableListableBeanFactory clBeanFactory, Parameter[] parameters, int parameterIndex) { final Parameter parameter = parameters[parameterIndex]; // find @Qualifier matching candidate final Optional<Map<String, Object>> qualifier = AnnotationUtils.findAnnotationAttributes(parameter, Qualifier.class); if (qualifier.isPresent()) { for (Map.Entry<String, ?> bean : beansFound.entrySet()) { if (SpringUtils.isQualifierMatch(bean.getKey(), clBeanFactory, (String) qualifier.get().get("qualifier"))) { return Optional.of(new SpringBeanParameterResolver(clBeanFactory, bean.getKey())); } } } // find @Primary matching candidate for (Map.Entry<String, ?> bean : beansFound.entrySet()) { if (clBeanFactory.containsBeanDefinition(bean.getKey()) && clBeanFactory.getBeanDefinition(bean.getKey()).isPrimary()) { return Optional.of(new SpringBeanParameterResolver(clBeanFactory, bean.getKey())); } } return Optional.empty(); }
private String determinePrimaryCandidate(BeanDefinitionRegistry registry, String[] candidateBeanNames, ResolvableType type) { String primaryBeanName = null; for (String candidateBeanName : candidateBeanNames) { BeanDefinition beanDefinition = registry.getBeanDefinition(candidateBeanName); if (beanDefinition.isPrimary()) { if (primaryBeanName != null) { throw new NoUniqueBeanDefinitionException(type.resolve(), candidateBeanNames.length, "more than one 'primary' bean found among candidates: " + asList(candidateBeanNames)); } primaryBeanName = candidateBeanName; } } return primaryBeanName; }
@SuppressWarnings("unchecked") private <T> T lazyBean(Class<T> interfaceName) { LazyInitTargetSource lazyTargetSource = new LazyInitTargetSource(); String[] beanNamesForType = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( applicationContext, interfaceName); if (beanNamesForType.length == 0) { return null; } String beanName; if (beanNamesForType.length > 1) { List<String> primaryBeanNames = Arrays.stream(beanNamesForType) .filter(i -> applicationContext instanceof ConfigurableApplicationContext) .filter(n -> ((ConfigurableApplicationContext) applicationContext).getBeanFactory().getBeanDefinition(n).isPrimary()) .collect(Collectors.toList()); Assert.isTrue(primaryBeanNames.size() != 0, () -> "Found " + beanNamesForType.length + " beans for type " + interfaceName + ", but none marked as primary"); Assert.isTrue(primaryBeanNames.size() == 1, () -> "Found " + primaryBeanNames.size() + " beans for type " + interfaceName + " marked as primary"); beanName = primaryBeanNames.get(0); } else { beanName = beanNamesForType[0]; } lazyTargetSource.setTargetBeanName(beanName); lazyTargetSource.setBeanFactory(applicationContext); ProxyFactoryBean proxyFactory = new ProxyFactoryBean(); proxyFactory = objectPostProcessor.postProcess(proxyFactory); proxyFactory.setTargetSource(lazyTargetSource); return (T) proxyFactory.getObject(); }
proxyDefinition.setPrimary(targetDefinition.isPrimary()); if (targetDefinition instanceof AbstractBeanDefinition) { proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
proxyDefinition.setPrimary(targetDefinition.isPrimary()); if (targetDefinition instanceof AbstractBeanDefinition) { proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
private static List<String> getPrimaryBeanDefinitions(List<String> beanNames, ConfigurableListableBeanFactory beanFactory) { ArrayList<String> primaryBeanNames = new ArrayList<>(); for (String name : beanNames) { if (beanFactory.getBeanDefinition(name).isPrimary()) { primaryBeanNames.add(name); } } return primaryBeanNames; }
ConfigurableListableBeanFactory clbf = (ConfigurableListableBeanFactory)beanFactory; String[] beanNames = clbf.getBeanNamesForType(myType); for (String beanName : beanNames) { BeanDefinition bd = clbf.getBeanDefinition(beanName); if (bd.isPrimary()) { ... } }
private Optional<String> moduleNameForBeanFactory() { return beanFactory.getBeansOfType( AcrossModule.class ) .keySet().stream() .filter( beanName -> beanFactory.getBeanDefinition( beanName ).isPrimary() ) .findFirst(); }
private void copyBeanDefinitionDetails(BeanDefinition from, RootBeanDefinition to) { to.setPrimary(from.isPrimary()); }
public boolean isPrimary(String name) { return definitionRegistry.getBeanDefinition(name).isPrimary(); }
private BeanDefinitionHolder getDataSourceBeanDefinition( ConfigurableListableBeanFactory beanFactory) { String[] beanNames = beanFactory.getBeanNamesForType(DataSource.class); if (ObjectUtils.isEmpty(beanNames)) { logger.warn("No DataSource beans found, " + "embedded version will not be used"); return null; } if (beanNames.length == 1) { String beanName = beanNames[0]; BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); return new BeanDefinitionHolder(beanDefinition, beanName); } for (String beanName : beanNames) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.isPrimary()) { return new BeanDefinitionHolder(beanDefinition, beanName); } } logger.warn("No primary DataSource found, " + "embedded version will not be used"); return null; }
private String determinePrimaryCandidate(BeanDefinitionRegistry registry, Collection<String> candidateBeanNames, ResolvableType type) { String primaryBeanName = null; for (String candidateBeanName : candidateBeanNames) { BeanDefinition beanDefinition = registry.getBeanDefinition(candidateBeanName); if (beanDefinition.isPrimary()) { if (primaryBeanName != null) { throw new NoUniqueBeanDefinitionException(type.resolve(), candidateBeanNames.size(), "more than one 'primary' bean found among candidates: " + Arrays.asList(candidateBeanNames)); } primaryBeanName = candidateBeanName; } } return primaryBeanName; }
private void process(BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory) { BeanDefinitionHolder holder = getDataSourceBeanDefinition(beanFactory); if (holder != null) { String beanName = holder.getBeanName(); boolean primary = holder.getBeanDefinition().isPrimary(); logger.info("Replacing '" + beanName + "' DataSource bean with " + (primary ? "primary " : "") + "embedded version"); registry.removeBeanDefinition(beanName); registry.registerBeanDefinition(beanName, createEmbeddedBeanDefinition(primary)); } }
private boolean isPrimary(String name, Scope scope) { ApplicationContext context = getApplicationContext(); while (context != null) { if (context instanceof ConfigurableApplicationContext) { ConfigurableListableBeanFactory factory = ((ConfigurableApplicationContext) context) .getBeanFactory(); if (factory.containsBean(name) && factory.getMergedBeanDefinition(name).isPrimary()) { return true; } } context = (scope != Scope.NO_ANCESTORS) ? context.getParent() : null; } return false; }
protected static BeanDefinitionHolder getFlywayBeanDefinition(ConfigurableListableBeanFactory beanFactory, FlywayTest[] annotations) { if (annotations.length > 1) { return null; // optimized loading is not supported yet when using multiple flyway test annotations } String flywayBeanName = resolveFlywayBeanName(annotations); if (StringUtils.isNotBlank(flywayBeanName)) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(flywayBeanName); return new BeanDefinitionHolder(beanDefinition, flywayBeanName); } String[] beanNames = beanFactory.getBeanNamesForType(Flyway.class); if (ObjectUtils.isEmpty(beanNames)) { return null; } if (beanNames.length == 1) { String beanName = beanNames[0]; BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); return new BeanDefinitionHolder(beanDefinition, beanName); } for (String beanName : beanNames) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.isPrimary()) { return new BeanDefinitionHolder(beanDefinition, beanName); } } return null; }
protected static BeanDefinitionHolder getDataSourceBeanDefinition(ConfigurableListableBeanFactory beanFactory, AutoConfigureEmbeddedDatabase annotation) { if (StringUtils.isNotBlank(annotation.beanName())) { if (beanFactory.containsBean(annotation.beanName())) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(annotation.beanName()); return new BeanDefinitionHolder(beanDefinition, annotation.beanName()); } else { return new BeanDefinitionHolder(new RootBeanDefinition(), annotation.beanName()); } } String[] beanNames = beanFactory.getBeanNamesForType(DataSource.class); if (ObjectUtils.isEmpty(beanNames)) { throw new IllegalStateException("No DataSource beans found, embedded version will not be used, " + "you must specify data source name - use @AutoConfigureEmbeddedDatabase(beanName = \"dataSource\") annotation"); } if (beanNames.length == 1) { String beanName = beanNames[0]; BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); return new BeanDefinitionHolder(beanDefinition, beanName); } for (String beanName : beanNames) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); if (beanDefinition.isPrimary()) { return new BeanDefinitionHolder(beanDefinition, beanName); } } throw new IllegalStateException("No primary DataSource found, embedded version will not be used"); }
private void registerPrimaryDataSource( DataSource expected, AcrossListableBeanFactory beanFactory, boolean hasInstallerDataSource ) { BeanDefinitionRegistry registry = getRegistryWithLocalBeanDefinition( beanFactory, DATASOURCE ); if ( registry != null ) { BeanDefinition beanDefinition = registry.getBeanDefinition( DATASOURCE ); boolean multipleDataSources = hasMultipleDataSources( beanFactory ) || hasInstallerDataSource; if ( multipleDataSources && !beanDefinition.isPrimary() ) { registerPrimaryDataSourceBeanDefinition( beanFactory, expected ); } } else if ( expected != null ) { registerPrimaryDataSourceBeanDefinition( beanFactory, expected ); } }
private void createDataSourceProxy(ConfigurableListableBeanFactory beanFactory, String beanName, BeanDefinition originDataSource, String jdbcUrl) { // re-register origin datasource bean BeanDefinitionRegistry beanDefinitionRegistry = (BeanDefinitionRegistry) beanFactory; beanDefinitionRegistry.removeBeanDefinition(beanName); boolean isPrimary = originDataSource.isPrimary(); originDataSource.setPrimary(false); beanDefinitionRegistry.registerBeanDefinition(transformDatasourceBeanName(beanName), originDataSource); // register proxied datasource RootBeanDefinition proxiedBeanDefinition = new RootBeanDefinition(SmartDataSource.class); proxiedBeanDefinition.setRole(BeanDefinition.ROLE_APPLICATION); proxiedBeanDefinition.setPrimary(isPrimary); proxiedBeanDefinition.setInitMethodName("init"); proxiedBeanDefinition.setDependsOn(transformDatasourceBeanName(beanName)); MutablePropertyValues originValues = originDataSource.getPropertyValues(); MutablePropertyValues values = new MutablePropertyValues(); String appName = environment.getProperty(TRACER_APPNAME_KEY); Assert.isTrue(!StringUtils.isBlank(appName), TRACER_APPNAME_KEY + " must be configured!"); values.add("appName", appName); values.add("delegate", new RuntimeBeanReference(transformDatasourceBeanName(beanName))); values.add("dbType", DataSourceUtils.resolveDbTypeFromUrl(unwrapPropertyValue(originValues.get(jdbcUrl)))); values.add("database", DataSourceUtils.resolveDatabaseFromUrl(unwrapPropertyValue(originValues.get(jdbcUrl)))); proxiedBeanDefinition.setPropertyValues(values); beanDefinitionRegistry.registerBeanDefinition(beanName, proxiedBeanDefinition); }
@Override public void postProcessBeanFactory( ConfigurableListableBeanFactory configurableListableBeanFactory) { DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory; Queue<Instance<?>> instances = getInstances(testContext); removeInstances(instances, beanFactory); addInstances(instances, beanFactory); for (String beanName : beanFactory.getBeanDefinitionNames()) { BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName); //mark all beans as lazy beans so we don't needlessly //instianticate them during testing beanDefinition.setLazyInit(true); Class<?> beanType = beanFactory.getType(beanName); if (beanDefinition.isPrimary()) { processPrimary(beanFactory, beanDefinition, beanName, beanType); } //by default spring eagerly initilizes singleton scoped beans such as //controllers so lets insure that controller entry points are prototype //scoped and thus make them lazy. boolean isController = isController(beanType); if (isController) { beanDefinition.setScope(SCOPE_PROTOTYPE); } } beanFactory.addBeanPostProcessor(new SpringReifierPostProcessor(testContext)); }