Class AbstractView

    • Field Detail


        public static final java.lang.String DEFAULT_CONTENT_TYPE
        Default content type. Overridable as bean property.
        See Also:
        Constant Field Values
    • Constructor Detail

      • AbstractView

        public AbstractView()
    • Method Detail

      • setContentType

        public void setContentType(@Nullable
                                   java.lang.String contentType)
        Set the content type for this view. Default is "text/html;charset=ISO-8859-1".

        May be ignored by subclasses if the view itself is assumed to set the content type, e.g. in case of JSPs.

      • getContentType

        public java.lang.String getContentType()
        Return the content type for this view.
        Specified by:
        getContentType in interface View
        the content type String (optionally including a character set), or null if not predetermined
      • setRequestContextAttribute

        public void setRequestContextAttribute(@Nullable
                                               java.lang.String requestContextAttribute)
        Set the name of the RequestContext attribute for this view. Default is none.
      • getRequestContextAttribute

        public java.lang.String getRequestContextAttribute()
        Return the name of the RequestContext attribute, if any.
      • setAttributesCSV

        public void setAttributesCSV(@Nullable
                                     java.lang.String propString)
                              throws java.lang.IllegalArgumentException
        Set static attributes as a CSV string. Format is: attname0={value1},attname1={value1}

        "Static" attributes are fixed attributes that are specified in the View instance configuration. "Dynamic" attributes, on the other hand, are values passed in as part of the model.

      • setAttributes

        public void setAttributes(java.util.Properties attributes)
        Set static attributes for this view from a java.util.Properties object.

        "Static" attributes are fixed attributes that are specified in the View instance configuration. "Dynamic" attributes, on the other hand, are values passed in as part of the model.

        This is the most convenient way to set static attributes. Note that static attributes can be overridden by dynamic attributes, if a value with the same name is included in the model.

        Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in XML bean definitions.

        See Also:
      • setAttributesMap

        public void setAttributesMap(@Nullable
                                     java.util.Map<java.lang.String,?> attributes)
        Set static attributes for this view from a Map. This allows to set any kind of attribute values, for example bean references.

        "Static" attributes are fixed attributes that are specified in the View instance configuration. "Dynamic" attributes, on the other hand, are values passed in as part of the model.

        Can be populated with a "map" or "props" element in XML bean definitions.

        attributes - a Map with name Strings as keys and attribute objects as values
      • getAttributesMap

        public java.util.Map<java.lang.String,java.lang.Object> getAttributesMap()
        Allow Map access to the static attributes of this view, with the option to add or override specific entries.

        Useful for specifying entries directly, for example via "attributesMap[myKey]". This is particularly useful for adding or overriding entries in child view definitions.

      • getStaticAttributes

        public java.util.Map<java.lang.String,java.lang.Object> getStaticAttributes()
        Return the static attributes for this view. Handy for testing.

        Returns an unmodifiable Map, as this is not intended for manipulating the Map but rather just for checking the contents.

        the static attributes in this view
      • setExposePathVariables

        public void setExposePathVariables(boolean exposePathVariables)
        Specify whether to add path variables to the model or not.

        Path variables are commonly bound to URI template variables through the @PathVariable annotation. They're are effectively URI template variables with type conversion applied to them to derive typed Object values. Such values are frequently needed in views for constructing links to the same and other URLs.

        Path variables added to the model override static attributes (see setAttributes(Properties)) but not attributes already present in the model.

        By default this flag is set to true. Concrete view types can override this.

        exposePathVariables - true to expose path variables, and false otherwise
      • isExposePathVariables

        public boolean isExposePathVariables()
        Return whether to add path variables to the model or not.
      • setExposeContextBeansAsAttributes

        public void setExposeContextBeansAsAttributes(boolean exposeContextBeansAsAttributes)
        Set whether to make all Spring beans in the application context accessible as request attributes, through lazy checking once an attribute gets accessed.

        This will make all such beans accessible in plain ${...} expressions in a JSP 2.0 page, as well as in JSTL's c:out value expressions.

        Default is "false". Switch this flag on to transparently expose all Spring beans in the request attribute namespace.

        NOTE: Context beans will override any custom request or session attributes of the same name that have been manually added. However, model attributes (as explicitly exposed to this view) of the same name will always override context beans.

        See Also:
      • setExposedContextBeanNames

        public void setExposedContextBeanNames(java.lang.String... exposedContextBeanNames)
        Specify the names of beans in the context which are supposed to be exposed. If this is non-null, only the specified beans are eligible for exposure as attributes.

        If you'd like to expose all Spring beans in the application context, switch the "exposeContextBeansAsAttributes" flag on but do not list specific bean names for this property.

      • setBeanName

        public void setBeanName(@Nullable
                                java.lang.String beanName)
        Set the view's name. Helpful for traceability.

        Framework code must call this when constructing views.

        Specified by:
        setBeanName in interface BeanNameAware
        beanName - the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the BeanFactoryUtils.originalBeanName(String) method to extract the original bean name (without suffix), if desired.
      • getBeanName

        public java.lang.String getBeanName()
        Return the view's name. Should never be null, if the view was correctly configured.
      • createMergedOutputModel

        protected java.util.Map<java.lang.String,java.lang.Object> createMergedOutputModel(@Nullable
                                                                                           java.util.Map<java.lang.String,?> model,
                                                                                           HttpServletRequest request,
                                                                                           HttpServletResponse response)
        Creates a combined output Map (never null) that includes dynamic values and static attributes. Dynamic values take precedence over static attributes.
      • createRequestContext

        protected RequestContext createRequestContext(HttpServletRequest request,
                                                      HttpServletResponse response,
                                                      java.util.Map<java.lang.String,java.lang.Object> model)
        Create a RequestContext to expose under the specified attribute name.

        The default implementation creates a standard RequestContext instance for the given request and model. Can be overridden in subclasses for custom instances.

        request - current HTTP request
        model - combined output Map (never null), with dynamic values taking precedence over static attributes
        the RequestContext instance
        See Also:
        setRequestContextAttribute(java.lang.String), RequestContext
      • prepareResponse

        protected void prepareResponse(HttpServletRequest request,
                                       HttpServletResponse response)
        Prepare the given response for rendering.

        The default implementation applies a workaround for an IE bug when sending download content via HTTPS.

        request - current HTTP request
        response - current HTTP response
      • renderMergedOutputModel

        protected abstract void renderMergedOutputModel(java.util.Map<java.lang.String,java.lang.Object> model,
                                                        HttpServletRequest request,
                                                        HttpServletResponse response)
                                                 throws java.lang.Exception
        Subclasses must implement this method to actually render the view.

        The first step will be preparing the request: In the JSP case, this would mean setting model objects as request attributes. The second step will be the actual rendering of the view, for example including the JSP via a RequestDispatcher.

        model - combined output Map (never null), with dynamic values taking precedence over static attributes
        request - current HTTP request
        response - current HTTP response
        java.lang.Exception - if rendering failed
      • exposeModelAsRequestAttributes

        protected void exposeModelAsRequestAttributes(java.util.Map<java.lang.String,java.lang.Object> model,
                                                      HttpServletRequest request)
                                               throws java.lang.Exception
        Expose the model objects in the given map as request attributes. Names will be taken from the model Map. This method is suitable for all resources reachable by RequestDispatcher.
        model - a Map of model objects to expose
        request - current HTTP request
      • createTemporaryOutputStream

        protected createTemporaryOutputStream()
        Create a temporary OutputStream for this view.

        This is typically used as IE workaround, for setting the content length header from the temporary stream before actually writing the content to the HTTP response.

      • writeToResponse

        protected void writeToResponse(HttpServletResponse response,
        Write the given temporary OutputStream to the HTTP response.
        response - current HTTP response
        baos - the temporary OutputStream to write
        Throws: - if writing/flushing failed
      • toString

        public java.lang.String toString()
        toString in class java.lang.Object
      • formatViewName

        protected java.lang.String formatViewName()