messagebrokerbeandefinitionparser.java

来自「java 和flex的整合,主要是spring和flex的整合,不可多得啊」· Java 代码 · 共 505 行 · 第 1/2 页

        if (remotingServiceElement != null) {
            ParsingUtils.mapAllAttributes(remotingServiceElement, remotingProcessorBuilder);
        }

        String brokerId = parent.getAttribute(ID_ATTRIBUTE);

        ParsingUtils.registerInfrastructureComponent(source, parserContext, remotingProcessorBuilder, brokerId + BeanIds.REMOTING_PROCESSOR_SUFFIX);
        configProcessors.add(new RuntimeBeanReference(brokerId + BeanIds.REMOTING_PROCESSOR_SUFFIX));

        registerFlexRemotingAnnotationPostProcessorIfNecessary(source, parserContext);
    }

    @SuppressWarnings("unchecked")
    private void configureSecurity(Element parent, ParserContext parserContext, ManagedSet configProcessors, ManagedList advisors,
        ManagedSet translators, ManagedSet interceptors, Element securedElement) {

        if (securedElement == null) {
            return;
        }

        boolean perClientAuthentication = Boolean.parseBoolean(securedElement.getAttribute(PER_CLIENT_AUTHENTICATION_ATTR));

        String authManager = securedElement.getAttribute(AUTH_MANAGER_ATTR);
        if (!StringUtils.hasText(authManager)) {
            authManager = org.springframework.security.config.BeanIds.AUTHENTICATION_MANAGER;
        }

        String accessManager = securedElement.getAttribute(ACCESS_MANAGER_ATTR);
        if (!StringUtils.hasText(accessManager)) {
            accessManager = org.springframework.security.config.BeanIds.ACCESS_MANAGER;
        }

        registerAuthenticationListenerIfNecessary(securedElement, parserContext);

        String brokerId = parent.getAttribute(ID_ATTRIBUTE);
        registerLoginCommand(brokerId, parserContext, configProcessors, securedElement, authManager, perClientAuthentication);

        translators.add(new SecurityExceptionTranslator());
        if (perClientAuthentication) {
            interceptors.add(new PerClientAuthenticationInterceptor());
        }
        interceptors.add(new LoginMessageInterceptor());

        registerEndpointInterceptorIfNecessary(securedElement, parserContext, interceptors, authManager, accessManager);
    }

    private Object parseConfigAttributeDefinition(String access) {
        if (StringUtils.hasText(access)) {
            return new ConfigAttributeDefinition(StringUtils.commaDelimitedListToStringArray(access));
        } else {
            return null;
        }
    }

    private void registerAuthenticationListenerIfNecessary(Element securedElement, ParserContext parserContext) {

        if (!parserContext.getRegistry().containsBeanDefinition(BeanIds.SESSION_FIXATION_PROTECTION_CONFIGURER)) {
            BeanDefinitionBuilder configurerBuilder = BeanDefinitionBuilder.genericBeanDefinition(SESSION_FIXATION_CONFIGURER_CLASS_NAME);
            ParsingUtils.registerInfrastructureComponent(securedElement, parserContext, configurerBuilder,
                BeanIds.SESSION_FIXATION_PROTECTION_CONFIGURER);
        }
    }

    @SuppressWarnings("unchecked")
    private void registerConfigMapEditorIfNecessary(Element source, ParserContext parserContext) {
        if (!parserContext.getRegistry().containsBeanDefinition(BeanIds.JSON_CONFIG_MAP_EDITOR_CONFIGURER)) {
            BeanDefinitionBuilder configurerBuilder = BeanDefinitionBuilder.genericBeanDefinition(CUSTOM_EDITOR_CONFIGURER_CLASS_NAME);
            ManagedMap editors = new ManagedMap();
            editors.put(CONFIG_MAP_CLASS_NAME, JSON_CONFIG_MAP_EDITOR_CLASS_NAME);
            configurerBuilder.addPropertyValue(CUSTOM_EDITORS_PROPERTY, editors);
            ParsingUtils.registerInfrastructureComponent(source, parserContext, configurerBuilder, BeanIds.JSON_CONFIG_MAP_EDITOR_CONFIGURER);
        }

    }

    @SuppressWarnings("unchecked")
    private void registerCustomConfigProcessors(ParserContext parserContext, Set configProcessors, List configProcessorElements) {
        if (!CollectionUtils.isEmpty(configProcessorElements)) {
            Iterator i = configProcessorElements.iterator();
            while (i.hasNext()) {
                Element configProcessorElement = (Element) i.next();
                configProcessors.add(new RuntimeBeanReference(configProcessorElement.getAttribute(REF_ATTR)));
            }
        }
    }

    @SuppressWarnings("unchecked")
    private void registerEndpointInterceptorIfNecessary(Element securedElement, ParserContext parserContext, ManagedSet interceptors,
        String authManager, String accessManager) {
        if (securedElement.hasChildNodes()) {
            BeanDefinitionBuilder interceptorBuilder = BeanDefinitionBuilder.genericBeanDefinition(ENDPOINT_INTERCEPTOR_CLASS_NAME);
            interceptorBuilder.addPropertyReference(AUTH_MANAGER_PROPERTY, authManager);
            interceptorBuilder.addPropertyReference(ACCESS_MANAGER_PROPERTY, accessManager);

            BeanDefinitionBuilder endpointDefSourceBuilder = BeanDefinitionBuilder.genericBeanDefinition(ENDPOINT_DEFINITION_SOURCE_CLASS_NAME);

            HashMap endpointMap = new HashMap();
            List securedChannelElements = DomUtils.getChildElementsByTagName(securedElement, SECURED_CHANNEL_ELEMENT);
            if (!CollectionUtils.isEmpty(securedChannelElements)) {
                Iterator i = securedChannelElements.iterator();
                while (i.hasNext()) {
                    Element securedChannel = (Element) i.next();
                    String access = securedChannel.getAttribute(ACCESS_ATTR);
                    String channel = securedChannel.getAttribute(CHANNEL_ATTR);
                    Object attributeDefinition = parseConfigAttributeDefinition(access);
                    endpointMap.put(channel, attributeDefinition);
                }
            }

            LinkedHashMap requestMap = new LinkedHashMap();
            List securedEndpointPathElements = DomUtils.getChildElementsByTagName(securedElement, SECURED_ENDPOINT_PATH_ELEMENT);
            if (!CollectionUtils.isEmpty(securedEndpointPathElements)) {
                Iterator i = securedEndpointPathElements.iterator();
                while (i.hasNext()) {
                    Element securedPath = (Element) i.next();
                    String access = securedPath.getAttribute(ACCESS_ATTR);
                    RequestKey pattern = new RequestKey(securedPath.getAttribute(PATTERN_ATTR));
                    Object attributeDefinition = parseConfigAttributeDefinition(access);
                    requestMap.put(pattern, attributeDefinition);
                }
            }

            endpointDefSourceBuilder.addConstructorArgValue(new AntUrlPathMatcher());
            endpointDefSourceBuilder.addConstructorArgValue(requestMap);
            endpointDefSourceBuilder.addConstructorArgValue(endpointMap);

            String endpointDefSourceId = ParsingUtils.registerInfrastructureComponent(securedElement, parserContext, endpointDefSourceBuilder);
            interceptorBuilder.addPropertyReference(OBJECT_DEF_SOURCE_PROPERTY, endpointDefSourceId);
            String interceptorId = ParsingUtils.registerInfrastructureComponent(securedElement, parserContext, interceptorBuilder);
            interceptors.add(new RuntimeBeanReference(interceptorId));
        }
    }

    @SuppressWarnings("unchecked")
    private void registerEndpointProcessor(ParserContext parserContext, ManagedSet configProcessors, ManagedList advisors, Element securedElement,
        String brokerId) {
        BeanDefinitionBuilder endpointProcessorBuilder = BeanDefinitionBuilder.genericBeanDefinition(ENDPOINT_PROCESSOR_CLASS_NAME);
        endpointProcessorBuilder.addConstructorArgValue(advisors);
        ParsingUtils.registerInfrastructureComponent(securedElement, parserContext, endpointProcessorBuilder, brokerId
            + BeanIds.ENDPOINT_PROCESSOR_SUFFIX);
        configProcessors.add(new RuntimeBeanReference(brokerId + BeanIds.ENDPOINT_PROCESSOR_SUFFIX));
    }

    @SuppressWarnings("unchecked")
    private void registerExceptionTranslation(Element element, ParserContext parserContext, ManagedList advisors, ManagedSet translators,
        List exceptionTranslatorElements) {

        if (!CollectionUtils.isEmpty(exceptionTranslatorElements)) {
            Iterator i = exceptionTranslatorElements.iterator();
            while (i.hasNext()) {
                Element exceptionTranslatorElement = (Element) i.next();
                translators.add(new RuntimeBeanReference(exceptionTranslatorElement.getAttribute(REF_ATTR)));
            }
        }

        BeanDefinitionBuilder advisorBuilder = BeanDefinitionBuilder.genericBeanDefinition(SERVICE_MESSAGE_ADVISOR_CLASS_NAME);
        BeanDefinitionBuilder exceptionTranslationBuilder = BeanDefinitionBuilder.genericBeanDefinition(EXCEPTION_TRANSLATION_CLASS_NAME);
        exceptionTranslationBuilder.addPropertyValue(EXCEPTION_TRANSLATORS_PROPERTY, translators);
        String exceptionTranslationId = ParsingUtils.registerInfrastructureComponent(element, parserContext, exceptionTranslationBuilder);
        advisorBuilder.addConstructorArgReference(exceptionTranslationId);
        String advisorId = ParsingUtils.registerInfrastructureComponent(element, parserContext, advisorBuilder);
        advisors.add(new RuntimeBeanReference(advisorId));
    }

    private void registerFlexRemotingAnnotationPostProcessorIfNecessary(Element source, ParserContext parserContext) {
        if (!parserContext.getRegistry().containsBeanDefinition(BeanIds.REMOTING_ANNOTATION_PROCESSOR)) {
            BeanDefinitionBuilder processorBuilder = BeanDefinitionBuilder.genericBeanDefinition(REMOTING_ANNOTATION_PROCESSOR_CLASS_NAME);
            ParsingUtils.registerInfrastructureComponent(source, parserContext, processorBuilder, BeanIds.REMOTING_ANNOTATION_PROCESSOR);
        }
    }

    private void registerHandlerAdapterIfNecessary(Element element, ParserContext parserContext) {
        // Make sure we only ever register one MessageBrokerHandlerAdapter
        if (!parserContext.getRegistry().containsBeanDefinition(BeanIds.MESSAGE_BROKER_HANDLER_ADAPTER)) {
            BeanDefinitionBuilder handlerAdapterBuilder = BeanDefinitionBuilder.genericBeanDefinition(MESSAGE_BROKER_HANDLER_ADAPTER_CLASS_NAME);

            ParsingUtils.registerInfrastructureComponent(element, parserContext, handlerAdapterBuilder, BeanIds.MESSAGE_BROKER_HANDLER_ADAPTER);
        }
    }

    @SuppressWarnings("unchecked")
    private void registerHandlerMappings(Element parent, ParserContext parserContext, List mappingPatternElements) {
        BeanDefinitionBuilder handlerMappingBuilder = BeanDefinitionBuilder.genericBeanDefinition(DEFAULT_HANDLER_MAPPING_CLASS_NAME);

        if (StringUtils.hasText(parent.getAttribute(MAPPING_ORDER_ATTR))) {
            handlerMappingBuilder.addPropertyValue(ORDER_PROPERTY, Integer.parseInt(parent.getAttribute(MAPPING_ORDER_ATTR)));
        }

        Map mappings = new HashMap();
        if (CollectionUtils.isEmpty(mappingPatternElements)) {
            mappings.put(DEFAULT_MAPPING_PATH, parent.getAttribute(ID_ATTRIBUTE));
        } else {
            Iterator i = mappingPatternElements.iterator();
            while (i.hasNext()) {
                Element mappingElement = (Element) i.next();
                mappings.put(mappingElement.getAttribute(PATTERN_ATTR), parent.getAttribute(ID_ATTRIBUTE));
            }
        }

        handlerMappingBuilder.addPropertyValue(URL_MAP_PROPERTY, mappings);
        ParsingUtils.registerInfrastructureComponent(parent, parserContext, handlerMappingBuilder, parent.getAttribute(ID_ATTRIBUTE)
            + BeanIds.HANDLER_MAPPING_SUFFIX);
    }

    @SuppressWarnings("unchecked")
    private void registerLoginCommand(String brokerId, ParserContext parserContext, ManagedSet configProcessors, Element securedElement,
        String authManager, boolean perClientAuthentication) {

        String loginCommandId = brokerId + BeanIds.LOGIN_COMMAND_SUFFIX;

        BeanDefinitionBuilder loginCommandBuilder = BeanDefinitionBuilder.genericBeanDefinition(LOGIN_COMMAND_CLASS_NAME);
        loginCommandBuilder.addConstructorArgReference(authManager);
        loginCommandBuilder.addPropertyValue(PER_CLIENT_AUTHENTICATION_PROPERTY, perClientAuthentication);

        ParsingUtils.registerInfrastructureComponent(securedElement, parserContext, loginCommandBuilder, loginCommandId);
        configProcessors.add(new RuntimeBeanReference(loginCommandId));
    }

    @SuppressWarnings("unchecked")
    private void registerMessageInterception(Element element, ParserContext parserContext, ManagedList advisors, ManagedSet interceptors,
        List messageInterceptorElements) {

        if (!CollectionUtils.isEmpty(messageInterceptorElements)) {
            Iterator i = messageInterceptorElements.iterator();
            while (i.hasNext()) {
                Element messageProcessorElement = (Element) i.next();
                interceptors.add(new RuntimeBeanReference(messageProcessorElement.getAttribute(REF_ATTR)));
            }
        }

        BeanDefinitionBuilder advisorBuilder = BeanDefinitionBuilder.genericBeanDefinition(SERVICE_MESSAGE_ADVISOR_CLASS_NAME);
        BeanDefinitionBuilder messageInterceptionBuilder = BeanDefinitionBuilder.genericBeanDefinition(MESSAGE_INTERCEPTION_CLASS_NAME);
        messageInterceptionBuilder.addPropertyValue(MESSAGE_INTERCEPTORS_PROPERTY, interceptors);
        String messageInterceptionId = ParsingUtils.registerInfrastructureComponent(element, parserContext, messageInterceptionBuilder);
        advisorBuilder.addConstructorArgReference(messageInterceptionId);
        String advisorId = ParsingUtils.registerInfrastructureComponent(element, parserContext, advisorBuilder);
        advisors.add(new RuntimeBeanReference(advisorId));
    }

    private void validateMessageBroker(Element element, ParserContext parserContext) {

        if (!FlexConfigurationManager.DEFAULT_CONFIG_PATH.equals(element.getAttribute(SERVICES_CONFIG_PATH_ATTR))
            && StringUtils.hasText(element.getAttribute(CONFIGURATION_MANAGER_ATTR))) {
            parserContext.getReaderContext().error(
                "The " + SERVICES_CONFIG_PATH_ATTR + " cannot be set when using a custom " + CONFIGURATION_MANAGER_ATTR
                    + " reference.  Set the configurationPath on the custom ConfigurationManager instead.", element);

        }
    }

}