毕业设计JSP MVC外文翻译
毕业设计英文翻译JSP
JSP OverviewJSP is the latest Java technology for web application development and is based on the servlet technology introduced in the previous chapter. While servlets are great in many ways, they are generally reserved for programmers. In this chapter, we look at the problems that JSP technology solves, the anatomy of a JSP page, the relationship between servlets and JSP, and how the server processes a JSP page.In any web application, a program on the server processes requests and generates responses. In a simple one-page application, such as an online bulletin board, you don't need to be overly concerned about the design of this piece of code; all logic can be lumped together in a single program. However, when the application grows into something bigger (spanning multiple pages, using external resources such as databases, with more options and support for more types of clients), it's a different story. The way your site is designed is critical to how well it can be adapted to new requirements and continue to evolve. The good news is that JSP technology can be used as an important part in all kinds of web applications, from the simplest to the most complex.Therefore, this chapter also introduces the primary concepts in the design model recommended for web applications and the different roles played by JSP and other Java technologies in this model.The Problem with ServletsIn many Java servlet-based applications, processing the request and generating the response are both handled by a single servlet class. shows how a servlet class often looks.Example 3-1. A typical servlet classpublic class OrderServlet extends HttpServlet {public void doGet((HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {("text/html");PrintWriter out = ( );if (isOrderInfoValid(request)) {saveOrderInfo(request);("<html>");(" <head>");(" <title>Order Confirmation</title>");(" </head>");(" <body>");(" <h1>Order Confirmation</h1>");renderOrderInfo(request);(" </body>");("</html>");}...If you're not a programmer, don't worry about all the details in this code. The point is that the servlet contains request processing and business logic (implemented by methods such as isOrderInfoValid() and saveOrderInfo( )), and also generates the response HTML code, embedded directly in the servlet code using println( ) calls. A more structured servlet application isolates different pieces of the processing in various reusable utility classes and may also use a separate class library for generating the actual HTML elements in the response. Even so, the pure servlet-based approach still has a few problems:Thorough Java programming knowledge is needed to develop and maintain all aspects of the application, since the processing code and the HTML elements are lumped together.Changing the look and feel of the application, or adding support for a new type of client (such as a WML client), requires the servlet code to be updated and recompiled.It's hard to take advantage of web page development tools when designing the application interface. If such tools are used to develop the web page layout, the generated HTML must then be manually embedded into the servlet code, a process which is time consuming, error prone, and extremely boring.Adding JSP to the puzzle lets you solve these problems by separating the request processing and business logic code from the presentation, as illustrated in . Instead of embedding HTML in the code, place all static HTML in a JSP page, just as in a regular web page, and add a few JSP elements to generate the dynamic parts of the page. The request processing can remain the domain of the servlet, and the business logic can be handled by JavaBeans and EJB components.Figure 3-1. Separation of request processing, business logic, and presentationAs I mentioned before, separating the request processing and business logic frompresentation makes it possible to divide the development tasks among people with different skills. Java programmers implement the request processing and business logic pieces, web page authors implement the user interface, and both groups can use best-of-breed development tools for the task at hand. The result is a much more productive development process. It also makes it possible to change different aspects of the application independently, such as changing the business rules without touching the user interface.This model has clear benefits even for a web page author without programming skills, working alone. A page author can develop web applications with many dynamic features, usingthe JSP standard actions and the JSTL libraries, as well as Java components provided by open source projects and commercial companies.JSP ProcessingJust as a web server needs a servlet container to provide an interface to servlets, the server needs a JSP container to process JSP pages. The JSP container is responsible for intercepting requests for JSP pages. To process all JSP elements in the page, the container first turns the JSP page into a servlet (known as the JSP page implementation class). The conversion is pretty straightforward; all template text is converted to println( ) statements similar to the ones in the handcoded servlet shown in , and all JSP elements are converted to Java code that implements the corresponding dynamic behavior. The container then compiles the servlet class.Converting the JSP page to a servlet and compiling the servlet form the translation phase. The JSP container initiates the translation phase for a page automatically when it receives the first request for the page. Since the translation phase takes a bit of time, the first user to request a JSP page notices a slight delay. The translation phase can also be initiated explicitly; this is referred to as precompilation of a JSP page. Precompiling a JSP page is a way to avoid hitting the first user with this delay. It is discussed in more detail in .The JSP container is also responsible for invoking the JSP page implementation class (the generated servlet) to process each request and generate the response. This is called the request processing phase. The two phases are illustrated in .Figure 3-2. JSP page translation and processing phasesAs long as the JSP page remains unchanged, any subsequent request goes straight to the request processing phase ., the container simply executes the class file). When the JSP page is modified, it goes through the translation phase again before entering the request processing phase.The JSP container is often implemented as a servlet configured to handle all requests for JSP pages. In fact, these two containers—a servlet container and a JSP container—are often combined in one package under the name web container.So in a way, a JSP page is really just another way to write a servlet without having to be a Java programming wiz. Except for the translation phase, a JSP page is handled exactly like a regular servlet; it's loaded once and called repeatedly, until the server is shut down. By virtue of being an automatically generated servlet, a JSP page inherits all the advantages of a servlet described in : platform and vendor independence, integration, efficiency, scalability, robustness, and security.JSP ElementsThere are three types of JSP elements you can use: directive, action, and scripting. A new construct added in JSP is an Expression Language (EL) expression; let's call this a forth element type, even though it's a bit different than the other three.Directive elementsThe directive elements, shown in , specify information about the page itself that remains the same between requests—for example, if session tracking is required or not, buffering requirements,Table 3-1. Directive elementscomponentsJSP elements, such as action and scripting elements, are often used to work with JavaBeans components. Put succinctly, a JavaBeans component is a Java class that complies with certain coding conventions. JavaBeans components are typically used as containers for information that describes application entities, such as a customer or an order.JSP Application Design with MVCJSP technology can play a part in everything from the simplest web application, such as an online phone list or an employee vacation planner, to complex enterprise applications, such as a human resource application or a sophisticated online shopping site. How large a part JSP plays MVC was first described by Xerox in a number of papers published in the late 1980s. The key differs in each case, of course. In this section, I introduce a design model called Model-View-Controller (MVC), suitable for logic into three distinct units: the Model, the View, and the Controller. In a server application, we commonly classify the parts of the application as business logic, presentation, and request processing. Business logic is the term used for the manipulation of an application's data, such as customer, product, and order information. Presentation refers to how the application data is displayed to the user, for example, position, font, and size. And finally, request processing is what ties the business logic and presentation parts together. In MVC terms, the Model corresponds to business logic and data, the View to the presentation, and the Controller to the request processing.Why use this design with JSP? The answer lies primarily in the first two elements. Remember that an application data structure and logic (the Model) is typically the most stable part of an application, while the presentation of that data (the View) changes fairly often. Just look at all the face-lifts many web sites go through to keep up with the latest fashion in web design. Yet, the data they present remains the same. Another common example of why presentation should be separated from the business logic is that you may want to present the data in different languages or present different subsets of the data to internal and external users. Access to the data through new types of devices, such as cell phones and personal digital assistants (PDAs), is the latest trend. Each client type requires its own presentation format. It should come as no surprise, then, that separating business logic from the presentation makes it easier to evolve an application as the requirements change; new presentation interfaces can be developed without touching the business logic.This MVC model is used for most of the examples in this book. In Part II, JSP pages are used as both the Controller and the View, and JavaBeans components are used as the Model. The examples in Chapter 5 through Chapter 9 use a single JSP page that handles everything, while Chapter 10 through Chapter 14 show how you can use separate pages for the Controller and the View to make the application easier to maintain. Many types of real-world applications can be developed this way, but what's more important is that this approach allows you to examine all the JSP features without getting distracted by other technologies. In Part III, we look at other possible role assignments when JSP is combined with servlets and Enterprise JavaBeans.JSP 概览JSP是一种用于Web应用程序开发的最新的Java技术，它是成立在servlet 技术基础之上的。
MVC设计模式THE-MVC-WEB-DESIGN-PATTERN大学毕业论文外文文献翻译及原文
毕业设计（论文）外文文献翻译文献、资料中文题目：MVC设计模式文献、资料英文题目：THE MVC-WEB DESIGN PATTERN文献、资料来源：文献、资料发表（出版）日期：院（部）：专业：班级：姓名：学号：指导教师：翻译日期： 2017.02.14MVC设计模式Ralph F. Grove计算机科学，詹姆斯麦迪逊大学，哈里森堡，美国弗吉尼亚州***************Eray Ozkan计算机科学，詹姆斯麦迪逊大学，哈里森堡，美国弗吉尼亚州*****************关键字：web，web框架，设计模式，模型-视图-控制器模式摘要：模型-视图-控制器模式被引用为许多web开发框架的基础架构。
然而，用于web开发的MVC 版本随着原来的Smalltalk的MVC的演变而发生了一些改变。
本文介绍了对这些变化的分析，并提出了一种独立的Web-MVC模式，用于更准确的描述MVC是如何在web框架中实现的。
1.介绍模型-视图-控制器(Modle-View-Controller，MVC)设计模式被一些web应用框架作为基础架构，例如，Rails，以及Struts。
MVC最初是在施乐帕克研究中心(Goldberg和Robson，1985)开发的Smalltalk编程环境中实现的。
为了适应web框架，MVC已经演变成了另一种方式，最终成为一种不同于其他任何设计模式，也与原始的Smaltalk完全不同的模式的实现。
本文的第一个目标是介绍MVC设计模式，其中包括它的原始形态(第2节)以及现代众所周知的用于web应用框架的变更后的形态(第3节)。
第二个目标是对这个模式演变后发生的变化进行评估，同时呈现演变后版本的有效性(第3节)。
最后，我们提出了一个标准的MVC-Web设计模式的描述，用于反映目前在web框架中模式的使用，同时又能保持原始的MVC中令人满意的特性。
基于MVC的web应用框架的修订版本已经被提出了(Chun, Yanhua, 和Hanhong, 2003) (Barrett和Delaney, 2004)。
毕业设计JSPmvc外文翻译
Struts——一种开源MVC的实现这篇文章介绍 Struts，一个使用 servlet 和 JavaServer Pages 技术的一种 Model-View-Controller 的实现。
Struts 可以帮助你控制 Web 项目中的变化并提高专业化。
即使你可能永远不会用 Struts实现一个系统，你可以获得一些想法用于你未来的 servlet 和 JSP 网页的实现中。
简介在小学校园里的小孩子们都可以在因特网上发布 HTML 网页。
然而，有一个重大的不同在一个小学生和一个专业人士开发的之间。
网页设计师（或者 HTML开发人员）必须理解颜色、用户、生产流程、网页布局、浏览器兼容性、图像创建、JavaScript 等等。
设计漂亮的需要做大量的工作，大多数 Java 开发人员更注重创建优美的对象接口，而不是用户界面。
JavaServer Pages (JSP) 技术为网页设计人员和 Java 开发人员提供了一种联系钮带。
如果你开发过大型 Web 应用程序，你就理解“变化”这个词语。
“模型-视图-控制器”(MVC) 就是用来帮助你控制变化的一种设计模式。
MVC 减弱了业务逻辑接口和数据接口之间的耦合。
Struts 是一种 MVC 实现，它将 Servlet 2.2 和 JSP 1.1 标记（属于 J2EE 规）用作实现的一部分。
你可能永远不会用 Struts 实现一个系统，但了解一下 Struts 或许使你能将其中的一些思想用于你以后的 Servlet 和 JSP 实现中。
模型-视图-控制器 (MVC)JSP标签只解决了我们问题中的一部分。
我们依然有验证、流控制、以及更新应用程序结构的问题。
这就是MVC从哪儿来以及来干嘛的。
MVC通过把问题分成三类来帮助解决一些与单模块相关的问题：?Model（模型）模块包括应用程序功能的核心。
模型封装着应用程序的各个结构。
有时它所包含的唯一功能就是结构。
它对于视图或者控制器一无所知。
jsp技术网站设计外文翻译(适用于毕业论文外文翻译+中英文对照)
Combining JSP and ServletsThe technology of JSP and Servlet is the most important technology which use Java technology to exploit request of server, and it is also the standard which exploit business application .Java developers prefer to use it for a variety of reasons, one of which is already familiar with the Java language for the development of this technology are easy to learn Java to the other is "a preparation, run everywhere" to bring the concept of Web applications, To achieve a "one-prepared everywhere realized." And more importantly, if followed some of the principles of good design, it can be said of separating and content to create high-quality, reusable, easy to maintain and modify the application. For example, if the document in HTML embedded Java code too much (script), will lead the developed application is extremely complex, difficult to read, it is not easy reuse, but also for future maintenance and modification will also cause difficulties. In fact, CSDN the JSP / Servlet forum, can often see some questions, the code is very long, can logic is not very clear, a large number of HTML and Java code mixed together. This is the random development of the defects.Early dynamic pages mainly CGI (Common Gateway Interface, public Gateway Interface) technology, you can use different languages of the CGI programs, such as VB, C / C + + or Delphi, and so on. Though the technology of CGI is developed and powerful, because of difficulties in programming, and low efficiency, modify complex shortcomings,it is gradually being replaced by the trend. Of all the new technology, JSP / Servlet with more efficient and easy to program, more powerful, more secure and has a good portability, they have been many people believe that the future is the most dynamic site of the future development of technology.Similar to CGI, Servlet support request / response model. When a customer submit a request to the server, the server presented the request Servlet, Servlet responsible for handling requests and generate a response, and then gave the server, and then from the server sent to the customer. And the CGI is different, Servlet not generate a new process, but with HTTP Server at the same process. It threads through the use of technology, reduce the server costs. Servlet handling of the request process is this: When received from the client's request, calling service methods, the method of Servlet arrival of the first judgement is what type of request (GET / POST / HEAD…), then calls the appropriate treatment (DoGet / doPos t / doHead…) and generate a response.Although such a complex, in fact, simply said to Servlet is a Java class. And the general category of the difference is that this type operating in a Servlet container, which can provide session management and targeted life-cycle management. So that when you use the Servlet, you can get all the benefits of the Java platform, including the safety of the management, use JDBC access the database and cross-platform capability. Moreover, Servlet using thread, and can develop more efficient Web applications.JSP technology is a key J2EE technology, it at a higher level of abstraction of a Servlet.It allows conventional static and dynamic HTML content generated by combining an HTML page looks like, but as a Servlet to run. There are many commercial application server support JSP technology, such as BEA WebLogic, IBM WebSphere, JRun, and so on. JSP and Servlet use more than simple. If you have a JSP support for Web servers, and a JSP document, you can put it Fangdao any static HTML files can be placed, do not have to compile, do not have to pack, do not have to ClassPath settings, you can visit as ordinary Web It did visit, the server will automatically help you to do other work.JSP document looks like an ordinary static HTML document, but inside contains a number of Java code. It uses. Jsp the suffix, used to tell the server this document in need of special treatment. When we visit a JSP page, the document will first be translated into a JSP engine Java source files, is actually a Servlet, and compiler, and then, like other Servlet, from Servlet engine to handle. Servlet engine of this type loading, handling requests from customers, and the results returned to the customer, as shown below:Figure 1: Calling the process of JSP pagesAfter another visit this page to the customer, as long as the paper there have been no changes, JSP engine has been loaded directly call the Servlet. If you have already been modified, it will be once again the implementation of the above process, translate, compile and load. In fact, this is the so-called "first person to punishment." Because when the first visit to the implementation of a series of the above process, so will spend some time after such a visit would not.Java servlets offer a powerful API that provides access to all the information about the request, the session, and the application. combining JSP with servlets lets you clearly separate the application logic from the presentation of the application; in other words, it lets you use the most appropriate component type for the roles of Model, View and Controller.Servlets, Filters, and ListenersA servlet is a Java class that extends a server with functionality for processing a request and producing a response. It's implemented using the classes and interfaces defined by the Servlet API. The API consists of two packages: the javax.servlet package contains classes and interfaces that are protocol-independent, while the javax.servlet.http package provides HTTP-specific extensions and utility classes.What makes a servlet a servlet is that the class implements an interface named javax.servlet.Servlet, either directly or by extending one of the support classes. This interface defines the methods used by the web container to manage and interact with theservlet. A servlet for processing HTTP requests typically extends the javax.servlet.http.HttpServlet class. This class implements the Servlet interface and provides additional methods suitable for HTTP processing.Servlet LifecycleThe web container manages all aspects of the servlet's lifecycle. It creates an instance of the servlet class when needed, passes requests to the instance for processing, and eventually removes the instance. For an HttpServlet, the container calls the following methods at the appropriate times in the servlet lifecycle.Besides the doGet( ) and doPost( ) methods, there are methods corresponding to the other HTTP methods: doDelete( ), doHead( ), doOptions( ), doPut( ), and doTrace( ). Typically you don't implement these methods; the HttpServlet class already takes care of HEAD, OPTIONS, and TRACE requests in a way that's suitable for most servlets, and the DELETE and PUT HTTP methods are rarely used in a web application.It's important to realize that the container creates only one instance of each servlet. This means that the servlet must be thread safe -- able to handle multiple requests at the same time, each executing as a separate thread through the servlet code. Without getting lost in details, you satisfy this requirement with regards to instance variables if you modify the referenced objects only in the init( ) and destroy( ) methods, and just read them in the request processing methods.Compiling and Installing a ServletTo compile a servlet, you must first ensure that you have the JAR file containing all Servlet API classes in the CLASSPATH environment variable. The JAR file is distributed with all web containers. Tomcat includes it in a file called servlet.jar, located in the common/lib directory. On a Windows platform, you include the JAR file in the CLASSPATH.. Reading a RequestOne of the arguments passed to the doGet( ) and doPost( ) methods is an object that implements the HttpServletRequest interface. This interface defines methods that provide access to a wealth of information about the request.Generating a ResponseBesides the request object, the container passes an object that implements the HttpServletResponse interface as an argument to the doGet( ) and doPost( ) methods. This interface defines methods for getting a writer or stream for the response body. It also defines methods for setting the response status code and headers.Using Filters and ListenersThe servlet specification defines two component types beside servlets: filters and listeners. These two types were introduced in the Servlet 2.3 specification, so if you're using a container that doesn't yet support this version of the specification, I'm afraid you'reout of luck.FiltersA filter is a component that can intercept a request targeted for a servlet, JSP page, or static page, as well as the response before it's sent to the client. This makes it easy to centralize tasks that apply to all requests, such as access control, logging, and charging for the content or the services offered by the application. A filter has full access to the body and headers of the request and response, so it can also perform various transformations. One example is compressing the response body if the Accept-Language request header indicates that the client can handle a compressed response.A filter can be applied to either a specific servlet or to all requests matching a URL pattern, such as URLs starting with the same path elements or having the same extension. ListenersListeners allow your application to react to certain events. Prior to Servlet 2.3, you could handle only session attribute binding events (triggered when an object was added or removed from a session). You could do this by letting the object saved as a sessionattribute(using the HttpSession.setAttribute() method)implement the HttpSessionBindingListener interface. With the new interfaces introduced in the 2.3 version of the specification, you can create listeners for servlet context and session lifecycle events as well as session activation and passivation events (used by a container that temporarily saves session state to disk or migrates a session to another server). A newsession attribute event listener also makes it possible to deal with attribute binding events for all sessions in one place, instead of placing individual listener objects in each session.The new types of listeners follow the standard Java event model. In other words, a listener is a class that implements one or more of the listener interfaces. The interfaces define methods that correspond to events. The listener class is registered with the container when the application starts, and the container then calls the event methods at the appropriate times.Initializing Shared Resources Using a ListenerBeans like this typically need to be initialized before they can be used. For instance, they may need a reference to a database or some other external data source and may create an initial information cache in memory to provide fast access even to the first request for data. You can include code for initialization of the shared resources in the servlet and JSP pages that need them, but a more modular approach is to place all this code in one place and let the other parts of the application work on the assumption that the resources are already initialized and available. An application lifecycle listener is a perfect tool for this type of resource initialization. This type of listener implements the javax.servlet.ServletContextListener interface, with methods called by the container when the application starts and when it shuts down.Picking the Right Component Type for Each TaskThe Project Billboard application introduced is a fairly complex application. Half thepages are pure controller and business logic processing, it accesses a database to authenticate users, and most pages require access control. In real life, it would likely contain even more pages, for instance, pages for access to a shared document archive, time schedules, and a set of pages for administration. As the application evolves, it may become hard to maintain as a pure JSP application. It's easy to forget to include the access control code in new pages.This is clearly an application that can benefit from using a combination of JSP pages and the component types defined by the servlet specification for the MVC roles. Let's look at the main requirements and see how we can map them to appropriate component types:●Database access should be abstracted, to avoid knowledge of a specific dataschema or database engine in more than one part of the application: beans in therole of Model can be used to accomplish this.●The database access beans must be made available to all other parts of theapplication when it starts: an application lifecycle event listener is the perfectcomponent type for this task.●Only authenticated users must be allowed to use the application: a filter canperform access control to satisfy this requirement.●Request processing is best done with Java code: a servlet, acting as the Controller,fits the bill.●It must be easy to change the presentation: this is where JSP shines, acting as theView.Adding servlets, listeners, and filters to the mix minimizes the need for complex logic in the JSP pages. Placing all this code in Java classes instead makes it possible to use a regular Java compiler and debugger to fix potential problems.Centralized Request Processing Using a ServletWith a servlet as the common entry point for all application requests, you gain control over the page flow of the application. The servlet can decide which type of response to generate depending on the outcome of the requested action, such as returning a common error page for all requests that fail, or different responses depending on the type of client making the request. With the help from some utility classes, it can also provide services such as input validation, I18N preparations, and in general, encourage a more streamlined approach to request handling.When you use a servlet as a Controller, you must deal with the following basic requirements:●All requests for processing must be passed to the single Controller servlet.●The servlet must be able to distinguish requests for different types of processing.Here are other features you will want support for, even though they may not be requirements for all applications:● A strategy for extending the application to support new types of processingA mechanism for changing the page flow of the application without modifyingcode.Mapping Application Requests to the ServletThe first requirement for using a Controller servlet is that all requests must pass through it. This can be satisfied in many ways. If you have played around a bit with servlets previously, you're probably used to invoking a servlet with a URI that starts with /myApp/servlet. This is a convention introduced by Suns Java Web Server (JWS), the first product to support servlets before the API was standardized. Most servlet containers support this convention today, even though it's not formally defined in the servlet specification.将Servlet和JSP组合使用Servlet和JSP技术是用Java开发服务器端应用的主要技术，是开发商务应用表示端的标准。
JSP及其WEB技术毕业设计论文中英文资料对照外文翻译文献
中英文资料对照外文翻译文献JSP及其WEB技术. 1 JSP简介JSP（JavaServer Pages）是一种基于Java的脚本技术。
是由Sun Microsystems 公司倡导、许多公司参与一起建立的一种动态网页技术标准。
JSP技术有点类似ASP 技术，它是在传统的网页HTML文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件(*.jsp)。
用JSP开发的Web应用是跨平台的，即能在Linux下运行，也能在其他操作系统上运行。
在JSP 的众多优点之中，其中之一是它能将 HTML 编码从 Web 页面的业务逻辑中有效地分离出来。
用 JSP 访问可重用的组件，如 Servlet、JavaBean 和基于 Java 的 Web 应用程序。
JSP 还支持在Web 页面中直接嵌入 Java 代码。
可用两种方法访问 JSP 文件：浏览器发送 JSP 文件请求、发送至 Servlet 的请求。
JSP技术使用Java编程语言编写类XML的tags 和scriptlets，来封装产生动态网页的处理逻辑。
网页还能通过tags和scriptlets 访问存在于服务端的资源的应用逻辑。
JSP将网页逻辑与网页设计和显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。
Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。
插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。
JSP与Java Servlet一样，是在服务器端执行的，通常返回该客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。
JSP页面由HTML代码和嵌入其中的Java代码所组成。
服务器在页面被客户端请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。
jsp网站开发毕设外文翻译
jsp网站开发毕设外文翻译西安邮电大学外文文献翻译院 (系): 计算机学院专业: 计算机科学与技术班级:学生姓名: 导师姓名: 职称:起止时间:2011年 9月23日至 2012年 6月2日原文:Java and the InternetAlthough Java is very useful for solving traditional stand-alone programming problems, it is also important because it will solve programming problems on the World Wide Web.1. Client-side programmingThe Web’s initial server-browser design provided for interactive content, but the interactivity was completely provided by the server. The server produced static pages for the client browser, which would simply interpret and display them. Basic HTML contains simple mechanisms for data gathering: text-entry boxes, check boxes, radio boxes, lists and drop-down lists, as well as a button that can only be programmed to reset t he data on the form or “submit” the data on the form back to the server. This submission passes through the Common Gateway Interface (CGI) provided on all Web servers. The text within the submission tells CGI what to do with it. The most common action is to run a programlocated on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the topof your browser when you push a button on a Web page, you can sometimes see “cgi-bin” within all thegobbledygook there.) These programs can be written in most languages. Perl is a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system.Many powerful Web sites today are built strictly on CGI, and you can in fact do nearly anything with it. However, Web sites built on CGI programs can rapidly become overly complicated to maintain, and there is also the problem of response time. The response of a CGI program depends on how much data must be sent, as well as the load on both the serverand the Internet. (On top of this, starting a CGI program tends to be slow.) The initial designers of the Web did not foresee how rapidly this bandwidth would be exhausted for the kinds of applications people developed. For example, any sort of dynamic graphing is nearlyimpossible to perform with consistency because a GIF file must becreated and moved from the server to the client for each version of the graph. And you’ve no doubt had direct ex perience with something as simple as validating the data on an input form. You press the submit button on a page; the data is shipped back to the server; the server starts a CGI program that discovers an error, formats an HTML page informing you of the error, and then sends the page back to you; youmust then back up a page and try again. Not only is this slow, it’s inelegant.The solution is client-side programming. Most machines that run Web browsers are powerful engines capable of doing vast work, and with the original static HTML approach they are sitting there, just idly waiting for the server to dish up the next page. Client-side programming means that the Web browser is harnessed to do whatever work it can, and the result for the user is a much speedier and more interactive experience at your Web site.The problem with discussions of client-side programming is that they aren’t very different fromdiscussions of programming in general. The parameters are almost the same, but the platform is different: a Web browser is like a limited operating system. In the end, you must still program, and this accounts for the dizzying array of problems and solutions produced by client-side programming. The rest of this section provides an overview of the issues and approaches in client-side programming. 2.Plug-insOne of the most significant steps forward in client-side programming is the development of the plug-in. This is a way for a programmer to add new functionality to the browser by downloading a piece of code that plugs itself into the appropriate spot in the browser. It tells the browser “from now on you can perform this new activity.” (You need to download the plug-in only once.) Some fast and powerfulbehavior is added to browsers via plug-ins, but writing a plug-in is not a trivial task, and isn’t somethingyou’d want to do as part of the process of building a particular site. The value of the plug-in forclient-side programming is that it allows an expert programmer to develop a new language and add that language to a browser without the permission of the browser manufacturer. Thus, plug-ins provide a “back door” that allows the creation of new client-side programming languages (although not alllanguages are implemented as plug-ins).3.Scripting languagesPlug-ins resulted in an explosion of scripting languages. With a scripting language you embed the source code for your client-side program directly into the HTML page, and the plug-in that interpretsthat language is automatically activated while the HTML page is being displayed. Scripting languages tend to be reasonably easy to understand and, because they are simply text that is part of an HTML page, they load very quickly as part of the single server hit required to procure that page. The trade-off is that your code is exposed for everyone to see (and steal). Generally, however, you aren’t doing amazingly sophisticated things with scripting languages so this is not too much of a hardship. This points out that the scripting languages used inside Web browsers are really intended to solve specific types of problems, primarily the creation of richer and more interactive graphical userinterfaces (GUIs). However, a scripting language might solve 80 percent of the problems encountered in client-side programming. Your problems might very well fit completely within that 80 percent, and sincescripting languages can allow easier and faster development, you should probably consider a scripting language before looking at a more involved solution such as Java or ActiveX programming. The most commonly discussed browser scripting languages are JavaScript (which has nothing to do with Java; it’s named that way just to grab some of Java’s marketing momentum), VBScript (whichlooks like Visual Basic), and Tcl/Tk, which comes from the popular cross-platform GUI-building language. There are others out there, and no doubt more in development.JavaScript is probably the most commonly supported. It comes builtinto both Netscape Navigatorand the Microsoft Internet Explorer (IE). In addition, there are probably more JavaScript books available than there are for the other browser languages, and some tools automatically create pages using JavaScript. However, if you’re already fluent in Visual Basic or Tcl/Tk, you’ll be mor e productive using those scripting languages rather than learning a new one. (You’ll have your hands full dealing with the Web issues already.)4.JavaIf a scripting language can solve 80 percent of the client-side programming problems, what about the other 20 percent—the “really hardstuff?” The most popular solution today is Java. Not only is it a powerful programming language built to be secure, cross-platform, and international, but Java is being continually extended to provide language features and libraries that elegantly handle problems that are difficult in traditional programming languages, such as multithreading, database access, network programming, and distributed computing. Java allows client-side programming via the applet. An applet is a mini-program that will run only under a Web browser. The applet is downloaded automatically as part of a Web page (just as, for example, a graphic is automatically downloaded).it provides you with a When the applet is activated it executes a program. This is part of its beauty—way to automatically distribute the client software from the server at the time the user needs the client software, and no sooner. The user gets the latest version of the client software without fail and without difficult reinstallation. Because of the way Java is designed, the programmer needs to create only a single program, and that program automatically works with all computers that have browsers with built-in Java interpreters. (This safely includes the vast majority of machines.) Since Java is a full-fledged programming language, you can do as much work as possible on the client before and after making requests of the server. For example, you won’t need to send a request form across the Internet todiscover that you’ve gotten a d ate or some other parameter wrong, and your client computer can quickly do the work of plotting data instead of waiting for the server to make a plot and ship a graphic image back to you. Not only do you get the immediate win of speed and responsiveness, but the general network traffic and load on servers can be reduced, preventing the entire Internet from slowing down. One advantage a Java applet has over a scripted program is that it’s in compiled form, so the sourcecode isn’t available to the client. O n the other hand, a Javaapplet can be decompiled without too much trouble, but hiding your code is often not an important issue. Two other factors can be important. As you will see later in this book, a compiled Java applet can comprise many modules and t ake multiple server “hits” (accesses) to download. (In Java 1.1 and higher this is minimized by Java archives, called JAR files, that allow all the required modules to be packaged together and compressed for a single download.) A scripted program will just be integrated into the Web page as part of its text (and will generally be smaller and reduce server hits). This could be important to the responsiveness of your Web site. Another factor is the all-important learning curve. Regardless of what you’ve heard, Java is not a trivial language to learn. If you’re a Visual Basic programmer, moving to VBScript will be your fastest solution, and since it will probably solve most typical client/server problems you might be hard pressed to justify learning Java. If yo u’re experienced with a scripting language you willcertainly benefit from looking at JavaScript or VBScript before committing to Java, since they might fit your needs handily and you’ll bemore productive sooner.to run its applets withi5.ActiveXTo so me degree, the competitor to Java is Microsoft’s ActiveX, although it takes a completely different approach. ActiveX wasoriginally a Windows-only solution, although it is now being developed via an independent consortium to become cross-platform. Effectively, ActiveX says “if yourprogram connects to its environment just so, it can be dropped into a Web page and run under a browser that supports ActiveX.” (IE directly supports ActiveX and Netscape does so using a plug-in.) Thus, ActiveX does not constrain you to a particular language. If, for example, you’re already an experienced Windows programmer using a language such as C++, Visual Basic, or Borland’s Delphi, you can create ActiveX components with almost no changes to your programming knowledge. ActiveX also provides a path for the use of legacy code in your Web pages.6.Internet vs. intranetThe Web is the most general solution to the client/server problem,so it makes sense that you can use the same technology to solve a subset of the problem, in particular the classic client/server problem within a company. With traditional client/server approaches you have the problemof multiple types of client computers, as well as the difficulty of installing new client software, both of which are handily solved with Web browsers and client-side programming. When Web technology is used for an information network that is restricted to a particular company, it is referred to as an intranet. Intranets provide much greater security than the Internet, since you can physically control access to the servers within your company. In terms of training, it seems that once people understand the general concept of a browser it’s much easier for them to deal with differences in the way pages and applets look, so thelearning curve for new kinds of systems seems to be reduced.The security problem brings us to one of the divisions that seems to be automatically forming in the world of client-side programming. If your program is running on the Internet, you don’t know what platform it will be working under, and you want to be extra careful that you don’t disseminate buggy code. You need something cross-platform and secure, like a scripting language or Java. If you’re running on an intranet, you might have a different set of constraints. It’s not uncommon that your machines could all be Intel/Windows platforms. On an intranet, you’re responsible for the quality of your own code and can repair bugs when they’re discovered. In addition, you might already have abody of legacy code that you’ve been using in a more traditional client/server approach, whereby you must physically install clientprograms every time you do an upgrade. The time wasted in installing upgrades is the most compelling reason to move to browsers, because upgrades are invisible and automatic. If you are involved in such an intranet, the most sensible approach to take is the shortest path that allows you to use your existing code base, rather than trying to recode your programs in a new language.When faced with this bewildering array of solutions to the client-side programming problem, the bestplan of attack is a cost-benefit analysis. Consider the constraints of your problem and what would be the shortest path to your solution. Since client-side programming is still programming, it’s always a good idea to take the fastest development approach for your particular situation. This is an aggressive stance to prepare for inevitable encounters with the problems of program development.翻译:Java和因特网Java除了可解决传统的程序设计问题以外，还能解决World Wide Web(万维网)上的编程问题。
jsp在线问卷调查系统的分析与实现毕业设计英文文献翻译
jsp在线问卷调查系统的分析与实现毕业设计英文文献翻译毕业设计说明书英文文献及中文翻译班级: 学号:姓名:软件学院学院:软件工程专业:指导教师:2014 年 6 月MVC Design PatternMVC is a widely popular software design pattern, as early as in the70's, IBM introduced the Sanfronscisico on the project, in fact, is the MVC design pattern research. Recently, with the maturity of J2EE, it is becoming a recommendation in the J2EE platform, a design model, the majority of Java developers are also very interested in the design model. MVC model is gradually developed in PHP and ColdFusion are in use, and growth trends. With the rapid increase in web applications, MVC modelfor the development of Web applications is a very advanced design idea, no matter what language you choose, no matter how complicated the application, it can be for you to understand and provide the most basic application model analytical methods, structural products for you toprovide a clear framework for the design, for your software projects in accordance with norms.MVC design ideaMVC in English or Model-View-Controller, an application that is input, process, output process in accordance with the Model, View, Controller isolated manner, such an application is divided into three layers - model layer, view layer, control layer.View (View) on behalf of the user interface for Web applications can be summed up as HTML interface, but has the potential to XHTML, XML, and Applet. With the application of the complexity and scale, the interface has become challenging to deal with. An application may have different views, MVC design pattern to deal with the view of the limited view of data acquisition and processing, as well as the user's request, not included in the view on the handling of business processes. The handling of business processes to the model (Model) to deal with. For example, a view only accept orders from the model data and display to users, as well as input user interface data and the request passed to the control and model.Model (Model): is the business process / status of the processing and business rules. Business process layer is the other black-box operation, the model view to accept the request of the data, and return the results of the final. The design of business models can be said to be the most important core of MVC.Currently popular model of EJB applications is a typical example of the application of technology from the perspective of the model further delineation in order to make full use of existing components, but it can not be used as a framework for application design model. It only tell you that according to the design of this model will be able to use certain technology components, thereby reducing the technical difficulties. Example of a developer, you can focus on business model design. MVC design pattern tells us that the application of the model according to certain rules of taking away the level of extraction is very important, which is to determine whether the development in accordance with good design. Abstract and concrete can not be separated too far, nor too close.MVC model did not provide the design method, but only tell you that the management of these models should be organized in order tofacilitate reconstruction and improve the model reusability. We can make an analogy with object programming, MVC defines a top-level category, the sub-class to tell it you have todo these, but you can not do these restrictions. This is the developer of the programming is very important.There is also a business model of the model is very important that the data model. Data model mainly refers to the object data entities (continued of).For example, an order will be saved to the database, to obtainorders from the database. We can separate this model, all the operation of the database is only. Limited to the model.Control (Controller) can be interpreted as a request received from the user, matching the model and view together to complete the user's request. The role of division of control layer is also very clear that it clearly tell you that it is a distributed, and what kind of model to choose, choose what kind of view, to complete what the user requests. Control layer does not do any data processing. For example, the user clicks on a link and control layer to receive arequest, does not deal with business information, only the user's information to the model, to tell what model to choose the view to meet the requirements to return to the user. Therefore, a model may correspond to multiple views, one view may correspond to a number of models. The benefits of MVC Most of the process of language use such as ASP, PHP developed Web applications, the development of the initial template is the mixed layer of the data programming. For example, send the request directly to the database and display HTML, development speed is often faster, but because of the separation of data pages is not very direct, and therefore reflect the business model difficult to look or model reusability. Very flexible product design efforts, it is difficult to meet the changing needs of users. MVC layered on the application of the requirements, although additional work would take, but clearly thestructure of products, product application through the model can be better reflected.First of all, the most important thing is that there should be a number of view corresponds to the ability of a model. In the current rapidly changing user requirements, it may have access to a wide range of applications. For example, orders for the model may be orders of the system as well as online orders, or orders for other systems, but the handling of orders is the same, that is to say the handling of orders is the same. MVC design pattern in accordance with a orders for models and multiple views can solve the problem. This reduced the code to copy,that is, a reduction of the maintenance code, once the model changes, but also easy to maintain.MVC Design ModelSecondly, the data returned as a result of the model without any display format, so these models can also be directly applied to the use of interfaces.Third, as a result of an application to be separated into three, it is sometimes one of them will be able to change to meet changes in the application.An application of business processes or business rules change simply changes the model layer MVC.The concept of control layer is also very effective, because of its different models and different views together to complete variousrequests, the control layer can be said to be included in the concept of a user request for permission.Finally, it is also beneficial to the management of software engineering. Because each different layer, each layer of different applications have some similar characteristics, is conducive to the adoption of engineering and management tools of program code generated.The shortcomings of MVCDesign and implementation of MVC is not very easy, easier to understand, but for developers the requirements are relatively high. MVC is just a basic designidea, but also the need for careful design and planning.Model and the strict separation of view may make debugging more difficult, but easier to find errors.Experience has shown that, MVC as a result of the application is divided into three, means that the number of code files, so the need for document management. Costs point thought.Above, MVC is a very good software to build a basic model, at least the separation of processing and display, forcing the application is divided into model, view and control layer, making you seriously consider the additional complexity of the application of these ideasinto the structure, an increase of application scalability. If we can grasp this, MVC model will make your application stronger, more flexible and more personalized.MVC设计模型MVC是一种目前广泛流行的软件设计模式，早在70年代，IBM就推出了Sanfronscisico项目计划，其实就是MVC设计模式的研究。
外文文献JSP中英文翻译
THE TECHNIQUE DEVELOPMENT HISTORY OF JSPBy:Kathy Sierra and Bert BatesSource：Servlet&JSPThe Java Server Pages( JSP) is a kind of according to web of the script plait distance technique, similar carries the script language of Java in the server of the Netscape company of server- side JavaScript( SSJS）and the Active Server Pages(ASP) of the Microsoft. JSP compares the SSJS and ASP to have better can expand sex，and it is no more exclusive than any factory or some one particular server of Web. Though the norm of JSP is to be draw up by the Sun company of，any factory can carry out the JSP on own system.The After Sun release the JSP（the Java Server Pages) formally，the this kind of new Web application development technique very quickly caused the peopl e’s concern.JSP provided a special development environment for the Web application that establishes the high dynamic state。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Struts——一种开源MVC的实现这篇文章介绍Struts，一个使用servlet和JavaServer Pages技术的一种Model-View-Controller的实现。
Struts可以帮助你控制Web项目中的变化并提高专业化。
即使你可能永远不会用Struts实现一个系统，你可以获得一些想法用于你未来的servlet和JSP网页的实现中。
简介在小学校园里的小孩子们都可以在因特网上发布HTML网页。
然而，有一个重大的不同在一个小学生和一个专业人士开发的网站之间。
网页设计师（或者HTML开发人员）必须理解颜色、用户、生产流程、网页布局、浏览器兼容性、图像创建、JavaScript等等。
设计漂亮的网站需要做大量的工作，大多数Java开发人员更注重创建优美的对象接口，而不是用户界面。
JavaServer Pages(JSP)技术为网页设计人员和Java开发人员提供了一种联系钮带。
如果你开发过大型Web应用程序，你就理解“变化”这个词语。
“模型-视图-控制器”(MVC)就是用来帮助你控制变化的一种设计模式。
MVC减弱了业务逻辑接口和数据接口之间的耦合。
Struts是一种MVC实现，它将Servlet2.2和JSP 1.1标记（属于J2EE规范）用作实现的一部分。
你可能永远不会用Struts实现一个系统，但了解一下Struts或许使你能将其中的一些思想用于你以后的Servlet和JSP实现中。
模型-视图-控制器(MVC)JSP标签只解决了我们问题中的一部分。
我们依然有验证、流控制、以及更新应用程序结构的问题。
这就是MVC从哪儿来以及来干嘛的。
MVC通过把问题分成三类来帮助解决一些与单模块相关的问题：∙Model（模型）模块包括应用程序功能的核心。
模型封装着应用程序的各个结构。
有时它所包含的唯一功能就是结构。
它对于视图或者控制器一无所知。
∙View（视图）视图提供了模型的演示。
它是应用程序的外表。
视图可以进入模型获得者，但是它对于设置者一无所知。
除此之外，它对于控制器也是一无所知。
视图仅仅当模型发生改变的时候才被通知。
∙Controller（控制器）控制器对于用户的输入做出反应。
它创造和设置模型。
MVC模型2Web给软件开发人员带来了一些独特的挑战，最显著的就是客户端和服务器端的无结构连接。
这种无结构连接行为使得模型很难知道视图的改变。
在Web上，浏览器必须重复询问服务器端以此来发现应用程序结构的改变。
另外一个显而易见的改变就是相对于模型或者控制器，视图采用了不同的技术。
当然，我们可以使用Java（或者PERL、C/C++或之前的其他代码）代码来生成HTML。
这种方法存在一些弊端：∙Java程序员应该开发服务，而不是HTML。
∙布局的改变将需要改变代码。
∙服务的客户将有能力去创造一些页面去满足他们的一些特殊需求。
∙页面设计人员将不能直接介入到页面的开发中。
∙嵌入在代码中的HTML将会变得丑陋。
对于Web，MVC的经典形式将需要改变。
图4展示了MVC的Web适应，也就是通常所说的MVC模型2或者MVC2。
.图 4.MVC模型2Struts，MVC2的一种实现Struts是一组相互协作的类、servlet和JSP标记，它们组成一个可重用的MVC2设计。
这个定义表示Struts是一个框架，而不是一个库，但Struts也包含了丰富的标记库和独立于该框架工作的实用程序类。
图5显示了Struts的一个概览。
图 5.Struts概览Struts概览∙客户端浏览器一个来自客户端浏览器的HTTP创建一个事件。
Web容器将会用一个HTTP 响应来作出响应。
∙控制器控制器接收来自浏览器的请求，并决定发送请求到何处。
就Struts而言，控制器就是一个以servlet执行的一个命令设计模式。
struts-config.xml文件配置控制器。
∙业务逻辑业务逻辑更新模型的状态，并帮助控制应用程序的流。
就Struts而言，这就是通过作为实际业务逻辑“瘦”包装的Action类完成的。
∙模型状态模型代表了应用程序的状态。
业务对象更新应用程序的状态。
ActionFormbean在会话级或请求级表示模型的状态，而不是在持久级。
JSP文件使用JSP标记读取来自ActionForm bean的信息。
∙视图视图就是一个JSP文件。
其中没有流程逻辑，没有业务逻辑，也没有模型信息--只有标记。
标记是使Struts有别于其他框架（如Velocity）的因素之一。
Struts详细资料在图6中展示了一个无其他附属设备的阿帕奇struts的action包的UML图表。
图6显示了ActionServlet(Controller)、ActionForm(Form State)和Action(Model Wrapper)之间的最小关系。
图 6.命令(ActionServlet)与模型(Action&ActionForm)之间的关系的UML 图ActionServlet类你还记得使用函数映射的日子吗？你会映射一些输入时间到一个函数的一个指针。
如果你很老练，你可以把这些配置信息放进一个文件里并且在运行时加载该文件。
函数指针装扮了在C语言结构化程序设计中的旧时光。
现在日子好过多了，自从我们有了Java技术、XML、J2EE等等之后。
Struts控制器是一个映射事件（事件通常是一个HTTP post）到类的一个servlet。
猜猜怎么着--控制器用一个配置文件以致于你不必非硬编码这些值。
生活变了，但方法依然如此。
ActionServlet是MVC实现的命令部分并且它是框架的核心。
ActionServlet (Command)创建并使用Action、ActionForm和ActionForward。
正如前面所提及的，struts-config.xml文件配置Command。
在Web工程创建期间，Action和ActionForm被扩展用来解决特殊的问题空间。
文件struts-config.xml指导ActionServlet如何扩展这些类。
这种方法有几个优点：∙网页设计人员不必费力地通过Java代码来理解应用程序的流程。
∙当流程发生改变时Java开发人员不需要重新编译代码。
∙通过扩展ActionServlet命令函数可以被添加进来。
ActionForm类ActionForm维持着Web应用程序的会话状态。
ActionForm是一个必须为每个输入表单模型创建该类的子类的抽象类。
当我说输入表单模型时,我就是说ActionForm代表了一个由HTML表单设置或更新的一般意义上的数据。
例如，你可能有一个由HTML表单设置的UserActionForm。
Struts框架将会：∙检查UserActionForm是否存在；如果不存在，它将会创建该类的一个实例。
∙Struts将使用HttpServletRequest中相应的域设置UserActionForm的状态。
没有太多糟糕的请求.getParameter()调用。
例如，Struts框架将从请求流中提取fname并调用UserActionForm.setFname()。
∙Struts框架在将在传递它到业务包装UserAction之前将更新UserActionForm的状态。
∙在传递它到Action类之前，Struts将还会对UserActionForm调用validation()方法进行表单验证。
备注：这样做通常并不明智。
别的网页或业务对象可能有方法使用UserActionForm，然而验证可能不同。
在UserAction类中进行状态验证可能更好。
∙UserActionForm能够维持一个会话级别。
备注：∙struts-config.xml文件控制着HTML表单请求与ActionForm之间的映射。
∙多重请求会被映射到UserActionForm。
∙UserActionForm可被映射到诸如向导之类的多重页面的东西上。
Action类Action类是一个围绕业务逻辑的一个包装器。
Action类的目的就是将HttpServletRequest翻译给业务逻辑。
要使用Action，需重写process()原理。
ActionServlet(命令)通过使用perform()原理将参数化的类传递给ActionForm。
此外，没有太多讨厌的request.getParameter()调用。
通过事件到达这里的时间，输入表单数据（或HTML表单数据）已经被从请求流中翻译出来并进入ActionForm类中。
注：扩展Action类时请注意简洁。
Action类应该控制应用程序的流程，而不应该控制应用程序的逻辑。
通过将业务逻辑放在单独的包或EJB中，我们就可以提供更大的灵活性和可重用性。
考虑Action类的另一种方式是Adapter设计模式。
Action的用途是“将类的接口转换为客户机所需的另一个接口。
Adapter使类能够协同工作，如果没有Adapter，则这些类会因为不兼容的接口而无法协同工作。
”（摘自Gof所著的Design Patterns-Elements of Reusable OO Software）。
本例中的客户机是ActionServlet，它对我们的具体业务类接口一无所知。
因此，Struts提供了它能够理解的一个业务接口，即Action。
通过扩展Action，我们使得我们的业务接口与Struts业务接口保持兼容。
（一个有趣的发现是，Action是类而不是接口）。
Action 开始为一个接口，后来却变成了一个类。
真是金无足赤。
）Error类UML图（图6）还包括ActionError和ActionErrors。
ActionError封装了单个错误消息。
ActionErrors是ActionError类的容器，View可以使用标记访问这些类。
ActionError是Struts保持错误列表的方式。
图mand(ActionServlet)与Model(Action)之间的关系的UML图ActionMapping类输入事件通常是在HTTP请求表单中发生的，servlet容器将HTTP请求转换为HttpServletRequest。
控制器查看输入事件并将请求分派给某个Action类。
struts-config.xml确定Controller调用哪个Action类。
struts-config.xml配置信息被转换为一组ActionMapping，而后者又被放入ActionMappings容器中。
（你可能尚未注意到这一点，以s结尾的类就是容器）ActionMapping包含有关特定事件如何映射到特定Action的信息。
ActionServlet(Command)通过perform()方法将ActionMapping传递给Action 类。