Example usage for org.springframework.beans.factory.support BeanDefinitionBuilder genericBeanDefinition

Introduction

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

Prototype

public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) 

Source Link

Document

Create a new BeanDefinitionBuilder used to construct a GenericBeanDefinition .

Usage

From source file:org.brushingbits.jnap.persistence.factory.DaoFactoryPostProcessor.java

protected BeanDefinition createDaoDefinition(Class<? extends PersistentModel> entityClass,
        SessionFactory sessionFactory) {
    Class daoClass = IndexedModel.class.isAssignableFrom(entityClass) ? GenericFullTextDao.class
            : GenericDao.class;
    return BeanDefinitionBuilder.genericBeanDefinition(daoClass).addConstructorArgValue(entityClass)
            .addPropertyValue("sessionFactory", sessionFactory).setScope(BeanDefinition.SCOPE_SINGLETON)
            .getBeanDefinition();//from w w w .j  a va  2 s.c  o  m
}

---

From source file:nz.co.senanque.madura.bundle.BundleRootImpl.java

public void init(DefaultListableBeanFactory ownerBeanFactory, Properties properties, ClassLoader cl,
        Map<String, Object> inheritableBeans) {
    m_properties = properties;/*from   w ww. j  a v  a2s  .co m*/
    m_inheritableBeans = inheritableBeans;
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(cl);
    m_classLoader = cl;
    GenericApplicationContext ctx = new GenericApplicationContext();
    XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx);
    String contextPath = properties.getProperty("Bundle-Context", "/bundle-spring.xml");
    m_logger.debug("loading context: {}", contextPath);
    ClassPathResource classPathResource = new ClassPathResource(contextPath, cl);
    xmlReader.loadBeanDefinitions(classPathResource);
    PropertyPlaceholderConfigurer p = new PropertyPlaceholderConfigurer();
    p.setProperties(properties);
    ctx.addBeanFactoryPostProcessor(p);
    if (m_logger.isDebugEnabled()) {
        dumpClassLoader(cl);
    }
    for (Map.Entry<String, Object> entry : inheritableBeans.entrySet()) {
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(InnerBundleFactory.class);
        beanDefinitionBuilder.addPropertyValue("key", entry.getKey());
        beanDefinitionBuilder.addPropertyValue("object", inheritableBeans.get(entry.getKey()));
        ctx.registerBeanDefinition(entry.getKey(), beanDefinitionBuilder.getBeanDefinition());
    }
    Scope scope = ownerBeanFactory.getRegisteredScope("session");
    if (scope != null) {
        ctx.getBeanFactory().registerScope("session", scope);
    }
    ctx.refresh();
    m_applicationContext = ctx;
    Thread.currentThread().setContextClassLoader(classLoader);
}

---

From source file:org.jdal.vaadin.beans.DefaultsBeanDefinitionParser.java

/**
 * @return//from   ww w  .j a  v a2 s.  c o m
 */
private ComponentDefinition registerPaginatorView(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder bdb = BeanDefinitionBuilder.genericBeanDefinition(VaadinPaginator.class);
    bdb.addPropertyValue("pageSizes", "10,20,30,40,50,100,All");
    bdb.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    BeanComponentDefinition bcd = new BeanComponentDefinition(bdb.getBeanDefinition(),
            PAGINATOR_VIEW_BEAN_NAME);
    registerBeanComponentDefinition(element, parserContext, bcd);
    return bcd;
}

---

From source file:org.bigtester.ate.model.page.elementaction.SendKeysActionPostBeanProcessor.java

/**
 * {@inheritDoc}/*from   w  w  w.ja  va 2  s  . co  m*/
 */
@Override
public void postProcessBeanFactory(@Nullable ConfigurableListableBeanFactory beanFactory)
        throws BeansException {
    if (beanFactory == null)
        throw new IllegalStateException("Spring Container initialization error");
    // String[] homePageNames =
    // beanFactory.getBeanNamesForType(IStepInputData.class, true, false);
    String[] allSendKeysActions = beanFactory.getBeanNamesForType(SendKeysAction.class, true, false);
    for (int index = 0; index < allSendKeysActions.length; index++) {
        BeanDefinition sendKeyActDef = beanFactory.getBeanDefinition(allSendKeysActions[index]);
        String dataValue = ((RuntimeBeanReference) sendKeyActDef.getConstructorArgumentValues()
                .getGenericArgumentValue(RuntimeBeanReference.class).getValue()).getBeanName();
        //.getAttribute(XsdElementConstants.ATTR_SENDKEYSACTION_DATAVALUE);
        if (null == dataValue) {
            throw new IllegalStateException("Spring Container sendKeyActionValue initialization error");
        } else {
            try {
                beanFactory.getBeanDefinition(dataValue);
            } catch (NoSuchBeanDefinitionException NoBeanDef) {

                String idstr;
                BeanDefinitionBuilder definitionBuilder;

                if (StringUtils.isEmpty(dataValue)) {
                    definitionBuilder = BeanDefinitionBuilder
                            .genericBeanDefinition(RandomAlphaTextValueDataHolder.class);
                    idstr = (String) sendKeyActDef.getAttribute("id")
                            + "_SendKeysRandomAlphaTextDataValueBean_ID";
                    definitionBuilder.addConstructorArgValue(idstr);
                    definitionBuilder.addConstructorArgValue(10);

                } else {
                    definitionBuilder = BeanDefinitionBuilder
                            .genericBeanDefinition(ManualAssignedValueDataHolder.class);

                    definitionBuilder.addConstructorArgValue(EnumRunTimeDataType.TEXT);
                    definitionBuilder.addConstructorArgValue(dataValue);

                    idstr = (String) sendKeyActDef.getAttribute("id") + "_SendKeysDataValueBean_ID";
                    definitionBuilder.addConstructorArgValue(idstr);

                }

                getBdReg().registerBeanDefinition(idstr, definitionBuilder.getBeanDefinition());
                sendKeyActDef.setAttribute(XsdElementConstants.ATTR_SENDKEYSACTION_DATAVALUE, idstr);
                sendKeyActDef.getConstructorArgumentValues().getGenericArgumentValue(RuntimeBeanReference.class)
                        .setValue(new RuntimeBeanReference(idstr));
            }
        }
    }

}

---

From source file:com.dinstone.jrpc.spring.EndpointBeanDefinitionParser.java

protected BeanDefinition getTransportBeanDefinition(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder sbd = BeanDefinitionBuilder.genericBeanDefinition(TransportBean.class);
    String address = element.getAttribute("address");
    if (StringUtils.hasText(address)) {
        sbd.addPropertyValue("address", address);
    }//w  w w .  ja  va  2s.  co  m

    String host = element.getAttribute("host");
    if (StringUtils.hasText(host)) {
        sbd.addPropertyValue("host", host);
    }

    String port = element.getAttribute("port");
    if (StringUtils.hasText(port)) {
        sbd.addPropertyValue("port", port);
    }

    String transport = element.getAttribute("transport");
    if (StringUtils.hasText(transport)) {
        sbd.addPropertyValue("type", transport);
    }

    return sbd.getBeanDefinition();
}

---

From source file:ch.simuonline.idh.attribute.resolver.spring.dc.aq.impl.AttributeQueryDataConnectorParser.java

/** {@inheritDoc} */
@Override/*w  ww .  java2  s .  co  m*/
protected void doV2Parse(@Nonnull final Element config, @Nonnull final ParserContext parserContext,
        @Nonnull final BeanDefinitionBuilder builder) {
    log.debug("{} Parsing v2 configuration {}", getLogPrefix(), config);

    final String targetResolvingStrategy = AttributeSupport.getAttributeValue(config,
            new QName("targetDeterminationStrategy"));
    Constraint.isNotNull(StringSupport.trimOrNull(targetResolvingStrategy),
            "The targetDeterminationStrategy can not be null or empty, please adjust entityID from the AQ DataConnector");

    if (targetResolvingStrategy.equals("mysql")) {
        // Constructor is MySQLTargetResolvingStrategy(String url, String username, String password), adding arguments in this order:
        final BeanDefinitionBuilder mysqlTargetResolvingStrategy = BeanDefinitionBuilder
                .genericBeanDefinition(MySQLTargetDeterminationStrategy.class);

        final String dbURL = AttributeSupport.getAttributeValue(config, new QName("dbURL"));
        Constraint.isNotNull(StringSupport.trimOrNull(dbURL),
                "The dbURL attribute is required if the targetResolvingStrategy is mysql, please adjust entityID from the AQ DataConnector");
        mysqlTargetResolvingStrategy.addConstructorArgValue(dbURL);

        final String dbUsername = AttributeSupport.getAttributeValue(config, new QName("dbUsername"));
        Constraint.isNotNull(StringSupport.trimOrNull(dbUsername),
                "The dbUsername attribute is required if the targetResolvingStrategy is mysql, please adjust entityID from the AQ DataConnector");
        mysqlTargetResolvingStrategy.addConstructorArgValue(dbUsername);

        final String dbPassword = AttributeSupport.getAttributeValue(config, new QName("dbPassword"));
        Constraint.isNotNull(StringSupport.trimOrNull(dbPassword),
                "The dbPassword attribute is required if the targetResolvingStrategy is mysql, please adjust entityID from the AQ DataConnector");
        mysqlTargetResolvingStrategy.addConstructorArgValue(dbPassword);

        builder.addPropertyValue("targetResolvingStrategy", mysqlTargetResolvingStrategy.getBeanDefinition());
    } else if (targetResolvingStrategy.equals("ldap")) {
        final BeanDefinitionBuilder ldapTargetResolvingStrategy = BeanDefinitionBuilder
                .genericBeanDefinition(LDAPTargetDeterminationStrategy.class);

        final String sourceAttributeID = AttributeSupport.getAttributeValue(config,
                new QName("sourceAttributeID"));
        Constraint.isNotNull(StringSupport.trimOrNull(sourceAttributeID),
                "The sourceAttributeID attribute is required if the targetResolvingStrategy is ldap, please adjust entityID from the AQ DataConnector");
        ldapTargetResolvingStrategy.addConstructorArgValue(sourceAttributeID);

        final List<Element> dependencyElements = ElementSupport.getChildElements(config,
                ResolverPluginDependencyParser.ELEMENT_NAME);
        ldapTargetResolvingStrategy.addPropertyValue("dependencies",
                SpringSupport.parseCustomElements(dependencyElements, parserContext));

        final String connectorID = AttributeSupport.getAttributeValue(config, new QName("id"));
        Constraint.isNotNull(StringSupport.trimOrNull(sourceAttributeID),
                "The connectorID can not be empty, please adjust it for the AQ DataConnector");
        ldapTargetResolvingStrategy.addConstructorArgValue(connectorID);

        builder.addPropertyValue("targetResolvingStrategy", ldapTargetResolvingStrategy.getBeanDefinition());

    } else {
        log.error("{} Unsupported targetResolvingStrategy: {}. Change it to mysql or ldap! ", getLogPrefix(),
                targetResolvingStrategy);
    }

    final BeanDefinitionBuilder attributeQueryBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(AttributeQueryBuilder.class);

    // Parse value of the entityID attribute
    final String issuer = AttributeSupport.getAttributeValue(config, new QName("entityID"));
    Constraint.isNotNull(StringSupport.trimOrNull(issuer),
            "The entityID of the Issuer can not be empty, please adjust entityID from the AQ DataConnector");
    attributeQueryBuilder.addConstructorArgValue(issuer);

    // parsing of the defined AQAttributes for the attribute query
    final List<Element> children = ElementSupport.getChildElements(config, ATTRIBUTE_ELEMENT_NAME);
    final List<BeanDefinition> attributes = new ManagedList<>(children.size());
    for (final Element child : children) {
        final String name = AttributeSupport.getAttributeValue(child, new QName("name"));
        final String friendlyName = AttributeSupport.getAttributeValue(child, new QName("friendlyName"));

        final BeanDefinitionBuilder attribute = BeanDefinitionBuilder.genericBeanDefinition(AQAttribute.class);
        attribute.addConstructorArgValue(name);
        attribute.addConstructorArgValue(friendlyName);
        log.debug("{} Added one AQAttribute to the resolving List. Friendly Name {}, Name {}", getLogPrefix(),
                friendlyName, name);
        attributes.add(attribute.getBeanDefinition());
    }

    attributeQueryBuilder.addConstructorArgValue(attributes);
    builder.addPropertyValue("attributeQueryBuilder", attributeQueryBuilder.getBeanDefinition());

    final BeanDefinitionBuilder keyManager = BeanDefinitionBuilder
            .genericBeanDefinition(AttributeQueryKeyManager.class);

    // parse the keyLocaton attribute from the AQ DataCOnnector
    final String keyLocation = AttributeSupport.getAttributeValue(config, new QName("keyLocation"));
    Constraint.isNotNull(StringSupport.trimOrNull(keyLocation),
            "Key location can not be empty, please adjust keyLocation from the AQ DataConnector");

    // parse the certLocaton attribute from the AQ DataCOnnector
    final String certLocation = AttributeSupport.getAttributeValue(config, new QName("certLocation"));
    Constraint.isNotNull(StringSupport.trimOrNull(certLocation),
            "Certificate location can not be empty, please adjust certLocation from the AQ DataConnector");

    keyManager.addConstructorArgValue(getPrivateKey(keyLocation));
    keyManager.addConstructorArgValue(getCertificate(certLocation));
    builder.addPropertyValue("attributeQueryKeyManager", keyManager.getBeanDefinition());

    // if the asertionSigned attribute is true, set the value to true
    final String signatureRequired = AttributeSupport.getAttributeValue(config, new QName("assertionSigned"));
    if (signatureRequired != null && signatureRequired.equals("true")) {
        builder.addPropertyValue("signatureRequired", Boolean.TRUE);
    }

    // if the requestedAttributesRequired attribute is true, set the value to true
    final String requireMetadataAttributes = AttributeSupport.getAttributeValue(config,
            new QName("requestedAttributesRequired"));
    if (requireMetadataAttributes != null && requireMetadataAttributes.equals("true")) {
        builder.addPropertyValue("requireMetadataAttributes", Boolean.TRUE);
    }

    builder.setInitMethodName("initialize");
    builder.setDestroyMethodName("destroy");
}

---

From source file:com.alibaba.citrus.service.form.impl.FormServiceDefinitionParser.java

private Object parseGroup(Element element, ParserContext parserContext,
        BeanDefinitionBuilder formConfigBuilder) {
    BeanDefinitionBuilder groupConfigBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(GroupConfigImpl.class);

    // set attributes
    attributesToProperties(element, groupConfigBuilder, "name", "trimmingByDefault", "postOnly");

    String parentGroup = trimToNull(element.getAttribute("extends"));

    if (parentGroup != null) {
        groupConfigBuilder.addPropertyValue("parentGroup", parentGroup);
    }//from w w w .j av a2s  .co m

    // import & field
    ElementSelector importSelector = and(sameNs(element), name("import"));
    ElementSelector fieldSelector = and(sameNs(element), name("field"));

    List<Object> imports = createManagedList(element, parserContext);
    List<Object> fields = createManagedList(element, parserContext);

    for (Element subElement : subElements(element)) {
        if (importSelector.accept(subElement)) {
            imports.add(parseImportGroup(subElement, parserContext, groupConfigBuilder));
        } else if (fieldSelector.accept(subElement)) {
            fields.add(parseField(subElement, parserContext, groupConfigBuilder));
        }
    }

    groupConfigBuilder.addPropertyValue("imports", imports);
    groupConfigBuilder.addPropertyValue("fieldConfigImplList", fields);

    return groupConfigBuilder.getBeanDefinition();
}

---

From source file:com.dinstone.jrpc.spring.spi.ClientBeanDefinitionParser.java

protected BeanDefinition getTransportBeanDefinition(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder sbd = BeanDefinitionBuilder.genericBeanDefinition(TransportBean.class);
    String addresses = element.getAttribute("addresses");
    if (StringUtils.hasText(addresses)) {
        sbd.addPropertyValue("addresses", addresses);
    }//from  w w  w  .  ja  va  2s  .c om

    String transport = element.getAttribute("transport");
    if (StringUtils.hasText(transport)) {
        sbd.addPropertyValue("type", transport);
    }

    return sbd.getBeanDefinition();
}

---

From source file:io.cloudslang.schema.WorkerBeanDefinitionParser.java

private AbstractBeanDefinition createRootBeanDefinition() {
    return BeanDefinitionBuilder.genericBeanDefinition(Object.class).getBeanDefinition();
}

---

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

private void registerProcessStartAnnotationBeanPostProcessor(Element element, ParserContext parserContext) {
    Class clz = ProcessStartAnnotationBeanPostProcessor.class;

    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clz);
    AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    configureProcessEngine(beanDefinition, element);

    String beanName = baseBeanName(clz);
    parserContext.getRegistry().registerBeanDefinition(beanName, beanDefinition);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• »