The Spring Framework

## org.springframework.web.servlet.view.tiles2
Class TilesConfigurer

    java.lang.Object
      org.springframework.web.servlet.view.tiles2.TilesConfigurer

All Implemented Interfaces:
  DisposableBean, InitializingBean, ServletContextAware

    public class TilesConfigurer

extends Object
implements ServletContextAware, InitializingBean, DisposableBean

Helper class to configure Tiles2 for the Spring Framework. See http://tiles.apache.org for more information about Tiles, which basically is a templating mechanism for JSP-based web applications.

The TilesConfigurer simply configures a TilesContainer using a set of files containing definitions, to be accessed by `TilesView` instances.

TilesViews can be managed by any `ViewResolver`. For simple convention-based view resolution, consider using `UrlBasedViewResolver` with the "viewClass" property set to "org.springframework.web.servlet.view.tiles2.TilesView".

A typical TilesConfigurer bean definition looks as follows:

     <bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
       <property name="definitions">
         <list>
           <value>/WEB-INF/defs/general.xml</value>
           <value>/WEB-INF/defs/widgets.xml</value>
           <value>/WEB-INF/defs/administrator.xml</value>
           <value>/WEB-INF/defs/customer.xml</value>
           <value>/WEB-INF/defs/templates.xml</value>
         </list>
       </property>
     </bean>

The values in the list are the actual files containing the definitions.

Since:
  2.5
Author:
  Juergen Hoeller
See Also:
  `TilesView`, `UrlBasedViewResolver`

Field Summary
`protected Log` `logger`

Constructor Summary
`TilesConfigurer()`

Method Summary
`void` `afterPropertiesSet()` Creates and exposes a TilesContainer for this web application.
`protected TilesContainer` `createTilesContainer(ServletContext context)` Create a TilesContainer for this web application.
`void` `destroy()` Removes the TilesContainer from this web application.
`void` `setDefinitions(String[] definitions)` Set the Tiles definitions, i.e. the list of files containing the definitions.
`void` `setDefinitionsFactoryClass(Class definitionsFactoryClass)` Set the `DefinitionsFactory` implementation to use.
`void` `setPreparerFactoryClass(Class preparerFactoryClass)` Set the `PreparerFactory` implementation to use.
`void` `setServletContext(ServletContext servletContext)` Set the ServletContext that this object runs in.
`void` `setTilesProperties(Properties tilesProperties)` Set Tiles properties (equivalent to the ServletContext init-params in the Tiles documentation), overriding the default settings.
`void` `setUseMutableTilesContainer(boolean useMutableTilesContainer)` Set whether to use a MutableTilesContainer for this application.
`void` `setValidateDefinitions(boolean validateDefinitions)` Set whether to validate the Tiles XML definitions.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### logger

    protected final Log logger

Constructor Detail

### TilesConfigurer

    public TilesConfigurer()

Method Detail

### setDefinitions

    public void setDefinitions(String[] definitions)

  Set the Tiles definitions, i.e. the list of files containing the definitions. Default is "/WEB-INF/tiles.xml".

### setValidateDefinitions

    public void setValidateDefinitions(boolean validateDefinitions)

  Set whether to validate the Tiles XML definitions. Default is "true".

### setDefinitionsFactoryClass

    public void setDefinitionsFactoryClass(Class definitionsFactoryClass)

  Set the `DefinitionsFactory` implementation to use. Default is `UrlDefinitionsFactory`, operating on definition resource URLs.

  Specify a custom DefinitionsFactory, e.g. a UrlDefinitionsFactory subclass, to customize the creation of Tiles Definition objects. Note that such a DefinitionsFactory has to be able to handle `URL` source objects, unless you configure a different TilesContainerFactory.

### setPreparerFactoryClass

    public void setPreparerFactoryClass(Class preparerFactoryClass)

  Set the `PreparerFactory` implementation to use. Default is `BasicPreparerFactory`, creating shared instances for specified preparer classes.

  Specify `SimpleSpringPreparerFactory` to autowire `ViewPreparer` instances based on specified preparer classes, applying Spring's container callbacks as well as applying configured Spring BeanPostProcessors. If Spring's context-wide annotation-config has been activated, annotations in ViewPreparer classes will be automatically detected and applied.

  Specify `SpringBeanPreparerFactory` to operate on specified preparer names instead of classes, obtaining the corresponding Spring bean from the DispatcherServlet's application context. The full bean creation process will be in the control of the Spring application context in this case, allowing for the use of scoped beans etc. Note that you need to define one Spring bean definition per preparer name (as used in your Tiles definitions).

  See Also:
    `SimpleSpringPreparerFactory`, `SpringBeanPreparerFactory`

### setUseMutableTilesContainer

    public void setUseMutableTilesContainer(boolean useMutableTilesContainer)

  Set whether to use a MutableTilesContainer for this application. Default is "false".

### setTilesProperties

    public void setTilesProperties(Properties tilesProperties)

  Set Tiles properties (equivalent to the ServletContext init-params in the Tiles documentation), overriding the default settings.

### setServletContext

    public void setServletContext(ServletContext servletContext)

  Description copied from interface: `ServletContextAware`
  Set the ServletContext that this object runs in.

  Invoked after population of normal bean properties but before an init callback like InitializingBean's `afterPropertiesSet` or a custom init-method. Invoked after ApplicationContextAware's `setApplicationContext`.

  Specified by:
    `setServletContext` in interface `ServletContextAware`
  Parameters:
    `servletContext` - ServletContext object to be used by this object
  See Also:
    `InitializingBean.afterPropertiesSet()`, `ApplicationContextAware.setApplicationContext(org.springframework.context.ApplicationContext)`

### afterPropertiesSet

    public void afterPropertiesSet()
                            throws TilesException

  Creates and exposes a TilesContainer for this web application.

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`
  Throws:
    `TilesException` - in case of setup failure

### createTilesContainer

    protected TilesContainer createTilesContainer(ServletContext context)
                                           throws TilesException

  Create a TilesContainer for this web application.

  Parameters:
    `context` - this web application's ServletContext
  Returns:
    the TilesContainer to expose
  Throws:
    `TilesException` - in case of setup failure

### destroy

    public void destroy()
                 throws TilesException

  Removes the TilesContainer from this web application.

  Specified by:
    `destroy` in interface `DisposableBean`
  Throws:
    `TilesException` - in case of cleanup failure

The Spring Framework

Copyright © 2002-2008 The Spring Framework.