Servlet、JSP总结(1)

Servlet、JSP总结(1)

一、Servlet

Servlet简介

Java Servlet是和平台无关的服务器端组件，它运行在Servlet容器中。Servlet容器负责Servlet和客户的通信以及调用Servlet的方法，Servlet和客户的通信采用“请求/响应”的模式。
Servlet可完成如下功能：

• 创建并返回基于客户请求的动态HTML页面。
• 创建可嵌入到现有HTML 页面中的部分HTML 页面（HTML 片段）。
• 与其它服务器资源（如数据库或基于Java的应用程序）进行通信。

Servlet容器响应客户请求的工程

ServletAPI

使用 JavaEE 版的 Eclipse 开发动态的 WEB 工程(JavaWEB 项目)

1). 把开发选项切换到 JavaEE
2). 可以在 Window -> Show View 中找到 Package Explorer, 并把其拖拽到开发区的左边
3). 在 Servers 面板中新建 Tomcat 服务器. 一定要关联到 Tomcat 安装的根目录
4). 新建一个 Dynamic Web Project. 其中 Target Runtime 需选择 Tomcat6.0
5). 开发 Java WEB 应用
6). 可以通过 run on server 来运行 WEB 项目.

Servlet容器响应客户请求的过程

①Servlet引擎检查是否已经装载并创建了该Servlet的实例对象。如果是，则直接执行第④步，否则，执行第②步。

②装载并创建该Servlet的一个实例对象：调用该 Servlet 的构造器

③调用Servlet实例对象的init()方法。

④创建一个用于封装请求的ServletRequest对象和一个代表响应消息的ServletResponse对象，然后调用Servlet的service()方法并将请求和响应对象作为参数传递进去。

⑤WEB应用程序被停止或重新启动之前，Servlet引擎将卸载Servlet，并在卸载之前调用Servlet的destroy()方法。

Servlet 的 HelloWorld

1). 创建一个 Servlet 接口的实现类.
public class HelloServlet implements Servlet

2). 在 web.xml 文件中配置和映射这个 Servlet

<!-- 配置和映射 Servlet -->
<servlet>
	<!-- Servlet 注册的名字 -->
	<servlet-name>helloServlet</servlet-name>
	<!-- Servlet 的全类名 -->
	<servlet-class>com.atguigu.javaweb.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
	<!-- 需要和某一个 servlet 节点的 serlvet-name 子节点的文本节点一致 -->
	<servlet-name>helloServlet</servlet-name>
	<!-- 映射具体的访问路径: / 代表当前 WEB 应用的根目录. -->
	<url-pattern>/hello</url-pattern>
</servlet-mapping>

3).Servlet 容器: 运行 Servlet、JSP、Filter 等的软件环境.

1). 可以来创建 Servlet, 并调用 Servlet 的相关生命周期方法.
2). JSP, Filter, Listener, Tag ...

Servlet 生命周期的方法: 以下方法都是由 Serlvet 容器负责调用.

1). 构造器: 只被调用一次. 只有第一次请求 Servlet 时, 创建 Servlet 的实例. 调用构造器. 这说明 Serlvet 的单实例的!
2). init 方法: 只被调用一次. 在创建好实例后立即被调用. 用于初始化当前 Servlet.
3). service: 被多次调用. 每次请求都会调用 service 方法. 实际用于响应请求的.
4). destroy: 只被调用一次. 在当前 Servlet 所在的 WEB 应用被卸载前调用. 用于释放当前 Servlet 所占用的资源.

4).load-on-startup 参数:

1). 配置在 servlet 节点中:

<servlet>
	<!-- Servlet 注册的名字 -->
	<servlet-name>secondServlet</servlet-name>
	<!-- Servlet 的全类名 -->
	<servlet-class>com.atguigu.javaweb.SecondServlet</servlet-class>
	<!-- 可以指定 Servlet 被创建的时机 -->
	<load-on-startup>2</load-on-startup>
</servlet>

2). load-on-startup: 可以指定 Serlvet 被创建的时机. 若为负数, 则在第一次请求时被创建.若为 0 或正数, 则在当前 WEB 应用被Serlvet 容器加载时创建实例, 且数组越小越早被创建.

5).关于 serlvet-mapping：

1). 同一个Servlet可以被映射到多个URL上，即多个 元素的子元素的设置值可以是同一个Servlet的注册名。

2). 在Servlet映射到的URL中也可以使用 * 通配符，但是只能有两种固定的格式：
一种格式是“ .扩展名”，另一种格式是以正斜杠（/）开头并以“/”结尾。

<servlet-mapping>
	<servlet-name>secondServlet</servlet-name>
	<url-pattern>/*</url-pattern>
</servlet-mapping>

OR

<servlet-mapping>
	<servlet-name>secondServlet</servlet-name>
	<url-pattern>*.do</url-pattern>
</servlet-mapping>

注意: 以下的既带 / 又带扩展名的不合法.

<servlet-mapping>
	<servlet-name>secondServlet</servlet-name>
	<url-pattern>/*.action</url-pattern>
</servlet-mapping>

ServletConfig: 封装了 Serlvet 的配置信息, 并且可以获取 ServletContext 对象

Servlet在有些情况下可能需要访问Servlet容器或借助Servlet容器访问外部的资源，所以，Serlvet引擎需要将表示Servlet容器的对象传递给Servlet。另外，在web.xml文件中为某个Servlet设置的友好名称和初始化参数等信息也需要传递给该Servlet

Servlet引擎将代表Servlet容器的对象(ServletContext)和Servlet的配置参数信息一并封装到一个称为ServletConfig的对象中，并在初始化Servlet实例对象时传递给Servlet。ServletConfig接口则用于定义ServletConfig对象需要对外提供的方法，以便在Servlet程序中可以调用这些方法来获取有关信息。

Servlet引擎调用Servlet的实例对象的init(ServletConfig config)方法将ServletConfig对象传递给Servlet。Servlet.getServletConfig()方法必须返回init(ServletConfig config)方法传递进来的这个ServletConfig对象的引用。

1). 配置 Serlvet 的初始化参数

<servlet>
	<servlet-name>helloServlet</servlet-name>
	<servlet-class>com.atguigu.javaweb.HelloServlet</servlet-class>
	
	<!-- 配置 Serlvet 的初始化参数。 且节点必须在 load-on-startup 节点的前面 -->
	<init-param>
		<!-- 参数名 -->
		<param-name>user</param-name>
		<!-- 参数值 -->
		<param-value>root</param-value>
	</init-param>
	
	<init-param>
		<param-name>password</param-name>
		<param-value>1230</param-value>
	</init-param>
	
	<load-on-startup>-1</load-on-startup>
	
</servlet>

2). 获取初始化参数:

> getInitParameter(String name): 获取指定参数名的初始化参数
> getInitParameterNames(): 获取参数名组成的 Enumeration 对象. 

String user = servletConfig.getInitParameter("user");
System.out.println("user： " + user);

Enumeration<String> names = servletConfig.getInitParameterNames();
while(names.hasMoreElements()){
	String name = names.nextElement();
	String value = servletConfig.getInitParameter(name);
	System.out.println("^^" + name + ": " + value);
}

3). 获取 Serlvet 的配置名称(了解)

ServletContext

Servlet引擎为每个WEB应用程序都创建一个对应的ServletContext对象，ServletContext对象被包含在ServletConfig对象中，调用ServletConfig.getServletContext方法可以返回ServletContext对象的引用。

由于一个WEB应用程序中的所有Servlet都共享同一个ServletContext对象，所以，ServletContext对象被称之为 application 对象（Web应用程序对象）

1). 可以由 SerlvetConfig 获取:

ServletContext servletContext = servletConfig.getServletContext();

2). 该对象代表当前 WEB 应用: 可以认为 SerlvetContext 是当前 WEB 应用的一个大管家. 可以从中获取到当前 WEB 应用的各个方面的信息.

①. 获取当前 WEB 应用的初始化参数

设置初始化参数: 可以为所有的 Servlet 所获取, 而 Servlet 的初始化参数只用那个 Serlvet 可以获取.

<!-- 配置当前 WEB 应用的初始化参数 -->
<context-param>
	<param-name>driver</param-name>
	<param-value>com.mysql.jdbc.Driver</param-value>
</context-param>

方法:

getInitParameter
getInitParameterNames

代码:

ServletContext servletContext = servletConfig.getServletContext();
		
String driver = servletContext.getInitParameter("driver");
System.out.println("driver:" + driver);

Enumeration<String> names2 = servletContext.getInitParameterNames();
while(names2.hasMoreElements()){
	String name = names2.nextElement();
	System.out.println("-->" + name); 
}

②. 获取当前 WEB 应用的某一个文件在服务器上的绝对路径, 而不是部署前的路径

getRealPath(String path);

代码:

String realPath = servletContext.getRealPath("/note.txt");
System.out.println(realPath);

③. 获取当前 WEB 应用的名称:

getContextPath()

代码:

String contextPath = servletContext.getContextPath();
System.out.println(contextPath); 

④. 获取当前 WEB 应用的某一个文件对应的输入流.

getResourceAsStream(String path): path 的 / 为当前 WEB 应用的根目录.

代码:

InputStream is2 = servletContext.getResourceAsStream("/WEB-INF/classes/jdbc.properties");

⑤. 和 attribute 相关的几个方法:

HTTP简介

• WEB浏览器与WEB服务器之间的一问一答的交互过程必须遵循一定的规则，这个规则就是HTTP协议。
• HTTP是 hypertext transfer protocol（超文本传输协议）的简写，它是 TCP/IP 协议集中的一个应用层协议，用于定义WEB浏览器与WEB服务器之间交换数据的过程以及数据本身的格式。
• HTTP协议的版本 HTTP/1.0、HTTP/1.1、HTTP-NG

HTTP的会话方式

一个请求行、若干消息头、以及实体内容，其中的一些消息头和实体内容都是可选的，消息头和实体内容之间要用空行隔开

一个状态行、若干消息头、以及实体内容其中的一些消息头和实体内容都是可选的，消息头和实体内容之间要用空行隔开。

GET 请求和 POST 请求:

1). 使用GET方式传递参数:

①. 在浏览器地址栏中输入某个URL地址或单击网页上的一个超链接时，浏览器发出的HTTP请求消息的请求方式为GET。
②. 如果网页中的

表单元素的 method 属性被设置为了“GET”，浏览器提交这个FORM表单时生成的HTTP请求消息的请求方式也为GET。
③. 使用GET请求方式给WEB服务器传递参数的格式：

http://www.atguigu.com/counter.jsp?name=lc&password=123

④. 使用GET方式传送的数据量一般限制在 1KB 以下。

2). 使用 POST 方式传递参数:

①. POST 请求方式主要用于向 WEB 服务器端程序提交 FORM 表单中的数据: form 表单的 method 置为 POST
②. POST 方式将各个表单字段元素及其数据作为 HTTP 消息的实体内容发送给 WEB 服务器，传送的数据量要比使用GET方式传送的数据量大得多。

如何在 Serlvet 中获取请求信息:

1). Servlet 的 service() 方法用于应答请求: 因为每次请求都会调用 service() 方法

public void service(ServletRequest request, ServletResponse response)
			throws ServletException, IOException

​
ServletRequest: 封装了请求信息. 可以从中获取到任何的请求信息.
ServletResponse: 封装了响应信息, 如果想给用户什么响应, 具体可以使用该接口的方法实现.

这两个接口的实现类都是服务器给予实现的, 并在服务器调用 service 方法时传入.

2). ServletRequest: 封装了请求信息. 可以从中获取到任何的请求信息.

①. 获取请求参数:

String getParameter(String name): 根据请求参数的名字, 返回参数值. 
若请求参数有多个值(例如 checkbox), 该方法只能获取到第一个提交的值. 

String[] getParameterValues(String name): 根据请求参数的名字, 返回请求参数对应的字符串数组. 

Enumeration getParameterNames(): 返回参数名对应的 Enumeration 对象, 
类似于 ServletConfig(或 ServletContext) 的 getInitParameterNames() 方法. 

Map getParameterMap(): 返回请求参数的键值对: key: 参数名,  value: 参数值, String 数组类型. 

②. 获取请求的 URI:

HttpServletRequest httpServletRequest = (HttpServletRequest) request;
	
String requestURI = httpServletRequest.getRequestURI();
System.out.println(requestURI); //  /day_29/loginServlet

③. 获取请求方式:

String method = httpServletRequest.getMethod();
System.out.println(method); //GET

④. 若是一个 GET 请求, 获取请求参数对应的那个字符串, 即 ? 后的那个字符串.

String queryString = httpServletRequest.getQueryString();
System.out.println(queryString); //user=atguigu&password=123456&interesting=game&interesting=party&interesting=shopping

⑤. 获取请求的 Serlvet 的映射路径

String servletPath = httpServletRequest.getServletPath();
System.out.println(servletPath);  //  /loginServlet

⑥. 和 attribute 相关的几个方法:

3). HttpServletRequest: 是 SerlvetRequest 的子接口. 针对于 HTTP 请求所定义. 里边包含了大量获取 HTTP 请求相关的方法.

4). ServletResponse: 封装了响应信息, 如果想给用户什么响应, 具体可以使用该接口的方法实现.

①. getWriter(): 返回 PrintWriter 对象. 调用该对象的 print() 方法, 将把 print() 中的参数直接打印
到客户的浏览器上.

②. 设置响应的内容类型: response.setContentType("application/msword");

③. void sendRedirect(String location): 请求的重定向. (此方法为 HttpServletResponse 中定义.)

GenericServlet:

1). 是一个 Serlvet. 是 Servlet 接口和 ServletConfig 接口的实现类. 但是一个抽象类. 其中的 service 方法为抽象方法

2). 如果新建的 Servlet 程序直接继承 GenericSerlvet 会使开发更简洁.

3). 具体实现:

①. 在 GenericServlet 中声明了一个 SerlvetConfig 类型的成员变量, 在 init(ServletConfig) 方法中对其进行了初始化
②. 利用 servletConfig 成员变量的方法实现了 ServletConfig 接口的方法
③. 还定义了一个 init() 方法, 在 init(SerlvetConfig) 方法中对其进行调用, 子类可以直接覆盖 init() 在其中实现对 Servlet 的初始化.
④. 不建议直接覆盖 init(ServletConfig), 因为如果忘记编写 super.init(config); 而还是用了 SerlvetConfig 接口的方法,
则会出现空指针异常.
⑤. 新建的 init(){} 并非 Serlvet 的生命周期方法. 而 init(ServletConfig) 是生命周期相关的方法.

    public abstract class GenericServlet implements Servlet, ServletConfig {
    /** 以下方法为 Servlet 接口的方法 **/
    @Override
    public void destroy() {}

    @Override
    public ServletConfig getServletConfig() {
        return servletConfig;
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    private ServletConfig servletConfig;

    @Override
    public void init(ServletConfig arg0) throws ServletException {
        this.servletConfig = arg0;
        init();
    }

    public void init() throws ServletException{}

    @Override
    public abstract void service(ServletRequest arg0, ServletResponse arg1)
            throws ServletException, IOException;

    /** 以下方法为 ServletConfig 接口的方法 **/
    @Override
    public String getInitParameter(String arg0) {
        return servletConfig.getInitParameter(arg0);
    }

    @Override
    public Enumeration getInitParameterNames() {
        return servletConfig.getInitParameterNames();
    }

    @Override
    public ServletContext getServletContext() {
        return servletConfig.getServletContext();
    }

    @Override
    public String getServletName() {
        return servletConfig.getServletName();
	}
}

HttpServlet:

1). 是一个 Servlet, 继承自 GenericServlet. 针对于 HTTP 协议所定制.

2). 在 service() 方法中直接把 ServletReuqest 和 ServletResponse 转为 HttpServletRequest 和 HttpServletResponse.
并调用了重载的 service(HttpServletRequest, HttpServletResponse)

在 service(HttpServletRequest, HttpServletResponse) 获取了请求方式: request.getMethod(). 根据请求方式有创建了
doXxx() 方法(xxx 为具体的请求方式, 比如 doGet, doPost)

@Override
 public void service(ServletRequest req, ServletResponse res)
    throws ServletException, IOException {
    HttpServletRequest  request;
    HttpServletResponse response;

    try {
        request = (HttpServletRequest) req;
        response = (HttpServletResponse) res;
    } catch (ClassCastException e) {
        throw new ServletException("non-HTTP request or response");
    }
    service(request, response);
}

public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {
	//1. 获取请求方式.
	String method = request.getMethod();
    //2. 根据请求方式再调用对应的处理方法
    if("GET".equalsIgnoreCase(method)){
        doGet(request, response);
    }else if("POST".equalsIgnoreCase(method)){
        doPost(request, response);
    }
}

public void doPost(HttpServletRequest request, HttpServletResponse response) 
		throws ServletException, IOException{
	// TODO Auto-generated method stub
	
}

public void doGet(HttpServletRequest request, HttpServletResponse response) 
		throws ServletException, IOException {
	// TODO Auto-generated method stub
	
}

3). 实际开发中, 直接继承 HttpServlet, 并根据请求方式复写 doXxx() 方法即可.

4). 好处: 直接由针对性的覆盖 doXxx() 方法; 直接使用 HttpServletRequest 和 HttpServletResponse, 不再需要强转.

二、JSP

建立对JSP的直观认识

• JSP页面是由HTML语句和嵌套在其中的Java代码组成的一个普通文本文件，JSP 页面的文件扩展名必须为.jsp。
  在JSP页面中编写的Java代码需要嵌套在<%和%>中，嵌套在<%和%>之间的Java代码被称之为脚本片段（Scriptlets），没有嵌套在<%和%>之间的内容被称之为JSP的模版元素。
• JSP中的Java代码可以使用out.println语句将其他Java程序代码产生的结果字符串输出给客户端，也可以使用System.out.println语句将它们打印到命令行窗口。
• JSP文件就像普通的HTML文件一样，它们可以放置在WEB应用程序中的除了WEB-INF及其子目录外的其他任何目录中，JSP页面的访问路径与普通HTML页面的访问路径形式也完全一样。
• 在JSP页面中也可以使用一种称之为JSP表达式的元素，只需将要输出的变量或表达式直接封装在<%= 和 %>之中，就可以向客户端输出这个变量或表达式的运算结果。在JSP表达式中嵌套的变量或表达式后面不能有分号。

WHY

JSP 是简 Servlet 编写的一种技术, 它将 Java 代码和 HTML 语句混合在同一个文件中编写,
只对网页中的要动态产生的内容采用 Java 代码来编写，而对固定不变的静态内容采用普通静态 HTML 页面的方式编写。

Java Server Page: Java 服务器端网页. 在 HTML 页面中编写 Java 代码的页面.

JSP 可以放置在 WEB 应用程序中的除了 WEB-INF 及其子目录外的其他任何目录中,
JSP 页面的访问路径与普通 HTML 页面的访问路径形式也完全一样

helloword

新建一个 JSP 页面, 在 body 节点内的 <% %> 即可编写 Java 代码.

<body>
	<% 
		Date date = new Date();
		System.out.print(date); 
	%>
</body>

JSP运行原理

SP 本质上是一个 Servlet.

每个JSP 页面在第一次被访问时, JSP 引擎将它翻译成一个 Servlet 源程序, 接着再把这个 Servlet 源程序编译成 Servlet 的 class 类文件.
然后再由WEB容器（Servlet引擎）像调用普通Servlet程序一样的方式来装载和解释执行这个由JSP页面翻译成的Servlet程序。

JSP隐含对象

没有声明就可以使用的对象. JSP页面一共有 9 个隐含对象.

public void _jspService(HttpServletRequest request, HttpServletResponse response)
        throws java.io.IOException, ServletException {

    PageContext pageContext = null;
    HttpSession session = null;
    ServletContext application = null;
    ServletConfig config = null;
    JspWriter out = null;
    Object page = this;

	//...
	
	//使用  <% %> 编写的代码在此位置. 可以用到 request, response, pageContext, session
	//application, config, out, page 这 8 个隐含对象. (实际上还可以使用一个叫 exception 的隐含对象)
    
}

①. request: HttpServletRequest 的一个对象. *
②. response: HttpServletResponse 的一个对象(在 JSP 页面中几乎不会调用 response 的任何方法.)

③. pageContext: 页面的上下文, 是 PageContext 的一个对象. 可以从该对象中获取到其他 8 个隐含对象. 也可以从中获取到当前
页面的其他信息. (学习自定义标签时使用它) *
④. session: 代表浏览器和服务器的一次会话, 是 HttpSession 的一个对象. 后面详细学习. *

⑤. application: 代表当前 WEB 应用. 是 ServletContext 对象. *
⑥. config: 当前 JSP 对应的 Servlet 的 ServletConfig 对象(几乎不使用). 若需要访问当前 JSP 配置的初始化参数,
需要通过映射的地址才可以.

映射 JSP:

  <servlet>
  	<servlet-name>hellojsp</servlet-name>
  	<jsp-file>/hello.jsp</jsp-file>
  	<init-param>
  		<param-name>test</param-name>
  		<param-value>testValue</param-value>
  	</init-param>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>hellojsp</servlet-name>
	<url-pattern>/hellojsp</url-pattern>  	
  </servlet-mapping>
  

⑦. out: JspWriter 对象. 调用 out.println() 可以直接把字符串打印到浏览器上. *
⑧. page: 指向当前 JSP 对应的 Servlet 对象的引用, 但为 Object 类型, 只能调用 Object 类的方法(几乎不使用)

⑨. exception: 在声明了 page 指令的 isErrorPage="true" 时, 才可以使用. *

JSP语法

1）脚本程序<% %> ,JSP脚本片断（scriptlet）是指嵌套在<% 和 %>之中的一条或多条Java程序代码。 多个脚本片断中的代码可以相互访问,单个脚本片断中的Java语句可以是不完整的，但是，多个脚本片断组合后的结果必须是完整的Java语句

<% 
	Date date = new Date();
	out.print(date);
%>

2). JSP表达式：供了将一个 java 变量或表达式的计算结果输出到客户端的简化方式，
它将要输出的变量或表达式直接封装在<%= 和 %>之中。

<% 
	Date date = new Date();
	out.print(date);
%>

<%= date %>

3).模板元素：jsp中html元素

4).JSP 声明: JSP 声明将 Java 代码封装在<%！和 %>之中，它里面的代码将被插入进 Servle t的 _jspService 方法的外面(在 JSP 页面中几乎从不这样使用)

区别: JSP 注释可以阻止 Java 代码的执行.

和属性相关的方法:

1). 方法

• void setAttribute(String name, Object o): 设置属性
• Object getAttribute(String name): 获取指定的属性
• Enumeration getAttributeNames(): 获取所有的属性的名字组成的 Enumeration 对象
• removeAttribute(String name): 移除指定的属性

2). pageContext, request, session, application 对象都有这些方法!
这四个对象也称之为域对象.

• pageContext: 属性的作用范围仅限于当前 JSP 页面
• request: 属性的作用范围仅限于同一个请求.
• session: 属性的作用范围限于一次会话: 浏览器打开直到关闭称之为一次会话(在此期间会话不失效)
• application: 属性的作用范围限于当前 WEB 应用. 是范围最大的属性作用范围, 只要在一处设置属性, 在其他各处的 JSP 或 Servlet 中都可以获取到.

请求的转发与重定向

本质区别: 请求的转发只发出了一次请求, 而重定向则发出了两次请求.

具体:

①. 请求的转发: 地址栏是初次发出请求的地址.
请求的重定向: 地址栏不再是初次发出的请求地址. 地址栏为最后响应的那个地址

②. 请求转发: 在最终的 Servlet 中, request 对象和中转的那个 request 是同一个对象.
请求的重定向: 在最终的 Servlet 中, request 对象和中转的那个 request 不是同一个对象.

③. 请求的转发: 只能转发给当前 WEB 应用的的资源
请求的重定向: 可以重定向到任何资源.

④. 请求的转发: / 代表的是当前 WEB 应用的根目录
请求的重定向: / 代表的是当前 WEB 站点的根目录.

1).RequestDispatcher接口

RequestDispatcher实例对象是由Servlet引擎创建的，它用于包装一个要被其他资源调用的资源（例如，Servlet、HTML文件、JSP文件等），并可以通过其中的方法将客户端的请求转发给所包装的资源。

•RequestDispatcher接口中定义了两个方法：forward方法和include方法。

•forward和include方法接收的两个参数必须是传递给当前Servlet的service方法的那两个ServletRequest和ServletResponse对象，或者是对它们进行了包装的ServletRequestWrapper 或ServletResponseWrapper对象。

•获取RequestDispatcher对象的方法：

ServletContext.getRequestDispatcher （参数只能是以“/”开头的路径）

ServletContext.getNamedDispatcher

ServletRequest.getRequestDispatcher（参数可以是不以“/”开头的路径）

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ForwardServlet extends HttpServlet {
	
	private static final long serialVersionUID = 1L;

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("ForwardServlet's doGet");
		
		request.setAttribute("name", "abcde");
		System.out.println("ForwardServlet's name: " + request.getAttribute("name"));
		
		//请求的转发.
		//1. 调用 HttpServletRequest 的 getRequestDispatcher() 方法获取  RequestDispatcher 对象
		//调用 getRequestDispatcher() 需要传入要转发的地址
		String path = "testServlet";
		RequestDispatcher requestDispatcher = request.getRequestDispatcher("/" + path);
		
		//2. 调用 HttpServletRequest 的 forward(request, response) 进行请求的转发. 
		requestDispatcher.forward(request, response); 
	}

}

2).用sendRedirect方法实现请求重定向

sendRedirect 方法不仅可以重定向到当前应用程序中的其他资源，它还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。

​ 如果传递给sendRedirect 方法的相对URL以“/”开头，则是相对于整个WEB站点的根目录，而不是相对于当前WEB应用程序的根目录。

package com.atguigu.javaweb;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RedirectServlet extends HttpServlet {
	
	private static final long serialVersionUID = 1L;

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("RedirectServlet's doGet");
		
		request.setAttribute("name", "xyzmn");
		System.out.println("RedirectServlet's name: " + request.getAttribute("name"));
		
		
		//执行请求的重定向, 直接调用 response.sendRedirect(path) 方法,
		//path 为要重定向的地址
		String path = "testServlet";
		response.sendRedirect(path);
	}

}

3).请求重定向与请求转发的比较

• RequestDispatcher.forward方法只能将请求转发给同一个WEB应用中的组件；而HttpServletResponse.sendRedirect 方法还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。
• 如果传递给HttpServletResponse.sendRedirect 方法的相对URL以“/”开头，它是相对于整个WEB站点的根目录；如果创建RequestDispatcher对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。
• 调用HttpServletResponse.sendRedirect方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；调用RequestDispatcher.forward 方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。
• HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的访问请求；RequestDispatcher.forward方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。
• RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；而HttpServletResponse.sendRedirect方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。

JSP指令

JSP指令（directive）是为JSP引擎而设计的,
它们并不直接产生任何可见输出, 而只是告诉引擎如何处理JSP页面中的其余部分。

在目前的JSP 2.0中，定义了page、include 和 taglib这三种指令

1）page指令： page指令用于定义JSP页面的各种属性, 无论page指令出现在JSP页面中的什么地方, 它作用的都是整个JSP页面, 为了保持程序的可读性和遵循良好的编程习惯, page指令最好是放在整个JSP页面的起始位置。

Page指令的常用属性：

①. import 属性: 指定当前 JSP 页面对应的 Servlet 需要导入的类.
<%@page import="java.text.DateFormat"%>

②. session 属性: 取值为 true 或 false, 指定当前页面的 session 隐藏变量是否可用, 也可以说访问当前页面时是否一定要生成 HttpSession
对象.
<%@ page session="false" %>

③. errorPage 和 isErrorPage:

• errorPage 指定若当前页面出现错误的实际响应页面时什么. 其中 / 表示的是当前 WEB 应用的根目录.
  <%@ page errorPage="/error.jsp" %>
• 在响应 error.jsp 时, JSP 引擎使用的请求转发的方式.
• isErrorPage 指定当前页面是否为错误处理页面, 可以说明当前页面是否可以使用 exception 隐藏变量. 需要注意的是: 若指定 isErrorPage="true", 并使用 exception 的方法了, 一般不建议能够直接访问该页面.
• 如何使客户不能直接访问某一个页面呢 ? 对于 Tomcat 服务器而言, WEB-INF 下的文件是不能通过在浏览器中直接输入地址的方式来访问的. 但通过请求的转发是可以的!
• 还可以在 web.xml 文件中配置错误页面:

<error-page>
    <!-- 指定出错的代码: 404 没有指定的资源, 500 内部错误. --
    <error-code>404</error-code>
    <!-- 指定响应页面的位置 -->
    <location>/WEB-INF/error.jsp</location>
</error-page>

<error-page>
    <!-- 指定异常的类型 -->
    <exception-type>java.lang.ArithmeticException</exception-type>
    <location>/WEB-INF/error.jsp</location>
</error-page>

④. contentType: 指定当前 JSP 页面的响应类型. 实际调用的是 response.setContentType("text/html; charset=UTF-8");
通常情况下, 对于 JSP 页面而言其取值均为 text/html; charset=UTF-8. charset 指定返回的页面的字符编码是什么. 通常取值为 UTF-8

⑤. pageEncoding: 指定当前 JSP 页面的字符编码. 通常情况下该值和 contentType 中的 charset 一致.

⑥. isELIgnored: 指定当前 JSP 页面是否可以使用 EL 表达式. 通常取值为 false.

2).include指令<%@ include file="b.jsp" %>

1). include 指令用于通知 JSP 引擎在翻译当前 JSP 页面时将其他文件中的内容合并进当前 JSP 页面转换成的 Servlet 源文件中,
这种在源文件级别进行引入的方式称之为静态引入, 当前JSP页面与静态引入的页面紧密结合为一个Servlet。

2). file属性的设置值必须使用相对路径

3). 如果以 / 开头，表示相对于当前WEB应用程序的根目录（注意不是站点根目录），否则，表示相对于当前文件。

细节：

• 除了指令元素之外，被引入的文件中的其他元素都被转换成相应的Java源代码，然后插入进当前JSP页面所翻译成的Servlet源文件中，插入位置与include指令在当前JSP页面中的位置保持一致。
• 引入文件与被引入文件是在被JSP引擎翻译成Servlet的过程中进行合并，而不是先合并源文件后再对合并的结果进行翻译。当前JSP页面的源文件与被引入文件的源文件可以采用不同的字符集编码，即使在一个页面中使用page指令的pageEncoding或contentType属性指定了其源文件的字符集编码，在另外一个页面中还需要用page指令的pageEncoding或contentType属性指定其源文件所使用的字符集 。
• Tomcat 5.x在访问JSP页面时，可以检测它所引入的其他文件是否发生了修改，如果发生了修改，则重新编译当前JSP页面
• file属性的设置值必须使用相对路径，如果以“/”开头，表示相对于当前WEB应用程序的根目录（注意不是站点根目录），否则，表示相对于当前文件。

JSP标签（JSP行为）

JSP还提供了一种称之为Action的元素，在JSP页面中使用Action元素可以完成各种通用的JSP页面功能，也可以实现一些处理复杂业务逻辑的专用功能。

Action元素采用XML元素的语法格式，即每个Action元素在JSP页面中都以XML标签的形式出现。

JSP规范中定义了一些标准的Action元素，这些元素的标签名都以jsp作为前缀，并且全部采用小写，例如，jsp:include、jsp:forward等等

1).<jsp:include >标签

jsp:include标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。

page属性用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。

flush属性指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端。

2).<jsp:include >标签与include指令的比较

• <jsp:include >标签是在当前JSP页面的执行期间插入被引入资源的输出内容，当前JSP页面与被动态引入的资源是两个彼此独立的执行实体，被动态引入的资源必须是一个能独立被WEB容器调用和执行的资源。include指令只能引入遵循JSP格式的文件，被引入文件与当前JSP文件共同合被翻译成一个Servlet的源文件。
• 使用<jsp:include >标签和include指令都可以把一个页面的内容分成多个组件来生成，开发者不必再把页眉和页脚部分的相同HTML代码复制到每个JSP文件中，从而可以更轻松地完成维护工作，但是都应注意最终的输出结果内容应遵循HTML语法结构，例如，如果当前页面产生了、、、等标记，那么在被引入文件中就不能再输出、、、等标记。
• <jsp:include >标签对JSP引擎翻译JSP页面的过程不起作用，它是在JSP页面的执行期间才被调用，因此不会影响两个页面的编译。由于include指令是在JSP引擎翻译JSP页面的过程中被解释处理的，所以它对JSP引擎翻译JSP页面的过程起作用，如果多个JSP页面中都要用到一些相同的声明，那么就可以把这些声明语句放在一个单独的文件中编写，然后在每个JSP页面中使用include指令将那个文件包含进来。
• <jsp:include >标签使用page属性指定被引入资源的相对路径，而include指令使用file属性指定被引入资源的相对路径

3).<jsp:forward >标签

<jsp:forward >标签用于把请求转发给另外一个资源。
语法：
<jsp:forward page="relativeURL | <%=expression%>" />

page属性用于指定请求转发到的资源的相对路径，它也可以通过执行一个表达式来获得

RequestDispatcher.forward方法、PageContext.forward方法、jsp:forward标

签的区别

调用RequestDispatcher.forward方法的JSP脚本代码的前后不能有JSP模版内容。

调用PageContext.forward方法的JSP脚本代码的后面不能有JSP模版内容。

<Jsp:forward >标签的前后都能有JSP模版内容。

4).<jsp:param >标签

当使用jsp:include和jsp:forward标签引入或将请求转发给的资源是一个能动态执行的程序时，例如Servlet和JSP页面，那么，还可以使用jsp:param标签向这个程序传递参数信息。
语法1：

<jsp:include page="relativeURL | <%=expression%>">
	<jsp:param name="parameterName" value="parameterValue|<%=expression %>" />
</jsp:include >

语法2：

<jsp:forward page="relativeURL | <%=expression%>">
	<jsp:param name="parameterName" value="parameterValue|<%=expression %>" />
</jsp:include>

<jsp:param > 标签的name属性用于指定参数名，value属性用于指定参数值。在<jsp:include >和<jsp:forward >标签中可以使用多个<jsp:param >标签来传递多个参数。

关于中文乱码

1). 在 JSP 页面上输入中文, 请求页面后不出现乱码: 保证

 contentType="text/html; charset=UTF-8", pageEncoding="UTF-8" 

charset 和 pageEncoding 的编码一致, 且都支持中文. 通常建议取值为UTF-8还需保证浏览器的显示的字符编码也和请求的 JSP 页面的编码一致.

2). 获取中文参数值: 默认参数在传输过程中使用的编码为 ISO-8859-1

①. 对于 POST 请求: 只要在获取请求信息之前(在调用 request.getParameter 或者是 request.getReader 等), 调用 request.setCharacterEncoding("UTF-8") 即可.

②. 对于 GET 请求: 前面的方式对于 GET 无效. 可以通过修改 Tomcat 的 server.xml 文件的方式.

参照 http://localhost:8989/docs/config/index.html 文档的 useBodyEncodingForURI 属性.
为 Connector 节点添加 useBodyEncodingForURI="true" 属性即可.

<Connector connectionTimeout="20000" port="8989" protocol="HTTP/1.1" redirectPort="8443" useBodyEncodingForURI="true"/>

三、MVC设计模式

JavaEE开发中常用的组件

• commons-beansutils
• commons-dbcp
• commons-dbutils
• commons-fileupload
• commons-logging
• hibernate-refease
• jbpm

MVC的概念

MVC是Model-View-Controller的简称，即模型-视图-控制器。MVC是一种设计模式，它把应用程序分成三个核心模块：模型、视图、控制器，它们各自处理自己的任务。

1).模型（model）

模型是应用程序的主体部分，模型表示业务数据和业务逻辑。

一个模型能为多个视图提供数据。

由于应用于模型的代码只需写一次就可以被多个视图重用，所以提高了代码的可重用性。

2).视图(view)

•视图是用户看到并与之交互的界面，作用如下：

• 视图向用户显示相关的数据。
• 接受用户的输入。
• 不进行任何实际的业务处理。

2).控制器（controler）

•控制器接受用户的输入并调用模型和视图去完成用户的需求。

•控制器接收请求并决定调用哪个模型组件去处理请求，然后决定调用哪个视图来显示模型处理返回的数据。

四、会话与状态管理

• HTTP协议是一种无状态的协议，WEB服务器本身不能识别出哪些请求是同一个浏览器发出的 ，浏览器的每一次请求都是完全孤立的
• 即使 HTTP1.1 支持持续连接，但当用户有一段时间没有提交请求，连接也会关闭。
• 怎么才能实现网上商店中的购物车呢：某个用户从网站的登录页面登入后，再进入购物页面购物时，负责处理购物请求的服务器程序必须知道处理上一次请求的程序所得到的用户信息。
• 作为 web 服务器，必须能够采用一种机制来唯一地标识一个用户，同时记录该用户的状态

如何实现有状态的会话

WEB服务器端程序要能从大量的请求消息中区分出哪些请求消息属于同一个会话，即能识别出来自同一个浏览器的访问请求，这需要浏览器对其发出的每个请求消息都进行标识：属于同一个会话中的请求消息都附带同样的标识号，而属于不同会话的请求消息总是附带不同的标识号，这个标识号就称之为会话ID（SessionID）。

在 Servlet 规范中，常用以下两种机制完成会话跟踪

• Cookie
• Session

Cookie机制

• cookie机制采用的是在客户端保持 HTTP 状态信息的方案
• Cookie是在浏览器访问WEB服务器的某个资源时，由WEB服务器在HTTP响应消息头中附带传送给浏览器的一个小文本文件。
• 一旦WEB浏览器保存了某个Cookie，那么它在以后每次访问该WEB服务器时，都会在HTTP请求头中将这个Cookie回传给WEB服务器。
• 底层的实现原理： WEB服务器通过在HTTP响应消息中增加Set-Cookie响应头字段将Cookie信息发送给浏览器，浏览器则通过在HTTP请求消息中增加Cookie请求头字段将Cookie回传给WEB服务器。
• 一个Cookie只能标识一种信息，它至少含有一个标识该信息的名称（NAME）和设置值（VALUE）。
• 一个WEB站点可以给一个WEB浏览器发送多个Cookie，一个WEB浏览器也可以存储多个WEB站点提供的Cookie。
• 浏览器一般只允许存放300个Cookie，每个站点最多存放20个Cookie，每个Cookie的大小限制为4KB。