java left logo
java middle logo
java right logo
 

Home arrow Book Reviews arrow Struts in Action: Building Web Applications with the Leading Java Framework
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4093
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Struts in Action: Building Web Applications with the Leading Java Framework E-mail
User Rating: / 29
PoorBest 
 Book Information

Image

Authors: Ted Husted, Cedric Dumoulin, George Franciscus, David Winterfeldt, Craig R. McClanahan
Paperback: 664 pages
Publisher: Manning Publications (November 2002)
Language: English
ISBN: 1930110502
Product Dimensions: 9.4 x 7.4 x 1.5 inches
ImageAmazon.com Link


 Book Review

Introduction and Target Audiences:

“Struts in Action” by Manning Publications is an excellent work on the emerging Struts technology framework. Being a complete book on Struts it not only helps the novice developers but also makes it easy for the experienced people to get their application to work according to “Struts” methodology. Although author had tried to make this as a start-to-finish book which can be readily referred by professional developers but still he had given only a brief knowledge regarding the related technologies required along with struts. Through this author seems to make his point clear that the readers will get a comprehensive stuff which mainly deals with the struts framework and the interaction between the various technologies. This makes the book as one of the serious and well designed effort by the author. Familiarity of the readers with certain web application related concepts will definitely prove helpful for them. Moreover prior knowledge of Java syntax will help them grasping the concepts with more ease. Although knowledge of above mentioned skills are required in order to have a quick and better learning from the book but rather these are not essential for starting with “Struts in Action”. No other book on Struts gives such detailed knowledge-rich text on the topic as this gives to its readers.

Organization of book:

Looking merely at the list of chapters one can easily make out the amount of hard work done by the author while writing the book. The entire Strut content had been divided into seventeen chapters in the book. Each chapter deals with one or the other important concept of Strut framework. While chapter one introduces the web application development and Struts to the readers, chapter two says much regarding the Struts architecture. These two chapters together make up for the introductory part of the book as from here the book straight way goes on to the application development phase.Chapter three initiates the actual implementation cycle as it gives the readers a basic know-how of Struts application development. It enables the readers to develop their own simple web application. The idea of a simple application with all the necessary details required for the readers had worked out well in the book. Taking the application development issue further chapter four discusses the various configuration elements which can help the developers in building and deploying their application. The application resources file, the Ant Build file, Struts Configuration file had been discussed in an effective way.

While traversing the book one will definitely notice the ease with which each new topic comes and by the time it finishes the reader finds himself well-through the taught concept. Chapter five covers the Struts ActionForm. This chapter deals with some of the important features like life cycle, responsibilities, consequences and characteristics of ActionForm design. Chapter five and six are important from implementation point of view as these chapters tells you some of the important struts concepts required for a robust web application. Chapter six is about Struts Action Forwards, their working, usage of runtime parameters and dynamic forwards. Moreover this chapter also gives the users an additional option of providing their own Action Forwards.

How an Action class is reused and configured for different tasks is what chapter seven speaks about. The Struts Action Mapping being the foundation of Struts Controller had been explained in an effective manner. Moving on to the Struts Action object, author spends some quality time in explaining the struts Action, their usage, chaining of actions and some other standard Actions. These chapters being important from developers’ point of view had attracted maximum of author’s time. Where chapter eight had enough of Struts ActionObject , chapter nine focuses mainly on the Struts ActionServlet, its role in the application, processing of requests, the Exception handler, and also the customization of ActionServlets suiting to the developers’ needs. Chapter ten in itself is sufficient enough to let the readers become well-acquainted with the Struts JSP tags and server pages. It also discusses regarding the writing and Installing of tag extensions. Chapter eleven tells the readers how they can develop their application with Tiles along with the usage of Struts and Tiles Framework together.

Each individual chapter of this book says some or the other important aspect of Strut. It also gives the readers an added advantage that they can quickly refer to the index and learn from the chapter which suits their requirements the most. Next chapter following the similar lines is fully devoted to the Validation of user inputs. While chapter thirteen covers the Struts Internationalization issues, chapter fourteen teaches you how you can use data services with Struts. Developers can look out for some valuable guidance from this chapter as it can solve much of their data related queries. Understanding applications usage of databases, integration of application with data services, usage of data layers for data service connection are some of the prominent features of this chapter.

Chapter fifteen presents an enterprise-grade application that pulls out all the stops and demonstrates the key Struts features and add-ons in one package. This example application Artimus tells the user how he can use Tiles, Validator and Scaffold all in the same application. This chapter mainly tries to highlight the best and the brightest features of Struts. Chapter sixteen allows all those developers who want to upgrade their struts 1.0 application to the new 1.1 features. Various added and attractive features like dynamic ActionForms Action-based Security, plug-ins and multiple modules together make up 1.1. Last chapter of this book shows how Velocity Template can replace JavaServerPages when used with Struts. Here the author makes use of the same application as used in chapter three to demonstrate the usage of Velocity Template. Comparison of Velocity templates along with JSPs had also been done.

Finally:

“An excellent book by a sincere author”. This would be the best comment for the hard work which the authors had done while writing this masterpiece. Everything right from title to cover, to the knowledge-rich text, seems to be so perfect that there is hardly any chance to point a finger for some mistake. The text is well complemented by some eye-catching application examples demonstrating the best practice techniques. Author from his side had tried to put in all his experience and knowledge while writing this book. I would recommend this book to anyone and everyone who is even slightly interested in working with Struts Framework. I bet, once started the book he/she will not be able to leave it unless completing it fully.Strictly a “no-nonsense” book on Struts for every web application developer.


 Table of Contents

    PART 1 GETTING STARTED WITH STRUTS

  1. Chapter 1 Introduction

    • What is this book about?
    • What are application frameworks?
    • Enabling technologies
    • Struts from 30,000 feet Real-world web applications

  2. Chapter 2 Exploring the Struts architecture

    • Talking the talk
    • Why we need Struts
    • Why we need frameworks
    • Struts, Model 2, and MVC
    • Struts control flow
    • The strengths and weaknesses of Struts

  3. Chapter 3 Building a simple application

    • Strut by Strut
    • Touring a logon application
    • Dissecting the logon application
    • Constructing an application Why we need frameworks

  4. Chapter 4 Configuring Struts components

    • Three XMLs and a Properties file
    • The web application deployment descriptor
    • The Struts configuration
    • The Struts configuration elements
    • The application resources file
    • The Ant build file
    • Configuring the Struts core
    • Configuring the Tiles framework
    • Configuring the Struts Validator
    • Getting started with the Struts Blank application
    • Configuring modular applications
    • Sharing the Struts JARDissecting the logon application

    PART 2 RAISING YOUR FRAMEWORK


  5. Chapter 5 Coping with ActionForms
    • Garbage in, treasure out
    • The many faces of an ActionForm
    • ActionForm design consequences
    • ActionForm flavors
    • Why isn’t an ActionForm
    • Debriefing ActionForms
    • BaseForm

  6. Chapter 6 Wiring with ActionForwards

    • What ActionForwards do
    • How ActionForwards work
    • Global and local forwards
    • Runtime parameters
    • Dynamic forwards
    • Why doesn’t the address bar change?
    • Rolling your own ActionForward ActionForm flavors

  7. Chapter 7 Designing with ActionMappings

    • Enter ActionMappings
    • ActionMapping properties
    • Nested components
    • Rolling your own ActionMapping

  8. Chapter 8 Working with Action objects

    • Ready, set, action!
    • Getting it done with Action objects
    • The standard Actions
    • Chaining Actions
    • Scaffold Actions
    • Base View Actions
    • Helper Action techniques
    • Using smart forwarding Nested components

  9. Chapter 9 Extending ActionServlet

    • Where’s the beef?
    • The RequestProcessor
    • The ExceptionHandler
    • PlugIn Scaffold Actions

    PART 3 BUILDING YOUR PAGES

  10. Chapter 10 Displaying dynamic content

    • Tag—you’re it
    • Working with tag extensions
    • The Struts taglibs
    • Using Struts JSP tags
    • Alternate views Enabling technologies

  11. Chapter 11 Developing applications with Tiles

    • Leveraging layouts
    • Building a layout template
    • Tiles Definitions
    • Tile attributes
    • Migrating an application to Tiles The Struts taglibs

  12. Chapter 12 Validating user input

    • I know it when I see it
    • Overview of the Struts Validator
    • Basic validators
    • Resource bundles
    • Configuration files
    • Validator JSP tags
    • ValidatorForm and ValidatorActionForm
    • Localized validations
    • Pluggable validators
    • Techniques
    • Migrating an application to the Struts Validator Tiles Definitions

  13. Chapter 13 Localizing content

    • By any other name
    • Struts’ internationalized components
    • Localizing a Struts application
    • Localizing other components.

  14. Chapter 14 Using data services with Struts

    • Stepping out
    • Exploring the business layer
    • Using ProcessBeans and JDBC with Struts
    • Using result objects
    • Using helper Actions
    • Using Lucene
    • Using content syndication
    • Using EJBs with Struts

    PART 4 STRUTS BY EXAMPLE

  15. Chapter 15 Artimus: pulling out the stops

    • The framework’s framework
    • Scaffold—birth of a toolset
    • About Artimus
    • The deployment descriptor (web.xml)
    • ArtimusServlet
    • The application and SQL Properties files
    • index.jsp
    • Global forwards
    • /find/Recent
    • tiles.xml and Article.jsp
    • result.jsp
    • Article actions
    • view.jsp
    • edit.jsp
    • /do/Menu
    • menu.jspUsing Struts JSP tags

  16. Chapter 16 Redux: migrating to Struts

    • Next station, Struts 1.1
    • Baseline changes
    • Discretionary changes

  17. Chapter 17 Velocity: replacing JSPs

    • Moving to Velocity templates
    • Change makes the framework
    • Why we need Velocity
    • Using Velocity with web applications
    • Our logon templates
    • Setting up VelocityViewServlet
    • Setting up struts-config

  18. Appendix A : Design patterns

    • A.1 A brief history of design patterns
    • A.2 Why patterns are important
    • A.3 What patterns won’t do
    • A.4 Struts—a Who’s Who of design patterns

  19. Appendix B : The struts-config

    • B.1 <struts-config>

  20. Appendix C : Taglib quick reference

 Overview of Chapters

    PART 1 GETTING STARTED WITH STRUTS

  1. Chapter 1 Introduction

    • Introducing application frameworks
    • Understanding HTTP, CGI, servlets, and JSPs.
    • The technology behind HTTP, the Common Gateway Interface, Java servlets, JSPs, and JavaBeans.
    • Using the Model 2 architecture
    • How to build a simple application.

  2. Chapter 2 Exploring the Struts architecture

    • Need for Struts and frameworks.
    • Introducing application frameworks, MVC, and Model 2
    • Understanding how Struts works
    • How you can use the Struts control flow.
    • What are the strengths and weaknesses of Struts.

  3. Chapter 3 Building a simple application

    • How to create a simple application
    • Extending an application by zooming in on each component.
    • Changing an application
    • How you can set up your development tools.
    • How you can use JavaServer Pages in an application.

  4. Chapter 4 Configuring Struts components

    • The Web application deployment descriptor
    • The Struts configuration file
    • What are the various elements of struts configuration.
    • The application resources file.
    • The Ant build file.
    • How you can configure modular applications.

    PART 2 RAISING YOUR FRAMEWORK


  5. Chapter 5 Coping with ActionForms
    • Understanding the ActionForm life cycle
    • Examining the responsibilities of an ActionForm.
    • What are the consequences of using an ActionForm.
    • What are the characteristics of an ActionForm design?
    • Using ActionForm best practices
    • How to populate and debrief ActionForms.
    • Introduction of the Scaffold BaseForm.

  6. Chapter 6 Wiring with ActionForwards

    • Understanding ActionForward best practices
    • What ActionForwards do
    • How ActionForwards work
    • Discussion on Global and local forwards
    • How to use runtime parameters
    • How to use dynamic forwards
    • How you can provide your own ActionForward subclass.

  7. Chapter 7 Designing with ActionMappings

    • Understanding ActionMappings
    • How ActionMappings catalog the business logic available to a Struts application.
    • Defining ActionMapping properties
    • Using local and global ActionForwards
    • How an application can have its own set of local exception handlers.

  8. Chapter 8 Working with Action objects

    • What are Actions, when are they called and their significance.
    • Understanding Action best practices
    • What are some standard actions.
    • How you can use a base Action.
    • Chaining Actions
    • Relying on standard Actions
    • Leveraging helper Actions.

  9. Chapter 9 Extending ActionServlet

    • Understanding the ActionServlet’s role in your application
    • How requests are getting processed by RequestProcessor.
    • Using ActionServlet extension components
    • The Exception Handler.
    • How you can create the desired controller servlet behavior by plugging in a prewritten component.
    • Using ActionServlet extension points

    PART 3 BUILDING YOUR PAGES

  10. Chapter 10 Displaying dynamic content

    • Understanding why and where you can use JSP tags.
    • How you can write and Install tag extensions.
    • How you can use the Struts JSP tags
    • What is there in the near future for JSP tags.

  11. Chapter 11 Developing applications with Tiles

    • How you can design applications with dynamic includes.
    • Layering with dynamic templates.
    • How you can use the Struts and Tiles frameworks together.
    • Understanding Tiles Definitions and attributes.
    • Migrating applications to Tiles.

  12. Chapter 12 Validating user input

    • Understanding the need to validate data.
    • Overview of the Struts Validator
    • How you can configure and use the Commons Validator
    • How you can use multipage and localized validations.
    • How you can write your own validators.

  13. Chapter 13 Localizing content

    • Why developers localize their applications and how Java internationalization works.
    • Understanding the importance of localization
    • How you can use the Struts internationalization features.
    • How you can localize your Struts application.
    • How you can localize other parts of your application such as Struts Validator and Tiles.

  14. Chapter 14 Using data services with Struts

    • Understanding why and how applications use databases and other data services
    • How you can integrate your application with a data service.
    • How you can use layers when connecting with a data service.
    • Defining the business layer of an application
    • How you can connect data access components with the business layer.
    • Connecting other data services, such as search engines and content syndication, with the business layer.

    PART 4 STRUTS BY EXAMPLE

  15. Chapter 15 Artimus: pulling out the stops

    • Introducing the Artimus example application
    • How you can use Tiles, Validator, and Scaffold in the same application.
    • The Artimus Servlet.
    • Understanding recommended practices for production applications.

  16. Chapter 16 Redux: migrating to Struts

    • Updating an application for 1.0
    • Using dynamic ActionForms
    • Implementing Action-based security
    • Configuring Tiles and Validator 1.1

  17. Chapter 17 Velocity: replacing JSPs

    • Introducing Velocity templates
    • Using Velocity in web applications
    • Using Velocity with Struts applications
    • How you can set up the Velocity ViewServlet.
    • How to convert JavaServer Pages to Velocity templates.

Reviewer: Sumit Kulshreshtha


 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.