没有合适的资源?快使用搜索试试~ 我知道了~
首页计算机专业毕业设计-外文翻译
本文介绍Struts,它是使用 servlet 和 JavaServer Pages 技术的一种 Model-View-Controller 实现。Struts 可帮助您控制 Web 项目中的变化并提高专业化水平。尽管您可能永远不会用 Struts 实现一个系统,但您可以将其中的一些思想用于您以后的 servlet 和 JSP 网页的实现中。
资源详情
资源评论
资源推荐

Struts——an open-source MVC implementation
By Christian Kirkegaard and Anders Moller,BRICS, University of Aarhus, Denmark
This article introduces Struts, a Model-View-Controller implementation that uses servlets
and JavaServer Pages (JSP) technology. Struts can help you control change in your Web project
and promote specialization. Even if you never implement a system with Struts, you may get
some ideas for your future servlets and JSP page implementation.
Introduction
Kids in grade school put HTML pages on the Internet. However, there is a monumental
difference between a grade school page and a professionally developed Web site. The page
designer (or HTML developer) must understand colors, the customer, product flow, page layout,
browser compatibility, image creation, JavaScript, and more. Putting a great looking site together
takes a lot of work, and most Java developers are more interested in creating a great looking
object interface than a user interface. JavaServer Pages (JSP) technology provides the glue
between the page designer and the Java developer.
If you have worked on a large-scale Web application, you understand the term change.
Model-View-Controller (MVC) is a design pattern put together to help control change. MVC
decouples interface from business logic and data. Struts is an MVC implementation that uses
Servlets 2.2 and JSP 1.1 tags, from the J2EE specifications, as part of the implementation. You
may never implement a system with Struts, but looking at Struts may give you some ideas on
your future Servlets and JSP implementations.
Model-View-Controller (MVC)
JSP tags solved only part of our problem. We still have issues with validation, flow control,
and updating the state of the application. This is where MVC comes to the rescue. MVC helps
resolve some of the issues with the single module approach by dividing the problem into three
categories:

Model
The model contains the core of the application's functionality. The model encapsulates
the state of the application. Sometimes the only functionality it contains is state. It knows
nothing about the view or controller.
View
The view provides the presentation of the model. It is the look of the application. The
view can access the model getters, but it has no knowledge of the setters. In addition, it
knows nothing about the controller. The view should be notified when changes to the
model occur.
Controller
The controller reacts to the user input. It creates and sets the model.
MVC Model 2
The Web brought some unique challenges to software developers, most notably the stateless
connection between the client and the server. This stateless behavior made it difficult for the
model to notify the view of changes. On the Web, the browser has to re-query the server to
discover modification to the state of the application.
Another noticeable change is that the view uses different technology for implementation than the
model or controller. Of course, we could use Java (or PERL, C/C++ or what ever) code to
generate HTML. There are several disadvantages to that approach:
Java programmers should develop services, not HTML.
Changes to layout would require changes to code.
Customers of the service should be able to create pages to meet their specific needs.
The page designer isn't able to have direct involvement in page development.

HTML embedded into code is ugly.
For the Web, the classical form of MVC needed to change. Figure 1 displays the Web adaptation
of MVC, also commonly known as MVC Model 2 or MVC 2.
Figure 1. MVC Model 2
Struts, an MVC 2 implementation
Struts is a set of cooperating classes, servlets, and JSP tags that make up a reusable MVC 2
design. This definition implies that Struts is a framework, rather than a library, but Struts also
contains an extensive tag library and utility classes that work independently of the framework.
Figure 2 displays an overview of Struts.
Figure 2. Struts view
Struts overview
Client browser

An HTTP request from the client browser creates an event. The Web container will respond with
an HTTP response.
Controller
The Controller receives the request from the browser, and makes the decision where to send the
request. With Struts, the Controller is a command design pattern implemented as a servlet. The
struts-config.xml file configures the Controller.
Business logic
The business logic updates the state of the model and helps control the flow of the application.
With Struts this is done with an Action class as a thin wrapper to the actual business logic.
Model state
The model represents the state of the application. The business objects update the application
state. ActionForm bean represents the Model state at a session or request level, and not at a
persistent level. The JSP file reads information from the ActionForm bean using JSP tags.
View
The view is simply a JSP file. There is no flow logic, no business logic, and no model
information -- just tags. Tags are one of the things that make Struts unique compared to other
frameworks like Velocity.
Struts details
Displayed in Figure 3 is a stripped-down UML diagram of the org.apache.struts.action package.
Figure 6 shows the minimal relationships among ActionServlet (Controller), ActionForm (Form
State), and Action (Model Wrapper).

Figure 3:the relationship between ActionServlet (Controller)、 ActionForm (Form State)
and Action (Model Wrapper)
The ActionServlet class
Do you remember the days of function mappings? You would map some input event to a pointer
to a function. If you where slick, you would place the configuration information into a file and
load the file at run time. Function pointer arrays were the good old days of structured
programming in C.
Life is better now that we have Java technology, XML, J2EE, and all that. The Struts Controller
is a servlet that maps events (an event generally being an HTTP post) to classes. And guess what
-- the Controller uses a configuration file so you don_t have to hard-code the values. Life
changes, but stays the same.
ActionServlet is the Command part of the MVC implementation and is the core of the
Framework. ActionServlet (Command) creates and uses Action, an ActionForm, and
ActionForward. As mentioned earlier, the struts-config.xml file configures the Command.
During the creation of the Web project, Action and ActionForm are extended to solve the
specific problem space. The file struts-config.xml instructs ActionServlet on how to use the
extended classes. There are several advantages to this approach:
The entire logical flow of the application is in a hierarchical text file. This makes it easier
to view and understand, especially with large applications.
The page designer does not have to wade through Java code to understand the flow of the
application.
剩余21页未读,继续阅读





安全验证
文档复制为VIP权益,开通VIP直接复制

评论0