Java BeanDefinitionRegistry.getBeanDefinition方法代码示例

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
protected void validateServiceReferences(Element element, String serviceId, ParserContext parserContext) {
	BeanDefinitionRegistry registry = parserContext.getRegistry();
	String[] names = registry.getBeanDefinitionNames();

	for (String name : names) {
		BeanDefinition definition = registry.getBeanDefinition(name);
		Collection<String> exporters =
				(Collection<String>) definition.getAttribute(ParserUtils.REFERENCE_LISTENER_REF_ATTR);

		if (exporters != null && exporters.contains(serviceId)) {
			parserContext.getReaderContext()
					.error(
							"Service exporter '" + serviceId + "' cannot be used as a reference listener by '"
									+ name + "'", element);
		}
	}
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		return null;
	}
	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
/**
 * Checks if a bean of given type and bound to given data context id is already registered
 * @param beanFactory Bean factory
 * @param registry Bean registry
 * @param type Bean type to check
 * @param dataContextId Data context id
 * @param defaultBeanName Default bean name to check
 * @return The registered bean name if found, <code>null</code> otherwise
 */
private static String isBeanRegistered(ListableBeanFactory beanFactory, BeanDefinitionRegistry registry,
		Class<?> type, String dataContextId, String defaultBeanName) {
	String[] beanNames = beanFactory.getBeanNamesForType(type);
	if (beanNames != null && beanNames.length > 0) {
		for (String beanName : beanNames) {
			BeanDefinition bd = registry.getBeanDefinition(beanName);
			if (bd instanceof DataContextBoundBeanDefinition) {
				String did = ((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null);
				if ((dataContextId == null && did == null)
						|| (dataContextId != null && dataContextId.equals(did))) {
					return beanName;
				}
			} else {
				if (dataContextId == null) {
					return beanName;
				}
			}
		}
	}
	if (defaultBeanName != null && registry.containsBeanDefinition(defaultBeanName)) {
		return defaultBeanName;
	}
	return null;
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
private BeanDefinition findParentDefinition(String parentName, BeanDefinitionRegistry registry)
{   
    if (registry != null) 
    {
        if (registry.containsBeanDefinition(parentName)) 
        {
            return registry.getBeanDefinition(parentName);
        } 
        else if (registry instanceof HierarchicalBeanFactory) 
        {
            // Try to get parent definition from the parent BeanFactory. This could return null
            BeanFactory parentBeanFactory = ((HierarchicalBeanFactory)registry).getParentBeanFactory();
            return findParentDefinition(parentName, (BeanDefinitionRegistry)parentBeanFactory);
        } 
    }
    
    // we've exhausted all possibilities        
    return null;
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

	if (beanFactory instanceof ListableBeanFactory) {

		String[] dataSourceBeanNames = ((ListableBeanFactory) beanFactory).getBeanNamesForType(DataSource.class,
				false, true);
		if (dataSourceBeanNames != null) {
			for (String dataSourceBeanName : dataSourceBeanNames) {
				BeanDefinition bd = registry.getBeanDefinition(dataSourceBeanName);
				if (bd instanceof DataContextBoundBeanDefinition) {
					DataSourceRegistrar.registerDataSourceTransactionManager(registry, dataSourceBeanName,
							((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null),
							PrimaryMode.AUTO);
				}
			}
		}

	}

}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
public static boolean registerBeanDefinitionIfNotExists(BeanDefinitionRegistry registry, String beanName,
                                                        Class<?> beanClass) {
  if (registry.containsBeanDefinition(beanName)) {
    return false;
  }

  String[] candidates = registry.getBeanDefinitionNames();

  for (String candidate : candidates) {
    BeanDefinition beanDefinition = registry.getBeanDefinition(candidate);
    if (Objects.equals(beanDefinition.getBeanClassName(), beanClass.getName())) {
      return false;
    }
  }

  BeanDefinition annotationProcessor = BeanDefinitionBuilder.genericBeanDefinition(beanClass).getBeanDefinition();
  registry.registerBeanDefinition(beanName, annotationProcessor);

  return true;
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
/**
 * 为@ConfigBean的bean注册它的Factory Method，通过静态Factory Method来创建@ConfigBean实例
 *
 * @param registry
 */
private void registerFactoryMethodForConfigBeans(BeanDefinitionRegistry registry) {
    for (String beanName : registry.getBeanDefinitionNames()) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
        registerFactoryMethodForConfigBean(registry, beanName, beanDefinition);
    }
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
/**
 * 获取所有可刷新的beans
 *
 * @param registry
 */
private List<String> getRefreshScopeBeans(BeanDefinitionRegistry registry) {
    List<String> beanNames = new ArrayList<>();
    for (String beanName : registry.getBeanDefinitionNames()) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
        if (VersionRefreshScope.SCOPE_NAME.equalsIgnoreCase(beanDefinition.getScope())) {
            beanNames.add(beanName);
        }
    }
    return beanNames;
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
protected BeanDefinition registerSpringConfiguratorIfNecessary(BeanDefinitionRegistry registry)
{
    if (!registry.containsBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID))
    {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(SpringConfigurator.class);
        builder.addPropertyValue("creators", new ManagedMap());
        builder.addPropertyValue("converters", new ManagedMap());
        registry.registerBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID, builder.getBeanDefinition());
    }
    return registry.getBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID);
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
	if (beanFactory instanceof ListableBeanFactory) {
		// Get DataSource bean names
		List<String> dataSourceBeanNames = BeanRegistryUtils.getBeanNames((ListableBeanFactory) beanFactory,
				DataSource.class);
		List<String> dataSourceFactoryBeanNames = BeanRegistryUtils.getBeanNames((ListableBeanFactory) beanFactory,
				DataSourceFactoryBean.class);
		final List<String> dsBeanNames = new ArrayList<>(
				dataSourceBeanNames.size() + dataSourceFactoryBeanNames.size());
		dataSourceBeanNames.forEach(n -> dsBeanNames.add(n));
		dataSourceFactoryBeanNames.forEach(n -> {
			if (!dsBeanNames.contains(n)) {
				dsBeanNames.add(n);
			}
		});

		for (String dsBeanName : dsBeanNames) {
			// get data context id, if available
			String dataContextId = null;
			BeanDefinition bd = registry.getBeanDefinition(dsBeanName);
			if (bd instanceof DataContextBoundBeanDefinition) {
				dataContextId = ((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null);
			}

			// register JDBC datastore
			JdbcDatastoreRegistrar.registerDatastore(registry, environment, dataContextId, PrimaryMode.AUTO,
					dsBeanName, null, true, beanClassLoader);
		}
	}
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void postProcessBeanDefinitionRegistry(final BeanDefinitionRegistry registry) throws BeansException
{
    final BeanDefinition renditionServiceDefinition = registry.getBeanDefinition("renditionService");
    if (renditionServiceDefinition != null
            && renditionServiceDefinition.getBeanClassName().equals(RenditionServiceImpl.class.getName()))
    {
        renditionServiceDefinition.setBeanClassName(ArchiveSupportingRenditionServiceImpl.class.getName());
        renditionServiceDefinition.getPropertyValues().add("nodeArchiveService", new RuntimeBeanReference("nodeArchiveService"));
    }
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
	}
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
	}
}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
/**
 * Register a {@link JpaDatastore} bean
 * @param registry BeanDefinitionRegistry
 * @param dataContextId Data context id
 * @param primaryMode Primary mode
 * @param entityManagerFactoryBeanName EntityManagerFactory bean name reference
 * @param transactional Whether to add transactional behaviour to transactional datastore methods
 * @param beanClassLoader Bean class loader
 * @return Registered Datastore bean name
 */
public static String registerDatastore(BeanDefinitionRegistry registry, String dataContextId,
		PrimaryMode primaryMode, String entityManagerFactoryBeanName, boolean transactional, boolean autoFlush,
		ClassLoader beanClassLoader) {

	boolean primary = PrimaryMode.TRUE == primaryMode;
	if (!primary && PrimaryMode.AUTO == primaryMode) {
		if (registry.containsBeanDefinition(entityManagerFactoryBeanName)) {
			BeanDefinition bd = registry.getBeanDefinition(entityManagerFactoryBeanName);
			primary = bd.isPrimary();
		}
	}

	GenericDataContextBoundBeanDefinition definition = new GenericDataContextBoundBeanDefinition();
	definition.setDataContextId(dataContextId);

	Class<?> datastoreClass = transactional
			? addTransactionalAnnotations(DefaultSpringJpaDatastore.class, dataContextId, beanClassLoader)
			: DefaultSpringJpaDatastore.class;

	definition.setBeanClass(datastoreClass);

	definition.setAutowireCandidate(true);
	definition.setPrimary(primary);
	definition.setDependsOn(entityManagerFactoryBeanName);

	if (dataContextId != null) {
		definition.addQualifier(new AutowireCandidateQualifier(Qualifier.class, dataContextId));
	}

	MutablePropertyValues pvs = new MutablePropertyValues();
	pvs.add("entityManagerFactory", new RuntimeBeanReference(entityManagerFactoryBeanName));
	pvs.add("autoFlush", autoFlush);
	definition.setPropertyValues(pvs);

	String beanName = BeanRegistryUtils.buildBeanName(dataContextId,
			EnableJpaDatastore.DEFAULT_DATASTORE_BEAN_NAME);

	registry.registerBeanDefinition(beanName, definition);

	StringBuilder log = new StringBuilder();
	if (dataContextId != null) {
		log.append("<Data context id: ");
		log.append(dataContextId);
		log.append("> ");
	}
	log.append("Registered JPA Datastore bean with name \"");
	log.append(beanName);
	log.append("\"");
	if (dataContextId != null) {
		log.append(" and qualifier \"");
		log.append(dataContextId);
		log.append("\"");
	}
	log.append(" bound to EntityManagerFactory bean: ");
	log.append(entityManagerFactoryBeanName);
	logger.info(log.toString());

	return beanName;

}
 

import org.springframework.beans.factory.support.BeanDefinitionRegistry; //导入方法依赖的package包/类
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {

	// Register JPA beans for every Data context bound DataSource
	if (beanFactory instanceof ListableBeanFactory) {
		ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;

		String[] dataSourceBeanNames = listableBeanFactory.getBeanNamesForType(DataSource.class, false, true);
		if (dataSourceBeanNames != null) {
			for (String dataSourceBeanName : dataSourceBeanNames) {
				BeanDefinition bd = registry.getBeanDefinition(dataSourceBeanName);
				if (bd instanceof DataContextBoundBeanDefinition) {
					String dataContextId = ((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null);

					String emfBeanName = isBeanRegistered(listableBeanFactory, registry, EntityManagerFactory.class,
							dataContextId, BeanRegistryUtils.buildBeanName(dataContextId,
									EnableJpa.DEFAULT_ENTITYMANAGERFACTORY_BEAN_NAME));
					if (emfBeanName == null) {

						Map<String, Object> attributes = new HashMap<>();
						attributes.put("dataContextId", dataContextId);
						attributes.put("dataSourceReference", dataSourceBeanName);
						attributes.put("entityPackages", getPackagesToScan(dataContextId));
						attributes.put("enableDatastore", Boolean.FALSE);
						emfBeanName = JpaRegistrar.registerJpaBeans(registry, beanFactory, environment, attributes,
								beanClassLoader);

					}

					if (emfBeanName != null && isBeanRegistered(listableBeanFactory, registry, JpaDatastore.class,
							dataContextId, BeanRegistryUtils.buildBeanName(dataContextId,
									EnableJpaDatastore.DEFAULT_DATASTORE_BEAN_NAME)) == null) {
						// Register JPA Datastore (transactional)
						JpaDatastoreRegistrar.registerDatastore(registry, dataContextId, PrimaryMode.AUTO,
								emfBeanName, true, false, beanClassLoader);
					}

				}
			}
		}

	}

}