Apache Tapestry 4 Tutorial - JavaServer Pages came to the rescue (Page 2 of 5 )
Technically, a JSP page is just the same servlet as it gets compiled into a servlet behind the scenes before it is shown to a Web application's user. However, from the developer's point of view, working with JSP pages is a completely different thing. You can have as much HTML in your page as needed, and if you want to use some Java code, you just insert a scriptlet, as in this example:
<p>Some nicely formatted HTML goes here</p>
<%
// And here is some Java code as needed by the page
String name = request.getParameter("firstName");
%>
<p>Hello <%= name %></p>
This was the original design of JSP technology. What can be better: designers can work on their pieces of HTML, Java programmers can work on their pieces of code, and whatever is generated in the code can be easily inserted into HTML using a simple notation.
But this holds true only for simple pages with limited functionality. As the dynamic part of the page becomes more complex, Java unavoidably gets mixed with HTML. Have a look at another example:
<%
for (int i = 1; i <= metaData.getColumnCount(); i++) {
if (metaData.getColumnType(i) == Types.DOUBLE) {
%>
<td align='right'>
<%= formatter.format(resultSet.getDouble(i)) %>
</td>
<%
} else {
%>
<td>
<%= resultSet.getObject(i).toString() %>
</td>
<%
}
}
%>
If you write such a page yourself and you know both HTML and Java, no problem, you can do this. However, many Java Web applications are created by a group of people, often with narrow specializations, and this kind of Java/HTML cocktail makes both designers and developers unhappy.
As a result, it was decided that scriptlets are a bad thing, and they should not be used. Instead, a set of tags was provided. If designers don't like Java code, they should be much happier working with tags.
The idea was to have all Java code in some separate Java class, referred to as a bean, and then you can use that bean from your JSP page by using a few simple tags like these:
<jsp:useBean id="myBean" class="com.example.MyBean"/>
Hello <jsp:getProperty name="myBean" property="firstName"/>
Again, the idea wasn't bad, especially for simple pages. But for anything more complex the existing set of tags was severely limiting.
Of course, there was an opportunity to write your own custom tags and do in them everything you can imagine. But writing custom tags isn't for the fainthearted; one would need a pretty good understanding of the details of JSP technology to do that. Also, if you wanted to output some HTML in your custom tag, you would have to print it out in the same way as in a servlet.
Still, many developers produced numerous libraries of custom tags, and one such library, JSTL (JavaServer Pages Standard Tag Library), became a part of JSP standard.
However, obstinate developers kept using scriptlets in their JSP pages, saying that even the best custom tags do not give them the flexibility they require. This finally led to yet another addition to JSP - the Expression Language (EL).
Expression Language is truly powerful and convenient. The only problem is that to get rid of Java code inside of JSP pages, three different notations were introduced: standard tags, custom tags and EL expressions. All three have slightly different logic, naming scheme and rules, so that learning them in detail can be quite a nuisance! Have a look at this brief example, taken from real life code:
<tr>
<c:forEach var="column"
items="ID,Name,Quantity,Price,Total">
<th><c:out value="${column}"/></th>
</c:forEach>
</tr>
Does this look like a clean separation between HTML and code? I wouldn't say so.
Still, JavaServer Pages technology solved the tasks for which it was created. However, this is a rather low level technology. Creating a Web application from scratch using JSP pages and servlets required writing a lot of "boiler plate code" again and again, or copying and pasting large chunks of code - what a reliable source of hard to find errors!
Some kind of framework was required that would have all the basic stuff already written and would provide some sort of architectural solution for a future Java Web application. A number of such frameworks appeared; the most famous of them is Apache Struts. Typically, they embodied the MVC (Model-View-Controller) pattern, widely regarded as a panacea for many problems of software development.
Next: The Holy Trinity of software development >>
More Apache Articles
More By Alexander Kolesnikov
