You can apply Spring Web MVC framework themes to set the overall look-and-feel of your application, thereby enhancing user experience. A theme is a collection of static resources, typically style sheets and images, that affect the visual style of the application.
To use themes in your web application, you must set up an implementation of the
org.springframework.ui.context.ThemeSource interface.
The WebApplicationContext interface extends
ThemeSource but delegates its
responsibilities to a dedicated implementation. By default the delegate
will be an
org.springframework.ui.context.support.ResourceBundleThemeSource
implementation that loads properties files from the root of the
classpath. To use a custom ThemeSource
implementation or to configure the base name prefix of the
ResourceBundleThemeSource, you can register a
bean in the application context with the reserved name
themeSource. The web application context
automatically detects that bean and starts using it.
When using the ResourceBundleThemeSource, a
theme is defined in a simple properties file. The
properties file lists the resources that make up the theme. Here is an
example:
styleSheet=/themes/cool/style.css background=/themes/cool/img/coolBg.jpg
The keys of the properties are the names that refer to the themed
elements from view code. For a JSP, you typically do this using the
spring:theme custom tag, which is very similar to the
spring:message tag. The following JSP fragment uses
the theme defined in the previous example to customize the look and
feel:
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%> <html> <head> <link rel="stylesheet" href="<spring:theme code="styleSheet"/>" type="text/css"/> </head> <body background="<spring:theme code="background"/>"> ... </body> </html>
By default, the ResourceBundleThemeSource
uses an empty base name prefix. As a result, the properties files are
loaded from the root of the classpath, so you would put the
cool.properties theme definition in a directory at
the root of the classpath, for example, in
/WEB-INF/classes. The
ResourceBundleThemeSource uses the standard Java
resource bundle loading mechanism, allowing for full
internationalization of themes. For example, we could have a
/WEB-INF/classes/cool_nl.properties that references a
special background image with Dutch text on it.
After you define themes, as in the preceding section, you decide
which theme to use. The DispatcherServlet will
look for a bean named themeResolver to find out
which ThemeResolver implementation to
use. A theme resolver works in much the same way as a
LocaleResolver. It detects the theme to
use for a particular request and can also alter the request's theme. The
following theme resolvers are provided by Spring:
Table 15.5. ThemeResolver
implementations
| Class | Description |
|---|---|
FixedThemeResolver | Selects a fixed theme, set using the
defaultThemeName property. |
SessionThemeResolver | The theme is maintained in the user's HTTP session. It only needs to be set once for each session, but is not persisted between sessions. |
CookieThemeResolver | The selected theme is stored in a cookie on the user-agent's machine. |
Spring also provides a
ThemeChangeInterceptor, which allows theme
changes on every request with a simple request parameter.