JSF入门：通过示例理解JavaServer Faces

JavaServer

Faces

需积分: 10 74 浏览量更新于2024-07-19 收藏 4.56MB PDF 举报

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

领优惠券(最高得80元）

JavaServer Faces (JSF) 是一种基于Java的服务器端组件技术，用于构建动态Web应用程序，特别在Java Enterprise Edition (Java EE)环境中广泛应用。本文档通过实例介绍的方式，帮助读者理解JSF的基础概念和核心功能。首先，让我们回顾一下Java Servlets的历史。Servlets由Sun Microsystems于1997年发布，作为早期Java Web开发的核心技术之一。它们允许开发人员创建可重用的服务器端组件，处理HTTP请求并生成动态响应。随着Java EE的发展，Servlet规范经历了多次迭代，尤其是在Java EE 6中的3.0版本，引入了更多功能和优化，使得开发效率得到显著提升。在Servlets的基础上，JavaServer Pages (JSP)作为一种Servlet容器内置的模板技术，允许开发者嵌入Java代码在HTML中，实现了动态内容的生成。然而，JSF的出现提供了一种更为集成和面向组件的开发方式。它将页面展示、数据绑定和事件处理等功能统一在一个框架内，简化了前端开发工作。本书共分为六个章节： 1. **第一章：Servlets简介** - 介绍了Servlet的基本概念，包括其历史发展、作用以及在现代Java EE应用中的地位。这部分会帮助读者理解Servlets是如何构成动态Web应用的基础架构。 2. **第二章：JavaServer Pages** - 虽然这部分可能涉及，但重点会转移到JSF上。不过，它仍然是理解后续章节的背景知识，因为JSP是早期的动态页面技术，与JSF形成对比。 3. **第三章：JavaServer Faces基础知识** - 进一步阐述JSF的核心原理，包括其组件模型、生命周期管理和视图技术，这是学习JSF的基石。 4. **第四章：Facelets** - Facelets是JSF的标记语言，它提供了直观的声明式编程方法，简化了前端开发者的编码过程。本章会深入讲解Facelets的语法和用法。 5. **第五章：JavaServer Faces标准组件** - 介绍预定义的JSF组件库，这些组件可以复用，减少了开发者自定义UI的复杂性，提高了开发效率。 6. **第六章：高级JavaServer Faces和Ajax** - 探讨JSF的进阶主题，包括异步更新（Ajax）技术如何增强用户体验，以及如何利用JSF进行更复杂的交互式Web应用设计。通过阅读这本书，读者不仅能掌握JSF的基础，还能了解如何将其与Ajax等现代技术结合，创建出高效且用户友好的Web应用。无论是初学者还是经验丰富的Java开发者，这本书都是深入了解和实践JSF的宝贵资源。

资源详情

资源推荐

CHAPTER 1 ■ INTRODUCTION TO SERVLETS

Example

Define a field within your servlet to contain the dynamic content that is to be displayed. Post the dynamic content on

the page by appending the field containing it using the PrintWriter println method. The following example servlet

declares a Date field and updates it with the current Date each time the page is loaded:

package org.javaserverfaces.chapter01;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Date;

import javax.servlet.ServletException;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

* Displaying Dynamic Content with a Servlet

* @author juneau

@WebServlet(name = "CurrentDateAndTime", urlPatterns = {"/CurrentDateAndTime"})

public class CurrentDateAndTime extends HttpServlet {

/**

* Processes requests for both HTTP <code>GET</code> and <code>POST</code>

* methods.

* @param request servlet request

* @param response servlet response

* @throws ServletException if a servlet-specific error occurs

* @throws IOException if an I/O error occurs

protected void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType("text/html;charset=UTF-8");

PrintWriter out = response.getWriter();

try {

out.println("<html>");

out.println("<head>");

out.println("<title>Servlet CurrentDateAndTime</title>");

out.println("</head>");

out.println("<body>");

out.println("<h1>Servlet CurrentDateAndTime at " + request.getContextPath() + "</h1>");

out.println("<br/>");

Date currDateAndTime = new Date();

out.println("The current date and time is: " + currDateAndTime);

www.it-ebooks.info

CHAPTER 1 ■ INTRODUCTION TO SERVLETS

out.println("</body>");

out.println("</html>");

} finally {

out.close();

}

/**

* Handles the HTTP <code>GET</code> method.

* @param request servlet request

* @param response servlet response

* @throws ServletException if a servlet-specific error occurs

* @throws IOException if an I/O error occurs

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

processRequest(request, response);

}

/**

* Handles the HTTP <code>POST</code> method.

* @param request servlet request

* @param response servlet response

* @throws ServletException if a servlet-specific error occurs

* @throws IOException if an I/O error occurs

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

processRequest(request, response);

}

The resulting output from this servlet will be the current date and time.

Explanation

One of the reasons why Java servlets are so useful is because they allow dynamic content to be displayed on a web

page. The content can be taken from the server itself, a database, another web site, or many other web-accessible

resources. Servlets are not static web pages; they are dynamic, and that is arguably their biggest strength.

In the solution to this example, a servlet is used to display the current time and date on the server. When the

servlet is processed, the doGet method is called, which subsequently makes a call to the processRequest method,

passing the request and response objects. Therefore, the processRequest method is where the bulk of the work

occurs. The processRequest method creates a PrintWriter by calling the response.getWriter method, and the

PrintWriter is used to display content on the resulting web page. Next, the current date and time are obtained

from the server by creating a new Date and assigning it to the currDateAndTime field. Lastly, the processRequest

method sends the web content through the out.println method, and the contents of the currDateAndTime field

are concatenated to a String and sent to out.println as well. Each time the servlet is processed, it will display the

current date and time at the time in which the servlet is invoked because a new Date is created with each request.

www.it-ebooks.info

CHAPTER 1 ■ INTRODUCTION TO SERVLETS

This example just scratches the surface of what is possible with a Java servlet. Although displaying the current

date and time is trivial, you could alter that logic to display the contents of any field contained within the servlet.

Whether it be an int field that displays a calculation that was performed by the servlet container or a String field

containing some information, the possibilities are endless.

Handling Requests and Responses

Most applications allow forms that accept input, and then produce a response. This is one of the main components of

an HTTP application, and servlets are ideal for handling a request-response lifecycle. It can also be useful to develop

forms in HTML, and have the form submitted to a processing engine, such as a servlet.

Example

To see a request-response example in action, create a standard HTML-based web form, and when the submit

button is clicked, invoke a servlet to process the end-user input and post a response. To examine this technique,

you will see two different pieces of code. The following code is HTML that is used to generate the input form. Pay

particular attention to the <form> and <input> tags. You will see that the form’s action parameter lists a servlet name,

MathServlet.

<html>

<head>

<title>Simple Math Servlet</title>

</head>

<body>

<h1>This is a simple Math Servlet</h1>

<label for="numa">Enter Number A: </label>

<label for="numb">Enter Number B: </label>

</form>

</body>

</html>

Next, take a look at the following code for a servlet named MathServlet. This is the Java code that receives the

input from the HTML code listed earlier, processes it accordingly, and posts a response.

package org.javaserverfaces.chapter01;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Date;

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

www.it-ebooks.info

CHAPTER 1 ■ INTRODUCTION TO SERVLETS

Note ■ To run the example, deploy the JSFByExample application to your application server container, and then

enter the following address into your browser: http://localhost:8080/JSFByExample/chapter01/math.html.

This assumes you are using default port numbers for your application server installation. If using the NetBeans project

that was packaged with the sources, you do not need to worry about copying the code as everything is pre-configured.

Explanation

Servlets make it easy to create web applications that adhere to a request and response life cycle. They have the

ability to provide HTTP responses and also process business logic within the same body of code. The ability to

process business logic makes servlets much more powerful than standard HTML code. The solution to this example

demonstrates a standard servlet structure for processing requests and sending responses. An HTML web form

contains parameters that are sent to a servlet. The servlet then processes those parameters in some fashion and

publishes a response that can be seen by the client. In the case of an HttpServlet object, the client is a web browser,

and the response is a web page.

Values can be obtained from an HTML form by using HTML <input> tags embedded within an HTML <form>.

In the solution to this example, two values are accepted as input, and they are referenced by their id attributes as

numa and numb. There are two more <input> tags within the form; one of them is used to submit the values to the form

action, and the other is used to reset the form fields to blank. The form action is the name of the servlet that the form

values will be passed to as parameters. In this case, the action is set to MathServlet. The <form> tag also accepts a

form-processing method, either GET or POST. In the example, the POST method is used because form data is being sent

to the action; in this case, data is being sent to MathServlet. You could, of course, create an HTML form as detailed

as you would like and then have that data sent to any servlet in the same manner. This example is relatively basic; it

serves to give you an understanding of how the processing is performed.

The <form> action attribute states that the MathServlet should be used to process the values that are contained

within the form. The MathServlet name is mapped back to the MathServlet class via the web.xml deployment

descriptor or the @WebServlet annotation. Looking at the MathServlet code, you can see that a doPost method is

implemented to handle the processing of the POST form values. The doPost method accepts HttpServletRequest

and HttpServletResponse objects as arguments. The values contained with the HTML form are embodied within the

HttpServletRequest object. To obtain those values, call the request object’s getParameter method, passing the id

of the input parameter you want to obtain. In this example, those values are obtained and stored within local String

fields.

String numA = req.getParameter("numa");

String numB = req.getParameter("numb");

Once the values are obtained, they can be processed as needed. In this case, those String values are converted

into int values, and then they are added together to generate a sum and stored into an int field. That field is then

presented as a response on a resulting web page.

int solution = Integer.valueOf(numA) + Integer.valueOf(numB);

As mentioned, the HTML form could be much more complex, containing any number of <input> fields.

Likewise, the servlet could perform more complex processing of those field values. This example is merely the tip

of the iceberg, and the possibilities are without bounds. Servlet-based web frameworks such as Java Server Pages

and Java Server Faces hide many of the complexities of passing form values to a servlet and processing a response.

However, the same basic framework is used behind the scenes.

www.it-ebooks.info

剩余344页未读，继续阅读

cccccccc_

粉丝: 1
资源: 23

JSF入门：通过示例理解JavaServer Faces

将_Adobe_Flex_和_JavaFX_与_JavaServer_Faces_2.0_结合使用.pdf

JavaServer-Faces.rar_JavaServer Faces_java programming

读取fetch_olivetti_faces数据并可视化显示任意两人的10幅图像并按四行五列的形式输出

fetch_olivetti_faces数据包

yaml_string = model.to_json() with open('cat_dog_faces.yaml', 'w') as outfile: outfile.write(yaml_string) model.save_weights('cat_dog_faces.h5')

print("Detected animal faces: ", len(animal_faces)) for (x, y, w, h) in animal_faces: print("Face size: ", w, "x", h)

dataset = fetch_lfw_people(min_faces_per_person=100)中的dataset

cnn_faces_recognition-master

为什么无法打开，是否需要在get_faces_from_camera_tkinter.py中添加一些东西

proj_data = np.dot(diff_faces, eig_vecs) 报错内容为：shapes (400,64,64) and (4096,4096) not aligned: 64 (dim 2) != 4096 (dim 0)

【中科院1区】Matlab实现哈里斯鹰优化算法HHO-SAE实现故障诊断算法研究.rar

最新资源