Professional JSP Excerpt
Part Four : Servlets versus
JSPs
JSPs
can be used for most purposes, but there are some scenarios where Servlets
are more appropriate. As well as components such as the "mediator"
Servlets used earlier in this chapter, Servlets are well suited for
handling binary data dynamically (for example, uploading files or creating
dynamic images), since they need not contain any display logic.
Consider the
following: a JSP needs to display a banner image based on who is referring
the user to the site. This can be done by using the IMG tag like this:
<%@ page import="com.ibm.jspredbook.*;" errorPage="error.jsp" %> <body bgcolor="#FFFFFF"> <!--the referer header is used to trap the url the user is coming from --> <IMG SRC="/servlets/ImgServlet?from=<%=request.getHeader("Referer")%>"></body> </html> The Servlet referenced
in the IMG tag, ImgServlet, is coded as:
package com.ibm.projsp;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.*;
public class ImageServlet extends HttpServlet {
private String docHome = ".";
public void service(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession(true);
ServletConfig config = getServletConfig();
ServletContext application = config.getServletContext();
File file = findFile(request, response);
if (file == null) {
return;
} else {
response.setContentType(application.getMimeType(file.getName()));
response.setContentLength((int) file.length());
sendFile(file, response);
}
}
protected File findFile(HttpServletRequest request,
HttpServletResponse response) throws IOException {
// We should store a flow-to-image mapping and return the appropriate
// File, without any platform-specific paths. Right now we will just
// return a GIF file.
File file = new File("c://weblogic//images/myimage.gif");
return file;
}
protected void sendFile(File file, HttpServletResponse response)
throws IOException {
int c = 0;
FileInputStream fileinputstream = null;
try {
ServletOutputStream servletoutputstream =
response.getOutputStream();
fileinputstream = new FileInputStream(file);
while ((c = fileinputstream.read()) != -1) {
servletoutputstream.write(c);
}
servletoutputstream.flush();
}
finally {
if (fileinputstream != null) {
fileinputstream.close();
}
}
}
}
This image can be
cached in memory and updated every minute or so as needed. Keeping the
data in memory and using a servlet can save time and improve performance
by not requiring access to the file system every time a request is
made.
Summary
We have examined how we architect systems using JSPs,
Servlets, and JavaBeans, discussed benefits and limitations of various
approaches and actually seen an example that evolves to satisfy the
constraints of the various architectures.
We discussed a variety of architectural patterns, each
of which we categorized as either a Page-Centric or Dispatcher type of
architecture. Page-Centric architectures have a JSP handling the request
directly, while Dispatcher architectures include a Servlet that handles
the request and delegates to a JSP.
The architectural patterns we examined are:
-
Page-View
(Page-Centric)
-
Page-View
with Bean (Page-Centric)
-
Mediator-View
(Dispatcher)
-
Mediator-Composite
View (Dispatcher)
-
Service-to-Workers
(Dispatcher)
As we continue to investigate new ways to build our
systems, we will continue to realize new architectural patterns.
Additionally, the specifications for these technologies continue to be
refined and improved in ways that will potentially demand modifications to
current architectural patterns and the realization of additional ones. The
ability (in the post-1.0 JSP specifications) to factor code and
implementation details into a Custom Tag that might be used in place of a
JavaBean is simply one example. The integration of these technologies more
closely with XML and XSLT is another.
This is certainly an exciting and important area of
technology that continues to change at a rapid pace. Hopefully, this
information will help you better understand the current state of affairs
with respect to JSP architectures, and thus feel better positioned to
follow the evolution of these architectural issues in the future.
We hope you enjoyed this excerpt. Professional
JSP is published by Wrox Press. | 
