public boolean isExposeModelAsRequestAttributes() {
        return exposeModelAsRequestAttributes;
    }

    public void setExposeModelAsRequestAttributes(boolean exposeModelAsRequestAttributes) {
        this.exposeModelAsRequestAttributes = exposeModelAsRequestAttributes;
    }

    public boolean isExposeSpringMacroHelpers() {
        return exposeSpringMacroHelpers;
    }

    public void setExposeSpringMacroHelpers(boolean exposeSpringMacroHelpers) {
        this.exposeSpringMacroHelpers = exposeSpringMacroHelpers;
    }

    public void addContextAttribute(String name, Class<?> componentClass) {
        ContextAttributeConfiguration attributeConfiguration = new ContextAttributeConfiguration();
        attributeConfiguration.setName(name);
        attributeConfiguration.setComponentClass(componentClass);
        addContextAttribute(name, attributeConfiguration);
    }

    @Override
    protected void setupContext(Map<String, Object> ctx, Node content, RenderableDefinition definition, RenderingModel<?> model, Object actionResult) {
        super.setupContext(ctx, content, definition, model, actionResult);
        ctx.putAll(RenderContext.get().getModel());
    }

    @Override
    protected String resolveTemplateScript(Node content, RenderableDefinition definition, RenderingModel<?> model, String actionResult) {
        return RenderContext.get().getTemplateScript();
    }

    @Override
    protected void onRender(Node content, RenderableDefinition definition, RenderingContext renderingCtx, Map<String, Object> ctx, String templateScript) throws RenderException {

        if (MgnlContext.isWebContext()) {

            @SuppressWarnings("unchecked")
            Map<String, Object> model = ctx;

            // Expose RequestContext instance for Spring macros.
            // See org.springframework.web.servlet.view.AbstractTemplateView#setExposeSpringMacroHelpers
            if (this.exposeSpringMacroHelpers) {
                model.put(AbstractTemplateView.SPRING_MACRO_REQUEST_CONTEXT_ATTRIBUTE,
                        new RequestContext(
                                MgnlContext.getWebContext().getRequest(),
                                MgnlContext.getWebContext().getResponse(),
                                MgnlContext.getWebContext().getServletContext(),
                                model));
            }

            // Expose the model objects in the given map as request attributes.
            // Necessary to let JSP tags access them, especially the spring form taglib.
            // See org.springframework.web.servlet.view.AbstractView#exposeModelAsRequestAttributes
            if (this.exposeModelAsRequestAttributes) {
                HttpServletRequest request = MgnlContext.getWebContext().getRequest();
                for (Map.Entry<String, Object> entry : model.entrySet()) {
                    String modelName = entry.getKey();
                    Object modelValue = entry.getValue();
                    if (modelValue != null) {
                        request.setAttribute(modelName, modelValue);
                    } else {
                        request.removeAttribute(modelName);
                    }
                }
            }
        }

        super.onRender(content, definition, renderingCtx, ctx, templateScript);
    }
}

    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        if (methodParameter.getParameterType().isAssignableFrom(Node.class)) {
            RenderingContext renderingContext = Components.getComponent(RenderingContext.class);
            if (hasSubsequentParametersOfType(methodParameter, Node.class)) {
                return renderingContext.getMainContent();
            }
            Node currentContent = renderingContext.getCurrentContent();
            return currentContent != null ? currentContent : renderingContext.getMainContent();
        }
        if (methodParameter.getParameterType().isAssignableFrom(Content.class)) {
            AggregationState aggregationState = MgnlContext.getAggregationState();
            if (hasSubsequentParametersOfType(methodParameter, Content.class)) {
                return aggregationState.getMainContent();
            }
            Content currentContent = aggregationState.getCurrentContent();
            return currentContent != null ? currentContent : aggregationState.getMainContent();
        }
        if (methodParameter.getParameterType().isAssignableFrom(TemplateDefinition.class)) {
            return Components.getComponent(RenderingContext.class).getRenderableDefinition();
        }
        if (methodParameter.getParameterType().isAssignableFrom(BlossomTemplateDefinition.class)) {
            return Components.getComponent(RenderingContext.class).getRenderableDefinition();
        }
        if (methodParameter.getParameterType().isAssignableFrom(AreaDefinition.class)) {
            return Components.getComponent(RenderingContext.class).getRenderableDefinition();
        }
        if (methodParameter.getParameterType().isAssignableFrom(BlossomAreaDefinition.class)) {
            return Components.getComponent(RenderingContext.class).getRenderableDefinition();
        }
        if (methodParameter.getParameterType().isAssignableFrom(AggregationState.class)) {
            return MgnlContext.getAggregationState();
        }
        if (methodParameter.getParameterType().isAssignableFrom(Context.class)) {

    protected BlossomDialogDescription postProcessDialogFactoryDialog(final BlossomDialogDescription dialogDescription) {

        Object factoryObject = dialogDescription.getFactoryMetaData().getFactoryObject();

        final Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);

        final List<Method> matchingMethods = new ArrayList<Method>();

        ReflectionUtils.doWithMethods(factoryClass, new ReflectionUtils.MethodCallback() {

            @Override
            public void doWith(Method method) {
                if (method.isAnnotationPresent(PreRegister.class) && method.equals(ClassUtils.getMostSpecificMethod(method, factoryClass))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("PreRegister annotation is not supported on static methods");
                    }
                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {
                        matchingMethods.add(method);
                    }
                }
            }
        });
        Collections.reverse(matchingMethods);

        final AtomicReference<BlossomDialogDescription> reference = new AtomicReference<BlossomDialogDescription>(dialogDescription);
        for (Method matchingMethod : matchingMethods) {
            Object returnValue = MethodInvocationUtils.invoke(matchingMethod, factoryObject, new ParameterResolver() {
                @Override
                public Object resolveParameter(Class<?> parameterType) {
                    if (parameterType.isAssignableFrom(BlossomDialogDescription.class)) {
                        return reference.get();
                    }

            return MgnlContext.getWebContext();
        }
        if (methodParameter.getParameterType().isAssignableFrom(User.class)) {
            return MgnlContext.getUser();
        }
        if (methodParameter.getParameterType().isAssignableFrom(MgnlUser.class)) {
            return MgnlContext.getUser();
        }
        if (methodParameter.getParameterType().isAssignableFrom(Channel.class)) {
            return MgnlContext.getAggregationState().getChannel();
        }
        if (methodParameter.getParameterType().isAssignableFrom(Theme.class)) {
            Site site = siteManager.getCurrentSite();
            if (site == null) {
                return null;
            }
            return siteFunctions.theme(site);
        }
        if (methodParameter.getParameterType().isAssignableFrom(Site.class)) {
            return siteManager.getCurrentSite();
        }

        return null;

        Object handler = templateDefinition.getHandler();

        final Class<?> factoryClass = AopUtils.getTargetClass(handler);

        final List<Method> matchingMethods = new ArrayList<Method>();

        ReflectionUtils.doWithMethods(factoryClass, new ReflectionUtils.MethodCallback() {

            @Override
            public void doWith(Method method) {
                if (method.isAnnotationPresent(PreRegister.class) && method.equals(ClassUtils.getMostSpecificMethod(method, factoryClass))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("PreRegister annotation is not supported on static methods");
                    }
                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomTemplateDefinition.class)) {

    protected BlossomDialogDescription postProcessTemplateDialog(final BlossomTemplateDefinition templateDefinition, final BlossomDialogDescription dialogDescription) {
        Object factoryObject = dialogDescription.getFactoryMetaData().getFactoryObject();

        final Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);

        final List<Method> matchingMethods = new ArrayList<Method>();

        ReflectionUtils.doWithMethods(factoryClass, new ReflectionUtils.MethodCallback() {

            @Override
            public void doWith(Method method) {
                if (method.isAnnotationPresent(PreRegister.class) && method.equals(ClassUtils.getMostSpecificMethod(method, factoryClass))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("PreRegister annotation is not supported on static methods");
                    }
                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {

    protected BlossomDialogDescription postProcessDialogFactoryDialog(final BlossomDialogDescription dialogDescription) {

        Object factoryObject = dialogDescription.getFactoryMetaData().getFactoryObject();

        final Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);

        final List<Method> matchingMethods = new ArrayList<Method>();

        ReflectionUtils.doWithMethods(factoryClass, new ReflectionUtils.MethodCallback() {

            @Override
            public void doWith(Method method) {
                if (method.isAnnotationPresent(PreRegister.class) && method.equals(ClassUtils.getMostSpecificMethod(method, factoryClass))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("PreRegister annotation is not supported on static methods");
                    }
                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {

                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {
                        matchingMethods.add(method);
                    }
                }
            }
        });
        Collections.reverse(matchingMethods);

        final AtomicReference<BlossomDialogDescription> reference = new AtomicReference<BlossomDialogDescription>(dialogDescription);
        for (Method matchingMethod : matchingMethods) {
            Object returnValue = MethodInvocationUtils.invoke(matchingMethod, factoryObject, new ParameterResolver() {
                @Override
                public Object resolveParameter(Class<?> parameterType) {
                    if (parameterType.isAssignableFrom(BlossomDialogDescription.class)) {
                        return reference.get();
                    }
                    if (parameterType.isAssignableFrom(BlossomTemplateDefinition.class)) {

    }

    @Override
    public ServletContext getServletContext() {
        return servletContext;
    }

    @Override
    public String getInitParameter(String name) {
        return initParameters.get(name);
    }

    @Override
    public Enumeration getInitParameterNames() {
        return Collections.enumeration(initParameters.keySet());
    }

    public void addInitParameters(Map<String, String> map) {
        this.initParameters.putAll(map);
    }

    public void addInitParameter(String name, String value) {
        this.initParameters.put(name, value);
    }

    public String removeInitParameter(String name) {
        return initParameters.remove(name);
    }
}

        final Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);

        final List<Method> matchingMethods = new ArrayList<Method>();

        ReflectionUtils.doWithMethods(factoryClass, new ReflectionUtils.MethodCallback() {

            @Override
            public void doWith(Method method) {
                if (method.isAnnotationPresent(PreRegister.class) && method.equals(ClassUtils.getMostSpecificMethod(method, factoryClass))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("PreRegister annotation is not supported on static methods");
                    }
                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {

                    if (method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(BlossomDialogDescription.class)) {
                        matchingMethods.add(method);
                    }
                }
            }
        });
        Collections.reverse(matchingMethods);

        final AtomicReference<BlossomDialogDescription> reference = new AtomicReference<BlossomDialogDescription>(dialogDescription);
        for (Method matchingMethod : matchingMethods) {
            Object returnValue = MethodInvocationUtils.invoke(matchingMethod, factoryObject, new ParameterResolver() {
                @Override
                public Object resolveParameter(Class<?> parameterType) {
                    if (parameterType.isAssignableFrom(BlossomDialogDescription.class)) {
                        return reference.get();
                    }

    public SpringContent2BeanTransformer(AutowireCapableBeanFactory autowireCapableBeanFactory) {
        this.autowireCapableBeanFactory = autowireCapableBeanFactory;
    }

    public void setDefaultClass(Class<?> defaultClass) {
        this.defaultClass = defaultClass;
    }

    public void setTopLevelBeanName(String topLevelBeanName) {
        this.topLevelBeanName = topLevelBeanName;
    }

    @Override
    protected TypeDescriptor onResolveType(TypeMapping typeMapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
        if (resolvedType == null && defaultType == null && defaultClass != null) {
            defaultType = typeMapping.getTypeDescriptor(defaultClass);
        }
        return resolvedType == null ? defaultType : resolvedType;
    }

    @Override
    public Object newBeanInstance(TransformationState state, Map properties, ComponentProvider componentProvider) throws Content2BeanException {