Struts2实战：现代Web应用框架解析

struts2

action

4星 · 超过85%的资源需积分: 3 108 浏览量更新于2024-08-01 收藏 1.71MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"struts2 in action" 《Struts2 in Action》是Action系列图书中的一本，该系列还包括《Spring in Action》、《Hibernate in Action》、《iBatis in Action》、《Ajax in Action》、《Ant in Action》和《Lucene in Action》，对于学习Java Web开发的人来说极具价值。这本书专门探讨了Struts2框架，它是一个现代化的Web应用程序框架，旨在简化Java Web应用的开发工作。 Struts2作为一款强大的MVC框架，它的出现是为了应对Struts1的局限性，提供更高效、更灵活的解决方案。在书中，作者详细介绍了以下几个关键部分： 1. **Part1: Struts2 - 一个全新的框架** - 第1章：Struts2 - 现代Web应用程序框架这一章介绍了Struts2的核心概念和它如何改进了原始Struts框架。它强调了Struts2的灵活性、可扩展性和与其他Java EE技术（如Spring、Hibernate）的集成能力。 2. **Part2: 深入核心：动作（Actions）、拦截器（Interceptors）和类型转换** - 第2章：与Struts2一起工作这一章详细阐述了如何创建和使用Struts2的动作，这些动作是处理用户请求的核心。 - 第3章：添加工作流 - 拦截器拦截器允许开发者在动作执行前后插入自定义逻辑，实现事务管理、权限检查等功能。 - 第4章：数据传输 - OGNL和类型转换 OGNL（Object-Graph Navigation Language）是Struts2中的表达式语言，用于对象属性的访问和操作；类型转换则涉及到将HTTP请求参数转化为Java对象的属性。 3. **Part3: 构建视图：标签（Tags）、UI组件（UI Components）、结果（Results）** - 第5章：构建视图 - 标签 Struts2提供了丰富的标签库，帮助开发者快速构建动态HTML页面。 - 第6章：UI组件标签这一章深入讨论了Struts2的UI组件，如表单、列表等，以及如何利用它们来增强用户界面。 - 第7章：结果的详细信息结果是动作执行后的状态，包括重定向、转发等，这部分解释了如何配置和控制这些结果。 4. **Part4: 完成应用：资源管理、验证（Validation）及其他** - 验证是任何Web应用中不可或缺的部分，书中会介绍如何在Struts2中实现有效的用户输入验证。 - 此外，还可能涵盖了国际化、错误处理、性能优化和部署策略等内容。通过阅读《Struts2 in Action》，开发者不仅可以掌握Struts2框架的基本用法，还能深入了解其设计原理和最佳实践，从而提高开发效率和应用质量。同时，读者可以参与作者在线论坛（http://www.manning-sandbox.com/forum.jspa?forumID=351），在那里发表评论或提问，获取及时的帮助和解答。

资源详情

资源推荐

Please post comments or corrections to the Author online forum at

http://www.manning-sandbox.com/forum.jspa?forumID=351

these actions should handle the request. Once it finds the appropriate action, the controller hands

over control of the request processing to the action by invoking it. This invocation process,

conducted by the framework, will both prepare the necessary data and execute the action’s

business logic. When the action completes its work, it will forward to the Struts 2 view

component, the result – which we will now consider.

View – Result

The view is the presentation component of the MVC pattern. Looking back at Figure 1.3,

we see that the result returns the page to the web browser. This page is the user interface which

presents a representation of the application’s state to the user. These are commonly JSP pages,

Velocity templates or some other presentation layer technology. While there are many choices

for the view, the role of the view is pretty clear cut and simple; it translates the state of the

application into a visual presentation with which the user can interact. With rich clients and Ajax

applications increasingly complicating the details of the view, it becomes even more important to

have clean MVC separation of concerns. Good MVC lays the ground work for easy management

of the most complex front end.

Pull-out: One of the interesting aspects of Struts 2 is how well its clean architecture paves

the way for new technologies and techniques. The Struts 2 result component is a good

demonstration of this. The result provides a clean encapsulation of the processing of

handing off control of the processing to another object that will write the response to the

client. This makes it very easy for alternative responses, such as XML Ajax snippets or

XSLT transformations, to be integrated into the framework.

If you look back to Figure 1.3, you can see that the action is responsible for choosing

which result will render the response. The action can choose from any number of results with

which it might have been associated. Common choices are between results that represent the

semantic outcomes of the action's processing, such as 'success' and 'error'. Struts 2 provides out

of the box support for using most common view layer technologies as results. These include JSP,

Velocity, FreeMarker, and XSLT . Better yet, the clean structure of the architecture insures that

more result types can be easily built to handle new types of responses.

Now that we've met the MVC components of the framework, you should probably have a

general idea of how Struts 2 handles the workflow of a web application. Now, we'll move in for a

closer examination of exactly how the framework processes a request.

1.3.3 How Struts 2 Works

Licensed to Lisa Williams <anhmytl@oatoz.net>

Please post comments or corrections to the Author online forum at

http://www.manning-sandbox.com/forum.jspa?forumID=351

You may have noticed, while studying Figure 1.4, that there is a stack of interceptors in

front of the action. This is a key part of the Struts 2 framework. We will devote an entire chapter

to this important component later in the book. At this time, it is enough to understand that every

action will have a stack of interceptors associated with it. These interceptors are invoked both

before and after the action. Note in Figure 1.4 that the interceptors actually fire before the action

and after the result. Also note that interceptors don't necessarily have to do something both times

they fire; sometimes the control merely pass through them. Some interceptors only do work

before the action has been executed, and others only do work afterwards. It depends on their

work. The important thing is that the interceptor allows common, cross cutting tasks to be

defined in clean, re-usable components that you can keep separate from your action code.

Definition: Interceptors are Struts 2 components that execute both before and after the

rest of the request processing. They provide an architectural component in which to

define various workflow and crosscutting tasks so that they can be easily reused as well

as separated from other architectural concerns.

What kinds of work should be done in interceptors? Logging is a good example.

Logging is something that should be done with the invocation of every action, but it probably

shouldn't be put in the action itself. Why? Because its not really part of the action's own unit of

work. It's more administrative, overhead if you will. Earlier, we charged a framework with the

responsibility of providing built-in functional solutions to common domain tasks such as data

validation, type conversion and file uploads. Struts 2 uses interceptors to do this type of work.

While these tasks are important, they are not specifically related to the action logic of the request.

Struts 2 uses interceptors to both separate and reuse these crosscutting concerns. Interceptors

play a huge role in the Struts 2 framework. And while you probably won’t spend a large

percentage of your time writing interceptors, most developers will eventually find that many tasks

are perfectly solved with custom interceptors. As we said, we will devote all of Chapter 4

Interceptors in Action to exploring this core component.

The ValueStack and OGNL

While interceptors may not absorb a lot of your daily development energies, the

ValueStack and OGNL will be constantly on your mind. In a nutshell, the ValueStack is simply a

storage area that holds all of the application domain data associated with the processing of a

request. You could think of it as a piece of scratch paper where the framework does its data work

while solving the problems of request processing. In short, OGNL is an expression language that

allows you to reference and manipulate the data on the ValueStack. Developers new to Struts 2

probably ask more questions about the ValueStack and OGNL than any thing else. If you are

coming from Struts 1, these are certainly a couple of the more exotic features of the new

framework. Due to this, and the sheer importance of this duo, we will carefully treat them

throughout the book. In particular, Chapter Five and Chapter Six describe the detailed function

of these two framework components.

Definition: Struts 2 uses the ValueStack as a storage area for all application domain data

that will be needed during the processing of a request. Data is moved to the ValueStack

in preparation of request processing, it is manipulated there during action execution, and

it is read from there when the results render their response pages.

Licensed to Lisa Williams <anhmytl@oatoz.net>

Please post comments or corrections to the Author online forum at

http://www.manning-sandbox.com/forum.jspa?forumID=351

The tricky, and powerful, thing about the ValueStack and OGNL is that they don't belong

to any of the individual framework components. In Figure 1.4, note than both interceptors and

results can use OGNL to target values on the ValueStack. The data in the ValueStack follows the

request processing through all phases; it slices through the whole length of the framework. It can

do this because it is stored in a ThreadLocal context called the ActionContext.

Definition: OGNL is a powerful expression language, and more, that is used to reference

and manipulate properties on the ValueStack.

The ActionContext contains all of the data that makes up the context in which an action

occurs. This includes the ValueStack obviously, but it also includes stuff the framework itself

will use internally, like the request, session, and application maps from the Servlet API. You can

definitely access these objects yourself if you like, and we'll see how later in the book. For now,

we just want to focus on the ActionContext as the ThreadLocal home of the ValueStack. The use

of ThreadLocal makes the ActionContext, and thus the ValueStack, accessible from anywhere in

the same thread of execution. Since Struts 2's processing of each request occurs in a single

thread, the ValueStack is available from any point in the framework's handling of a request.

Typically, its considered bad form to obtain the contents of the ActionContext yourself.

The framework provides many elegant ways to interact with that data with out actually touching

the ActionContext, or the ValueStack, yourself. Primarily, you will use OGNL to do this. OGNL

is used in many places in the framework to reference and manipulate data in the ValueStack. For

instance, you will use OGNL to bind HTML form fields to data objects on the ValueStack for

data transfer, and you will use OGNL to pull data into the rendering of your JSP's and other result

types. At this point, you just need to understand that the ValueStack is where your data is stored

while you work with it, and that OGNL is the expression language that you, and the framework,

use to target this data from various parts of the request processing cycle.

Now you've seen how Struts 2 implements MVC, and you've got a brief introduction to

all the other important players in the processing of actual requests. The next thing we need to do,

before getting down to the nuts and bolts of the framework’s core components, is to make all of

this concrete with a the simple HelloWorld application of Chapter Two. But first, a quick

summary.

1.4 Summary

We started with a lot of abstract stuff about frameworks and design patterns, but you

should now have a fairly good high level understanding of the Struts 2 architecture. If abstraction

is not to your taste, you'll be happy to know that we've officially completed the theoretical portion

of the book. Starting immediately with Chapter Two's HelloWorld application, the rest of the

book will deal with only the concrete, practical matters of building web applications. But before

we move on, let's take a moment to review the things we've learned.

We should probably spend a moment or two to evaluate Struts 2 as a framework. Based

upon our understanding of the technological context and the common domain tasks, we laid out

two responsibilities for a web application framework at the outset of this chapter. First, we said

that a framework should provide an architectural foundation for web applications. We've seen

that Struts 2 certainly does this, and we discussed the design pattern roots that inform the Struts 2

architectural decisions. In particular, we have seen that Struts 2 takes the lessons learned from

first generation web application frameworks to implement a brand new, cleaner MVC based

Licensed to Lisa Williams <anhmytl@oatoz.net>

Please post comments or corrections to the Author online forum at

http://www.manning-sandbox.com/forum.jspa?forumID=351

framework. We also met the specific framework components that implement the MVC pattern:

the action component, the result component, and the FilterDispatcher.

The other responsibility with which we charged web application frameworks was the

automation of many common tasks of the web application domain. These tasks are sometimes

referred to as cross cutting concerns because they occur again and again across the execution of a

disparate set of application specific actions. Logging, data validation, and other common, cross

cutting concerns should be separated from the concerns of the action and result. In Struts 2, the

interceptor provides an architectural mechanism for removing cross cutting concerns from the

core MVC components. As we go further into the book, you will realize that the framework

comes with many built-in interceptors to handle all the common tasks of the domain. Though

you will rarely, if ever, need to write an interceptor yourself, you will soon realize that they do

most of the work of the framework.

We also took a high level look at the actual request processing of the framework. We

saw that each action has a stack of interceptors that fire both before and after the action and result

have done their work. In addition to the MVC components and the interceptors, the ValueStack

and the OGNL expression language play critical roles in the storage and manipulation of data

within the framework. Hopefully, you have a decent grasp of what the framework does. In the

next chapter’s HelloWorld application, you will see a concrete example of the framework

components in action. Once we get the Chapter Two and the HelloWorld application behind us,

we will be moving on to explore the core components of the framework and start building our

Struts 2 Portfolio sample application.

Licensed to Lisa Williams <anhmytl@oatoz.net>

剩余175页未读，继续阅读

Silence

粉丝: 7
资源: 42

Struts2实战：现代Web应用框架解析

Struts2 in action中文版+配套源代码

Struts2 in action(struts2实战)

Struts 2实战：Struts2 in Action

Struts 2 in Action: 深入解析与实战指南

Struts 2入门指南：Struts 2 in Action英文原版PDF

Struts2中的Action 和 ActionContext

Struts2简介与基本原理

Struts2的安装与配置

Struts2中的表单处理

Struts2中的异常处理

struts1整合swagger2

实现一个基于Struts2的登录系统（需要访问数据库）。修改实验1登录系统代码，页面使用Struts2标签，登录成功页面使用OGNL表达式显示登录用户名称，并显示是系统第几位登录成功的用户的代码

struts1获取jsp上传文件

struts1 上传文件为null_JAVA入门：fileUpload文件上传

修改实验1登录系统代码，页面使用Struts2标签，登录成功页面使用OGNL表达式显示登录用户名称，并显示是系统第几位登录成功的用户。

页面使用Struts2标签，登录成功页面使用OGNL表达式显示登录用户名称，并显示是系统第几位登录成功的用户。完整代码

用jsp+struts2框架代码实现以下功能:导出千万级数据量,要求每50000笔数据导入到excel表格直到导完为止,再讲得到的多个excel表格压缩成zip包,最后导出为一个压缩包

idea利用strust2实现登录系统并记录登录次数 代码展示

javaweb外文文献

能不能把Python脚本提供给我

最新资源

idea利用strust2实现登录系统并记录登录次数代码展示