- Shopping Bag ( 0 items )
Servlets and JavaServer Pages is the first complete guide to building dynamic Java-based Web applications using the new JavaServer Pages 2.0 and Servlets 2.4. Servlets and JavaServer Pages (JSP) provide a robust solution to developing large, complex Web applications, including multiserver projects. In addition to built-in security, portability, and a Web server, they offer developers the freedom to work with any operating system that supports Java—be it Linux, Windows, OSX, or Solaris.
This authoritative book begins by explaining how to set up a Servlet and JSP development environment, including a discussion of containers, Java support, and installing and configuring Tomcat. The authors then thoroughly explore servlets and JSP, including significant coverage of custom tag libraries, newly available filters, and popular servlet and JSP design patterns. Readers can then test-drive the knowledge gained by constructing a book-support Web site.
Among the topics covered in-depth are:
The actual book-support site (www.jspbook.com) features frequently asked questions, working code examples, and references.
With Servlets and JavaServer Pages as their guide, readers will learn how to fully harness the power of these flexible Java technologies.
1. Setting up a Servlet and JSP Environment.
2. Java Servlets.
3. JavaServer Pages.
4. Exception Handling.
6. Custom Tag Libraries.
7. JavaServer Pages Standard Tag Library.
9. Managing State in a Web Application.
11. Design Patterns.
13. Multi-Client Support.
14. Database Connectivity.
References: Charsets(i18n?), web.xml Schema, TLD.
The goal of this preface is to briefly but accurately introduce this book and its content. The preface is broken into four main parts: about the authors, an overview of the book's content, a list of the conventions used throughout the book, and an explanation of the book's cover. All parts are relevant to the book; however, not all parts may be of personal interest to you. It is suggested at least the first two sections be read because they explain who wrote this book and what the book is about. The last two sections are not helpful unless you decide to read any portion of the book.
Two authors collaborated on this book: Jayson Falkner and Kevin Jones. Both Jayson and Kevin are well-known developers in the JavaServer Pages (JSP) and Servlets communities, and both authors have worked extensively with the technologies. Servlets and JavaServer Pages: The J2E Technology Web Tier originally started as Jayson's project; however, during the JavaOne 2002 conference the two authors met. It turns out Kevin was thinking of working on a similar title, and the two decided to collaborate.
Jayson is a J2EE developer from the United States. He started developing with J2EE just before JSP 1.1 and Servlets 2.2 were released and has been focusing on the technologies since. Jayson is best known as the Webmaster of JSP Insider,
http://www.jspinsider.com , and for asking far too many questions in the popular Servlet and JSP forums. Jayson has worked on numerous JSP titles and is constantly present at the popular Java conferences. Jayson participated on the JSR 152 expert group, JSP 2.0, and helped with the Tomcat 5 reference implementation.
Jayson prefers to think of himself as a tax-dodging student, who is currently working on a Ph.D. in bioinformatics at the University of Michigan; however, he also works professionally as a J2EE consult with Amberjack Software LLC. Open-source software and free Java development are Jayson's specialties. You can thank (or complain) to Jayson for dictating the use of Mozilla and Tomcat with this book.
You can get in touch with Jayson by sending an email to
Kevin is a longtime Java developer and educator, and has been involved in the training industry for the last twelve years. For the last eight years Kevin has been involved in writing and delivering Java training and consulting on various Java projects, and for the last four years has concentrated on J2EE and specifically Web technologies.
Kevin spoke at JavaOne in 2000 and was invited to become a member of JSR 53, the "Java Servlet 2.3 and JavaServer Pages 1.2 Specifications" and also JSR 52 "A Standard Tag Library for JavaServer Pages". Since then Kevin has successfully spoken at JavaOne in 2001 and 2002 as well as participating in JSR 154 (Servlets 2.4) and, like Jayson, in JSR 152.
Kevin is responsible for the Java curriculum at DevelopMentor, where he teaches the Essential Java Web Development class that covers much of the material in this book, as well as many other Java classes. You can reach Kevin at
firstname.lastname@example.org or through his Web site at
In this book you will find a few, hopefully delightful, things. The book is a complete guide to Servlets and JavaServer Pages and their practical use for developers familiar with HTML and basic Java. If you are unfamiliar with the terms Servlets and JavaServer Pages, think of this book as a complete guide to building dynamic, Java-based Web sites. It is assumed you understand Java and HTML. Never does the book attempt to test these two skills; however, code examples in this book do not include explanations of fundamental Java concepts and HTML syntax.
Before introducing the book's content, there are a few points worth mentioning in relation to competing technologies, especially since you are likely standing next to several books about building Web sites using the plethora of other "superior" technologies. At all times this book follows the open-source mindset—that is, software you need is free and you get all the source-code. It will cost you or your development team absolutely nothing to get and use all the software demonstrated, both directly and indirectly. In comparison to the primary competitor of Servlets and JSP, Microsoft's .NET and Microsoft's ASP .NET, you will have no software costs, no licensing costs, and the freedom to choose any operating system that supports Java, such as Linux, Windows, OSX, and Solaris. Compared to other open-source solutions, namely PHP or Perl, this book offers a truly robust solution to developing Web applications. You will get everything you need, including built-in security, portability, and a Web server. A Servlet and JSP-based Web application does not need an additional Web server, such as IIS or Apache, installed to serve up Web pages and provide encryption for secure connections. Additionally, Servlet and JSP-based code, even code for multiple Web sites being run on the same server, can literally be packaged up into one big file and moved between a development environment and a production environment, even if the two places are using different operating systems—you can not do this with technologies such as PHP or Perl. Additionally, Servlets and JSP are an official part of J2EE, Java's solution to the hardest problems of application programming. If you plan on programming the largest and most complex ofWeb applications (including multi-server projects), this book still provides relevant code—surely a bonus compared to other popular, open-source technologies thatare not meant for large Web applications.
The table of contents provides a complete list of the book's contents, but the titles of most chapters are meaningless to a new user of Servlets and JavaServer Pages. Here is a complete description of the book's content, divided by chapters, explaining why the chapter is in this book:
http://www.jspbook.com. The task is not difficult because it is little more than a rehash of the concepts covered in this book and recycling snippets of code, but the chapter nicely concludes the book and really proves you can build a good Web application based on the content of this manuscript.
http://www.jspbook.com. At the book support site you will find numerous things including current updates, FAQ, news about the book, working code examples, references, and a method to reach the authors. This book support site is not the standard publisher-supported site (and Addison-Wesley's site is quite nice), but it is something created and supported completely by the authors. You are encouraged to use the book support site as a place to aid your reading of the book and communicate with the authors.
InTextCodestyle. This style signifies that the word is a direct reference to a file, variable name, Object type, or any other specific code reference.
fookeyword appears in code, you should be suspect of its practical use. Some examples of places where foo appears include
com.jspbook.foopackage and code that is named with
fooappearing in the title. In the case of the
fookeyword means code in this package is not too helpful on its own. Instead,
com.jspbook.fooclasses are usually built to directly complement a helpful class appearing in the
com.jspbookpackage. When the
fookeyword appears in the title of code, perhaps a JSP named
Foo.jsp, it signals the whole page is slightly contrived. Be conscious of occurrences of the
fookeyword and do not focus on them but rather the point they illustrate.
http://jakarta.apache.org/tomcat. All code in this book is tested against Tomcat, and many screenshots show common behavior of the container. Be aware that Tomcat is the specific container in all of these cases, and different containers might have slightly different results. This warning does not imply that the code would not work in other containers; code should seamlessly work on any JSP 2.0 and Servlet 2.4 container. The mention is solely to prevent possible confusion that might arise from examples that give different styles of the same result when executed.Mozilla is the very popular open-source Web browser that is built with an emphasis on compliance to Internet standards. The results of a JSP or Servlet are almost always intended for rendering by a Web browser. In almost every screenshot the Web browser is visible. This browser is Mozilla,
http://www.mozilla.org, unless specifically mentioned otherwise. Mozilla was chosen because it is both a truly superb piece of software and because it behaves in a way that is to be expected by other Web browsers.
Posted February 13, 2004
Posted January 23, 2004
I was at the 57th Street store looking for a different book, and when they didn't have it on the shelf I peeked at this one because of the tiny little Addison Wesley logo down at the bottom of the binder. I opened the book to a random location and by the end of the first sentence I read I knew I had found a good one. I skimmed a couple of topics I was interested in, and was so impressed with the clear, succinct, intelligent style of presentation that I didn't bother looking at any other titles and headed straight for the checkout line. In keeping with Addison Wesley's usual standard of high quality, the book is written in a way that makes it easy to grasp the material quickly and thoroughly. Jayson and Kevin consistently find just the right depth of coverage that is appropriate for a web application developer without getting bogged down in details that would only be of interest to a J2EE container developer. They do move along pretty quickly though, and you won't get far if you don't have a reasonably good understanding of Java. If you feel a bit overwhelmed by this book, then you might want to get your feet wet first with something directed a little bit more toward the beginner--Perhaps start with Ivor Horton's 'Beginning Java 2' or Bruce Eckel's 'Thinking in Java', and then run through 'Core Servlets and JavaServer Pages' by Marty Hall. Then you'll be ready to quickly take your JSP/Servlet programming skills up to the expert level with this book.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.
Posted October 28, 2003
To build a web application that generates dynamic web pages leads you immediately to a crossroads. Do you stick to the old, original CGI, or do you use a newer, more powerful language? Of the latter, you might choose PHP, Perl or JSP/servlets. These are all free. But the book's authors argue strongly that the last choice is the most portable and expressive for large scale web applications, because it is used at the heart of J2EE for such problems. Experienced developers of PHP or Perl might reply that their languages are just as powerful for handling web apps. Indeed, a computer science theorist might say that if PHP and Perl are Turing complete (as I think they are), then they can certainly express anything JSP/servlets can, so what is the issue? To answer this, you can regard the book as written on two levels. The most immediate is when it offers a detailed exposition of the properties of JSP/servlets. But at a deeper level, it offers a rebuttal to the other languages, or indeed also to Microsoft's offering. In essence, by being an extension of java, JSP/servlets give you a programming language that is fully object oriented, which makes coding more robust and scalable. You also get the java built in security and exception handling. Plus all the internationalisation. By contrast, take Perl, for example. Very powerful at parsing, and incredibly compact notation. But the latter makes for harder debugging. And it is not very object oriented, so writing large code bodies can get awkward fast. But what about using Microsoft's offering? It really is on a technical par with JSP/servlets for most things. Perhaps the biggest advantage of the latter is simply the zero licensing cost. Followed by the greater mindshare in the marketplace. If you are a web developer and you are not totally committed to your current language, then it behooves you to at least consider the alternative presented in this book.Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.