Table of Contents
Preface
Chapter 1: Struts and Agile Development
Chapter 2: Basic Configuration
Chapter 3: Actions and ActionSupport
Chapter 4: Results and Result Types
Chapter 5: OGNL, the Value Stack, and Custom Tags
Chapter 6: Form Tags
Chapter 7: Form Validation and Type Conversion
Chapter 8: Interceptors
Chapter 9: Exceptions and Logging
Chapter 10: Getting Started with JavaScript
Chapter 11: Advanced JavaScript, the DOM, and CSS
Chapter 12: Themes and Templates
Chapter 13: Rich Internet Applications
Chapter 14: Comprehensive Testing
Chapter 15: Documenting our Application
Index
* Preface
Up
* Chapter 1: Struts and Agile Development
o Struts 2 in a nutshell
+ The filter dispatcher
+ Interceptors
+ Actions
+ Results
+ Plug-ins
o Agile in a nutshell
+ User stories
+ Testing
+ Refactoring
+ Short iterations
o Real applications in a nutshell
+ Making it pretty
+ JavaScript
+ Documentation
+ All of the rest
o Getting started
+ Creating our own applications
# Doing it "by hand"
# Using Maven
o Summary
Up
* Chapter 2: Basic Configuration
o Setting up our environment
+ A sanity-checking application
+ Configuring web.xml for Struts 2
+ Writing our first action
# Configuring our first action with XML
# Configuring our result
# Choosing an action method
o Getting started with our application
+ Gathering user stories—defining our application
+ Building skeletal applications using wildcards
+ Matching multiple wildcards
+ More wildcard tricks
+ Packages and namespaces
+ Creating site navigation
+ Including external configuration files
+ Our application so far
+ Examining our configuration
+ Configuration via convention and annotations
# The Convention Plug-in and action-less actions
# The Convention Plug-in and action configuration
# Configuring the Convention Plug-in with annotations
o Summary
Up
* Chapter 3: Actions and ActionSupport
o ActionSupport and its interfaces
+ The Action interface
# Action's convenience strings
+ The TextProvider interface
+ Detour—action properties, JSPs, and more tags
+ Continuing with message lookup
+ Parameterized messages
+ The LocaleProvider interface
+ The Validateable and ValidationAware interfaces
o Implementing our first user story
+ Refining our story
+ Creating the recipe form
+ Adding some validation
+ Displaying our error messages
o More action interfaces
+ Detour—creating the list of interfaces to explore
# Leveraging the IDE
# Using the command line
# Examining class files
o Additional action interfaces
+ Preparable interface
+ Accessing scoped attributes (and request parameters)
+ Accessing servlet objects
+ Request parameter/action property filtering
o Summary
Up
* Chapter 4: Results and Result Types
o The dispatcher result type
o The redirect result type
o The redirectAction result type
o The chain result type (action chaining)
o The parse parameter and a usecase detour
+ Displaying the form
+ Coding our action
+ Configuring our success result
+ Type conversion sneak attack
+ Coding the show action
o The FreeMarker and Velocity result types
+ FreeMarker result configuration
o The XSLT result type
o The plaintext result
o The stream result
o The httpheader result
o The Tiles and JasperReports results
o Creating custom result types
+ Configuring our custom result type
+ Writing the action
+ Implementing our markdown result type
o Summary
Up
* Chapter 5: OGNL, the Value Stack, and Custom Tags
o OGNL
+ Contents of the value stack and the <s:property> tag
# Escaping values
# Default values
# Escaping values for JavaScript
+ Other value stack objects and the debug tag
+ A dirty EL trick
o The <s:set> tag
o Calling static methods from OGNL
o Conditionals
o Collections and iteration
+ The <s:iterator> tag
# Tracking iteration status
# CSS detour: Alternating table row background color
# The <s:generator> tag
# It's not a list, it's an iterator!
# Silent death
# Another potential stumper (Struts 2.0 only)
# What is <s:generator> for?
+ The <s:append> tag
+ The <s:merge> tag
+ The <s:subset> tag
# Arbitrary filtering with the <s:subset> tag
# Dirty OGNL secrets
+ The <s:sort> tag
+ Are the collection tags useful?
o Referencing other pages and actions
+ The <s:include> tag
+ The <s:action> tag
+ The <s:url> tag
o Summary
Up
* Chapter 6: Form Tags
o Form tag basics
+ The xhtml theme in a nutshell
+ The <s:head> tag
+ The <s:form> tag
+ Common input element tag attributes
# Values, labels, and names (and keys)
# All the rest
+ Basic rendering
# But I don't want tables
+ Basic form input elements
# The <s:textfield>, <s:password>, and <s:hidden> tags
# The <s:textarea> tag
# The <s:label> tag
# The <s:radio> tag
# The <s:checkbox> tag
# The <s:checkboxlist> tag
# Using the <s:checkboxlist> tag to implement a user story
# The <s:select> tag
# The <s:optgroup> tag
# The <s:submit> tag
# The <s:reset> tag
+ Combination form tags
# The <s:combobox> tag
# The <s:updownselect> tag
# The <s:optiontransferselect> tag
# The <s:doubleselect> tag
+ Uploading files
+ Preventing double submits with the <s:token> tag
o Summary
Up
* Chapter 7: Form Validation and Type Conversion
o Form validation
+ Manual validation
+ Configuring XML validation
# Customizing validation messages
+ What validations are available?
# The requiredstring validator
# The stringlength validator
# Detour—playing games with validation messages
# The required and int validators
# But wait, there's more
# The double validator
# The email validator
# The url validator
# The date validator
# The regex validator
# The expression and fieldexpression validators
# Combining validation methods
# The conversion validator
# The visitor validator
+ Configuring validation with annotations
# The @Validation annotation
# The @Validations annotation
# The @SkipValidation annotation
# The @RequiredFieldValidator annotation
# The @IntRangeFieldValidator annotation
# The @DoubleRangeFieldValidator annotation
# The remaining validation annotations
+ Client-side validation
+ Custom validators
o Type conversion
+ The problem
+ The solution
+ Defining our own converters
# Type conversion usecase—trimmed BigDecimals
# Configuring conversion across the entire application
# Custom type conversion is handy
+ Collections
# Usecase—adding a list of ingredients
# Updating our new recipe form
# Map-based collections
o Summary
Up
* Chapter 8: Interceptors
o The basics
+ Configuring interceptor stacks
+ Configuring interceptors
+ Configuring interceptors for individual actions
+ How interceptors work
o Interceptors in the default stack
+ The exception interceptor
+ The alias interceptor
+ The servletConfig interceptor
+ The prepare interceptor
+ The i18n interceptor
+ The chain interceptor
+ The debugging interceptor
+ The profiling interceptor
+ The scopedModelDriven interceptor
+ The modelDriven interceptor
# Getting back to the scopedModelDriven interceptor
+ The fileUpload interceptor
+ The checkbox interceptor
+ The staticParams interceptor
+ The params interceptor
# Ordered parameters and ad hoc factory patterns
+ The conversionError interceptor
+ The validation interceptor
+ The workflow interceptor
o Other important interceptors and interceptor stacks
+ The token interceptor
+ The store interceptor
+ The roles Interceptor
+ The clearSession interceptor
+ The paramsPrepareParamsStack interceptor stack
o Writing our own interceptors
+ The trim interceptor
+ Configuring the trim interceptor
+ The Test Action
+ Testing the trim interceptor
+ Modifying application flow with interceptors
# Configuring the result
# Writing the ResultMappingInterceptor
# Writing the ResultMappingInterceptor and making it work
o Summary
Up
* Chapter 9: Exceptions and Logging
o Handling exceptions in Struts 2
+ Global exception mappings
+ Action-specific exception mappings
+ Accessing the exception
+ Architecting exceptions and exception handling
# Checked versus unchecked exceptions
# Application-specific exceptions
# Abstracting underlying exceptions
+ Handling exceptions
o Logging
+ Introduction to logging
# Using the loggers
# Configuring the loggers
o Summary
Up
* Chapter 10: Getting Started with JavaScript
o Introduction to JavaScript
+ Playing with JavaScript
o Minor syntax and language notes
+ Unicode
+ Whitespace
+ Semicolons
+ Null and undefined values
+ The equal and strict equal operators
+ The logical OR operator
o Variables and scoping
+ JavaScript data types
# Numbers
# Strings
# Arrays
o Exception handling
o Introduction to JavaScript objects and OOP
+ Open objects and object augmentation
+ Object values can be functions
+ Object maker functions
o Functions
+ Function parameters
# Some trickery
+ Inner functions
+ Closures
o Introduction to JavaScript classes
+ Creating classes
# Variable and function access
# JavaScript's "this" keyword
+ Prototypes
o JavaScript modules and OOP
+ Creating a namespace
o Summary
Up
* Chapter 11: Advanced JavaScript, the DOM, and CSS
o The importance of markup
+ ID or style attribute?
+ Dressing up our form
# JavaScript modules and jQuery
+ Adding onclick handlers
# Using a function builder
# Accessing module data
# The final trick
o Adding dynamic form elements
+ Identifying where to add the elements
+ The JavaScript "Recipe" module
o Summary
Up
* Chapter 12: Themes and Templates
o Extracting the templates
o A maze of twisty little passages
+ Creating our theme
o Other uses of templates
o Summary
Up
* Chapter 13: Rich Internet Applications
o What this chapter is and isn't
o Dojo tags
+ Simple use cases really are simple
+ The Dojo <sx:head> tag
+ The Dojo <sx:a> tag
+ A brief side journey on topics
+ The Dojo <sx:div> tag
# Finishing our user story
# Highlighting the need to know
+ Dojo and forms
o The REST plug-in
+ REST in a nutshell
+ The REST plug-in in a nutshell
# REST plug-in URLs
# REST plug-in results
+ A web browser client example
# The REST controller
# REST controller responses
+ An example of a useful client
+ A command-line example
+ Custom content handler example
# YAML in a nutshell
# Writing our YAML handler
# Configuring our YAML handler
# Handling our YAML
o Summary
Up
* Chapter 14: Comprehensive Testing
o Test-driven development
o Unit testing
+ Test, code, refactor—the "heartbeat" of TDD
+ JUnit
# Revisiting our iterator filter
# The test environment
# The initial test stub
# Testing vowel recognition
# Testing non-string parameter exceptions
# Test granularity and test setup
+ TestNG
+ Legacy code and unit testing
+ Simple action testing
# Detour: Dependency Injection (Inversion of Control)
# Dependency Injection helps us test
+ Detour: Struts and Spring in a nutshell
# Spring web.xml configuration
# Spring context configuration file
o Testing Struts 2 in context
+ Testing a Struts interceptor
o Client-side (functional) testing
+ Selenium
# Selenium RC
# The test scenario
# Our first Selenium test
o Other forms of testing
+ Acceptance testing
+ Load testing
# Load testing with JMeter
+ Recovery testing
o Summary
Up
* Chapter 15: Documenting our Application
o Documenting Java
+ Self-documenting code
# Document why, not what
# Make your code read like the problem
# Contract-oriented programming
+ Javadocs
# Always write Javadocs!
# The first sentence
# Add information beyond the API name
# Write for multiple formats
# Generating targeted Javadocs
# The -use argument
# Creating new Javadoc tags with the -tag argument
# Never write Javadocs!
# Never write inline Java comments!
+ Using UML
# Package diagrams
# Class diagrams
# Sequence diagrams
o Documenting web applications
+ High-level overviews
+ Documenting JSPs
+ Documenting JavaScript
+ Documenting interaction
# More UML and the power of scribbling
# Don't spend so much time making pretty pictures
+ User documentation
o Documenting development
+ Source code control systems
# Code and mental history
# Commit comment commitment
# When (and what) do we commit
# Branching
# Branching discipline
+ Issue and bug management
# Linking to the SCCS
+ Wikis
+ RSS and IRC/chat systems
+ Word processor documents
o Summary
Up
* Index
此主题相关图片如下：
This book provides an in-depth introduction to Struts 2 and crash-courses in JavaScript, CSS, Test-Driven Development, agile programming techniques, and tool development, focusing on the delivery of complete, documented, maintainable web applications.
In Detail
Struts 2.1 is a modern, extensible, agile web application framework suitable for both small- and large-scale web applications.
The book begins with a comprehensive look at Struts 2.1 basics, interspersed with detours into more advanced development topics. You'll learn about configuring Struts 2.1 actions, results, and interceptors via both XML and Java annotations. You'll get an introduction to most of the Struts 2.1 custom tags and learn how they can assist in rapid application prototyping and development.
From there you'll make your way into Struts 2.1's strong support for form validation and type conversion, which allows you to treat your form values as domain objects without cluttering your code. A look at Struts 2.1's interceptors is the final piece of the Struts 2.1 puzzle, allowing you to leverage the standard Struts 2 interceptors as well as implement your own custom behavior.
After covering Struts 2.1 you'll journey into the world of JavaScript, a surprisingly capable language, the Document Object Model (DOM), and CSS, and learn how to create clean and concise client-side behavior. You'll leverage that knowledge as you move on to Struts 2 themes and templates, which give you a powerful way to encapsulate site-wide user interface behavior.
The book closes with a look at some tools that make the application development life cycle easier to manage, particularly in a team environment, and more automatic.
What you will learn from this book
* Explore the features of Struts 2.1 to develop your application
* Enhance your web application by writing your own custom result type
* Create your own type converter to handle custom data types
* Automatically generate application and development documentation
* Learn good exception handling practices for your applications
* Implement rich client behavior using JavaScript, the DOM, and CSS
* Create custom themes and templates to make shorter, cleaner JSP pages
* Run many types of tests both to prove functionality and to make change safe
Approach
This book takes a clear approach, focusing on one topic per chapter, but interspersing other issues in the mainline text and in chapter detours. Taking a practical approach, it discusses agile web development using Struts 2, with plenty of examples for better understanding.
Who this book is written for
This book is for Java developers who are interested in developing web applications using Struts. If you need a comprehensive introduction to Struts 2.1, along with the most important aspects of additional web application development technologies, agile programming practices, tool creation, and application life cycle management this book is for you. You don't need to know JavaScript and CSS to use this book as the author will teach you the required basics.
If you are a Struts 1 or WebWork user and wish to go ahead and migrate to Struts 2, this practical guide is also for you.
[返回] 中文XML论坛 - 专业的XML技术讨论区 →
计算机技术与应用 → 『 Java/Eclipse 』 → [分享][下载]Apache Struts 2 Web Application Development pdf
(订阅本版)
2009/8/6 19:18:00
新浪微博
[分享][下载]Apache Struts 2 Web Application Development pdf
