Struts with Tiles Framework

by Anuj Verma · Published 20/01/2015 · Updated 06/01/2018

Overview of Struts Tiles Framework
Templates
Configurie tiles framework in struts-config.xml files
Struts tiles tag library
Tiles Definition
Example for Tiles Framework

Overview of Struts Tiles Framework

In most of the Web application, we have used three different approaches to assembling Web pages.

The first approach

sometimes referred to as a straight JSP-based approach.
The JSP pages contain presentation logic along with HTML layout tags; there is no separation of the two.
This approach is typically used for smaller, less complicated Web applications.

The second approach

uses the JSP include directive.
It’s used by developers for larger Web applications.
Using the JSP include directive allows for more reuse, which reduces the total development and maintenance costs.

The third approach,

which is introduced in this session is Tiles (template-based approach),
describes a way to reduce the amount of redundant code a Web application contains and, at the same time,
allows you to separate the content from the layout better than the first two approaches.

Overview of Tiles

Tiles allows you to exploit the concept of JSP includes by providing a framework for defining and dynamically populating page layouts.
Each page layout is simply a JSP that defines a template frame (or outline) with placeholders for where content should go.
At run time, Tiles replaces the placeholders with their associated content, creating a complete page ad unique instance of the layout.
To accomplish this Tiles uses its concepts of definitions and attributes.
A Tiles definition creates a piece of content that Tiles can insert into a JSP using that definition’s name.
Each definition consists of a name (or identifier), a layout JSP, and a set of attributes associated with the definition.
To facilitate the use of definitions and attributes, Tiles uses an XML configuration file (tiles-defs.xml) for storing their definitions.
Tiles also provides a JSP tag library for defining definitions and attributes.

Tiles framework provides the following features.

Template capabilities
Dynamic page construction and loading
Screen definitions
Support for tile and layout reuse
Support for internationalization
Support for multiple channels

Templates

A template is a JSP page that uses a JSP custom tag library to describe the layout of a page.
The template acts as a definition for what the pages of an application will look like, without specifying the content.
The content is inserted into the template page at runtime.
One or more pages may use the same template.
The template file includes a body-content section.
This allows us to reuse the template for any page that has this generic format.
This one file can then control the layout of multiple pages.
If we need to modify the layout of the site, this is the only file you need to change-that is the real power of using a template-based approach.

The following example illustrates how the template will look like:

<% taglib uri="/WEB-INF/tlds/struts-tiles.tld" prefix="tiles" %> 	
	<html:html> 	
	<head><title> < tiles:getAsString name="title" /> 
	</title>
	</head>
		
	<body> 	
	<tiles:insert attribute="header"/> 	
	<tiles:insert attribute="menubar"/> 	
	<tiles:insert attribute="bodycontent"/> 	
	<tiles:insert attribute="footer"/> 
	
	</body> 	
	</html:html>

Configuring Struts-config.xml and tiles files

You must add the Tiles library to the Web application deployment descriptor before wecan use it. Add the following taglib element to the Web.xml file:

<taglib> 	
	<taglib-uri>/WEB-INF/tiles.tld</taglib-uri>	
	<taglib-location>/WEB-INF/tiles.tld</taglib-location>	
	</taglib>

Each page that needs to use the Tiles tag library must include the following line at the top:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

Configuring tiles with struts

To add the Tiles plug-in to a Struts application, you need to add the following plug-in element to the Struts configuration file

<plug-in ClassName="org.apache.struts.tiles.TilesPlugin">	
<set-property property="definitions-config" value="/WEB-INF/tiles-defs.xml"/>	
</plug-in>

The definitions-config initialization parameter specifies the XML file or files containing Tile definitions. If multiple filenames are used, they must be comma-separated.

Tiles tag Library

This section introduces the JSP custom tags used by the Tiles framework. The tags are very similar to the ones provided in any template-based framework, but Tiles contains more functionality.

Tag name	Description
add	Add an element to the surrounding list.
definition	Create a tile component definition.
get	Get the content from request scope that was put there by a put tag.
getAsString	Render the value of the specified tile/component/template attribute to the current JspWriter.
importAttribute	Import a tile’s attribute into the specified context.
initComponentDefinitions	Initialize a tile definitions factory.
insert	Insert a tiles component.
put	Put an attribute into a tile context.
putList	Declare a list that will be passed as an attribute.
useAttribute	Use an attribute value inside a page.

The insert Tag

The insert tag is responsible for inserting content into a page.
In a layout tile, the insert tag prescribes where the content will go using attribute values

Attributes of the insert tag

Attribute name	Description
attribute	The name of an attribute in the current tile/component context.
beanName	The name of the bean used as a value.
beanProperty	The name of the bean property. If specified, the value is retrieved from this property.
beanScope	The context scope the bean can be found within.
component	A string representing the URI of a tile or template.
controllerUrl	The URL of a controller called immediately before the page is inserted.
controllerClass	The class type of a controller called immediately before the page is inserted.
definition	The name of the definition to insert. Definitions are defined in a centralized file
flush	true or false. If true, the current page output stream is flushed before tile insertion.
ignore	If this attribute is set to true and the attribute specified by the name does not exist, simply return without writing anything. runtime exception to be thrown.
name	The name of an entity to insert.
page	A string representing the URI of a tile or template.
role	If the user is in the specified role, the tag is taken into account; otherwise, the tag is skipped and the content is not written out.
template	A string representing the URI of a tile or template.

The definition Tag

The definition tag is used to create a tile (template) definition as a bean.
The newly created bean will be saved under the specified id, in the requested scope.
The definition tag has the same syntax as the insert tag.
The new definition can extend a definition described in the definition factory (XML file) and may overload any previously defined parameters.

Attributes of the definition tag

Attribute name	Description
extends	The name of a parent definition that is used to initialize this new definition.
id	The name under which the newly created definition bean will be saved. This attribute is required.
page	URL of the template/component to insert. Same as template.
role	The role to check before inserting this definition.
scope	The variable scope in which the newly defined bean will be created.
template	A string representing the URL of a tile/component/template (a JSP page).

The put tag

The put tag is used to pass attributes to a tile component.
This tag can be used only inside the insert or definition tags.
The value (or content) of the put tag is specified using the value attribute or the tag body.
It is also possible to specify the type of the value.

Attribute name	Description
beanName	The name of the bean used to retrieve the value.
beanProperty	The property name in the bean
beanScope	The scope used to search for the bean.
content	Content that’s put into tile scope.
direct	How the content is handled: true means content is printed directly; false means content is included.
name	The name of the attribute.
role	If the user is in the specified role, the tag is taken into account. Otherwise, the tag is skipped and the content is not written out.
type	The content type. Valid values are "string", "page", "template", or "definition".
value	The attribute valuecan be a String or an Object.

Tiles Definition

Tiles definitions provide just such functionality.
A definition allows you to statically specify the attributes that are used by a template, which in turn allows you to specify only the page-specific attributes in your tiles.
There are two locations in which you can specify definitions: a JSP page or an XML file.

Declaring definition in JSP Page

<tiles:definition id="default" page="DefaultLayout.jsp" scope="request">	
<tiles:put name="header" value="/header.jsp" /> 
<tiles:put name="menubar" value="/menubar.jsp" /> 
<tiles:put name="footer" value="/footer.jsp" /> 
</tiles:definition>

The common files that were spread through the various tiles are now located in the definition file. This makes changing their values much easier. For instance, if we wanted to specify a different footer page, the only place to change it would be in the definition file.

Declaring definition in a configuration file

To use the XML approach, create an XML file that follows the syntax of the tiles-config.dtd file. The definition XML file should be placed in the WEB-INF directory.

<definition name="layout" path="/mainLayout.jsp">
	<put name="title" value="" /> 	
	<put name="header" value="/header.jsp" /> 	
	<put name="menu" value="/menubar.jsp" /> 	
	<put name="body" value="" /> 	
	<put name="footer" value="/footer.jsp" /> 	
	</definition> 
	
	<definition name= "search.page" extends= "layout"> 
	<put name="title" value="Search Page" /> 	
	<put name="body" value="/search.jsp" /> 	
	</definition>

Extending tiles definition

One of the most powerful features of tile definitions is the ability to create new definitions by extending existing ones. All attributes and properties of the parent definition are inherited, and you can override any attribute or property.
In the preceding example you are extending mainLayout.jsp to search.jsp.so the attribute and properties of the mainLayout.jsp are inherited to search.jsp page.

Using Definitions as Forwards in Struts

Tiles definitions can also be used as Struts forwards, instead of actual URLs. To use definitions in this manner, you first create the definitions.
In the Struts configuration file, you need to define the forwards that use these definitions:

<global-forwards> 	
	<forward name="main" path=" layout" /> 	
	</global-forwards>

In the preceding example instead of giving the full path of JSP page(/mainLayout.jsp) , we can specify only the definition of that page lyout.

Example for Tiles Framework

Display the hello.jsp page using tiles telmplate .Use tiles-def.xml, struts-config.xml for this purpose.

header.jsp

<%@ taglib prefix="html" uri="/WEB-INF/struts-html" %> 
	
	<table> 	
	<tr> 	
	<td>Javaskool WELCOME TO ALL</td> 	
	</tr> 	
	</table>

footer.jsp

<%@ taglib prefix="html" uri="/WEB-INF/struts-html" %> 
	
	<table> 	
	<tr> 	
	<td>©Copyright 2010-12, JavaSkool.com, All Rights Reserved</td> 	
	</tr> 	
	</table>

hello.jsp

<%@ taglib prefix="html" uri="/WEB-INF/struts-html" %> 	
	<html:html> 	
	Welcome to Tiles Framework 	
	</html:html>

Template.jsp

Template page is a JSP page, in which you can insert header.jsp, footer.jsp pages. You can use this template as a layout.

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %> 	
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %> 	
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %> 	
<%@ taglib prefix="tiles" uri="http://struts.apache.org/tags-tiles" %>	
	
	<html:html> 	
	<head> 	
	<title><tiles:getAsString name="title" ignore="true"/></title> 
	
	</head> 	
	<body> 
	<table > 	
	<tr><td><!-- Enter the Header here --> 	
	<tiles:insert attribute="header"/></td></tr> 	
	</table> 	
	
	<table> 	
	<tr><td><!--Body Section here --> 
	
	<tiles:insert attribute="body"/> 	
	</td></tr> 	
	</table> 
	
	<!--Footer Section here --> 
	
	<tiles:insert attribute="footer"/> 	
	</body> 	
	</html:html>

tiles-def.xml

It is a configuration file to define template page extending template page to other pages.

<?xml version="1.0" encoding="UTF-8"?> 
	
	<!DOCTYPE tiles-definitions PUBLIC "-//Apache Software Foundation//DTD Tiles Configuration 
1.1//EN" "http://jakarta.apache.org/struts/dtds/tiles-config_1_3.dtd">
		
	<tiles-definitions> 	
	<!--Master Template -->
	
	<definition name="MasterTemplate" page="/template.jsp"> 	
	<put name="title" type="String" value="Example" /> 	
	<put name="header" value="/header.jsp" /> 	
	<put name="body" value="/blank.jsp" /> 	
	<put name="footer" value="/footer.jsp" /> 	
	</definition> 
	
	<!hello page start-->
	
	<definition name="hello" extends="MasterTemplate"> 	
	<put name="title" type="string" value="Hello Page" /> 	
	<put name="body" value="/hello.jsp" /> 	
	</definition>

struts-config.xml

You need to add tiles plugin in struts-config.xml

<?xml version="1.0" encoding="ISO-8859-1"?> 
	
	<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" 
"http://jakarta.apache.org/struts/dtds/struts-config_1_3.dtd">	
	
	<struts-config> 	
	<plug-in className="org.apache.struts.tiles.TilesPlugin">	
	<set-property property="definitions-config" value="/WEB-INF/tiles-defs.xml" />	
	<set-property property="moduleAware" value="true" />	
	</plug-in> 	
	</struts-config>

Flow

template.jsp file contains the template for the application like header, body and footer.The actual data will populated at runtime using tiles tags.
tiles-def.xml file contains the definition for the template(template.jsp) and definition of the hello.jsp page which extended template.jsp.
All the jsp files will extend and override the required (body) content.