毕业论文外文翻译JSP应用框架

Aplication frameworks

What arc application frameworks:

A framework is a reusable, semi-complete application that can be specialized to

produce custom applications [Johnson]. Like people, software applications are more alike than they are different. They run on the same computers, expect input from the same devices, output to the same displays, and save data to the same hard disks. Developers working on conventional desktop applications arc accustomed to toolkits and development environments that leverage the sameness between applications. Application frameworks build on this common ground to provide developers with a reusable structure that can serve as the foundation for their own products.

A framework provides developers with a set of backbone components that have the following characteristics:

1 .They arc known to work well in other applications.

  1. They are ready to use with the next project.
  2. They can also be used by other teams in the organization.

Frameworks are the classic build-versus-buy proposition. If you build it, you will understand it when you are done—but how long will it be before you can roll your own? If you buy it, you will have to climb the learning curve—and how long is that going to take? There is no right answer here, but most observers would agree that frameworks such as Struts provide a significant return on investment compared to starting from scratch, especially for larger projects.

Other types of frameworks:

The idea of a framework applies not only to applications but to application componcntsas well. Throughout this article, wc introduce other types of frameworks that you can use with Struts. These include the Lucene search engine, the Scaffold toolkit, the Struts validator, and the Tiles tag library. Like application frameworks, these tools provide semi-complete versions of a subsystem that can be specialized to provide a custom component.

Some frameworks have been linked to a proprietary development environment. This is not the case with Struts or any of the other frameworks shown in this book. You can use any development environment with Struts: Visual Age for Java, JBuilder, Eclipse, Emacs, and Textpad arc all popular choices among Struts developers. If you can use it with Java, you can use it with Struts.

Enabling technologies:

Applications developed with Struts are based on a number of enabling technologies.These components are not specific to Struts and underlie every Java web application. A reason that developers use frameworks like Struts is to hide the nasty details behind acronyms like HTTP, CGI, and JSP. As a Struts developer, you don’t need to be an alphabet soup guru, but a working knowledge of these base technologies can help you devise creative solutions to tricky problems.

Hypertext Transfer Protocol (HTTP):

When mediating talks between nations, diplomats often follow a formal protocol.

Diplomatic protocols arc designed to avoid misunderstandings and to keep negotiations from breaking down. In a similar vein, when computers need to talk, they also follow a formal protocol. The protocol defines how data is transmitted and how to decode it once it arrives. Web applications use the Hypertext Transfer Protocol (HTTP) to move data between the browser running on your computer and the application running on the server.

Many server applications communicate using protocols other than HTTP. Some of these maintain an ongoing connection between the computers. The application server knows exactly who is connected at all times and can tell when a connection is dropped. Because they know the state of each connection and the identity of each person using it, these are known as stateful protocols.

By contrast, HTTP is known as a stateless protocol An HTTP server will accept any request from any client and will always provide some type of response, even if the response is just to say no. Without the overhead of negotiating and retaining a connection, stateless protocols can handle a large volume of requests. This is one reason why the Internet has been able to scale to millions of computers.

Another reason HTTP has become the universal standard is its simplicity. An HTTP request looks like an ordinary text document. This has made it easy for applications to make HTTP requests. You can even send an HTTP request by hand using a standard utility such as Telnet. When the HTTP response comes back, it is also in plain text that developers can read.

The first line in the HTTP request contains the method, followed by the location

of the requested resource and the version of HTTP. Zero or more HTTP request headers follow the initial line. The HTTP headers provide additional information to the server. This can include the browser type and version, acceptable document types, and the browser’s cookies, just to name a few. Of the seven request methods, GET and POST are by far the most popular.

Once the server has received and serviced the request, it will issue an HTTP response. The first line in the response is called the status line and carries the HTTP protocol version, a numeric status, and a brief description of the status. Following the status line, the server will return a set of HTTP response headers that work in a way similar to the request headers.

As wc mentioned, HTTP docs not preserve state information between rcqucsts.Thc server logs the request, sends the response, and goes blissfully on to the next request. While simple and efficient, a stateless protocol is problematic fbr dynamic applications that need to keep track of their users. (Ignorance is not always bliss.

Cookies and URL rewriting are two common ways to keep track of users between requests. A cookie is a special packet of information on the user’s computer. URL rewriting stores a special reference in the page address that a Java server can use to track users. Neither approach is seamless, and using either means extra work when developing a web application. On its own, a standard HTTP web server does not traffic in dynamic content. It mainly uses the request to locate a file and then returns that file in the response. The file is typically formatted using Hypertext Markup Language (HTML) [W3C, HTML] that the web browser can format and display. The HTML page often includes hypertext links to other web pages and may display any number of other goodies, such as images and

Standard web servers handle static content and images quite well but need a helping hand to provide users with a customized, dynamic response.

DEFINITION:Static content on the Web comes directly from text or data files, like HTML or JPEG files. These files might be changed from time to time, but they are not altered automatically when requested by a web browser. Dynamic content, on the other hand, is generated on the fly, typically in response to an individualized request from a browser.

Common Gateway Interface (CGI):

The first widely used standard for producing dynamic content was the Common Gateway Interface (CGI). CGI uses standard operating system features, such as environment variables and standard input and output, to create a bridge, or gateway, between the web server and other applications on the host machine. The other applications can look at the request sent to them by the web server and create a customized response.

When a web server receives a request that’s intended for a CGI program, it runs that program and provides the program with information from the incoming request. The CGI program runs and sends its output back to the server. The web server then relays the response to the browser.

CGI defines a set of conventions regarding what information it will pass as environment variables and how it expects standard input and output to be used. Like HTTP, CGI is flexible and easy to implement, and a great number of CGI-aware programs have been written.

The main drawback to CGI is that it must mn a new copy of the CGI-aware program for each request. This is a relatively expensive process that can bog down high-volume sites where thousands of requests are serviced per minute. Another drawback is that CGI programs tend to be platform dependent. A CGI program written for one operating system may not run on another.

Java servlets:

Sun’s Java Servlet platform directly addresses the two main drawbacks of CGI programs.First, servlets offer better performance and utilization of resources than conventional CGI programs. Second, the write-once, run-anywhere nature of Java means that servlets arc portable between operating systems that have a Java Virtual Machine (JVM).

A servlet looks and feels like a miniature web server. It receives a request and renders a response. But, unlike conventional web servers, the servlet application programming interfoce (API) is specifically designed to help Java developers create dynamic applications.

The servlet itself is simply a Java class that has been compiled into byte code, like any other Java object. The servlet has access to a rich API of HTTP-specific services, but it is still just another Java object running in an application and can leverage all your other Java assets.

To give conventional web servers access to servlets, the servlets are plugged into containers. The servlet container is attached to the web sener. Each servlet can declare what URL patterns it would like to handle. When a request matching a registered pattern arrives, the web server passes the request to the container, and the container invokes the servlet.

But unlike CGI programs, a new servlet is not created for each request. Once the container instantiates the servlet, it will just create a new thread fbr each request. Java threads are much less expensive than the server processes used by CGI progiams. Once the servlet has been created, using it fbr additional requests incurs very little overhead. Servlet developers can use the init() method to hold references to expensive resources, such as database connections or EJB I lome Interfaces, so that they can be shared between requests. Acquiring resources like these can take several seconds—which is longer than many surfers are willing to wait.

The other edge of the sword is that, since servlets arc multithreaded, servlet developers must take special care to be sure their servlets are thread-safe. To learn more about servlet programming, we recommend Java Servlets by Example, by Alan R. Williamson [Williamson]. The definitive source fbr Servlet information is the Java Servlet Specification [Sun, JST].

JavaServer Pages:

While Java servlets are a big step up from CGI programs, they are not a panacea. To generate the response, developers arc still stuck with using printin statements to render the HTML. Code that looks like:

out.println(H<P>One line of HTML.</P>U);

out.println(H<P>Another line of HTML.</P>U);

is all too common in servlets that generate the HTTP response. There are libraries that can help you generate HTML, but as applications grow more complex, Java developers end up being cast into the role of HTML page designers.

Meanwhile, given the choice, most project managers prefer to divide development teams into specialized groups. They like HTML designers to be working on the presentation while Java engineers sweat the business logic. Using servlets alone encourages mixing markup with business logic, making it difficult fbr team members to specialize.

To solve this problem, Sun turned to the idea of using server pages to combine scripting and templating technologies into a single component. To build Java Server Pages, developers start by creating HTML pages in the same old way, using the same old HTML syntax. To bring dynamic content into the page, the developer can also place JSP scripting elements on the page. Scripting elements arc tags that encapsulate logic that is recognized by the JSP. You can easily pick out scripting elements on JSP pages by looking fbr code that begins with <% and ends with %>.

To be seen as a JSP page, the file just needs to be saved with an extension of jsp.

When a client requests the JSP page, the container translates the page into a source code file fbr a Java servlet and compiles the source into a Java class file—just as you would do if you were writing a servlet from scratch. At runtime, the container can also check the last modified date of the JSP file against the class file. If the JSP file has changed since it was last compiled, the container will retranslate and rebuild the page all over again.

Project managers can now assign the presentation layer to HTML developers, who then pass on their work to Java developers to complete the business-logic portion. The important thing to remember is that a JSP page is really just a servlet. Anything you can do with a servlet, you can do with a JSP.

JavaBeans:

JavaBeans are Java classes which conform to a set of design patterns that make them easier to use with development tools and other components.

DEFINITION A JavaBean is a reusable software component written in Java. To qualify as a JavaBean, the class must be concrete and public, and have a noargument constructor. JavaBeans expose internal fields as properties by providing public methods that follow a consistent design pattern. Knowing that the property names follow this pattern, other Java classes are able to use introspection to discover and manipulate JavaBean properties.

The JavaBean design patterns provide access to the bean’s internal state through two flavors of methods: accessors are used to read a JavaBean’s state; mutators are used to change a JavaBean’s stale.

Mutators arc always prefixed with lowercase token set followed by the property name. The first character in the property name must be uppercase. The return value is always void—mutators only change property values; they do not retrieve them. The mutator for a simple property takes only one parameter in its signature, which can be of any type. Mutators are often nicknamed setters after their prefix. The mutator method signature for a weight property of the type Double would be:

public void sctWcight(Doublc weight)

A similar design pattern is used to create the accessor method signature. Accessor methods are always prefixed with the lowercase token get, followed by the property name. The first character in the property name must be uppercase. The return value will match the method parameter in the corresponding mutator. Accessors fbr simple properties cannot accept parameters in their method signature. Not surprisingly, accessors are often called getters.

The accessor method signature for our weight property is:

public Double get Weight。

If the accessor returns a logical value, there is a variant pattern. Instead of using the lowercase token get, a logical property can use the prefix is, followed by the property name. The first character in the property name must be uppercase. The return value will always be a logical value― it her boolean or Boolean. Logical accessors cannot accept parameters in their method signature.

The boolean accessor method signature for an on property would be

public boolean isOn()

The canonical method signatures play an important role when working with Java- Beans. Other components are able to use the Java Reflection API to discover a JavaBean’s properties by looking Ibr methods prefixed by set, is, or get. If a component finds such a signature on a JavaBean, it knows that the method can be used to access or change the bcairs properties.

Sun introduced JavaBeans to work with GUI components, but they are now used with every aspect of Java development, including web applications. When Sun engineers developed the JSP tag extension classes, they designed them to work with JavaBeans. The dynamic data fbr a page can be passed as a JavaBcan, and the JSP tag can then use the bcair s properties to customize the output.

For more on JavaBeans, we highly recommend The Awesome Power of JavaBeans, by Lawrence H. Rodrigues [Rodrigues]. The definitive source fbr JavaBcan information is the JavaBean Specification [Sun, JBS].

Model 2:

The 0.92 release of the Servlet/JSP Specification described Model 2 as an architecture that uses servlets and JSP pages together in the same application. The term Model 2 disappeared from later releases, but it remains in popular use among Java web developers.

Under Model 2, servlets handle the data access and navigational flow, while JSP pages handle the presentation. Model 2 lets Java engineers and HTML developers each work on their own part of the application. A change in one part of a Model 2 application does not mandate a change to another part of the application. HTML developers can often change the look and feel of an application without changing how the back-office servlets work.

The Struts framework is based on the Model 2 architecture. It provides a controller servlet to handle the navigational flow and special classes to help with the data access. A substantial custom tag library is bundled with the framework to make Struts easy to use

 

with JSP pages.

Summary:

In this article, we introduced Struts as an application framework. We examined the technology behind HTTP, the Common Gateway Interface, Java servlets, JSPs, and JavaBeans. We also looked at the Model 2 application architecture to see how it is used to combine servlets and JSPs in the same application.

Now that you have had a taste of what it is like to develop a web application with Struts, in chapter 2 we dig deeper into the theory and practice behind the Struts architecture.

 

JSP应用框架

什么是应用框架:

框架(framework)是可垣用的,半成品的应用程序,可以用来产生专门的定制 程序。象人-样,软件应用的相似性比不同点要多。它们运行在相似的机器上,期 望从相同的设备输入信息,输出到相同的显示设备,并口将数据存储到相同的硬盘 设备。开发传统桌面应用的开发人员更习惯于那些可以涵盖应用开发同一性的工具 包和开发环境。构架在这些公共基础上的应用框架可以为开发人员提供可以为他们 的产品提供可重用服务的基础架构。

椎架向开发人员提供一系列具有以下特征的骨架组件:

  1. 已经知道它们在其它程序上工作得很好;
  2. 它们随时可以在下一个项目中使用;
  3. 它们可以被组织的其它团队使用;

对于框架是典型的构建还是购买命题。如果你自己构建它,在你完成时你就会 理解它,但是在你被融入之前乂将花费多长时间呢?如果要购买,你必须得克服学 习曲线,同样,在你可以用它进行工作之前乂得花多长时间?这里没有所谓正确答 案,但许多观察者都会同意,象Struts这样的框架能提供比从头开始开发更显著的 投资回报,特别是对于大型项目来说。

其它类型的框架:

框架的概念不仅用于应用程序也可用于组件。在其它的资料里面,我们也介绍 了一些可以和Struts 一起使用的框架。这些包括Lucene搜索引擎,Scaffold工具包, Struts验证器,以及Tiles标签库。与应用框架-•样,这些工具也提供了一些半完成 的版本,可以用在用户的定制组件之中。某些框架被限制于专门的开发环境中。Struts 以及本文中涉及的组件却不是这样。你可以在很多环境中来开发Struts: Visual Age for Java, JBuilder, Eclipse, Emacs,甚至使用Textpad。对于你的工具,如果你可以用 来开发Java,你就可以用它来开发Struts.

使用的技术:

使用Struts的应用开发使用了大量的其他基础技术。这些技术并不是专门针对

 

Stnits,而是所TT Java web应用都可以使用的。开发者使用Struts Z类的框架是为 了隐藏在诸如HTTP, CGL以及JSP之类技术后面的繁琐的细节。作为一个Struts 开发者,你并不需要知晓所右的相关知识,但是这些基本技术的工作原理可能仃助 于你针对棘手问题设计出创造性的方案。

超文木传输协议(HTTP):

当两个国家之间进行调解时,外交官们总是遵循一定的正式协议。外交协议主 要设计来避免误解,以及防止谈判破裂。同样,当计算机间需要对话,它们也遵循 一个正式的协议。这个协议定义数据是如何传输,以及它们到这后如何进行解码。 Web应用程序就是使用HTTP协议在运行浏览器的计算机和运行的服务脂的程序间 传输数据。

很多服务器应用程序使用HTTP之外的其他协议。他们在计算机之间维护一个 持久性的连接。应用服务器可以清楚的知道是谁连接上来,而且何时中断连接。因 为它们知道每一个连接的状态,以及每一个使用它的人。这称之为状态协议。

相反,HTTP是一个无状态协议。HTTP Server可以接受来自于各种客户的各 种请求,并提供各种响应,即使是这个响应仅仅是说No。没有大量的协商和连接 持久性,无状态协议可以处理大最的请求。这也是Internet可以扩展到很多计算机 的原因。

HTTP成为通用标准的原因是其简单性。HTTP请求看起来就像一个平常的文 木文档。这使应用程序很容易创建HTTP请求°你甚至可以通过标准的程序如Telnet 来手动传递一个HTTP请求。当HTTP响应返回时,它也是一个开发者可以直接阅 读的平面文本。HTTP请求的第一行包含方法,其后是请求的来源地址和HTTP版 本。HTTP请求头跟在首行后而,可以没有也可以有多个。HTTP头向服务器提供 额外的信息。可以包括浏览器的种类和版本,可接受的文档类型,浏览器的cookies 等等。7种请求方法中,GET和POST是用得最多的。

一旦服务器接收到请求,它就要产生一个HTTP响应。响应的第一行称为状态 行,包含了 HTTP协议的版本,数字型状态,以及状态的简短描述。状态行后,服 务器将返回一个HTTP响应头,类似于HTTP请求头。如上所述,HTTP并不在请 求间保持状态信息。服务器接受请求,发出响应,并且继续愉快地处理文本清求。

因为简单和效率,无状态协议不适合于需要跟踪用户状态的动态应用。Cookies 和URL重写是两个在请求间跟踪用户状态的方式。cookie是一种特殊的信息包, 存储于用户的计算机中。URL重写是在页而地址中存储一个特殊的标记,Java服务 器可以用它来跟踪用户。这两种方法都不是无缝的,是用哪一个都意味着在开发时 都要进行额外的工作。对其本身来说,标准的HTTP web服务器并不传输动态内容。 它主要是使用请求来定位文件资源,并在响应中返回此资源。通常这里的文件使用 Hypertext Mark叩Language (HTML) [W3C,HTML]格式化,以使浏览器可以显示它 们。HTML页面通常包含一些到其他页面的超文本连接,也可以显示其他一些内容 比如图像和视频等等。用户点击连接将产生另一个请求,就开始一个新的处理过程。 标准web服务器处理静态内容处理得很好,但处理动态内容时则需要额外的帝助手 段了。

定义静态内容直接来闩于文本或数据文件,比如HTML或者JPEG文件。这 些文件可以随时改变,但通过浏览器请求时,却不能自动改变。相反,动态内容是 临时产生的,典型地,它是针对浏览器的个别请求的响应。

公共网关接口 (CG1):

第一个普遍用来产生动态内容的标准是通用网美接口( Common Gateway Interface (CGI))。CGI使用标准的操作系统特征,比如环境变量和标准输入输出, Web服务器间以及利主机系统间创建桥接和网关。其他程序可以看到web server 传递过来的请求,并创建一个定制的响应。当web服务器接收到一个对CGI程序的 请求时,它便运行这个程序并向其提供它请求里面所包含的信息。CGI程序运行, 并将输出返回给Web server, web server则将输出响应给浏览器。CGI定义了一套 关于什么信息将作为环境变量传递,以及它希望怎样使用标准输入和输出的惯例。 与HTTP-样,CGI是灵活和易于实现的,并且已经有大量现成的CGI程序。

CGI的主要缺点是它必须为每个请求运行一个程序。这是一个相对昂贵的处理 方法,对大容量站点来说,每分钟有数千个请求,有可能使站点瘫痪。CGI程序的 另一个缺点是平台依赖性,一个平台上开发的程序不一定在另一个平台上能运行。

Java servlet:

Sun公司的Java Servlet平台直接解决了 CGI程序的两个主要缺点:

首先,servlet比常规CGI程序提供更好的性能和资源利用。其次,一次编写, 随处运行的JAVA特性意味若servlet在有JVM的操作系统间是轻便的可移动的。 Servlet看起来好像是一个微小的web servero它接受请求并产生响应。但,和常规 web server不同,servlet API是专|’ J设计来帮助Java开发人员创建动态应用的

Servlet本身是要编译成字节码的Java类,就像其他Java对象-•样。Servlet [)j 问HTTP特定服务的API,但它仍然是一个运行于程序之中的Java对象,并可以 利用所有的Java资产。为了使常规web servers能访问servlet, servlet被安插在— 个容器之中。Servlet容器连接到Web服务器。每servlet都可以声明它可以处理何 种样式的URL。当符合所注册样式的请求到达,web server将请求传递给容器,容 器则调用响应的servleto但和CGI程序不同,并不是针对每个请求都要创建一个新 的servleto 一旦容器实例化了一个servlet,它就仅为何个新的请求创建一个新的线 程。Java线程可比使用CGI程序的服务器处理开销小多了。

一旦servlet被创建,使用它处理额外的请求仅带来很小的额外开销。Servlet 开发人员可以使用init()方法保持对昂贵资源的引用,比如到数据库或者EJB Home 接口的连接,以便它们可以在不同的请求之间进行共享。获得这些资源要耗费数秒时 间,这比大多数冲浪者愿意等的时间要长些。

Servlet的另一个好处是,它是多线程的,servlet开发人员必须特别注意确保它 们的servlet是线程安全的。学习servlet编程,我们推荐Java Servlets by Example,作 者 Alan R. Williamson[Williamson]o

JavaServer Pages:

虽然servlets对CG【程序来说前进了一大步,但它也不是万能灵为。为了产生 响应,开发人员不得不使用大量的printin语句来生成HTML。比如这样的代码:

out.println(H<P>Onc line of HTML </P>M);

out.println(H<P>Another line of HTML.</P>”);

在产生HTTP响应的Servlet中是很普遍的。也有一些库有助于你产生HTML。 随着应用越来越殳杂,Java开发人员将不再扮演HTML页面设计的角色。同时,大 多数项目经理更喜欢将团队分成不同的小组。它们喜欢HTML设计人员处理表现 层的工作,而Java工程师则专注于业务逻辑。单独使用servlet的做法鼓励混合标 记和业务逻辑,很难区分团队人员的专业工作。

为解决这个问题,Sun提出了一个将脚本和模板技术结合到一个组件中的服务 器页面技术(JavaServer Pages)。为创建JSP页面,开发者按创建HTML页面类似 的方式创建页而,使用相同的HTML语法。为将动态内容引入页面,开发人员可 以将脚本元索置入页面之中。脚木元素•是一些标记,封装了可以被JSP识别的逻辑。 你可以在JSP页面中很容易的识别出脚本元素,他们被封装在一对v%和%>标记 中。

为了识别JSP页面,文件需要保存为扩展名.jsp。当一个客户请求JSP页面时, 容器将页面翻译成Java servlet源代码文件,并将它编译成Java类文件——就象你 写的servlet文件-•样。在运行时,容器也能检测JSP文件和相应的类的最后更新时 间。如果,JSP文件自上次编译以来被修改了,容器将重新翻译和编译JSP文件。 项目经理现在可以将表现层分派给HTML开发人员,将业务逻辑工作分派给JAVA 开发人员。重要的是记住,JSP页面事实上是一个servlet。你可以在servlet做的, 也可■以在JSP中做。

JavaBean:

JavaBean是一种Java类,它遵从一定的设计模式,使它们易于和其他开发工 具利组件一起使用。

定义JavaBean是–种JAVA语言写成的可重用组件。要编写JavaBean,类必 须是具体类和公共类,并且具咨无参数的构造器(NON-ARGS CONSTRUCTOR)。 JavaBean通过提供符合一致性设计模式的公共访问方法将内部字段暴谶称为属性。 众所周知,属性名称也符合这种模式,其他JAVA类可以通过自省机制发现和操作 这些JavaBean属性。

我们必须做的如下:

1 .编写一个类,通过实现doStart()或者doEnd()方法来实现 javax.servlet.jsp.tagext.TagSupport 或者 javax.servlet.jsp.tagext.BodyTagSupport 接口。 这些方法获得一个JspWriter对象,你可以用它来输出你需要的HTML内容。

  1. 创建一个标签库描述文件(TLD)来将你的新建的类,映射到一个标签名称。
  2. 在你的Web应用描述符(web.xml)中定义你的<(aglib>元素。通过在JSP页 面的顶部放置下面的语句:<%@tagliburi=7tags/app.tld prefix=”app” %>来告诉 JSP 页面你将使用你自己的标签库。
  3. 这个语句导入将在本页中使用的标签库,并分配给它一个前缀。关于更多 细节,请参考JSP标签库技术页面。

JavaBean设计模式提供两种类型的方式来访问bean的内部状态:访问器 (accessor)用来读JavaBean的状态,修改器(mutator )用来改变JavaBean的状 态。

Mutator通常以小写的set前缀开始,后跟属性名。属性名的第一个字母必须 大写。返回值通常是void,因为mutator仅仅改变属性的值,而不返回它们。简单 属性的mutator在其方法体中W能只有一•个参数,该参数可以是各种类型。Mutator 也可根据其前缀称为设置器setters o例如,对Double类型的属性weight的mutator 方法体可能是:

public void setWeight(Double weight)

相似的设计模式也用于访问器方法的创建。Accessor通常以小写的get为前 缀,后跟属性名。属性名的第一个字母必须大写。返回值必须匹配相应的修改若方 法的参数。简单属性的Accessor在其方法体中不能接受参数。同样,访问器accessor 也经常称为获取器gcttcro

属性weight的访问器方法体可能是:public Double getWeight()

如果访问器返回–个逻辑值,这种情况下有个变体模式。不使用小写的get, 逻辑属性的访问器可以使用小写的is前缀,后跟属性名。属性名的首字母必须大写。 返回值肯定是逻辑值,不管是boolean还是Booleano逻辑访问器在其方法体中不 能接受参数。On属性的逻辑访问器的方法体nJ能是:public boolean isOn()

在使用JavaBean时,规范的方法体签名扮演了极为重要的角色。其他组件可 以使用Java的反射API通过查找前缀为set、is或者get的方法来发现JavaBean的 属性。如果一个组件在一个JavaBean中发现一个这样的方法,它就知道这个方法 nJ以用来访问或者改变JavaBean的属性。Sun引入JavaBean是为了用于GUI组件, 但它们巳经用在Java开发的各个方面,包括Web应用。Sun的工程师在开发JSP 标签的扩展类时,也被设计来可以和JavaBean 一起工作。一个页面的动态数据可以 使用一个JavaBean来传递,并且JSP标记可以随后使用bean的属性来定制页而的 输出。

Model 2:

Servlet/JSP规范的0.92版描述了在一个应用中使用servlet和JSP的架构。在 其后的规范中,Model 2这个叫法消失了,但它已经在Java web开发人员中非常通 用了 o根据Model 2, servlet处理数据存取和导航流,JSP处理表现。Model 2使Java 工程师和HTML设计者分别工作于它们所擅长和负责的部分。Model 2应用的一部 分发生改变并不强求其他部分也跟着发生改变。HTML开发人员可以改变程序的外 观和感觉,并不需要改变后端servlet的工作方式。Struts框架是基于Model 2的架

 

构。它提供一个控制器servlet来处理导航流和一些特殊类来部助数据访问。随柩架 也提供一个丰富的标签库,以使Struts易于和JSP -起使用。

小结:

在本文中,我们介绍了 Struts应用框架。并介绍了一些基本知识,关于HTTP, CGI, Java servlet, JSP,以及JavaBean。我们也说明了 Model 2应用架构,以及它如何 用来将servlets和JSP在结合在同一*个应用之中。现在你已经Tf关于Strtus Web应 用程序模样的初步印象,以后我们将更深入的讨论Strtuts框架的理论和具体实践

我们提供的笔译服务始终如一、质量可靠、值得信赖。为帮助客户了解我们的质量,我们可以接受200字以内免费试译。客户拥有绝对的控制权。

发表评论

您的电子邮箱地址不会被公开。

QQ业务客服
QQ翻译交流群
微信号:benzdeng
您好,有任何疑问请与我们联系!