Book Description
Ideal for the 3+ million Java developers, this fast-paced tutorial offers in-depth coverage of JavaServer Faces (JSF) -- Sun Microsystem's Web application architecture for the future. Co-written by the #1 JSF expert in the Java community, this book offers the most complete resource on JSF available. * Extensive coverage on JSF custom component development * Serves as a thorough introduction to AJAX technology and techniques * Numerous custom JSF component examples including AJAX enabled components provided
Customer Reviews:
good coverage, too much discussion.......2007-08-17
The book has very good coverage, my only complaint is that explanations are too long. I think the whole book can be condensed into 100-200 pages.
Not fun.......2007-04-06
I bought this book because it's the best-seller for JavaServer Faces according to Amazon and I don't like it that much. I've been reading a lot of Computer books lately, and a lot of them are surprisingly well written and fun to read. This one is not. The writing is less than stellar and it doesn't have the dorky humor that other computer books have.
On the plus side, I am learning a lot from this book and I don't have much to compare it to as far as other JSF references. It's the most up-to-date one when I bought it, which is important since it's still an evolving framework.
Very good book, its deep and explains very good.......2007-02-18
The book goes over all the stuff in JSF and explains in a very clear language exactly whats happening under the hood of JSF. I have also some other JSF books and this is by far the best.
The most comprehensive JSF coverage so far!.......2007-01-24
I really enjoyed reading this book. I have several JSF books, and I feel that most of them were rushed to the market. This one is an exception. The coverage is very comprehensive (the book is written by the spec lead), JSF 1.2 is extensively discussed. The book covers multiple open-source "sub-frameworks" for JSF such as Shale and Facelets as well as various component libraries.
JSF is a relatively complex framework, and one does need a good reference to be able to master it. I think this book is it.
JavaServer Faces is the FUTURE.......2007-01-17
This book is great! It starts out simple but moves at a brisk pace that helps keep you interested. I'd definately recommend this to anybody interested in JSF or for someone who is looking for a good MVC framework for Java. If you're a Struts developer and want to make the shift to Java's standard MVC framework than BUY THIS BOOK!
Book Description
The examples are thorough and come with loads of readable code listings. In addition, many complex topics were further clarified with a good use of graphics.
— Lasse Koskela, JavaRanch Sheriff
Book Description
Pro JSF and Ajax shows you how to leverage the full potential of JavaServer Faces (JSF) and Ajax. This is not an entry-level tutorial, but a book about building Ajax-enabled JSF components for sophisticated, enterprise-level Rich Internet Applications. Written by JSF experts and verified by established community figures--including Adam Winer (member of the JSF Expert Group, Java Champion), Kito D. Mann (JSFCentral.com and JSF in Action), and Matthias Weßendorf (MyFaces)--this JSF 1.2-compatible book provides reliable and groundbreaking JSF components to help you exploit the power of JSF in your Java web applications.
This book provides a blueprint for building custom JSF UI components and shows how to leverage the best browser technologies, such as AJAX, Mozilla XUL and Microsoft HTC, to deliver Rich Internet Applications.
This book covers standard best practices for behavioral and renderer-specific component classes, renderers, events and event listeners, and JSP tag handlers for each. It also covers advanced techniques such as dynamic content type negotiation, JAR-based resource delivery, and dynamic render kit selection.
Foreword
"Does the world really and truly need another JavaServer Faces book?
I was fairly well convinced the answer could only be a resounding 'no'! After all, there's a good half dozen books out in stores today, by a whole host of web luminaries, and I've even personally helped as a technical reviewer on half of those. So what more could really be said on the subject?
But when I thought about this a bit more, it became clear that all of these books only go so far. They'll show you how to use what JSF gives you out of the box, throw you a bone for writing your own components and renderers, maybe even a bit more. But none that I've seen get to the heart of why JSF is really and truly cool and important technology; they make JSF look like YAMVCF (Yet Another Model-View-Controller Framework) for HTML - more powerful here and there, easier to use in many places, a bit harder to use in others, but really nothing major. And certainly nothing that takes us beyond the dull basics of building ordinary-looking web applications.
This book goes a lot further. It'll cover the basics, of course, and show you how to build components, but then it keeps going: on to AJAX, on to HTC, on to XUL - and how you can wrap this alphabet soup up underneath the heart of JSF, its component model, and how you can leverage it to finally develop web applications that don't need radical re-architecting every time the winds of client technologies blow in a different direction. Along the way, you'll learn a wide array of open source toolkits that make web magic practical even when you're not a Javascript guru.
So, heck, I'm convinced. The world does need another JSF book."
Adam Winer,
Architect ADF Faces, JSF Expert Group Member, and Java Champion. (From the Foreword)
Customer Reviews:
Too many typos and quite confusing.......2007-07-01
Even for an advanced developer/architect this book does not make sense. There are too many typos, wrong references to Figures and Tables, and confusing diagrams. On the top of all these things, it is poorly written. For example (Verbatim from chapter 2):
Figure -1 shows the five classes you'11 create in this chapter, they are HtmlInputDateRenderer,ProInputData,UIComponentTagSupport,and ProInputDateTag, as well as two you'11 be extending Renderer and UIInput.
As you can tell from the above the author is quite confusing.
Needlessly difficult, -- NOT CLEAR AT ALL.......2006-12-02
I tried reading the first chapter, got through half and realized that the overview was simply hitting the architecture big picture with no code (this is after reading the complete reference cover to cover) -- skipped to the second chapter cause I had no clue where the author was at on chapter 1. Chapter 2, trying to describe component extensions -- the code examples had a bunch of css. CSS? And no mention that css was a part or not a part of jsf. To someone without a design background this would be very confusing. Huh? Why? To take up space that's why.
This is a worthless book that obfuscates. My opinion, they put this thing together to capitalize on the hype surrounding jsf and ajax with no clue as to how to actually teach how to integrate the two. Finally the most annoying thing is about half of the copy starts out "in this chapter you will ... " then some worthless unrelated code and then another section with "in this chapter you will ..." Waste of my precious time and mental space to read this book. They should take a hint from NIKE and just do it rather than talk about it. CODE... examples and more code -- I don't want to read or waste time reading "in this chapter you will"...
Needlessly difficult, no source code.......2006-10-23
This book is definitely written by someone who knows JSF. From the author's point of view, the structure and style of this book may have made sense. From your point of view as a reader, unfortunately, it does not.
The code examples are broken unnaturely and even an experienced developer will find themselves wondering what class this or that code fragment belongs to. There's no solid narrative that shows you how to accomplish the objective of building a component. Instead, there is a confounding play-by-play: do this, then this, then this... Its a memorization challenge.
Complexity is not really an excuse to jettison any attempt to make a book readable. That is the books main flaw, it takes an admittedly challenging subject (JSF and AJAX integration) and makes it almost impossibly uncohesive and, frankly, dull.
Another disturbing fact is that AJAX plays a remarkably small role in the book. So much so that it walks the line of simply cashing in on the hype by putting the name on the cover.
Having found these things to be true, I decided if I downloaded the source code and used that as a framework for understanding, the book might be more useful. I surfed on over to its website only to discover - THERE IS NO SOURCE CODE.
That's just plain scary.
The book graduates from 1 to 2 stars based on the fact that there is a lot of information present, expecially regarding the processing lifecylce. You won't have much fun parsing it though.
When I saw this book, I thought, "Great! This is EXACTLY what I'm looking for." Don't fall into the trap. The title is exactly what you are looking for, not the book.
Moving beyond "Hello World" to cool applications..........2006-06-29
If you already have a background in JavaServer Faces (JSF) and you want to start exploring the integration of that with some of the Web 2.0 technologies, Jonas Jacobi and John R. Fallows have a book that might interest you... Pro JSF and Ajax - Building Rich Internet Components.
Contents:
Part 1 - Developing Smarter with JavaServer Faces: The Foundation of JSF - Components; Defining the Date Field Component; Defining the Deck Component
Part 2 - Designing Rich Internet Components: Using Rich Internet Technologies; Loading Resources with Weblets; Ajax Enabling the Deck Component; Ajax Enabling the Date Field Component; Providing Mozilla XUL Renderers; Providing Microsoft HTC Renderers; Switching RenderKits Dynamically
Index
To be honest, this book was beyond my current technology level. While there is a brief overview of JSF technology, you'll get the most out of the book if you already have a relatively solid grounding in it. They use two components, the Date Field and the Deck components, to show how JSF can be used to build internet application components that are able to be reused in other applications. The real value comes in Part 2, where they take those two components and start mixing them up with technologies that allow for rich internet functionality, such as Ajax and XUL. Using the examples provided, you start to see how a JSF application mixed with something like Ajax allows you to start building internet applications that behave more like desktop client apps... no round-trips to the server... no constant screen refreshes to get new content... Pretty cool stuff. I'd also recommend that you be pretty conversant with the rich internet technology already. Like with JSF, there's an assumption that you already understand the basics, so don't think that your first exposure to Ajax could be with this book. You'll be in pain if you try that route...
If you've had the exposure and you're now looking for some really cool project on which to apply your JSF skills, this could easily be the book that helps you make that transition from "Hello World" to "ooooohhh..."
Advanced Guide.......2006-06-17
The authors begin "This book is not, and we would like to emphasize this, not an introductory level book..." That's for certain. Except for quick review material in the first chapter, the authors move quickly into a project that assumes a good amount of experience.
The book effectively follows a pattern that you have seen before. Build a simple component, integrate it, then progressively build in functionality and complexity while dealing with usability and maintainability issues.
One factor that makes this book stand out is the great number of flow diagrams. This book has the expected code printouts and screenshots but the extra emphasis on logic diagrams is exceptional. Also not seen in other JSF books are two chapters on providing Mozilla XUL and Microsoft .htc renderers. Yes, the last is a bit of a surprise!
Book Description
JavaServer Faces (JSF) is quickly emerging as the leading solution for rapid user interface development in Java-based server-side applications. Now,
Core JavaServer⢠Faces–the #1 guide to JSF–has been thoroughly updated in this second edition, covering the latest feature enhancements, the powerful Ajax development techniques, and open source innovations that make JSF even more valuable.
Authors David Geary and Cay Horstmann delve into all facets of JSF 1.2 development, offering systematic best practices for building robust applications, minimizing handcoding, and maximizing productivity. Drawing on unsurpassed insider knowledge of the Java platform, they present solutions, hints, tips, and âhow-tosâ for writing superior JSF 1.2 production code, even if you’re new to JSF, JavaServer Pagesâ¢, or servlets.
The second edition’s extensive new coverage includes: JSF 1.2’s improved alignment with the broader Java EE 5 platform; enhancements to the JSF APIs; controlling Web flow with Shale; and using Facelets to replace JSP with XHTML markup. The authors also introduce Ajax development with JSF–from real-time validation and Direct Web Remoting to wrapping Ajax in JSF components and using the popular Ajax4jsf framework.
This book will help you
- Automate low-level details and eliminate unnecessary complexity in server-side development
- Discover JSF best practices, ranging from effective UI design and style sheets to internationalization
- Use JSF with Tiles to build consistent, reusable user interfaces
- Leverage external services such as databases, LDAP directories, authentication/authorization, and Web services
- Use JBoss Seam to greatly simplify development of database-backed applications
- Implement custom components, converters, and validators
- Master the JSF 1.2 tag libararies, and extend JSF with additional tag libraries
Preface
Acknowledgments
Chapter 1: Getting Started
Chapter 2: Managed Beans
Chapter 3: Navigation
Chapter 4: Standard JSF Tags
Chapter 5: Data Tables
Chapter 6: Conversion and Validation
Chapter 7: Event Handling
Chapter 8: Subviews and Tiles
Chapter 9: Custom Components, Converters, and Validators
Chapter 10: External Services
Chapter 11: Ajax
Chapter 12: Open Source
Chapter 13: How Do I . . .
Index
Customer Reviews:
The best but..........2007-08-04
Hi, this is the best book you can get.
But I hope in their future version:
1. There should be a new chapter called Managed Bean Environment or something like that. One managed bean cannot do much if it knows nothing about its environment. How to access other managed beans in scopes. How to access objects in scopes. How to access the parameters in the environment. We need to know how several managed beans communicate each other and communicate with their environment to complish a real project. We also need you to provide a concret example like in J2EE5 tutorial bookstore6. I am so pity you missing this crucial part.
2. There should be a new chapter called JSF and Enterprise Bean. This is an important issue to put JSF into a meaningful environment. JSF is for J2EE application. Managed bean need to link to session bean and session bean link to JPA. We need a such example how it works.
3. The chapter 8 to chapter 12 do not realy need to know for CORE JSF and therefore should be dropped to give book space for the above content.
4. In the chapter 5 Data Tables : Editing Table Cells. It is very inconvinient to click a checkbox to active editing mode. I suggest to remove all checkbox because in practise people will edit seveal cell content and click a save button. Also you do not need one inputText and one outputText for one cell. Remove outputText and add readonly in the inputText. Can you tell how to freez header when scroll a table?
5. There should be a chapter to talk about JSTL. It seems my request is out of the topic but it is not. JSTL is hard to stand out for an independent book. It will live with JSF. In real project, JSF is always mixed with JSTL to make a web page. We need to know when and how to use JSTL in a JSF page. I would say, the technique you learned from this book is not enough fro you to make a real web page.
Regards
A solid 'must have' reference for any serious library catering to Java programmers........2007-07-27
Java programmers will find essential this second updated edition CORE JAVASERVER FACES, which examines all elements of JSF 1.2 development and offers up a set of 'best practices' for automating functions, building consistent reusable user interfaces, and tweaking Java with JBoss Seam and custom components. There have been extensive updates and modifications to this edition, making it a solid 'must have' reference for any serious library catering to Java programmers.
Diane C. Donovan
California Bookwatch
Great Book for JSF Beginner's.......2007-06-27
I was excited when I first purchased this book, but I think my expectations were a bit too high. The Book covers the basics of JSF with aesthetic elegance, but more advanced topic's are not covered in as much depth.
That is not to say, however, that they are not covered. The book touches upon things like JSF used along side open source frameworks; which is an excellent place to start for the developer looking at the current options available for Object Relational / JSF / Alternate View Technology integration (Shale, Facelets, Seam, etc.)
But I would have liked to have seen a more thorough explanation on custom component creation. The example given in the book, e.g. the creation of a custom spinner component, is something that is somewhat useless in actual production environments. Usually, if a custom component needs to be created, it involves much more complicated functionality; such as a custom 'dataTable' component.
Even an explanation on how to create an advanced custom renderer would have been appreciated, for example, how to create a custom renderer for the 'dataTable' component.
Nevertheless, the book was useful and informative in many ways that I did not expect. The 'How do I...' section is an interesting approach, that was invaluable to me on numerous occasions.
Thus, overall, I would recommend this book to beginner and intermediate JSF developers looking to utilize JSF technology in their development pipelines. Unfortunately, for the most advanced JSF topics, looking at JSF implementation source code, and JavaDoc's still remains the best way to learn these advanced topics.
Great Book.......2006-08-24
It's a great book, easy to understand, a lot of examples, could be used by people initiating on JSF, or like a reference book. It is not necessary any knowledge of servlets or JSP. Just install tomcat, jsdk a jsf lib and start to write yours first webapp!!
Excellent thick book on web application development with JSF.......2006-03-23
Reading the Amazon reviews I suspected this to be a good book. But how excellent it actually was, caught me by surprise.
You get introduced slowly. The authors do not even hesitate to make pedagogically motivated design shortcuts at the beginning and they comment what they will improve later on.
The code examples are complete. Though you rarely ever need all of it, it strongly helped me not to get lost in the later chapters.
The code quality is top notch with a slight taste of C. It just feels good to read the code and one learns for even completely different software contexts.
If you only want a thin book on JSF the first six chapters (270 pages) will do an excellent job on that too. In fact this would be even the better book.
The style is unpretentious and the intellectual muscle of the authors is just amazing.
Are there problems? Well I think yes, in the more advanced chapters. The authors are just too competent. The consequence: In the later chapters you learn how you could do much, and I mean really much more, than is directly covered by the JSF standard. This might be a life saver, if you really do have any of those specific problems. In a general purpose book this might encourage people to overstretch their own system.
This book focuses only on the development side of the issues. If you want to learn the visual or the usability part of web applications, you have to turn to other books.
In summary I do highly recommend this book to people interested in JSF, Web development and software in general.
Book Description
JavaServer Faces, or JSF, brings a component-based model to web application development that's similar to the model that's been used in standalone GUI applications for years. The technology builds on the experience gained from Java Servlets, JavaServer Pages, and numerous commercial and open source web application frameworks that simplify the development process. In JavaServer Faces, developers learn how to use this new framework to build real-world web applications. The book contains everything you'll need: how to construct the HTML on the front end; how to create the user interface components that connect the front end to your business objects; how to write a back-end that's JSF-friendly; and how to create the deployment descriptors that tie everything together. JavaServer Faces pays particular attention to simple tasks that are easily ignored, but crucial to any real application: working with tablular data, for example, or enabling and disabling buttons. And this book doesn't hide from the trickier issues, like creating custom components or creating renderers for different presentation layers. Whether you're experienced with JSF or a just starting out, you'll find everything you need to know about this technology in this book. Topics covered include:
- The JSF environment
- Creating and rendering components
- Validating input
- Handling user-generated events
- Controlling page navigation
- Working with tabular data
- Internationalization
- Integration between JSF and Struts
- Developing custom renderers and custom components
JavaServer Faces is a complete guide to the crucial new JSF technology. If you develop web applications, JSF belongs in your toolkit, and this book belongs in your library.
Customer Reviews:
OK Starting Point.......2006-11-09
This book is an "OK" starting point for someone learning JSF.
Here are some things to be aware of:
1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration
2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.
3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.
4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.
5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".
On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.
I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.
For a J2EE beginner, a great resource.......2006-03-27
I've been working on webapps for the past 3 years in PHP, Python, and most recently Ruby. I've been trying to learn J2EE and have found it very difficult to find a foothold, a solid piece of ground to get oriented as to how people write Java webapps. I tend to like tutorial-style books when learning a new subject, ones that pick a project and implement it step by step, explaining the importance and contextual relevance of each hunk of code along the way. Of the four or five J2EE books that I've read on O'Reilly's Safari, this book is by far the best one for my style of learning. Java webapps are unique in that there is such a wide variety of options for each layer of your application. The Model, View, and Controller layers are all completely independent, and the interfaces between them are all configurable. Not only are they configurable, but you can choose to implement the connections between layers in code, or by using xml configuration files. This is *very* different to any other framework that I've used, and the complexity and power it presents is immensely overwhelming.
Bergsten does an excellent job (in contrast to the Official J2EE Tutorial, imho) at presenting each concept with just enough background, context, and detail as is necessary for one to understand what is happenening at a given moment.
I really like the fact that all of the code is listed in its entirety in the text, with descriptions interspersed. I really dislike the style of tutorial that tells you to "download and install the source code" and then proceeds to discuss it. I find that by having the example provided to me, I tend to skip over the boring, but important, details and at the end of the read, I haven't retained much. I learn by "following along" and typing in the listings myself. It helps me to remember the concepts, and forces me to concentrate on what's happening.
I can't speak for how effective this book would be for someone who already knew J2EE in some capacity, but for me, a J2EE newbie who likes a hands-on, applied approach, this book was the perfect fit.
A decent survey of JSF.......2006-02-26
I have this book and Core Javaserver Faces; this is the book that lies open on the desk, is dog eared, and has coffee spills on it. It's not perfect, but it's the best there is in this space.
Look instead at Core JavaServer Faces or free J2EE tutorial.......2005-09-27
1/4 of the book goes explains how to use JSP, JSTL
2/4 of the book API reprint
1/4 of the book actual JSF stuff - not real world related - unless you know exactly what you are looking for you'll never find it...
i'm surprised this book went into print - probably somebody upstairs decided to have at least something rather than nothing.
waste of time and money.
Pretty good reference for Java Server Faces.......2005-06-14
It describes very details about JSP, HTML and web architechure. However, I think it's not necessary as the readers should have basic knowledge of Java.
There are many examples to demonstrate how to use JSF. It's good for beginner. It lets reader to get knowledge faster and neatly. However, the codes must be downloaded from Internet. It's not convenience for us.
There are some parts for intermediate and expert JSP developers. "Developing Custom Renders and Components" are good topics.
The Appendix is very useful for developer to get syntax of JSF quickly. I appreciate it.
Book Description
Explains exciting new JavaServer Faces framework components and then shows you how to put them to work with real-world examples and usable codes. Developers of varying skill levels learn to quickly and easily build Web applications by assembling reusable UI components in a page, connecting these components to an application data source, and wiring client-generated events to server-side event handlers.
Customer Reviews:
Request for updated version.......2005-02-28
It includes a lot of practical examples. After reading several chapters, you really want to have more practices with these examples. You are happy to find the web site www.brainysoftware.com stored all the examples, but you are disappointed as all examples are not compiled successfully with the most updated jsf libraries. Be patient, please change the f:use_faces tag to f:view and h:output_text tag to h:outputText. In addition, the datatable tag is not mentioned.
The book is well organized and easy to understand. The information about installing and configuration Tomcat5 may benefit to beginners. However, the example is outdated and may cause reader's frustration. It is the best to have updated examples for downloading.
waste money.......2004-12-24
not only it is uptodate, the info that is presented in this book is too trivial and exists in the specification
Out of date. Move on to the next book........2004-05-12
Unfortunately the version of JSF this was written against was using a different naming standard for the taglibs and there are a few other concepts that have changed. Wish I would've bought a different book.
Nicely written, but watch out for updates..........2004-05-03
Target Audience
Developers who want to start using JavaServer Faces (JSF) technology for their web applications
Contents
This is a comprehensive tutorial on the JSF technology, how it works, and how to code an application using it.
The book has the following chapters: Overview Of Java Web Technologies; Introduction To JavaServer Faces; Objects For Request Processing; The User Interface Component Model; JSF Simple Components; JSF Advanced Components; JSF Event Handling; Page Navigation; Validators; Converters; Internationalization And Localization; Renderers; Custom User Interface Components; Online Store Application; The Application Configuration File; Summing Up: How JSF Works; The JSP 2.0 Expression Language; The JSP Standard Tag Library; Installing And Configuring Tomcat 5; The Web Application Deployment Descriptor
Review
JavaServer Faces technology is gaining steam in the Java community as a standard framework for building web applications, much like Struts has become. If this is a primary part of your development activity, you'll need to get up to speed on how JSF works. This book will help you get started.
Budi starts by reviewing servlet and javaserver page concepts, which is what JSF is based on. Once that area is reviewed, he starts with the basics of JSF coding and gives you plenty of examples of how they are coded. To me, the writing style and examples are clear and appropriate for someone just starting out in this area. The chapters build on each other and it all comes together in chapter 14 where an entire online application is built. After working your way through the book, you should have a basic mastery of the technology.
With a little additional research, I found that there is a later release of the technology (JSF beta 1) that supercedes the release on which this book was written (JSF Early Access 4). Not yet being a JSF wizard, I can't tell you how much of a difference that will make in the accuracy of the information presented. The author has updated the examples on his web site to work with the beta 1 version, so be prepared for some of the examples to work a little differently than what you see in print. Unfortunately that's one of the drawbacks in trying to get a book in print about a technology who's foundational concepts are still in development. That's probably why they call it the "bleeding edge of technology".
Conclusion
I thought this was a well-written, understandable book on an emerging technology. Just keep in mind that what you currently read and what may be in the final release could change.
Do not buy this book now........2004-04-16
I was suckered into buying this book, as there was no other book on JSF in the store. As the JSF specs have changed considerably, this book is OUTDATED.
But that is not the reason for the rating. The author rehashes the old JSF docs available from Sun in addition to tons of useless code. This is probably the worst part as ALL the examples are TOY (hello world) kind of applications, which gives the impression that the author himself does not quite understand the technology.
Book Description
Harness the power of JavaServer Faces to create your own server-side user interfaces for the Web
This innovative book arms you with the tools to utilize JavaServer Faces (JSF), a new standard that will make building user interfaces for J2EE⢠applications a lot easier. The authors begin by painting the architectural big picture-covering everything from the Patterns that are used in the implementation to the typical JSF Request/Response lifecycle. Next, you'll learn how to use JSF in the real world by uncovering the various pieces of the JSF component model, such as UI components, events and validation. The authors then explain how to apply JSF, including how to integrate JSF user interfaces with the Business Tier and how to render your own user interface components. By following this approach, you'll be able to confidently create and validate your own custom applications that meet the needs of your company.
Whether working in J2EE or J2SEâ¢, this book will show you how to:
- Use UI Components to build your user interface
- Ensure that the data you store meets the business rules for your application
- Integrate JSF with JSPs through the custom Tag feature in JSP implementations
- Build JSF applications that interact with either EJBs or POJOs
- Validate a new component and queue events to invoke custom application logic
- Move your application from Struts to JSF
Customer Reviews:
Whither hello world?.......2007-06-01
If you are like me, you don't have the time to read about the philosophy behind the design of JSF or how it's more like swing than struts. Why can't the authors of such books start with a hello world example. Most experienced programmers can figure out the basics of JSF just by looking at the hello world example and relating it to technologies they've already used(struts, perhaps?). Most authors can't resist the temptation to impress us with the awesome power of the new framework especially when they haven't introduced the basic examples? Why have a whole chapter explaining the intricacies of faces-config.xml before you really introduce a simple application? I got more out of http://www.jsftutorials.net than the first few chapters of this book. Get eclipse wtp, install the jsf plugin and go through the tutorial.
Could be a 5 star book, but missing an important piece.......2006-10-26
This book reads very well. Explains most things very clearly but the examples are missing what to put into the faces-config.xml file. Ch. 5, Ch 6, ... have some nice examples and show you what goes in the jsp files but as you add to these jsp files you need to make the necessary adjustments to the faces-config.xml file too. You have to download the source to see the contents of the faces-config.xml file.
As a beginner, I found this very frustrating and out searching the net for more tutorials that show how to make adjustments to the faces-config.xml and the JSP file.
Other than this issue, the book is good the learning about the JSP/JSF contents.
It is just disappointing that this book was so close, if it had covered the faces-config.xml I would have given it 5 stars.
Mastering JavaServer Faces.......2005-08-06
Good outline of JavaServer Faces but not enough examples. Too much theory not enough practical examples. It is not a complete reference so you need other books or sources to get answers on specific functions and uses of JavaServer Faces.
Could be better.......2005-04-05
The problem is that the book has a lot of mistakes and don't explain some mechanism like ValueBinding. The book use hibernate to persist data to database and this can be a problem to people who don't know this technology, in my opinion they should have used plain JDBC technology, it would be much easier to the readers.
The Best JSF Book I've Read Yet.......2005-01-18
This is the best JSF book I've read to date. To begin with, its an excellent value. There is no wasted space. The O'Reilly book has 242 pages of appendix which basically regurgitates the API (shame!) You won't find that here. Also, the authors do not waste your time explaining what a JSP page is, etc.
The book starts off with an overview of MVC but it goes beyond explaining what MVC is (which is where most books stop) but explains how MVC is used in Swing and Struts and compares that to how it is employed in JSF. It also goes into some of the rationale for why things in JSF were designed the way they were. If you're not into that - fine, but at least its not an explanation of how to deploy a Servlet.
This book provides the most thorough explanation of how things work in JSF and provides impressive coverage of the lifecylce. These are the things you are going to have to know once you finish your "Hello World" programs and need to start actually writing a program.
I've read the Core and O'Reilly books so far. I'd have to rate this one the best. Perhaps my impressions were affected by the fact that I read these books first, but I feel like the reader will learn more from this book. It doesn't waste your time writing "Hello Faces" examples in chapter one just to appease the reader. You won't get down and dirty with the code to the middle of the book but that is how it should be in my opinion.
Also, if you are a Struts programmer, this book is much better than the others in discussing Struts and how it compares. It also provides some detail about integrating the two etc. Not as much as I would have liked, but much much more than the other books.
Book Description
Helping front-end developers, back-end developers, and architects understand how they can get the most out of JavaServer Faces (JSF), this guide to the new official standard for simplifying Java web development explains what JSF is, how it works, and how it relates to other frameworks and technologies like Struts, Servlets, Portlets, JSP, and JSTL. Also provided is coverage of all the standard components, renderers, converters, and validators, along with advice on how to use them to create solid applications. The building of complete JSF applications is demonstrated with an in-depth case study covering complex user interface layouts, prototyping, and integrating templates with back-end model objects. Also covered are advanced techniques like internationalization, integration with Struts, and extending JSF with custom components, renderers, converters, and validators.
Customer Reviews:
Poor code examples.......2007-05-18
This book does not compare to "Core Java Server Faces" first edition by Geary and Horstman. The book provides fery few and not very useful code examples. The content is not very organized. Also, it does not address more advanced topics such as displaying very large result sets.
Not up to the Manning Standard.......2006-11-07
I purchased this book based on my previously great experience with Manning Press books. I've found other books by this publisher to be easy to read and easy to comprehend. They usually give you just enough background information and then details on different aspects of the subject matter. This book just goes on and on and on about background information and implementation details that are of little use to anyone after they configure their first application. It takes too long to get to the meat of writing JSF applications. And once you get to where the meat is supposed to be, most of that has to be downloaded as a 300 page PDF from their web site. Not very useful at all.
If you are looking for good JSF information, I now use the Core book for information and the O'Reilly book for a quick API reference. If you want examples of great Manning Press books, please check out their "Spring In Action" and "JSTL In Action" books. Both are fantastic reads and full of great information.
Sadly, this particular book left a lot to be desired both as an instructional text or as an API reference.
Nice book,examples should have been better.......2006-11-02
The book is nice in overall but the examples should be better.
Core JSF is better and I recommend that one over this.
Good book but swarm with typos.......2006-10-05
I am totally amazed from what a great technology JSF is. I have worked for so many years with Struts - JSF beats it definitely. And this book is quite good at teaching it. I would give it 5 stars for the content if there were no typos. There are swarms of them. I am currently on page 212 and I see them at least every 3 pages. What's bad about these typos is that they are all in important areas - not just misspelt words but messed up names of classes and objects. I am getting tired from them.
But again, the content of the book is great.
Very few examples of java backing beans.......2006-09-20
Many, many pages with very few examples of java backing beans.
Book Description
In addition to listing all of the important JavaServer Faces (JSF) components, this guide also teaches developers and software architects how to use each of them. Helping front-end developers, back-end developers, and architects understand how they can get the most out of JSF, this look at the new official standard for simplifying Java Web development also explains what JSF is, how it works, and how it relates to other frameworks and technologies such as Struts, Servlets, Portlets, JSP, and JSTL. Coverage of all the standard components, renderers, converters, and validators is included, as is advice on how to use them to create solid applications.
Books:
- Mastering the Trade (McGraw-Hill Trader's Edge)
- MCSA/MCSE Managing and Maintaining a Windows Server 2003 Environment Exam Cram 2 (Exam Cram 70-292)
- MCSA/MCSE Self-Paced Training Kit (Exam 70-270): Installing, Configuring, and Administering Microsoft Windows XP Professional, Second Edition
- MCSA/MCSE Self-Paced Training Kit (Exam 70-350): Implementing Microsoft Internet Security and Acceleration Server 2004 (Pro-Certification)
- MCSE Self-Paced Training Kit (Exams 70-290, 70-291, 70-293, 70-294): Microsoft Windows Server 2003 Core Requirements, Second Edition
- MCSE Self-Paced Training Kit (Exams 70-290, 70-291, 70-293, 70-294): Microsoft Windows Server 2003 Core Requirements, Second Edition
- MCTS Self-Paced Training Kit (Exam 70-431): Microsoft SQL Server 2005 Implementation and Maintenance (Pro-Certification)
- MCTS Self-Paced Training Kit (Exam 70-431): Microsoft SQL Server 2005 Implementation and Maintenance (Pro-Certification)
- Microsoft .NET Compact Framework (Core Reference)
- Microsoft SQL Server 2000 Resource Kit (With CD-ROM)
Books Index
Books Home
Recommended Books
- Art of Analog Layout, The
- The Oxford Companion to United States History
- Labour Force Statistics 1983-2003
- Roman Polanski: Interviews
- StrengthsFinder 2.0: A New and Upgraded Edition of the Online Test from Gallup's Now, Discover Your
- The Servant: A Simple Story About the True Essence of Leadership
- The Israelis: Ordinary People in an Extraordinary Land
- Unternehmensrechnung, Anreiz und Kontrolle: Die Messung, Zurechnung und Steuerung des Erfolges als G
- Rising from the Ashes
- The Heaven of Mercury: A Novel
General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
Pro JSF and Ajax: Building Rich Internet Components (Pro)
Core JavaServer(TM) Faces (2nd Edition) (Core Series)
Java Persistence with Hibernate
Pro EJB 3: Java Persistence API (Pro)
Struts: The Complete Reference, 2nd Edition (Complete Reference Series)
