It seems that there are two methods for templating with JSP. Including files with one of these statements
<%@ include file="foo.html" %>
<jsp:include page="foo.html" />
or using JSP tag files
// Save this as mytag.tag
<%@ tag description="Description" pageEncoding="UTF-8"%>
<html>
<head>
</head>
<body>
<jsp:doBody/>
</body>
</html>
And in another JSP page call it with
<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
<t:mytag>
<h1>Hello World</h1>
</t:mytag>
So which method should I use? Is one now considered deprecated or are they both valid and cover different use cases?
Edit
Isn't using this tag file the same as using an include?
// Save this as product.tag
<%@ tag description="Product templage" pageEncoding="UTF-8"%>
<%@ tag import="com.myapp.Product" %>
<%@ attribute name="product" required="true" type="com.myapp.Product"%>
Product name: ${product.name} <br/>
Quantity: ${product.quantity} <br/>
And call it on another JSP with
<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
<t:product>
<c:forEach items="${cart.products}" var="product">
<t:product product="${product}"/>
</c:forEach>
</t:product>
That seems to me to be the very same as using an include and passing parameters to it. So are Tag Files the same as includes?
Overview of JSP Syntax Elements
First, to make things more clear, here is a short overview of JSP syntax elements:
How content is included in JSP
There are several mechanisms for reusing content in a JSP file.
The following 4 mechanisms to include content in JSP can be categorized as direct reuse:
(for the first 3 mechanisms quoting from "Head First Servlets and JSP")
Tag File is an indirect method of content reuse, the way of encapsulating reusable content. A Tag File is a source file that contains a fragment of JSP code that is reusable as a custom tag.
The PURPOSE of includes and Tag Files is different.
Tag file (a concept introduced with JSP 2.0) is one of the options for creating custom tags. It's a faster and easier way to build custom tags. Custom tags, also known as tag extensions, are JSP elements that allow custom logic and output provided by other Java components to be inserted into JSP pages. The logic provided through a custom tag is implemented by a Java object known as a tag handler.
Some examples of tasks that can be performed by custom tags include operating on implicit objects, processing forms, accessing databases and other enterprise services such as email and directories, and implementing flow control.
Regarding your Edit
Maybe in your example (in your "Edit" paragraph), there is no difference between using direct include and a Tag File. But custom tags have a rich set of features. They can
Be customized by means of attributes passed from the calling page.
Pass variables back to the calling page.
Access all the objects available to JSP pages.
Communicate with each other. You can create and initialize a JavaBeans component, create a public EL variable that refers to that bean in one tag, and then use the bean in another tag.
Be nested within one another and communicate by means of private variables.
Also read this from "Pro JSP 2": Understanding JSP Custom Tags.
Useful reading
Difference between include directive and include action in JSP
JSP tricks to make templating easier
Very informative and easy to understand tutorial from coreservlet.com with beautiful explanations that include
<jsp:include> VS. <%@ include %>comparison table:Including Files and Applets in JSP Pages
Another nice tutorial from coreservlets.com related to tag libraries and tag files:
Creating Custom JSP Tag Libraries: The Basics
The official Java EE 5 Tutorial with examples:
Encapsulating Reusable Content Using Tag Files.
This page from the official Java EE 5 tutorial should give you even more understanding:
Reusing Content in JSP Pages.
This excerpt from the book "Pro JSP 2" also discuses why do you need a Tag File instead of using static include:
Reusing Content with Tag Files
Very useful guide right from the Oracle documentation:
Static Includes Versus Dynamic Includes
Conclusion
Use Tag Files as a quick and easy way of creating custom tags that can help you encapsulate reusable content.
As for the including content in JSP (quote from here):