Custom tags, also known as JSP tag extensions (because they
extend the set of built-in JSP tags), provide a way of encapsulating reusable functionality on
JSP pages. One of the major drawbacks of scripting environments such as JSP is that it’s
easy to quickly put together an application without thinking about how it will be maintained and
grown in the future. For example, the ability to generate dynamic content by using Java
code embedded in the page is a very powerful feature of the JSP specification. Custom tags
allow such functionality to be encapsulated into reusable components. Custom tags
provide a great way for the logic behind common and recurring
tasks to be wrapped up in an easy-to-use package.

It is necessary to know when to use tags as opposed to JavaBeans for wrapping up
reusable functionality. After all, JavaBeans are reusable components and the JSP specification
provides a built-in mechanism for integrating and utilizing the features provided by
JavaBeans. Although both technologies can be used to achieve the same goal, that of encapsulating and
abstracting data away from the JSP page, there are significant differences between the two.

JavaBeans are good general-purpose objects that encapsulate
state in a portable “bucket.” We will continue to use these in our examples because they make
great business objects. Tags are a web-specific technology. Tags are primarily for
generating presentation elements, and as such they primarily encapsulate behavior. In addition,
custom tags are aware of the environment in which they are running. For example,
custom tags have access to the same implicit objects as the ones available when developing JSP
pages: pageContext, request, response, session, and so on. JavaBeans, however, are components
that can be reused within any Java environment; hence, they don’t know about such JSP
specifics. Therefore, custom tags are a much better choice for encapsulating reusable
functionality that will be used on JSP pages. Keep in mind the following rules:

Use JavaBeans for representing and storing information and
state. An example is building JavaBeans to represent the business objects in your application.

Use custom tags to represent and implement actions that
occur on those JavaBeans, as well as logic related to the presentation of information. An
example from JSTL is iterating over a collection of objects or conditional logic.