Creating Custom Tags Using JSP

Basil Vandegriend — Thu, 24 Apr 2008 22:12:01 +0000

Java Server Pages (JSP) is a Java technology for rendering dynamic web pages. Unlike servlets written directly in Java, JSP files contain special markup to identify java or JSP code. The normal (non-markup) text is interpreted as HTML. Early in JSP's evolution, custom tags were introduced as a way of providing reusable functionality, particularly reusable UI widgets, across JSP files. The original mechanism for creating these custom tags was very clunky: each tag had to be written in Java code (similar to servlets) and required extra configuration in XML to package into a tag library.

As of JSP version 2.0, available since Java EE 1.4, there is now support for creating custom tags using only the JSP syntax. No Java or XML is required. Each individual custom tag corresponds to a tag file, which is nothing more than a JSP file with a .tag extension located in a special directory within the WAR file: /WEB-INF/tags.

Attributes can be supplied to the tag file using a JSP directive <%@attribute name="" required="{true|false}"%>. Attributes are referenced within the tag file like any other JSP variable using EL (the expression language).

This JSP tag library within your WAR can be referenced by other JSPs using the taglib directive: <%@taglib tagdir="/WEB-INF/tags" prefix="tags"%>.

The following example shows this in action. First the custom tag file WEB-INF/tags/title.tag:

<%@attribute name="title" required="true"%>
<%@tag description="Standard Title" pageEncoding="UTF-8"%>

${title}

Now a normal JSP file that uses this custom tag:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@taglib tagdir="/WEB-INF/tags" prefix="tags"%>

Prior to JSP 2.0 I have made reusable JSP fragments using the import directive, but this new mechanism is just as simple and much more convenient. Smart JSP editors can in fact provide lookup/completion functionality when you are invoking your custom tags.

The capabilities of these custom tags go far beyond what I have shown here. For more information see Sun's Custom Tags Tutorial.

The Reuse Trap in Software Design

Basil Vandegriend — Thu, 07 Sep 2006 15:00:39 +0000

I stared at my code on the screen, but inspiration wouldn't come. I was trying to design a new feature which shared some commonalities with the existing code base. In particular, there were a couple classes that I knew I could reuse. I just wasn't sure how they would have to be modified because I was still figuring out the structure of the new feature. This also was difficult - I didn't have a clear picture of how those reused classes would fit in. Around and around my thoughts went, without any progress. I was stuck in the reuse trap.

Does this story sound familiar? I have been ensnared by the reuse trap many times, especially early in my career. At first I labored in vain, wondering why I was making no progress, oblivious of the trap I was in. As I gained experience, I become aware of the reuse trap and learned techniques and skills to avoid or escape it.

The reuse trap is a term I coined to describe the situation when one becomes stuck trying to design new functionality while simultaneously attempting to reuse existing code that needs some modifications. I believe this happens because we are trying to solve two separate yet interrelated problems: one, implementing the new functionality, and two, modifying the code to be reused. The new functionality depends on the reusable code, and the way we modify this code depends on how it will be used by the new functionality. Trying to reason about both issues at the same time imposes too high a cognitive load, so we fail to make progress on either front.

How can we escape the reuse trap? Simply put, don't try to do two things at the same time. You need to produce the new functionality, so you can't avoid working on this problem. The solution, therefore, is to defer the code reuse problem. Trying to achieve reuse is the root cause of this trap, and is the key to escaping it. The first step is to just start developing the new functionality. You can reuse code, but only as is, like you would do for a third party library. If you need to modify it, then just ignore it (for now). When you reach points where you could reuse existing code with some modification, feel free to take a copy of this existing code and change it as needed. This is also called cut-and-paste reuse, which is generally frowned upon. The use of it here is only temporary, as you'll see. Your goal is to finish enough of the new functionality to know that the design will work. This may mean finishing it completely, or just writing a basic skeleton. In either case, once you reach this point the next step is to eliminate duplication in the code base. Any sections of new code that you copied (cut-and-pasted) from existing code will be primary targets for your efforts. During this step, it is helpful to follow a disciplined refactoring process as described in Martin Fowler's refactoring book.

In this second refactoring step, I deliberately omitted the word reuse and instead used the term eliminating duplication. Reuse implies thinking about the future - how can this code be re-used in a different context? By its very nature, it is more abstract, more uncertain, and thus more difficult to reason about. Eliminating duplication is more concrete and focused on what exists now, in the present. Adopting a mindset of eliminating duplication rather than up-front reuse therefore helps you avoid the reuse trap. This relates closely to some of the principles of Extreme Programming: "You ain't gonna need it", "Do the simplest thing that could possibly work", and "Once and only once".

As your design experience grows, it becomes easier to avoid the reuse trap. You become more adept at knowing how to modify existing code to reuse it without really having to think hard about the problem. This allows you to focus on the problem of developing the new functionality, which is also likely easier. Therefore, your overall cognitive load is reduced - you can solve both problems at once - and the reuse trap is avoided. However, even experienced developers will still encounter difficult situations for which their experience is insufficient. That is when you need to know how to escape the reuse trap.

Basil Vandegriend: Professional Software Development » reuse

Creating Custom Tags Using JSP

${title}

The Reuse Trap in Software Design