@Override public void registerBeanDefinitions(AnnotationMetadata meta, BeanDefinitionRegistry registry) { Map<String, Object> attrs = meta.getAnnotationAttributes(EnableReactor.class.getName()); // Create a root Enivronment if (!registry.containsBeanDefinition(Environment.class.getName())) { BeanDefinitionBuilder envBeanDef = BeanDefinitionBuilder.rootBeanDefinition(Environment.class); String configReaderBean = (String) attrs.get("configurationReader"); if (StringUtils.hasText(configReaderBean)) { envBeanDef.addConstructorArgReference(configReaderBean); } else { String profileName = (String) attrs.get("value"); if (StringUtils.hasText(profileName)) { envBeanDef.addConstructorArgValue(new PropertiesConfigurationReader(profileName)); } } registry.registerBeanDefinition(Environment.class.getName(), envBeanDef.getBeanDefinition()); } // Create a ConsumerBeanPostProcessor if (!registry.containsBeanDefinition(ConsumerBeanPostProcessor.class.getName())) { BeanDefinitionBuilder envBeanDef = BeanDefinitionBuilder.rootBeanDefinition(ConsumerBeanPostProcessor.class); registry.registerBeanDefinition( ConsumerBeanPostProcessor.class.getName(), envBeanDef.getBeanDefinition()); } }
/** * Registers bean definitions for a {@link PluginRegistry} to capture {@link RelProvider} * instances. Wraps the registry into a {@link DelegatingRelProvider} bean definition backed by * the registry. * * @param registry */ private static void registerRelProviderPluginRegistryAndDelegate( BeanDefinitionRegistry registry) { Class<?> defaultRelProviderType = EVO_PRESENT ? EvoInflectorRelProvider.class : DefaultRelProvider.class; RootBeanDefinition defaultRelProviderBeanDefinition = new RootBeanDefinition(defaultRelProviderType); registry.registerBeanDefinition("defaultRelProvider", defaultRelProviderBeanDefinition); RootBeanDefinition annotationRelProviderBeanDefinition = new RootBeanDefinition(AnnotationRelProvider.class); registry.registerBeanDefinition("annotationRelProvider", annotationRelProviderBeanDefinition); BeanDefinitionBuilder registryFactoryBeanBuilder = BeanDefinitionBuilder.rootBeanDefinition(PluginRegistryFactoryBean.class); registryFactoryBeanBuilder.addPropertyValue("type", RelProvider.class); registryFactoryBeanBuilder.addPropertyValue("exclusions", DelegatingRelProvider.class); AbstractBeanDefinition registryBeanDefinition = registryFactoryBeanBuilder.getBeanDefinition(); registry.registerBeanDefinition("relProviderPluginRegistry", registryBeanDefinition); BeanDefinitionBuilder delegateBuilder = BeanDefinitionBuilder.rootBeanDefinition(DelegatingRelProvider.class); delegateBuilder.addConstructorArgValue(registryBeanDefinition); AbstractBeanDefinition beanDefinition = delegateBuilder.getBeanDefinition(); beanDefinition.setPrimary(true); registry.registerBeanDefinition(DELEGATING_REL_PROVIDER_BEAN_NAME, beanDefinition); }
/** * Register a {@link WebSocketHandlerMappingFactoryBean} which could also be overridden by the * user by simply using {@link org.springframework.web.socket.config.annotation.EnableWebSocket} * * <p>In addition, checks if the {@code javax.servlet.Servlet} class is present on the classpath. * When Spring Integration WebSocket support is used only as a WebSocket client, there is no * reason to use and register the Spring WebSocket server components. * * <p>Note, there is no XML equivalent for the {@link * org.springframework.web.socket.config.annotation .EnableWebSocket} in the Spring WebSocket. * therefore this registration can be used to process {@link WebSocketConfigurer} implementations * without annotation configuration. From other side it can be used to replace {@link * org.springframework.web.socket.config.annotation.EnableWebSocket} in the Spring Integration * applications when {@link org.springframework.integration.config.EnableIntegration} is in use. */ private void registerEnableWebSocketIfNecessary(BeanDefinitionRegistry registry) { if (servletPresent) { if (!registry.containsBeanDefinition("defaultSockJsTaskScheduler")) { BeanDefinitionBuilder sockJsTaskSchedulerBuilder = BeanDefinitionBuilder.genericBeanDefinition(ThreadPoolTaskScheduler.class) .addPropertyValue("threadNamePrefix", "SockJS-") .addPropertyValue("poolSize", Runtime.getRuntime().availableProcessors()) .addPropertyValue("removeOnCancelPolicy", true); registry.registerBeanDefinition( "defaultSockJsTaskScheduler", sockJsTaskSchedulerBuilder.getBeanDefinition()); } if (!registry.containsBeanDefinition(DelegatingWebSocketConfiguration.class.getName()) && !registry.containsBeanDefinition(WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME)) { BeanDefinitionBuilder enableWebSocketBuilder = BeanDefinitionBuilder.genericBeanDefinition(WebSocketHandlerMappingFactoryBean.class) .setRole(BeanDefinition.ROLE_INFRASTRUCTURE) .addConstructorArgReference("defaultSockJsTaskScheduler"); registry.registerBeanDefinition( WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME, enableWebSocketBuilder.getBeanDefinition()); } } }
private AbstractBeanDefinition parseSessionFactory( Element element, String dataSourceId, BeanDefinitionRegistry targetRegistry, ParserContext parserContext) { String sessionFactoryId = StringUtils.hasText(element.getAttribute(ID_ATTRIBUTE)) ? element.getAttribute(ID_ATTRIBUTE) : "sessionFactory"; AbstractBeanDefinition sessionFactoryBean = new GenericBeanDefinition(); sessionFactoryBean.setBeanClass(ConfigurableLocalSessionFactoryBean.class); MutablePropertyValues propertyValues = sessionFactoryBean.getPropertyValues(); final RuntimeBeanReference dataSourceRef = new RuntimeBeanReference(dataSourceId); propertyValues.addPropertyValue("dataSource", dataSourceRef); Class<?> configClass = lookupConfigClass(element, parserContext); propertyValues.addPropertyValue("configClass", configClass); final String configLocation = element.getAttribute(CONFIG_LOCATION_ATTRIBUTE); if (StringUtils.hasText(configLocation)) { propertyValues.addPropertyValue("configLocation", configLocation); } propertyValues.addPropertyValue( GrailsApplication.APPLICATION_ID, new RuntimeBeanReference(GrailsApplication.APPLICATION_ID)); targetRegistry.registerBeanDefinition(sessionFactoryId, sessionFactoryBean); final String lobHandlerRef = element.getAttribute(LOB_HANDLER_ATTRIBUTE); if (StringUtils.hasText(lobHandlerRef)) { propertyValues.addPropertyValue("lobHandler", new RuntimeBeanReference(lobHandlerRef)); } else { GenericBeanDefinition lobHandler = new GenericBeanDefinition(); lobHandler.setBeanClass(SpringLobHandlerDetectorFactoryBean.class); lobHandler.getPropertyValues().addPropertyValue("pooledConnection", true); lobHandler.getPropertyValues().addPropertyValue("dataSource", dataSourceRef); propertyValues.addPropertyValue("lobHandler", lobHandler); } String transactionManagerRef = element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE); if (StringUtils.hasText(transactionManagerRef)) { targetRegistry.registerAlias(transactionManagerRef, "transactionManager"); } else { GenericBeanDefinition transactionManagerBean = new GenericBeanDefinition(); transactionManagerBean.setBeanClass(GrailsHibernateTransactionManager.class); transactionManagerBean .getPropertyValues() .addPropertyValue("sessionFactory", new RuntimeBeanReference(sessionFactoryId)); targetRegistry.registerBeanDefinition("transactionManager", transactionManagerBean); } parserContext.getDelegate().parsePropertyElements(element, sessionFactoryBean); return sessionFactoryBean; }
public BeanDefinition parse(Element element, ParserContext parserContext) { final XmlReaderContext readerContext = parserContext.getReaderContext(); final ClassLoader beanClassLoader = readerContext.getBeanClassLoader() != null ? readerContext.getBeanClassLoader() : Thread.currentThread().getContextClassLoader(); String[] basePackages = StringUtils.commaDelimitedListToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE)); String dataSourceId = element.getAttribute(DATA_SOURCE_ATTRIBUTE); if (!StringUtils.hasText(dataSourceId)) { throw new BeanDefinitionParsingException( new Problem( "Attribute [" + DATA_SOURCE_ATTRIBUTE + "] of tag <gorm:sessionFactory> must be specified!", new Location(readerContext.getResource()))); } // Actually scan for bean definitions and register them. BeanDefinitionRegistry targetRegistry = parserContext.getRegistry(); // setup the GrailsApplication instance parseGrailsApplication(element, parserContext, readerContext, beanClassLoader, basePackages); GenericBeanDefinition postProccessingBeanDef = new GenericBeanDefinition(); postProccessingBeanDef.setBeanClass(GORMEnhancingBeanPostProcessor.class); targetRegistry.registerBeanDefinition("gormEnhancingPostProcessor", postProccessingBeanDef); return parseSessionFactory(element, dataSourceId, targetRegistry, parserContext); }
@Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { Collection<Class<?>> remotingServices = new HashSet<Class<?>>(); remotingServices.addAll(getIncludeClasses()); String[] basePackages = getBasePackages(); if (basePackages != null) remotingServices.addAll(ClassScanner.scanAnnotated(basePackages, Remoting.class)); Collection<Class<?>> excludeRemotingServices = getExcludeClasses(); for (Class<?> remotingService : remotingServices) { if (!remotingService.isInterface() || excludeRemotingServices.contains(remotingService)) continue; String beanName = StringUtils.uncapitalize(remotingService.getSimpleName()); if (registry.containsBeanDefinition(beanName)) { logger.info( "Skip bean {} which implemented by {}", beanName, registry.getBeanDefinition(beanName).getBeanClassName()); continue; } RootBeanDefinition beanDefinition = new RootBeanDefinition(HttpInvokerClient.class); beanDefinition.setTargetType(remotingService); beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_NAME); MutablePropertyValues propertyValues = new MutablePropertyValues(); propertyValues.addPropertyValue("serviceInterface", remotingService.getName()); beanDefinition.setPropertyValues(propertyValues); registry.registerBeanDefinition(beanName, beanDefinition); logger.info("Registered bean {} for remoting service", beanName); } }
private void registerBeanDefinitionsWithRegistry(BeanDefinitionRegistry registry) { for (Object key : beanDefinitions.keySet()) { BeanDefinition bd = beanDefinitions.get(key); if (LOG.isDebugEnabled()) { LOG.debug("[RuntimeConfiguration] Registering bean [" + key + "]"); if (LOG.isTraceEnabled()) { PropertyValue[] pvs = bd.getPropertyValues().getPropertyValues(); for (PropertyValue pv : pvs) { LOG.trace( "[RuntimeConfiguration] With property [" + pv.getName() + "] set to [" + pv.getValue() + "]"); } } } final String beanName = key.toString(); if (registry.containsBeanDefinition(beanName)) { removeBeanDefinition(registry, beanName); } registry.registerBeanDefinition(beanName, bd); registerBeanAliases(registry, beanName); } }
private void registerBeanConfigsWithRegistry(BeanDefinitionRegistry registry) { for (BeanConfiguration bc : beanConfigs.values()) { String beanName = bc.getName(); if (LOG.isDebugEnabled()) { LOG.debug("[RuntimeConfiguration] Registering bean [" + beanName + "]"); if (LOG.isTraceEnabled()) { PropertyValue[] pvs = bc.getBeanDefinition().getPropertyValues().getPropertyValues(); for (PropertyValue pv : pvs) { LOG.trace( "[RuntimeConfiguration] With property [" + pv.getName() + "] set to [" + pv.getValue() + "]"); } } } if (registry.containsBeanDefinition(beanName)) { removeBeanDefinition(registry, beanName); } registry.registerBeanDefinition(beanName, bc.getBeanDefinition()); registerBeanAliases(registry, beanName); } }
private void registerUnrefreshedBeansWithRegistry(BeanDefinitionRegistry registry) { if (context != null) { for (String beanName : context.getBeanDefinitionNames()) { registry.registerBeanDefinition(beanName, context.getBeanDefinition(beanName)); } } }
@Override protected void createOperationsBean(BeanDefinitionRegistry registry) { String beanName = "s3ResourceTemplate"; BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(S3ResourceTemplate.class); registry.registerBeanDefinition(beanName, builder.getBeanDefinition()); }
private void process( BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory) { BeanDefinitionHolder holder = getDataSourceBeanDefinition(beanFactory); if (holder != null) { logger.info( "Replacing '" + holder.getBeanName() + "' DataSource bean with embedded version"); registry.registerBeanDefinition(holder.getBeanName(), createEmbeddedBeanDefinition()); } }
/** * Sets the given source on the given {@link AbstractBeanDefinition} and registers it inside the * given {@link BeanDefinitionRegistry}. For {@link BeanDefinition}s to be registerd * once-and-only-once for all configuration elements (annotation or XML), prefer calling {@link * #registerIfNotAlreadyRegistered(AbstractBeanDefinition, BeanDefinitionRegistry, String, * Object)} with a dedicated bean name to avoid the bead definition being registered multiple * times. * * * @param registry must not be {@literal null}. * @param bean must not be {@literal null}. * @param source must not be {@literal null}. * @return the bean name generated for the given {@link BeanDefinition} */ public static String registerWithSourceAndGeneratedBeanName( BeanDefinitionRegistry registry, AbstractBeanDefinition bean, Object source) { bean.setSource(source); String beanName = generateBeanName(bean, registry); registry.registerBeanDefinition(beanName, bean); return beanName; }
private void processRegularClass(BeanDefinitionRegistry registry, Class implementation) { LOG.debug( String.format( "Registering bean definition for implementation class %s", implementation.getCanonicalName())); String beanName = implementation.getCanonicalName(); GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); beanDefinition.setBeanClass(implementation); beanDefinition.setAutowireMode(AUTOWIRE_BY_TYPE); registry.registerBeanDefinition(beanName, beanDefinition); }
/** * Registers the given {@link AbstractBeanDefinition} with the given registry with the given bean * name unless the registry already contains a bean with that name. * * @param bean must not be {@literal null}. * @param registry must not be {@literal null}. * @param beanName must not be {@literal null} or empty. * @param source must not be {@literal null}. */ public static void registerIfNotAlreadyRegistered( AbstractBeanDefinition bean, BeanDefinitionRegistry registry, String beanName, Object source) { if (registry.containsBeanDefinition(beanName)) { return; } bean.setSource(source); registry.registerBeanDefinition(beanName, bean); }
@Override public void registerBeanDefinitions( AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { if (this.beanFactory != null && this.beanFactory .getBeansOfType(EmbeddedServletContainerCustomizerBeanPostProcessor.class) .size() == 0) { BeanDefinition beanDefinition = new RootBeanDefinition(EmbeddedServletContainerCustomizerBeanPostProcessor.class); registry.registerBeanDefinition( "embeddedServletContainerCustomizerBeanPostProcessor", beanDefinition); } }
@Override public synchronized <T> T registerAndGetBean( Class<? extends T> type, final String id, final Scope scope) { if (contains(id)) return getBean(id); final AutowireCapableBeanFactory factory = getContext().getAutowireCapableBeanFactory(); final BeanDefinitionRegistry registry = (BeanDefinitionRegistry) factory; final GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); beanDefinition.setBeanClass(type); if (scope != null) beanDefinition.setScope(scope.getType()); beanDefinition.setAutowireCandidate(true); registry.registerBeanDefinition(id, beanDefinition); factory.autowireBeanProperties(this, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false); return getBean(id); }
private void processRepositoryInterface( BeanDefinitionRegistry registry, Class repositoryInterface) { LOG.debug( String.format( "Registering bean definition for repository interface %s", repositoryInterface.getCanonicalName())); String beanName = Introspector.decapitalize(repositoryInterface.getSimpleName()); GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); beanDefinition.setBeanClass(JpaRepositoryFactoryBean.class); MutablePropertyValues mutablePropertyValues = new MutablePropertyValues(); mutablePropertyValues.add("repositoryInterface", repositoryInterface); beanDefinition.setPropertyValues(mutablePropertyValues); registry.registerBeanDefinition(beanName, beanDefinition); }
/** * 增加自动跟踪的auto tracer bean definition * * @param beanFactory */ public static void addTracerBeanDefinition(final BeanDefinitionRegistry beanFactory) { AbstractBeanDefinition pointcut = new GenericBeanDefinition(); pointcut.setBeanClassName( org.jtester.module.tracer.spring.TracerMethodRegexPointcut.class.getName()); pointcut.setScope("singleton"); pointcut.setAutowireCandidate(false); pointcut.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO); beanFactory.registerBeanDefinition("jtester-internal-methodname-pointcut", pointcut); AbstractBeanDefinition advice = new GenericBeanDefinition(); advice.setBeanClassName(org.jtester.module.tracer.spring.SpringBeanTracer.class.getName()); advice.setScope("singleton"); advice.setAutowireCandidate(false); advice.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO); beanFactory.registerBeanDefinition("jtester-internal-springbeantracer", advice); AbstractBeanDefinition advisor = new GenericBeanDefinition(); advisor.setBeanClassName( org.springframework.aop.support.DefaultPointcutAdvisor.class.getName()); advisor.setScope("singleton"); advisor.setAutowireCandidate(false); advisor.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO); advisor .getPropertyValues() .addPropertyValue( "pointcut", new RuntimeBeanReference("jtester-internal-methodname-pointcut")); advisor .getPropertyValues() .addPropertyValue("advice", new RuntimeBeanReference("jtester-internal-springbeantracer")); beanFactory.registerBeanDefinition("jtester-internal-beantracer-advisor", advisor); }
private void registerDomainBean( final Class<?> entityClass, BeanDefinitionRegistry targetRegistry, String messageSourceRef) { GenericBeanDefinition beanDef = new GenericBeanDefinition(); beanDef.setBeanClass(entityClass); beanDef.setScope("prototype"); RootBeanDefinition domainDef = new RootBeanDefinition(MethodInvokingFactoryBean.class); domainDef .getPropertyValues() .addPropertyValue( "targetObject", new RuntimeBeanReference(GrailsApplication.APPLICATION_ID)); domainDef.getPropertyValues().addPropertyValue("targetMethod", "getArtefact"); domainDef .getPropertyValues() .addPropertyValue( "arguments", Arrays.asList(DomainClassArtefactHandler.TYPE, entityClass.getName())); final String domainRef = entityClass.getName() + "Domain"; if (StringUtils.hasText(messageSourceRef)) { GenericBeanDefinition validatorDef = new GenericBeanDefinition(); validatorDef.setBeanClass(HibernateDomainClassValidator.class); validatorDef .getPropertyValues() .addPropertyValue("messageSource", new RuntimeBeanReference(messageSourceRef)); validatorDef .getPropertyValues() .addPropertyValue("domainClass", new RuntimeBeanReference(domainRef)); validatorDef .getPropertyValues() .addPropertyValue("sessionFactory", new RuntimeBeanReference("sessionFactory")); targetRegistry.registerBeanDefinition(entityClass.getName() + "Validator", validatorDef); } targetRegistry.registerBeanDefinition(entityClass.getName(), beanDef); targetRegistry.registerBeanDefinition(domainRef, domainDef); }
/** * Register the specified entity scan packages with the system. * * @param registry the source registry * @param packageNames the package names to register */ public static void register(BeanDefinitionRegistry registry, Collection<String> packageNames) { Assert.notNull(registry, "Registry must not be null"); Assert.notNull(packageNames, "PackageNames must not be null"); if (registry.containsBeanDefinition(BEAN)) { BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN); ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues(); constructorArguments.addIndexedArgumentValue( 0, addPackageNames(constructorArguments, packageNames)); } else { GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); beanDefinition.setBeanClass(EntityScanPackages.class); beanDefinition .getConstructorArgumentValues() .addIndexedArgumentValue(0, packageNames.toArray(new String[packageNames.size()])); beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); registry.registerBeanDefinition(BEAN, beanDefinition); } }
private void parseGrailsApplication( Element element, ParserContext parserContext, XmlReaderContext readerContext, ClassLoader beanClassLoader, String[] basePackages) { BeanDefinitionRegistry simpleRegistry = new SimpleBeanDefinitionRegistry(); ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, simpleRegistry); scanner.scan(basePackages); BeanDefinitionRegistry targetRegistry = parserContext.getRegistry(); AbstractBeanDefinition grailsApplicationBean = new GenericBeanDefinition(); grailsApplicationBean.setBeanClass(DefaultGrailsApplication.class); grailsApplicationBean.setInitMethodName("initialise"); ConstructorArgumentValues constructorArgs = grailsApplicationBean.getConstructorArgumentValues(); Set<Class<?>> classes = new HashSet<Class<?>>(); for (String beanName : simpleRegistry.getBeanDefinitionNames()) { BeanDefinition beanDef = simpleRegistry.getBeanDefinition(beanName); try { Class<?> entityClass = Class.forName(beanDef.getBeanClassName(), true, beanClassLoader); classes.add(entityClass); registerDomainBean( entityClass, targetRegistry, element.getAttribute(MESSAGE_SOURCE_ATTRIBUTE)); } catch (ClassNotFoundException e) { throw new BeanDefinitionParsingException( new Problem( "Unable to load class whilst configuring GORM: " + e.getMessage(), new Location(readerContext.getResource()), null, e)); } } constructorArgs.addGenericArgumentValue(classes.toArray(new Class[classes.size()])); constructorArgs.addGenericArgumentValue(beanClassLoader); targetRegistry.registerBeanDefinition(GrailsApplication.APPLICATION_ID, grailsApplicationBean); }
@Override public Object buildBean(String beanName, Map<String, Object> extraContext) throws Exception { LOG.debug("Building bean for name {}", beanName); if (!skipBeanNames.contains(beanName)) { ApplicationContext anAppContext = getApplicationContext(extraContext); try { LOG.debug( "Trying the application context... appContext = {},\n bean name = {}", anAppContext, beanName); return anAppContext.getBean(beanName); } catch (NoSuchBeanDefinitionException e) { LOG.debug( "Did not find bean definition for bean named {}, creating a new one...", beanName); if (autoWiringFactory instanceof BeanDefinitionRegistry) { try { Class clazz = Class.forName(beanName); BeanDefinitionRegistry registry = (BeanDefinitionRegistry) autoWiringFactory; RootBeanDefinition def = new RootBeanDefinition(clazz, autowireStrategy, true); def.setScope(BeanDefinition.SCOPE_SINGLETON); LOG.debug("Registering a new bean definition for class {}", beanName); registry.registerBeanDefinition(beanName, def); try { return anAppContext.getBean(beanName); } catch (NoSuchBeanDefinitionException e2) { LOG.warn("Could not register new bean definition for bean {}", beanName); skipBeanNames.add(beanName); } } catch (ClassNotFoundException e1) { skipBeanNames.add(beanName); } } } } LOG.debug("Returning autowired instance created by default ObjectFactory"); return autoWireBean(super.buildBean(beanName, extraContext), autoWiringFactory); }
/** * Read a particular {@link ConfigurationClassMethod}, registering bean definitions with the * BeanDefinitionRegistry based on its contents. */ private void loadBeanDefinitionsForBeanMethod(ConfigurationClassMethod beanMethod) { ConfigurationClass configClass = beanMethod.getConfigurationClass(); MethodMetadata metadata = beanMethod.getMetadata(); RootBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass); beanDef.setResource(configClass.getResource()); beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource())); beanDef.setFactoryBeanName(configClass.getBeanName()); beanDef.setUniqueFactoryMethodName(metadata.getMethodName()); beanDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR); beanDef.setAttribute( RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE); // consider name and any aliases Map<String, Object> beanAttributes = metadata.getAnnotationAttributes(Bean.class.getName()); List<String> names = new ArrayList<String>(Arrays.asList((String[]) beanAttributes.get("name"))); String beanName = (names.size() > 0 ? names.remove(0) : beanMethod.getMetadata().getMethodName()); for (String alias : names) { this.registry.registerAlias(beanName, alias); } // has this already been overridden (e.g. via XML)? if (this.registry.containsBeanDefinition(beanName)) { BeanDefinition existingBeanDef = registry.getBeanDefinition(beanName); // is the existing bean definition one that was created from a configuration class? if (!(existingBeanDef instanceof ConfigurationClassBeanDefinition)) { // no -> then it's an external override, probably XML // overriding is legal, return immediately if (logger.isDebugEnabled()) { logger.debug( String.format( "Skipping loading bean definition for %s: a definition for bean " + "'%s' already exists. This is likely due to an override in XML.", beanMethod, beanName)); } return; } } if (metadata.isAnnotated(Primary.class.getName())) { beanDef.setPrimary(true); } // is this bean to be instantiated lazily? if (metadata.isAnnotated(Lazy.class.getName())) { beanDef.setLazyInit( (Boolean) metadata.getAnnotationAttributes(Lazy.class.getName()).get("value")); } else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())) { beanDef.setLazyInit( (Boolean) configClass.getMetadata().getAnnotationAttributes(Lazy.class.getName()).get("value")); } if (metadata.isAnnotated(DependsOn.class.getName())) { String[] dependsOn = (String[]) metadata.getAnnotationAttributes(DependsOn.class.getName()).get("value"); if (dependsOn.length > 0) { beanDef.setDependsOn(dependsOn); } } Autowire autowire = (Autowire) beanAttributes.get("autowire"); if (autowire.isAutowire()) { beanDef.setAutowireMode(autowire.value()); } String initMethodName = (String) beanAttributes.get("initMethod"); if (StringUtils.hasText(initMethodName)) { beanDef.setInitMethodName(initMethodName); } String destroyMethodName = (String) beanAttributes.get("destroyMethod"); if (StringUtils.hasText(destroyMethodName)) { beanDef.setDestroyMethodName(destroyMethodName); } // consider scoping ScopedProxyMode proxyMode = ScopedProxyMode.NO; Map<String, Object> scopeAttributes = metadata.getAnnotationAttributes(Scope.class.getName()); if (scopeAttributes != null) { beanDef.setScope((String) scopeAttributes.get("value")); proxyMode = (ScopedProxyMode) scopeAttributes.get("proxyMode"); if (proxyMode == ScopedProxyMode.DEFAULT) { proxyMode = ScopedProxyMode.NO; } } // replace the original bean definition with the target one, if necessary BeanDefinition beanDefToRegister = beanDef; if (proxyMode != ScopedProxyMode.NO) { BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy( new BeanDefinitionHolder(beanDef, beanName), this.registry, proxyMode == ScopedProxyMode.TARGET_CLASS); beanDefToRegister = proxyDef.getBeanDefinition(); } if (logger.isDebugEnabled()) { logger.debug( String.format( "Registering bean definition for @Bean method %s.%s()", configClass.getMetadata().getClassName(), beanName)); } registry.registerBeanDefinition(beanName, beanDefToRegister); }