Example usage for org.springframework.beans.factory.support BeanDefinitionReaderUtils registerBeanDefinition

List of usage examples for org.springframework.beans.factory.support BeanDefinitionReaderUtils registerBeanDefinition

  1. HOME
  2. Java
  3. org.springframework.beans
  4. org.springframework.beans.factory.support.*
  5. BeanDefinitionReaderUtils
  6. registerBeanDefinition

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support BeanDefinitionReaderUtils registerBeanDefinition.

Prototype

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder,
        BeanDefinitionRegistry registry) throws BeanDefinitionStoreException

Source Link

Document

Register the given bean definition with the given bean factory.

Usage

From source file:com.trigonic.utils.spring.cmdline.CommandLineBeanDefinitionReader.java

public <T> void parse(Class<T> beanClass, String[] args) {
    OptionParser parser = new OptionParser();
    parser.acceptsAll(Arrays.asList("h", "help"), "Usage information");

    CommandLineMetaData metaData = new CommandLineMetaData(beanClass);
    metaData.register(parser);//from www.j a v  a 2s.co  m

    OptionSet optionSet;
    try {
        optionSet = parser.parse(args);
        if (optionSet.has("help")) {
            throw new UsageException(parser, metaData, null); // triggers usage
        }

        CommandLineBeanDefinition beanDef = new CommandLineBeanDefinition(beanClass, metaData, optionSet);
        String beanName = beanNameGenerator.generateBeanName(beanDef, this.registry);

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDef, beanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    } catch (OptionException e) {
        throw new UsageException(parser, metaData, e);
    } catch (OperandException e) {
        throw new UsageException(parser, metaData, e);
    }
}

From source file:org.activiti.spring.components.config.xml.StateHandlerAnnotationBeanFactoryPostProcessor.java

private void configureDefaultActivitiRegistry(String registryBeanName, BeanDefinitionRegistry registry) {

    if (!beanAlreadyConfigured(registry, registryBeanName, ActivitiStateHandlerRegistry.class)) {
        String registryName = ActivitiStateHandlerRegistry.class.getName();
        log.info("registering a " + registryName + " instance under bean name "
                + ActivitiContextUtils.ACTIVITI_REGISTRY_BEAN_NAME + ".");

        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName(registryName);
        rootBeanDefinition.getPropertyValues().addPropertyValue("processEngine", this.processEngine);

        BeanDefinitionHolder holder = new BeanDefinitionHolder(rootBeanDefinition, registryBeanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }//from   w ww.j  av  a 2 s.  c  o m
}

From source file:org.ff4j.spring.namespace.FF4JPlaceHolderBeanDefinitionParser.java

/** {@inheritDoc} */
public final BeanDefinition parse(Element element, ParserContext parserContext) {
    logger.debug("Initialization from <ff4j:" + TAG_PLACEHOLDER + "> TAG");
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.getRawBeanDefinition().setBeanClass(FF4jPropertiesPlaceHolderConfigurer.class);
    builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));

    // Reference to FF4J bean
    RuntimeBeanReference refFF4j = new RuntimeBeanReference("ff4j");
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("id", BEANID_PLACEHOLDER_CONF);
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("ff4j", refFF4j);
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("order", 2);

    AbstractBeanDefinition def = builder.getBeanDefinition();
    if (def != null && !parserContext.isNested()) {
        BeanDefinitionHolder holder = new BeanDefinitionHolder(def, BEANID_PLACEHOLDER, new String[0]);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    }/*from  ww  w. j a  va  2s.c  o  m*/
    return def;
}

From source file:net.hasor.rsf.spring.parser.RsfDefinitionParser.java

/** ?Xml  */
@Override//w  w w.  ja v a 2  s. co m
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // Spring 
    String version = SpringVersion.getVersion();
    version = StringUtils.isBlank(version) ? "?" : version;
    Map customEditors = null;
    if (version.charAt(0) == '4' || version.charAt(0) == '5') {
        customEditors = new HashMap<Class<?>, Class<? extends java.beans.PropertyEditor>>();
        customEditors.put(InterAddress.class, RsfAddressPropertyEditor.class);
    } else {
        customEditors = new HashMap();
        customEditors.put("net.hasor.rsf.InterAddress", new RsfAddressPropertyEditor());
    }
    //
    // . Bean 
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.getRawBeanDefinition().setBeanClass(CustomEditorConfigurer.class);
    builder.setScope(BeanDefinition.SCOPE_SINGLETON);//?
    builder.addPropertyValue("customEditors", customEditors);
    //
    //  .,BeanID net.hasor.rsf.spring.RsfAddressPropertyEditor
    AbstractBeanDefinition propEditors = builder.getBeanDefinition();
    String beanID = RsfAddressPropertyEditor.class.getName();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(propEditors, beanID);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    parserContext.registerComponent(new BeanComponentDefinition(holder));
    //
    //
    NamedNodeMap attributes = element.getAttributes();
    //
    return null;
}

From source file:io.fabric8.spring.boot.AbstractServiceRegistar.java

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry) {

    for (Method method : REFLECTIONS.getMethodsAnnotatedWith(Factory.class)) {
        String methodName = method.getName();
        Class sourceType = getSourceType(method);
        Class targetType = method.getReturnType();
        Class beanType = method.getDeclaringClass();
        BeanDefinitionHolder holder = createConverterBean(beanType, methodName, sourceType, targetType);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }//from   w  w w .j  a  va  2 s  .c  o  m

    for (Field field : REFLECTIONS.getFieldsAnnotatedWith(ServiceName.class)) {
        Class targetClass = field.getType();
        Alias alias = field.getAnnotation(Alias.class);
        ServiceName name = field.getAnnotation(ServiceName.class);
        PortName port = field.getAnnotation(PortName.class);
        Protocol protocol = field.getAnnotation(Protocol.class);
        External external = field.getAnnotation(External.class);

        String serviceName = name != null ? name.value() : null;

        //We copy the service since we are going to add properties to it.
        Service serviceInstance = new ServiceBuilder(getService(serviceName)).build();
        String servicePort = port != null ? port.value() : null;
        String serviceProtocol = protocol != null ? protocol.value() : DEFAULT_PROTOCOL;
        Boolean serviceExternal = external != null && external.value();
        String serviceAlias = alias != null ? alias.value()
                : createAlias(serviceName, targetClass, serviceProtocol, servicePort, serviceExternal);

        //Add annotation info as additional properties
        serviceInstance.getAdditionalProperties().put(ALIAS, serviceAlias);
        serviceInstance.getAdditionalProperties().put(PROTOCOL, serviceProtocol);
        serviceInstance.getAdditionalProperties().put(EXTERNAL, serviceExternal);

        //We don't want to add a fallback value to the attributes.
        if (port != null) {
            serviceInstance.getAdditionalProperties().put(PORT, servicePort);
        }

        BeanDefinitionHolder holder = createServiceDefinition(serviceInstance, serviceAlias, serviceProtocol,
                servicePort, targetClass);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
}

From source file:org.activiti.spring.components.config.xml.ActivitiAnnotationDrivenBeanDefinitionParser.java

@Deprecated
private void registerStateHandlerAnnotationBeanFactoryPostProcessor(Element element, ParserContext context) {
    Class clz = StateHandlerAnnotationBeanFactoryPostProcessor.class;
    BeanDefinitionBuilder postProcessorBuilder = BeanDefinitionBuilder.genericBeanDefinition(clz.getName());

    BeanDefinitionHolder postProcessorHolder = new BeanDefinitionHolder(
            postProcessorBuilder.getBeanDefinition(),
            ActivitiContextUtils.ANNOTATION_STATE_HANDLER_BEAN_FACTORY_POST_PROCESSOR_BEAN_NAME);
    configureProcessEngine(postProcessorBuilder.getBeanDefinition(), element);
    BeanDefinitionReaderUtils.registerBeanDefinition(postProcessorHolder, context.getRegistry());

}

From source file:br.com.caelum.vraptor.ioc.spring.SpringRegistry.java

private void registerOn(Class<?> type, boolean customComponent) {
    AnnotatedGenericBeanDefinition definition = new AnnotatedGenericBeanDefinition(type);
    if (!customComponent) {
        definition.setLazyInit(true);//w ww .  j av a  2 s.  c  om
    }
    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);
    definition.setPrimary(customComponent);
    definition.setRole(customComponent ? BeanDefinition.ROLE_APPLICATION : BeanDefinition.ROLE_INFRASTRUCTURE);

    String name = beanNameGenerator.generateBeanName(definition, (BeanDefinitionRegistry) beanFactory);
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(definition, name);

    ScopeMetadata scopeMetadata = scopeResolver.resolveScopeMetadata(definition);
    definitionHolder = applyScopeOn(definitionHolder, scopeMetadata);

    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, (BeanDefinitionRegistry) beanFactory);
}

From source file:org.zalando.stups.spring.cloud.netflix.feign.OAuth2FeignClientsRegsitrar.java

@Override
public void registerBeanDefinitions(final AnnotationMetadata importingClassMetadata,
        final BeanDefinitionRegistry registry) {

    Set<String> basePackages = getBasePackages(importingClassMetadata);

    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
    scanner.setResourceLoader(this.resourceLoader);

    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {

                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");

                BeanDefinitionHolder holder = createBeanDefinition(annotationMetadata);
                BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
            }/*from  w  w  w . ja v a2 s.co  m*/
        }
    }
}

From source file:org.jboss.seam.spring.namespace.CdiBeanImportBeanDefinitionParser.java

@Override
public AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder cdiBeanFactoryBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(FACTORY_BEAN_CLASS_NAME);
    String beanManagerReference = element.getAttribute(BEAN_MANAGER_REFERENCE);
    if (StringUtils.hasText(beanManagerReference)) {
        cdiBeanFactoryBuilder.addPropertyReference("beanManager", beanManagerReference);
    } else {// w  w w.j  a  va  2 s.  co  m
        cdiBeanFactoryBuilder.addPropertyReference("beanManager", DEFAULT_BEAN_MANAGER_ID);
    }

    String name = element.getAttribute(NAME_ATTRIBUTE);

    String type = element.getAttribute("type");

    if (!StringUtils.hasText(name) && !StringUtils.hasText(type)) {
        parserContext.getReaderContext()
                .error("A CDI bean reference must specify at least a name or the bean type", element);
    }

    ArrayList<Qualifier> qualifiers = new ArrayList<Qualifier>();

    NodeList children = element.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node childNode = children.item(i);
        if (childNode.getNodeType() == Node.ELEMENT_NODE && "qualifier".equals(childNode.getLocalName())) {
            Element qualifierElement = (Element) childNode;
            Qualifier qualifier = new Qualifier();
            Map<String, Object> attributes = new HashMap<String, Object>();
            qualifier.setClassName(qualifierElement.getAttribute("type"));

            if (qualifierElement.hasChildNodes()) {
                NodeList attributeNodes = qualifierElement.getChildNodes();
                for (int j = 0; j < attributeNodes.getLength(); j++) {
                    Node attributeNode = attributeNodes.item(j);
                    if (attributeNode.getNodeType() == Node.ELEMENT_NODE
                            && "attribute".equals(attributeNode.getLocalName())) {
                        Element attributeElement = (Element) attributeNode;
                        String attributeName = attributeElement.getAttribute("name");
                        String attributeValue = attributeElement.getAttribute("value");
                        if (!StringUtils.hasText(attributeName) || !StringUtils.hasText(attributeValue)) {
                            parserContext.getReaderContext().error(
                                    "Qualifier attributes must have both a name and a value", attributeElement);
                        }
                        attributes.put(attributeName, attributeValue);
                    }
                }
            }
            qualifier.setAttributes(attributes);
            qualifiers.add(qualifier);
        }
    }
    if (StringUtils.hasText(name) && !qualifiers.isEmpty()) {
        parserContext.getReaderContext()
                .error("A bean reference must either specify a name or qualifiers but not both", element);
    }

    BeanDefinitionBuilder lookupBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(TYPE_SAFE_BEAN_LOOKUP_CLASS_NAME);
    lookupBuilder.addConstructorArgValue(type);
    lookupBuilder.addPropertyValue("qualifiers", qualifiers);
    AbstractBeanDefinition lookupBeanDefinition = lookupBuilder.getBeanDefinition();
    String lookupBeanName = parserContext.getReaderContext().generateBeanName(lookupBeanDefinition);
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(lookupBeanDefinition, lookupBeanName), parserContext.getRegistry());
    cdiBeanFactoryBuilder.addPropertyReference("cdiBeanLookup", lookupBeanName);

    return cdiBeanFactoryBuilder.getBeanDefinition();
}

From source file:com.dianping.avatar.cache.spring.CacheBeanDefinitionParser.java

/**
 * Register jms listener definition/*  w ww .  j  a  va 2 s .c om*/
 */
private void registerJmsDefinition(Element element, ParserContext parserContext) {
    GenericBeanDefinition definition = new GenericBeanDefinition();
    MutablePropertyValues propertyValues = definition.getPropertyValues();

    definition = new GenericBeanDefinition();
    definition.setBeanClass(CacheKeyTypeVersionUpdateListener.class);
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("cacheItemConfigManager", new RuntimeBeanReference(cacheItemConfigManager));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, "keyTypeVersionUpdateListener"), parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(SingleCacheRemoveListener.class);
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("cacheClientFactory",
            new RuntimeBeanReference(DEFAULT_CACHE_CLIENT_FACTORY_ID));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, "singleCacheRemoveListener"), parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(CacheConfigurationUpdateListener.class);
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("cacheClientFactory",
            new RuntimeBeanReference(DEFAULT_CACHE_CLIENT_FACTORY_ID));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, "cacheConfigUpdateListener"), parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(CacheKeyConfigUpdateListener.class);
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("cacheItemConfigManager", new RuntimeBeanReference(cacheItemConfigManager));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, "cacheKeyConfigUpdateListener"), parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(MessageReceiver.class);
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("mappingList[0]", new RuntimeBeanReference("keyTypeVersionUpdateListener"));
    propertyValues.addPropertyValue("mappingList[1]", new RuntimeBeanReference("singleCacheRemoveListener"));
    propertyValues.addPropertyValue("mappingList[2]", new RuntimeBeanReference("cacheConfigUpdateListener"));
    propertyValues.addPropertyValue("mappingList[3]", new RuntimeBeanReference("cacheKeyConfigUpdateListener"));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, "dispatchMessageListener"), parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(MongoMQService.class);
    ConstructorArgumentValues constructorArgumentValues = definition.getConstructorArgumentValues();
    constructorArgumentValues.addGenericArgumentValue("${avatar-cache.swallow.url}", "java.lang.String");
    BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(definition, "MQService"),
            parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    definition.setBeanClass(Destination.class);
    definition.setFactoryMethodName(DEFAULT_CACHE_JMS_MODE);
    constructorArgumentValues = definition.getConstructorArgumentValues();
    constructorArgumentValues.addGenericArgumentValue(DEFAULT_CACHE_JMS_TOPIC_NAME, "java.lang.String");
    BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(definition, "CacheDestination"),
            parserContext.getRegistry());

    definition = new GenericBeanDefinition();
    //        definition.setBeanClass(MongoMessageConsumer.class);
    definition.setFactoryBeanName("MQService");
    definition.setFactoryMethodName("createConsumer");
    constructorArgumentValues = definition.getConstructorArgumentValues();
    //TODO where to get the DEFAULT_CACHE_JMS_TOPIC_NAME
    constructorArgumentValues.addGenericArgumentValue(new RuntimeBeanReference("CacheDestination"));
    propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("messageListener", new RuntimeBeanReference("dispatchMessageListener"));
    BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(definition, "cacheConsumer"),
            parserContext.getRegistry());
}