@Override @Nullable public BeanDefinition parse(Element element, ParserContext parserContext) { Object source = parserContext.extractSource(element); CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source); parserContext.pushContainingComponent(compDefinition); BeanDefinitionRegistry registry = parserContext.getRegistry(); if (registry.containsBeanDefinition(JmsListenerConfigUtils.JMS_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)) { parserContext.getReaderContext().error( "Only one JmsListenerAnnotationBeanPostProcessor may exist within the context.", source); BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition( "org.springframework.jms.annotation.JmsListenerAnnotationBeanPostProcessor"); builder.getRawBeanDefinition().setSource(source); String endpointRegistry = element.getAttribute("registry"); if (StringUtils.hasText(endpointRegistry)) { builder.addPropertyReference("endpointRegistry", endpointRegistry); String containerFactory = element.getAttribute("container-factory"); if (StringUtils.hasText(containerFactory)) { builder.addPropertyValue("containerFactoryBeanName", containerFactory); String handlerMethodFactory = element.getAttribute("handler-method-factory"); if (StringUtils.hasText(handlerMethodFactory)) { builder.addPropertyReference("messageHandlerMethodFactory", handlerMethodFactory);
public void parseBatchlet(Element batchletElement, AbstractBeanDefinition bd, ParserContext parserContext, String stepName) { bd.setBeanClass(StepFactoryBean.class); bd.setAttribute("isNamespaceStep", false); String taskletRef = batchletElement.getAttribute(REF); if (StringUtils.hasText(taskletRef)) { bd.getPropertyValues().addPropertyValue("stepTasklet", new RuntimeBeanReference(taskletRef)); } bd.setRole(BeanDefinition.ROLE_SUPPORT); bd.setSource(parserContext.extractSource(batchletElement)); new PropertyParser(taskletRef, parserContext, BatchArtifactType.STEP_ARTIFACT, stepName).parseProperties(batchletElement); } }
setParentName(original.getParentName()); setBeanClassName(original.getBeanClassName()); setScope(original.getScope()); setAbstract(original.isAbstract()); setLazyInit(original.isLazyInit()); setFactoryBeanName(original.getFactoryBeanName()); setFactoryMethodName(original.getFactoryMethodName()); setRole(original.getRole()); setSource(original.getSource()); copyAttributesFrom(original); if (originalAbd.hasBeanClass()) { setBeanClass(originalAbd.getBeanClass()); if (originalAbd.hasConstructorArgumentValues()) { setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues())); if (originalAbd.hasPropertyValues()) { setPropertyValues(new MutablePropertyValues(original.getPropertyValues())); if (originalAbd.hasMethodOverrides()) { setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides())); setAutowireMode(originalAbd.getAutowireMode()); setDependencyCheck(originalAbd.getDependencyCheck()); setDependsOn(originalAbd.getDependsOn()); setAutowireCandidate(originalAbd.isAutowireCandidate()); setPrimary(originalAbd.isPrimary()); copyQualifiersFrom(originalAbd);
/** * Set the name of a non-static factory method to use for this definition, * including the bean name of the factory instance to call the method on. * @since 4.3.6 */ public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean) { this.beanDefinition.setFactoryMethodName(factoryMethod); this.beanDefinition.setFactoryBeanName(factoryBean); return this; }
/** * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}. * @param beanClass the {@code Class} of the bean that the definition is being created for * @param factoryMethodName the name of the method to use to construct the bean instance */ public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass, @Nullable String factoryMethodName) { BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition()); builder.beanDefinition.setBeanClass(beanClass); builder.beanDefinition.setFactoryMethodName(factoryMethodName); return builder; }
/** * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}. * @param beanClassName the class name for the bean that the definition is being created for * @param factoryMethodName the name of the method to use to construct the bean instance */ public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName, @Nullable String factoryMethodName) { BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition()); builder.beanDefinition.setBeanClassName(beanClassName); builder.beanDefinition.setFactoryMethodName(factoryMethodName); return builder; }
@Override protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(AnnotationMBeanExporter.class); builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); builder.getRawBeanDefinition().setSource(parserContext.extractSource(element)); String defaultDomain = element.getAttribute(DEFAULT_DOMAIN_ATTRIBUTE); if (StringUtils.hasText(defaultDomain)) { builder.addPropertyValue("defaultDomain", defaultDomain); String serverBeanName = element.getAttribute(SERVER_ATTRIBUTE); if (StringUtils.hasText(serverBeanName)) { builder.addPropertyReference("server", serverBeanName); String registration = element.getAttribute(REGISTRATION_ATTRIBUTE); RegistrationPolicy registrationPolicy = RegistrationPolicy.FAIL_ON_EXISTING; if (REGISTRATION_IGNORE_EXISTING.equals(registration)) {
/** * Parse a '{@code declare-parents}' element and register the appropriate * DeclareParentsAdvisor with the BeanDefinitionRegistry encapsulated in the * supplied ParserContext. */ private AbstractBeanDefinition parseDeclareParents(Element declareParentsElement, ParserContext parserContext) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(DeclareParentsAdvisor.class); builder.addConstructorArgValue(declareParentsElement.getAttribute(IMPLEMENT_INTERFACE)); builder.addConstructorArgValue(declareParentsElement.getAttribute(TYPE_PATTERN)); String defaultImpl = declareParentsElement.getAttribute(DEFAULT_IMPL); String delegateRef = declareParentsElement.getAttribute(DELEGATE_REF); if (StringUtils.hasText(defaultImpl) && !StringUtils.hasText(delegateRef)) { builder.addConstructorArgValue(defaultImpl); } else if (StringUtils.hasText(delegateRef) && !StringUtils.hasText(defaultImpl)) { builder.addConstructorArgReference(delegateRef); } else { parserContext.getReaderContext().error( "Exactly one of the " + DEFAULT_IMPL + " or " + DELEGATE_REF + " attributes must be specified", declareParentsElement, this.parseState.snapshot()); } AbstractBeanDefinition definition = builder.getBeanDefinition(); definition.setSource(parserContext.extractSource(declareParentsElement)); parserContext.getReaderContext().registerWithGeneratedName(definition); return definition; }
static RootBeanDefinition parseSearchBean(Element elt, ParserContext parserContext) { String userSearchFilter = elt.getAttribute(ATT_USER_SEARCH_FILTER); String userSearchBase = elt.getAttribute(ATT_USER_SEARCH_BASE); Object source = parserContext.extractSource(elt); if (StringUtils.hasText(userSearchBase)) { if (!StringUtils.hasText(userSearchFilter)) { parserContext.getReaderContext().error( ATT_USER_SEARCH_BASE + " cannot be used without a " + ATT_USER_SEARCH_FILTER, source); } } else { userSearchBase = DEF_USER_SEARCH_BASE; } if (!StringUtils.hasText(userSearchFilter)) { return null; } BeanDefinitionBuilder searchBuilder = BeanDefinitionBuilder .rootBeanDefinition(LDAP_SEARCH_CLASS); searchBuilder.getRawBeanDefinition().setSource(source); searchBuilder.addConstructorArgValue(userSearchBase); searchBuilder.addConstructorArgValue(userSearchFilter); searchBuilder.addConstructorArgValue(parseServerReference(elt, parserContext)); return (RootBeanDefinition) searchBuilder.getBeanDefinition(); }
@Override protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) { bd.setDependsOn(element.getAttribute( RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE)); List<Element> childElements = DomUtils.getChildElements(element); for (Element elt : childElements) { String localName = elt.getLocalName(); if (BeanDefinitionParserDelegate .QUALIFIER_ELEMENT.equals(localName)) { id = elt.getAttribute( BeanDefinitionParserDelegate.BEAN_REF_ATTRIBUTE); } else { parserContext.getDelegate().parseCustomElement(elt, bd); id = elt.getAttribute( RedissonNamespaceParserSupport.ID_ATTRIBUTE); = builder.getRawBeanDefinition() .getConstructorArgumentValues(); if (args.getArgumentCount() > 0) { ConstructorArgumentValues.ValueHolder value builder.addConstructorArgReference(id);
@Override protected BeanDefinitionBuilder getBuilder(Element element, ParserContext parserContext) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(WebFluxRequestExecutingMessageHandler.class); String webClientRef = element.getAttribute("web-client"); if (StringUtils.hasText(webClientRef)) { builder.getBeanDefinition() .getConstructorArgumentValues() .addIndexedArgumentValue(1, new RuntimeBeanReference(webClientRef)); } return builder; }
protected void doParse(Element elt, ParserContext parserContext, BeanDefinitionBuilder builder) { if (!StringUtils.hasText(elt.getAttribute(ATT_USER_SEARCH_FILTER))) { parserContext.getReaderContext().error("User search filter must be supplied", elt); } builder.addConstructorArgValue(parseSearchBean(elt, parserContext)); builder.getRawBeanDefinition().setSource(parserContext.extractSource(elt)); builder.addConstructorArgValue(parseAuthoritiesPopulator(elt, parserContext)); builder.addPropertyValue("userDetailsMapper", parseUserDetailsClassOrUserMapperRef(elt, parserContext)); }
public Collection<BeanDefinition> parse(Element element, ParserContext parserContext, String jobFactoryRef) { BeanDefinitionBuilder factoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(); AbstractBeanDefinition factoryDefinition = factoryBuilder.getRawBeanDefinition(); factoryDefinition.setBeanClass(DecisionStepFactoryBean.class); BeanDefinitionBuilder stateBuilder = BeanDefinitionBuilder.genericBeanDefinition(JsrStepState.class); String idAttribute = element.getAttribute(ID_ATTRIBUTE); parserContext.registerBeanComponent(new BeanComponentDefinition(factoryDefinition, idAttribute)); stateBuilder.addConstructorArgReference(idAttribute); String refAttribute = element.getAttribute(REF_ATTRIBUTE); factoryDefinition.getPropertyValues().add("decider", new RuntimeBeanReference(refAttribute)); factoryDefinition.getPropertyValues().add("name", idAttribute); if(StringUtils.hasText(jobFactoryRef)) { factoryDefinition.setAttribute("jobParserJobFactoryBeanRef", jobFactoryRef); } new PropertyParser(refAttribute, parserContext, BatchArtifactType.STEP_ARTIFACT, idAttribute).parseProperties(element); return FlowParser.getNextElements(parserContext, stateBuilder.getBeanDefinition(), element); } }
@Override protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(DataSourceInitializer.class); builder.addPropertyReference("dataSource", element.getAttribute("data-source")); builder.addPropertyValue("enabled", element.getAttribute("enabled")); DatabasePopulatorConfigUtils.setDatabasePopulator(element, builder); builder.getRawBeanDefinition().setSource(parserContext.extractSource(element)); return builder.getBeanDefinition(); }
if (element.hasAttribute(POINTCUT) && element.hasAttribute(POINTCUT_REF)) { parserContext.getReaderContext().error( "Cannot define both 'pointcut' and 'pointcut-ref' on <advisor> tag.", element, this.parseState.snapshot()); return null; else if (element.hasAttribute(POINTCUT)) { String expression = element.getAttribute(POINTCUT); AbstractBeanDefinition pointcutDefinition = createPointcutDefinition(expression); pointcutDefinition.setSource(parserContext.extractSource(element)); return pointcutDefinition; else if (element.hasAttribute(POINTCUT_REF)) { String pointcutRef = element.getAttribute(POINTCUT_REF); if (!StringUtils.hasText(pointcutRef)) { parserContext.getReaderContext().error( "'pointcut-ref' attribute contains empty value.", element, this.parseState.snapshot()); return null; parserContext.getReaderContext().error( "Must define one of 'pointcut' or 'pointcut-ref' on <advisor> tag.", element, this.parseState.snapshot());
/** * Parses the supplied {@code <pointcut>} and registers the resulting * Pointcut with the BeanDefinitionRegistry. */ private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) { String id = pointcutElement.getAttribute(ID); String expression = pointcutElement.getAttribute(EXPRESSION); AbstractBeanDefinition pointcutDefinition = null; try { this.parseState.push(new PointcutEntry(id)); pointcutDefinition = createPointcutDefinition(expression); pointcutDefinition.setSource(parserContext.extractSource(pointcutElement)); String pointcutBeanName = id; if (StringUtils.hasText(pointcutBeanName)) { parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition); } else { pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition); } parserContext.registerComponent( new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression)); } finally { this.parseState.pop(); } return pointcutDefinition; }
String id = advisorElement.getAttribute(ID); if (StringUtils.hasText(advisorBeanName)) { parserContext.getRegistry().registerBeanDefinition(advisorBeanName, advisorDef); advisorBeanName = parserContext.getReaderContext().registerWithGeneratedName(advisorDef); advisorDef.getPropertyValues().add(POINTCUT, pointcut); parserContext.registerComponent( new AdvisorComponentDefinition(advisorBeanName, advisorDef, (BeanDefinition) pointcut)); advisorDef.getPropertyValues().add(POINTCUT, new RuntimeBeanReference((String) pointcut)); parserContext.registerComponent( new AdvisorComponentDefinition(advisorBeanName, advisorDef));
private void parseJob(Element stepElement, Element jobElement, AbstractBeanDefinition bd, ParserContext parserContext, boolean stepUnderspecified) { bd.setBeanClass(StepParserStepFactoryBean.class); bd.setAttribute("isNamespaceStep", true); String jobRef = jobElement.getAttribute(REF_ATTR); if (!StringUtils.hasText(jobRef)) { parserContext.getReaderContext().error("You must specify a job", jobElement); return; } MutablePropertyValues propertyValues = bd.getPropertyValues(); propertyValues.addPropertyValue("job", new RuntimeBeanReference(jobRef)); String jobParametersExtractor = jobElement.getAttribute(JOB_PARAMS_EXTRACTOR_ATTR); String jobLauncher = jobElement.getAttribute(JOB_LAUNCHER_ATTR); if (StringUtils.hasText(jobParametersExtractor)) { propertyValues.addPropertyValue("jobParametersExtractor", new RuntimeBeanReference(jobParametersExtractor)); } if (StringUtils.hasText(jobLauncher)) { propertyValues.addPropertyValue("jobLauncher", new RuntimeBeanReference(jobLauncher)); } }
String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isTraceEnabled()) { if (containingBean != null) { beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); beanName = this.readerContext.generateBeanName(beanDefinition); String beanClassName = beanDefinition.getBeanClassName(); if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { aliases.add(beanClassName);
/** * @param element the top level element containing a flow definition * @param parserContext the {@link ParserContext} */ @Override protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { CoreNamespaceUtils.autoregisterBeansForNamespace(parserContext, element); String flowName = element.getAttribute(ID_ATTR); builder.getRawBeanDefinition().setAttribute("flowName", flowName); builder.addPropertyValue("name", flowName); builder.addPropertyValue("stateTransitionComparator", new RuntimeBeanReference(DefaultStateTransitionComparator.STATE_TRANSITION_COMPARATOR)); String abstractAttr = element.getAttribute(ABSTRACT_ATTR); if (StringUtils.hasText(abstractAttr)) { builder.setAbstract(abstractAttr.equals("true")); } super.doParse(element, parserContext, builder); }