Product Description

Customer Reviews (150)

Great book ever
Its fun to read and learn! Each page will give you an "AHA" moment !

perfect
The seller did a amazing working. the product was shipped in the same day that I paid. thanks

The book helped me a lot
The book helped me a lot with my J2EE studies. Everything is being explained in very friendly and understandable way.
I'd like the book to include also explanations about the work with Data Bases though.

Good book but not complete
It is a good book but to get the J2EE 5 Web Component Developer certificate you must use other resources. Nevertheless, I would say that I learned a lot reading this book and it wouldn't be fair to grade it with 4 stars. I recommend this book for people who don't know nothing about web development using Java. However, if you want to be an expert you should read other books for complementing the knowledge.

Excellent book on Servlets & JSP
The Head First series is like a seal of quality, its friendly approach and way of explaining concepts just show that. And Head First Servlets & JSP is no different.

The book is recommended for those who want to learn JEE (the web part), but if you have to have some background on Java, if you don't buy Head First Java first!

The book starts showing some concepts on the Internet, how servers work, pages and HTML. ABSOLUTELY FANTASTIC! They can make computers look much simpler and easy to learn.
Then, they show some simple web app. and explain it, then you'll see that this small app. got some problems (the HTML and Java code are mixed, making it painfully hard to maintain and understand) so they introduce other concepts like JSP, and they progress, showing that scriptlets in JSP are terrible too, so they present JSTL and so on. Even Enterprise Design Patterns are covered.

I found the book covers pretty well all the non-framework part of JEE, that is just Sun technology, no Struts, JSF, Hibernate, Spring, etc. But that's an excellent intro for Java Enterprise Edition. And of course, probably the best book for the Sun Certified Web Components Developer (SCWCD), with a lot of exercises in the last pages of each chapter. Every topic for the SCWCD is covered.

Definitely recommended! ... Read more

Product Description
This new edition of Murach's Java Servlets and JSP makes it easier than ever for Java developers to master web programming. It starts by showing how to install and use Tomcat as a web server and NetBeans as an IDE. Then, it teaches how and when to use JavaServer Pages and Java servlets to build well-structured web applications that implement the MVC pattern. Next, it shows how to use sessions, cookies, JavaBeans, Expression Language (EL), the JSP Standard Tag Library (JSTL), and custom tags. Then, it shows how to use JDBC and connection pooling to work with a MySQL database. Finally, it shows how to use JavaMail, SSL/TLS, authentication, listeners, and filters. These are the skills that you need to build professional Java web applications. A great read for any Java developer. ... Read more

Customer Reviews (34)

Murach does well again
I've read a couple of murach's books and they explain topics well and in a logical order.Much approved!

Good deal
Got a good deal on the book, was cheaper then buying from book store. Was delivered quickly and was happy with the deal.

Good book; useful
I bought the book for a grad-school class. I found the book useful and now that the class is over I expect that I will find continue use for the book. This book is quite effective in explaining what it intends to explain. Furthermore, the book is not boring (like some tech book/documents).

If you need to learn Java EE, Java Servlets or JSP, this book will likely work for you.

great book
I love this book, it takes you step by step toward understanding servlet/jsp with examples. It's a great book if you wanted to start learning web application development, it will guide through installation of netbeans, tomcat, etc.. There aren't many good books in this subject out there but i'm happy that i invested in this book, i read this book twice to make sure i understood everything.

jenia
A very good book about jsp/servlet.
I'm not sure if this book will be good for someone with no jsp/servlet experience; this book is easy to read and has a lot of information, all of it well organized.
However, this book does not "discuss" the topics, it doesnt really engage with you to think about why you would need this or that feature in jsp/servlets; it just describes (very well) that feature.
For the way this book is suppose to be used (reference book in my opinion) it is a very good book. ... Read more

Product Description
For the current edition of this book, please see Murach's Java Servlets and JSP, 2nd Edition (ISBN 9781890774448).

This book methodically teaches all of the skills necessary for developing a commercial web site using servlets and JavaServer Pages. These skills include working with HTML, HTTP, servlets, JSP, sessions, cookies, JavaBeans, SQL, JDBC, connection pooling, JavaMail, SSL, security, and XML. Unlike many of the competing books, this book provides detailed coding examples for working with Tomcat, one of the most popular servlet and JSP servers, and MySQL, one of the webÂ’s most popular database servers. A great book for any Java programmer. ... Read more

Customer Reviews (30)

Excellent book for the subject
I used this book as the text for a course in applied client/server computing.This book passed the test: I would definitely use it again.

The 'alternating page' format that the authors use is unique.It makes the information in the book very easy to absorb: description on the left page, code example on the right page.It's so simple and so effective it makes me wish I'd thought of it first. ;)And even with so many code examples, I don't recall finding a single error.

This is a wonderful, no-fluff, down-to-business, practical introduction to the subject.The authors carefully guide the reader through installation of all the tools needed to start writing servlets and JSPs.This book requires that the reader already have a decent understanding of Java.

Great job, Andrea and Joel.

A must read book
This is a great book! It starts from very basic structure of web applications with examples and builds upon that to creation of an actual web application. Of course, I am assuming you know HTML. You also need to know some Java or other programming languages that helps you pick up Java quick. Here is the simple idea, you write your program with Java and then using JSP, Servlets and J2EE make that appliaction a web application. Of course don't get scared by these topics and titles. Simply start reading this book, then you get a better idea if you need to put this book on hold while you are learning Java before tackling the rest. Normally the first 4 chapters are very easy to follow if you know HTML and some programming. The rest is not hard but it needs a little attention.
That is where the actual JSP and ... starts!! It is a lot of fun!!

Thank you Murach

The Best for Understanding JSPs and Servlets
Thank you to the authors.This book is simple to follow, precise and complete.I own the Wrox and OReilly JSP books but both of those give incomplete examples in critical portions of the book.

For easy to follow, complete, working examples with full explanation, this is the book.

Needs a new revision
I bought this because Amazons pairing system linked this book to a JDK6 book with a publication date of 2007. This book was published in 2003! That'll teach me to check the publication date of the links.

This book is fine if you are still using Tomcat 4.1 as a release enviroment for your web apps. If you are like the rest of the world and have moved on to Tomcat 5 or 6, then forget it. This means the 2.1/1.2 Servlet/JSP specs rather than the 2.5/2.1 spec. From 1.2->2.1 there have been some powerful additions to the tagging which you obviously won't find any info on in here.

I'll give the book 2 stars as it is well laid out, thought there are a few niggles where the content is wrong, but nothing major.

A good training book
This is a perfer training book for Java servlet.
It is very helpful for any level's user. ... Read more

Product Description

This is the first comprehensive guide to cover JSP 2 and 2.1. It supplies you with the tools andtechniques to develop web applications with JSP and Java servlets. You'll learn to choose and implement the best persistence option for your web applications, and how to secure web sites against malicious attack and accidental misuse. You will improve the performance and scalability of JSP pages, as well as architect reliable, stable applications.

The authors describe all of the rich JSP 2 features, and explain JSF integration with JSP. Completing the thorough package, this book examines how integration with open source projects like Ant, Struts, XDoclet, JUnit, and Cactus can make web development even easier.

Customer Reviews (2)

Thorough, detailed, and usable
This book is somewhat of an amalgamation between two other Apress books, "Beginning JSP 2: From Novice to Professional", and "Foundations of JSP Design Patterns", however there is more information in those two books in regards to their respective topics, and this book has much more detail in topics those other two books do not address.

While this book is designated for intermediate to advanced developers, it could be used as an all-in-one for a novice if they have decent Java knowledge and are able to read at a relaxed pace. I found chapter quality to be consistently good. The provided examples are useful and expertly selected (not too short, not too long).

Topics discussed include JSP page "anatomy", servlets, expression language, the standard tag library (JSTL), a surprisingly concise and well done chapter on JavaServer Faces (JSF), custom tag development both from a legacy and modern approach, data access, filtering, security, performance, scalability, web application design and best practices, and Struts.

The majority of topics are discussed in great detail. Some of the more detailed topics such as performance and scalability have as much detail as could be expected in a non-specialized book and at the very least provide you with information on where to learn more about the topic.

I have been working with JSP and JSF for 2 years and I found this book useful to fill in some knowledge gaps. I recommend it without reservation.

Very Comprehensive Text
Java's web technology has always been my fascination. This book opened up a whole new perspective on Java and JSP for me.
The book that I truly started learning JSP with is "More Servlets and Java Server Pages" by Marty Hall. That book breaks down piece by piece how it all works. It's a really great book. "Pro JSP" shows you how to exploit that knowledge to turn it into something truly useful. If you are a Java web developer you know that Java web applications can be slow and clumsy. Have you ever wondered how the sites like Amazon are written in Java and can handle millions of hits a day? Well, that book explains the technology behind those kinds of applications.
The book makes very extensive use of EL (not something I am very fond of). It shows you how far you can go with JSTL by utilizing it in creating Java Server Faces. So it doesn't just tell you how amazing JSTL is because it can connect to a MySQL db from a jsp page (I mean maybe hardcore PHP programmers would find that feature cool. I don't). As far a JSF, the book shows very clearly how to do it. And you can easily try it out on your server. Still I do not believe the book does a good job providing examples of when you would really need the JSF technology. It's pretty much up to the reader's imagination. The book does a good job breaking down the use of managed beans in the context of JSF.
I think the coolest chapter of the book is the chapter on filters. Let me tell you I still have hard time comprehending the entire filtering technology in JSP. It's a really advanced topic. I had no idea you could control users' requests to that extent. The book shows graphs on how requests to your web application travel through layers of filters. So it's really clear as to when you need a filter in your applications. And it's not hard to figure out how to optimize your application's performance using filters.
I can really go forever, so I will stop here and let you see the rest for yourself. ... Read more

Product Description
JSP-ServletInterview Questions You'll Most Likely Be Asked is a perfect companion to stand a head above the rest in today's competitive job market. Rather than going through comprehensive, textbook-sized reference guides, this book includes only the information required immediately for job search to build an IT career. This book puts the interviewee in the driver's seat and helps them steer their way to impress the interviewer. Includes:a) 153 JSP-Servlet Interview Questions, Answers and Proven Strategies for getting hired as an IT professionalb) Dozens of examples to respond to interview questionsc) 51 HR Questions with Answers and Proven strategies to give specific, impressive, answers that help nail the interviews ... Read more

Product Description
With literally hundreds of examples and thousands of lines of code, the Java Servlet and JSP Cookbook yields tips and techniques that any Java web developer who uses JavaServer Pages or servlets will use every day, along with full-fledged solutions to significant web application development problems that developers can insert directly into their own applications.

Java Servlet and JSP Cookbook presents real-world problems, and provides concise, practical solutions to each. Finding even one tested code "recipe" that solves a gnarly problem in this comprehensive collection of solutions and best practices will save hours of frustration--easily justifying the cost of this invaluable book.

But "Java Servlet and JSP Cookbook" is more than just a wealth of cut-and-paste code. It also offers clear explanations of how and why the code works, warns of potential pitfalls, and directs you to sources of additional information, so you can learn to adapt the problem-solving techniques to similar situations.

These recipes include vital topics like the use of Ant to setup a build environment, extensive coverage of the WAR file format and web.xml deployment descriptor, file-uploading, error-handling, cookies, logging, dealing with non-HTML content, multimedia, request filtering, web services, I18N, web services, and a host of other topics that frustrate even the most seasoned developers.

For Java web developers of all levels who are eager to put into practice the theory presented in other API-focused books, the solutions presented in this practical book will prove invaluable over and over again. This is painless way for less experienced developers who prefer to learn by doing to expand their skills and productivity, while accomplishing practical solutions to the pressing problems they face every day. More experienced developers can use these recipes to solve time-consuming problems quickly, freeing up their time for the more creative aspects of their work. ... Read more

Customer Reviews (8)

Joke of a Book
As some other reviewer pointed out (read his reveiw for details), the examples are based on Oreilly's Library, the realy nitty-gritty stuff is completely skipped. I think author is cuckoo, to beleive he expects most of his readers to pay for this joke of a book. I paid four dollars and fifty cents for it (second hand) .... about right price.

A Good Reference Book
A good book. Not for someone looking for a "tutorial" or "introduction" on the subjects covered. However, a good reference book to find examples of specific programming problems for someone who already has a good understanding of servlets and JSP. Covers a good number of different aspects of servlet/JSP programming. I also found it a good book to convey some general knowledge in areas like using attributes, DB access, etc. I enjoyed selectively reading different chapters.

You want to write Servlets & JSP's - Buy This!
I'm not a big reviewer. I find writing a challenge, even if it's a positive experience, as it is now. I started learning Java a few months ago and bought a number of books on the topics I needed to really create a java website.
I stumbled on this book as one of the ten or so I purchased.

I haven't touched the other's since. This book has it all, written so clearly that you know the author is very familiar with her subject and understands it thouroughly. It was written in 2003 and discusses Tomcat server as release 4.0 but that does not matter one bit. I was truly able to use this book to put together a website. Servlet, jsp, even java script is covered. I found many questions I had assembled reading the other books being answered in this one.
Murach's books should be proud of this and I notice that they don't publish a 100 books on a subject; just have a few. I'll bet they're just as good.

Precisely the book I've been dreaming of...
This book is exactly what it claims to be: a general reference to hundreds of "everyday" situations Java Web developers face. Just as any cookbook, it doesn't go into the "deepest" details about every little thing, and it does give examples of ways to not reinvent the wheel. Some reviewers see this as worthy of only 1 star... This is only a 1 star book for readers who like to reinvent the wheel and waste time on unnecessary details... if you're like me and have deadlines to meet, you'll find what you need here quickly and efficiently.

Hampered by use of custom libraries
Being an O'Reilly fan it is hard for me to find fault with their no-nonsense approach to technical books, but there is one MAJOR issue I have with this book.

As a developer for a major corporation I cannot use custom libraries for my work, especially when the license (http://www.servlets.com/cos/license.html) does not allow for commercial use.Where it would be helpful to see details on creating say, a multipart request class, Bruce Perry instead uses the com.oreilly.servlet.MultipartRequest class to hide much of the functionality (this is just one example).

This makes little or no sense.Developers in the real world need real examples.Hiding the implementation of such under the non-commercial license pretty much ruins much of the potential application of an otherwise well written book.If you buy this book realise that only some of it will actually be useful in the real world. ... Read more

Product Description
After reading this book, you'll be able to do a whole lot more.

— Dirk Schreckmann, JavaRanch Sheriff and Journal Editor

Let Beginning JSP 2 be your guide as you begin using JSP. This comprehensive guide starts by steering you through your first JSP application. It reviews HTML, and provides you with a useful overview of JSP. You'll then be ready to start learning one of the core techniques in JSP: pulling data from a database and working with that data.

When you've mastered this technique, you'll be ready to branch out powerfully into other JSP topics: variables, scope, flow control, and code reuse for productive time management. Finally, the book shows you how you can use JSP with XML and gives you a taste of some advanced topics, including using Struts and the Model View Controller.

Customer Reviews (5)

At most an average computer book
The directory structure described in 1st chapter doesn't fit Tomcat's directory structure. The text description is correct, but the screen shot is wrong. Also in 1st chapter, the JAR files that should be included in PATH variable also have the wrong name. This is very low-level mistakes.

The 2nd chapter reviews HTML. Well, it is rather confusing than helpful. Then in Chapter 4 the author talks about database and tries to explain Normalization. I'd rather the author skips on this topic because he/she seems just lack of ability to explain things in the clear way.

I bought this book to learn JSP, not to compose an errata for the author. I believe most readers don't like to do that either. If you would like avoid unnecessary headache, look else where.

A Self Contained, Extensive Introduction to JSP, Tomcat, Servlets and Related
First of all:
I did like this book. It gave me an easyly accessible introduction to all this business around using Tomcat. The author took quite some trouble to explain every related technology (HTML, CSS, SQL, OO, Java ...) in some detail. Sometimes you want to read through it to get reminded, sometimes you want to skim over it and sometimes even to skip it. But it is good that it is there. I do not know if you can actually grasp those related technologies, if you never saw them before. For me the rehash was helpful on all the cases I needed them.

The core topics of the book: JSP itself with its expression language und standard tag libraries were very well explained and easy to grasp also for a first timer like me. I now do have a good feeling for its core topics and their whereabouts. I only got lost (a little) in the last chapter about Struts. There is seemingly so much overlap to other technologies (EL, JSTL, home grown Beans) that I did not succeed to get a clear picture of when to use what.

CRAP
I did not read this book through because not even the 1st sample code works (due to configuration). Sent questions to two of the aythors the email addresses given in the book are not even valid !!! I went to sun website and the anwser was straight forward. If a book for novice can not explain better than Sun's official documents, why bother write the book?

Waste of time and Money! Keep away from these authors who failed to display professionalism!

Beginning JSP 2 - not quite a set-by-step book
I had bought this book to improve my knowledge of JSP - which is rather limited. I had expected, from the text on the back cover, this to be a comprehensive book on how to code JSPs (with lots of examples - which I like). In reality I was rather disappointed.
The first Chapter went well, how to install Tomcat, and the second wasn't too bad (a review of HTML) but by the third chapter I started to notice a lack of clarity. It wasn't always clear which text I should be typing in and which were simply given as an aside - which for a step-by-step guide is frustrating. The fourth chapter was far worse. This started of by saying that we would be using mySQL, but failed to give any indication of where to get the software from, how to install it or how to start the server (you need to start the server to follow the examples). And then a number of the example instructions, that were given in this chapter, did not work without modification. I was able to work round these problems and make progress. But as this wasn't a core chapter (I read this book to learn how to use JSPs not mySQL) I had expected to go through it quickly.
Overall the content was very useful and I learnt a lot, but the book would benefit from being edited (again?) and a second edition.

Beginning JSP 2?Yeah, right.
"Beginning JSP 2?"Yeah, right.Try: "Beginning JSP 2, HTML, JDBC, Java, JSTL, XML, XSLT, XML DTDs, XML Schemas, Servlets, Filters, with some MVC (Model 2) and Struts thrown in for Good Measure."While my recommended title may be a bit too long to be practical as a book title, it would better capture the materials covered from an introductory level, in "Beginning JSP 2."

In about 360 pages, through 10 chapters, this book covers the technologies listed above, describing what they are, what they do, why folks are using them, how to use them, and how they relate and work with other technologies.Following these action packed chapters, the appendixes serve as great quick references on JSP syntax, implicit JSP objects, and various XML configuration files.

To nitpick a bit: The book could benefit from some more aggressive editing, in parts, where sentence and paragraph wording is occasionally a little clumsy, and a few good-to-understand details were left out.

The description on the back cover of the book says, "All you need... is a basic understanding of HTML and Java."I suggest this be corrected as follows: "All you need to know in order to follow and understand the lessons in 'Beginning JSP 2' is enough HTML to create a 'Hello World!' web page, and enough Java to create a 'Hello World!' application."On second thought, even if you can't do those things, yet, after reading this book, you'll be able to do a whole lot more. ... Read more

Product Description
JSP Tag Libraries is an extension to Java Server Pages, the java API for web development, that allows a cleaner separation of logic and presentation. This promotes genuine reusability and improves the scope and power of JSP.

JSP Tag Libraries teaches you how to create usable, maintainable, and flexible tags. We will teach you good practices, and the design implications of tags, that will enable you to maximise the reusability of your code. This book includes many useful code examples that illustrate the points being made. With the prevalence of material on using of jsp tags, we will not concentrate in detail on using 3rd party tags, but rather aim to take you from writing script-like JSP based applications to creating genuinely object oriented web applications. ... Read more

Customer Reviews (2)

A good reference book for JSP tags and struts
Title: Professional JSP Tag Libraries
Author: Simon Brown
Publisher: WROX publisher Ltd.
ISBN: 1 861006 217

Reviewer Name: Ravi Mahalingam
Review Date 23 Apr 2003.

Overall Value of the book: 4
Instructional value of the book: 4
Reference value of the book: 5

Like every WROX, this book covers different aspects of tag libraries
of JSP (custom and regular) in a detailed fashion.The author Mr. Brown
has done a good job to explain the concepts of tag libraries.

the book has useful code snippets that can be used for real
world problems.the book also provides screen prints of the
actual output making it easier for the readers to find out the
result of the code.

THE author has explained how STRUTS work and has explained
it in great detail.

overall, this book is a good reference and will find a place in
my office shelf. we are in the process of developing a jsp
based user application which uses STRUTS.

Excellent Content
Professional JSP Tag Libraries has great, effective content that Web programmers will appreciate.

It would have received 5 stars, except for the fact that there are technical errors.Each one isn't major, but it does affect the text's consistency and fluidity.For example, the diagram on page 41 that reveals the Web Archive File Structure misspells a directory name where the tag library descriptors are placed. ... Read more

Product Description

Start building Java–based web applications now, even if you’re a complete newcomer to Java. Comprehensive and example–driven, Beginning JSP™, JSF™, and Tomcat™ Web Developmentis all you need to develop dynamic web applications using JSP, connect to databases with JSF, and put them into action using the world’s most popular open source Java web server, Apache Tomcat.

• A comprehensive introduction to JavaServer Pages (JSP), JavaServer Faces (JSF), and the Apache Tomcat web application server
• Key concepts made easy to grasp by numerous working examples and a walkthrough of the development of a complete e-commerce project
• Written for professionals by a practicing Java web application professional and expert

Customer Reviews (5)

So-so
Well after reviewing almost every book online and reading the reviews, I thought this Apress book and another on JPA would help me get over the issues I was having trying to incorporate a real world database driven JSP/JSF application. Unfortunately, the book's author simply does not present a start to finish encapsulation of a real business world application. Coming from a .Net background - I find the steps involved in just trying to build the foundation of the application's package to simply create a usable database driven front-end is like purchasing a car in a kit and trying to put it together so you can drive it. The pieces are all there, but the instruction manuals are spotty and don't always compliment one another. If there is an author out there that knows how their stuff, I'd love to work with them to explain how to write a book that will actually help people..I'm sure there are a lot of people out there in the same boat. Good luck, perhaps you can grasp the concepts better than I can - just felt it got me to a point, but crucial pieces were missing. It's not a bad book, I'm probably just a little too green yet to put it all together.

Way to little JSF
This book is far to basic and superficial in its treatment of Java Server Faces than anticipated.

There are far too many chapters on how to set up the supporting services and far to little on Java Server Faces.With 8 chapters and 8 appendixes there is only 1 chapter and one appendix on JSF.The other chapters deal with an overview of Web Pages in General, an overview of JSPs, an overview of setting up MySQL (only for a Windows platform), an overview of setting up Tomcat 6 (again only for the Windows Platform) and the underlying structure of Tomcat 6, a superficial discussion of XML technologies such as XPath and XSLT (there are whole BOOKS written on this), a superficial discussion of CSS and HTML and an appendix on the Eclipse platform (ignoring NetBeans or other valid IDE's).

If one is rusty on some of the technologies, it is a great review.But a person new to JSP's and Java Web technology would be very quick to get lost.This does not take you from Novice to Professional.It a surface scratch of a handful of the basic technologies and leaves one wanting.Nowhere near a Professional developer.

On the plus side, if one IS rusty, the discussion of JSP's is a very quick and down and dirty get one back up to speed on Intrinsic Objects, JSP directives JSTL and EL and a slam, bang, thank you mam' on custom tag libraries.

It would do better to get Pro JSP 2, Fourth Edition (Expert's Voice in Java) or a book specifically on JSF if you want to learn JSF.

Usefull Book
This book is a good source for beginnerr and a little reference about JSP and JSF. If you need more specific information about the titles you will need another book.

Good startat using technologies
Okay, I haven't touched JavaServer Pages in some time and this book got me back up to speed pretty quickly. Adding in JSF was easy, which I hadn't used before. It does start a little too basic for my needs and doesn't go quite as deep as I'd like, but overall will have you using JSP and JSF with MySQL within Tomcat pretty quickly. The title is Beginning JSP..., so not going as deep as I'd like is not the book's problem, but more now its time for me to go to the next level and probably look into one of the Pro books.

One complaint with the book is the excessive appendices, almost half. Maybe it is just me, but I think eight pages to specify HTML characters and another 40 pages for an HTML reference seems excessive for the book's topic. With Beginning in the title, I was thinking more beginning JSP and JSF, not beginning HTML.

Good starter book
From what I have read so far, this book is really good. It starts with a good introduction then moves into a thorough explanation with a useable example. ... Read more

Product Description
This in-depth tutorial acquaints HTML and Java programmers with the world of JSP tags-Java components that open up JSP development to the everday content developer (the HTML programmer) and improve code reuse and separation between presentation and business logic. Using real-world tags, it guides the novice through practical JSP applications, such as performing iterations and accessing databases, EJBs, e-mail systems, and Java Beans, and demonstrates how tags can be used in the context of e-commerce applications and WAP that work with cellular phones. Included are numerous short examples that can be reused to add simple and powerful dynamic features to web sites. ... Read more

Customer Reviews (9)

Indepth coverage, excellent examples
This is a review I did for AustonJUG group. Since it is a long review (more than 1000 words), I only post the overview here....Working with other server side Java components, such as JavaBeans, EJBs and JDBC, properly designed custom tag libraries allow developers to encapsulate and reuse code. Custom tags create a tag-based content authoring environment and allow web authors to write highly dynamic web applications in HTML style without learning the Java programming language. So, architects, developers and content authors can all benefit from studying JSP custom tags.

Manning's book "JSP Tag Libraries" by Gal Shachor, Adam Chace and Magnus Rydin (ISBN 1-930110-09-X) is an excellent JSP custom tag text suited for both new and seasoned developers. This book covers JSP specifications 1.1 and 1.2.

One of the main strengths of this book is that it does not merely repeat API documentations. The authors put a lot of effort to show the readers the big picture, the philosophy behind JSP custom tags and how to apply them in real world applications. This book talks about "why" as well as "how".

After studying this book, the reader should be able to understand:

* What JSP custom tags are and why we need them;
* How custom tags work;
* How to use tags to perform common and advanced tasks;
* Steps to develop and deploy tag applications;
* Basic design patterns for tag applications;

The book is very well organized and well written. It is full of excellent code examples. Those examples put the techniques into context.The readers can learn effectively by playing with the examples.As added bonuses, the code examples can be easily adopted for real world applications.In section "Case Studies", the authors discuss two complete multi-tier E-commerce and M-commerce applications.They offer not only code examples on applying practical techniques but also insights and templates on how to design good JSP applications.

All the code examples in the book are annotated with in-depth explaining text. That truly helps readers to understand not only what the code is doing but also what the authors intended to do.

However, there are still things I wish the authors could improve in the next version:

1. The authors had excellent discussions on how to implement conditional tags, iteration tags and database access tags. But they did not mention similar tag libraries under development by the Jakarta Taglib project. I would really like to hear about their insights on the designs of Jakarta tag libraries and many similar libraries developed by commercial companies.

2. In the "Case Studies" part, it is quite easy to add a parallel WAP store front to the JDBC-driven WebStore through another set of custom tags. That would really drive home the power of separating business logic from presentation logic and highlight the flexibility of a JSP custom tag based solution. I wish the authors had done that.

Overall, I think this is an excellent book and would like to HIGHLY RECOMMEND it to anyone working with JavaServer Pages technology.

Best book on JSP Tags
There are now quite a few JSP books around and some of them mention JSP Tag libraries. In a typical n-tier web application, JSP tag libraries enable the presentation layer to be cleanly separated from the business layer. This allows simple scripted pages to call complex Java code without confusing the HTML web page Developer. By using JSP tag libraries, the developers have reusable code that can provide easy access to different J2EE services.

This book starts of with a quick introduction to dynamic web servers, Java servlets and Java Server Pages (JSP). We recommend that readers new to JSP should read a book dedicated to JSP before reading this one. Chapter 3 begins with an explaination of JSP custom tags, setting up the environment (Tomcat) and creating a simple Hello World tag. The authors provide enough information to explain the example without confusing the reader. They also suggest solutions to why the example might not work, providing a useful insight into what to check if something goes wrong.

Chapter 4 gives an overview of the tag API (interface and methods) and Chapter 4 explains how to create a tag lib descriptor (TLD) and how the JSP runtime uses this information to produce a servlet. Chapter 6 and 7 present some coding techniques to build a tag library and use an example of building a tag library for sending email. This is a simple and effective example that describes the process of developing and using JSP tab libraries.

Chapter 8 is important because it describes in detail how to use JavaBeans with tags. Starting off with information about the Reflection API, the authors show how to create a JavaBean and use Tags to present the information. This technique allows the developer to remove a lot of Java code from the JSP, making the page easier to understand and maintain. Chapter 9 and 10 show how to develop condition and interating tags.

Chapter 11 focuses on designing a database presentation tag library. This chapter answers many useful questions such as, Why not just wrap everything in a JavaBean? Again the authors give an exellent explaination of a very important topic. Realistically many readers would not be accessing a database directly from a tag library so the next chapters present J2EE and how to access Enterprise JavaBeans using tag libraries.

Chapters 13 and 14 are very interesting because they explain two case studies; a JDBC-driven web store and an EJB driven WAP store. The authors go over the design and development in quite a bit of detail and it is useful to all readers wanting to use JSP tag libraries in their projects. The last chapter covers tips and tricks, showing how to generalize tags using the Command design pattern and discussing maintainence, performance and debugging.

Suprisingly, the Apache Struts project is not mentioned in this book, however many of the concepts found in Struts are explained here. The authors have done an excellent job in explaining how to develop and use JSP tag libraries. We found the authors' insight very useful and on the whole the book is easy to read.
visualbuilder.com

Great Book on JSP Tags
I have written several custom JSP tags and I wish this book had been available when I started, it would have saved lots of time.All of the issues I ran into during my development efforts have been clearly outlined in this book.I highly recommend this book for anyone interested in JSP custom tags.This book would be a great resource for those with some experience with custom tags.But it also provides a great introduction for those that are new to the topic.

For learning JSP Tags, this is your only option.
Most other books I have read on this topic include merely one or two chapters for custom JSP tags. This book gives you chapter after chapter of custom tags and holds your hand throughout the learning process.The authors are clearly developers themselves, which shows in the quality of the work. The beginning chapters are particularly useful for those who are completely new to the topic. In all, a fine book, I hold back giving it 5 stars due to the lack of discussion of Struts. Please add that to the next print, otherwise this is a valuable book that has no competitor in the market.

Excellent book
Contrary to the previous review, the Java classes in the book do compile. I highly recommend the book. ... Read more

Product Description

While most other books merely instruct on basic JSP and servlet development, JSP Examples and Best Practices gives you some of the best practices and design principles, enabling you to build scalable and extensible enterprise Java applications. And JavaServer Pages technology can be used to build complex enterprise applications in a highly re-usable manner.

This book takes basic JSP and applies sound architectural principles and design patterns, to give you the tools to build scalable enterprise applications using JSP. Further, this book covers new features of the JSP 1.2 specification, including the standard filtering mechanism. ... Read more

Customer Reviews (8)

Good Intermediate JSP Book


This book will probably be most useful to someone who knows JSPs and servlets and has worked with them, and is looking for better or alternative ways of writing JSP applications.

The first two chapters provide a review of JSPs and an overview of web deployment.They include a nice JSP/MySQL example, with
instructions indicating how to build the MySQL database and incorporate into the JSP example using JDBC.

Chapters 3 and 4 include discussions and examples of how to use JavaBeans and custom tags.The JavaBean example shows how to handle the display of a large amount of data retrieved from a database.

The use of J2EE patterns is discussed in the next several chapters, as befitting a book with "best practices" in its title.The four patterns covered are the Decorating Filter, Front Controller, View Helper, and Dispatcher View.

The remainder of the book covers some topics that are not directly connected to JSPs, but may be useful in a wide range of software applications.These include regression testing, and the use of JUnit and JMeter;deployment, and Ant and CVS, as well as precompiling JSP pages;and application frameworks, including an example.

In short, the book includes a collection of topics not often found in a JSP book.

I noticed some minor quibbles, such as use of single-character variables and older break tags (rather than
),
but generally speaking I find the book to be quite informative and practical, especially in the discussions and use of open source software such as MySQL, JUnit, JMeter, and Ant, with JSPs.

The best book on JSP / Web application development
This book draws a clear picture on JSP web application development. If you are a JSP beginner, this book is a must read. It teaches you the right way to do things from the beginning.

I really enjoyed its step by step approach that leads to the framework based application development, makes a lot of sense to me.

Disappointingread
I can save you money on the purchase of this book. If you can answer "yes" to the questions below, there is no need to buy this book:

* Do you know what JSP and servlets are?
* Do you know how to separate presentation and business logic with JavaBeans and custom tags?
* Are you familiar with MVC?

If so, no need for the book. I was expecting much more. It's less best practice, and more typical web app development. What disappointed me further was various comments in the text that displayed poor practices in areas outside of JSP web development, e.g. "the first step in developing a jsp web application is designing the user interface."

My one-star rating can be summarized as follows:

* Poor typesetting and book formatting: -1
* Very few "best practices" -2
* Below average writing, low content-to-price tag ratio -1

Fills an important niche
I am teaching myself server-side Java programming. After reading, using, and reviewing many books on Java server-side web development, I had found they fell into two categories: Beginner and advanced. The beginner books typically introduce a lot of bad coding practices, such as filling JSP pages with java code, or using outdated examples of Servlets that output HTML. After a few chapters of this, they jump to the Struts framework, thereby never helping the reader build good coding practices and skills.
The advanced books get quickly into frameworks like Struts, and also employ EJBs. EJBs are not needed in many web applications, where they introduce unneeded complexity. What I wanted but couldn't find was a good book that covered the middle ground: how to build applications based on JSPs and Servlets that demonstrate good design and coding practices, with a realistic sample application, and yet understandable for someone learning the J2EE technology.
When I found this book I was surprised to see that it concisely and clearly presented all the key topics I had hoped for. I found it by accident, because I never would have guessed from the scant 3 or 4 reviews on Amazon that it would be worth looking at.
Prerequisite knowledge for this book is basic Java skills and an introductory understanding of JSPs and Servlets. I liked this because so many beginner books spend a lot of time going over the basics. The book covers all the key intermediate-level topics you'll need to get started coding good Java web applications. This book goes beyond others I read in also showing how to use JUnit to do unit testing, and Ant to do application deployment. The author demonstrates these so clearly and simply that a person new to these tools will find it easy to follow and put to use.
Finally, the author finishes with taking the reader through how to build a basic but solid application framework that even the beginner to frameworks can follow. This framework is no Struts with its relatively steep learning curve. By the time the reader has got to the framework chapter he has learned what he needs to understand the framework. As if this were not enough, the author then shows how to deploy the framework, and then use it to build a sample application. All this is done in slim, concise, easily-to-follow chapters and code that is clearly and completely presented. You won't have to go hunting through the source code download or CD to research a bunch of code that is not illustrated in the book itself. It's all in the book.
A previous review rated this book low because he thought it didn't have a realistic application. I don't know what he is looking for exactly, but I thought the application was quite real enough in giving a fully functioning, realistic, web application. It is no super app, but neither is it a toy app. Again, it aims for the later novice to intermediate-level skill set. And I think it succeeds well.

Not bad, but could be better
I agree mostly with what some of the other positive reviews read.The discussion about different design patterns was interesting to read.

However, I did get caught up on the source code in the book. I would think that a book is supposed to be about "best practices" would handle quotes in database inserts/updates.Is it common practice to assume that your form data will never contain erroneous information that will cause your system to fail?

I don't want to harp on this book too bad (many others are worse), but I am still searching for a solid JSP book that has sample code on how to build a solid/useful application from start to finish, while maintaining a clean separation of business logic and actual presentation. ... Read more

Product Description
JavaServer Pages technology allows Web developers and designers to rapidly develop and easily maintain information-rich, dynamic Web pages that are platform independent. JavaServer Pages technology uses XML-like tags and "scriptlets" written in the Java programming language to encapsulate the logic that generates the content for the page. This book is geared towards JavaServer Pages developers, bringing them a confident functionality and usage with XML. There are many examples within the book that are usable in other projects. The reader learns to build and expand custom JSP tags, which can realistically be used on any JSP project. Many advanced topics are also covered to maintain the interest of the more accomplished JSP developer. ... Read more

Customer Reviews (1)

Got Source?
Greetings, all in all this book is easy to follow and has many examples, but lacks a CD with source code. Not to worry, you can download a ZIP file containg all the code. Unfortunatly, they have the wrong publishers site listed in the book. I searched around and found the true link. ... I hope this helps. It's the only way I found it. Other than that, the examples have saved me countless hours. ... Read more

Product Description

Web development is simpler than it seems, especially with the software tools freely available on the Web. This book breaks from the tradition of teaching a history of Web development and jumps to the good stuff from the outset so that students can start writing real applications.

This comprehensive textbook introduces readers to the three-tiered, Model-View-Controller architecture by using Hibernate, JSPs, and Java Servlets. These three technologies all use Java, so that a student with a background in programming will be able to master them with ease, with the end result of being able to create web applications that use MVC, validate user input and save data to a database.

Features and topics:

• Presents the many topics of web development in small steps, in an accessible, easy-to-follow style; focusing on the most important information first, and allowing the reader to gain basic understanding before moving forwards

• Uses existing powerful technologies that are freely available on the web to speed up web development, such as JSP, JavaBeans, Annotations, JSTL, Java 1.5, Hibernate and Tomcat

• Starts with the simplest technology for web development (JSP) and gradually introduces the reader to more complex topics

• Core technologies are introduced from the outset, such as the Model-View-Controller architecture

• Includes many helpful pedagogical tools for students and lecturers such as, an introduction to each topic, questions and exercises at the end of each chapter, detailed illustrations and chapter summaries

• By using Hibernate as the database tool in this book, there is no need for the reader to know SQL

Written for novice developers with a solid background in programming, but who do not have any database training, this thorough, easy-to-use book provides an exemplary introductory course in web development for undergraduates, as well as web developers. With its straightforward and systematic style this text is also ideal for self-study.

Tim Downey has over ten years experience teaching web development, and has won Outstanding Teaching Awards in 1997, 2002, 2006 and 2007. He maintains the following active website which contains many complete examples and tutorials: http://www.bytesizebook.com/

Customer Reviews (5)

Web Development with Java: Using Hibernate, JSPs and Servlets
Pulled down the Kindle edition of the book and at first glance I was happy with the book. When you get into some of the later chapters from about 6 on, the book stops being a "type this in and run it" to see how it works which I fine very helpful when trying to learn a new technology. I've even went to the website to pull down the example from there thinking that I missed a step or two only to find that the not all the code is in its complete condition which did not help in the understanding of what the chapter was trying to accomplish.

If you are looking for a book that started with a basic web app and allowed you to add code building on the code that came before progressing to a more advance web app, I don't think this is the book of for you. I did get some useful information from this book but I was hoping for more.

understanding a java web application
I have almost finished reading the book.
It is clear, the examples help you understanding the mechanism of a web application.
It is a straight and concise introduction to web applications: in an affordable number of pages you can have the basic tools for starting, I trust in the best way.
There are some references to libraries which are not immediately clear and the evolution of the web application with unclear changing of the name of the packages but finally, I found a book which made me able to understand a java WEB application.

A useful textbook for beginners
This is a great book for a niche audience: Students who are familiar with the Java language, but not with Hibernate (a popular library for storing objects in databases), JSPs (a format for embedding Java in HTML pages--the book does not assume previous experience with HTML) or servlets (Java code that interacts directly with HTTP requests). It is, in short, a comprehensive textbook on the subject, well-suited to undergraduates who have taken only a course or two on programming.

Those with prior web development experience are more likely to be interested in learning about a particular architecture. Few web applications are being developed with JSPs and servlets these days; instead, most use something like Spring MVC, Struts, Wicket, or the Groovy-driven Grails (my personal choice), all of which have fine books dedicated to them. Typically, these web frameworks act as a layer on top of the servlet layer, greatly simplifying the architecture. Learning to use servlets first might help to better understand the more high-level APIs, but it's probably unnecessary. If you want to jump right into creating professional-grade web applications for the Java platform, I'd suggest The Definitive Guide to Grails.

Awesome !!
I got my hands on a copy of this book, and I couldn't stop reading it.This books is really well written, its clear and understandable, a very rare feature in J2EE books.

If you are looking for a book to learn the basics of Web Development using Java, this is the one for you, it guides you through complicated concepts such as JSP-Servlets interaction, formerly-cryptic web application directory tree, with so much ease.

I highly recommend this title to all the developers/students/java enthusiasts that want to learn how to do Java Web Programming. Advanced programmers might find it somewhat basic, but still a very good conceptual reference.

Web development using current Java technology
The rapid changes in Java web technology have left a morass of outdated books. So it is refreshing to see this book using Java 5 annotations, JSP 2.0 with its EL (expression language), and Hibernate 3 annotations both for validation and for persistence. Unfortunately Spring is not covered, causing home-grown solutions for some things Spring could do. I didn't see any real errors in concepts, but there are gaps and statements that depend on the specific case being considered, where this dependency is not clear. For example, there is a statement on pg. 157 that only Hibernate can set the primary key for a row, but this is only true in the @GeneratedKey case in use in this example.

The helper code has no comments and scanty explanation. Some bad practices are in the code, such as HTML by generation by Java printlns and swallowed exceptions. Of course a teacher can fix up localized problems, so this book could be used in a web apps course, and has almost no competitors for a textbook there. It has questions and "tasks" at the end of each chapter, a first for such books in my experience. It covers the basic user interface techniques you need for a simple web app, and a little about multipage apps and MVC organization. There is nothing about a service API, or any layering in the app. ... Read more

Product Description

CodeNotes provides the most succinct, accurate, and speedy way for a developer to ramp up on a new technology or language. Unlike other programming books, CodeNotes drills down to the core aspects of a technology, focusing on the key elements needed in order to understand it quickly and implement it immediately. It is a unique resource for developers, filling the gap between comprehensive manuals and pocket reference.

CodeNotes for J2EE: EJB,JDBC, JSP, and Servlets introduces Java developers to the key database and web development technologies of the Java 2 Platform, Enterprise Edition. The JDBC API, JavaServer Pages, and Servlet frameworks are covered individually with examples that show how these technologies work together to create robust, dynamic web-based applications. The book also explains how to use Enterprise JavaBeans to create large, distributed, scalable applications.See "About the Authors" at the beginning of the book for more information.
... Read more

Customer Reviews (6)

Just Great! Suggest that publishers benchmark this series.
I think I was very lucky to have found this book while I was struggling to grasp the idea of what J2EE is all about reading a very thick book from another publisher. I am quite sure 3 days spent on reading this book was worth much more than over 10 days spent on getting lost while reading another one. How amazing it is that such a small book covers almost all the important aspects of J2EE (even design issues!). I can't wait for the new books in this series (such as C, C++, etc) to hit the market. Other publishers that are notorious for their verbose style in their books should learn some philosophy from this series and stop wasting the valuable time of the readers with enticing but practically unnecessary details.

The sample of a good-written IT book
There are a lot of thick IT volumes that give us examples of how NOT to write IT books. CodeNotes for J2EE is an opposite example. It is undestandable, precise and contains only sufficient information.

Don't use without checking the online errata!!
Good idea, poor accuracy - the online errata page could fill a small chapter!! For a book which condenses (complex?) 'tekki' info like J2EE into a readable, understandable, and USEABLE 'guru' reference, accuracy REALLY counts!!Without updating your copy from the online errata, you could easily 'be pulling your hair out' for quite a while by following the instructions found in here. Also, I was surprised at their comments regarding the recent migration of their website from J2EE to .NET.One of their listed reasons was "...and the drag-and-drop method of web development.(for .NET)". Wow!!For people who sell 'technical guru how-to' books, this sounds a bit like taking advanced painting lessons from teachers who 'paint by numbers'!! Call me 'antiquated', but I think that their website should reflect the technical competence that they purport to publish.

Small profile yet gets right to the point!
This book was a real pleasure to own.The book is small enough to fit in my notebook computer bag and contains essential reference information, so that I could write some prototype code within an hour or two.My leather computer bag now has an imprint of this book, which I don't mind because of the confidence it gives me to know it is available.

The book covers all the essential information needed to install the J2SE, J2EE and TomCat environment in Windows.There was little more than references to installations for Solaris and Linux.Most folks with UNIX experence shouldn't have much problem setting up the environmental variables.

An annoyance with this book is that Chapter 4 attempts to cover topics with JavaMail, RMI, COBRA, JNDI with little content.The chapter appears to be an aborted attempt since it is only 3 pages long.These topics should just be placed in a glossary.

I am also really pleased with the publishers profile for this series of books. Most publishers of these books tend to go for quantity over concise reference material. This is a big relief compared to "Java for the Web with Servlets, JSP and EJB" which is 976 pages (a big 4 lb red brick).

Gets Right to the Point
I like this book very much because it gets right to the point.Sometimes when reading through massive programming books, I find myself wondering how relevant the current topic is.Is this really something that is widely used in the real world, or is this fluff?Every page of this book contains just the important stuff with no filler.

The section on EJB may have even been a bit too consise.Enterprise Java Beans is a very complicated topic that is difficult to give a short summary of.Even so, it's nice to have a well-written book that explains how the whole of J2EE hangs together.(I have another book about EJB).

I hope that smaller technical books become the trend.I'd much prefer a consise 250 pager over a 1000 page book that has no focus. ... Read more

Product Description
Write, adapt, deploy, and debug powerful and robust applications with help from this comprehensive resource. Learn how JSPs integrate with Enterprise JavaBeans and JDBC, and how they communicate with other Web components, including Perl, CGI, servlets, and applets. Well-suited for both experienced JSP developers and those new to JSP technology, this book is an ideal reference. ... Read more

Customer Reviews (10)

Descriptive Book
Indeed a nice book. I wonder where i will get the source code of examples used in this book?

detailed, trustworthy, well written: superb
I had previous edition and bought this one too. Previous one proved for me to be absolutely invaluable for understanding of technicalities of jsp pages and underlying mechanics of jsp and servlets. Because of many changes between last and current releases of jsp and servlet technologies two editions of the book are different but format, luckily, did not change: author adheres to concept of giving concise but clear and very friendly explanations. Despite of confines of single book, he does not short cut on good design for his examples therefore making them especially valuable.
It is classic approach to jsp; approach that is not cluttered by hastily explained now-fashionable frameworks like Struts. It gives you foundation and knowledge for making your own framework.
I would highly recommend this book to anybody interested in java-based web development. I, myself, am using Struts framework for my current project but the books by Phil Hanna are giving me special power named solid knowledge of theory and concepts that you cannot find in books specialized on one particular topic like EL, Struts etc.
Overall, I am very grateful to Phil Hanna, because he, obviously, stays focused on his task of producing REFERENCE that is needed and gets referenced all the time in order to produce your own unique recipes.
I am sure that the author can write a lot of other books on web technologies that are just mine field for unaware developers (faithfully yours). I would buy those books.

Complete!
Book is excellet, packed with useful examples and appendixes, indeed a COMPLETE REFERENCE to JSP.

Complete reference to what?
This book is terrible. The Complete Reference to JSP? If I wanted a book to explain the HTTP protocol, HTML forms and other non JSP topics I would have purchased another book. The examples are simplistic... Too simplistic.
If your seriously trying to learn JSP find another more advanced book with real examples.

Just great
I'm usually not a big fan of the osborne series, but once in a while, they get it right.This book is indeed complete.The only reference you will need. ... Read more

Product Description

JSP developers encounter unique problems when building web applications that require intense database connectivity. MySQL and JSP Web Applications addresses the challenges of building data-driven applications based on the JavaServer Pages development model. MySQL and JSP Web Applications begins with an overview of the core technologies required for JSP database development--JavaServer Pages, JDBC, and the database schema. The book then outlines and presents an Internet commerce application that demonstrates concepts such as receiving and processing user input, designing and implementing business rules, and balancing the user load on the server. Through the JDBC (Java DataBase Connector), the developer can communicate with most commercial databases, such as Oracle. The solutions presented in MySQL and JSP Web Applications center on the open source tools MySQL and Tomcat, allowing the reader an affordable way to test applications and experiment with the book's examples.

Customer Reviews (8)

The Worst Technical Book I've Ever Bought
This is without a doubt the worst technical book I have ever bought.

Some of the problems stem from the fact that most of the packages used are now out of date.Case in point:the book walks through the installation & configuration of Turbine (which is used for connection pooling), unfortunately the connection pooling part of Turbine has now been branched off into another project (and Tomcat now includes standard J2EE connection pooling anyway).

The other major problem is that a nearly every instance of example code is either sloppy and badly edited, or in some cases plainly doesn't even work without serious debugging.

If you must buy this book, don't even think about trying to follow the core example application without first downloading the source-code from the authors website.You WILL be needing it, even if only to 'fill in the blanks' from the poor instructions, and to help find the coding errors.

In conclusion, I would never recommend this book to anyone - even another experienced programmer trying to add JSP/Servlets to their repertoire.

Do yourself a favour, buy Murach's book instead.

Why would anyone give this book 5 stars
I have read this book from cover to cover and used many of the examples in some of my development. There are errors in the editing to be sure. For the most part most are minor e.g. links that end with .htm instead of .html will not work or if you create the database in mySQL, in my case on a Linux platform there are errors you will run into. These errors are limited to making sure you observe the case of the letters in creating and quering your database. This book is not for the beginner. It teaches a systematic approach to building an ecommerce web site using jsp's and mysql. The reason for the 5 star rating is this book makes you go out of the box to learn ant, turbine and other opensource packages to build a working e-commmerce web site. Personally I do not like to put java code int an html page = jsp's ... but this book offers sound eamples and good advice. One of the better practical but certainly not perfect books I've bought.

Poorly edited
I was encouraged when I first started reading this book, but soon I grew disappointed. The book is peppered with useful tips here and there, but in general it's too linear, as an earlier review mentioned. The book is more of a recipe for a web app than a general guide, and it wastes too much space on design process. But worse than that, it is fraught with errors, as if edited by someone who didn't understand the material. Letters have been dropped from words, referenced figures don't show what the referencing text says, there are errors in XML examples. A funny example is on the "In This Chapter" sidebar on the opening page of Chapter 2 where one of the bullet items is "Bean Resistence". More power to the beans! He meant "Bean Persistence", but hey, if you're going to get it wrong, at least spell it right. :)

Some valid information but stays strict to Turbine
I picked up this book as a reference for integrating our PHP and MySQL designs with JSP pages.However the author sticks to a single fundamental method of JSP development for MySQL which is using Apache's Jakarta Turbine classes.No information is given as to the other mechanisms available to utilize MySQL with Java such as MySQL Connector/J or Resin JDBC.I believe this book is a very shortsighted approach to the many tools available in the Java and JSP world. I think the Turbine approach is fine, but should maybe have been a later chapter not most of the book.We developed our entire web site without the use of Turbine.

Some discussion is given to strategies with JNDI and LDAP, as well as EJB.There is also a healthy discussion of XML which I believe would be better suited for an XML book, but serves as nothing more than filler here, which could have been used to expand upon the other methods of JDBC.

I would have given this book three stars, but several errors in the code examples always bring down quality by at least one star.I expect a book written by a developer for the purpose of instruction to be error free in all code examples.

All in all the book appears to be a step by step tutorial to building a program according to the developer's linear scheme, rather than a comprehensive discussion of all the options available to a JSP/Servlet developer integrating with MySQL. Sadly this really is the only book available on the subject at this time.

What the Doctor Ordered!
If you are using the Tomcat, MySQL, JSP configuration, this book is the absolute perfect marriage of these technologies.It covers every aspect of the implementation.It is required, however, that you do have a little background in 1 or more of these technologies.The examples are excellent and at times the book is a lighthearted read.Kudos to the author. ... Read more

Product Description
JavaServer Pages, together with the Java Servlet API, provide the dynamic web content presentation layer for the Java 2 Enterprise Edition. JSPs and Servlets integrate tightly to enable scalable and portable applications, and are widely supported. This book extensively covers the next generation of these technologies, JSP 1.2 and Servlets 2.3, which are nearing completion under the Java Community Process and provide major enhancements to Java's web programming model.

This book looks in depth at these core components of the forthcoming J2EE 1.3 platform, preparing you for building the next generation of web solutions. You'll learn about the enhancements to the JSP tag library model; the new filtering and application event facilities; how to architect web applications to ensure clean separation of presentation and logic; and the increasingly popular Jakarta Struts framework. The book also addresses using JSP with XML and XSLT; databases access with JDBC; and how JSP and Servlets fit into the overall J2EE platform alongside Enterprise JavaBeans, JavaMail, and other J2EE technologies. ... Read more

Customer Reviews (23)

Not for beginers
I thought to learn JSP just by reading this book. I read several review comments on this book and other books. Fairly thougt to buy this one on hope of better explanation.
Though I am new to JSP, but working on programming for 13 years.
1. I did not get a streamline explanation to start the first program. Someplaces exaplanation is too much, I was lost.
2. Explanation on Tomcat installation won't be helpful because of older versions.

Those have already known JSP TAG, Bean etc. it may be helpful for them. But purely it is not for beginners.

Information overload
Explains one aproach then rejects it in favor of another then yet another. By the end you discover that you should have bought a book on Jakarta Struts if you want to develop real JSP sites because someone has already done lots of work for you.

An excellent book
I have never read such an excellent book before. No wonder the JavaRanch community rates this book 10 horseshoes!

Good but with some notable problems
Wrox Press continues their time-honored tradional of piling as many authors into one 1200 page volume that they can in the hopes that they will end up with a definitive treatment of the subject. The authors range from seasoned professionals with real-world experience to people with nothing but a year or two of college computer science courses behind them.I must confess that I am not sure what I was expecting in these chapters but since JSP Tag Libraries seemed to be one of the more challenging and interesting areas of JSPs I was hoping for some more meaningful, 'meaty' content.

The assembly of these 18 (yes, 18!) authors wind up generating a book that essentially could have been put together with more precision and continuity if it had 15 fewer authors. It very much comes off as a rushed effort, without any tightness whatsoever. The writing style of this second edition can only be described as amateurish. This, fortunately, can be a little easier to swallow if you accept the spirit of the book (in Wrox's words 'Programmer to Programmer'). Take the text as quickly put-together material from programmers that have been through it (even if it was brief or only in school) and you should be fine.

Many unnecessary forward references exist throughout the text and, because of the unusually large number of authors, there is a large amount of repetition in the body of most chapters. The book's page count could also have been greatly reduced had the authors not consistently given condensed introduction to material that ends up being the subject matter for entire chapters later in the book. For example, two early chapters describe the basics of Tag Libraries, only to have them surface as the primary topic of chapters 8 - 11.

The code included throughout the book is variable in quality, as you might expect. The book doesn't pretend to be an academic tome of best practices or a showcase for some top-flight, brilliant programming but you end up thinking that many of the examples could have been made much more effective with more thought put into them. As with many other programming books out there, this one is definitely not without its errors. You'd hope, however, that with the 21 technical reviewers and 3 editors that worked on this book that it would have fared better than most.

In summary, if you take the text for what it is and skip over the segments of fluff and numerous poor code examples I think that most professional programmers new to this technology will find enough material to make the hefty price tag almost worth it (especially if you share it with others on your team!).

Good as a Novel
This book is awesome. The one thing I truly love about this book is the layout. I had zero experience in JAVA/J2EE and after the first chapter it all made sense. I Actually make time to read this book.

The one thing this book does that no other I have read is tech the low level nuts and bolts along with top level syntax and make it make sense. For instance, the chapter on Servlets rocks. It teaches Servlets on both "Here are Servlets" and "How to use them".

I highly recommend this book for anyone wanting to learn JSP/Servlet environment. It is a great book to learn the big picture and be able to use all know features in the technology. ... Read more

Product Description
JavaServer Pages (JSP) is a technology for building dynamic web applications that can access databases and provide an interactive experience for users. It's a powerful technology with open source implementations (server and platform independent) for building enterprise Web applications.With JSP, existing business systems can be leveraged with minimal overhead, maintenance, and support.JSP: Practical Guide for Java Programmers is designed to cover the essentials of JSP including the basic JSP constructs and the relevant implicit objects as well as more advanced concepts such as incorporating JavaBeans, developing custom tags, utilizing the JSP expression language, building with the JSP Standard Tag Library, and developing complete JSP-Servlet application. Throughout the book, an electronic bank Web application is used to introduce new concepts, while demonstrating to the reader how the pieces fit together.

*Covers the latest release of JSP, version 2.0, and covers new features such as the Expression Language and Standard Tag Library.

*Includes a sample application of an electronic bank Web site, showing the power of JSP in providing the foundation for building Web applications .

*Provides a clear, straight-to-the-point approach to the JSP so that readers can start using it in their own projects right away.

*A supplemental web site includes code for all of the examples in the book as well as additional resources. ... Read more

Customer Reviews (1)

effective and easy to read, but beware of typos
This is a slim and easy to read book which covers JSP 2.0 in just about the right amount of detail to get a competent Java programmer up to speed quickly and effectively.As well as JSP there is a also a very brief and shallow introduction to a few other associated technologies: servlets, CSS etc.

The writing style is polished and comfortable, but a worrying number of typos and other errata have slipped through the editing process, in particular in the first part of the book.I suggest it would be a good idea to check the associated web site before relying on the printed code and configuration examples.I'm also uneasy about the choice of example application used as a case study throughout the book.While everyone is likely to understand the idea of a bank, the examples given neither make a very convincing bank, nor make particularly good use of JSP technology.

This book will be useful for anyone starting work on a web application project which makes use of JSP 2.0, but who doesn't want to wade through the specification documents. If your project still runs on an older version, this book will only be frustrating, but it might just tempt you to upgrade. ... Read more

Product Description
Professional JavaServer Pages covers a wide variety ofareas including design and architecture, JSPs and their relation toJ2EE (Servlets, EJBs, JDBC etc) as well as extensive coverage of thetag extension mechanism that allows you to customize the tags you usein your pages to the data you're presenting.

Readers are given anintroduction to JSP, explaining how they relate to servlets, showingthe tags, and creating beans to encapsulate business logic, to keepweb page design simple.Further chapters cover database access withJDBC and connection pooling, JSP debugging, and web applicationarchitecture using JSP and servlets.

After considering security issues in JSP web applications, the bookconcludes with seven real-world case studies including using JSP, XMLand XSLT to target content at WAP and HTML browsers, e-commerce,streaming using JMF, and porting an existing ASP-based application toJSP.Appendices give programming refreshers on installing the TomcatJSP/Servlet engine, detailed references to JSP, the Servlet API, andHTTP, and finally JSP for ASP programmers.

This book is for both professional Java developers, who want to useJSP as the front-end of their J2EE web applications, and webdesigners, who want to see how JSP separates presentation from dynamiccontent generation.Although no knowledge of Java is assumed,reference will be made to a quick start Java tutorial atwrox.com and to other materials for some topics.Knowledgeof HTML and some programming experience is required.Amazon.com Review
For readers with some previous Java experience, Professional JSP is a comprehensive guide to today's JavaServer Pages (JSPs). Besides a solid tutorial on JSPs and servlets, this book gives you lots of useful examples of how JSPs can work with other Java APIs (like EJBs and XML) to deliver highly functional Web sites.

Professional JSP shows the underlying servlet code for many JSP samples. As explained by the authors, JSPs are a simpler way to write servlet code because Java statements are embedded within HTML. This fact makes the book especially useful to programmers who know about servlets and want to progress to JSP development. The introductory tutorial to JSP is as good as any you'll ever see. Short examples illustrate basic JSP features like directives, scripting elements, implicit objects, and JavaBeans. The book also reveals a variety of ways to track session information (including cookies), which is particularly helpful.

Several case studies show key concepts in action, including how to use custom tag libraries. Nicely functional samples include a Web site for an online investment company, a photography database, and a membership-based online grocery store. (This last example shows how to use LDAP and JNDI to store user information.) In addition to a thorough tutorial for learning JSPs, chapters in this text look at combining EJBs, XML, and other Java 2 Enterprise features that you'll need for successful real-world development. Handy appendices detail how to install and configure the free Apache Web Server and Tomcat JSP engine. There's also a reference to all JSP and servlet objects and APIs.

Overall, you'll mine plenty from Professional JSP, including several extremely useful coding examples that'll get you going on serious development for real-world e-commerce Web sites. --Richard Dragan

Topics covered:

Introduction to Java 2 Enterprise Edition and JavaServer Pages (JSP) JSP, CGI, and ASP compared The JSP life cycle JSP directives, scripting elements, standard actions, and implicit objects Servlet architecture and APIs Using JavaBeans with JSPs JDBC database programming basics Using the PoolMan database connection pool manager Storing session state with hidden fields, cookies, and URL rewriting Error handling and debugging with JSPs

Tag extensions and tag libraries Personalizing look-and-feel and content with JSPs Global settings JSP architecture Security and personalization with JNDI and LDAP Introduction to Enterprise JavaBeans (EJBs) HTTP streaming with JSPs Basics of the Wireless Access Protocol (WAP) Wireless Markup Language (WML) XML and XSLT Case studies on e-commerce and Web-site personalization

... Read more

Customer Reviews (26)

Comprehensive
The most comprehensive book I've ever read about JSP! Must have for JSP developer

full of details, but presented in many different ways..
I think the authors of this book are really "Professional" in working on their projects, but not really "Professional" on how to work together to make a good book that is easy to read and understand. I'd recommend "Web developement with Java Server Pages" (from the IBM "Einstein" & the MIT "Rocketman") Save your penny my friends.

Not For Beginners, No Practical Use
The title of my review sums it up.For a beginner I expected this book to get me up and running, It never did.I read the first 5 chapters and their was way too much focus on the Java code that was created by the JSP engine from a JSP page, and not enough emphasis on how to implement and use JSP.BOOOOH.And there are numerous spelling mistakes, including one on the first page of the introduction.C'mon WROX, wheres your QA/Copywriters?I will return this in exchange for ISBN 1884777996

Too wordy - hard to understand
I didn't like this book.The examples are hard to follow.Also, it assumes you want to use other technologies like Servlets in conjunction of your JSP pages, which I'm not.API is not organized very well and hard to find things fast.I hope my O'Reilly (on order) is better...

Good JSP book, but .......
Too wordy, like other WROX books. ... Read more

Product Description
...the pattern chapters have plenty of code that allows you to understand the pattern both by explanation and by example of a real application.

— Tom Duff, Duffbert's Random Musings

Foundations of JSP Design Patterns gives you the tools to build scalable enterprise applications using JSP. While other books merely provide instruction on basic JSP and servlet development, this insightful guide goes a step further to offer a variety of best practices and design principles, enabling you to build your own scalable and extensible enterprise Java applications quickly and easily. Through the application of enterprise design patterns, JSP technology can be used to build complex enterprise applications in a highly reusable manner.

Customer Reviews (4)

All IN ONE
Very helpful book for beginners to intermediate level java developers. Because,
this book starts with introduction to jsp and chapter 1 and 2 cover,
* The basics of the JSP2.0 specification
* Describes the syntax and commands, used to produce dynamic content.

After the two introductory chapters, you will move into the real thrust of the
book. Chapter 3 and 4 take the roles of developer and page designer, which
gives you,
* Introduction to javabean to deal with data,
* form handling to deal with html data
* Custom tags to build with reusable html tags.

The next chapters show you how to separate designer and developer role by
separating the application into layers, or tiers (View, Model and Controller).
Chapter 5,6 and 7 present about,
* Pattern for your web application design,
* MVC action for controlling your application
* Filter to intercept the HTTP requests and responses.

Chapter 8 finishes the pattern with,
* View helper pattern that you use to adapt data to the presentation
layer of application.

Now those chapters they have provided after 8 are surprised, personally I like this
very much about they have discussed on testing techniques and deployment techniques.
Which are very helpful chapters for some one who wants start to finish developing web
application.
I have liked chapter 3, 4, 5, 9 and 10 of this book.

The next step for intermediate JSP developers...
If you're familiar with JSP technology and you're ready to take the next step, you might find the book Foundations Of JSP Design Patterns by Andrew Patzer (Apress) interesting...

Chapter list:JSP Foundations; Using JSP; Role Separation with JavaBeans; Role Separation with Custom Tags; Development Using Patterns; The Decorating Filter Pattern; The Front Controller Pattern; The View Helper Pattern; Testing Techniques; Deployment Techniques; Application Frameworks; Putting It All Together; Index

While this book does cover some basics of JSP, I wouldn't recommend it for a complete newcomer to the subject.This book is more designed for the person who has learned the basics, done some work with JSP, and would now like to learn how to better structure their code to separate business logic from presentation.Patzer does a good job in showing how a consistent approach to presentation/logic separation can avoid maintenance issues down the road, and how it allows developers and designers with different roles to work together on a project.By introducing patterns, the developer can build applications with a solid structure that follow proven architecture that works.The thing I appreciate most is that the pattern chapters have plenty of code that allows you to understand the pattern both by explanation and by example of a real application.That helps take the information from a theoretical to a practical level.The chapters at the end that deal with testing and deployment are also very valuable, and they should help the developer to follow a solid approach to JSP application development from design through implementation.Very good material here.

Respect due to JSP
For the front end of Java web applications JSP has never been given a lot of respect. It's always been the domain of lower paid 'front end programmers'. But that doesn't mean that it isn't difficult to do it right. This book takes the time to emphasize the patterns of implementation to make a solid web front end.

The book covers the web application page flow of forwarding and maintaining state. It also covers tag libraries, data validation and a host of other topics.

The text of the book is well written, and graphics are used effectively.

This is a great book for front end developers. This is the type of coverage this complex topics needs. Hopefully we can get similar books for PHP and Perl web development.

Understand the idea of patterns
A good reworking of what are now classic JSP design patterns, as codified by Sun and others. You need never have read about design patterns to appreciate this book. But chances are, you're already coding JSPs and Servlets. If so, you need a book like this. At the very least, a rough Model-View-Controller design will aid your coding.

But Patzer also goes into more detailed patterns. Like a decorator filler and a front controller. But perhaps as important as any specific pattern is that you get some idea of what to look for as a pattern that might arise out of your work. The patterns in the book show you code reuse, at a higher level than literal reuse of a given body of source code. A very powerful idea for you to grasp.

I reiterate. Understanding, using and looking for new patterns moves you into the realm of design. Increases your experience and your value. Design is higher margin work. Makes your skill sets more valuable.

He also introduces you to the discipline of testing. Especially having a unit testing framework. And since this is java, you have JUnit to help you. ... Read more