2020ok  Directory of FREE Online Books and FREE eBooks

Free eBooks > Computers & Internet > Web Development > Internet Commerce > Web Site Design > Advanced JavaServer Pages

Advanced JavaServer Pages

by David M. Geary

Download Book
(Respecting the intellectual property of others is utmost important to us, we make every effort to make sure we only link to legitimate sites, such as those sites owned by authors and publishers. If you have any questions about these links, please contact us.)

link 1

About Book

Aimed at the more experienced Java Web developer, Advanced JavaServer Pages covers leading-edge techniques for writing more maintainable Web applications in Java. Stressing custom tag libraries and other reusable components, this book is all you need to take your programming skills to the next level.

There are any number of good introductory texts on JavaServer Pages. This title distinguishes itself with techniques recommended by Sun for building better Web applications. Backed up by the author's own collection of custom tag libraries, which allow ordinary Web designers to program with tags instead of Java code, this text covers all the bases from getting started with tags to more advanced techniques. Early examples of tag libraries include a variety of ways to validate data in HTML forms. Throughout, the book deftly describes installing tag libraries, and shows how HTML designers can use custom tags after Java developers have created them.

Readers also get best practices for JSP and Beans, which is a big plus. Author David Geary presents both Model 1 and Model 2 architectures. (In Model 1, JavaBeans are used to present data to front-end JSPs. In Model 2, a more sophisticated set of Java classes using the Model-View-Controller design pattern allows even greater flexibility.) Sample code for using JSP and JavaBeans for internationalized code (including French, German, and Chinese) will show you how to take your Web application to worldwide markets. The book concludes with a working case study of an online fruit stand (using several languages) and applies the techniques presented earlier on.

All in all, with its mix of practical advice and some very useful techniques for getting the most out of JSP and Java for Web applications, Advanced JavaServer Pages fills a valuable niche for any serious Java developer who wants to see some of the best ways to create Web applications today. --Richard Dragan

Topics covered:

  • Custom tag tutorial (including JSP and TLD files)
  • The tag life cycle
  • Tag attributes
  • Tag classes
  • Body tag handlers
  • Scripting variables
  • Nested tags
  • HTML forms and JavaBeans
  • Validating form data with Beans and custom tags
  • Templates and custom tags for defining regions within Web pages
  • Model 1 and Model 2 basics
  • Sample classes and tags for Model 2 framework (including samples for managing logins)
  • Event handling
  • Sensitive form resubmissions
  • Internationalization techniques (including resource bundles and locales)
  • Security issues (including basic, digest, form-based, and SSL authentication)
  • Custom tags for JDBC database programming
  • Database connection pooling, XML, and JavaBeans
  • The Simple API for XML (SAX)
  • The Document Object Model (DOM) and custom tags for these APIs
  • XSLT and XML
  • Case study for an internationalized online fruit stand
  • Appendix on Servlet filters and the Servlet 2.3 specification

Book Description

Thousands of developers have discovered that JavaServer Pages represent the optimal solution for cross-platform web-based development. Now that they've mastered the basics of JSP, many are seeking to deepen and strengthen their expertise. In Advanced JavaServer Pages, best-selling Java author and former JavaSoft developer David Geary delivers the sophisticated enterprise-class techniques they're searching for. Geary tackles JavaServer Pages 1.1 with the same exhaustive, authoritative approach that made his Graphic Java books so successful. He begins with a thorough review of JSP elements, servlets, and JavaBeans; then introduces custom and body tags; and offers sophisticated insights into JSP-based Web application design. Advanced JavaServer Pages includes detailed chapters on internationalization, security, databases, e-mail integration, and Enterprise JavaBeans. For every Java developer interested in creating server-side programs with JavaServer Pages and Sun's servlet technologies.

From the Inside Flap

Shortly after the Swing volume of Graphic Java was published in March 1999, I became aware of the mass exodus from client-side Java to server-side Java. Because I make a living writing books, I took that exodus very seriously, so I began exploring server-side Java in search of a technology that would be appropriate for my next book. At first, I was enamored with XML, XSLT, and Java, and I spent a good deal of time experimenting with those technologies. But as exciting as those technologies are, it seemed to me that they were on the periphery of developing web applications, and I wanted something that was directly involved in the creation of web applications. Then I discovered servlets.

To be honest, I wasn't too excited about servlets. Were software developers really going to create user interfaces by generating HTML with print statements from the guts of some servlet? I knew of at least one software developer that was not. Since 1984, I've had the good fortune to develop software by using a number of object-oriented languages and very cool user interface toolkits. I've developed applications in Smalltalk, Eiffel, and NeXTSTEP, and it seemed to me that developing applications with HTML—especially HTML manually generated from servlets—was akin to trading in a Ferrari for a Yugo. Then I discovered JSP.

Although back in 1999 JSP was in its infancy, it was easy to see its potential. Here was a way to mix Java with HTML, which opened the door to all kinds of interesting possibilities. And in the Future Directions section of the JSP 1.0 specification, I saw something that really caught my eye: A portable tag extension mechanism is being considered for the JSP 1.1 specification. This mechanism permits the description of tags that can be used from any JSP page. Wow. With custom tags you could encapsulate Java code, which would essentially allow you to create custom components, in the form of tags, that could be used in conjunction with HTML. From then on, I knew that my next book would be about JSP.

So I started to write an introductory JSP book, and I actually wrote the first chapter of that book before I realized two things. First, there was going to be a glut of introductory JSP books, and I did not want to compete against all of those books. Second, and most important, that first chapter was boring, and I hate to read boring books, let alone write them. So, I decided to write this book instead.What This Book Is About

As its name suggests, this book is an advanced treatment of JavaServer Pages. The central theme of this book is the design and implementation of flexible, extensible, and maintainable applications with beans, servlets, and JSP.

This book begins where most introductory JSP books leave off, by showing you how to implement JSP custom tags. The ability to create custom tags is arguably JSP's greatest strength because it allows software developers and page authors to work in parallel with few dependencies. Subsequent chapters cover HTML forms, JSP templates, Model 1 and Model 2 architectures, a simple Model 2 framework, handling events, internationalization, security, databases, and XML. This book concludes with a comprehensive case study that shows how to use the techniques discussed in this book to develop a nontrivial web application.The Servlet and JSP APIs This Book Depends Upon

The code in this book depends upon the Servlet 2.2 and JSP 1.1 specifications. Although the Servlet 2.3 and JSP 1.2 specifications were first released in draft form in November 2000, as this book went to press they were still in a state of flux. Because servlet filters are arguably the most important addition to the Servlet 2.3 specification, that topic is covered in "Servlet Filters" on page 471; however, you should be aware that the code in that appendix is very likely to change by the time you read this.How This Book's Code Was Tested

I tested all of the code in this book with Tomcat 3.2.1. If a code example from this book does not work correctly with Tomcat 3.2.1, such as the example in "Digest Authentication" on page 259, that fact is pointed out in the book's text.

Because Tomcat is the reference implementation for the Servlet and JSP specifications, all of the code in this book should work with any servlet container that conforms to the Servlet 2.2 and JSP 1.1 (or higher) specifications. If an example from this book does not work with your servlet container, it is most likely a bug in that servlet container.

I also tested all of the code in this book against Resin 1.2, which is an excellent servlet container available from caucho. As a general rule, it is beneficial to test your code against more than one servlet container to ensure correctness and portability.This Book's Audience

This book was written for Java developers with a basic understanding of servlets and JSP. For most Java developers, this should be their second book that covers servlets and JSP. If you are new to servlets and JSP, I recommend the following books for your first book on those topics:

Core Servlets and JSP by Marty Hall, Sun Microsystems Press

Java Servlet Programming by Jason Hunter, O'Reilly

Web Development with JavaServer Pages by Fields and Kolb, Manning

It also won't hurt to have a basic understanding of design patterns and the Unified Modeling Language (UML). This book demonstrates how to implement a number of design patterns in JSP-based web applications and uses UML class and sequence diagrams to show how classes are related and how they interact, respectively. See page 181 for a list of resources on design patterns and UML.

This book was not written for page authors. If you are a page author with no Java experience, you will be better served by one of the books listed above.How This Book Was Written

Designing object-oriented software is very much an iterative process. You start with a few classes and build on them, all the while iterating over classes, both old and new, as you integrate them to build an ever-evolving system. In object-oriented parlance, that process is known as refactoring.

After working for 15 years as a software engineer, I tend to write books the way I write software. Each of this book's chapters started out in humble fashion. And each chapter was subsequently refactored into the final product that you hold in your hands.

You can get a glimpse into this process by looking at a JavaWorld article that I wrote about JSP templates. That article is the first cut of this book's Templates chapter, so you can see where the process started for that chapter and where it ended; both the chapter and the code that it discusses underwent much refactoring.How To Use This Book

This book is not a novel, so I don't expect anyone to sit down and read it cover to cover. Because most readers will read chapters out of order in a random fashion, nearly every chapter in the book can stand on its own. There is one exception to that rule. Chapter 6, which discusses a simple Model 2 framework, depends on Chapter 5, which introduces the Model 2 architecture. Chapter 6 retrofits an example from Chapter 5; therefore, Chapter 5 is a prerequisite for Chapter 6.

The last chapter in this book is a comprehensive case study that employs the techniques discussed throughout this book to implement a nontrivial web application. You can read (or most likely, skim) that chapter first to get a feel for those techniques, or you can read it last to see how to integrate those techniques. Or you can do both.This Book's Custom Tag Libraries

This book discusses the implementation of approximately 50 JSP custom tags, ranging from internationalization tags to tags that use XML's Document Object Model to parse XML. There are no legal restrictions whatsoever on those tags, so you are free to use those tags in any manner you deem appropriate. See "This Book's Code" on page xvii to see how you can download those tags.

This book's custom tags serve two purposes. First, they illustrate how you can implement your own custom tags. Second, they serve to reinforce the concepts discussed throughout this book. But those custom tags are not the focus of this book; rather, it's the concepts that those tags embody that are important. For example, if you look at the internationalization chapter, you will see that most of that chapter is dedicated to internationalizing text, numbers, dates, and currency in a JSP-based web application. The last few pages of that chapter show how to implement two custom tags that perform internationalization. But it's the internationalization concepts, and not the custom tags, that take center stage in that chapter.This Book's Code

You can download all of the code from this book, including the book's custom tag libraries, from the following URL: phptr/advjsp

From the Back Cover

  • Design and implement flexible, extensible, and maintainable applications with servlets and JSP technology
  • Master powerful authentication and internationalization techniques
  • Learn how to integrate industry-standard XML and XSLT with JSP technology
  • Use JSP technology-based templates to develop robust applications from modular components

Advanced JavaServer Pages delivers:

  • Web application design techniques based on JSP and servlets technology
  • Proven strategies for achieving enterprise-class robustness and scalability with JSP technology
  • Expert guidance on implementing JSP technology-based applications with reusable components

To fully exploit the power of JavaServer Pages technology in Web application development, based on J2EE technology, you need to master the sophisticated server-side techniques that David Geary presents in Advanced JavaServer Pages.

Geary tackles JavaServer Pages technology with the same exhaustive, authoritative approach that made his Graphic Java books into worldwide best sellers. He presents in-depth coverage of advanced topics including:

  • Implementing custom JSP technology tags
  • Designing scalable and extensible Web applications
  • Using authentication to build secure JSP technology-based applications
  • Internationalizing JSP technology-based applications for global environments

Advanced JavaServer Pages features detailed chapters on internationalization, authentication, JSP technology templates, design, and XML. It concludes with a comprehensive case study that ties together key topics developed in the book and demonstrates how to integrate advanced techniques based on JSP technology. This book is a must-have resource for every developer of Java technology creating server-side applications with JSP technology and servlets.

About the Author

David M. Geary is best known for his Graphic Java series from Prentice Hall PTR and Sun Microsystems Press, but for the past two years he has been immersed in server-side Java technology. He is a member of the expert group that's defining the standard JSP technology tag library and is also a key contributor to the Apache Struts JSP technology-based application framework.



PLEASE READ: All comments must be approved before appearing in the thread; time and space constraints prevent all comments from appearing. We will only approve comments that are directly related to the article, use appropriate language and are not attacking the comments of others.

Message (please, no HTML tags. Web addresses will be hyperlinked):

Related Free eBooks

Related Tags

DIGG This story   Save To Google   Save To Windows Live   Save To Del.icio.us   diigo it   Save To blinklist
Save To Furl   Save To Yahoo! My Web 2.0   Save To Blogmarks   Save To Shadows   Save To stumbleupon   Save To Reddit