Organization
This book begins with a preliminary discussion that lays the
groundwork for the rest of the material. This discussion will be a
refresher for some and completely new for others. From there, we
explore the components of Struts's MVC
implementation, including a look at the JSP custom tags that are part
of the framework. Then, to round out your understanding of the value
of the Struts framework, we look at several complicated but important
topics related to building web-based applications.- Chapter 1, Introduction
This chapter discusses some preliminary concepts, such as the MVC
pattern, Model 2, and the idea of a software framework. Although many
developers may already be familiar with some or all of the ideas
presented here, I want to ensure that all readers are starting from
the same place. The concepts presented in this chapter help to lay
the foundation for the rest of the book.
- Chapter 2, Inside the Web Tier
The Struts framework is based on the Java Servlet technology and, to
a lesser extent, JavaServer Pages, and therefore is tightly coupled
to a web container. For Struts developers, understanding how the web
container processes client requests is fundamental to understanding
the framework itself. This chapter discusses the components of the
web container and the responsibilities of each.
- Chapter 3, Overview of the Struts Framework
This chapter provides an overview of the Struts framework; it does
not attempt to cover all of the features or go into significant
depth. It emphasizes how all the pieces fit into the MVC and Model 2
architecture presented in Chapter 1.
- Chapter 4,Configuring Struts Applications
The Struts framework uses two separate but somewhat related types of
configuration files, which must be configured properly before an
application will function properly. Due to the popularity and
flexibility of XML, both types of configuration files are based on
XML. This chapter presents the syntax of the files.
- Chapter 5, Struts Controller Components
The Struts framework uses a servlet to process incoming requests;
however, it relies on many other components that are part of the
controller domain to help it carry out its responsibilities. This
chapter takes in-depth look at the components that are responsible
for the controller functionality in the framework.
- Chapter 6, Struts Model Components
This chapter introduces the components that make up the model portion
of a Struts application. The model represents the business data for
an application and should closely resemble the real-world entities
and business processes for the organization. This chapter explores
the roles and responsibilities of the model components within the
Struts framework and focuses on building an architecturally correct
implementation for the Storefront application. Special attention is
given to using a persistence framework that can be integrated into a
Struts application easily and effortlessly.
- Chapter 7, Struts View Components
This chapter introduces the components that make up the view portion
of the Struts framework. The framework uses the view components to
render dynamic content for the client. Based primarily on JavaServer
Pages, the components provide support for internationalized
applications as well as for user-input acceptance, validation, and
error handling, all of which make it easier for the developer to
focus on business requirements. This chapter concludes the three-part
discussion of how the Struts framework implements the MVC pattern.
- Chapter 8, JSP Custom Tag Libraries
This chapter looks at the different categories of tags and how they
can help make developing applications with the Struts framework even
easier. It is not meant to be an exhaustive reference for every tag
that's part of the Struts tag librariesthat
information can be found within the Struts user guide or JavaDocs.
The real purpose of this chapter is to put forth the benefits of
using the Struts tag libraries and to provide a few strategies that
can help make the switch to using the tags less painful.
- Chapter 9, Extending the Struts Framework
One of the biggest advantages of using a framework is the ability to
extend and customize it based on the needs of the application. The
Struts framework is no exception; it provides several important
extension points for developers. This chapter takes a quick glance at
several of those extension points and examines the benefits and
drawbacks of extending the framework.
- Chapter 10, Exception Handling
This chapter looks at how to use the Java exception-handling
mechanism within your Struts applications to make them more robust
and allow them to respond gracefully when things
don't go as expected. Special attention is given to
the differences between performing the exception handling
programmatically and using the new declarative feature added to the
Struts framework in Version 1.1.
- Chapter 11, The Validator Framework
This chapter introduces the Validator framework, which was created
specifically to work with Struts components. The Validator allows you
to declaratively configure validation routines for a Struts
application without having to program special validation logic.
- Chapter 12, Internationalization and Struts
This chapter focuses on what it takes to make a Struts application
available to customers from around the world, regardless of their
language or geographical location. As is often the case in software
development, planning ahead is the most important thing that you can
do to help ensure success. After reading this chapter, you should be
able to build Struts applications that can support a broad range of
customers.
- Chapter 13, Struts and Enterprise JavaBeans
This chapter covers the issues you need to consider when developing
an interface between your Struts actions and an application tier. It
focuses on interfacing to a model built using Enterprise
JavaBeans™ (EJB).
- Chapter 14, Using Tiles
This chapter looks at the Tiles framework, which now is part of the
core Struts distribution. The Tiles framework is an advanced
templating framework that reduces the amount of redundant code a web
application contains and allows developers to better separate content
from layout.
- Chapter 15, Logging in a Struts Application
This chapter examines how the use of logging in your Struts
applications can help you identify defects before the applications
get into production and, if your software already is being used in
production, how logging can help you identify problems and arrive at
solutions much more quickly.
- Chapter 16, Packaging Your Struts Application
This chapter discusses the best practices for packaging and deploying
a Struts application and what it takes to automate the build process
for your environment. Special coverage is given to Ant, the
Java-based build tool available from Jakarta.
- Chapter 17, Addressing Performance
This chapter explores the performance implications of using the
Struts framework and its associated technologies to build web
applications and discusses how certain design and programming
decisions affect the overall performance of the applications. It
covers performance, load, and stress testing, and the steps necessary
to carry out each.
- Chapter 18, JavaServer Faces
This chapter provides an overview of yet another Java technology
being birthed from the Java Community. JavaServer Faces provides some
promising continuation for the Java web development community.
Although some overlap exists between Struts and JSF, there is plenty
of room for both and this chapter explores what that integration
looks like.
- Appendix A, Changes Since Struts 1.0
This appendix enumerates the new features within the 1.1 release.
- Appendix B, Downloading and Installing Struts
This appendix discusses the steps for downloading and installing
Struts in your environment.
- Appendix C, Resources
This appendix lists several resources that can help increase your
knowledge once you've mastered the concepts in this
book.
|
لطفا منتظر باشید ...
