下面列出了org.springframework.context.annotation.ImportBeanDefinitionRegistrar#org.springframework.beans.factory.support.BeanDefinitionRegistry 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (annotationPackage == null || annotationPackage.length() == 0) {
return;
}
if (beanFactory instanceof BeanDefinitionRegistry) {
try {
// init scanner
Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
Object scanner = scannerClass.getConstructor(new Class<?>[] {BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[] {(BeanDefinitionRegistry) beanFactory, true});
// add filter
Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");
Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);
Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));
addIncludeFilter.invoke(scanner, filter);
// scan packages
String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});
scan.invoke(scanner, new Object[] {packages});
} catch (Throwable e) {
// spring 2.0
}
}
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (annotationPackage == null || annotationPackage.length() == 0) {
return;
}
if (beanFactory instanceof BeanDefinitionRegistry) {
try {
// init scanner
Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
Object scanner = scannerClass.getConstructor(new Class<?>[]{BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[]{(BeanDefinitionRegistry) beanFactory, true});
// add filter
Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");
Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);
Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));
addIncludeFilter.invoke(scanner, filter);
// scan packages
String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});
scan.invoke(scanner, new Object[]{packages});
} catch (Throwable e) {
// spring 2.0
}
}
}
public synchronized static void create(ApplicationContext applicationContext) {
DoradoServerBuilder builder = Dorado.serverConfig;
if (builder == null) {
throw new IllegalStateException("Please init DoradoServer first!");
}
if (!(applicationContext instanceof DoradoApplicationContext)
&& (applicationContext instanceof BeanDefinitionRegistry)) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(
(BeanDefinitionRegistry) applicationContext);
scanner.resetFilters(false);
scanner.addIncludeFilter(new AnnotationTypeFilter(Controller.class));
scanner.scan(builder.scanPackages());
}
instance = new SpringContainer(applicationContext);
Dorado.springInitialized = true;
}
private String registerFinderBean(
ReferenceFactory referenceFactory,
PersistenceSupportBeanFactory persistenceFactory,
StatefulController statefulContollerAnnotation,
String repoBeanId,
BeanDefinitionRegistry reg) {
String finderId = statefulContollerAnnotation.finderId();
if (StringUtils.isEmpty(finderId)) {
if (persistenceFactory == null) {
throw new RuntimeException("PersistenceFactory is undefined and no finder bean was specified in the StatefulController Annotation for " + statefulContollerAnnotation.clazz());
}
if (StringUtils.isEmpty(repoBeanId)) {
throw new RuntimeException("No Repository is defined for " + statefulContollerAnnotation.clazz());
}
finderId = referenceFactory.getFinderId();
reg.registerBeanDefinition(
finderId,
persistenceFactory.buildFinderBean(repoBeanId));
}
return finderId;
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
// 解析指定扫描的包名=》
Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);
if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
// 注册服务提供者bean定义=》
registerServiceBeans(resolvedPackagesToScan, registry);
} else {
if (logger.isWarnEnabled()) {
logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
}
}
}
private String registerState(
ReferenceFactory referenceFactory,
Class<?> statefulControllerClass,
String state,
boolean isBlocking,
BeanDefinitionRegistry reg) {
String stateId = referenceFactory.getStateId(state);
BeanDefinition stateBean = BeanDefinitionBuilder
.genericBeanDefinition(StateImpl.class)
.getBeanDefinition();
ConstructorArgumentValues args = stateBean.getConstructorArgumentValues();
args.addIndexedArgumentValue(0, state);
args.addIndexedArgumentValue(1, false);
args.addIndexedArgumentValue(2, isBlocking);
reg.registerBeanDefinition(stateId, stateBean);
return stateId;
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
throws BeansException {
registry.registerBeanDefinition("foo", BeanDefinitionBuilder
.genericBeanDefinition(Foo.class, () -> foo()).getBeanDefinition());
registry.registerBeanDefinition("bar",
BeanDefinitionBuilder
.genericBeanDefinition(Bar.class,
() -> bar(context.getBean(Foo.class)))
.getBeanDefinition());
registry.registerBeanDefinition("runner",
BeanDefinitionBuilder
.genericBeanDefinition(CommandLineRunner.class,
() -> runner(context.getBean(Bar.class)))
.getBeanDefinition());
}
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
if (sourceElement != null) {
// 这方法作用挺简单的，就是解析下面两个属性，如果是 true，将它们加入代理注册器的属性列表中
// definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE)
boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
if (proxyTargetClass) {
// 处理 proxy-target-class 属性
// 与代码生成方式有关，在之后步骤中决定使用 jdk 动态代理 或 cglib
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
if (exposeProxy) {
// 处理 expose-proxy 属性
// 扩展增强，有时候目标对象内部的自我调用无法实施切面中的增强，通过这个属性可以同时对两个方法进行增强
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
/**
* @param bf
* @param reg
* @param clazz
* @return
* @throws ClassNotFoundException
*/
private Class<?> getClassFromFactoryMethod(BeanDefinition bf, BeanDefinitionRegistry reg)
throws ClassNotFoundException {
Class<?> clazz = null;
String factoryBeanName = bf.getFactoryBeanName();
if (factoryBeanName != null) {
BeanDefinition factory = reg.getBeanDefinition(factoryBeanName);
if (factory != null) {
String factoryClassName = factory.getBeanClassName();
Class<?> factoryClass = Class.forName(factoryClassName);
List<Method> methods = new LinkedList<Method>();
methods.addAll(Arrays.asList(factoryClass.getMethods()));
methods.addAll(Arrays.asList(factoryClass.getDeclaredMethods()));
for (Method method : methods) {
method.setAccessible(true);
if (method.getName().equals(bf.getFactoryMethodName())) {
clazz = method.getReturnType();
break;
}
}
}
}
return clazz;
}
@Override
protected void registerAuditListenerBeanDefinition(
BeanDefinition auditingHandlerDefinition, BeanDefinitionRegistry registry) {
if (!registry.containsBeanDefinition(MYBATIS_MAPPING_CONTEXT_BEAN_NAME)) {
registry.registerBeanDefinition(MYBATIS_MAPPING_CONTEXT_BEAN_NAME, //
new RootBeanDefinition(MybatisMappingContextFactoryBean.class));
}
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.rootBeanDefinition(AuditingEntityListener.class);
builder.addPropertyValue("auditingHandler", ParsingUtils
.getObjectFactoryBeanDefinition(getAuditingHandlerBeanName(), null));
builder.addPropertyReference("sqlSessionTemplate",
DEFAULT_SQL_SESSION_TEMPLATE_BEAN_NAME);
registerInfrastructureBeanWithId(builder.getRawBeanDefinition(),
AuditingEntityListener.class.getName(), registry);
}
private String registerNodeServicesBean(Node node,
Web3j web3j,
String web3jServiceBeanName,
BeanDefinitionRegistry registry) {
final BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
NodeServices.class);
builder.addPropertyValue("nodeName", node.getName())
.addPropertyValue("web3j", web3j)
.addPropertyReference("blockchainService", web3jServiceBeanName);
final String beanName = String.format(NODE_SERVICES_BEAN_NAME, node.getName());
registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
return beanName;
}
/**
* {@inheritDoc}
*
* @since 1.0.2
*/
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
if (this.processPropertyPlaceHolders) {
processPropertyPlaceHolders();
}
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
scanner.setAddToConfig(this.addToConfig);
scanner.setAnnotationClass(this.annotationClass);
scanner.setMarkerInterface(this.markerInterface);
scanner.setSqlSessionFactory(this.sqlSessionFactory);
scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
scanner.setResourceLoader(this.applicationContext);
scanner.setBeanNameGenerator(this.nameGenerator);
scanner.registerFilters();
//设置通用 Mapper
scanner.setMapperHelper(this.mapperHelper);
scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
private static Matcher<BeanDefinitionRegistry> containsBeanDefinition(final String beanName) {
return new TypeSafeMatcher<BeanDefinitionRegistry>() {
@Override
public void describeTo(Description desc) {
desc.appendText("a BeanDefinitionRegistry containing bean named ")
.appendValue(beanName);
}
@Override
public boolean matchesSafely(BeanDefinitionRegistry beanFactory) {
return beanFactory.containsBeanDefinition(beanName);
}
};
}
@Override
protected void registerContentStoreBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AnnotationMetadata metadata = new StandardAnnotationMetadata(
EnableJpaContentAutoConfiguration.class);
AnnotationAttributes attributes = new AnnotationAttributes(
metadata.getAnnotationAttributes(this.getAnnotation().getName()));
String[] basePackages = this.getBasePackages();
Set<GenericBeanDefinition> definitions = StoreUtils.getStoreCandidates(this.getEnvironment(), this.getResourceLoader(), basePackages, multipleStoreImplementationsDetected(), getIdentifyingTypes());
this.buildAndRegisterDefinitions(importingClassMetadata, registry, attributes, basePackages, definitions);
}
private BeanDefinitionRegistry beanFactoryFor(String xmlName, String... activeProfiles) {
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
StandardEnvironment env = new StandardEnvironment();
env.setActiveProfiles(activeProfiles);
reader.setEnvironment(env);
reader.loadBeanDefinitions(new ClassPathResource(xmlName, getClass()));
return beanFactory;
}
/**
* 注册组件
*
* @param am 注解元信息
* @param bdr 组件注册器
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata am, BeanDefinitionRegistry bdr) {
Map<String, Object> attributes = am.getAnnotationAttributes(EnableYuRPC.class.getName());
BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(YuRPCAutoConfiguration.class);
if (attributes != null && attributes.containsKey("server")) {
bdb.addPropertyValue("server", (Boolean) attributes.get("server"));
}
if (attributes != null && attributes.containsKey("client")) {
bdb.addPropertyValue("client", (Boolean) attributes.get("client"));
}
bdr.registerBeanDefinition(YuRPCAutoConfiguration.class.getName(), bdb.getBeanDefinition());
}
/**
* {@inheritDoc}
*/
@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
String name = definition.getBeanClassName();
int index = name.lastIndexOf(".");
if (index != -1) {
name = name.substring(index + 1);
}
if (name.endsWith("Impl")) {
name = name.substring(0, name.length() - 4);
}
name = Introspector.decapitalize(name);
return name;
}
private void registerReactiveAuditingEntityCallback(BeanDefinitionRegistry registry, Object source) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.rootBeanDefinition(ReactiveAuditingBeforeBindCallback.class);
builder.addConstructorArgValue(
ParsingUtils.getObjectFactoryBeanDefinition(getAuditingHandlerBeanName(), registry));
builder.getRawBeanDefinition().setSource(source);
registerInfrastructureBeanWithId(builder.getBeanDefinition(),
ReactiveAuditingBeforeBindCallback.class.getName(), registry);
}
/**
* @since 4.0.1
* @see https://jira.spring.io/browse/SPR-11360
*/
@Test
public void generateBeanNameFromComposedControllerAnnotationWithStringValue() {
BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
AnnotatedBeanDefinition bd = new AnnotatedGenericBeanDefinition(
ComposedControllerAnnotationWithStringValue.class);
String beanName = this.beanNameGenerator.generateBeanName(bd, registry);
assertEquals("restController", beanName);
}
@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
if (registry instanceof DefaultListableBeanFactory) {
return (DefaultListableBeanFactory) registry;
}
else if (registry instanceof GenericApplicationContext) {
return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
}
else {
return null;
}
}
private String registerFSM(
ReferenceFactory referenceFactory,
Class<?> statefulControllerClass,
StatefulController scAnnotation,
String persisterId,
Class<?> managedClass,
String finderId,
Class<? extends Annotation> idAnnotationType,
BeanDefinitionRegistry reg) {
int retryAttempts = scAnnotation.retryAttempts();
int retryInterval = scAnnotation.retryInterval();
String fsmBeanId = referenceFactory.getFSMId();
BeanDefinition fsmBean = BeanDefinitionBuilder
.genericBeanDefinition(FSM.class)
.getBeanDefinition();
ConstructorArgumentValues args = fsmBean.getConstructorArgumentValues();
args.addIndexedArgumentValue(0, fsmBeanId);
args.addIndexedArgumentValue(1, new RuntimeBeanReference(persisterId));
args.addIndexedArgumentValue(2, retryAttempts);
args.addIndexedArgumentValue(3, retryInterval);
args.addIndexedArgumentValue(4, managedClass);
args.addIndexedArgumentValue(5, idAnnotationType);
args.addIndexedArgumentValue(6, this.appContext);
if (finderId != null) {
args.addIndexedArgumentValue(7, new RuntimeBeanReference(finderId));
}
reg.registerBeanDefinition(fsmBeanId, fsmBean);
return fsmBeanId;
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 解析@EnableDubboConfigBinding注解属性值
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
importingClassMetadata.getAnnotationAttributes(EnableDubboConfigBinding.class.getName()));
// 注册bean定义=》
registerBeanDefinitions(attributes, registry);
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry){
Class beanClass = RabbitmqOfflineInfoHelper.class;
RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
String beanName = StringUtils.uncapitalize(beanClass.getSimpleName());
//在这里可以拿到所有注解的信息，可以根据不同注解来返回不同的class,从而达到开启不同功能的目的
//通过这种方式可以自定义beanName
registry.registerBeanDefinition(beanName, beanDefinition);
}
private static void registerCredentialsProviderIfNeeded(
BeanDefinitionRegistry registry) {
if (!registry.containsBeanDefinition(CREDENTIALS_PROVIDER_BEAN_NAME)) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.genericBeanDefinition(CredentialsProviderFactoryBean.class);
builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(CREDENTIALS_PROVIDER_BEAN_NAME,
builder.getBeanDefinition());
}
}
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);
}
public static void replaceDefaultCredentialsProvider(BeanDefinitionRegistry registry,
String customGlobalCredentialsProvider) {
if (registry.containsBeanDefinition(CREDENTIALS_PROVIDER_BEAN_NAME)) {
registry.removeBeanDefinition(CREDENTIALS_PROVIDER_BEAN_NAME);
}
registry.registerAlias(customGlobalCredentialsProvider,
CREDENTIALS_PROVIDER_BEAN_NAME);
}
private void registerMessageLogReceiverEndpointProcessorBeanDefinition(final BeanDefinitionRegistry registry,
final String beanName,
final String messageLogBeanName,
final String channelName) {
registry.registerBeanDefinition(
beanName,
genericBeanDefinition(MessageLogConsumerContainer.class)
.addConstructorArgValue(messageLogBeanName)
// TODO: support other channel positions as a starting point for @EnableMessageLogReceiverEndpoint
.addConstructorArgValue(ChannelPosition.fromHorizon())
.setDependencyCheck(DEPENDENCY_CHECK_ALL)
.getBeanDefinition()
);
LOG.info("Registered MessageLogReceiverEndpointProcessor {} with for channelName {}", beanName, channelName);
}
/**
* Parses the given XML element containing the properties and/or sub-elements
* necessary to configure a strategy for setting up declarative caching
* services.
*
* @param element
* the XML element to parse
* @param parserContext
* the parser context
* @throws IllegalStateException
* if the bean definition registry does not have a definition for
* the <code>CacheProviderFacade</code> registered under the name
* specified in the XML attribute "providerId"
* @throws IllegalStateException
* if the cache provider facade is in invalid state
* @throws IllegalStateException
* if any of the caching listeners is not an instance of
* <code>CachingListener</code>
*
* @see BeanDefinitionParser#parse(Element, ParserContext)
*/
public final BeanDefinition parse(Element element, ParserContext parserContext)
throws NoSuchBeanDefinitionException, IllegalStateException {
String cacheProviderFacadeId = element.getAttribute("providerId");
BeanDefinitionRegistry registry = parserContext.getRegistry();
if (!registry.containsBeanDefinition(cacheProviderFacadeId)) {
throw new IllegalStateException(
"An implementation of CacheProviderFacade should be registered under the name "
+ StringUtils.quote(cacheProviderFacadeId));
}
RuntimeBeanReference cacheProviderFacadeReference = new RuntimeBeanReference(
cacheProviderFacadeId);
Object cacheKeyGenerator = parseCacheKeyGenerator(element, parserContext);
List cachingListeners = parseCachingListeners(element, parserContext);
Map cachingModels = parseCachingModels(element);
Map flushingModels = parseFlushingModels(element);
CacheSetupStrategyPropertySource ps = new CacheSetupStrategyPropertySource(
cacheKeyGenerator, cacheProviderFacadeReference, cachingListeners,
cachingModels, flushingModels);
parseCacheSetupStrategy(element, parserContext, ps);
return null;
}
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}
/**
* Registers {@link ReferenceAnnotationBeanPostProcessor} into {@link BeanFactory}
*
* @param registry {@link BeanDefinitionRegistry}
*/
private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) {
// Register @Reference Annotation Bean Processor
BeanRegistrar.registerInfrastructureBean(registry,
ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);
}