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

List of usage examples for org.springframework.beans.factory.support BeanDefinitionBuilder getBeanDefinition

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. BeanDefinitionBuilder
  6. getBeanDefinition

Introduction

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

Prototype

public AbstractBeanDefinition getBeanDefinition()

Source Link

Document

Validate and return the created BeanDefinition object.

Usage

From source file:org.springframework.security.config.method.GlobalMethodSecurityBeanDefinitionParser.java

public BeanDefinition parse(Element element, ParserContext pc) {
    CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(),
            pc.extractSource(element));//from  w  w w  .j  a  v a  2 s  . c o m
    pc.pushContainingComponent(compositeDef);

    Object source = pc.extractSource(element);
    // The list of method metadata delegates
    ManagedList<BeanMetadataElement> delegates = new ManagedList<>();

    boolean jsr250Enabled = "enabled".equals(element.getAttribute(ATT_USE_JSR250));
    boolean useSecured = "enabled".equals(element.getAttribute(ATT_USE_SECURED));
    boolean prePostAnnotationsEnabled = "enabled".equals(element.getAttribute(ATT_USE_PREPOST));
    boolean useAspectJ = "aspectj".equals(element.getAttribute(ATT_MODE));

    BeanDefinition preInvocationVoter = null;
    ManagedList<BeanMetadataElement> afterInvocationProviders = new ManagedList<>();

    // Check for an external SecurityMetadataSource, which takes priority over other
    // sources
    String metaDataSourceId = element.getAttribute(ATT_META_DATA_SOURCE_REF);

    if (StringUtils.hasText(metaDataSourceId)) {
        delegates.add(new RuntimeBeanReference(metaDataSourceId));
    }

    if (prePostAnnotationsEnabled) {
        Element prePostElt = DomUtils.getChildElementByTagName(element, INVOCATION_HANDLING);
        Element expressionHandlerElt = DomUtils.getChildElementByTagName(element, EXPRESSION_HANDLER);

        if (prePostElt != null && expressionHandlerElt != null) {
            pc.getReaderContext().error(
                    INVOCATION_HANDLING + " and " + EXPRESSION_HANDLER + " cannot be used together ", source);
        }

        BeanDefinitionBuilder preInvocationVoterBldr = BeanDefinitionBuilder
                .rootBeanDefinition(PreInvocationAuthorizationAdviceVoter.class);
        // After-invocation provider to handle post-invocation filtering and
        // authorization expression annotations.
        BeanDefinitionBuilder afterInvocationBldr = BeanDefinitionBuilder
                .rootBeanDefinition(PostInvocationAdviceProvider.class);
        // The metadata source for the security interceptor
        BeanDefinitionBuilder mds = BeanDefinitionBuilder
                .rootBeanDefinition(PrePostAnnotationSecurityMetadataSource.class);

        if (prePostElt != null) {
            // Customized override of expression handling system
            String attributeFactoryRef = DomUtils
                    .getChildElementByTagName(prePostElt, INVOCATION_ATTRIBUTE_FACTORY).getAttribute("ref");
            String preAdviceRef = DomUtils.getChildElementByTagName(prePostElt, PRE_INVOCATION_ADVICE)
                    .getAttribute("ref");
            String postAdviceRef = DomUtils.getChildElementByTagName(prePostElt, POST_INVOCATION_ADVICE)
                    .getAttribute("ref");

            mds.addConstructorArgReference(attributeFactoryRef);
            preInvocationVoterBldr.addConstructorArgReference(preAdviceRef);
            afterInvocationBldr.addConstructorArgReference(postAdviceRef);
        } else {
            // The default expression-based system
            String expressionHandlerRef = expressionHandlerElt == null ? null
                    : expressionHandlerElt.getAttribute("ref");

            if (StringUtils.hasText(expressionHandlerRef)) {
                logger.info(
                        "Using bean '" + expressionHandlerRef + "' as method ExpressionHandler implementation");
                RootBeanDefinition lazyInitPP = new RootBeanDefinition(
                        LazyInitBeanDefinitionRegistryPostProcessor.class);
                lazyInitPP.getConstructorArgumentValues().addGenericArgumentValue(expressionHandlerRef);
                pc.getReaderContext().registerWithGeneratedName(lazyInitPP);

                BeanDefinitionBuilder lazyMethodSecurityExpressionHandlerBldr = BeanDefinitionBuilder
                        .rootBeanDefinition(LazyInitTargetSource.class);
                lazyMethodSecurityExpressionHandlerBldr.addPropertyValue("targetBeanName",
                        expressionHandlerRef);

                BeanDefinitionBuilder expressionHandlerProxyBldr = BeanDefinitionBuilder
                        .rootBeanDefinition(ProxyFactoryBean.class);
                expressionHandlerProxyBldr.addPropertyValue("targetSource",
                        lazyMethodSecurityExpressionHandlerBldr.getBeanDefinition());
                expressionHandlerProxyBldr.addPropertyValue("proxyInterfaces",
                        MethodSecurityExpressionHandler.class);

                expressionHandlerRef = pc.getReaderContext()
                        .generateBeanName(expressionHandlerProxyBldr.getBeanDefinition());

                pc.registerBeanComponent(new BeanComponentDefinition(
                        expressionHandlerProxyBldr.getBeanDefinition(), expressionHandlerRef));
            } else {
                RootBeanDefinition expressionHandler = registerWithDefaultRolePrefix(pc,
                        DefaultMethodSecurityExpressionHandlerBeanFactory.class);

                expressionHandlerRef = pc.getReaderContext().generateBeanName(expressionHandler);
                pc.registerBeanComponent(new BeanComponentDefinition(expressionHandler, expressionHandlerRef));
                logger.info(
                        "Expressions were enabled for method security but no SecurityExpressionHandler was configured. "
                                + "All hasPermision() expressions will evaluate to false.");
            }

            BeanDefinitionBuilder expressionPreAdviceBldr = BeanDefinitionBuilder
                    .rootBeanDefinition(ExpressionBasedPreInvocationAdvice.class);
            expressionPreAdviceBldr.addPropertyReference("expressionHandler", expressionHandlerRef);
            preInvocationVoterBldr.addConstructorArgValue(expressionPreAdviceBldr.getBeanDefinition());

            BeanDefinitionBuilder expressionPostAdviceBldr = BeanDefinitionBuilder
                    .rootBeanDefinition(ExpressionBasedPostInvocationAdvice.class);
            expressionPostAdviceBldr.addConstructorArgReference(expressionHandlerRef);
            afterInvocationBldr.addConstructorArgValue(expressionPostAdviceBldr.getBeanDefinition());

            BeanDefinitionBuilder annotationInvocationFactory = BeanDefinitionBuilder
                    .rootBeanDefinition(ExpressionBasedAnnotationAttributeFactory.class);
            annotationInvocationFactory.addConstructorArgReference(expressionHandlerRef);
            mds.addConstructorArgValue(annotationInvocationFactory.getBeanDefinition());
        }

        preInvocationVoter = preInvocationVoterBldr.getBeanDefinition();
        afterInvocationProviders.add(afterInvocationBldr.getBeanDefinition());
        delegates.add(mds.getBeanDefinition());
    }

    if (useSecured) {
        delegates.add(BeanDefinitionBuilder.rootBeanDefinition(SecuredAnnotationSecurityMetadataSource.class)
                .getBeanDefinition());
    }

    if (jsr250Enabled) {
        RootBeanDefinition jsrMetadataSource = registerWithDefaultRolePrefix(pc,
                Jsr250MethodSecurityMetadataSourceBeanFactory.class);
        delegates.add(jsrMetadataSource);
    }

    // Now create a Map<String, ConfigAttribute> for each <protect-pointcut>
    // sub-element
    Map<String, List<ConfigAttribute>> pointcutMap = parseProtectPointcuts(pc,
            DomUtils.getChildElementsByTagName(element, PROTECT_POINTCUT));

    if (pointcutMap.size() > 0) {
        if (useAspectJ) {
            pc.getReaderContext().error("You can't use AspectJ mode with protect-pointcut definitions", source);
        }
        // Only add it if there are actually any pointcuts defined.
        BeanDefinition mapBasedMetadataSource = new RootBeanDefinition(
                MapBasedMethodSecurityMetadataSource.class);
        BeanReference ref = new RuntimeBeanReference(
                pc.getReaderContext().generateBeanName(mapBasedMetadataSource));

        delegates.add(ref);
        pc.registerBeanComponent(new BeanComponentDefinition(mapBasedMetadataSource, ref.getBeanName()));
        registerProtectPointcutPostProcessor(pc, pointcutMap, ref, source);
    }

    BeanReference metadataSource = registerDelegatingMethodSecurityMetadataSource(pc, delegates, source);

    // Check for additional after-invocation-providers..
    List<Element> afterInvocationElts = DomUtils.getChildElementsByTagName(element,
            Elements.AFTER_INVOCATION_PROVIDER);

    for (Element elt : afterInvocationElts) {
        afterInvocationProviders.add(new RuntimeBeanReference(elt.getAttribute(ATT_REF)));
    }

    String accessManagerId = element.getAttribute(ATT_ACCESS_MGR);

    if (!StringUtils.hasText(accessManagerId)) {
        accessManagerId = registerAccessManager(pc, jsr250Enabled, preInvocationVoter);
    }

    String authMgrRef = element.getAttribute(ATT_AUTHENTICATION_MANAGER_REF);

    String runAsManagerId = element.getAttribute(ATT_RUN_AS_MGR);
    BeanReference interceptor = registerMethodSecurityInterceptor(pc, authMgrRef, accessManagerId,
            runAsManagerId, metadataSource, afterInvocationProviders, source, useAspectJ);

    if (useAspectJ) {
        BeanDefinitionBuilder aspect = BeanDefinitionBuilder.rootBeanDefinition(
                "org.springframework.security.access.intercept.aspectj.aspect.AnnotationSecurityAspect");
        aspect.setFactoryMethod("aspectOf");
        aspect.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        aspect.addPropertyValue("securityInterceptor", interceptor);
        String id = pc.getReaderContext().registerWithGeneratedName(aspect.getBeanDefinition());
        pc.registerBeanComponent(new BeanComponentDefinition(aspect.getBeanDefinition(), id));
    } else {
        registerAdvisor(pc, interceptor, metadataSource, source, element.getAttribute(ATT_ADVICE_ORDER));
        AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(pc, element);
    }

    pc.popAndRegisterContainingComponent();

    return null;
}

From source file:org.springframework.security.config.method.GlobalMethodSecurityBeanDefinitionParser.java

/**
 * Register the default AccessDecisionManager. Adds the special JSR 250 voter jsr-250
 * is enabled and an expression voter if expression-based access control is enabled.
 * @return/*from  ww  w.j ava  2 s .c o  m*/
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
private String registerAccessManager(ParserContext pc, boolean jsr250Enabled, BeanDefinition expressionVoter) {

    BeanDefinitionBuilder accessMgrBuilder = BeanDefinitionBuilder.rootBeanDefinition(AffirmativeBased.class);
    ManagedList voters = new ManagedList(4);

    if (expressionVoter != null) {
        voters.add(expressionVoter);
    }
    voters.add(new RootBeanDefinition(RoleVoter.class));
    voters.add(new RootBeanDefinition(AuthenticatedVoter.class));

    if (jsr250Enabled) {
        voters.add(new RootBeanDefinition(Jsr250Voter.class));
    }

    accessMgrBuilder.addConstructorArgValue(voters);

    BeanDefinition accessManager = accessMgrBuilder.getBeanDefinition();
    String id = pc.getReaderContext().generateBeanName(accessManager);
    pc.registerBeanComponent(new BeanComponentDefinition(accessManager, id));

    return id;
}

From source file:org.springframework.security.config.method.GlobalMethodSecurityBeanDefinitionParser.java

private BeanReference registerMethodSecurityInterceptor(ParserContext pc, String authMgrRef,
        String accessManagerId, String runAsManagerId, BeanReference metadataSource,
        List<BeanMetadataElement> afterInvocationProviders, Object source, boolean useAspectJ) {
    BeanDefinitionBuilder bldr = BeanDefinitionBuilder.rootBeanDefinition(
            useAspectJ ? AspectJMethodSecurityInterceptor.class : MethodSecurityInterceptor.class);
    bldr.getRawBeanDefinition().setSource(source);
    bldr.addPropertyReference("accessDecisionManager", accessManagerId);
    RootBeanDefinition authMgr = new RootBeanDefinition(AuthenticationManagerDelegator.class);
    authMgr.getConstructorArgumentValues().addGenericArgumentValue(authMgrRef);
    bldr.addPropertyValue("authenticationManager", authMgr);
    bldr.addPropertyValue("securityMetadataSource", metadataSource);

    if (StringUtils.hasText(runAsManagerId)) {
        bldr.addPropertyReference("runAsManager", runAsManagerId);
    }//from   w  w  w .j  av  a 2s.c  om

    if (!afterInvocationProviders.isEmpty()) {
        BeanDefinition afterInvocationManager;
        afterInvocationManager = new RootBeanDefinition(AfterInvocationProviderManager.class);
        afterInvocationManager.getPropertyValues().addPropertyValue("providers", afterInvocationProviders);
        bldr.addPropertyValue("afterInvocationManager", afterInvocationManager);
    }

    BeanDefinition bean = bldr.getBeanDefinition();
    String id = pc.getReaderContext().generateBeanName(bean);
    pc.registerBeanComponent(new BeanComponentDefinition(bean, id));

    return new RuntimeBeanReference(id);
}

From source file:org.springframework.security.config.websocket.WebSocketMessageBrokerSecurityBeanDefinitionParser.java

/**
 * @param element/*from w  ww  .  jav  a 2 s . c  om*/
 * @param parserContext
 * @return
 */
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionRegistry registry = parserContext.getRegistry();
    XmlReaderContext context = parserContext.getReaderContext();

    ManagedMap<BeanDefinition, String> matcherToExpression = new ManagedMap<BeanDefinition, String>();

    String id = element.getAttribute(ID_ATTR);
    boolean sameOriginDisabled = Boolean.parseBoolean(element.getAttribute(DISABLED_ATTR));

    List<Element> interceptMessages = DomUtils.getChildElementsByTagName(element, Elements.INTERCEPT_MESSAGE);
    for (Element interceptMessage : interceptMessages) {
        String matcherPattern = interceptMessage.getAttribute(PATTERN_ATTR);
        String accessExpression = interceptMessage.getAttribute(ACCESS_ATTR);
        String messageType = interceptMessage.getAttribute(TYPE_ATTR);

        BeanDefinition matcher = createMatcher(matcherPattern, messageType, parserContext, interceptMessage);
        matcherToExpression.put(matcher, accessExpression);
    }

    BeanDefinitionBuilder mds = BeanDefinitionBuilder
            .rootBeanDefinition(ExpressionBasedMessageSecurityMetadataSourceFactory.class);
    mds.setFactoryMethod("createExpressionMessageMetadataSource");
    mds.addConstructorArgValue(matcherToExpression);

    String mdsId = context.registerWithGeneratedName(mds.getBeanDefinition());

    ManagedList<BeanDefinition> voters = new ManagedList<BeanDefinition>();
    voters.add(new RootBeanDefinition(MessageExpressionVoter.class));
    BeanDefinitionBuilder adm = BeanDefinitionBuilder.rootBeanDefinition(ConsensusBased.class);
    adm.addConstructorArgValue(voters);

    BeanDefinitionBuilder inboundChannelSecurityInterceptor = BeanDefinitionBuilder
            .rootBeanDefinition(ChannelSecurityInterceptor.class);
    inboundChannelSecurityInterceptor.addConstructorArgValue(registry.getBeanDefinition(mdsId));
    inboundChannelSecurityInterceptor.addPropertyValue("accessDecisionManager", adm.getBeanDefinition());
    String inSecurityInterceptorName = context
            .registerWithGeneratedName(inboundChannelSecurityInterceptor.getBeanDefinition());

    if (StringUtils.hasText(id)) {
        registry.registerAlias(inSecurityInterceptorName, id);

        if (!registry.containsBeanDefinition(PATH_MATCHER_BEAN_NAME)) {
            registry.registerBeanDefinition(PATH_MATCHER_BEAN_NAME,
                    new RootBeanDefinition(AntPathMatcher.class));
        }
    } else {
        BeanDefinitionBuilder mspp = BeanDefinitionBuilder
                .rootBeanDefinition(MessageSecurityPostProcessor.class);
        mspp.addConstructorArgValue(inSecurityInterceptorName);
        mspp.addConstructorArgValue(sameOriginDisabled);
        context.registerWithGeneratedName(mspp.getBeanDefinition());
    }

    return null;
}

From source file:org.springframework.security.config.websocket.WebSocketMessageBrokerSecurityBeanDefinitionParser.java

private BeanDefinition createMatcher(String matcherPattern, String messageType, ParserContext parserContext,
        Element interceptMessage) {
    boolean hasPattern = StringUtils.hasText(matcherPattern);
    boolean hasMessageType = StringUtils.hasText(messageType);
    if (!hasPattern) {
        BeanDefinitionBuilder matcher = BeanDefinitionBuilder.rootBeanDefinition(SimpMessageTypeMatcher.class);
        matcher.addConstructorArgValue(messageType);
        return matcher.getBeanDefinition();
    }//from   w ww .  java 2s . c  o  m

    String factoryName = null;
    if (hasPattern && hasMessageType) {
        SimpMessageType type = SimpMessageType.valueOf(messageType);
        if (SimpMessageType.MESSAGE == type) {
            factoryName = "createMessageMatcher";
        } else if (SimpMessageType.SUBSCRIBE == type) {
            factoryName = "createSubscribeMatcher";
        } else {
            parserContext.getReaderContext()
                    .error("Cannot use intercept-websocket@message-type=" + messageType
                            + " with a pattern because the type does not have a destination.",
                            interceptMessage);
        }
    }

    BeanDefinitionBuilder matcher = BeanDefinitionBuilder
            .rootBeanDefinition(SimpDestinationMessageMatcher.class);
    matcher.setFactoryMethod(factoryName);
    matcher.addConstructorArgValue(matcherPattern);
    matcher.addConstructorArgValue(new RuntimeBeanReference("springSecurityMessagePathMatcher"));
    return matcher.getBeanDefinition();
}

From source file:org.springframework.social.auth0.config.xml.Auth0ConfigBeanDefinitionParser.java

@Override
protected BeanDefinition getConnectionFactoryBeanDefinition(String appId, String appSecret,
        Map<String, Object> allAttributes) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(Auth0ConnectionFactory.class)
            .addConstructorArgValue(appId).addConstructorArgValue(appSecret);
    return builder.getBeanDefinition();
}

From source file:org.springframework.social.config.support.InMemoryConnectionRepositoryConfigSupport.java

private BeanDefinition registerUsersConnectionRepositoryBeanDefinition(BeanDefinitionRegistry registry,
        String usersConnectionRepositoryId, String connectionFactoryLocatorRef, String connectionSignUpRef) {
    if (logger.isDebugEnabled()) {
        logger.debug("Registering InMemoryUsersConnectionRepository bean");
    }//w w  w. j  ava 2  s .c o  m
    BeanDefinitionBuilder usersConnectionRepositoryBeanBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(InMemoryUsersConnectionRepository.class)
            .addConstructorArgReference(connectionFactoryLocatorRef);
    if (connectionSignUpRef != null && connectionSignUpRef.length() > 0) {
        usersConnectionRepositoryBeanBuilder.addPropertyReference("connectionSignUp", connectionSignUpRef);
    }
    BeanDefinition usersConnectionRepositoryBD = usersConnectionRepositoryBeanBuilder.getBeanDefinition();
    BeanDefinition scopedProxyBean = decorateWithScopedProxy(usersConnectionRepositoryId,
            usersConnectionRepositoryBD, registry);
    registry.registerBeanDefinition(usersConnectionRepositoryId, scopedProxyBean);
    return scopedProxyBean;
}

From source file:org.springframework.social.config.support.JdbcConnectionRepositoryConfigSupport.java

private BeanDefinition registerUsersConnectionRepositoryBeanDefinition(BeanDefinitionRegistry registry,
        String usersConnectionRepositoryId, String connectionFactoryLocatorRef, String dataSourceRef,
        String encryptorRef, String connectionSignUpRef) {
    if (logger.isDebugEnabled()) {
        logger.debug("Registering JdbcUsersConnectionRepository bean");
    }/*  ww w . j a  va  2s .c  om*/
    BeanDefinitionBuilder usersConnectionRepositoryBeanBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(JdbcUsersConnectionRepository.class)
            .addConstructorArgReference(dataSourceRef).addConstructorArgReference(connectionFactoryLocatorRef)
            .addConstructorArgReference(encryptorRef);
    if (connectionSignUpRef != null && connectionSignUpRef.length() > 0) {
        usersConnectionRepositoryBeanBuilder.addPropertyReference("connectionSignUp", connectionSignUpRef);
    }
    BeanDefinition usersConnectionRepositoryBD = usersConnectionRepositoryBeanBuilder.getBeanDefinition();
    BeanDefinition scopedProxyBean = decorateWithScopedProxy(usersConnectionRepositoryId,
            usersConnectionRepositoryBD, registry);
    registry.registerBeanDefinition(usersConnectionRepositoryId, scopedProxyBean);
    return scopedProxyBean;
}

From source file:org.springframework.social.extension.config.support.InMemoryConnectionRepositoryConfigSupport.java

private BeanDefinition registerUsersConnectionRepositoryBeanDefinition(BeanDefinitionRegistry registry,
        String usersConnectionRepositoryId, String connectionFactoryLocatorRef, String connectionSignUpRef) {
    if (logger.isDebugEnabled()) {
        logger.debug("Registering JpaUsersConnectionRepository bean");
    }/*w  w w  . ja  va  2s .  co m*/
    BeanDefinitionBuilder usersConnectionRepositoryBeanBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(JpaUsersConnectionRepository.class)
            .addConstructorArgReference(connectionFactoryLocatorRef);
    if (connectionSignUpRef != null && connectionSignUpRef.length() > 0) {
        usersConnectionRepositoryBeanBuilder.addPropertyReference("connectionSignUp", connectionSignUpRef);
    }
    BeanDefinition usersConnectionRepositoryBD = usersConnectionRepositoryBeanBuilder.getBeanDefinition();
    BeanDefinition scopedProxyBean = decorateWithScopedProxy(usersConnectionRepositoryId,
            usersConnectionRepositoryBD, registry);
    registry.registerBeanDefinition(usersConnectionRepositoryId, scopedProxyBean);
    return scopedProxyBean;
}