Web Applications with Java/JSP

Linux's history as an enthusiast's playground has always made it a fun place to work for programmers. Combine the fun of Linux with the power of Java and JSP, and quickly build secure multi-tier Web applications using the latest technologies.

First, this method obtains a connection from a database connection
pool and then determines if the Task is being created from scratch or
updated (although our UI doesn't offer an “update” method yet, this class
has been designed to allow updates). In each case, a parameterized
SQL statement is prepared and then filled with data passed in from the
calling code. Then, the statement is executed to write to the database,
and a new object is passed back to the caller. In the case of a new task,
the database-generated primary key is fetched from the statement after
execution in order to pass it back to the caller.

Under normal circumstances, methods such as “save” would be split out
into a separate class for easier organization, testing and architectural
separation, but I've left them in the servlet classes for simplicity.

The example's full source code and prebuilt WAR file are available
from the Linux Journal FTP server (see Resources), and I encourage you to download it and
play around with it. I've also included quick installation instructions for
Java and the Apache Tomcat servlet container, which will be required to
run the example application.

Java and Model-View-Controller Architecture

Often, Perl and PHP-based Web applications are composed of self-contained
scripts that perform one task: loading and displaying tasks, for
instance. This kind of thing is entirely possible using nothing but JSPs.
There are tag libraries that perform SQL queries, and you even can write
Java code directly into a JSP, although I haven't covered it here because
it's not necessary with the rich tools provided by the JSTL. On the
other hand, there are some philosophical and practical reasons not to
stuff everything into a single JSP. Most (Java) programmers subscribe
to the “model-view-controller” architecture, where code is separated
into logical units that model your problem domain (that would be the Task
and Client objects in our example), provide views of your data (that's
our JSPs) and control program flow (the servlets). This architectural
separation actually leads to quite a few practical benefits, including:

Error handling: if the controller is the only likely component to fail
(due to bad input, db connection failure and so on), you don't have
to worry about the view component failing during rendering, ruining
your output.

Most Java projects are going to be split up in this way, so I wrote my
example to illustrate this architecture, and I hope you consider using
this architecture in your Java projects too.

Sponsored by:

Webinar: 8 Signs You’re Beyond Cron

Scheduling Crontabs With an Enterprise Scheduler
11am CDT, April 29th

Join Linux Journal and Pat Cameron, Director of Automation Technology at HelpSystems, as they discuss the eight primary advantages of moving beyond cron job scheduling. In this webinar, you’ll learn about integrating cron with an enterprise scheduler.