Overview of JSP Syntax Elements

First, to make things more clear, here is a short overview of JSP syntax elements:

• Directives: These convey information regarding the JSP page as awhole.
• Scripting elements: These are Java coding elements such asdeclarations, expressions, scriptlets, and comments.
• Objects and scopes: JSP objects can be created either explicitly orimplicitly and are accessible within a given scope, such as fromanywhere in the JSP page or the session.
• Actions: These create objects or affect the output stream in the JSPresponse (or both).

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")

1) The include directive:

<%@ include file="header.html" %>

Static: adds the content from the value of the file attribute to the current page at translation time. The directive wasoriginally intended for static layout templates, like HTML headers.

2) The <jsp:include> standard action:

<jsp:include page="header.jsp" />

Dynamic: adds the content from the value of the page attribute to the current page at request time. Was intended more for dynamiccontent coming from JSPs.

3) The <c:import> JSTL tag:

<c:import url=”http://www.example.com/foo/bar.html” />

Dynamic: adds the content from the value of the URL attribute to the current page, at request time. It works a lot like<jsp:include>, but it’s more powerful and flexible: unlike theother two includes, the <c:import> url can be from outside theweb Container!

4) Preludes and codas:

Static: preludes and codas can be applied only to the beginnings and ends of pages.
You can implicitly include preludes (also called headers) and codas(also called footers) for a group of JSP pages by adding<include-prelude> and <include-coda> elements respectively withina <jsp-property-group> element in the Web application web.xml deployment descriptor. Read more here:
• Configuring Implicit Includes at the Beginning and End of JSPs
• Defining implicit includes

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 inJSP

• JSP tricks to make templatingeasier

• Very informative and easy to understand tutorial from coreservlet.com with beautifulexplanations that include <jsp:include> VS. <%@ include %>comparison table:
  Including Files and Applets in JSPPages

• Another nice tutorial from coreservlets.com related to tag libraries andtag files:
  Creating Custom JSP Tag Libraries: TheBasics

• The official Java EE 5 Tutorial with examples:
  Encapsulating Reusable ContentUsing TagFiles.

• This page from the official Java EE 5 tutorial should give you evenmore understanding:
  Reusing Content in JSPPages.

• This excerpt from the book "Pro JSP 2" also discuses why do you needa Tag File instead of using static include:
  Reusing Content with TagFiles

• Very useful guide right from the Oracle documentation:
  Static Includes Versus Dynamic Includes

Conclusion

Use the right tools for each task.

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):

• Use the include directive if the file changes rarely. It’s the fastest mechanism. If your container doesn’t automatically detect changes, you can force the changes to take effect by deleting the main page class file.
• Use the include action only for content that changes often, and if which page to include cannot be decided until the main page is requested.

Possible Duplicate Question

<@include> - The directive tag instructs the JSP compiler to merge contents of the included file into the JSP before creating the generated servlet code. It is the equivalent to cutting and pasting the text from your include page right into your JSP.

• Only one servlet is executed at run time.
• Scriptlet variables declared in the parent page can be accessed in the included page (remember, they are the same page).
• The included page does not need to able to be compiled as a standalone JSP. It can be a code fragment or plain text. The included page will never be compiled as a standalone. The included page can also have any extension, though .jspf has become a conventionally used extension.
• One drawback on older containers is that changes to the include pages may not take effect until the parent page is updated. Recent versions of Tomcat will check the include pages for updates and force a recompile of the parent if they're updated.
• A further drawback is that since the code is inlined directly into the service method of the generated servlet, the method can grow very large. If it exceeds 64 KB, your JSP compilation will likely fail.

<jsp:include> - The JSP Action tag on the other hand instructs the container to pause the execution of this page, go run the included page, and merge the output from that page into the output from this page.

• Each included page is executed as a separate servlet at run time.
• Pages can conditionally be included at run time. This is often useful for templating frameworks that build pages out of includes. The parent page can determine which page, if any, to include according to some run-time condition.
• The values of scriptlet variables need to be explicitly passed to the include page.
• The included page must be able to be run on its own.
• You are less likely to run into compilation errors due to the maximum method size being exceeded in the generated servlet class.

Depending on your needs, you may either use <@include> or <jsp:include>

Main advantage of <jsp:include /> over <%@ include > is:

<jsp:include /> allows to pass parameters

<jsp:include page="inclusion.jsp">    <jsp:param name="menu" value="objectValue"/></jsp:include>

which is not possible in <%@include file="somefile.jsp" %>