Example usage for org.springframework.beans.factory.config BeanDefinition getBeanClassName

List of usage examples for org.springframework.beans.factory.config BeanDefinition getBeanClassName

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config BeanDefinition getBeanClassName.

Prototype

@Nullable
String getBeanClassName();

Source Link

Document

Return the current bean class name of this bean definition.

Usage

From source file:com.cloudseal.spring.client.namespace.CloudSealBeanDefinitionParserInstance.java

private int getBeanIndex(List list, String regexp) {
    final Pattern pattern = Pattern.compile(regexp);
    final Matcher matcher = pattern.matcher("");
    int index = -1;
    for (int i = 0; i < list.size(); i++) {
        final Object item = list.get(i);
        if (BeanDefinition.class.isInstance(item)) {
            final BeanDefinition filter = (BeanDefinition) item;
            matcher.reset(filter.getBeanClassName());
            if (matcher.find()) {
                index = i;//  ww w  .  j  av  a 2  s  .c o m
            }
        }
    }
    return index;
}

From source file:com.cloudseal.spring.client.namespace.CloudSealBeanDefinitionParserInstance.java

private BeanDefinition registerBean(BeanDefinition bean, String beanID) {
    LOGGER.debug("Registering a {} class bean as {}...", bean.getBeanClassName(), beanID);
    parserContext.registerBeanComponent(new BeanComponentDefinition(bean, beanID));
    return bean;/*from   w ww. j  ava  2s.co m*/
}

From source file:lodsve.core.condition.BeanTypeRegistry.java

private Class<?> doGetFactoryBeanGeneric(ConfigurableListableBeanFactory beanFactory, BeanDefinition definition,
        String name) throws Exception, ClassNotFoundException, LinkageError {
    if (StringUtils.hasLength(definition.getFactoryBeanName())
            && StringUtils.hasLength(definition.getFactoryMethodName())) {
        return getConfigurationClassFactoryBeanGeneric(beanFactory, definition, name);
    }//w  w  w. ja  v a  2 s .  c o  m
    if (StringUtils.hasLength(definition.getBeanClassName())) {
        return getDirectFactoryBeanGeneric(beanFactory, definition, name);
    }
    return null;
}

From source file:org.drools.container.spring.namespace.KnowledgeSessionDefinitionParser.java

@SuppressWarnings("unchecked")
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {

    String id = element.getAttribute("id");
    emptyAttributeCheck(element.getLocalName(), "id", id);

    String kbase = element.getAttribute(KBASE_ATTRIBUTE);
    emptyAttributeCheck(element.getLocalName(), KBASE_ATTRIBUTE, kbase);

    String sessionType = element.getAttribute(TYPE_ATTRIBUTE);
    BeanDefinitionBuilder factory;//  w  w w  .j  ava2s . co  m

    if ("stateful".equals(sessionType)) {
        factory = BeanDefinitionBuilder.rootBeanDefinition(StatefulKnowledgeSessionBeanFactory.class);
    } else if ("stateless".equals(sessionType)) {
        factory = BeanDefinitionBuilder.rootBeanDefinition(StatelessKnowledgeSessionBeanFactory.class);
    } else {
        throw new IllegalArgumentException(
                "Invalid value for " + TYPE_ATTRIBUTE + " attribute: " + sessionType);
    }

    factory.addPropertyReference("kbase", kbase);

    String node = element.getAttribute(GRID_NODE_ATTRIBUTE);
    if (node != null && node.length() > 0) {
        factory.addPropertyReference("node", node);
    }

    String name = element.getAttribute(NAME_ATTRIBUTE);
    if (StringUtils.hasText(name)) {
        factory.addPropertyValue("name", name);
    } else {
        factory.addPropertyValue("name", id);
    }

    // Additions for JIRA JBRULES-3076
    String listeners = element.getAttribute(LISTENERS_ATTRIBUTE);
    if (StringUtils.hasText(listeners)) {
        factory.addPropertyValue("eventListenersFromGroup", new RuntimeBeanReference(listeners));
    }
    EventListenersUtil.parseEventListeners(parserContext, factory, element);
    // End of Additions for JIRA JBRULES-3076

    Element ksessionConf = DomUtils.getChildElementByTagName(element, "configuration");
    if (ksessionConf != null) {
        Element persistenceElm = DomUtils.getChildElementByTagName(ksessionConf, "jpa-persistence");
        if (persistenceElm != null) {
            BeanDefinitionBuilder beanBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(JpaConfiguration.class);

            String loadId = persistenceElm.getAttribute("load");
            if (StringUtils.hasText(loadId)) {
                beanBuilder.addPropertyValue("id", Long.parseLong(loadId));
            }

            Element tnxMng = DomUtils.getChildElementByTagName(persistenceElm, TX_MANAGER_ATTRIBUTE);
            String ref = tnxMng.getAttribute("ref");

            beanBuilder.addPropertyReference("platformTransactionManager", ref);

            Element emf = DomUtils.getChildElementByTagName(persistenceElm, EMF_ATTRIBUTE);
            ref = emf.getAttribute("ref");
            beanBuilder.addPropertyReference("entityManagerFactory", ref);

            Element variablePersisters = DomUtils.getChildElementByTagName(persistenceElm,
                    "variable-persisters");
            if (variablePersisters != null && variablePersisters.hasChildNodes()) {
                List<Element> childPersisterElems = DomUtils.getChildElementsByTagName(variablePersisters,
                        "persister");
                ManagedMap persistors = new ManagedMap(childPersisterElems.size());
                for (Element persisterElem : childPersisterElems) {
                    String forClass = persisterElem.getAttribute(FORCLASS_ATTRIBUTE);
                    String implementation = persisterElem.getAttribute(IMPLEMENTATION_ATTRIBUTE);
                    if (!StringUtils.hasText(forClass)) {
                        throw new RuntimeException("persister element must have valid for-class attribute");
                    }
                    if (!StringUtils.hasText(implementation)) {
                        throw new RuntimeException(
                                "persister element must have valid implementation attribute");
                    }
                    persistors.put(forClass, implementation);
                }
                beanBuilder.addPropertyValue("variablePersisters", persistors);
            }

            factory.addPropertyValue("jpaConfiguration", beanBuilder.getBeanDefinition());
        }
        BeanDefinitionBuilder rbaseConfBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(SessionConfiguration.class);
        Element e = DomUtils.getChildElementByTagName(ksessionConf, KEEP_REFERENCE);
        if (e != null && StringUtils.hasText(e.getAttribute("enabled"))) {
            rbaseConfBuilder.addPropertyValue("keepReference", Boolean.parseBoolean(e.getAttribute("enabled")));
        }

        e = DomUtils.getChildElementByTagName(ksessionConf, CLOCK_TYPE);
        if (e != null && StringUtils.hasText(e.getAttribute("type"))) {
            rbaseConfBuilder.addPropertyValue("clockType", ClockType.resolveClockType(e.getAttribute("type")));
        }
        factory.addPropertyValue("conf", rbaseConfBuilder.getBeanDefinition());

        e = DomUtils.getChildElementByTagName(ksessionConf, WORK_ITEMS);
        if (e != null) {
            List<Element> children = DomUtils.getChildElementsByTagName(e, WORK_ITEM);
            if (children != null && !children.isEmpty()) {
                ManagedMap workDefs = new ManagedMap();
                for (Element child : children) {
                    workDefs.put(child.getAttribute("name"),
                            new RuntimeBeanReference(child.getAttribute("ref")));
                }
                factory.addPropertyValue("workItems", workDefs);
            }
        }
    }

    Element batch = DomUtils.getChildElementByTagName(element, "batch");
    if (batch == null) {
        // just temporary legacy suppport
        batch = DomUtils.getChildElementByTagName(element, "script");
    }
    if (batch != null) {
        // we know there can only ever be one
        ManagedList children = new ManagedList();

        for (int i = 0, length = batch.getChildNodes().getLength(); i < length; i++) {
            Node n = batch.getChildNodes().item(i);
            if (n instanceof Element) {
                Element e = (Element) n;

                BeanDefinitionBuilder beanBuilder = null;
                if ("insert-object".equals(e.getLocalName())) {
                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(InsertObjectCommand.class);
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "insert-object must either specify a 'ref' attribute or have a nested bean");
                    }
                } else if ("set-global".equals(e.getLocalName())) {
                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(SetGlobalCommand.class);
                    beanBuilder.addConstructorArgValue(e.getAttribute("identifier"));
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "set-global must either specify a 'ref' attribute or have a nested bean");
                    }
                } else if ("fire-until-halt".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(FireUntilHaltCommand.class);
                } else if ("fire-all-rules".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(FireAllRulesCommand.class);
                    String max = e.getAttribute("max");
                    if (StringUtils.hasText(max)) {
                        beanBuilder.addPropertyValue("max", max);
                    }
                } else if ("start-process".equals(e.getLocalName())) {

                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(StartProcessCommand.class);
                    String processId = e.getAttribute("process-id");
                    if (!StringUtils.hasText(processId)) {
                        throw new IllegalArgumentException("start-process must specify a process-id");
                    }
                    beanBuilder.addConstructorArgValue(processId);

                    List<Element> params = DomUtils.getChildElementsByTagName(e, "parameter");
                    if (!params.isEmpty()) {
                        ManagedMap map = new ManagedMap();
                        for (Element param : params) {
                            String identifier = param.getAttribute("identifier");
                            if (!StringUtils.hasText(identifier)) {
                                throw new IllegalArgumentException(
                                        "start-process paramaters must specify an identifier");
                            }

                            String ref = param.getAttribute("ref");
                            Element nestedElm = getFirstElement(param.getChildNodes());
                            if (StringUtils.hasText(ref)) {
                                map.put(identifier, new RuntimeBeanReference(ref));
                            } else if (nestedElm != null) {
                                map.put(identifier, parserContext.getDelegate()
                                        .parsePropertySubElement(nestedElm, null, null));
                            } else {
                                throw new IllegalArgumentException(
                                        "start-process parameters must either specify a 'ref' attribute or have a nested bean");
                            }
                        }
                        beanBuilder.addPropertyValue("parameters", map);
                    }
                } else if ("signal-event".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(SignalEventCommand.class);
                    String processInstanceId = e.getAttribute("process-instance-id");
                    if (StringUtils.hasText(processInstanceId)) {
                        beanBuilder.addConstructorArgValue(processInstanceId);
                    }

                    beanBuilder.addConstructorArgValue(e.getAttribute("event-type"));

                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "signal-event must either specify a 'ref' attribute or have a nested bean");
                    }
                }
                if (beanBuilder == null) {
                    throw new IllegalStateException("Unknow element: " + e.getLocalName());
                }
                children.add(beanBuilder.getBeanDefinition());
            }
        }
        factory.addPropertyValue("batch", children);
    }

    // find any kagent's for the current kbase and assign (only if this 
    // is a stateless session)
    if (sessionType.equals("stateless")) {
        for (String beanName : parserContext.getRegistry().getBeanDefinitionNames()) {
            BeanDefinition def = parserContext.getRegistry().getBeanDefinition(beanName);
            if (KnowledgeAgentBeanFactory.class.getName().equals(def.getBeanClassName())) {
                PropertyValue pvalue = def.getPropertyValues().getPropertyValue("kbase");
                RuntimeBeanReference tbf = (RuntimeBeanReference) pvalue.getValue();
                if (kbase.equals(tbf.getBeanName())) {
                    factory.addPropertyValue("knowledgeAgent", new RuntimeBeanReference(beanName));
                }
            }
        }
    }

    return factory.getBeanDefinition();
}

From source file:com.griddynamics.banshun.StrictContextParentBean.java

@Override
protected List<String> analyzeDependencies(List<String> configLocations) throws Exception {
    ContextAnalyzer analyzer = new ContextAnalyzer();
    List<Exception> exceptions = new LinkedList<>();

    List<String> limitedLocations = new ArrayList<>();
    for (String loc : configLocations) {
        BeanDefinitionRegistry beanFactory = getBeanFactory(loc);

        String[] beanNames = beanFactory.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            try {
                if (isExport(beanDefinition)) {
                    analyzer.addExport(beanDefinition);
                    if (checkForRunOnly(beanName)) {
                        limitedLocations.add(loc);
                    }/*  w w  w .ja va 2 s .  c  o  m*/
                } else if (isImport(beanDefinition)) {
                    analyzer.addImport(beanDefinition);
                } else if (beanDefinition.getBeanClassName() != null) {
                    checkClassExist(loc, beanName, beanDefinition.getBeanClassName());
                }
            } catch (Exception ex) {
                exceptions.add(ex);
            }
        }
    }

    analyzer.areThereExportsWithoutImport();

    if (analyzer.areThereImportsWithoutExports() || !analyzer.areImportsTypesCorrect()) {
        exceptions.add(new BeanDefinitionValidationException(
                "There are severe errors while parsing contexts. See logs for details"));
    }

    if (!exceptions.isEmpty()) {
        for (Exception exception : exceptions) {
            log.error(exception.getMessage());
        }
        throw exceptions.get(0);
    }

    DependencySorter sorter = new DependencySorter(configLocations.toArray(new String[0]),
            analyzer.getImports(), analyzer.getExports());
    sorter.setProhibitCycles(prohibitCycles);

    locationsGraph = new LocationsGraph(analyzer.getImports(), analyzer.getExports());
    List<String> analyzedConfigLocations = locationsGraph.filterConfigLocations(limitedLocations,
            sorter.sort());

    log.info("ordered list of the contexts: {}", analyzedConfigLocations);

    return analyzedConfigLocations;
}

From source file:org.iff.infra.util.spring.script.ScriptFactoryPostProcessor.java

/**
 * Create a ScriptFactory bean definition based on the given script definition,
 * extracting only the definition data that is relevant for the ScriptFactory
 * (that is, only bean class and constructor arguments).
 * @param bd the full script bean definition
 * @return the extracted ScriptFactory bean definition
 * @see org.springframework.scripting.ScriptFactory
 *///from   w w  w .j a v a 2s  . c o  m
protected BeanDefinition createScriptFactoryBeanDefinition(BeanDefinition bd) {
    GenericBeanDefinition scriptBd = new GenericBeanDefinition();
    scriptBd.setBeanClassName(bd.getBeanClassName());
    scriptBd.getConstructorArgumentValues().addArgumentValues(bd.getConstructorArgumentValues());
    return scriptBd;
}

From source file:net.phoenix.thrift.xml.ProcessorBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    this.beanName = this.parseBeanName(element);
    this.multiplexed = this.parseBoolean(element.getAttribute("multiplexed"));
    boolean autoScan = this.parseBoolean(element.getAttribute("auto-scan"));
    Map<String, BeanDefinition> processors = null;
    if (autoScan)
        processors = this.scanProcessors(parserContext);
    if (this.multiplexed) {
        BeanDefinitionBuilder root = BeanDefinitionBuilder.rootBeanDefinition(this.getServerClassName());
        if (processors != null) {
            for (Map.Entry<String, BeanDefinition> processor : processors.entrySet()) {
                String serviceName = processor.getKey();
                String processorBeanName = serviceName + "-Processor";
                BeanDefinition processorBean = processor.getValue();
                parserContext.getRegistry().registerBeanDefinition(processorBeanName, processorBean);
                this.registerProcessor(parserContext, processor.getKey(), processorBeanName);
                LOG.info("{msg: \"Thrift Service Registered\" " + ", service-name: \"" + serviceName + "\""
                        + ",processor-name: \"" + processorBeanName + "\"" + ",processor-class:"
                        + processorBean.getBeanClassName() + "}");
            }/*from  www  .  j  a  va2  s .  c o  m*/
        }
        AbstractBeanDefinition rootBean = root.getBeanDefinition();
        parserContext.getRegistry().registerBeanDefinition(this.beanName, rootBean);
        return rootBean;
    } else {
        if (processors == null || processors.size() == 0)
            throw new BeanCreationException("Could not found thrift service processors. ");
        if (processors.size() > 1)
            throw new BeanCreationException(
                    "More than one thrift service processors found, please change 'multiplexed' to true. ");
        BeanDefinition processor = processors.values().iterator().next();

        parserContext.getRegistry().registerBeanDefinition(this.beanName, processor);
        return (AbstractBeanDefinition) processor;
    }
}

From source file:nz.co.senanque.validationengine.metadata.AnnotationsMetadataFactory.java

private void scanPackageForDomainObjects(String basePackage, Set<Class<ValidationObject>> domainObjects)
        throws ClassNotFoundException {

    ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
            true) {/*from w  w  w  .j  ava  2 s  .com*/
        private String iface = ValidationObject.class.getCanonicalName();

        /**
         * Check if the class has the right annotation
         * @param metadataReader the ASM ClassReader for the class
         * @return whether the class qualifies as a candidate component
         */
        protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
            AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
            for (String n : metadata.getInterfaceNames()) {
                if (iface.equals(n)) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Determine whether the given bean definition qualifies as candidate.
         * <p>The default implementation checks whether the class is concrete
         * (i.e. not abstract and not an interface). Can be overridden in subclasses.
         * @param beanDefinition the bean definition to check
         * @return whether the bean definition qualifies as a candidate component
         */
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
            return (beanDefinition.getMetadata().isConcrete() && beanDefinition.getMetadata().isIndependent());
        }

    };

    Set<BeanDefinition> components = provider.findCandidateComponents(basePackage.replace('.', '/'));
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    for (BeanDefinition component : components) {
        @SuppressWarnings("unchecked")
        Class<ValidationObject> class_ = (Class<ValidationObject>) Class.forName(component.getBeanClassName(),
                true, cl);
        domainObjects.add(class_);
    }
}

From source file:org.codehaus.grepo.core.config.GenericRepositoryScanBeanDefinitionParser.java

/**
 * {@inheritDoc}/* ww  w. jav a 2 s.co  m*/
 */
public BeanDefinition parse(Element element, ParserContext parserContext) {
    Object source = parserContext.extractSource(element);
    GenericRepositoryConfigContext configContext = new GenericRepositoryConfigContext(element);

    // init bean defintion parse delegate...
    BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(parserContext.getReaderContext());
    delegate.initDefaults(element.getOwnerDocument().getDocumentElement());

    GenericRepositoryBeanDefinitionScanner scanner = configureScanner(configContext, parserContext);

    parseBeanNameGenerator(configContext, parserContext);

    String[] basePackages = StringUtils.commaDelimitedListToStringArray(configContext.getBasePackage());
    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidates = scanner.findCandidateComponents(basePackage);
        for (BeanDefinition candidate : candidates) {
            BeanDefinitionBuilder builder = BeanDefinitionParserHelper
                    .createBuilderFromConfigContext(configContext, source, defaultGenericRepositoryFactoryType);

            delegate.parsePropertyElements(configContext.getElement(), builder.getRawBeanDefinition());

            builder.addPropertyValue(GenericRepositoryConfigContext.PROXY_CLASS_PROPERTY,
                    candidate.getBeanClassName());

            String beanName = beanNameGenerator.generateBeanName(candidate, parserContext.getRegistry());
            parserContext
                    .registerBeanComponent(new BeanComponentDefinition(builder.getBeanDefinition(), beanName));
            logger.debug("Registered generic repository bean '{}'", beanName);
        }
    }

    return null;
}