首页 > 代码库 > java web -- gacl 汇总

java web -- gacl 汇总

2024-08-24 10:48:55 225人阅读

(五)——Servlet开发(一)
一、Servlet简介
Servlet是sun公司提供的一门用于开发动态web资源的技术。
Sun公司在其API中提供了一个servlet接口，用户若想用发一个动态web资源(即开发一个Java程序向浏览器输出数据)，需要完成以下2个步骤：
1、编写一个Java类，实现servlet接口。
2、把开发好的Java类部署到web服务器中。
按照一种约定俗成的称呼习惯，通常我们也把实现了servlet接口的java程序，称之为Servlet
二、Servlet的运行过程
Servlet程序是由WEB服务器调用，web服务器收到客户端的Servlet访问请求后：
①Web服务器首先检查是否已经装载并创建了该Servlet的实例对象。如果是，则直接执行第④步，否则，执行第②步。
②装载并创建该Servlet的一个实例对象。
③调用Servlet实例对象的init()方法。
④创建一个用于封装HTTP请求消息的HttpServletRequest对象和一个代表HTTP响应消息的HttpServletResponse对象，然后调用Servlet的service()方法并将请求和响应对象作为参数传递进去。
⑤WEB应用程序被停止或重新启动之前，Servlet引擎将卸载Servlet，并在卸载之前调用Servlet的destroy()方法。

三、Servlet调用图
　Servlet调用图

四、在Eclipse中开发Servlet
在eclipse中新建一个web project工程，eclipse会自动创建下图所示目录结构：
　
4.1、Servlet接口实现类
Servlet接口SUN公司定义了两个默认实现类，分别为：GenericServlet、HttpServlet。
HttpServlet指能够处理HTTP请求的servlet，它在原有Servlet接口上添加了一些与HTTP协议处理方法，它比Servlet接口的功能更为强大。因此开发人员在编写Servlet时，通常应继承这个类，而避免直接去实现Servlet接口。
HttpServlet在实现Servlet接口时，覆写了service方法，该方法体内的代码会自动判断用户的请求方式，如为GET请求，则调用HttpServlet的doGet方法，如为Post请求，则调用doPost方法。因此，开发人员在编写Servlet时，通常只需要覆写doGet或doPost方法，而不要去覆写service方法。
4.2、通过Eclipse创建和编写Servlet
选中gacl.servlet.study包，右键→New→Servlet，如下图所示：

这样，我们就通过Eclipse帮我们创建好一个名字为ServletDemo1的Servlet，创建好的ServletDemo01里面会有如下代码：
复制代码
package gacl.servlet.study;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ServletDemo1 extends HttpServlet {
/**
* The doGet method of the servlet. <br>
*
* This method is called when a form has its tag value method equals to get.
*
* @param request the request send by the client to the server
* @param response the response send by the server to the client
* @throws ServletException if an error occurred
* @throws IOException if an error occurred
*/
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
out.println("<HTML>");
out.println(" <HEAD><TITLE>A Servlet</TITLE></HEAD>");
out.println(" <BODY>");
out.print(" This is ");
out.print(this.getClass());
out.println(", using the GET method");
out.println(" </BODY>");
out.println("</HTML>");
out.flush();
out.close();
}
/**
* The doPost method of the servlet. <br>
*
* This method is called when a form has its tag value method equals to post.
*
* @param request the request send by the client to the server
* @param response the response send by the server to the client
* @throws ServletException if an error occurred
* @throws IOException if an error occurred
*/
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
out.println("<HTML>");
out.println(" <HEAD><TITLE>A Servlet</TITLE></HEAD>");
out.println(" <BODY>");
out.print(" This is ");
out.print(this.getClass());
out.println(", using the POST method");
out.println(" </BODY>");
out.println("</HTML>");
out.flush();
out.close();
}
}
复制代码
这些代码都是Eclipse自动生成的，而web.xml文件中也多了<servlet></servlet>和<servlet-mapping></servlet-mapping>两对标签，这两对标签是配置ServletDemo1的，如下图所示：

然后我们就可以通过浏览器访问ServletDemo1这个Servlet，如下图所示：

五、Servlet开发注意细节
5.1、Servlet访问URL映射配置
由于客户端是通过URL地址访问web服务器中的资源，所以Servlet程序若想被外界访问，必须把servlet程序映射到一个URL地址上，这个工作在web.xml文件中使用<servlet>元素和<servlet-mapping>元素完成。
<servlet>元素用于注册Servlet，它包含有两个主要的子元素：<servlet-name>和<servlet-class>，分别用于设置Servlet的注册名称和Servlet的完整类名。
一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含有两个子元素：<servlet-name>和<url-pattern>，分别用于指定Servlet的注册名称和Servlet的对外访问路径。例如：
复制代码
<servlet>
<servlet-name>ServletDemo1</servlet-name>
<servlet-class>gacl.servlet.study.ServletDemo1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/servlet/ServletDemo1</url-pattern>
</servlet-mapping>
复制代码
同一个Servlet可以被映射到多个URL上，即多个<servlet-mapping>元素的<servlet-name>子元素的设置值可以是同一个Servlet的注册名。例如：
复制代码
<servlet>
<servlet-name>ServletDemo1</servlet-name>
<servlet-class>gacl.servlet.study.ServletDemo1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/servlet/ServletDemo1</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/1.htm</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/2.jsp</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/3.php</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/4.ASPX</url-pattern>
</servlet-mapping>
复制代码
通过上面的配置，当我们想访问名称是ServletDemo1的Servlet，可以使用如下的几个地址去访问：
http://localhost:8080/JavaWeb_Servlet_Study_20140531/servlet/ServletDemo1
http://localhost:8080/JavaWeb_Servlet_Study_20140531/1.htm
http://localhost:8080/JavaWeb_Servlet_Study_20140531/2.jsp
http://localhost:8080/JavaWeb_Servlet_Study_20140531/3.php
http://localhost:8080/JavaWeb_Servlet_Study_20140531/4.ASPX
ServletDemo1被映射到了多个URL上。
5.2、Servlet访问URL使用*通配符映射
在Servlet映射到的URL中也可以使用*通配符，但是只能有两种固定的格式：一种格式是"*.扩展名"，另一种格式是以正斜杠（/）开头并以"/*"结尾。例如：

复制代码
<servlet>
<servlet-name>ServletDemo1</servlet-name>
<servlet-class>gacl.servlet.study.ServletDemo1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ServletDemo1</servlet-name>
<url-pattern>/*</url-pattern>
复制代码
*可以匹配任意的字符，所以此时可以用任意的URL去访问ServletDemo1这个Servlet，如下图所示：

对于如下的一些映射关系：
Servlet1 映射到 /abc/*
Servlet2 映射到 /*
Servlet3 映射到 /abc
Servlet4 映射到 *.do
问题：
当请求URL为“/abc/a.html”，“/abc/*”和“/*”都匹配，哪个servlet响应
Servlet引擎将调用Servlet1。
当请求URL为“/abc”时，“/abc/*”和“/abc”都匹配，哪个servlet响应
Servlet引擎将调用Servlet3。
当请求URL为“/abc/a.do”时，“/abc/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet1。
当请求URL为“/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet2。
当请求URL为“/xxx/yyy/a.do”时，“/*”和“*.do”都匹配，哪个servlet响应
Servlet引擎将调用Servlet2。
匹配的原则就是"谁长得更像就找谁"
5.3、Servlet与普通Java类的区别
Servlet是一个供其他Java程序（Servlet引擎）调用的Java类，它不能独立运行，它的运行完全由Servlet引擎来控制和调度。
针对客户端的多次Servlet请求，通常情况下，服务器只会创建一个Servlet实例对象，也就是说Servlet实例对象一旦创建，它就会驻留在内存中，为后续的其它请求服务，直至web容器退出，servlet实例对象才会销毁。
在Servlet的整个生命周期内，Servlet的init方法只被调用一次。而对一个Servlet的每次访问请求都导致Servlet引擎调用一次servlet的service方法。对于每次访问请求，Servlet引擎都会创建一个新的HttpServletRequest请求对象和一个新的HttpServletResponse响应对象，然后将这两个对象作为参数传递给它调用的Servlet的service()方法，service方法再根据请求方式分别调用doXXX方法。
如果在<servlet>元素中配置了一个<load-on-startup>元素，那么WEB应用程序在启动时，就会装载并创建Servlet的实例对象、以及调用Servlet实例对象的init()方法。
举例：
<servlet>
<servlet-name>invoker</servlet-name>
<servlet-class>
org.apache.catalina.servlets.InvokerServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
用途：为web应用写一个InitServlet，这个servlet配置为启动时装载，为整个web应用创建必要的数据库表和数据。
5.4、缺省Servlet
如果某个Servlet的映射路径仅仅为一个正斜杠（/），那么这个Servlet就成为当前Web应用程序的缺省Servlet。
凡是在web.xml文件中找不到匹配的<servlet-mapping>元素的URL，它们的访问请求都将交给缺省Servlet处理，也就是说，缺省Servlet用于处理所有其他Servlet都不处理的访问请求。例如：
复制代码
<servlet>
<servlet-name>ServletDemo2</servlet-name>
<servlet-class>gacl.servlet.study.ServletDemo2</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>ServletDemo2</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
复制代码
当访问不存在的Servlet时，就使用配置的默认Servlet进行处理，如下图所示：

在<tomcat的安装目录>\conf\web.xml文件中，注册了一个名称为org.apache.catalina.servlets.DefaultServlet的Servlet，并将这个Servlet设置为了缺省Servlet。
复制代码
<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
复制代码
当访问Tomcat服务器中的某个静态HTML文件和图片时，实际上是在访问这个缺省Servlet。
5.5、Servlet的线程安全问题
当多个客户端并发访问同一个Servlet时，web服务器会为每一个客户端的访问请求创建一个线程，并在这个线程上调用Servlet的service方法，因此service方法内如果访问了同一个资源的话，就有可能引发线程安全问题。例如下面的代码：
不存在线程安全问题的代码：
复制代码
package gacl.servlet.study;
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 ServletDemo3 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 当多线程并发访问这个方法里面的代码时，会存在线程安全问题吗
* i变量被多个线程并发访问，但是没有线程安全问题，因为i是doGet方法里面的局部变量，
* 当有多个线程并发访问doGet方法时，每一个线程里面都有自己的i变量，
* 各个线程操作的都是自己的i变量，所以不存在线程安全问题
* 多线程并发访问某一个方法的时候，如果在方法内部定义了一些资源(变量，集合等)
* 那么每一个线程都有这些东西，所以就不存在线程安全问题了
*/
int i=1;
i++;
response.getWriter().write(i);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
存在线程安全问题的代码：
复制代码
package gacl.servlet.study;
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 ServletDemo3 extends HttpServlet {
int i=1;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
i++;
try {
Thread.sleep(1000*4);
} catch (InterruptedException e) {
e.printStackTrace();
}
response.getWriter().write(i+"");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
把i定义成全局变量，当多个线程并发访问变量i时，就会存在线程安全问题了，如下图所示：同时开启两个浏览器模拟并发访问同一个Servlet，本来正常来说，第一个浏览器应该看到2，而第二个浏览器应该看到3的，结果两个浏览器都看到了3，这就不正常。

线程安全问题只存在多个线程并发操作同一个资源的情况下，所以在编写Servlet的时候，如果并发访问某一个资源(变量，集合等)，就会存在线程安全问题，那么该如何解决这个问题呢？
先看看下面的代码：
复制代码
package gacl.servlet.study;
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 ServletDemo3 extends HttpServlet {
int i=1;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 加了synchronized后，并发访问i时就不存在线程安全问题了，
* 为什么加了synchronized后就没有线程安全问题了呢？
* 假如现在有一个线程访问Servlet对象，那么它就先拿到了Servlet对象的那把锁
* 等到它执行完之后才会把锁还给Servlet对象，由于是它先拿到了Servlet对象的那把锁，
* 所以当有别的线程来访问这个Servlet对象时，由于锁已经被之前的线程拿走了，后面的线程只能排队等候了
*
*/
synchronized (this) {//在java中，每一个对象都有一把锁，这里的this指的就是Servlet对象
i++;
try {
Thread.sleep(1000*4);
} catch (InterruptedException e) {
e.printStackTrace();
}
response.getWriter().write(i+"");
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
现在这种做法是给Servlet对象加了一把锁，保证任何时候都只有一个线程在访问该Servlet对象里面的资源，这样就不存在线程安全问题了，如下图所示：

这种做法虽然解决了线程安全问题，但是编写Servlet却万万不能用这种方式处理线程安全问题，假如有9999个人同时访问这个Servlet，那么这9999个人必须按先后顺序排队轮流访问。
针对Servlet的线程安全问题，Sun公司是提供有解决方案的：让Servlet去实现一个SingleThreadModel接口，如果某个Servlet实现了SingleThreadModel接口，那么Servlet引擎将以单线程模式来调用其service方法。
查看Sevlet的API可以看到，SingleThreadModel接口中没有定义任何方法和常量，在Java中，把没有定义任何方法和常量的接口称之为标记接口，经常看到的一个最典型的标记接口就是"Serializable"，这个接口也是没有定义任何方法和常量的，标记接口在Java中有什么用呢？主要作用就是给某个对象打上一个标志，告诉JVM，这个对象可以做什么，比如实现了"Serializable"接口的类的对象就可以被序列化，还有一个"Cloneable"接口，这个也是一个标记接口，在默认情况下，Java中的对象是不允许被克隆的，就像现实生活中的人一样，不允许克隆，但是只要实现了"Cloneable"接口，那么对象就可以被克隆了。
让Servlet实现了SingleThreadModel接口，只要在Servlet类的定义中增加实现SingleThreadModel接口的声明即可。
对于实现了SingleThreadModel接口的Servlet，Servlet引擎仍然支持对该Servlet的多线程并发访问，其采用的方式是产生多个Servlet实例对象，并发的每个线程分别调用一个独立的Servlet实例对象。
实现SingleThreadModel接口并不能真正解决Servlet的线程安全问题，因为Servlet引擎会创建多个Servlet实例对象，而真正意义上解决多线程安全问题是指一个Servlet实例对象被多个线程同时调用的问题。事实上，在Servlet API 2.4中，已经将SingleThreadModel标记为Deprecated（过时的）。

(六)——Servlet开发
ServletConfig讲解
1.1、配置Servlet初始化参数
　　在Servlet的配置文件web.xml中，可以使用一个或多个<init-param>标签为servlet配置一些初始化参数。
例如：
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>Chapter6</display-name>

<servlet>
<servlet-name>Demo1</servlet-name>
<servlet-class>com.demos.Demo1</servlet-class>
<init-param>
<param-name>name</param-name>
<param-value>c0</param-value>
</init-param>
<init-param>
<param-name>password</param-name>
<param-value>123</param-value>
</init-param>
<init-param>
<param-name>charset</param-name>
<param-value>UTF-8</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>Demo1</servlet-name>
<url-pattern>/servlet/Demo1</url-pattern> 
</servlet-mapping>

</web-app>

Demo1.java
package com.demos;

import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/Demo1")
public class Demo1 extends HttpServlet {
private static final long serialVersionUID = 1L;

private ServletConfig config;

public Demo1() {
super();
}

/**
* 当servlet配置了初始化参数后，web容器在创建servlet实例对象时，
* 会自动将这些初始化参数封装到ServletConfig对象中，并在调用servlet的init方法时，
* 将ServletConfig对象传递给servlet。进而，程序员通过ServletConfig对象就可以
* 得到当前servlet的初始化参数信息。
*/
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
this.config = config;
}

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String name = this.config.getInitParameter("name");
//获取在web.xml中配置单个初始化参数
response.getWriter().print(name); //获取指定的初始化参数
response.getWriter().print("<hr/>");

//获取所有的初始化参数
Enumeration<String> e = config.getInitParameterNames();
while(e.hasMoreElements()){
name = e.nextElement();
String value = http://www.mamicode.com/config.getInitParameter(name);
response.getWriter().print(name + ":" + value + "<br/>");
}

}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}

ServletContext对象
一个WEB应用中的所有Servlet共享同一个ServletContext对象，因此Servlet对象之间可以通过ServletContext对象来实现通讯。

1 多个Servlet通过ServletContext对象实现数据共享
package com.demos;

import java.io.IOException;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/ServletContextDemo1")
public class ServletContextDemo1 extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String data = "http://www.mamicode.com/data from Demo1";

/**
* ServletConfig对象中维护了ServletContext对象的引用，开发人员在编写servlet时，
* 可以通过ServletConfig.getServletContext方法获得ServletContext对象。
*/
ServletContext context = this.getServletConfig().getServletContext();
context.setAttribute("data", data);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

}

/***********************************************************************************************/
package com.demos;

import java.io.IOException;

@WebServlet("/ServletContextDemo2")
public class ServletContextDemo2 extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
ServletContext context = this.getServletContext();
String data = http://www.mamicode.com/(String)context.getAttribute("data");
response.getWriter().print(data);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

}
先运行ServletContextDemo1，将数据data存储到ServletContext对象中，然后运行ServletContextDemo2就可以从ServletContext对象中取出数据了，这样就实现了数据共享，如下图所示：

2 获取WEB应用的初始化参数
Web.xml
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://localhost:3306/test</param-value>
</context-param>

package com.demos;

import java.io.IOException;

@WebServlet("/ServletContextDemo3")
public class ServletContextDemo3 extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
ServletContext context = this.getServletContext();
String contextInitParam = context.getInitParameter("url");
response.getWriter().print(contextInitParam);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

}

3 用servletContext实现请求转发
package com.demos;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/ServletContextDemo4")
public class ServletContextDemo4 extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String data = "http://www.mamicode.com/

abcdefghjkl

";
response.getWriter().write(data);
// response.getOutputStream().write(data.getBytes());
ServletContext context = this.getServletContext();
RequestDispatcher dispatcher = context.getRequestDispatcher("/ServletContextDemo5"); //获取请求转发对象(RequestDispatcher)
dispatcher.forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}

package com.demos;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/ServletContextDemo5")
public class ServletContextDemo5 extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// response.getOutputStream().write("this is ServletContextDemo5".getBytes());
response.getWriter().println("This is demo5");
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

}

4 使用servletContext读取资源文件
package gacl.servlet.study;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.MessageFormat;
import java.util.Properties;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* 使用servletContext读取资源文件
*
* @author gacl
*
*/
public class ServletContextDemo6 extends HttpServlet {

/**
* 读取src目录下的gacl.servlet.study包(同包)中的db4.properties配置文件
* @param response
* @throws IOException
*/
private void readPropCfgFile2(HttpServletResponse response)
throws IOException {
InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/gacl/servlet/study/db4.properties");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("读取src目录下的gacl.servlet.study包中的db4.properties配置文件：");
response.getWriter().println(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

/**
* 读取src目录下的db.config包中的db3.properties配置文件
* @param response
* @throws FileNotFoundException
* @throws IOException
*/
private void readPropCfgFile(HttpServletResponse response)
throws FileNotFoundException, IOException {
//通过ServletContext获取web资源的绝对路径
String path = this.getServletContext().getRealPath("/WEB-INF/classes/db/config/db3.properties");
InputStream in = new FileInputStream(path);
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("读取src目录下的db.config包中的db3.properties配置文件：");
response.getWriter().println(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

/**
*读取WebRoot目录下的properties配置文件
* @param response
* @throws IOException
*/
private void readWebRootDirPropCfgFile(HttpServletResponse response)
throws IOException {
/**
* 通过ServletContext对象读取WebRoot目录下的properties配置文件
* “/”代表的是项目根目录
*/
InputStream in = this.getServletContext().getResourceAsStream("/db2.properties");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("读取WebRoot目录下的db2.properties配置文件：");
response.getWriter().print(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

/**
*读取src目录下的properties配置文件
* @param response
* @throws IOException
*/
private void readSrcDirPropCfgFile(HttpServletResponse response) throws IOException {
/**
* 通过ServletContext对象读取src目录下的db1.properties配置文件
*/
InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db1.properties");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("读取src目录下的db1.properties配置文件：");
response.getWriter().println(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.doGet(request, response);
}
}

5 使用类装载器读取资源文件
package gacl.servlet.study;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.MessageFormat;
import java.util.Properties;

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

/**
* 用类装载器读取资源文件
* 通过类装载器读取资源文件的注意事项:不适合装载大文件，否则会导致jvm内存溢出
* @author gacl
*
*/
public class ServletContextDemo7 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* response.setContentType("text/html;charset=UTF-8");目的是控制浏览器用UTF-8进行解码；
* 这样就不会出现中文乱码了
*/
response.setHeader("content-type","text/html;charset=UTF-8");
test1(response);
response.getWriter().println("<hr/>");
test2(response);
response.getWriter().println("<hr/>");
//test3();
test4();

}

/**
* 读取类路径下的资源文件
* @param response
* @throws IOException
*/
private void test1(HttpServletResponse response) throws IOException {
//获取到装载当前类的类装载器
ClassLoader loader = ServletContextDemo7.class.getClassLoader();
//用类装载器读取src目录下的db1.properties配置文件
InputStream in = loader.getResourceAsStream("db1.properties");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("用类装载器读取src目录下的db1.properties配置文件：");
response.getWriter().println(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

/**
* 读取类路径下面、包下面的资源文件
* @param response
* @throws IOException
*/
private void test2(HttpServletResponse response) throws IOException {
//获取到装载当前类的类装载器
ClassLoader loader = ServletContextDemo7.class.getClassLoader();
//用类装载器读取src目录下的gacl.servlet.study包中的db4.properties配置文件
InputStream in = loader.getResourceAsStream("gacl/servlet/study/db4.properties");
Properties prop = new Properties();
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
response.getWriter().println("用类装载器读取src目录下的gacl.servlet.study包中的db4.properties配置文件：");
response.getWriter().println(
MessageFormat.format(
"driver={0},url={1},username={2},password={3}",
driver,url, username, password));
}

/**
* 通过类装载器读取资源文件的注意事项:不适合装载大文件，否则会导致jvm内存溢出
*/
public void test3() {
/**
* 01.avi是一个150多M的文件，使用类加载器去读取这个大文件时会导致内存溢出：
* java.lang.OutOfMemoryError: Java heap space
*/
InputStream in = ServletContextDemo7.class.getClassLoader().getResourceAsStream("01.avi");
System.out.println(in);
}

/**
* 读取01.avi,并拷贝到e:\根目录下
* 01.avi文件太大，只能用servletContext去读取
* @throws IOException
*/
public void test4() throws IOException {
// path=G:\Java学习视频\JavaWeb学习视频\JavaWeb\day05视频\01.avi
// path=01.avi
String path = this.getServletContext().getRealPath("/WEB-INF/classes/01.avi");
/**
* path.lastIndexOf("\\") + 1是一个非常绝妙的写法
*/
String filename = path.substring(path.lastIndexOf("\\") + 1);//获取文件名
InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/01.avi");
byte buffer[] = new byte[1024];
int len = 0;
OutputStream out = new FileOutputStream("e:\\" + filename);
while ((len = in.read(buffer)) > 0) {
out.write(buffer, 0, len);
}
out.close();
in.close();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

this.doGet(request, response);
}

}

客户端缓存Servlet的输出
　　对于不经常变化的数据，在servlet中可以为其设置合理的缓存时间值，以避免浏览器频繁向服务器发送请求，提升服务器的性能。例如：

package gacl.servlet.study;

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 ServletDemo5 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String data = "http://www.mamicode.com/abcddfwerwesfasfsadf";
/**
* 设置数据合理的缓存时间值，以避免浏览器频繁向服务器发送请求，提升服务器的性能
* 这里是将数据的缓存时间设置为1天
*/
response.setDateHeader("expires",System.currentTimeMillis() + 24 * 3600 * 1000);
response.getOutputStream().write(data.getBytes());
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

this.doGet(request, response);
}

}

(八、七)——HttpServletResponse对象
Web服务器收到客户端的http请求，会针对每一次请求，分别创建一个用于代表请求的request对象、和代表响应的response对象。
request和response对象即然代表请求和响应，那我们要获取客户机提交过来的数据，只需要找request对象就行了。要向客户机输出数据，只需要找response对象就行了。

1 使用OutputStream流向客户端浏览器输出中文数据
package gacl.response.study;
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ResponseDemo01 extends HttpServlet {
private static final long serialVersionUID = 4312868947607181532L;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
outputChineseByOutputStream(response);//使用OutputStream流输出中文
}

/**
* 使用OutputStream流输出中文
* @param request
* @param response
* @throws IOException
*/
public void outputChineseByOutputStream(HttpServletResponse response) throws IOException{
/**使用OutputStream输出中文注意问题：
* 在服务器端，数据是以哪个码表输出的，那么就要控制客户端浏览器以相应的码表打开，
* 比如：outputStream.write("中国".getBytes("UTF-8"));//使用OutputStream流向客户端浏览器输出中文，以UTF-8的编码进行输出
* 此时就要控制客户端浏览器以UTF-8的编码打开，否则显示的时候就会出现中文乱码，那么在服务器端如何控制客户端浏览器以以UTF-8的编码显示数据呢？
* 可以通过设置响应头控制浏览器的行为，例如：
* response.setHeader("content-type", "text/html;charset=UTF-8");//通过设置响应头控制浏览器以UTF-8的编码显示数据
*/
String data = "http://www.mamicode.com/中国";
OutputStream outputStream = response.getOutputStream();//获取OutputStream输出流
response.setHeader("content-type", "text/html;charset=UTF-8");//通过设置响应头控制浏览器以UTF-8的编码显示数据，如果不加这句话，那么浏览器显示的将是乱码
/**
* data.getBytes()是一个将字符转换成字节数组的过程，这个过程中一定会去查码表，
* 如果是中文的操作系统环境，默认就是查找查GB2312的码表，
* 将字符转换成字节数组的过程就是将中文字符转换成GB2312的码表上对应的数字
* 比如： "中"在GB2312的码表上对应的数字是98
* "国"在GB2312的码表上对应的数字是99
*/
/**
* getBytes()方法如果不带参数，那么就会根据操作系统的语言环境来选择转换码表，如果是中文操作系统，那么就使用GB2312的码表
*/
byte[] dataByteArr = data.getBytes("UTF-8");//将字符转换成字节数组，指定以UTF-8编码进行转换
outputStream.write(dataByteArr);//使用OutputStream流向客户端输出字节数组
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

客户端浏览器接收到数据后，就按照响应头上设置的字符编码来解析数据，如下所示：

2 使用PrintWriter流向客户端浏览器输出中文数据
使用PrintWriter流输出中文注意问题：
　　在获取PrintWriter输出流之前首先使用"response.setCharacterEncoding(charset)"设置字符以什么样的编码输出到浏览器，如：response.setCharacterEncoding("UTF-8");设置将字符以"UTF-8"编码输出到客户端浏览器，然后再使用response.getWriter();获取PrintWriter输出流，这两个步骤不能颠倒，如下：

response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
/**
* PrintWriter out = response.getWriter();这句代码必须放在response.setCharacterEncoding("UTF-8");之后
* 否则response.setCharacterEncoding("UTF-8")这行代码的设置将无效，浏览器显示的时候还是乱码
*/
PrintWriter out = response.getWriter();//获取PrintWriter输出流

　　然后再使用response.setHeader("content-type", "text/html;charset=字符编码");设置响应头，控制浏览器以指定的字符编码编码进行显示，例如：
//通过设置响应头控制浏览器以UTF-8的编码显示数据，如果不加这句话，那么浏览器显示的将是乱码
response.setHeader("content-type", "text/html;charset=UTF-8");

　　除了可以使用response.setHeader("content-type", "text/html;charset=字符编码");设置响应头来控制浏览器以指定的字符编码编码进行显示这种方式之外，还可以用如下的方式来模拟响应头的作用
/**
* 多学一招：使用HTML语言里面的<meta>标签来控制浏览器行为，模拟通过设置响应头控制浏览器行为
*response.getWriter().write("<meta http-equiv=‘content-type‘ content=‘text/html;charset=UTF-8‘/>");
* 等同于response.setHeader("content-type", "text/html;charset=UTF-8");
*/
response.getWriter().write("<meta http-equiv=‘content-type‘ content=‘text/html;charset=UTF-8‘/>");

范例：使用PrintWriter流向客户端浏览器输出"中国"这两个汉字
package gacl.response.study;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ResponseDemo01 extends HttpServlet {
private static final long serialVersionUID = 4312868947607181532L;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
outputChineseByPrintWriter(response);//使用PrintWriter流输出中文
}
/**
* 使用PrintWriter流输出中文
* @param request
* @param response
* @throws IOException
*/
public void outputChineseByPrintWriter(HttpServletResponse response) throws IOException{
String data = "http://www.mamicode.com/中国";

//通过设置响应头控制浏览器以UTF-8的编码显示数据，如果不加这句话，那么浏览器显示的将是乱码
//response.setHeader("content-type", "text/html;charset=UTF-8");

response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
/**
* PrintWriter out = response.getWriter();这句代码必须放在response.setCharacterEncoding("UTF-8");之后
* 否则response.setCharacterEncoding("UTF-8")这行代码的设置将无效，浏览器显示的时候还是乱码
*/
PrintWriter out = response.getWriter();//获取PrintWriter输出流
/**
* 多学一招：使用HTML语言里面的<meta>标签来控制浏览器行为，模拟通过设置响应头控制浏览器行为
* out.write("<meta http-equiv=‘content-type‘ content=‘text/html;charset=UTF-8‘/>");
* 等同于response.setHeader("content-type", "text/html;charset=UTF-8");
*/
out.write("<meta http-equiv=‘content-type‘ content=‘text/html;charset=UTF-8‘/>");
out.write(data);//使用PrintWriter流向客户端输出字符
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
3 使用OutputStream或者PrintWriter向客户端浏览器输出数字
package gacl.response.study;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ResponseDemo01 extends HttpServlet {
private static final long serialVersionUID = 4312868947607181532L;
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

outputOneByOutputStream(response);//使用OutputStream输出1到客户端浏览器

}
/**
* 使用OutputStream流输出数字1
* @param request
* @param response
* @throws IOException
*/
public void outputOneByOutputStream(HttpServletResponse response) throws IOException{
response.setHeader("content-type", "text/html;charset=UTF-8");
OutputStream outputStream = response.getOutputStream();
outputStream.write("使用OutputStream流输出数字1：".getBytes("UTF-8"));
//outputStream.write(1); // 此处无法显示数字1 , 如果想在服务端显示数字, 必须先转化为字符串格式
outputStream.write((1+"").getBytes());
}

}
如果希望服务器输出什么浏览器就能看到什么，那么在服务器端都要以字符串的形式进行输出。

如果使用PrintWriter流输出数字，那么也要先将数字转换成字符串后再输出，如下：

/**
* 使用PrintWriter流输出数字1
* @param request
* @param response
* @throws IOException
*/
public void outputOneByPrintWriter(HttpServletResponse response) throws IOException{
response.setHeader("content-type", "text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter out = response.getWriter();//获取PrintWriter输出流
out.write("使用PrintWriter流输出数字1：");
out.write(1+"");
}

文件下载
　　文件下载功能是web开发中经常使用到的功能，使用HttpServletResponse对象就可以实现文件的下载
文件下载功能的实现思路：
　　1.获取要下载的文件的绝对路径
　　2.获取要下载的文件名
　　3.设置content-disposition响应头控制浏览器以下载的形式打开文件
　　4.获取要下载的文件输入流
　　5.创建数据缓冲区
　　6.通过response对象获取OutputStream流
　　7.将FileInputStream流写入到buffer缓冲区
8.使用OutputStream将缓冲区的数据输出到客户端浏览器

package gacl.response.study;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URLEncoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 文件下载
*/
public class ResponseDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
downloadFileByOutputStream(response);//下载文件，通过OutputStream流
}
/**
* 下载文件，通过OutputStream流
* @param response
* @throws FileNotFoundException
* @throws IOException
*/
private void downloadFileByOutputStream(HttpServletResponse response)
throws FileNotFoundException, IOException {
//1.获取要下载的文件的绝对路径
String realPath = this.getServletContext().getRealPath("/download/1.JPG");
//2.获取要下载的文件名
String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);
//3.设置content-disposition响应头控制浏览器以下载的形式打开文件
response.setHeader("content-disposition", "attachment;filename="+fileName);
//4.获取要下载的文件输入流
InputStream in = new FileInputStream(realPath);
int len = 0;
//5.创建数据缓冲区
byte[] buffer = new byte[1024];
//6.通过response对象获取OutputStream流
OutputStream out = response.getOutputStream();
//7.将FileInputStream流写入到buffer缓冲区
while ((len = in.read(buffer)) > 0) {
//8.使用OutputStream将缓冲区的数据输出到客户端浏览器
out.write(buffer,0,len);
}
in.close();
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

使用Response实现中文文件下载
package gacl.response.study;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URLEncoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 文件下载
*/
public class ResponseDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
downloadChineseFileByOutputStream(response);//下载中文文件
}
/**
* 下载中文文件,中文文件下载时，文件名要经过URL编码，否则会出现文件名乱码
* @param response
* @throws FileNotFoundException
* @throws IOException
*/
private void downloadChineseFileByOutputStream(HttpServletResponse response)
throws FileNotFoundException, IOException {
String realPath = this.getServletContext().getRealPath("/download/张家界国家森林公园.JPG");//获取要下载的文件的绝对路径
String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);//获取要下载的文件名

//设置content-disposition响应头控制浏览器以下载的形式打开文件，中文文件名要使用URLEncoder.encode方法进行编码，否则会出现文件名乱码
response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
InputStream in = new FileInputStream(realPath);//获取文件输入流
int len = 0;
byte[] buffer = new byte[1024];
OutputStream out = response.getOutputStream();
while ((len = in.read(buffer)) > 0) {
out.write(buffer,0,len);//将缓冲区的数据输出到客户端浏览器
}
in.close();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
文件下载注意事项：编写文件下载功能时推荐使用OutputStream流，避免使用PrintWriter流，因为OutputStream流是字节流，可以处理任意类型的数据，而PrintWriter流是字符流，只能处理字符数据，如果用字符流处理字节数据，会导致数据丢失。

范例：使用PrintWriter流下载文件
package gacl.response.study;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URLEncoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 文件下载
*/
public class ResponseDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
downloadFileByPrintWriter(response);//下载文件，通过PrintWriter流
}
/**
* 下载文件，通过PrintWriter流，虽然也能够实现下载，但是会导致数据丢失，因此不推荐使用PrintWriter流下载文件
* @param response
* @throws FileNotFoundException
* @throws IOException
*/
private void downloadFileByPrintWriter(HttpServletResponse response)
throws FileNotFoundException, IOException {
String realPath = this.getServletContext().getRealPath("/download/张家界国家森林公园.JPG");//获取要下载的文件的绝对路径
String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);//获取要下载的文件名
//设置content-disposition响应头控制浏览器以下载的形式打开文件，中文文件名要使用URLEncoder.encode方法进行编码
response.setHeader("content-disposition", "attachment;filename="+URLEncoder.encode(fileName, "UTF-8"));
FileReader in = new FileReader(realPath);
int len = 0;
char[] buffer = new char[1024];
PrintWriter out = response.getWriter();
while ((len = in.read(buffer)) > 0) {
out.write(buffer,0,len);//将缓冲区的数据输出到客户端浏览器, 此处读取图片数据，最终会导致图片数据丢失
}
in.close();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

生成随机图片用作验证码
　　生成图片主要用到了一个BufferedImage类
package gacl.response.study;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ResponseDemo03 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

response.setHeader("refresh", "5");//设置refresh响应头控制浏览器每隔5秒钟刷新一次
//1.在内存中创建一张图片
BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
//2.得到图片
//Graphics g = image.getGraphics();
Graphics2D g = (Graphics2D)image.getGraphics();
g.setColor(Color.WHITE);//设置图片的背景色
g.fillRect(0, 0, 80, 20);//填充背景色
//3.向图片上写数据
g.setColor(Color.BLUE);//设置图片上字体的颜色
g.setFont(new Font(null, Font.BOLD, 20));
g.drawString(makeNum(), 0, 20);
//4.设置响应头控制浏览器浏览器以图片的方式打开
response.setContentType("image/jpeg");//等同于response.setHeader("Content-Type", "image/jpeg");
//5.设置响应头控制浏览器不缓存图片数据
response.setDateHeader("expries", -1);
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Pragma", "no-cache");
//6.将图片写给浏览器
ImageIO.write(image, "jpg", response.getOutputStream());
}
/**
* 生成随机数字
* @return
*/
private String makeNum(){
Random random = new Random();
String num = random.nextInt(9999999)+"";
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 7-num.length(); i++) {
sb.append("0");
}
num = sb.toString()+num;
return num;
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

结果每隔5秒自动刷新一次

response实现请求重定向
　　请求重定向指：一个web资源收到客户端请求后，通知客户端去访问另外一个web资源，这称之为请求重定向。
// 应用场景：用户登陆，用户首先访问登录页面，登录成功后，就会跳转到某个页面，这个过程就是一个请求重定向的过程
// 实现方式：response.sendRedirect(String location)，即调用response对象的sendRedirect方法实现请求重定向
// sendRedirect内部的实现原理：使用response设置302状态码和设置location响应头实现重定向
package gacl.response.study;
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 ResponseDemo04 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 1.调用sendRedirect方法实现请求重定向,
* sendRedirect方法内部调用了
* response.setHeader("Location", "/JavaWeb_HttpServletResponse_Study_20140615/index.jsp");
* response.setStatus(HttpServletResponse.SC_FOUND);//设置302状态码，等同于response.setStatus(302);
*/
response.sendRedirect("/JavaWeb_HttpServletResponse_Study_20140615/index.jsp");

//2.使用response设置302状态码和设置location响应头实现重定向实现请求重定向
//response.setHeader("Location", "/JavaWeb_HttpServletResponse_Study_20140615/index.jsp");
//response.setStatus(HttpServletResponse.SC_FOUND);//设置302状态码，等同于response.setStatus(302);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
(九)——通过Servlet生成验证码图片
1 BufferedImage -- DrawImage
package gacl.response.study;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 生成随机图片，用来作为验证码
*/
public class DrawImage extends HttpServlet {
private static final long serialVersionUID = 3038623696184546092L;

public static final int WIDTH = 120;//生成的图片的宽度
public static final int HEIGHT = 30;//生成的图片的高度
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.doPost(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String createTypeFlag = request.getParameter("createTypeFlag");//接收客户端传递的createTypeFlag标识
//1.在内存中创建一张图片
BufferedImage bi = new BufferedImage(WIDTH, HEIGHT,BufferedImage.TYPE_INT_RGB);
//2.得到图片
Graphics g = bi.getGraphics();
//3.设置图片的背影色
setBackGround(g);
//4.设置图片的边框
setBorder(g);
//5.在图片上画干扰线
drawRandomLine(g);
//6.写在图片上随机数
//String random = drawRandomNum((Graphics2D) g,"ch");//生成中文验证码图片
//String random = drawRandomNum((Graphics2D) g,"nl");//生成数字和字母组合的验证码图片
//String random = drawRandomNum((Graphics2D) g,"n");//生成纯数字的验证码图片
//String random = drawRandomNum((Graphics2D) g,"l");//生成纯字母的验证码图片
String random = drawRandomNum((Graphics2D) g,createTypeFlag);//根据客户端传递的createTypeFlag标识生成验证码图片
//7.将随机数存在session中
request.getSession().setAttribute("checkcode", random);
//8.设置响应头通知浏览器以图片的形式打开
response.setContentType("image/jpeg");//等同于response.setHeader("Content-Type", "image/jpeg");
//9.设置响应头控制浏览器不要缓存
response.setDateHeader("expries", -1);
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Pragma", "no-cache");
//10.将图片写给浏览器
ImageIO.write(bi, "jpg", response.getOutputStream());
}
/**
* 设置图片的背景色
* @param g
*/
private void setBackGround(Graphics g) {
// 设置颜色
g.setColor(Color.WHITE);
// 填充区域
g.fillRect(0, 0, WIDTH, HEIGHT);
}
/**
* 设置图片的边框
* @param g
*/
private void setBorder(Graphics g) {
// 设置边框颜色
g.setColor(Color.BLUE);
// 边框区域
g.drawRect(1, 1, WIDTH - 2, HEIGHT - 2);
}
/**
* 在图片上画随机线条
* @param g
*/
private void drawRandomLine(Graphics g) {
// 设置颜色
g.setColor(Color.GREEN);
// 设置线条个数并画线
for (int i = 0; i < 5; i++) {
int x1 = new Random().nextInt(WIDTH);
int y1 = new Random().nextInt(HEIGHT);
int x2 = new Random().nextInt(WIDTH);
int y2 = new Random().nextInt(HEIGHT);
g.drawLine(x1, y1, x2, y2);
}
}
/**
* 画随机字符
* @param g
* @param createTypeFlag
* @return
* String... createTypeFlag是可变参数，
* Java1.5增加了新特性：可变参数：适用于参数个数不确定，类型确定的情况，java把可变参数当做数组处理。注意：可变参数必须位于最后一项
*/
private String drawRandomNum(Graphics2D g,String... createTypeFlag) {
// 设置颜色
g.setColor(Color.RED);
// 设置字体
g.setFont(new Font("宋体", Font.BOLD, 20));
//常用的中国汉字
String baseChineseChar = "\u7684\u4e00\u4e86\u662f\u6211\u4e0d\u5728\u4eba\u4eec\u6709\u6765\u4ed6\u8fd9\u4e0a\u7740\u4e2a\u5730\u5230\u5927\u91cc\u8bf4\u5c31\u53bb\u5b50\u5f97\u4e5f\u548c\u90a3\u8981\u4e0b\u770b\u5929\u65f6\u8fc7\u51fa\u5c0f\u4e48\u8d77\u4f60\u90fd\u628a\u597d\u8fd8\u591a\u6ca1\u4e3a\u53c8\u53ef\u5bb6\u5b66\u53ea\u4ee5\u4e3b\u4f1a\u6837\u5e74\u60f3\u751f\u540c\u8001\u4e2d\u5341\u4ece\u81ea\u9762\u524d\u5934\u9053\u5b83\u540e\u7136\u8d70\u5f88\u50cf\u89c1\u4e24\u7528\u5979\u56fd\u52a8\u8fdb\u6210\u56de\u4ec0\u8fb9\u4f5c\u5bf9\u5f00\u800c\u5df1\u4e9b\u73b0\u5c71\u6c11\u5019\u7ecf\u53d1\u5de5\u5411\u4e8b\u547d\u7ed9\u957f\u6c34\u51e0\u4e49\u4e09\u58f0\u4e8e\u9ad8\u624b\u77e5\u7406\u773c\u5fd7\u70b9\u5fc3\u6218\u4e8c\u95ee\u4f46\u8eab\u65b9\u5b9e\u5403\u505a\u53eb\u5f53\u4f4f\u542c\u9769\u6253\u5462\u771f\u5168\u624d\u56db\u5df2\u6240\u654c\u4e4b\u6700\u5149\u4ea7\u60c5\u8def\u5206\u603b\u6761\u767d\u8bdd\u4e1c\u5e2d\u6b21\u4eb2\u5982\u88ab\u82b1\u53e3\u653e\u513f\u5e38\u6c14\u4e94\u7b2c\u4f7f\u5199\u519b\u5427\u6587\u8fd0\u518d\u679c\u600e\u5b9a\u8bb8\u5feb\u660e\u884c\u56e0\u522b\u98de\u5916\u6811\u7269\u6d3b\u90e8\u95e8\u65e0\u5f80\u8239\u671b\u65b0\u5e26\u961f\u5148\u529b\u5b8c\u5374\u7ad9\u4ee3\u5458\u673a\u66f4\u4e5d\u60a8\u6bcf\u98ce\u7ea7\u8ddf\u7b11\u554a\u5b69\u4e07\u5c11\u76f4\u610f\u591c\u6bd4\u9636\u8fde\u8f66\u91cd\u4fbf\u6597\u9a6c\u54ea\u5316\u592a\u6307\u53d8\u793e\u4f3c\u58eb\u8005\u5e72\u77f3\u6ee1\u65e5\u51b3\u767e\u539f\u62ff\u7fa4\u7a76\u5404\u516d\u672c\u601d\u89e3\u7acb\u6cb3\u6751\u516b\u96be\u65e9\u8bba\u5417\u6839\u5171\u8ba9\u76f8\u7814\u4eca\u5176\u4e66\u5750\u63a5\u5e94\u5173\u4fe1\u89c9\u6b65\u53cd\u5904\u8bb0\u5c06\u5343\u627e\u4e89\u9886\u6216\u5e08\u7ed3\u5757\u8dd1\u8c01\u8349\u8d8a\u5b57\u52a0\u811a\u7d27\u7231\u7b49\u4e60\u9635\u6015\u6708\u9752\u534a\u706b\u6cd5\u9898\u5efa\u8d76\u4f4d\u5531\u6d77\u4e03\u5973\u4efb\u4ef6\u611f\u51c6\u5f20\u56e2\u5c4b\u79bb\u8272\u8138\u7247\u79d1\u5012\u775b\u5229\u4e16\u521a\u4e14\u7531\u9001\u5207\u661f\u5bfc\u665a\u8868\u591f\u6574\u8ba4\u54cd\u96ea\u6d41\u672a\u573a\u8be5\u5e76\u5e95\u6df1\u523b\u5e73\u4f1f\u5fd9\u63d0\u786e\u8fd1\u4eae\u8f7b\u8bb2\u519c\u53e4\u9ed1\u544a\u754c\u62c9\u540d\u5440\u571f\u6e05\u9633\u7167\u529e\u53f2\u6539\u5386\u8f6c\u753b\u9020\u5634\u6b64\u6cbb\u5317\u5fc5\u670d\u96e8\u7a7f\u5185\u8bc6\u9a8c\u4f20\u4e1a\u83dc\u722c\u7761\u5174\u5f62\u91cf\u54b1\u89c2\u82e6\u4f53\u4f17\u901a\u51b2\u5408\u7834\u53cb\u5ea6\u672f\u996d\u516c\u65c1\u623f\u6781\u5357\u67aa\u8bfb\u6c99\u5c81\u7ebf\u91ce\u575a\u7a7a\u6536\u7b97\u81f3\u653f\u57ce\u52b3\u843d\u94b1\u7279\u56f4\u5f1f\u80dc\u6559\u70ed\u5c55\u5305\u6b4c\u7c7b\u6e10\u5f3a\u6570\u4e61\u547c\u6027\u97f3\u7b54\u54e5\u9645\u65e7\u795e\u5ea7\u7ae0\u5e2e\u5566\u53d7\u7cfb\u4ee4\u8df3\u975e\u4f55\u725b\u53d6\u5165\u5cb8\u6562\u6389\u5ffd\u79cd\u88c5\u9876\u6025\u6797\u505c\u606f\u53e5\u533a\u8863\u822c\u62a5\u53f6\u538b\u6162\u53d4\u80cc\u7ec6";
//数字和字母的组合
String baseNumLetter = "0123456789ABCDEFGHJKLMNOPQRSTUVWXYZ";
//纯数字
String baseNum = "0123456789";
//纯字母
String baseLetter = "ABCDEFGHJKLMNOPQRSTUVWXYZ";
//createTypeFlag[0]==null表示没有传递参数
if (createTypeFlag.length > 0 && null != createTypeFlag[0]) {
if (createTypeFlag[0].equals("ch")) {
// 截取汉字
return createRandomChar(g, baseChineseChar);
}else if (createTypeFlag[0].equals("nl")) {
// 截取数字和字母的组合
return createRandomChar(g, baseNumLetter);
}else if (createTypeFlag[0].equals("n")) {
// 截取数字
return createRandomChar(g, baseNum);
}else if (createTypeFlag[0].equals("l")) {
// 截取字母
return createRandomChar(g, baseLetter);
}
}else {
// 默认截取数字和字母的组合
return createRandomChar(g, baseNumLetter);
}

return "";
}
/**
* 创建随机字符
* @param g
* @param baseChar
* @return 随机字符
*/
private String createRandomChar(Graphics2D g,String baseChar) {
StringBuffer sb = new StringBuffer();
int x = 5;
String ch ="";
// 控制字数
for (int i = 0; i < 4; i++) {
// 设置字体旋转角度
int degree = new Random().nextInt() % 30;
ch = baseChar.charAt(new Random().nextInt(baseChar.length())) + "";
sb.append(ch);
// 正向角度先正向旋转, 添加字符, 再反向旋转回来, 这样相当于图片没转, 字符旋转了
g.rotate(degree * Math.PI / 180, x, 20);
g.drawString(ch, x, 20);
// 反向角度
g.rotate(-degree * Math.PI / 180, x, 20);
x += 30;
}
return sb.toString();
}
}
2 在Form表单中使用验证码图片
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>在Form表单中使用验证码</title>
<script type="text/javascript">
//刷新验证码
function changeImg(){
// 在末尾加Math.random()的作用：
// 如果两次请求地址一样，服务器只会处理第一次请求，第二次请求返回内容和第一次一样。或者说如果地址相同，第一次请求时，将自动缓存，导致第二次不会重复请求了。Math.random()是调用javascript语法中的数学函数，能够产生随机数。
// 末尾加Math.random()使每次请求地址不相同，服务器每次都去做不同的响应。也可以使用new date()时间戳的形式作为参数传递。
document.getElementById("validateCodeImg").src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage?"+Math.random();
}
</script>
</head>

<body>
<form action="${pageContext.request.contextPath}/servlet/CheckServlet" method="post">
验证码：<input type="text" name="validateCode"/>
<img alt="验证码看不清，换一张" src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage" id="validateCodeImg" onclick="changeImg()">
<a href="javascript:void(0)" onclick="changeImg()">看不清，换一张</a>
<br/>
<input type="submit" value="http://www.mamicode.com/提交">
</form>
</body>
</html>

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>在Form表单中使用验证码</title>
<script type="text/javascript">
//刷新验证码
function changeImg(obj,createTypeFlag){
document.getElementById(obj.id).src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage?createTypeFlag="+createTypeFlag+"&"+Math.random();
}
</script>
</head>

<body>
<form action="${pageContext.request.contextPath}/servlet/CheckServlet" method="post">
数字字母混合验证码：<input type="text" name="validateCode"/>
<img alt="验证码看不清，换一张" src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage" id="validateCodeImg1" onclick="changeImg(this,‘nl‘)">
<br/>
中文验证码：<input type="text" name="validateCode"/>
<img alt="验证码看不清，换一张" src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage?createTypeFlag=ch" id="validateCodeImg2" onclick="changeImg(this,‘ch‘)">
<br/>
英文验证码：<input type="text" name="validateCode"/>
<img alt="验证码看不清，换一张" src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage?createTypeFlag=l" id="validateCodeImg3" onclick="changeImg(this,‘l‘)">
<br/>
数字验证码：<input type="text" name="validateCode"/>
<img alt="验证码看不清，换一张" src="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/DrawImage?createTypeFlag=n" id="validateCodeImg4" onclick="changeImg(this,‘n‘)">
<br/>
<input type="submit" value="http://www.mamicode.com/提交">
</form>
</body>
</html>

3 服务器端对form表单提交上来的验证码处理
package gacl.response.study;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 服务器端接收到验证码后的处理
*/
public class CheckServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String clientCheckcode = request.getParameter("validateCode");//接收客户端浏览器提交上来的验证码
String serverCheckcode = (String) request.getSession().getAttribute("checkcode");//从服务器端的session中取出验证码
if (clientCheckcode.equals(serverCheckcode)) {//将客户端验证码和服务器端验证比较，如果相等，则表示验证通过
System.out.println("验证码验证通过！");
}else {
System.out.println("验证码验证失败！");
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

(十)——HttpServletRequest对象
HttpServletRequest对象代表客户端的请求，当客户端通过HTTP协议访问服务器时，HTTP请求头中的所有信息都封装在这个对象中，通过这个对象提供的方法，可以获得客户端请求的所有信息。
1 获得客户机信息
　　getRequestURL 方法返回客户端发出请求时的完整URL。
　　getRequestURI 方法返回请求行中的资源名部分。
　　getQueryString 方法返回请求行中的参数部分。
　　getPathInfo 方法返回请求URL中的额外路径信息。额外路径信息是请求URL中的位于Servlet的路径之后和查询参数之前的内容，它以“/”开头。
　　getRemoteAddr 方法返回发出请求的客户机的IP地址。
　　getRemoteHost 方法返回发出请求的客户机的完整主机名。
　　getRemotePort 方法返回客户机所使用的网络端口号。
　　getLocalAddr 方法返回WEB服务器的IP地址。
getLocalName 方法返回WEB服务器的主机名。

范例：通过 request 对象获取客户端请求信息
package gacl.request.study;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 通过request对象获取客户端请求信息
*/
public class RequestDemo01 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* 1.获得客户机信息
*/
String requestUrl = request.getRequestURL().toString();//得到请求的URL地址
String requestUri = request.getRequestURI();//得到请求的资源
String queryString = request.getQueryString();//得到请求的URL地址中附带的参数
String remoteAddr = request.getRemoteAddr();//得到来访者的IP地址
String remoteHost = request.getRemoteHost();
int remotePort = request.getRemotePort();
String remoteUser = request.getRemoteUser();
String method = request.getMethod();//得到请求URL地址时使用的方法
String pathInfo = request.getPathInfo();
String localAddr = request.getLocalAddr();//获取WEB服务器的IP地址
String localName = request.getLocalName();//获取WEB服务器的主机名
response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
//通过设置响应头控制浏览器以UTF-8的编码显示数据，如果不加这句话，那么浏览器显示的将是乱码
response.setHeader("content-type", "text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.write("获取到的客户机信息如下：");
out.write("<hr/>");
out.write("请求的URL地址："+requestUrl);
out.write("<br/>");
out.write("请求的资源："+requestUri);
out.write("<br/>");
out.write("请求的URL地址中附带的参数："+queryString);
out.write("<br/>");
out.write("来访者的IP地址："+remoteAddr);
out.write("<br/>");
out.write("来访者的主机名："+remoteHost);
out.write("<br/>");
out.write("使用的端口号："+remotePort);
out.write("<br/>");
out.write("remoteUser："+remoteUser);
out.write("<br/>");
out.write("请求使用的方法："+method);
out.write("<br/>");
out.write("pathInfo："+pathInfo);
out.write("<br/>");
out.write("localAddr："+localAddr);
out.write("<br/>");
out.write("localName："+localName);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

2 获得客户机请求头
　　getHeader(string name)方法:String
　　getHeaders(String name)方法:Enumeration
　　getHeaderNames()方法
范例：通过request对象获取客户端请求头信息
package gacl.request.study;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 获取客户端请求头信息
* 客户端请求头：
*
*/
public class RequestDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setCharacterEncoding("UTF-8");//设置将字符以"UTF-8"编码输出到客户端浏览器
//通过设置响应头控制浏览器以UTF-8的编码显示数据
response.setHeader("content-type", "text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
Enumeration<String> reqHeadInfos = request.getHeaderNames();//获取所有的请求头
out.write("获取到的客户端所有的请求头信息如下：");
out.write("<hr/>");
while (reqHeadInfos.hasMoreElements()) {
String headName = (String) reqHeadInfos.nextElement();
String headValue = http://www.mamicode.com/request.getHeader(headName);//根据请求头的名字获取对应的请求头的值
out.write(headName+":"+headValue);
out.write("<br/>");
}
out.write("<br/>");
out.write("获取到的客户端Accept-Encoding请求头的值：");
out.write("<hr/>");
String value = http://www.mamicode.com/request.getHeader("Accept-Encoding");//获取Accept-Encoding请求头对应的值
out.write(value);

Enumeration<String> e = request.getHeaders("Accept-Encoding");
while (e.hasMoreElements()) {
String string = (String) e.nextElement();
System.out.println(string);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

3 获得客户机请求参数(客户端提交的数据)
getParameter(String)方法(常用)
getParameterValues(String name)方法(常用)
getParameterNames()方法(不常用)
getParameterMap()方法(编写框架时常用)
getMethod();

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Html的Form表单元素</title>
</head>
<fieldset style="width:500px;">
<legend>Html的Form表单元素</legend>

<form action="${pageContext.request.contextPath}/servlet/RequestDemo03" method="post">

编  号(文本框)：
<input type="text" name="userid" value="http://www.mamicode.com/NO." size="2" maxlength="2"><br>

用户名(文本框)：<input type="text" name="username" value="http://www.mamicode.com/请输入用户名"><br>

密  码(密码框)：

<input type="password" name="userpass" value="http://www.mamicode.com/请输入密码"><br>

性  别(单选框)：
<input type="radio" name="sex" value="http://www.mamicode.com/男" checked>男
<input type="radio" name="sex" value="http://www.mamicode.com/女">女<br>

部  门(下拉框)：
<select name="dept">
<option value="http://www.mamicode.com/技术部">技术部</option>
<option value="http://www.mamicode.com/销售部" SELECTED>销售部</option>
<option value="http://www.mamicode.com/财务部">财务部</option>
</select><br>

兴  趣(复选框)：
<input type="checkbox" name="inst" value="http://www.mamicode.com/唱歌">唱歌
<input type="checkbox" name="inst" value="http://www.mamicode.com/游泳">游泳
<input type="checkbox" name="inst" value="http://www.mamicode.com/跳舞">跳舞
<input type="checkbox" name="inst" value="http://www.mamicode.com/编程" checked>编程
<input type="checkbox" name="inst" value="http://www.mamicode.com/上网">上网
<br>

说  明(文本域)：
<textarea name="note" cols="34" rows="5">
</textarea>
<br>

<input type="hidden" name="hiddenField" value="http://www.mamicode.com/hiddenvalue"/>

<input type="submit" value="http://www.mamicode.com/提交(提交按钮)">

<input type="reset" value="http://www.mamicode.com/重置(重置按钮)">
</form>

</fieldset>
</body>

</html>


在服务器端使用getParameter方法和getParameterValues方法接收表单参数，代码如下：
package gacl.request.study;
import java.io.IOException;
import java.text.MessageFormat;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 获取客户端通过Form表单提交上来的参数
*/
public class RequestDemo03 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//客户端是以UTF-8编码提交表单数据的，所以需要设置服务器端以UTF-8的编码进行接收，否则对于中文数据就会产生乱码
request.setCharacterEncoding("UTF-8");
/**
* 编  号(文本框)：
<input type="text" name="userid" value="http://www.mamicode.com/NO." size="2" maxlength="2">
*/
String userid = request.getParameter("userid");//获取填写的编号，userid是文本框的名字，<input type="text" name="userid">
/**
* 用户名(文本框)：<input type="text" name="username" value="http://www.mamicode.com/请输入用户名">
*/
String username = request.getParameter("username");//获取填写的用户名
/**
* 密  码(密码框)：<input type="password" name="userpass" value="http://www.mamicode.com/请输入密码">
*/
String userpass = request.getParameter("userpass");//获取填写的密码
String sex = request.getParameter("sex");//获取选中的性别
String dept = request.getParameter("dept");//获取选中的部门
//获取选中的兴趣，因为可以选中多个值，所以获取到的值是一个字符串数组，因此需要使用getParameterValues方法来获取
String[] insts = request.getParameterValues("inst");
String note = request.getParameter("note");//获取填写的说明信息
String hiddenField = request.getParameter("hiddenField");//获取隐藏域的内容

String instStr="";
/**
* 获取数组数据的技巧，可以避免insts数组为null时引发的空指针异常错误！
*/
for (int i = 0; insts!=null && i < insts.length; i++) {
if (i == insts.length-1) {
instStr+=insts[i];
}else {
instStr+=insts[i]+",";
}
}

String htmlStr = "<table>" +
"<tr><td>填写的编号：</td><td>{0}</td></tr>" +
"<tr><td>填写的用户名：</td><td>{1}</td></tr>" +
"<tr><td>填写的密码：</td><td>{2}</td></tr>" +
"<tr><td>选中的性别：</td><td>{3}</td></tr>" +
"<tr><td>选中的部门：</td><td>{4}</td></tr>" +
"<tr><td>选中的兴趣：</td><td>{5}</td></tr>" +
"<tr><td>填写的说明：</td><td>{6}</td></tr>" +
"<tr><td>隐藏域的内容：</td><td>{7}</td></tr>" +
"</table>";
htmlStr = MessageFormat.format(htmlStr, userid,username,userpass,sex,dept,instStr,note,hiddenField);

response.setCharacterEncoding("UTF-8");//设置服务器端以UTF-8编码输出数据到客户端
response.setContentType("text/html;charset=UTF-8");//设置客户端浏览器以UTF-8编码解析数据
response.getWriter().write(htmlStr);//输出htmlStr里面的内容到客户端浏览器显示
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

在服务器端使用getParameterNames方法接收表单参数，代码如下：
Enumeration<String> paramNames = request.getParameterNames();//获取所有的参数名
while (paramNames.hasMoreElements()) {
String name = paramNames.nextElement();//得到参数名
String value = http://www.mamicode.com/request.getParameter(name);//通过参数名获取对应的值
System.out.println(MessageFormat.format("{0}={1}", name,value));
}
运行结果如下：

在服务器端使用 getParameterMap 方法接收表单参数，代码如下：
//request对象封装的参数是以Map的形式存储的
Map<String, String[]> paramMap = request.getParameterMap();
for(Map.Entry<String, String[]> entry :paramMap.entrySet()){
String paramName = entry.getKey();
String paramValuehttp://www.mamicode.com/= "";
String[] paramValueArr = entry.getValue();
for (int i = 0; paramValueArr!=null && i < paramValueArr.length; i++) {
if (i == paramValueArr.length-1) {
paramValue+=paramValueArr[i];
}else {
paramValue+=paramValueArr[i]+",";
}
}
System.out.println(MessageFormat.format("{0}={1}", paramName,paramValue));
}
运行结果如下：

4 Request对象实现请求转发
请求转发：指一个web资源收到客户端请求后，通知服务器去调用另外一个web资源进行处理。
请求转发的应用场景：MVC设计模式
在Servlet中实现请求转发的两种方式：
1 通过ServletContext的getRequestDispatcher(String path)方法，该方法返回一个RequestDispatcher对象，调用这个对象的forward方法可以实现请求转发。
例如：将请求转发的test.jsp页面
RequestDispatcher reqDispatcher =this.getServletContext().getRequestDispatcher("/test.jsp");
reqDispatcher.forward(request, response);
2 通过request对象提供的getRequestDispatche(String path)方法，该方法返回一个RequestDispatcher对象，调用这个对象的forward方法可以实现请求转发。
例如：将请求转发的test.jsp页面
request.getRequestDispatcher("/test.jsp").forward(request, response);
request对象同时也是一个域对象(Map容器)，开发人员通过request对象在实现转发时，把数据通过request对象带给其它web资源处理。
例如：请求RequestDemo06 Servlet，RequestDemo06将请求转发到test.jsp页面
package gacl.request.study;
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 RequestDemo06 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String data="http://www.mamicode.com/大家好，我是孤傲苍狼，我正在总结JavaWeb";
/**
* 将数据存放到request对象中,此时把request对象当作一个Map容器来使用
*/
request.setAttribute("data", data);
//客户端访问RequestDemo06这个Servlet后，RequestDemo06通知服务器将请求转发(forward)到test.jsp页面进行处理
request.getRequestDispatcher("/test.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
test.jsp页面代码如下：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Request对象实现请求转发</title>
</head>

<body>
使用普通方式取出存储在request对象中的数据：
<h3 style="color:red;"><%=(String)request.getAttribute("data")%></h3>
使用EL表达式取出存储在request对象中的数据：
<h3 style="color:red;">${data}</h3>
</body>
</html>
运行结果如下：

request对象作为一个域对象(Map容器)使用时，主要是通过以下的四个方法来操作:
setAttribute(String name,Object o)方法，将数据作为request对象的一个属性存放到request对象中，例如：request.setAttribute("data", data);
getAttribute(String name)方法，获取request对象的name属性的属性值，例如：request.getAttribute("data")
removeAttribute(String name)方法，移除request对象的name属性，例如：request.removeAttribute("data")
getAttributeNames方法，获取request对象的所有属性名，返回的是一个，例如：Enumeration<String> attrNames = request.getAttributeNames();

请求重定向和请求转发的区别:
一个web资源收到客户端请求后，通知服务器去调用另外一个web资源进行处理，称之为请求转发/307。
一个web资源收到客户端请求后，通知浏览器去访问另外一个web资源进行处理，称之为请求重定向/302。

(十一)——使用Cookie进行会话管理
一、会话的概念
　　会话可简单理解为：用户开一个浏览器，点击多个超链接，访问服务器多个web资源，然后关闭浏览器，整个过程称之为一个会话。
　　有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学曾经来过，这称之为有状态会话。
二、会话过程中要解决的一些问题？
　　每个用户在使用浏览器与服务器进行会话的过程中，不可避免各自会产生一些数据，程序要想办法为每个用户保存这些数据。
三、保存会话数据的两种技术
3.1、Cookie
　　Cookie是客户端技术，程序把每个用户的数据以cookie的形式写给用户各自的浏览器。当用户使用浏览器再去访问服务器中的web资源时，就会带着各自的数据去。这样，web资源处理的就是用户各自的数据了。
3.2、Session
　　Session是服务器端技术，利用这个技术，服务器在运行时可以为每一个用户的浏览器创建一个其独享的session对象，由于session为用户浏览器独享，所以用户在访问服务器的web资源时，可以把各自的数据放在各自的session中，当用户再去访问服务器中的其它web资源时，其它web资源再从用户各自的session中取出数据为用户服务。
四、Java提供的操作Cookie的API
　　Java中的javax.servlet.http.Cookie类用于创建一个Cookie
Cookie类的主要方法
No. 方法类型描述
1 Cookie(String name, String value)
构造方法实例化Cookie对象，传入cooke名称和cookie的值
2 public String getName()
普通方法取得Cookie的名字
3 public String getValue()
普通方法取得Cookie的值
4 public void setValue(String newValue)
普通方法设置Cookie的值
5 public void setMaxAge(int expiry) 普通方法设置Cookie的最大保存时间，即cookie的有效期，当服务器给浏览器回送一个cookie时，如果在服务器端没有调用setMaxAge方法设置cookie的有效期，那么cookie的有效期只在一次会话过程中有效，用户开一个浏览器，点击多个超链接，访问服务器多个web资源，然后关闭浏览器，整个过程称之为一次会话，当用户关闭浏览器，会话就结束了，此时cookie就会失效，如果在服务器端使用setMaxAge方法设置了cookie的有效期，比如设置了30分钟，那么当服务器把cookie发送给浏览器时，此时cookie就会在客户端的硬盘上存储30分钟，在30分钟内，即使浏览器关了，cookie依然存在，在30分钟内，打开浏览器访问服务器时，浏览器都会把cookie一起带上，这样就可以在服务器端获取到客户端浏览器传递过来的cookie里面的信息了，这就是cookie设置maxAge和不设置maxAge的区别，不设置maxAge，那么cookie就只在一次会话中有效，一旦用户关闭了浏览器，那么cookie就没有了，那么浏览器是怎么做到这一点的呢，我们启动一个浏览器，就相当于启动一个应用程序，而服务器回送的cookie首先是存在浏览器的缓存中的，当浏览器关闭时，浏览器的缓存自然就没有了，所以存储在缓存中的cookie自然就被清掉了，而如果设置了cookie的有效期，那么浏览器在关闭时，就会把缓存中的cookie写到硬盘上存储起来，这样cookie就能够一直存在了。
6 public int getMaxAge() 普通方法获取Cookies的有效期
7 public void setPath(String uri)
普通方法设置cookie的有效路径，比如把cookie的有效路径设置为"/xdp"，那么浏览器访问"xdp"目录下的web资源时，都会带上cookie，再比如把cookie的有效路径设置为"/xdp/gacl"，那么浏览器只有在访问"xdp"目录下的"gacl"这个目录里面的web资源时才会带上cookie一起访问，而当访问"xdp"目录下的web资源时，浏览器是不带cookie的
8 public String getPath()
普通方法获取cookie的有效路径
9 public void setDomain(String pattern)
普通方法设置cookie的有效域
10 public String getDomain() 普通方法获取cookie的有效域
　　response接口也中定义了一个addCookie方法，它用于在其响应头中增加一个相应的Set-Cookie头字段。同样，request接口中也定义了一个getCookies方法，它用于获取客户端提交的Cookie。

五、Cookie使用范例
5.1、使用cookie记录用户上一次访问的时间
package gac.xdp.cookie;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* cookie实例：获取用户上一次访问的时间
*/
public class CookieDemo01 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//设置服务器端以UTF-8编码进行输出
response.setCharacterEncoding("UTF-8");
//设置浏览器以UTF-8编码进行接收,解决中文乱码问题
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
//获取浏览器访问访问服务器时传递过来的cookie数组
Cookie[] cookies = request.getCookies();
//如果用户是第一次访问，那么得到的cookies将是null
if (cookies!=null) {
out.write("您上次访问的时间是：");
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
if (cookie.getName().equals("lastAccessTime")) {
Long lastAccessTime =Long.parseLong(cookie.getValue());
Date date = new Date(lastAccessTime);
out.write(date.toLocaleString());
}
}
} else {
out.write("这是您第一次访问本站！");
}

//用户访问过之后重新设置用户的访问时间，存储到cookie中，然后发送到客户端浏览器
Cookie cookie = new Cookie("lastAccessTime", System.currentTimeMillis()+"");//创建一个cookie，cookie的名字是lastAccessTime
//将cookie对象添加到response对象中，这样服务器在输出response对象中的内容时就会把cookie也输出到客户端浏览器
response.addCookie(cookie);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
第一次访问时这个Servlet时，效果如下所示：

点击浏览器的刷新按钮，进行第二次访问，此时就服务器就可以通过cookie获取浏览器上一次访问的时间了，效果如下：

　　在上面的例子中，在程序代码中并没有使用setMaxAge方法设置cookie的有效期，所以当关闭浏览器之后，cookie就失效了，要想在关闭了浏览器之后，cookie依然有效，那么在创建cookie时，就要为cookie设置一个有效期。如下所示：
//用户访问过之后重新设置用户的访问时间，存储到cookie中，然后发送到客户端浏览器
Cookie cookie = new Cookie("lastAccessTime", System.currentTimeMillis()+"");//创建一个cookie，cookie的名字是lastAccessTime
//设置Cookie的有效期为1天
cookie.setMaxAge(24*60*60);
//将cookie对象添加到response对象中，这样服务器在输出response对象中的内容时就会把cookie也输出到客户端浏览器
response.addCookie(cookie);
　　

用户第一次访问时，服务器发送给浏览器的cookie就存储到了硬盘上，如下所示：

　　这样即使关闭了浏览器，下次再访问时，也依然可以通过cookie获取用户上一次访问的时间。

六、Cookie注意细节
一个Cookie只能标识一种信息，它至少含有一个标识该信息的名称（NAME）和设置值（VALUE）。
一个WEB站点可以给一个WEB浏览器发送多个Cookie，一个WEB浏览器也可以存储多个WEB站点提供的Cookie。
浏览器一般只允许存放300个Cookie，每个站点最多存放20个Cookie，每个Cookie的大小限制为4KB。
如果创建了一个cookie，并将他发送到浏览器，默认情况下它是一个会话级别的cookie（即存储在浏览器的内存中），用户退出浏览器之后即被删除。若希望浏览器将该cookie存储在磁盘上，则需要使用maxAge，并给出一个以秒为单位的时间。将最大时效设为0则是命令浏览器删除该cookie。
6.1、删除Cookie
注意：删除cookie时，path必须一致，否则不会删除
package gac.xdp.cookie;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 删除cookie
*/
public class CookieDemo02 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//创建一个名字为lastAccessTime的cookie
Cookie cookie = new Cookie("lastAccessTime", System.currentTimeMillis()+"");
//将cookie的有效期设置为0，命令浏览器删除该cookie
cookie.setMaxAge(0);
response.addCookie(cookie);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
6.2、cookie中存取中文
　　要想在cookie中存储中文，那么必须使用URLEncoder类里面的encode(String s, String enc)方法进行中文转码，例如：
Cookie cookie = new Cookie("userName", URLEncoder.encode("孤傲苍狼", "UTF-8"));
response.addCookie(cookie);
　　在获取cookie中的中文数据时，再使用URLDecoder类里面的decode(String s, String enc)进行解码，例如：
URLDecoder.decode(cookies[i].getValue(), "UTF-8")

(十二)——Session
一、Session简单介绍
　　在WEB开发中，服务器可以为每个用户浏览器创建一个会话对象（session对象），注意：一个浏览器独占一个session对象(默认情况下)。因此，在需要保存用户数据时，服务器程序可以把用户数据写到用户浏览器独占的session中，当用户使用浏览器访问其它程序时，其它程序可以从用户的session中取出该用户的数据，为用户服务。
二、Session和Cookie的主要区别
Cookie是把用户的数据写给用户的浏览器。
Session技术把用户的数据写到用户独占的session中。
Session对象由服务器创建，开发人员可以调用request对象的getSession方法得到session对象。
三、session实现原理
3.1、服务器是如何实现一个session为一个用户浏览器服务的？
　　服务器创建session出来后，会把session的id号，以cookie的形式回写给客户机，这样，只要客户机的浏览器不关，再去访问服务器时，都会带着session的id号去，服务器发现客户机浏览器带session id过来了，就会使用内存中与之对应的session为之服务。可以用如下的代码证明：
package xdp.gacl.session;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class SessionDemo1 extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setCharacterEncoding("UTF=8");
response.setContentType("text/html;charset=UTF-8");
//使用request对象的getSession()获取session，如果session不存在则创建一个
HttpSession session = request.getSession();
//将数据存储到session中
session.setAttribute("data", "孤傲苍狼");
//获取session的Id
String sessionId = session.getId();
//判断session是不是新创建的
if (session.isNew()) {
response.getWriter().print("session创建成功，session的id是："+sessionId);
}else {
response.getWriter().print("服务器已经存在该session了，session的id是："+sessionId);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
　　第一次访问时，服务器会创建一个新的sesion，并且把session的Id以cookie的形式发送给客户端浏览器，如下图所示：

点击刷新按钮，再次请求服务器，此时就可以看到浏览器再请求服务器时，会把存储到cookie中的session的Id一起传递到服务器端了，如下图所示：

我猜想request.getSession()方法内部新创建了Session之后一定是做了如下的处理
//获取session的Id
String sessionId = session.getId();
//将session的Id存储到名字为JSESSIONID的cookie中
Cookie cookie = new Cookie("JSESSIONID", sessionId);
//设置cookie的有效路径
cookie.setPath(request.getContextPath());
response.addCookie(cookie);

四、浏览器禁用Cookie后的session处理
4.1、IE8禁用cookie
工具->internet选项->隐私->设置->将滑轴拉到最顶上（阻止所有cookies）

4.2、解决方案：URL重写
response.encodeRedirectURL(java.lang.String url) 用于对sendRedirect方法后的url地址进行重写。
response.encodeURL(java.lang.String url)用于对表单action和超链接的url地址进行重写
4.3、范例：禁用Cookie后servlet共享Session中的数据, 没懂

/******************************** IndexServlet ********************************/
package xdp.gacl.session;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//首页：列出所有书
public class IndexServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
//创建Session
request.getSession();
out.write("本网站有如下书：<br/>");
Set<Map.Entry<String,Book>> set = DB.getAll().entrySet();
for(Map.Entry<String,Book> me : set){
Book book = me.getValue();
String url =request.getContextPath()+ "/servlet/BuyServlet?id=" + book.getId();
//response. encodeURL(java.lang.String url)用于对表单action和超链接的url地址进行重写
url = response.encodeURL(url);//将超链接的url地址进行重写
out.println(book.getName() + " <a href=http://www.mamicode.com/‘"+url+"‘>购买</a><br/>");
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
/**
* @author gacl
* 模拟数据库
*/
class DB{
private static Map<String,Book> map = new LinkedHashMap<String,Book>();
static{
map.put("1", new Book("1","javaweb开发"));
map.put("2", new Book("2","spring开发"));
map.put("3", new Book("3","hibernate开发"));
map.put("4", new Book("4","struts开发"));
map.put("5", new Book("5","ajax开发"));
}

public static Map<String,Book> getAll(){
return map;
}
}
class Book{

private String id;
private String name;
public Book() {
super();
}
public Book(String id, String name) {
super();
this.id = id;
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

/******************************** BuyServlet ********************************/
package xdp.gacl.session;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class BuyServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String id = request.getParameter("id");
Book book = DB.getAll().get(id); //得到用户想买的书
HttpSession session = request.getSession();
List<Book> list = (List) session.getAttribute("list"); //得到用户用于保存所有书的容器
if(list==null){
list = new ArrayList<Book>();
session.setAttribute("list", list);
}
list.add(book);
//response. encodeRedirectURL(java.lang.String url)用于对sendRedirect方法后的url地址进行重写
String url = response.encodeRedirectURL(request.getContextPath()+"/servlet/ListCartServlet");
System.out.println(url);
response.sendRedirect(url);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}

/******************************** ListCartServlet ********************************/
package xdp.gacl.session;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class ListCartServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
HttpSession session = request.getSession();
List<Book> list = (List) session.getAttribute("list");
if(list==null || list.size()==0){
out.write("对不起，您还没有购买任何商品!!");
return;
}

//显示用户买过的商品
out.write("您买过如下商品:<br>");
for(Book book : list){
out.write(book.getName() + "<br/>");
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
在禁用了cookie的IE8下的运行效果如下：(http://www.cnblogs.com/xdp-gacl/p/3855702.html)

通过查看IndexServlet生成的html代码可以看到，每一个超链接后面都带上了session的Id，如下所示
本网站有如下书：<br/>javaweb开发 <a href=http://www.mamicode.com/‘/JavaWeb_Session_Study_20140720/servlet/BuyServlet;jsessionid=96BDFB9D87A08D5AB1EAA2537CDE2DB2?id=1‘>购买

spring开发 <a href=http://www.mamicode.com/‘/JavaWeb_Session_Study_20140720/servlet/BuyServlet;jsessionid=96BDFB9D87A08D5AB1EAA2537CDE2DB2?id=2‘>购买

hibernate开发 <a href=http://www.mamicode.com/‘/JavaWeb_Session_Study_20140720/servlet/BuyServlet;jsessionid=96BDFB9D87A08D5AB1EAA2537CDE2DB2?id=3‘>购买

struts开发 <a href=http://www.mamicode.com/‘/JavaWeb_Session_Study_20140720/servlet/BuyServlet;jsessionid=96BDFB9D87A08D5AB1EAA2537CDE2DB2?id=4‘>购买

ajax开发 <a href=http://www.mamicode.com/‘/JavaWeb_Session_Study_20140720/servlet/BuyServlet;jsessionid=96BDFB9D87A08D5AB1EAA2537CDE2DB2?id=5‘>购买

所以，当浏览器禁用了cookie后，就可以用URL重写这种解决方案解决Session数据共享问题。而且response. encodeRedirectURL(java.lang.String url) 和response. encodeURL(java.lang.String url)是两个非常智能的方法，当检测到浏览器没有禁用cookie时，那么就不进行URL重写了。我们在没有禁用cookie的火狐浏览器下访问，效果如下： (http://www.cnblogs.com/xdp-gacl/p/3855702.html)

从演示动画中可以看到，浏览器第一次访问时，服务器创建Session，然后将Session的Id以Cookie的形式发送回给浏览器，response. encodeURL(java.lang.String url)方法也将URL进行了重写，当点击刷新按钮第二次访问，由于火狐浏览器没有禁用cookie，所以第二次访问时带上了cookie，此时服务器就可以知道当前的客户端浏览器并没有禁用cookie，那么就通知response. encodeURL(java.lang.String url)方法不用将URL进行重写了。

五、session对象的创建和销毁时机
5.1、session对象的创建时机
在程序中第一次调用request.getSession()方法时就会创建一个新的Session，可以用isNew()方法来判断Session是不是新创建的
范例：创建session
//使用request对象的getSession()获取session，如果session不存在则创建一个
HttpSession session = request.getSession();
//获取session的Id
String sessionId = session.getId();
//判断session是不是新创建的
if (session.isNew()) {
response.getWriter().print("session创建成功，session的id是："+sessionId);
}else {
response.getWriter().print("服务器已经存在session，session的id是："+sessionId);
}
5.2、session对象的销毁时机
session对象默认30分钟没有使用，则服务器会自动销毁session，在web.xml文件中可以手工配置session的失效时间，例如：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name></display-name>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

<session-config>
<session-timeout>15</session-timeout>
</session-config>
</web-app>
当需要在程序中手动设置Session失效时，可以手工调用session.invalidate方法，摧毁session。
HttpSession session = request.getSession();
//手工调用session.invalidate方法，摧毁session
session.invalidate();

(十三)——使用Session防止表单重复提交

在平时开发中，如果网速比较慢的情况下，用户提交表单后，发现服务器半天都没有响应，那么用户可能会以为是自己没有提交表单，就会再点击提交按钮重复提交表单，我们在开发中必须防止表单重复提交。
一、表单重复提交的常见应用场景
有如下的form.jsp页面
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>Form表单</title>
</head>

<body>
<form action="${pageContext.request.contextPath}/servlet/DoFormServlet" method="post">
用户名：<input type="text" name="username">
<input type="submit" value="http://www.mamicode.com/提交" id="submit">
</form>
</body>
</html>

package xdp.gacl.session;

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 DoFormServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//客户端是以UTF-8编码传输数据到服务器端的，所以需要设置服务器端以UTF-8的编码进行接收，否则对于中文数据就会产生乱码
request.setCharacterEncoding("UTF-8");
String userName = request.getParameter("username");
try {
//让当前的线程睡眠3秒钟，模拟网络延迟而导致表单重复提交的现象
Thread.sleep(3*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("向数据库中插入数据："+userName);
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}

}

如果没有进行form表单重复提交处理，那么在网络延迟的情况下下面的操作将会导致form表单重复提交多次
场景一：在网络延迟的情况下让用户有时间点击多次submit按钮导致表单重复提交
场景二：表单提交后用户点击【刷新】按钮导致表单重复提交
点击浏览器的刷新按钮，就是把浏览器上次做的事情再做一次，因为这样也会导致表单重复提交。
场景三：用户提交表单后，点击浏览器的【后退】按钮回退到表单页面后进行再次提交

二、利用JavaScript防止表单重复提交
采用JavaScript来防止表单重复提交，具体做法如下：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>Form表单</title>
<script type="text/javascript">
var isCommitted = false;//表单是否已经提交标识，默认为false
function dosubmit(){
if(isCommitted==false){
isCommitted = true;//提交表单后，将表单是否已经提交标识设置为true
return true;//返回true让表单正常提交
}else{
return false;//返回false那么表单将不提交
}
}
</script>
</head>

<body>
<form action="${pageContext.request.contextPath}/servlet/DoFormServlet" onsubmit="return dosubmit()" method="post">
用户名：<input type="text" name="username">
<input type="submit" value="http://www.mamicode.com/提交" id="submit">
</form>
</body>
</html>
除了用这种方式之外，经常见的另一种方式就是表单提交之后，将提交按钮设置为不可用，让用户没有机会点击第二次提交按钮，代码如下：
function dosubmit(){
//获取表单提交按钮
var btnSubmit = document.getElementById("submit");
//将表单提交按钮设置为不可用，这样就可以避免用户再次点击提交按钮
btnSubmit.disabled= "disabled";
//返回true让表单可以正常提交
return true;
}
另外还有一种做法就是提交表单后，将提交按钮隐藏起来，这种做法和将提交按钮设置为不可用是差不多的，可能会让用户误以为是bug

三、利用Session防止表单重复提交

对于[ 场景二 ]和[ 场景三 ]导致表单重复提交的问题，既然客户端无法解决，那么就在服务器端解决，在服务器端解决就需要用到session了。

具体的做法：在服务器端生成一个唯一的随机标识号，专业术语称为Token(令牌)，同时在当前用户的Session域中保存这个Token。然后将Token发送到客户端的Form表单中，在Form表单中使用隐藏域来存储这个Token，表单提交的时候连同这个Token一起提交到服务器端，然后在服务器端判断客户端提交上来的Token与服务器端生成的Token是否一致，如果不一致，那就是重复提交了，此时服务器端就可以不处理重复提交的表单。如果相同则处理表单提交，处理完后清除当前用户的Session域中存储的标识号。
在下列情况下，服务器程序将拒绝处理用户提交的表单请求：

存储Session域中的Token(令牌)与表单提交的Token(令牌)不同。
当前用户的Session中不存在Token(令牌)。
用户提交的表单数据中没有Token(令牌)。
看具体的范例：
1.创建FormServlet，用于生成Token(令牌)和跳转到form.jsp页面

package xdp.gacl.session;

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 FormServlet extends HttpServlet {
private static final long serialVersionUID = -884689940866074733L;

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String token = TokenProccessor.getInstance().makeToken();//创建令牌
System.out.println("在FormServlet中生成的token："+token);
request.getSession().setAttribute("token", token); //在服务器使用session保存token(令牌)
request.getRequestDispatcher("/form.jsp").forward(request, response);//跳转到form.jsp页面
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}

}
2.在form.jsp中使用隐藏域来存储Token(令牌)

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>form表单</title>
</head>

<title>First Jsp</title>

</head>

当我们通过浏览器访问index.jsp时，服务器首先将index.jsp翻译成一个index_jsp.class，在Tomcat服务器的work\Catalina\localhost\项目名\org\apache\jsp目录下可以看到index_jsp.class的源代码文件index_jsp.java，index_jsp.java的代码如下：

package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;
public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
private static java.util.List _jspx_dependants;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.AnnotationProcessor _jsp_annotationprocessor;
public Object getDependants() {
return _jspx_dependants;
}
public void _jspInit() {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());
}
public void _jspDestroy() {
}
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;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write(‘\r‘);
out.write(‘\n‘);
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
out.write("\r\n");
out.write("\r\n");
out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
out.write("<html>\r\n");
out.write(" <head>\r\n");
out.write(" <base href=http://www.mamicode.com/"");
out.print(basePath);
out.write("\">\r\n");
out.write(" \r\n");
out.write(" <title>First Jsp</title>\r\n");
out.write("\t\r\n");
out.write(" </head>\r\n");
out.write(" \r\n");
out.write(" <body>\r\n");
out.write(" ");
out.print("Hello Jsp");

out.write("\r\n");
out.write(" </body>\r\n");
out.write("</html>\r\n");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)) {
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try {
out.clearBuffer();
} catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
}
}
finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}

我们可以看到，index_jsp这个类是继承 org.apache.jasper.runtime.HttpJspBase这个类的，通过查看Tomcat服务器的源代码，可以知道在apache-tomcat-6.0.20-src\java\org\apache\jasper\runtime目录下存HttpJspBase这个类的源代码文件，如下图所示：

我们可以看看HttpJsBase这个类的源代码，如下所示：

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jasper.runtime;
import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.HttpJspPage;
import javax.servlet.jsp.JspFactory;
import org.apache.jasper.compiler.Localizer;
/**
* This is the super class of all JSP-generated servlets.
*
* @author Anil K. Vijendran
*/
public abstract class HttpJspBase
extends HttpServlet
implements HttpJspPage

{

protected HttpJspBase() {
}
public final void init(ServletConfig config)
throws ServletException {
super.init(config);
jspInit();
_jspInit();
}

public String getServletInfo() {
return Localizer.getMessage("jsp.engine.info");
}
public final void destroy() {
jspDestroy();
_jspDestroy();
}
/**
* Entry point into service.
*/
public final void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
_jspService(request, response);
}

public void jspInit() {
}
public void _jspInit() {
}
public void jspDestroy() {
}
protected void _jspDestroy() {
}
public abstract void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException;
}

HttpJspBase类是继承HttpServlet的，所以HttpJspBase类是一个Servlet，而index_jsp又是继承HttpJspBase类的，所以index_jsp类也是一个Servlet，所以当浏览器访问服务器上的index.jsp页面时，其实就是在访问index_jsp这个Servlet，index_jsp这个Servlet使用_jspService这个方法处理请求。
2.2、Jsp页面中的html排版标签是如何被发送到客户端的？
浏览器接收到的这些数据

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="http://localhost:8080/JavaWeb_Jsp_Study_20140603/">

<title>First Jsp</title>

</head>

<body>
Hello Jsp
</body>
</html>

都是在_jspService方法中使用如下的代码输出给浏览器的：

out.write(‘\r‘);
out.write(‘\n‘);
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
out.write("\r\n");
out.write("\r\n");
out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
out.write("<html>\r\n");
out.write(" <head>\r\n");
out.write(" <base href=http://www.mamicode.com/"");
out.print(basePath);
out.write("\">\r\n");
out.write(" \r\n");
out.write(" <title>First Jsp</title>\r\n");
out.write("\t\r\n");
out.write(" </head>\r\n");
out.write(" \r\n");
out.write(" <body>\r\n");
out.write(" ");
out.print("Hello Jsp");

out.write("\r\n");
out.write(" </body>\r\n");
out.write("</html>\r\n");

在jsp中编写的java代码和html代码都会被翻译到_jspService方法中去，在jsp中编写的java代码会原封不动地翻译成java代码，如<%out.print("Hello Jsp");%>直接翻译成out.print("Hello Jsp");
，而HTML代码则会翻译成使用out.write("<html标签>\r\n");
的形式输出到浏览器。在jsp页面中编写的html排版标签都是以out.write("<html标签>\r\n");
的形式输出到浏览器，浏览器拿到html代码后才能够解析执行html代码。
2.3、Jsp页面中的java代码服务器是如何执行的？
在jsp中编写的java代码会被翻译到_jspService方法中去，当执行_jspService方法处理请求时，就会执行在jsp编写的java代码了，所以Jsp页面中的java代码服务器是通过调用_jspService方法处理请求时执行的。
2.4、Web服务器在调用jsp时，会给jsp提供一些什么java对象？
查看_jspService方法可以看到，Web服务器在调用jsp时，会给Jsp提供如下的8个java对象

PageContext pageContext;
HttpSession session;
ServletContext application;
ServletConfig config;
JspWriter out;
Object page = this;
HttpServletRequest request,
HttpServletResponse response
其中page对象，request和response已经完成了实例化，而其它5个没有实例化的对象通过下面的方式实例化
pageContext = _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
这8个java对象在Jsp页面中是可以直接使用的，如下所示：

<%
session.setAttribute("name", "session对象");//使用session对象,设置session对象的属性
out.print(session.getAttribute("name")+"<br/>");//获取session对象的属性
pageContext.setAttribute("name", "pageContext对象");//使用pageContext对象,设置pageContext对象的属性
out.print(pageContext.getAttribute("name")+"<br/>");//获取pageContext对象的属性
application.setAttribute("name", "application对象");//使用application对象,设置application对象的属性
out.print(application.getAttribute("name")+"<br/>");//获取application对象的属性
out.print("Hello Jsp"+"<br/>");//使用out对象
out.print("服务器调用index.jsp页面时翻译成的类的名字是："+page.getClass()+"<br/>");//使用page对象
out.print("处理请求的Servlet的名字是："+config.getServletName()+"<br/>");//使用config对象
out.print(response.getContentType()+"<br/>");//使用response对象
out.print(request.getContextPath()+"<br/>");//使用request对象
%>

运行结果如下：

2.5、Jsp最佳实践
Jsp最佳实践就是jsp技术在开发中该怎么去用。
不管是JSP还是Servlet，虽然都可以用于开发动态web资源。但由于这2门技术各自的特点，在长期的软件实践中，人们逐渐把servlet作为web应用中的控制器组件来使用，而把JSP技术作为数据显示模板来使用。其原因为，程序的数据通常要美化后再输出：让jsp既用java代码产生动态数据，又做美化会导致页面难以维护。让servlet既产生数据，又在里面嵌套html代码美化数据，同样也会导致程序可读性差，难以维护。因此最好的办法就是根据这两门技术的特点，让它们各自负责各的，servlet只负责响应请求产生数据，并把数据通过转发技术带给jsp，数据的显示jsp来做。
2.6、Tomcat服务器的执行流程

第一次执行：
客户端通过电脑连接服务器，因为是请求是动态的，所以所有的请求交给WEB容器来处理
在容器中找到需要执行的*.jsp文件
之后*.jsp文件通过转换变为*.java文件
*.java文件经过编译后，形成*.class文件
最终服务器要执行形成的*.class文件
第二次执行：
因为已经存在了*.class文件，所以不在需要转换和编译的过程
修改后执行：
1.源文件已经被修改过了，所以需要重新转换，重新编译。

(十五)——JSP基础语法
任何语言都有自己的语法，JAVA中有，JSP虽然是在JAVA上的一种应用，但是依然有其自己扩充的语法，而且在JSP中，所有的JAVA语句都可以使用。
一、JSP模版元素
JSP页面中的HTML内容称之为JSP模版元素。
JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。
二、JSP表达式
JSP脚本表达式（expression）用于将程序数据输出到客户端
语法：<%= 变量或表达式 %>
举例：输出当前系统时间:
<%= new java.util.Date() %>
JSP引擎在翻译脚本表达式时，会将程序数据转成字符串，然后在相应位置用out.print(…) 将数据输给客户端。
JSP脚本表达式中的变量或表达式后面不能有分号（;）。
三、JSP脚本片断
JSP脚本片断(scriptlet)用于在JSP页面中编写多行Java代码。语法：
<%
多行java代码
%>
在<% %>中可以定义变量、编写语句，不能定义方法。
范例：在Scriptlet中定义变量、编写语句

<%
int sum=0;//声明变量
/*编写语句*/
for (int i=1; i<=100; i++) {
sum+=i;
}
out.println("<h1>Sum="+sum+"</h1>");
%>

注意事项：
JSP脚本片断中只能出现java代码，不能出现其它模板元素， JSP引擎在翻译JSP页面中，会将JSP脚本片断中的Java代码将被原封不动地放到Servlet的_jspService方法中。
JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每执行语句后面必须用分号（;）结束。
在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。
举例：

<%
int x = 10;
out.println(x);
%>
<p>这是JSP页面文本</p>
<%
int y = 20;
out.println(y);
%>

多个脚本片断中的代码可以相互访问，犹如将所有的代码放在一对<%%>之中的情况。如：out.println(x);
单个脚本片断中的Java语句可以是不完整的，但是，多个脚本片断组合后的结果必须是完整的Java语句，例如：

<%
for (int i=1; i<5; i++) {
%>
<H1>http://localhost:8080/JavaWeb_Jsp_Study_20140603/</H1>
<%
}
%>

四、JSP声明
JSP页面中编写的所有代码，默认会翻译到servlet的service方法中，而Jsp声明中的java代码被翻译到_jspService方法的外面。语法：
<%！
java代码
%>
所以，JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法。
多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP声明中。
JSP隐式对象的作用范围仅限于Servlet的_jspService方法，所以在JSP声明中不能使用这些隐式对象。
JSP声明案例：

<%!
static {
System.out.println("loading Servlet!");
}
private int globalVar = 0;
public void jspInit() {
System.out.println("initializing jsp!");
}
%>
<%!
public void jspDestroy() {
System.out.println("destroying jsp!");
}
%>

五、JSP注释
在JSP中，注释有两大类：
显式注释：直接使用HTML风格的注释：<!- - 注释内容- ->
隐式注释：直接使用JAVA的注释：//、/*……*/
　JSP自己的注释：<%-- 注释内容--%>
这三种注释的区别

<%
//JAVA中的单行注释
/*
JAVA中的多行注释
*/
%>
<%--JSP自己的注释--%>

HTML的注释在浏览器中查看源文件的时候是可以看得到的，而JAVA注释和JSP注释在浏览器中查看源文件时是看不到注释的内容的，这就是这三种注释的区别。

(十六)——JSP指令
一、JSP指令简介
JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。
在JSP 2.0规范中共定义了三个指令：
page指令
Include指令
taglib指令
JSP指令的基本语法格式：<%@ 指令属性名="值" %>
例如：
<%@ page contentType="text/html;charset=gb2312"%>
如果一个指令有多个属性，这多个属性可以写在一个指令中，也可以分开写。
例如：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date"%>
也可以写作：
<%@ page contentType="text/html;charset=gb2312" import="java.util.Date"%>
二、Page指令
page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置。例如：

JSP 2.0规范中定义的page指令的完整语法：

<%@ page
[ language="java" ]
[ extends="package.class" ]
[ import="{package.class | package.*}, ..." ]
[ session="true | false" ]
[ buffer="none | 8kb | sizekb" ]
[ autoFlush="true | false" ]
[ isThreadSafe="true | false" ]
[ info="text" ]
[ errorPage="relative_url" ]
[ isErrorPage="true | false" ]
[ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]
[ pageEncoding="characterSet | ISO-8859-1" ]
[ isELIgnored="true | false" ]
%>

2.1、page指令的import属性
在Jsp页面中，Jsp引擎会自动导入下面的包
java.lang.*
javax.servlet.*
javax.servlet.jsp.*
javax.servlet.http.*
可以在一条page指令的import属性中引入多个类或包，其中的每个包或类之间使用逗号(,)分隔
例如：
<%@ page import="java.util.*,java.io.*,java.sql.*"%>
上面的语句也可以改写为使用多条page指令的import属性来分别引入各个包或类
例如：
<%@ page import="java.util.Date"%>
<%@ page import="java.io.*" %>
<%@ page import="java.sql.*" %>
2.2、page指令的errorPage属性
errorPage属性的设置值必须使用相对路径，如果以“/”开头，表示相对于当前Web应用程序的根目录(注意不是站点根目录)，否则，表示相对于当前页面
可以在web.xml文件中使用<error-page>元素为整个Web应用程序设置错误处理页面。
<error-page>元素有3个子元素，<error-code>、<exception-type>、<location>
<error-code>子元素指定错误的状态码，例如：<error-code>404</error-code>
<exception-type>子元素指定异常类的完全限定名，例如：<exception-type>java.lang.ArithmeticException</exception-type>
<location>子元素指定以“/”开头的错误处理页面的路径，例如：<location>/ErrorPage/404Error.jsp</location>
如果设置了某个JSP页面的errorPage属性，那么在web.xml文件中设置的错误处理将不对该页面起作用。
2.3、使用errorPage属性指明出错后跳转的错误页面
比如Test.jsp页面有如下的代码：

<%@ page language="java" import="java.util.*" errorPage="/ErrorPage/error.jsp" pageEncoding="UTF-8"%>
<html>
<head>
<title>测试page指令的errorPage属性</title>
</head>
<body>
<%
//这行代码肯定会出错，因为除数是0，一运行就会抛出异常
int x = 1/0;
%>
</body>
</html>

在Test.jsp中，page指令的errorPage属性指明了出错后跳转到"/ErrorPage/error.jsp"，error.jsp页面代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>错误信息友好提示页面</title>
</head>
<body>
对不起，出错了，请联系管理员解决！
</body>
</html>

运行结果如下：

2.4、在web.xml中使用<error-page>标签为整个web应用设置错误处理页面
例如：使用<error-page>标签配置针对404错误的处理页面
web.xml的代码下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<display-name></display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>


<error-page>
<error-code>404</error-code>
<location>/ErrorPage/404Error.jsp</location>
</error-page>

</web-app>

404Error.jsp代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>404错误友好提示页面</title>

<meta http-equiv="refresh" content="3;url=${pageContext.request.contextPath}/index.jsp">
</head>
<body>
<img alt="对不起，你要访问的页面没有找到，请联系管理员处理!"
src="http://www.mamicode.com/${pageContext.request.contextPath}/img/404Error.png"/><br/>
3秒钟后自动跳转回首页，如果没有跳转，请点击<a href="http://www.mamicode.com/${pageContext.request.contextPath}/index.jsp">这里</a>
</body>
</html>

当访问一个不存在的web资源时，就会跳转到在web.xml中配置的404错误处理页面404Error.jsp，如下图所示：

2.5、关于在web.xml中使用<error-page>标签为整个web应用设置错误处理页面在IE下无法跳转的解决办法
这里需要注意的是，如果错误页面比较小，那么当访问服务器上不存在的web资源或者访问服务器出错时在IE浏览器下是无法跳转到错误页面的，显示的是ie自己的错误页面，而在火狐和google浏览器下(其他浏览器没有测试过)是不存在注意的问题的。
我们可以通过下面的实验来证明
在web.xml中配置500错误时的错误友好提示页面

<error-page>
<error-code>500</error-code>
<location>/ErrorPage/500Error.jsp</location>
</error-page>
500Error.jsp页面的代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>500(服务器错误)错误友好提示页面</title>

<meta http-equiv="refresh" content="3;url=${pageContext.request.contextPath}/index.jsp">
</head>
<body>
<img alt="对不起，服务器出错!"
src="http://www.mamicode.com/${pageContext.request.contextPath}/img/500Error.png"/><br/>
3秒钟后自动跳转回首页，如果没有跳转，请点击<a href="http://www.mamicode.com/${pageContext.request.contextPath}/index.jsp">这里</a>
</body>
</html>

500Error.jsp页面的字节大小

在IE8浏览器下的运行结果：

在IE下访问Test.jsp出现500错误后，显示的是ie自己的错误页面，而不是我们定制的那个500错误页面，而在google和火狐下却是可以正常跳转到我们自己定制的那个500错误页面的，如下图所示：

很多人遇到这个问题，而解决这个问题的办法有两种：
1、修改IE浏览器的设置（不推荐）
操作步骤：在IE【工具】->【Internet选项】->【高级】中勾掉【显示友好http错误提示】

经过这样的设置之后，访问服务器出错后就可以直接跳转到我们定制的500错误页面了，如下图所示：

这种做法需要修改客户端浏览器的配置，不推荐这样的方式。
2.不修改IE浏览器的设置下确保定制的错误页面的大小>1024字节
修改500Error.jsp，多添加一些内容，让页面的字节数大一些，修改后的500Error.jsp的代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<html>
<head>
<title>500(服务器错误)错误友好提示页面</title>

<meta http-equiv="refresh" content="3;url=${pageContext.request.contextPath}/index.jsp">
</head>
<body>
<img alt="对不起，服务器出错了，请联系管理员解决！"
src="http://www.mamicode.com/${pageContext.request.contextPath}/img/500Error.png"/><br/>
3秒钟后自动跳转回首页，如果没有跳转，请点击<a href="http://www.mamicode.com/${pageContext.request.contextPath}/index.jsp">这里</a>
</body>
</html>

也就多加了几个中文，让500Error.jsp多了几个字节，500Error.jsp现在的字节数如下：

在IE下访问，当服务器出错时，就可以正常跳转到500Error.jsp这个定制的错误页面了，如下图所示：

经过测试，当定制的错误页面的size=617bytes时，在IE8下已经可以跳转到定制的错误页面了，其他版本的IE浏览器没有经过测试，不过为了保险起见，定制的错误页面的size最好超过1024bytes。
2.6、使用page指令的isErrorPage属性显式声明页面为错误页面
如果某一个jsp页面是作为系统的错误处理页面，那么建议将page指令的isErrorPage属性(默认为false)设置为"true"来显式声明这个Jsp页面是一个错误处理页面。
例如：将error.jsp页面显式声明为错误处理页面

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" isErrorPage="true"%>
<html>
<head>
<title>错误信息友好提示页面</title>
</head>

<body>
对不起，出错了，请联系管理员解决！
</body>
</html>

将error.jsp页面显式声明为错误处理页面后，有什么好处呢，好处就是Jsp引擎在将jsp页面翻译成Servlet的时候，在Servlet的 _jspService方法中会声明一个exception对象，然后将运行jsp出错的异常信息存储到exception对象中，如下所示：

由于Servlet的_jspService方法中声明了exception对象，那么就可以在error.jsp页面中使用exception对象，这样就可以在Jsp页面中拿到出错的异常信息了，如下：

如果没有设置isErrorPage="true"，那么在jsp页面中是无法使用exception对象的，因为在Servlet的_jspService方法中不会声明一个exception对象，如下所示：

Jsp有9大内置对象，而一般情况下exception对象在Jsp页面中是获取不到的，只有设置page指令的isErrorPage属性为"true"来显式声明Jsp页面是一个错误处理页面之后才能够在Jsp页面中使用exception对象。
三、include指令
在JSP中对于包含有两种语句形式：
@include指令
<jsp:include>指令
3.1、@include指令
@include可以包含任意的文件，当然，只是把文件的内容包含进来。
include指令用于引入其它JSP页面，如果使用include指令引入了其它JSP页面，那么JSP引擎将把这两个JSP翻译成一个servlet。所以include指令引入通常也称之为静态引入。
语法：<%@ include file="relativeURL"%>，其中的file属性用于指定被引入文件的路径。路径以“/”开头，表示代表当前web应用。
include指令细节注意问题：
被引入的文件必须遵循JSP语法。
被引入的文件可以使用任意的扩展名，即使其扩展名是html，JSP引擎也会按照处理jsp页面的方式处理它里面的内容，为了见明知意，JSP规范建议使用.jspf（JSP fragments(片段)）作为静态引入文件的扩展名。
由于使用include指令将会涉及到2个JSP页面，并会把2个JSP翻译成一个servlet，所以这2个JSP页面的指令不能冲突（除了pageEncoding和导包除外）。
include指令使用范例:
新建head.jspf页面和foot.jspf页面，分别作为jsp页面的头部和尾部，存放于WebRoot下的jspfragments文件夹中，代码如下：
head.jspf代码：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1 style="color:red;">网页头部</h1>
foot.jspf代码：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1 style="color:blue;">网页尾部</h1>
在WebRoot文件夹下创建一个IncludeTagTest.jsp页面，在IncludeTagTest.jsp页面中使用@include指令引入head.jspf页面和foot.jspf页面，代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>jsp的Include指令测试</title>
</head>

<body>
<%--使用include标签引入引入其它JSP页面--%>
<%@include file="/jspfragments/head.jspf" %>
<h1>网页主体内容</h1>
<%@include file="/jspfragments/foot.jspf" %>
</body>
</html>

运行结果如下：

我们查看一下jsp引擎将IncludeTagTest.jsp翻译成IncludeTagTest_jsp类之后的源代码，找到Tomcat服务器的work\Catalina\localhost\JavaWeb_Jsp_Study_20140603\org\apache\jsp目录下找到IncludeTagTest_jsp.java，如下图所示：

打开IncludeTagTest_jsp.java，里面的代码如下所示：

package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;
import java.util.*;
import java.util.*;
public final class IncludeTagTest_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
private static java.util.List _jspx_dependants;
static {
_jspx_dependants = new java.util.ArrayList(2);
_jspx_dependants.add("/jspfragments/head.jspf");
_jspx_dependants.add("/jspfragments/foot.jspf");
}
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.AnnotationProcessor _jsp_annotationprocessor;
public Object getDependants() {
return _jspx_dependants;
}
public void _jspInit() {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());
}
public void _jspDestroy() {
}
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;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\r\n");
out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");
out.write("<html>\r\n");
out.write(" <head>\r\n");
out.write(" \r\n");
out.write(" <title>jsp的Include指令测试</title>\r\n");
out.write(" \r\n");
out.write(" </head>\r\n");
out.write(" \r\n");
out.write(" <body>\r\n");
out.write(" ");
out.write("\r\n");
out.write("<h1 style=\"color:red;\">网页头部</h1>\r\n");
out.write("\r\n");
out.write(" <h1>网页主体内容</h1>\r\n");
out.write(" ");
out.write("\r\n");
out.write("<h1 style=\"color:blue;\">网页尾部</h1>\r\n");
out.write("\r\n");
out.write(" </body>\r\n");
out.write("</html>\r\n");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try { out.clearBuffer(); } catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}

可以看到，head.jspf和foot.jspf页面的内容都使用out.write输出到浏览器显示了。
3.2、总结@include指令
使用@include可以包含任意的内容，文件的后缀是什么都无所谓。这种把别的文件内容包含到自身页面的@include语句就叫作静态包含，作用只是把别的页面内容包含进来，属于静态包含。
3.3、jsp:include指令
jsp:include指令为动态包含，如果被包含的页面是JSP，则先处理之后再将结果包含，而如果包含的是非*.jsp文件，则只是把文件内容静态包含进来，功能与@include类似。后面再具体介绍

(十七)——JSP中的九个内置对象
一、JSP运行原理
每个JSP 页面在第一次被访问时，WEB容器都会把请求交给JSP引擎（即一个Java程序）去处理。JSP引擎先将JSP翻译成一个_jspServlet(实质上也是一个servlet) ，然后按照servlet的调用方式进行调用。
由于JSP第一次访问时会翻译成servlet，所以第一次访问通常会比较慢，但第二次访问，JSP引擎如果发现JSP没有变化，就不再翻译，而是直接调用，所以程序的执行效率不会受到影响。
JSP引擎在调用JSP对应的_jspServlet时，会传递或创建9个与web开发相关的对象供_jspServlet使用。JSP技术的设计者为便于开发人员在编写JSP页面时获得这些web对象的引用，特意定义了9个相应的变量，开发人员在JSP页面中通过这些变量就可以快速获得这9大对象的引用。
二、认识九个内置对象

NO. 内置对象类型
1 pageContext javax.servlet.jsp.PageContext
2 request javax.servlet.http.HttpServletRequest
3 response javax.servlet.http.HttpServletResponse
4 session javax.servlet.http.HttpSession
5 application javax.servlet.ServletContext
6 config javax.servlet.ServletConfig
7 out javax.servlet.jsp.JspWriter
8 page java.lang.Object
9 exception java.lang.Throwable

request，response，session，application，config这些对象在前面都已经作了详细的介绍，这里重点介绍一下剩下的pageContext对象，out对象，page对象。
三、内置对象使用说明
3.1、page对象
page对象表示当前一个JSP页面，可以理解为一个对象本身，即：把一个JSP当作一个对象来看待。page对象在开发中几乎不用，了解一下即可
3.2、out对象
out对象用于向客户端发送文本数据。
out对象是通过调用pageContext对象的getOut方法返回的，其作用和用法与ServletResponse.getWriter方法返回的PrintWriter对象非常相似。
JSP页面中的out对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PrintWriter，设置JSP页面的page指令的buffer属性可以调整它的缓存大小，甚至关闭它的缓存。
只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的PrintWriter对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：
设置page指令的buffer属性关闭了out对象的缓存功能
out对象的缓冲区已满
整个JSP页面结束
out对象的工作原理图

3.3、pageContext对象
pageContext对象是JSP技术中最重要的一个对象，它代表JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个域对象(容器)，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如引入和跳转其它资源、检索其它域对象中的属性等。
3.4、通过pageContext获得其他对象
getException方法返回exception隐式对象
getPage方法返回page隐式对象
getRequest方法返回request隐式对象
getResponse方法返回response隐式对象
getServletConfig方法返回config隐式对象
getServletContext方法返回application隐式对象
getSession方法返回session隐式对象
getOut方法返回out隐式对象
3.5、pageContext封装其它8大内置对象的意义
如果在编程过程中，把pageContext对象传递给一个普通java对象，那么这个java对象将可以获取8大隐式对象，此时这个java对象就可以和浏览器交互了，此时这个java对象就成为了一个动态web资源了，这就是pageContext封装其它8大内置对象的意义，把pageContext传递给谁，谁就能成为一个动态web资源，那么什么情况下需要把pageContext传递给另外一个java类呢，什么情况下需要使用这种技术呢，在比较正规的开发中，jsp页面是不允许出现java代码的，如果jsp页面出现了java代码，那么就应该想办法把java代码移除掉，我们可以开发一个自定义标签来移除jsp页面上的java代码，首先围绕自定义标签写一个java类，jsp引擎在执行自定义标签的时候就会调用围绕自定义标签写的那个java类，在调用java类的时候就会把pageContext对象传递给这个java类，由于pageContext对象封装了对其它8大隐式对象的引用，因此在这个java类中就可以使用jsp页面中的8大隐式对象(request，response，config，application，exception，Session，page，out)了，pageContext对象在jsp自定义标签开发中特别重要。
3.6、pageContext作为域对象
pageContext对象可以作为容器来使用，因此可以将一些数据存储在pageContext对象中。
pageContext对象的常用方法
public void setAttribute(java.lang.String name,java.lang.Object value)
public java.lang.Object getAttribute(java.lang.String name)
public void removeAttribute(java.lang.String name)
public java.lang.Object findAttribute(java.lang.String name)
重点介绍一下findAttribute方法，这个方法是用来查找各个域中的属性的，查看这个方法的API可以看到关于这个方法的描述：
Searches for the named attribute in page, request, session (if valid), and application scope(s) in order and returns the value associated or null.
当要查找某个属性时，findAttribute方法按照查找顺序"page→request→session→application"在这四个对象中去查找，只要找到了就返回属性值，如果四个对象都没有找到要查找的属性，则返回一个null。
范例：使用pageContext的findAttribute方法查找属性值

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<title>pageContext的findAttribute方法查找属性值</title>
</head>
<%
pageContext.setAttribute("name1", "孤傲苍狼");
request.setAttribute("name2", "白虎神皇");
session.setAttribute("name3", "玄天邪帝");
application.setAttribute("name4", "灭世魔尊");
%>
<%
//使用pageContext的findAttribute方法查找属性，由于取得的值为Object类型，因此必须使用String强制向下转型，转换成String类型
//查找name1属性，按照顺序"page→request→session→application"在这四个对象中去查找
String refName1 = (String)pageContext.findAttribute("name1");
String refName2 = (String)pageContext.findAttribute("name2");
String refName3 = (String)pageContext.findAttribute("name3");
String refName4 = (String)pageContext.findAttribute("name4");
String refName5 = (String)pageContext.findAttribute("name5");//查找一个不存在的属性
%>
<h1>pageContext.findAttribute方法查找到的属性值：</h1>
<h3>pageContext对象的name1属性：<%=refName1%></h3>
<h3>request对象的name2属性：<%=refName2%></h3>
<h3>session对象的name3属性：<%=refName3%></h3>
<h3>application对象的name4属性：<%=refName4%></h3>
<h3>查找不存在的name5属性：<%=refName5%></h3>
<hr/>
<h1>使用EL表达式进行输出：</h1>
<h3>pageContext对象的name1属性：${name1}</h3>
<h3>request对象的name2属性：${name2}</h3>
<h3>session对象的name3属性：${name3}</h3>
<h3>application对象的name4属性：${name4}</h3>
<h3>不存在的name5属性：${name5}</h3>

运行结果：

EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、 session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
pageContext对象中封装了访问其它域的方法
public java.lang.Object getAttribute(java.lang.String name,int scope)
public void setAttribute(java.lang.String name, java.lang.Object value,int scope)
public void removeAttribute(java.lang.String name,int scope)
代表各个域的常量
PageContext.APPLICATION_SCOPE
PageContext.SESSION_SCOPE
PageContext.REQUEST_SCOPE
PageContext.PAGE_SCOPE
范例：pageContext访问其它域

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<title>pageContext访问其它域</title>
</head>
<%
//此时相当于往session对象中存放了一个name属性，等价于 session.setAttribute("name","孤傲苍狼");
pageContext.setAttribute("name","孤傲苍狼",PageContext.SESSION_SCOPE);
%>
<%
//取得session对象的属性，使用pageContext对象获取
String refName1 = (String)pageContext.getAttribute("name",PageContext.SESSION_SCOPE);
//由于取得的值为Object类型，因此必须使用String强制向下转型，转换成String类型
String refName2 = (String)session.getAttribute("name");
%>
<h1>取出存放在session对象中的属性值：</h1>
<p>第一种做法：使用pageContext.getAttribute("attributeName",PageContext.SESSION_SCOPE);去取出session对象中值</p>
<h3>姓名：<%=refName1%></h3>
<p>第二种做法：使用session.getAttribute("attributeName");去取出session对象中值</p>
<h3>姓名：<%=refName2%></h3>

3.7、PageContext引入和跳转到其他资源
PageContext类中定义了一个forward方法(用来跳转页面)和两个include方法(用来引入页面)来分别简化和替代RequestDispatcher.forward方法和include方法。
方法接收的资源如果以“/”开头， “/”代表当前web应用。
范例：使用pageContext的forward方法跳转到其他页面

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<title>使用pageContext的forward方法跳转页面</title>
</head>
<%
//使用pageContext的forward方法跳转到pageContextDemo05.jsp页面，/代表了当前的web应用
pageContext.forward("/pageContextDemo05.jsp");
//使用pageContext.forward(relativeUrlPath)替代RequestDispatcher.forward(relativeUrlPath)
//使用RequestDispatcher的forward方法实现的跳转方式
//pageContext.getRequest().getRequestDispatcher("/pageContextDemo05.jsp").forward(request, response);
%>

运行结果如下：

pageContext.forward("/pageContextDemo05.jsp");
这种写法是用来简化和替代pageContext.getRequest().getRequestDispatcher("/pageContextDemo05.jsp").forward(request, response);这种写法的。在实际开发中，使用pageContext.forward(relativeUrlPath)方法跳转页面用得不多，主要是因为要在Jsp页面中嵌套java代码，所以这种做法简单了解一下即可，在开发中，要想从一个Jsp页面采用服务器端跳转的方式跳转到另一个Jsp页面，那么一般会使用<jsp:forward>标签，<jsp:forward>标签用于把请求转发给另外一个资源。
范例：使用pageContext的include方法引入资源

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<title>使用pageContext的include方法引入资源</title>
</head>
<%
pageContext.include("/jspfragments/head.jsp");
%>
使用pageContext的include方法引入资源
<%
pageContext.include("/jspfragments/foot.jsp");
%>
<hr/>
<%--
<jsp:include page="/jspfragments/head.jsp"/>
使用jsp:include标签引入资源
<jsp:include page="/jspfragments/foot.jsp"/>
--%>

运行结果：

在实际开发中，使用pageContext的include方法引入页面这种做法也很少用，一般都使用jsp:include标签引入资源，因此这种做法了解一下即可。

(十八)——JSP属性范围
所谓的属性范围就是一个属性设置之后，可以经过多少个其他页面后仍然可以访问的保存范围。
一、JSP属性范围
JSP中提供了四种属性范围，四种属性范围分别指以下四种：
当前页：一个属性只能在一个页面中取得，跳转到其他页面无法取得
一次服务器请求：一个页面中设置的属性，只要经过了服务器跳转，则跳转之后的页面可以继续取得。
一次会话：一个用户设置的内容，只要是与此用户相关的页面都可以访问（一个会话表示一个人，这个人设置的东西只要这个人不走，就依然有效）
上下文中：在整个服务器上设置的属性，所有人都可以访问
二、属性的操作方法
既然JSP中提供了四种属性范围，则四种属性范围中都将包含以下的属性操作方法。
No.
方法
描述
public void setAttribute(String name,Object value)
设置属性
public object getAttribute(String name)
取得属性
public void removeAttribute(String name)
删除属性
属性的操作无外乎就是增加、取得和删除这个几个操作。
单词Attribute的意思是“属性”，setAttribute(String name,Object value)从单词的组合来看就可以知道是这个方法的是设置属性，设置属性的名字和属性的值，名字(name)为String类型，值(value)为Object类型，由于值为Object类型，这表示可以设置任意类型的数据作为值，因为所有的类都是从Object类型继承而来。因此设置属性值的时候可以是任意类型的数据。getAttribute(String name)方法是根据属性的名字取得属性，removeAttribute(String name)方法是根据属性的名字删除属性。
三、JSP四种属性范围的具体介绍
3.1、page属性范围（pageContext）
page属性范围相对好理解一些：在一个页面设置的属性，跳转到其他页面就无法访问了。但是在使用page属性范围的时候必须注意的是，虽然习惯上将页面范围的属性称为page范围，但是实际上操作的时候是使用pageContext内置对象完成的。
pageContext属性范围操作流程图

pageContext从字面上的定义，可以发现，是表示一个页面(page)的上下文(Context)，可以表示一个页面中的所有内容。
从操作流程图来看，在第一个页面设置的属性经过服务器端跳转到第二个页面以后，在第二个页面是无法取得在第一个页面中设置的属性的，就好比现在坐着的桌子上有一支笔，但一旦离开了这张桌子，坐到别的桌子上时，笔就没有了。
下面通过代码来观察此范围的属性
范例：pageContextDemo01.jsp
在页面中设置两个属性

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
//此时设置的属性只能够在本页中取得
pageContext.setAttribute("name","孤傲苍狼"); //设置属性
pageContext.setAttribute("date",new Date()); //设置属性
//注意：这里设置的两个属性的名字分别为name和date，这两个是字符串类型的数据，但对应的属性值MLDN和new Date这个两个值却不是字符串类型，而是两个Object类型的数据。
%>
<%
//取得设置的属性
String refName = (String)pageContext.getAttribute("name");
//由于取得的值为Object类型，因此必须使用String强制向下转型，转换成String类型
Date refDate = (Date)pageContext.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

程序运行结果如下：

这说明了在本页设置的pageContext范围属性在本页确实可以取得，下面使用跳转语句，观察跳转之后是否还可以取得属性。
范例：pageScopeDemo02.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
pageContext.setAttribute("name","孤傲苍狼");
pageContext.setAttribute("date",new Date());
%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/pageScopeDemo03.jsp" />

范例：pageScopeDemo03.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
String refName = (String)pageContext.getAttribute("name");
Date refDate = (Date)pageContext.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

在以上程序中的pageScopeDemo02.jsp只是设置了两个属性，跳转到pageScopeDemo03.jsp之后再在pageScopeDemo03.jsp中取在pageScopeDemo02.jsp设置的page属性。此时，运行结果如下：

使用了服务器端跳转，但是发现内容并不能取得，证明page范围的属性只能在本页中取得，跳转到其他页面之中不能取得。如果现在希望跳转到其他页面之中，依然可以取得，则可以扩大属性范围，使用request属性范围即可。
3.2、request属性范围
request属性范围表示在一次服务器跳转中有效，只要是服务器跳转，则设置的request属性可以一直传递下去。

范例：requestScopeDemo01.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
request.setAttribute("name","孤傲苍狼");
request.setAttribute("date",new Date());
%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/requestScopeDemo02.jsp" />

范例：requestScopeDemo02.jsp

运行结果如下：

从运行结果来看，程序跳转了，但是与page范围相比，内容可以向下继续传递，即在第一个页面设置的属性跳转到第二个页面后在第二个页面中依然可以取得第一个页面设置的属性。
如果现在有第三个页面了，则也可以继续向后传递
范例：修改requestScopeDemo02.jsp
<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%--使用jsp:forward标签进行服务器端跳转--%>
<jsp:forward page="/requestScopeDemo03.jsp" />
范例：requestScopeDemo03.jsp

以上的结果依然可以访问，但是如果，此时使用了超链接的方式传递的话，则属性是无法向下继续传递的。
范例：修改requestScopeDemo03.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
//取得requestScopdemo01.jsp设置的属性
String refName = (String)request.getAttribute("name");
Date refDate = (Date)request.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>
<h1>
<%--使用超链接的形式跳转，这是客户端跳转，URL地址会改变--%>
<a href="http://www.mamicode.com/${pageContext.request.contextPath}/requestScopeDemo04.jsp">跳转到requestScopeDemo04.jsp</a>
</h1>

此时使用了超链接跳转，一旦跳转之后，地址栏改变，所以此种跳转也可以称为客户端跳转。
requestScopeDemo04.jsp

运行结果：

requestScopeDemo04.jsp页面显示的结果是null。这说明了在requestScopeDemo01.jsp这个页面设置的属性经过超链接这种客户端跳转到别的页面时别的页面是无法取得requestScopeDemo01.jsp中设置的属性的。
如果还想进一步扩大属性范围，则可以使用session范围属性
3.3、session属性范围
session设置的属性不管如何跳转，都可以取得的。当然，session只针对一个用户

在第一个页面上设置的属性，跳转(服务器跳转/客户端跳转)到其他页面之后，其他的页面依然可以取得第一个页面上设置的属性。
下面通过代码来观察session属性范围
范例：sessionScopeDemo01.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
//此时设置的属性只能够在与本页相关的任何页面中取得
session.setAttribute("name","孤傲苍狼"); //设置属性
session.setAttribute("date",new Date());
%>
<%--使用服务器端跳转--%>
<jsp:forward page="/sessionScopeDemo02.jsp"/>

这里使用的是服务器端跳转
sessionScopeDemo02.jsp

<%@page contentType="text/html;charset=UTF-8"%>
<%@page import="java.util.*"%>
<%
String refName = (String)session.getAttribute("name");
Date refDate = (Date)session.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>
<%--使用超链接这种客户端跳转--%>
<h1><a href="http://www.mamicode.com/${pageContext.request.contextPath}/sessionScopeDemo03.jsp">sessionScopeDemo03</a></h1>

这里使用的是超链接这种客户端跳转
运行程序sessionScopeDemo01.jsp结果如下所示：

sessionScopeDemo03.jsp

点击超链接sessionScopeDemo03，跳转到了sessionScopeDemo03.jsp这个页面，此时程序的运行结果如下：

这说明了即使是采用客户端跳转，在别的页面依然可以取得第一个页面中设置的session属性。但是，如果，此时新开了一个浏览器，则sessionScopeDemo03.jsp肯定无法取得sessionScopeDemo01.jsp中设置的session对象的属性，因为session只是保留了一个人的信息。
如果一个属性想让所有的用户都可以访问，则可以使用最后一种属性范围：application范围。
3.4、application属性范围

因为application属性范围是在服务器上设置的一个属性，所以一旦设置之后任何用户都可以浏览到此属性。
下面通过代码来观察application属性范围
范例：applicationScopeDemo01.jsp

<%@ page contentType="text/html;charset=GBK"%>
<%@ page import="java.util.*"%>
<%
//此时设置的属性任何用户都可以取得
application.setAttribute("name","孤傲苍狼"); //设置属性
application.setAttribute("date",new Date());
%>
<h1><a href="http://www.mamicode.com/${pageContext.request.contextPath}/applicationScopeDemo02.jsp">applicationScopeDemo02</a></h1>

范例：applicationScopeDemo02.jsp

<%@ page contentType="text/html;charset=GBK"%>
<%@ page import="java.util.*"%>
<%
String refName = (String)application.getAttribute("name");
Date refDate = (Date)application.getAttribute("date");
%>
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>

观察页面的运行效果：

开启多个浏览器窗口，运行applicationScopeDemo02.jsp时，都可以显示出上图所示的结果，因为属性范围设置在了服务器中，所以只要是连接到此服务器的任意用户都可以取得此属性，当然，如果服务器关闭的话，则此属性肯定消失。
如把Tomcat服务器先关闭后再重新启动，打开浏览器窗口运行applicationScopeDemo02.jsp时，得到的结果如下图所示：

注意：如果在服务器上设置了过多的application属性，则会影响到服务器的性能。
3.5、关于pageContext属性范围的进一步补充
之前所讲解的四种属性范围，实际上都是通过pageContext属性范围设置上的。打开pageContext所在的说明文档。

PageContext类继承了JspContext类，在JspContext类中定义了setAttribute方法，如下：
public abstract void setAttribute(String name,Object value,int scope)
此方法中存在一个scope的整型变量，此变量就表示一个属性的保存范围。

PageContext类继承了JspContext类，所以在PageContext类中实现了抽象的setAttribute方法：
public abstract void setAttribute(String name,Object value,int scope)
这个setAttribute()方法如果不写后面的int类型的scope参数，则此参数默认为PAGE_SCOPE，则此时setAttribute()方法设置的就是page属性范围，如果传递过来的int类型参数scope为REQUEST_SCOPE，则此时setAttribute()方法设置的就是request属性范围，同理，传递的scope参数为SESSION_SCOPE和APPLICATION_SCOPE时，则表示setAttribute()方法设置的就是session属性范围和application属性范围。
下面通过代码来观察此四种属性范围常量的作用，以：request为例
范例：pageScopeDemo04.jsp

<%@page contentType="text/html;charset=GBK"%>
<%@page import="java.util.*"%>
<%
pageContext.setAttribute("name","孤傲苍狼",PageContext.REQUEST_SCOPE); //设置属性，并指明属性范围
pageContext.setAttribute("date",new Date(),PageContext.REQUEST_SCOPE); //设置属性，并指明属性范围
%>
<jsp:forward page="/pageScopeDemo05.jsp"/>

pageScopeDemo05.jsp

<%@page contentType="text/html;charset=GBK"%>
<%@page import="java.util.*"%>
<%
//使用request对象获取属性
String refName = (String)request.getAttribute("name");
Date refDate = (Date)request.getAttribute("date");
//也可以使用pageContext对象获取属性，只要在获取时指明对象的属性范围即可
String refName2 = (String)pageContext.getAttribute("name", PageContext.REQUEST_SCOPE);
Date refDate2 = (Date)pageContext.getAttribute("date", PageContext.REQUEST_SCOPE);
%>
使用request对象获取属性：
<h1>姓名：<%=refName%></h1>
<h1>日期：<%=refDate%></h1>
使用pageContext对象获取属性：
<h1>姓名：<%=refName2%></h1>
<h1>日期：<%=refDate2%></h1>

运行结果：

从运行结果可以看到：在pageScopeDemo04.jsp使用的是pageContext对象调用setAttribute()方法设置的属性范围是request的属性范围，因此在调用此方法时，把一个int类型的scope范围常量REQUEST_SCOPE传递了进来，这个REQUEST_SCOPE属性范围常量的作用就是告诉pageContext对象现在要设置的属性范围是request的属性范围，所以pageScopeDemo05.jsp这个页面中可以直接使用request.getAttribute();方法获取在pageScopeDemo04.jsp设置的属性。
四、jsp四种属性范围的使用场合
1、request：如果客户向服务器发请求，产生的数据，用户看完就没用了，像这样的数据就存在request域,像新闻数据，属于用户看完就没用的。
2、session：如果客户向服务器发请求，产生的数据，用户用完了等一会儿还有用，像这样的数据就存在session域中，像购物数据，用户需要看到自己购物信息，并且等一会儿，还要用这个购物数据结帐。
3、application(servletContext)：如果客户向服务器发请求，产生的数据，用户用完了，还要给其它用户用，像这样的数据就存在application(servletContext)域中，像聊天数据。

(十九)——JSP标签
一、JSP标签介绍
JSP标签也称之为Jsp Action(JSP动作)元素，它用于在Jsp页面中提供业务逻辑功能，避免在JSP页面中直接编写java代码，造成jsp页面难以维护。
二、JSP常用标签
jsp的常用标签有以下三个
<jsp:include>标签
<jsp:forward>标签
<jsp:param>标签
2.1、<jsp:include>标签
<jsp:include>标签用于把另外一个资源的输出内容插入进当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。
语法：
<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />
page属性用于指定被引入资源的相对路径，它也可以通过执行一个表达式来获得。
flush属性指定在插入其他资源的输出内容时，是否先将当前JSP页面的已输出的内容刷新到客户端。
范例：使用jsp:include标签引入资源

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>jsp的jsp:include标签测试</title>
</head>
<body>
<%--使用jsp:include标签引入其它JSP页面--%>
<jsp:include page="/jspfragments/head.jsp"/>
<h1>网页主体内容</h1>
<jsp:include page="/jspfragments/foot.jsp"/>
</body>
</html>

运行结果：

2.2、<jsp:include>标签与include指令的区别
<jsp:include>标签是动态引入， <jsp:include>标签涉及到的2个JSP页面会被翻译成2个servlet，这2个servlet的内容在执行时进行合并。
而include指令是静态引入，涉及到的2个JSP页面会被翻译成一个servlet，其内容是在源文件级别进行合并。
通过下面的例子来说明<jsp:include>标签与include指令的区别
demo.jsp：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%!
int i=1000;
%>
<h1>demo.jsp中i的值为：<%=i%></h1>
分别使用include指令和<jsp:include>标签两种包含语句，包含以上的demo.jsp
范例：使用@include包含内容
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%!
int i=10;
%>
<h1>JspIncludeTagDemo01.jsp中i的值为：<%=i%></h1>
<h1><%@include file="/jspfragments/demo.jsp"%></h1>
此时在编译jsp时就已经提示出错了，如下所示：

这个错误说的是变量i已经重复定义了
运行JspIncludeTagDemo01.jsp，结果如下：

运行后发现出现了重复定义变量i的错误提示信息，因为静态包含是将全部内容包含进来之后，再进行处理，属于先包含后处理。由于被包含进来的页面demo.jsp中定义了一个变量i，而包含页面JspIncludeTagDemo01.jsp本身又定义了一个变量i，所以服务器在处理JspIncludeTagDemo01.jsp这个页面时就会发现里面有两个重复定义的变量i，因此就会报错。
而如果现在使用的是<jsp:include>动态包含的话，观察以下程序：
范例：使用动态包含

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>JspIncludeTagDemo02.jsp</h1>
<%!
int i=10;
%>
<h1>JspIncludeTagDemo02.jsp中i的值为：<%=i%></h1>
<h1><jsp:include page="/jspfragments/demo.jsp" /></h1>

运行结果：

发现结果已经可以正确地显示，而且不会互相影响，这是因为使用jsp:include属于动态包含，动态包含就是指先将各个页面分别处理，处理完之后再将处理后的结果包含进来。
不管是<jsp:include>标签，还是include指令，它们都会把两个JSP页面内容合并输出，所以这两个页面不要出现重复的HTML全局架构标签，否则输出给客户端的内容将会是一个格式混乱的HTML文档。
2.3、*.jspf扩展名文件在jsp:include、@include和c:import中的区别
JSP规范建议使用.jspf（JSP fragments）作为静态引入文件的扩展名。今天无意中发现，把一个JSP文件命名为jspf扩展名，然后include到另一个jsp文件中的，发现只有用"@include"指令的时候，jspf文件的内容才会被解析并执行其中的jsp指令和tag，而使用"jsp:include"和JSTL的"c:import"都没有用，jspf文件被当作纯文本文件处理了。
比如现在有一个head.jspf页面和foot.jspf页面
head.jspf
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1 style="color:red;">网页头部</h1>
foot.jspf
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1 style="color:blue;">网页尾部</h1>
首先使用"@include"指令将"head.jspf和foot.jspf" include到IncludeTagTest.jsp页面，如下所示：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>jsp的Include指令测试</title>
</head>
<body>
　<%--使用include标签引入引入jspf页面--%>
<%@include file="/jspfragments/head.jspf" %>
<h1>网页主体内容</h1>
<%@include file="/jspfragments/foot.jspf" %>
</body>
</html>

运行IncludeTagTest.jsp页面，运行结果如下：

jspf文件的内容会被解析并执行其中的jsp指令和tag，查看浏览器解析JspIncludeTagTest.jsp页面生成的源代码，如下所示：

然后再使用<jsp:include>"标签将"head.jspf和foot.jspf" include到JspIncludeTagTest.jsp页面中，如下所示：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>jsp的jsp:include标签测试</title>
</head>
<body>
<%--使用jsp:include标签引入其它JSPf页面--%>
<jsp:include page="/jspfragments/head.jspf"/>
<h1>网页主体内容</h1>
<jsp:include page="/jspfragments/foot.jspf"/>
</body>
</html>

运行JspIncludeTagTest.jsp页面，运行结果如下：

查看浏览器解析JspIncludeTagTest.jsp页面生成的源代码，如下所示：

可以看到，head.jspf和foot.jspf中的<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>没有解析执行，而是原封不动地作为文本内容输出到页面上了，在IE下看不到<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>的输出，在google和火狐浏览器下运行可以看到页面上输出<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>，如下所示：

这说明jspf文件Tomcat服务器被当作纯文本文件处理了，没有当作jsp页面来解析执行，那么该如何解决这个问题呢？如何让tomcat服务器能够解析执行*.jspf文件中的java代码和标签呢，有如下的几种解决办法：
解决办法一：修改web.xml文件，添加对扩展名为*.jspf文件的映射
如下所示：

<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jspf</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>

上面的配置方式也可以简写成这样：
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>

<url-pattern>*.jspf</url-pattern>
</servlet-mapping>
两种写法的效果都是一样的。
添加这样的配置信息后，此时tomcat服务器就可以正常解析执行*.jspf文件了，如下所示：

解决办法二：修改Tomcat服务器的web.xml文件，添加对扩展名为*.jspf文件的映射
找到tomcat服务器的web.xml文件，如下所示：

找到名字为jsp的那个Servlet，如下所示：

<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
<init-param>
<param-name>fork</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>xpoweredBy</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>

然后根据Servlet名找到对应的servlet-mapping配置，如下所示：

<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>
在这里可以看到，名字为jsp的那个Servlet只支持*.jsp和*.jspx两种扩展名，因此可以在这个地方添加多一个<url-pattern>*.jspf</url-pattern>，如下所示：

<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
<url-pattern>*.jspf</url-pattern>
</servlet-mapping>

经过这样的配置之后，Tomcat服务器就可以正常解析和执行*.jspf文件了。
2.3、<jsp:forward>标签
<jsp:forward>标签用于把请求转发给另外一个资源。
语法：
<jsp:forward page="relativeURL | <%=expression%>" />
page属性用于指定请求转发到的资源的相对路径，它也可以通过执行一个表达式来获得。
范例：使用<jsp:forward>标签跳转页面
forwarddemo01.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--使用<jsp:forward>标签跳转到forwarddemo02.jsp--%>
<jsp:forward page="/forwarddemo02.jsp"/>
forwarddemo02.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>跳转之后的页面！！</h1>
运行结果如下：

从页面的显示效果来看，页面已经完成了跳转，但地址栏没有变化，地址栏中显示的地址还是forwarddemo01.jsp，但页面显示的内容却是forwardemo02.jsp中的内容。因为此跳转属于服务器端跳转。只要是服务器端跳转，则地址栏永远没有变化。
2.4、<jsp:param>标签
当使用<jsp:include>和<jsp:forward>标签引入或将请求转发给其它资源时，可以使用<jsp:param>标签向这个资源传递参数。
语法1：
<jsp:include page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="http://www.mamicode.com/parameterValue|" />
</jsp:include>
语法2：
<jsp:forward page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="http://www.mamicode.com/parameterValue|" />
</jsp:include>
<jsp:param>标签的name属性用于指定参数名，value属性用于指定参数值。在<jsp:include>和<jsp:forward>标签中可以使用多个<jsp:param>标签来传递多个参数。
范例：使用<jsp:param>标签向被包含的页面传递参数
JspIncludeTagDemo03.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>JspIncludeTagDemo03.jsp</h1>
<hr/>
<jsp:include page="/jspfragments/Inc.jsp">
<jsp:param name="parm1" value="http://www.mamicode.com/hello" />
<jsp:param name="parm2" value="http://www.mamicode.com/gacl" />
</jsp:include>

Inc.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>接收从JspIncludeTagDemo03.jsp页面中传递过来的参数：</h1>
<h2><%=request.getParameter("parm1")%></h2>
<h2><%=request.getParameter("parm2")%></h2>
在JspIncludeTagDemo03.jsp页面中使用<jsp:include>标签将Inc.jsp页面包含进来，使用<jsp:param/>标签向Inc.jsp页面传递了两个参数parm1和parm2
JspIncludeTagDemo03.jsp页面运行结果如下：

范例：使用<jsp:param>标签向要跳转的页面传递参数
forwarddemo03.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--使用<jsp:forward>标签跳转到forwarddemo04.jsp--%>
<%--使用<jsp:param>标签向forwarddemo04.jsp传递参数--%>
<jsp:forward page="/forwarddemo04.jsp">
<jsp:param name="ref1" value="http://www.mamicode.com/hello" />
<jsp:param name="ref2" value="http://www.mamicode.com/gacl" />
</jsp:forward>

forwarddemo04.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<h1>跳转之后的页面！！</h1>
<h1>接收从forwarddemo03.jsp传递过来的参数：</h1>
<h1>ref1：<%=request.getParameter("ref1")%></h1>
<h1>ref2：<%=request.getParameter("ref2")%></h1>
运行结果如下：

(二十)——JavaBean总结
一、什么是JavaBean
JavaBean是一个遵循特定写法的Java类，它通常具有如下特点：
这个Java类
必须具有一个无参的构造函数
属性必须私有化
私有化的属性必须通过public类型的方法暴露给其它程序，并且方法的命名也必须遵守一定的命名规范。
javaBean范例：
package gacl.javabean.study;
/**
* @author gacl
* Person类就是一个最简单的JavaBean
*/
public class Person {
//------------------Person类封装的私有属性---------------------------------------
// 姓名 String类型
private String name;
// 性别 String类型
private String sex;
// 年龄 int类型
private int age;
//是否已婚 boolean类型
private boolean married;
//---------------------------------------------------------
//------------------Person类的无参数构造方法---------------------------------------
/**
* 无参数构造方法
*/
public Person() {
}
//---------------------------------------------------------
//------------------Person类对外提供的用于访问私有属性的public方法---------------------------------------
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isMarried() {
return married;
}
public void setMarried(boolean married) {
this.married = married;
}
//---------------------------------------------------------
}

JavaBean在J2EE开发中，通常用于封装数据，对于遵循以上写法的JavaBean组件，其它程序可以通过反射技术实例化JavaBean对象，并且通过反射那些遵守命名规范的方法，从而获知JavaBean的属性，进而调用其属性保存数据。
二、JavaBean的属性
JavaBean的属性可以是任意类型，并且一个JavaBean可以有多个属性。每个属性通常都需要具有相应的setter、 getter方法，setter方法称为属性修改器，getter方法称为属性访问器。
属性修改器必须以小写的set前缀开始，后跟属性名，且属性名的第一个字母要改为大写，例如，name属性的修改器名称为setName，password属性的修改器名称为setPassword。
属性访问器通常以小写的get前缀开始，后跟属性名，且属性名的第一个字母也要改为大写，例如，name属性的访问器名称为getName，password属性的访问器名称为getPassword。
一个JavaBean的某个属性也可以只有set方法或get方法，这样的属性通常也称之为只写、只读属性。
三、在JSP中使用JavaBean
JSP技术提供了三个关于JavaBean组件的动作元素，即JSP标签，它们分别为：
<jsp:useBean>标签：用于在JSP页面中查找或实例化一个JavaBean组件。
<jsp:setProperty>标签：用于在JSP页面中设置一个JavaBean组件的属性。
<jsp:getProperty>标签：用于在JSP页面中获取一个JavaBean组件的属性。
3.1、<jsp:useBean>标签
<jsp:useBean>标签用于在指定的域范围内查找指定名称的JavaBean对象，如果存在则直接返回该JavaBean对象的引用，如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。
常用语法：
<jsp:useBean id="beanName" class="package.class" scope="page|request|session|application"/>
"id"属性用于指定JavaBean实例对象的引用名称和其存储在域范围中的名称。
"class"属性用于指定JavaBean的完整类名（即必须带有包名）。
"scope"属性用于指定JavaBean实例对象所存储的域范围，其取值只能是page、request、session和application等四个值中的一个，其默认值是page。

<jsp:useBean>标签使用范例：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--
在jsp中使用jsp:useBean标签来实例化一个Java类的对象
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
┝<jsp:useBean>：表示在JSP中要使用JavaBean。
┝id:表示生成的实例化对象，凡是在标签中看见了id，则肯定表示一个实例对象。
┝class：此对象对应的包.类名称
┝scope：此javaBean的保存范围，四种范围：page、request、session、application
--%>
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
<%
//person对象在上面已经使用jsp:useBean标签实例化了，因此在这里可以直接使用person对象
//使用setXxx方法为对象的属性赋值
//为person对象的name属性赋值
person.setName("孤傲苍狼");
//为person对象的Sex属性赋值
person.setSex("男");
//为person对象的Age属性赋值
person.setAge(24);
//为person对象的married属性赋值
person.setMarried(false);
%>
<!DOCTYPE HTML>
<html>
<head>
<title>jsp:useBean标签使用范例</title>
</head>

<body>
<%--使用getXxx()方法获取对象的属性值 --%>
<h2>姓名：<%=person.getName()%></h2>
<h2>性别：<%=person.getSex()%></h2>
<h2>年龄：<%=person.getAge()%></h2>
<h2>已婚：<%=person.isMarried()%></h2>
</body>
</html>

运行结果如下：

3.2、<jsp:useBean>执行原理
上面我们在index.jsp中使用<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>实例化了一个gacl.javabean.study.Person类的对象，那么这个peson对象是怎么实例化出来的呢？index.jsp在执行的过程中首先会翻译成一个servlet，因此我们可以通过查看index.jsp页面生成的servlet的java代码来查看peson对象的实例化过程
找到tomcat服务器下的"work\Catalina\localhost\项目名称\org\apache\jsp"这个目录，就可以看到将index.jsp页面翻译成servlet的java源码了，如下所示：

使用文本编辑器打开index_jsp.java文件，在_jspService方法中可以看到person对象的创建过程，如下所示：

gacl.javabean.study.Person person = null;
synchronized (_jspx_page_context) {
person = (gacl.javabean.study.Person) _jspx_page_context.getAttribute("person", PageContext.PAGE_SCOPE);
if (person == null){
person = new gacl.javabean.study.Person();
_jspx_page_context.setAttribute("person", person, PageContext.PAGE_SCOPE);
}
}

下面我们来分析一下上述生成的代码：
首先是定义一个person对象，值是null
gacl.javabean.study.Person person = null;//定义一个空的person对象
然后是使用pageContext对象的getAttribute方法获取存储在PageContext.PAGE_SCOPE域中的Person对象
person = (gacl.javabean.study.Person) _jspx_page_context.getAttribute("person", PageContext.PAGE_SCOPE);
如果在PageContext.PAGE_SCOPE域中的Person对象没有找到person对象，那么就创建一个新的person对象，然后使用pageContext对象的setAttribute方法将新创建的person存储在PageContext.PAGE_SCOPE域中
if (person == null){
person = new gacl.javabean.study.Person();
_jspx_page_context.setAttribute("person", person, PageContext.PAGE_SCOPE);
}
也就是说，在index.jsp中使用<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>来实例化person对象的过程实际上是执行了上述的java代码来实例化Person对象。这就是<jsp:useBean>标签的执行原理："首先在指定的域范围内查找指定名称的JavaBean对象，如果存在则直接返回该JavaBean对象的引用，如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。
3.3、带标签体的<jsp:useBean>标签
语法：
<jsp:useBean ...>
Body
</jsp:useBean>
功能：
Body部分的内容只在<jsp:useBean>标签创建JavaBean的实例对象时才执行。这种做法用得不多，了解一下即可
3.4、<jsp:setProperty>标签
<jsp:setProperty>标签用于设置和访问JavaBean对象的属性。
语法格式一：
<jsp:setProperty name="beanName" property="propertyName" value="http://www.mamicode.com/string字符串"/>
语法格式二：
<jsp:setProperty name="beanName" property="propertyName" value="http://www.mamicode.com/" />
语法格式三：
<jsp:setProperty name="beanName" property="propertyName" param="parameterName"/>
语法格式四：
<jsp:setProperty name="beanName" property= "*" />
name属性用于指定JavaBean对象的名称。
property属性用于指定JavaBean实例对象的属性名。
value属性用于指定JavaBean对象的某个属性的值，value的值可以是字符串，也可以是表达式。为字符串时，该值会自动转化为JavaBean属性相应的类型，如果value的值是一个表达式，那么该表达式的计算结果必须与所要设置的JavaBean属性的类型一致。
param属性用于将JavaBean实例对象的某个属性值设置为一个请求参数值，该属性值同样会自动转换成要设置的JavaBean属性的类型。

<jsp:setProperty>标签使用范例1：使用jsp:setProperty标签设置person对象的属性值

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--
在jsp中使用jsp:useBean标签来实例化一个Java类的对象
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
┝<jsp:useBean>：表示在JSP中要使用JavaBean。
┝id:表示生成的实例化对象，凡是在标签中看见了id，则肯定表示一个实例对象。
┝class：此对象对应的包.类名称
┝scope：此javaBean的保存范围，四种范围：page、request、session、application
--%>
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
<%--
使用jsp:setProperty标签设置person对象的属性值
jsp:setProperty在设置对象的属性值时会自动把字符串转换成8种基本数据类型
但是jsp:setProperty对于复合数据类型无法自动转换
--%>
<jsp:setProperty property="name" name="person" value="http://www.mamicode.com/白虎神皇"/>
<jsp:setProperty property="sex" name="person" value="http://www.mamicode.com/男"/>
<jsp:setProperty property="age" name="person" value="http://www.mamicode.com/24"/>
<jsp:setProperty property="married" name="person" value="http://www.mamicode.com/false"/>
<%--
birthday属性是一个Date类型，这个属于复合数据类型，因此无法将字符串自动转换成Date ，用下面这种写法是会报错的
<jsp:setProperty property="birthday" name="person" value="http://www.mamicode.com/1988-05-07"/>
--%>
<jsp:setProperty property="birthday" name="person" value="http://www.mamicode.com/"/>
<!DOCTYPE HTML>
<html>
<head>
<title>jsp:setProperty标签使用范例</title>
</head>

<body>
<%--使用getXxx()方法获取对象的属性值 --%>
<h2>姓名：<%=person.getName()%></h2>
<h2>性别：<%=person.getSex()%></h2>
<h2>年龄：<%=person.getAge()%></h2>
<h2>已婚：<%=person.isMarried()%></h2>
<h2>出生日期：<%=person.getBirthday()%></h2>
</body>
</html>

运行效果如下：

<jsp:setProperty>标签使用范例2：使用请求参数为bean的属性赋值

运行结果如下：

<jsp:setProperty>标签使用范例3：用所有的请求参数为bean的属性赋值

运行结果如下所示：

3.5、<jsp:getProperty>标签
<jsp:getProperty>标签用于读取JavaBean对象的属性，也就是调用JavaBean对象的getter方法，然后将读取的属性值转换成字符串后插入进输出的响应正文中。
语法：
<jsp:getProperty name="beanInstanceName" property="PropertyName" />
name属性用于指定JavaBean实例对象的名称，其值应与<jsp:useBean>标签的id属性值相同。
property属性用于指定JavaBean实例对象的属性名。
如果一个JavaBean实例对象的某个属性的值为null，那么，使用<jsp:getProperty>标签输出该属性的结果将是一个内容为“null”的字符串。
范例：使用jsp:getProperty获取bean对象的属性值

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--
在jsp中使用jsp:useBean标签来实例化一个Java类的对象
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
┝<jsp:useBean>：表示在JSP中要使用JavaBean。
┝id:表示生成的实例化对象，凡是在标签中看见了id，则肯定表示一个实例对象。
┝class：此对象对应的包.类名称
┝scope：此javaBean的保存范围，四种范围：page、request、session、application
--%>
<jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
<%--
使用jsp:setProperty标签设置person对象的属性值
jsp:setProperty在设置对象的属性值时会自动把字符串转换成8种基本数据类型
但是jsp:setProperty对于复合数据类型无法自动转换
--%>
<jsp:setProperty property="name" name="person" value="http://www.mamicode.com/白虎神皇"/>
<jsp:setProperty property="sex" name="person" value="http://www.mamicode.com/男"/>
<jsp:setProperty property="age" name="person" value="http://www.mamicode.com/24"/>
<jsp:setProperty property="married" name="person" value="http://www.mamicode.com/false"/>
<%--
birthday属性是一个Date类型，这个属于复合数据类型，因此无法将字符串自动转换成Date ，用下面这种写法是会报错的
<jsp:setProperty property="birthday" name="person" value="http://www.mamicode.com/1988-05-07"/>
--%>
<jsp:setProperty property="birthday" name="person" value="http://www.mamicode.com/"/>
<!DOCTYPE HTML>
<html>
<head>
<title>jsp:getProperty标签使用范例</title>
</head>

<body>
<%--使用jsp:getProperty标签获取对象的属性值 --%>
<h2>姓名：<jsp:getProperty property="name" name="person"/></h2>
<h2>性别：<jsp:getProperty property="sex" name="person"/></h2>
<h2>年龄：<jsp:getProperty property="age" name="person"/></h2>
<h2>已婚：<jsp:getProperty property="married" name="person"/></h2>
<h2>出生日期：<jsp:getProperty property="birthday" name="person"/></h2>
</body>
</html>

运行结果如下：

关于JavaBean方面的内容基本上就这么多了，只需要掌握JavaBean的写法，以及掌握<jsp:useBean>标签，<jsp:setProperty>标签，<jsp:getProperty>标签的使用！

(二十一)——JavaWeb的两种开发模式
SUN公司推出JSP技术后，同时也推荐了两种web应用程序的开发模式，一种是JSP+JavaBean模式，一种是Servlet+JSP+JavaBean模式。
一、JSP+JavaBean开发模式
1.1、jsp+javabean开发模式架构
jsp+javabean开发模式的架构图如下图(图1-1)所示
图1-1

在jsp+javabean架构中，JSP负责控制逻辑、表现逻辑、业务对象（javabean）的调用。
JSP+JavaBean模式适合开发业务逻辑不太复杂的web应用程序，这种模式下，JavaBean用于封装业务数据，JSP即负责处理用户请求，又显示数据。
1.2、JSP+JavaBean开发模式编写计算器
首先分析一下jsp和javabean各自的职责，jsp负责显示计算器(calculator)页面，供用户输入计算数据，并显示计算后的结果，javaBean负责接收用户输入的计算数据并且进行计算，JavaBean具有firstNum、secondNum、result、 operator属性，并提供一个calculate方法。
1、编写CalculatorBean，负责接收用户输入的计算数据并且进行计算
CalculatorBean代码如下：
复制代码
package me.gacl.domain;
import java.math.BigDecimal;
/**
* @author gacl
* CalculatorBean用于接收输入参数和计算
*/
public class CalculatorBean {
//用户输入的第一个数
private double firstNum;
//用户输入的第二个数
private double secondNum;
//用户选择的操作运算符
private char operator = ‘+‘;
//运算结果
private double result;
public double getFirstNum() {
return firstNum;
}
public void setFirstNum(double firstNum) {
this.firstNum = firstNum;
}
public double getSecondNum() {
return secondNum;
}
public void setSecondNum(double secondNum) {
this.secondNum = secondNum;
}
public char getOperator() {
return operator;
}
public void setOperator(char operator) {
this.operator = operator;
}
public double getResult() {
return result;
}
public void setResult(double result) {
this.result = result;
}
/**
* 用于计算
*/
public void calculate() {
switch (this.operator) {
case ‘+‘: {
this.result = this.firstNum + this.secondNum;
break;
}
case ‘-‘: {
this.result = this.firstNum - this.secondNum;
break;
}
case ‘*‘: {
this.result = this.firstNum * this.secondNum;
break;
}
case ‘/‘: {
if (this.secondNum == 0) {
throw new RuntimeException("被除数不能为0!!!");
}
this.result = this.firstNum / this.secondNum;
// 四舍五入
this.result = new BigDecimal(this.result).setScale(2,
BigDecimal.ROUND_HALF_UP).doubleValue();
break;
}
default:
throw new RuntimeException("对不起，传入的运算符非法！！");
}
}
}
复制代码
2、编写calculator.jsp，负责显示计算器(calculator)页面，供用户输入计算数据，并显示计算后的结果
calculator.jsp页面代码如下：
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--使用me.gacl.domain.CalculatorBean --%>
<jsp:useBean id="calcBean" class="me.gacl.domain.CalculatorBean"/>
<%--接收用户输入的参数 --%>
<jsp:setProperty name="calcBean" property="*"/>
<%
//使用CalculatorBean进行计算
calcBean.calculate();
%>
<!DOCTYPE HTML>
<html>
<head>
<title>使用【jsp+javabean开发模式】开发的简单计算器</title>
</head>

<body>
<br/>
计算结果是：
<jsp:getProperty name="calcBean" property="firstNum"/>
<jsp:getProperty name="calcBean" property="operator"/>
<jsp:getProperty name="calcBean" property="secondNum"/>
=
<jsp:getProperty name="calcBean" property="result"/>

<br/><hr> <br/>
<form action="${pageContext.request.contextPath}/calculator.jsp" method="post">
<table border="1px">
<tr>
<td colspan="2">简单的计算器</td>
</tr>
<tr>
<td>第一个参数</td>
<td><input type="text" name="firstNum"></td>
</tr>
<tr>
<td>运算符</td>
<td><select name="operator">
<option value="http://www.mamicode.com/+">+</option>
<option value="http://www.mamicode.com/-">-</option>
<option value="http://www.mamicode.com/*">*</option>
<option value="http://www.mamicode.com/">/</option>
</select></td>
</tr>
<tr>
<td>第二个参数</td>
<td><input type="text" name="secondNum"></td>
</tr>
<tr>
<td colspan="2"><input type="submit" value="http://www.mamicode.com/计算"></td>
</tr>
</table>
</form>
</body>
</html>
复制代码
运行结果如下：

二、Servlet+JSP+JavaBean开发模式
在平时的JavaWeb项目开发中，在不使用第三方mvc开发框架的情况下，通常会选择Servlet+JSP+JavaBean开发模式来开发JavaWeb项目，Servlet+JSP+JavaBean组合开发就是一种MVC开发模式了，控制器(Controller)采用Servlet、模型(Model)采用JavaBean、视图(View)采用JSP。在讲解Servlet+JSP+JavaBean开发模式之前，先简单了解一下MVC开发模式。
2.1、Web开发中的请求-响应模型
图2-1

在Web世界里，具体步骤如下：
1、Web浏览器（如IE）发起请求，如访问http://www.iteye.com/
2、Web服务器（如Tomcat）接收请求，处理请求（比如用户新增，则将把用户保存一下），最后产生响应（一般为html）。
3、web服务器处理完成后，返回内容给web客户端（一般就是我们的浏览器），客户端对接收的内容进行处理（如web浏览器将会对接收到的html内容进行渲染以展示给客户）。
因此，在Web世界里：都是Web客户端发起请求，Web服务器接收、处理并产生响应。
一般Web服务器是不能主动通知Web客户端更新内容。虽然现在有些技术如服务器推（如Comet）、还有现在的HTML5 websocket可以实现Web服务器主动通知Web客户端。
到此我们了解了在web开发时的请求/响应模型，接下来我们看一下标准的MVC模型是什么。
2.2、标准MVC模型概述
MVC模型：是一种架构型的模式，本身不引入新功能，只是帮助我们将开发的结构组织的更加合理，使展示与模型分离、流程控制逻辑、业务逻辑调用与展示逻辑分离。如下图(图2-2)所示：
图2-2

2.3、MVC（Model-View-Controller）的概念
首先让我们了解下MVC（Model-View-Controller）的概念：
Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型(domain)或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据）和服务层（行为）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。
从图2-1我们还看到，在标准的MVC中模型能主动推数据给视图进行更新（观察者设计模式，在模型上注册视图，当模型更新时自动更新视图），但在Web开发中模型是无法主动推给视图（无法主动更新用户界面），因为在Web开发是请求-响应模型。
那接下来我们看一下在Web里MVC是什么样子，我们称其为 Web MVC 来区别标准的MVC。
2.4.、Web MVC概述
Web MVC中的M(模型)-V(视图)-C(控制器)概念和标准MVC概念一样，我们再看一下Web MVC标准架构，如下图(图2-3)所示：
图2-3

在Web MVC模式下，模型无法主动推数据给视图，如果用户想要视图更新，需要再发送一次请求（即请求-响应模型）。
2.5、Servlet+JSP+JavaBean开发模式介绍
Servlet+JSP+JavaBean架构其实可以认为就是我们所说的Web MVC模型，只是控制器采用Servlet、模型采用JavaBean、视图采用JSP，如图2-4
图2-4

具体示例代码：
1、模型(model)

2、视图(View)

3、控制器(controller)

从Servlet+JSP+JavaBean(Web MVC)架构可以看出，视图和模型分离了，控制逻辑和展示逻辑分离了。
三、Servlet+JSP+JavaBean开发模式的缺点
Servlet+JSP+JavaBean(Web MVC)架构虽然实现了视图和模型分离以及控制逻辑和展示逻辑分离，但也有一些比较严重的缺点
3.1、Servlet作为控制器的缺点
此处的控制器使用Servlet，使用Servlet作为控制器有以下几个缺点：
1、控制逻辑可能比较复杂，其实我们可以按照规约，如请求参数submitFlag=toLogin，我们其实可以直接调用toLogin方法，来简化控制逻辑；而且每个模块基本需要一个控制器，造成控制逻辑可能很复杂。现在流行的Web MVC框架(如Struts2)都支持"请求参数submitFlag=toAdd，就可以直接调用toAdd方法"这样的处理机制，在Struts2中类似这样的处理机制就称为"动态方法调用"
2、请求参数到模型的封装比较麻烦，如果能交给框架来做这件事情，我们可以从中得到解放。
请求参数到模型的封装代码：
复制代码
// 1收集参数
String username = req.getParameter("username");
String password = req.getParameter("password");
// 2封装参数
UserBean user = new UserBean();
user.setUsername(username);
user.setPassword(password);
复制代码
当有几十个甚至上百个参数需要封装到模型中时，这样写恐怕就痛苦万分了，要写几十次甚至上百次这样的代码，估计写到吐了，所以现在流行的Web MVC框架(如Struts2)都提供了非常方便的获取参数，封装参数到模型的机制，减少这些繁琐的工作。
3、选择下一个视图，严重依赖Servlet API，这样很难或基本不可能更换视图。
例如：使用Servlet API提供的request对象的getRequestDispatcher方法选择要展示给用户看的视图
private void toLogin(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//使用Servlet API提供的request对象的getRequestDispatcher方法选择视图
// 此处和JSP视图技术紧密耦合，更换其他视图技术几乎不可能
request.getRequestDispatcher("/mvc/login.jsp").forward(request, response);
}
4、给视图传输要展示的模型数据，也需要使用Servlet API，更换视图技术也要一起更换，很麻烦。
例如：使用Servlet API提供的request对象给视图传输要展示的模型数据
//使用Servlet API提供的request对象给视图login.jsp传输要展示的模型数据(user)
request.setAttribute("user", user);
request.getRequestDispatcher("/mvc/login.jsp").forward(request, response)
3.2、JavaBean作为模型的缺点
此处模型使用JavaBean，JavaBean组件类既负责收集封装数据，又要进行业务逻辑处理，这样可能造成JavaBean组件类很庞大，所以一般现在项目都是采用三层架构，而不直接采用JavaBean。

3.3、视图的缺点
现在被绑定在JSP，很难更换视图，比如Velocity、FreeMarker；比如我要支持Excel、PDF视图等等。
关于JavaWeb的两种开发模式的讲解就介绍到这里，下一篇将使用servlet+jsp+javabean来开发一个用户登录注册功能，以此来加深servlet+jsp+javabean开发模式的理解。

(二十二)——基于Servlet+JSP+JavaBean开发模式的用户登录注册
一、Servlet+JSP+JavaBean开发模式(MVC)介绍
Servlet+JSP+JavaBean模式(MVC)适合开发复杂的web应用，在这种模式下，servlet负责处理用户请求，jsp负责数据显示，javabean负责封装数据。 Servlet+JSP+JavaBean模式程序各个模块之间层次清晰，web开发推荐采用此种模式。
这里以一个最常用的用户登录注册程序来讲解Servlet+JSP+JavaBean开发模式，通过这个用户登录注册程序综合案例，把之前的学过的XML、Xpath、Servlet、jsp的知识点都串联起来。
二、创建MVC架构的Web项目
在MyEclipse中新创建一个webmvcframework项目，导入项目所需要的开发包(jar包)，创建项目所需要的包，在java开发中，架构的层次是以包的形式体现出来的
项目所需要的开发包(jar包)
序号开发包名称描述
1 dom4j-1.6.1.jar dom4j用于操作XML文件
2 jaxen-1.1-beta-6.jar 用于解析XPath表达式
3 commons-beanutils-1.8.0.jar 工具类，用于处理bean对象
4 commons-logging.jar commons-beanutils-1.8.0.jar的依赖jar包
5 jstl.jar jstl标签库和EL表达式依赖包
6 standard.jar jstl标签库和EL表达式依赖包

项目所需要的包
序号包名描述所属层次
1 me.gacl.domain 存放系统的JavaBean类(只包含简单的属性以及属性对应的get和set方法，不包含具体的业务处理方法)，提供给【数据访问层】、【业务处理层】、【Web层】来使用 domain(域模型)层
2 me.gacl.dao 存放访问数据库的操作接口类数据访问层
3 me.gacl.dao.impl 存放访问数据库的操作接口的实现类
4 me.gacl.service 存放处理系统业务接口类业务处理层
5 me.gacl.service.impl 存放处理系统业务接口的实现类
6 me.gacl.web.controller 存放作为系统控制器的Servlet Web层(表现层)
7 me.gacl.web.UI 存放为用户提供用户界面的servlet(UI指的是user interface)
8 me.gacl.web.filter 存放系统的用到的过滤器(Filter)
9 me.gacl.web.listener 存放系统的用到的监听器(Listener)
10 me.gacl.util 存放系统的通用工具类，提供给【数据访问层】、【业务处理层】、【Web层】来使用
11 junit.test 存放系统的测试类

一个良好的JavaWeb项目架构应该具有以上的11个包，这样显得层次分明，各个层之间的职责也很清晰明了，搭建JavaWeb项目架构时，就按照上面的1~11的序号顺序创建包：domain→dao→dao.impl→service→service.impl→web.controller→web.UI→web.filter→web.listener→util→junit.test，包的层次创建好了，项目的架构也就定下来了，当然，在实际的项目开发中，也不一定是完完全全按照上面说的来创建包的层次结构，而是根据项目的实际情况，可能还需要创建其他的包，这个得根据项目的需要来定了
在src目录(类目录)下面，创建用于保存用户数据的xml文件(DB.xml)
在WEB-INF目录下创建一个pages目录，pages目录存放系统的一些受保护(不允许用户直接通过URL地址访问)的jsp页面，用户要想访问这些受保护的jsp页面，那么只能通过me.gacl.web.UI这个包里面的Servlet
创建好的项目如下图(图-1)所示：

图-1
三、分层架构的代码编写
分层架构的代码也是按照【域模型层(domain)】→【数据访问层(dao、dao.impl)】→【业务处理层(service、service.impl)】→【表现层(web.controller、web.UI、web.filter、web.listener)】→【工具类(util)】→【测试类(junit.test)】的顺序进行编写的。
3.1、开发domain层
在me.gacl.domain包下创建一个User类

User类具体代码如下：
复制代码
package me.gacl.domain;
import java.io.Serializable;
import java.util.Date;
/**
* @author gacl
* 用户实体类
*/
public class User implements Serializable {
private static final long serialVersionUID = -4313782718477229465L;

// 用户ID
private String id;
// 用户名
private String userName;
// 用户密码
private String userPwd;
// 用户邮箱
private String email;
// 用户生日
private Date birthday;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPwd() {
return userPwd;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
复制代码
3.2、开发数据访问层(dao、dao.impl)
在me.gacl.dao包下创建一个IUserDao接口类，对于开发接口类，我习惯以字母I作类的前缀，这样一眼就看出当前这个类是一个接口，这也算是一种良好的开发习惯吧，通过看类名就可以方便区分出是接口还是具体的实现类。

IUserDao接口的具体代码如下：
复制代码
package me.gacl.dao;
import me.gacl.domain.User;
public interface IUserDao {
/**
* 根据用户名和密码来查找用户
* @param userName
* @param userPwd
* @return 查到到的用户
*/
User find(String userName, String userPwd);
/**
* 添加用户
* @param user
*/
void add(User user);
/**根据用户名来查找用户
* @param userName
* @return 查到到的用户
*/
User find(String userName);
}
复制代码
对于接口中的方法定义，这个只能是根据具体的业务来分析需要定义哪些方法了，但是无论是多么复杂的业务，都离不开基本的CRUD(增删改查)操作，Dao层是直接和数据库交互的，所以Dao层的接口一般都会有增删改查这四种操作的相关方法。
在me.gacl.dao.impl包下创建一个UserDaoImpl类

UserDaoImpl类是IUserDao接口的具体实现类，对于接口的实现类命名方式，我习惯以"接口名(去除前缀I)+impl"形式或者"接口名+impl"形式来命名：IUserDao(接口)→UserDaoImpl(实现类)或者IUserDao(接口)→IUserDaoImpl(实现类)，这也算是一些个人的编程习惯吧，平时看到的代码大多数都是以这两种形式中的一种来来命名接口的具体实现类的，反正就是要能够一眼看出接口对应的实现类是哪一个就可以了。
UserDaoImpl类的具体代码如下：
复制代码
package me.gacl.dao.impl;
import java.text.SimpleDateFormat;
import org.dom4j.Document;
import org.dom4j.Element;
import me.gacl.dao.IUserDao;
import me.gacl.domain.User;
import me.gacl.util.XmlUtils;
/**
* IUserDao接口的实现类
* @author gacl
*/
public class UserDaoImpl implements IUserDao {
@Override
public User find(String userName, String userPwd) {
try{
Document document = XmlUtils.getDocument();
//使用XPath表达式来操作XML节点
Element e = (Element) document.selectSingleNode("//user[@userName=‘"+userName+"‘ and @userPwd=‘"+userPwd+"‘]");
if(e==null){
return null;
}
User user = new User();
user.setId(e.attributeValue("id"));
user.setEmail(e.attributeValue("email"));
user.setUserPwd(e.attributeValue("userPwd"));
user.setUserName(e.attributeValue("userName"));
String birth = e.attributeValue("birthday");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
user.setBirthday(sdf.parse(birth));

return user;

}catch (Exception e) {
throw new RuntimeException(e);
}
}
@SuppressWarnings("deprecation")
@Override
public void add(User user) {
try{
Document document = XmlUtils.getDocument();
Element root = document.getRootElement();
Element user_node = root.addElement("user"); //创建user结点，并挂到root
user_node.setAttributeValue("id", user.getId());
user_node.setAttributeValue("userName", user.getUserName());
user_node.setAttributeValue("userPwd", user.getUserPwd());
user_node.setAttributeValue("email", user.getEmail());

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
user_node.setAttributeValue("birthday", sdf.format(user.getBirthday()));

XmlUtils.write2Xml(document);

}catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public User find(String userName) {
try{
Document document = XmlUtils.getDocument();
Element e = (Element) document.selectSingleNode("//user[@userName=‘"+userName+"‘]");
if(e==null){
return null;
}
User user = new User();
user.setId(e.attributeValue("id"));
user.setEmail(e.attributeValue("email"));
user.setUserPwd(e.attributeValue("userPwd"));
user.setUserName(e.attributeValue("userName"));
String birth = e.attributeValue("birthday");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
user.setBirthday(sdf.parse(birth));

return user;

}catch (Exception e) {
throw new RuntimeException(e);
}
}
}
复制代码
3.3、开发service层(service层对web层提供所有的业务服务)
在me.gacl.service包中创建IUserService接口类

IUserService接口的具体代码如下：
复制代码
package me.gacl.service;
import me.gacl.domain.User;
import me.gacl.exception.UserExistException;
public interface IUserService {
/**
* 提供注册服务
* @param user
* @throws UserExistException
*/
void registerUser(User user) throws UserExistException;
/**
* 提供登录服务
* @param userName
* @param userPwd
* @return
*/
User loginUser(String userName, String userPwd);
}
复制代码
在me.gacl.service.impl包中创建UserServiceImpl类

UserServiceImpl类为IUserService接口的具体实现类，具体代码如下：
复制代码
package me.gacl.service.impl;
import me.gacl.dao.IUserDao;
import me.gacl.dao.impl.UserDaoImpl;
import me.gacl.domain.User;
import me.gacl.exception.UserExistException;
import me.gacl.service.IUserService;
public class UserServiceImpl implements IUserService {
private IUserDao userDao = new UserDaoImpl();

@Override
public void registerUser(User user) throws UserExistException {
if (userDao.find(user.getUserName())!=null) {
//checked exception
//unchecked exception
//这里抛编译时异常的原因：是我想上一层程序处理这个异常，以给用户一个友好提示
throw new UserExistException("注册的用户名已存在！！！");
}
userDao.add(user);
}
@Override
public User loginUser(String userName, String userPwd) {
return userDao.find(userName, userPwd);
}
}
复制代码
3.4、开发web层
3.4.1、开发注册功能
　 1、在me.gacl.web.UI包下写一个RegisterUIServlet为用户提供注册界面

RegisterUIServlet收到用户请求后，就跳到register.jsp
RegisterUIServlet的代码如下：
复制代码
package me.gacl.web.UI;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* 为用户提供注册的用户界面的Servlet
* RegisterUIServlet负责为用户输出注册界面
* 当用户访问RegisterUIServlet时，就跳转到WEB-INF/pages目录下的register.jsp页面
*/
public class RegisterUIServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
2、在/WEB-INF/pages/目录下编写用户注册的jsp页面register.jsp

凡是位于WEB-INF目录下的jsp页面是无法直接通过URL地址直接访问的，

在开发中如果项目中有一些敏感web资源不想被外界直接访问，那么可以考虑将这些敏感的web资源放到WEB-INF目录下，这样就可以禁止外界直接通过URL来访问了。
register.jsp页面的代码如下：
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>用户注册</title>
</head>
<body style="text-align: center;">
<form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
<table width="60%" border="1">
<tr>
<td>用户名</td>
<td>

<input type="text" name="userName">
</td>
</tr>
<tr>
<td>密码</td>
<td>
<input type="password" name="userPwd">
</td>
</tr>
<tr>
<td>确认密码</td>
<td>
<input type="password" name="confirmPwd">
</td>
</tr>
<tr>
<td>邮箱</td>
<td>
<input type="text" name="email">
</td>
</tr>
<tr>
<td>生日</td>
<td>
<input type="text" name="birthday">
</td>
</tr>
<tr>
<td>
<input type="reset" value="http://www.mamicode.com/清空">
</td>
<td>
<input type="submit" value="http://www.mamicode.com/注册">
</td>
</tr>
</table>
</form>
</body>
</html>
复制代码
register.jsp中的<form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">指明表单提交后，交给RegisterServlet进行处理
3、在me.gacl.web.controller包下编写用于处理用户注册的RegisterServlet

RegisterServlet担任着以下几个职责：
1、接收客户端提交到服务端的表单数据。
2、校验表单数据的合法性，如果校验失败跳回到register.jsp，并回显错误信息。
3、如果校验通过，调用service层向数据库中注册用户。
为了方便RegisterServlet接收表单数据和校验表单数据，在此我设计一个用于校验注册表单数据RegisterFormbean，再写WebUtils工具类，封装客户端提交的表单数据到formbean中。
在me.gacl.web.formbean包下创建一个用于校验注册表单数据RegisterFormbean

RegisterFormbean代码如下：
复制代码
1 package me.gacl.web.formbean;
2
3 import java.util.HashMap;
4 import java.util.Map;
5
6 import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
7
8 /**
9 * 封装的用户注册表单bean，用来接收register.jsp中的表单输入项的值
* RegisterFormBean中的属性与register.jsp中的表单输入项的name一一对应
* RegisterFormBean的职责除了负责接收register.jsp中的表单输入项的值之外还担任着校验表单输入项的值的合法性
* @author gacl
*
*/
public class RegisterFormBean {
//RegisterFormBean中的属性与register.jsp中的表单输入项的name一一对应
//<input type="text" name="userName"/>
private String userName;
//<input type="password" name="userPwd"/>
private String userPwd;
//<input type="password" name="confirmPwd"/>
private String confirmPwd;
//<input type="text" name="email"/>
private String email;
//<input type="text" name="birthday"/>
private String birthday;

/**
* 存储校验不通过时给用户的错误提示信息
*/
private Map<String, String> errors = new HashMap<String, String>();
public Map<String, String> getErrors() {
return errors;
}
public void setErrors(Map<String, String> errors) {
this.errors = errors;
}
/*
* validate方法负责校验表单输入项
* 表单输入项校验规则：
* private String userName; 用户名不能为空，并且要是3-8的字母 abcdABcd
* private String userPwd; 密码不能为空，并且要是3-8的数字
* private String confirmPwd; 两次密码要一致
* private String email; 可以为空，不为空要是一个合法的邮箱
* private String birthday; 可以为空，不为空时，要是一个合法的日期
*/
public boolean validate() {
boolean isOk = true;
if (this.userName == null || this.userName.trim().equals("")) {
isOk = false;
errors.put("userName", "用户名不能为空！！");
} else {
if (!this.userName.matches("[a-zA-Z]{3,8}")) {
isOk = false;
errors.put("userName", "用户名必须是3-8位的字母！！");
}
}
if (this.userPwd == null || this.userPwd.trim().equals("")) {
isOk = false;
errors.put("userPwd", "密码不能为空！！");
} else {
if (!this.userPwd.matches("\\d{3,8}")) {
isOk = false;
errors.put("userPwd", "密码必须是3-8位的数字！！");
}
}
// private String password2; 两次密码要一致
if (this.confirmPwd != null) {
if (!this.confirmPwd.equals(this.userPwd)) {
isOk = false;
errors.put("confirmPwd", "两次密码不一致！！");
}
}
// private String email; 可以为空，不为空要是一个合法的邮箱
if (this.email != null && !this.email.trim().equals("")) {
if (!this.email.matches("\\w+@\\w+(\\.\\w+)+")) {
isOk = false;
errors.put("email", "邮箱不是一个合法邮箱！！");
}
}
// private String birthday; 可以为空，不为空时，要是一个合法的日期
if (this.birthday != null && !this.birthday.trim().equals("")) {
try {
DateLocaleConverter conver = new DateLocaleConverter();
conver.convert(this.birthday);
} catch (Exception e) {
isOk = false;
errors.put("birthday", "生日必须要是一个日期！！");
}
}
return isOk;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPwd() {
return userPwd;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
public String getConfirmPwd() {
return confirmPwd;
}
public void setConfirmPwd(String confirmPwd) {
this.confirmPwd = confirmPwd;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
}
复制代码
WebUtils工具类
在me.gacl.util包下创建一个WebUtils工具类，该工具类的功能就是封装客户端提交的表单数据到formbean中

复制代码
package me.gacl.util;
import java.util.Enumeration;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.beanutils.BeanUtils;
/**
* @author gacl
* 把request对象中的请求参数封装到bean中
*/
public class WebUtils {
/**
* 将request对象转换成T对象
* @param request
* @param clazz
* @return
*/
public static <T> T request2Bean(HttpServletRequest request,Class<T> clazz){
try{
T bean = clazz.newInstance();
Enumeration<String> e = request.getParameterNames();
while(e.hasMoreElements()){
String name = (String) e.nextElement();
String value = http://www.mamicode.com/request.getParameter(name);
BeanUtils.setProperty(bean, name, value);
}
return bean;
}catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* 生成UUID
* @return
*/
public static String makeId(){
return UUID.randomUUID().toString();
}

}
复制代码
XmlUtils.java
package me.gacl.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class XmlUtils {

private static String filename = "DB.xml";

public static Document getDocument() throws DocumentException{

URL url = XmlUtils.class.getClassLoader().getResource(filename);
String realpath = url.getPath();
System.out.println(realpath);

SAXReader reader = new SAXReader();
return reader.read(new File(realpath));

}

public static void write2Xml(Document document) throws IOException{

URL url = XmlUtils.class.getClassLoader().getResource(filename);
String realpath = url.getPath();
System.out.println(realpath);

OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer = new XMLWriter(new FileOutputStream(realpath), format );
writer.write( document );
writer.close();

}

}

负责处理用户注册的RegisterServlet完整代码：
复制代码
package me.gacl.web.controller;
import java.io.IOException;
import java.util.Date;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
import me.gacl.domain.User;
import me.gacl.exception.UserExistException;
import me.gacl.service.IUserService;
import me.gacl.service.impl.UserServiceImpl;
import me.gacl.util.WebUtils;
import me.gacl.web.formbean.RegisterFormBean;
/**
* 处理用户注册的Servlet
* @author gacl
*
*/
public class RegisterServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//将客户端提交的表单数据封装到RegisterFormBean对象中
RegisterFormBean formbean = WebUtils.request2Bean(request,RegisterFormBean.class);
//校验用户注册填写的表单数据
if (formbean.validate() == false) {//如果校验失败
//将封装了用户填写的表单数据的formbean对象发送回register.jsp页面的form表单中进行显示
request.setAttribute("formbean", formbean);
//校验失败就说明是用户填写的表单数据有问题，那么就跳转回register.jsp
request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
return;
}
User user = new User();
try {
// 注册字符串到日期的转换器
ConvertUtils.register(new DateLocaleConverter(), Date.class);
BeanUtils.copyProperties(user, formbean);//把表单的数据填充到javabean中
user.setId(WebUtils.makeId());//设置用户的Id属性
IUserService service = new UserServiceImpl();
//调用service层提供的注册用户服务实现用户注册
service.registerUser(user);
String message = String.format(
"注册成功！！3秒后为您自动跳到登录页面！！<meta http-equiv=‘refresh‘ content=‘3;url=%s‘/>",
request.getContextPath()+"/servlet/LoginUIServlet");
request.setAttribute("message",message);
request.getRequestDispatcher("/message.jsp").forward(request,response);
} catch (UserExistException e) {
formbean.getErrors().put("userName", "注册用户已存在！！");
request.setAttribute("formbean", formbean);
request.getRequestDispatcher("/WEB-INF/pages/register.jsp").forward(request, response);
} catch (Exception e) {
e.printStackTrace(); // 在后台记录异常
request.setAttribute("message", "对不起，注册失败！！");
request.getRequestDispatcher("/message.jsp").forward(request,response);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
用户注册时如果填写的表单数据校验不通过，那么服务器端就将一个存储了错误提示消息和表单数据的formbean对象存储到request对象中，然后发送回register.jsp页面，因此我们需要在register.jsp页面中取出request对象中formbean对象，然后将用户填写的表单数据重新回显到对应的表单项上面，将出错时的提示消息也显示到form表单上面，让用户知道是哪些数据填写不合法！
修改register.jsp页面，代码如下：
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>用户注册</title>
</head>
<body style="text-align: center;">
<form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
<table width="60%" border="1">
<tr>
<td>用户名</td>
<td>
<%--使用EL表达式${}提取存储在request对象中的formbean对象中封装的表单数据(formbean.userName)以及错误提示消息(formbean.errors.userName)--%>
<input type="text" name="userName" value="http://www.mamicode.com/${formbean.userName}">${formbean.errors.userName}
</td>
</tr>
<tr>
<td>密码</td>
<td>
<input type="password" name="userPwd" value="http://www.mamicode.com/${formbean.userPwd}">${formbean.errors.userPwd}
</td>
</tr>
<tr>
<td>确认密码</td>
<td>
<input type="password" name="confirmPwd" value="http://www.mamicode.com/${formbean.confirmPwd}">${formbean.errors.confirmPwd}
</td>
</tr>
<tr>
<td>邮箱</td>
<td>
<input type="text" name="email" value="http://www.mamicode.com/${formbean.email}">${formbean.errors.email}
</td>
</tr>
<tr>
<td>生日</td>
<td>
<input type="text" name="birthday" value="http://www.mamicode.com/${formbean.birthday}">${formbean.errors.birthday}
</td>
</tr>
<tr>
<td>
<input type="reset" value="http://www.mamicode.com/清空">
</td>
<td>
<input type="submit" value="http://www.mamicode.com/注册">
</td>
</tr>
</table>
</form>
</body>
</html>
复制代码
到此，用户注册功能就算是开发完成了！
下面测试一下开发好的用户注册功能：
输入URL地址：http://localhost:8080/webmvcframework/servlet/RegisterUIServlet访问register.jsp页面，运行效果如下：

如果输入的表单项不符合校验规则，那么是无法进行注册的，运行效果如下：

3.4.2、开发登录功能
1、在me.gacl.web.UI包下写一个LoginUIServlet为用户提供登录界面

LoginUIServlet收到用户请求后，就跳到login.jsp
LoginUIServlet的代码如下：
复制代码
package me.gacl.web.UI;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author gacl
* LoginUIServlet负责为用户输出登陆界面
* 当用户访问LoginUIServlet时，就跳转到WEB-INF/pages目录下的login.jsp页面
*/
public class LoginUIServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.getRequestDispatcher("/WEB-INF/pages/login.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
2、在/WEB-INF/pages/目录下编写用户登录的jsp页面login.jsp

login.jsp页面的代码如下：
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>用户登陆</title>
</head>

<body>
<form action="${pageContext.request.contextPath }/servlet/LoginServlet" method="post">
用户名：<input type="text" name="username"><br/>
密码：<input type="password" name="password"><br/>
<input type="submit" value="http://www.mamicode.com/登陆">
</form>
</body>
</html>
复制代码
login.jsp中的<form action="${pageContext.request.contextPath}/servlet/LoginServlet" method="post">指明表单提交后，交给LoginServlet进行处理。
3、在me.gacl.web.controller包下编写用于处理用户登录的LoginServlet

LoginServlet的代码如下：
复制代码
package me.gacl.web.controller;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import me.gacl.domain.User;
import me.gacl.service.IUserService;
import me.gacl.service.impl.UserServiceImpl;
/**
* 处理用户登录的servlet
* @author gacl
*
*/
public class LoginServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//获取用户填写的登录用户名
String username = request.getParameter("username");
//获取用户填写的登录密码
String password = request.getParameter("password");

IUserService service = new UserServiceImpl();
//用户登录
User user = service.loginUser(username, password);
if(user==null){
String message = String.format(
"对不起，用户名或密码有误！！请重新登录！2秒后为您自动跳到登录页面！！<meta http-equiv=‘refresh‘ content=‘2;url=%s‘",
request.getContextPath()+"/servlet/LoginUIServlet");
request.setAttribute("message",message);
request.getRequestDispatcher("/message.jsp").forward(request, response);
return;
}
//登录成功后，就将用户存储到session中
request.getSession().setAttribute("user", user);
String message = String.format(
"恭喜：%s,登陆成功！本页将在3秒后跳到首页！！<meta http-equiv=‘refresh‘ content=‘3;url=%s‘",
user.getUserName(),
request.getContextPath()+"/index.jsp");
request.setAttribute("message",message);
request.getRequestDispatcher("/message.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
到此，用户登录的功能就算是开发完成了。
下面测试一下开发好的用户登录功能，输入URL地址：http://localhost:8080/webmvcframework/servlet/LoginUIServlet访问login.jsp页面，输入正确的用户名和密码进行登录，运行效果如下：

如果输入的用户名和密码错误，那么就无法登录成功，运行效果如下：

3.4.3、开发注销功能
在me.gacl.web.controller包下编写用于处理用户注销的LogoutServlet
LogoutServlet的代码如下：
复制代码
package me.gacl.web.controller;
import java.io.IOException;
import java.text.MessageFormat;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LogoutServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//移除存储在session中的user对象，实现注销功能
request.getSession().removeAttribute("user");
//由于字符串中包含有单引号，在这种情况下使用MessageFormat.format方法拼接字符串时就会有问题
//MessageFormat.format方法只是把字符串中的单引号去掉，不会将内容填充到指定的占位符中
String tempStr1 = MessageFormat.format(
"注销成功！！3秒后为您自动跳到登录页面！！<meta http-equiv=‘refresh‘ content=‘3;url={0}‘/>",
request.getContextPath()+"/servlet/LoginUIServlet");
System.out.println(tempStr1);//输出结果：注销成功！！3秒后为您自动跳到登录页面！！<meta http-equiv=refresh content=3;url={0}/>
System.out.println("---------------------------------------------------------");
/**
* 要想解决"如果要拼接的字符串包含有单引号，那么MessageFormat.format方法就只是把字符串中的单引号去掉，不会将内容填充到指定的占位符中"这个问题，
* 那么可以需要使用单引号引起来的字符串中使用2个单引号引起来，例如："<meta http-equiv=‘‘refresh‘‘ content=‘‘3;url={0}‘‘/>"
* 这样MessageFormat.format("<meta http-equiv=‘‘refresh‘‘ content=‘‘3;url={0}‘‘/>","index.jsp")就可以正常返回
* <meta http-equiv=‘‘refresh‘‘ content=‘‘3;url=index.jsp‘/>
*/
String tempStr2 = MessageFormat.format(
"注销成功！！3秒后为您自动跳到登录页面！！<meta http-equiv=‘‘refresh‘‘ content=‘‘3;url={0}‘‘/>",
request.getContextPath()+"/servlet/LoginUIServlet");
/**
* 输出结果：
* 注销成功！！3秒后为您自动跳到登录页面！！
* <meta http-equiv=‘refresh‘ content=‘3;url=/webmvcframework/servlet/LoginUIServlet‘/>
*/
System.out.println(tempStr2);

String message = String.format(
"注销成功！！3秒后为您自动跳到登录页面！！<meta http-equiv=‘refresh‘ content=‘3;url=%s‘/>",
request.getContextPath()+"/servlet/LoginUIServlet");
request.setAttribute("message",message);
request.getRequestDispatcher("/message.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
用户登录成功后，会将登录的用户信息存储在session中，所以我们要将存储在session中的user删除掉，这样就可以实现用户注销了。
用户登录成功后就会跳转到index.jsp页面，在index.jsp页面中放一个【退出登陆】按钮，当点击【退出登陆】按钮时，就访问LogoutServlet，将用户注销。
index.jsp的代码如下：
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
<%--为了避免在jsp页面中出现java代码，这里引入jstl标签库，利用jstl标签库提供的标签来做一些逻辑判断处理 --%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE HTML>
<html>
<head>
<title>首页</title>
<script type="text/javascript">
function doLogout(){
//访问LogoutServlet注销当前登录的用户
window.location.href="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/LogoutServlet";
}
</script>
</head>

<body>
<h1>孤傲苍狼的网站</h1>
<hr/>
<c:if test="${user==null}">
<a href="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/RegisterUIServlet" target="_blank">注册</a>
<a href="http://www.mamicode.com/${pageContext.request.contextPath}/servlet/LoginUIServlet">登陆</a>
</c:if>
<c:if test="${user!=null}">
欢迎您：${user.userName}
<input type="button" value="http://www.mamicode.com/退出登陆" onclick="doLogout()">
</c:if>
<hr/>
</body>
</html>
复制代码
测试开发好的注销功能，效果如下：

到此，所有的功能都开发完成了，测试也通过了。
四、开发总结
通过这个小例子，可以了解到mvc分层架构的项目搭建，在平时的项目开发中，也都是按照如下的顺序来进行开发的：
1、搭建开发环境
1.1 创建web项目
1.2 导入项目所需的开发包
1.3 创建程序的包名，在java中是以包来体现项目的分层架构的
2、开发domain
把一张要操作的表当成一个VO类(VO类只定义属性以及属性对应的get和set方法，没有涉及到具体业务的操作方法)，VO表示的是值对象，通俗地说，就是把表中的每一条记录当成一个对象，表中的每一个字段就作为这个对象的属性。每往表中插入一条记录，就相当于是把一个VO类的实例对象插入到数据表中，对数据表进行操作时，都是直接把一个VO类的对象写入到表中，一个VO类对象就是一条记录。每一个VO对象可以表示一张表中的一行记录，VO类的名称要和表的名称一致或者对应。
3、开发dao
3.1 DAO操作接口：每一个DAO操作接口规定了，一张表在一个项目中的具体操作方法，此接口的名称最好按照如下格式编写：“I表名称Dao”。
├DAO接口里面的所有方法按照以下的命名编写：
├更新数据库：doXxx()
├查询数据库：findXxx()或getXxx()
3.2 DAO操作接口的实现类：实现类中完成具体的增删改查操作
├此实现类完成的只是数据库中最核心的操作，并没有专门处理数据库的打开和关闭，因为这些操作与具体的业务操作无关。
4、开发service(service 对web层提供所有的业务服务)
5、开发web层

(二十三)——jsp自定义标签开发入门
一、自定义标签的作用
自定义标签主要用于移除Jsp页面中的java代码。
二、自定义标签开发和使用
2.1、自定义标签开发步骤
1、编写一个实现Tag接口的Java类(标签处理器类)
复制代码
package me.gacl.web.tag;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
public class ViewIPTag implements Tag {
//接收传递进来的PageContext对象
private PageContext pageContext;

@Override
public int doEndTag() throws JspException {
System.out.println("调用doEndTag()方法");
return 0;
}
@Override
public int doStartTag() throws JspException {
System.out.println("调用doStartTag()方法");
HttpServletRequest request =(HttpServletRequest) pageContext.getRequest();
JspWriter out = pageContext.getOut();
String ip = request.getRemoteAddr();
try {
//这里输出的时候会抛出IOException异常
out.write(ip);
} catch (IOException e) {
//捕获IOException异常后继续抛出
throw new RuntimeException(e);
}
return 0;
}
@Override
public Tag getParent() {
return null;
}
@Override
public void release() {
System.out.println("调用release()方法");
}
@Override
public void setPageContext(PageContext pageContext) {
System.out.println("setPageContext(PageContext pageContext)");
this.pageContext = pageContext;
}
@Override
public void setParent(Tag arg0) {
}
}
复制代码
2、在WEB-INF/目录下新建tld文件，在tld文件中对标签处理器类进行描述

gacl.tld文件的代码如下：
复制代码
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">

<description>孤傲苍狼开发的自定义标签库</description>

<tlib-version>1.0</tlib-version>
<short-name>GaclTagLibrary</short-name>

<uri>/gacl</uri>



<tag>
<description>这个标签的作用是用来输出客户端的IP地址</description>

<name>viewIP</name>

<tag-class>me.gacl.web.tag.ViewIPTag</tag-class>
<body-content>empty</body-content>
</tag>

</taglib>
复制代码
2.2、在Jsp页面中使用自定义标签
1、使用"<%@taglib uri="标签库的uri" prefix="标签的使用前缀"%>"指令引入要使用的标签库。
例如：在jspTag_Test1.jsp中引用gacl标签库
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>

<%@taglib uri="/gacl" prefix="xdp"%>
<!DOCTYPE HTML>
<html>
<head>
<title>输出客户端的IP</title>
</head>

<body>
你的IP地址是(使用java代码获取输出)：
<%
//在jsp页面中使用java代码获取客户端IP地址
String ip = request.getRemoteAddr();
out.write(ip);
%>
<hr/>
你的IP地址是(使用自定义标签获取输出)：
<%--使用自定义标签viewIP --%>
<xdp:viewIP/>
</body>
</html>
复制代码
标签的运行效果如下：

从运行效果种可以看到，使用自定义标签就可以将jsp页面上的java代码移除掉，如需要在jsp页面上输出客户端的IP地址时，使用 <xdp:viewIP/>标签就可以代替jsp页面上的这些代码：
<%
//在jsp页面中使用java代码获取客户端IP地址
String ip = request.getRemoteAddr();
out.write(ip);
%>
这就是开发和使用自定义标签的好处，可以让我们的Jsp页面上不嵌套java代码。
三、自定义标签的执行流程
JSP引擎遇到自定义标签时，首先创建标签处理器类的实例对象，然后按照JSP规范定义的通信规则依次调用它的方法。
1、public void setPageContext(PageContext pc)， JSP引擎实例化标签处理器后，将调用setPageContext方法将JSP页面的pageContext对象传递给标签处理器，标签处理器以后可以通过这个pageContext对象与JSP页面进行通信。
2、public void setParent(Tag t)，setPageContext方法执行完后，WEB容器接着调用的setParent方法将当前标签的父标签传递给当前标签处理器，如果当前标签没有父标签，则传递给setParent方法的参数值为null。
3、public int doStartTag()，调用了setPageContext方法和setParent方法之后，WEB容器执行到自定义标签的开始标记时，就会调用标签处理器的doStartTag方法。
4、public int doEndTag()，WEB容器执行完自定义标签的标签体后，就会接着去执行自定义标签的结束标记，此时，WEB容器会去调用标签处理器的doEndTag方法。
5、public void release()，通常WEB容器执行完自定义标签后，标签处理器会驻留在内存中，为其它请求服务器，直至停止web应用时，web容器才会调用release方法。
我们在tomcat服务器的"work\Catalina\localhost\JavaWeb_JspTag_study_20140816\org\apache\jsp"目录下可以找到将jspTag_Test1.jsp翻译成Servlet后的java源代码，如下图所示：

打开jspTag_005fTest1_jsp.java文件，可以看到setPageContext(PageContext pc)、setParent(Tag t)、doStartTag()、doEndTag()、release()这5个方法的调用顺序和过程。
jspTag_005fTest1_jsp.java的代码如下：
复制代码
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class jspTag_005fTest1_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {

private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
private static java.util.List _jspx_dependants;
static {
_jspx_dependants = new java.util.ArrayList(1);
_jspx_dependants.add("/WEB-INF/gacl.tld");
}
private org.apache.jasper.runtime.TagHandlerPool _005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.AnnotationProcessor _jsp_annotationprocessor;
public Object getDependants() {
return _jspx_dependants;
}
public void _jspInit() {
_005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody = org.apache.jasper.runtime.TagHandlerPool.getTagHandlerPool(getServletConfig());
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());
}
public void _jspDestroy() {
_005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody.release();
}
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;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\r\n");
out.write("\r\n");
out.write("\r\n");
out.write("<!DOCTYPE HTML>\r\n");
out.write("<html>\r\n");
out.write(" <head>\r\n");
out.write(" <title>输出客户端的IP</title>\r\n");
out.write(" </head>\r\n");
out.write(" \r\n");
out.write(" <body>\r\n");
out.write(" 你的IP地址是(使用java代码获取输出)：\r\n");
out.write(" ");
//在jsp页面中使用java代码获取客户端IP地址
String ip = request.getRemoteAddr();
out.write(ip);

out.write("\r\n");
out.write(" <hr/>\r\n");
out.write(" 你的IP地址是(使用自定义标签获取输出)：");
if (_jspx_meth_xdp_005fviewIP_005f0(_jspx_page_context))
return;
out.write("\r\n");
out.write(" </body>\r\n");
out.write("</html>\r\n");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try { out.clearBuffer(); } catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
private boolean _jspx_meth_xdp_005fviewIP_005f0(PageContext _jspx_page_context)
throws Throwable {
PageContext pageContext = _jspx_page_context;
JspWriter out = _jspx_page_context.getOut();
// xdp:viewIP
me.gacl.web.tag.ViewIPTag _jspx_th_xdp_005fviewIP_005f0 = (me.gacl.web.tag.ViewIPTag) _005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody.get(me.gacl.web.tag.ViewIPTag.class);
_jspx_th_xdp_005fviewIP_005f0.setPageContext(_jspx_page_context);
_jspx_th_xdp_005fviewIP_005f0.setParent(null);
int _jspx_eval_xdp_005fviewIP_005f0 = _jspx_th_xdp_005fviewIP_005f0.doStartTag();
if (_jspx_th_xdp_005fviewIP_005f0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE) {
_005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody.reuse(_jspx_th_xdp_005fviewIP_005f0);
return true;
}
_005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody.reuse(_jspx_th_xdp_005fviewIP_005f0);
return false;
}
}
复制代码
下面重点分析一下上述代码中标红色的那个 private boolean _jspx_meth_xdp_005fviewIP_005f0(PageContext _jspx_page_context)方法中的代码
①、这里是实例化一个viewIP标签处理器类me.gacl.web.tag.ViewIPTag的对象
// xdp:viewIP
me.gacl.web.tag.ViewIPTag _jspx_th_xdp_005fviewIP_005f0 = (me.gacl.web.tag.ViewIPTag) _005fjspx_005ftagPool_005fxdp_005fviewIP_005fnobody.get(me.gacl.web.tag.ViewIPTag.class);
②、实例化标签处理器后，调用setPageContext方法将JSP页面的pageContext对象传递给标签处理器
_jspx_th_xdp_005fviewIP_005f0.setPageContext(_jspx_page_context);
③、setPageContext方法执行完后，接着调用的setParent方法将当前标签的父标签传递给当前标签处理器，如果当前标签没有父标签，则传递给setParent方法的参数值为null
_jspx_th_xdp_005fviewIP_005f0.setParent(null);
④、调用了setPageContext方法和setParent方法之后，WEB容器执行到自定义标签的开始标记时，就会调用标签处理器的doStartTag方法
int _jspx_eval_xdp_005fviewIP_005f0 = _jspx_th_xdp_005fviewIP_005f0.doStartTag();
⑤、WEB容器执行完自定义标签的标签体后，就会接着去执行自定义标签的结束标记，此时，WEB容器会去调用标签处理器的doEndTag方法
if (_jspx_th_xdp_005fviewIP_005f0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE)
这就是自定义标签的执行流程。
这里以一个入门级的案例来讲解javaweb的自定义标签开发，在后面的博文中会进行更加详尽的介绍。

(二十四)——jsp传统标签开发
一、标签技术的API
1.1、标签技术的API类继承关系

二、标签API简单介绍
2.1、JspTag接口
JspTag接口是所有自定义标签的父接口，它是JSP2.0中新定义的一个标记接口，没有任何属性和方法。JspTag接口有Tag和SimpleTag两个直接子接口，JSP2.0以前的版本中只有Tag接口，所以把实现Tag接口的自定义标签也叫做传统标签，把实现SimpleTag接口的自定义标签叫做简单标签。
2.2、Tag接口
Tag接口是所有传统标签的父接口，其中定义了两个重要方法（doStartTag、doEndTag）方法和四个常量（EVAL_BODY_INCLUDE、SKIP_BODY、EVAL_PAGE、SKIP_PAGE），这两个方法和四个常量的作用如下：
（1）WEB容器在解释执行JSP页面的过程中，遇到自定义标签的开始标记就会去调用标签处理器的doStartTag方法，doStartTag方法执行完后可以向WEB容器返回常量EVAL_BODY_INCLUDE或SKIP_BODY。如果doStartTag方法返回EVAL_BODY_INCLUDE，WEB容器就会接着执行自定义标签的标签体；如果doStartTag方法返回SKIP_BODY，WEB容器就会忽略自定义标签的标签体，直接解释执行自定义标签的结束标记。
（2）WEB容器解释执行到自定义标签的结束标记时，就会调用标签处理器的doEndTag方法，doEndTag方法执行完后可以向WEB容器返回常量EVAL_PAGE或SKIP_PAGE。如果doEndTag方法返回常量EVAL_PAGE，WEB容器就会接着执行JSP页面中位于结束标记后面的JSP代码；如果doEndTag方法返回SKIP_PAGE，WEB容器就会忽略JSP页面中位于结束标记后面的所有内容。
从doStartTag和doEndTag方法的作用和返回值的作用可以看出，开发自定义标签时可以在doStartTag方法和doEndTag方法体内编写合适的Java程序代码来实现具体的功能，通过控制doStartTag方法和doEndTag方法的返回值，还可以告诉WEB容器是否执行自定义标签中的标签体内容和JSP页面中位于自定义标签的结束标记后面的内容。
2.3、IterationTag接口
IterationTag接口继承了Tag接口，并在Tag接口的基础上增加了一个doAfterBody方法和一个EVAL_BODY_AGAIN常量。实现IterationTag接口的标签除了可以完成Tag接口所能完成的功能外，还能够通知WEB容器是否重复执行标签体内容。对于实现了IterationTag接口的自定义标签，WEB容器在执行完自定义标签的标签体后，将调用标签处理器的doAfterBody方法，doAfterBody方法可以向WEB容器返回常量EVAL_BODY_AGAIN或SKIP_BODY。如果doAfterBody方法返回EVAL_BODY_AGAIN，WEB容器就会把标签体内容再重复执行一次，执行完后接着再调用doAfterBody方法，如此往复，直到doAfterBody方法返回常量SKIP_BODY，WEB容器才会开始处理标签的结束标记和调用doEndTag方法。
可见，开发自定义标签时，可以通过控制doAfterBody方法的返回值来告诉WEB容器是否重复执行标签体内容，从而达到循环处理标签体内容的效果。例如，可以通过一个实现IterationTag接口的标签来迭代输出一个集合中的所有元素，在标签体部分指定元素的输出格式。
在JSP API中也提供了IterationTag接口的默认实现类TagSupport，我们在编写自定义标签的标签处理器类时，可以继承和扩展TagSupport类，这相比实现IterationTag接口将简化开发工作。
2.4、BodyTag接口
BodyTag接口继承了IterationTag接口，并在IterationTag接口的基础上增加了两个方法（setBodyContent、doInitBody）和一个EVAL_BODY_BUFFERED常量。实现BodyTag接口的标签除了可以完成IterationTag接口所能完成的功能，还可以对标签体内容进行修改。对于实现了BodyTag接口的自定义标签，标签处理器的doStartTag方法不仅可以返回前面讲解的常量EVAL_BODY_INCLUDE或SKIP_BODY，还可以返回常量EVAL_BODY_BUFFERED。如果doStartTag方法返回EVAL_BODY_BUFFERED，WEB容器就会创建一个专用于捕获标签体运行结果的BodyContent对象，然后调用标签处理器的setBodyContent方法将BodyContent对象的引用传递给标签处理器，WEB容器接着将标签体的执行结果写入到BodyContent对象中。在标签处理器的后续事件方法中，可以通过先前保存的BodyContent对象的引用来获取标签体的执行结果，然后调用BodyContent对象特有的方法对BodyContent对象中的内容（即标签体的执行结果）进行修改和控制其输出。
在JSP API中也提供了BodyTag接口的实现类BodyTagSupport，我们在编写能够修改标签体内容的自定义标签的标签处理器类时，可以继承和扩展BodyTagSupport类，这相比实现BodyTag接口将简化开发工作。
2.5、SimpleTag接口
SimpleTag接口是JSP2.0中新增的一个标签接口。由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广，因此，SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口。SimpleTag接口与传统标签接口最大的区别在于，SimpleTag接口只定义了一个用于处理标签逻辑的doTag方法，该方法在WEB容器执行自定义标签时调用，并且只被调用一次。那些使用传统标签接口所完成的功能，例如是否执行标签体、迭代标签体、对标签体内容进行修改等功能都可以在doTag方法中完成。
在JSP API中也提供了SimpleTag接口的实现类SimpleTagSupport，我们在编写简单标签时，可以继承和扩展SimpleTagSupport类，这相比实现SimpleTag接口将简化开发工作。
2.6、传统标签接口中的各个方法可以返回的返回值说明
下图列举了Tag接口、IterationTag接口和BodyTag接口中的主要方法及它们分别可以返回的返回值的说明。

三、开发传统标签实现页面逻辑
开发人员在编写Jsp页面时，经常还需要在页面中引入一些逻辑，例如：
控制jsp页面某一部分内容是否执行。
控制整个jsp页面是否执行。
控制jsp页面内容重复执行。
修改jsp页面内容输出。
自定义标签除了可以移除jsp页面java代码外，它也可以实现以上功能。
3.1、控制jsp页面某一部分内容是否执行
编写一个类实现tag接口，控制doStartTag()方法的返回值，如果这个方法返回EVAL_BODY_INCLUDE，则执行标签体，如果返回SKIP_BODY，则不执行标签体。
SUN公司针对tag接口提供了一个默认的实现类TagSupport，TagSupport类中实现了tag接口的所有方法，因此我们可以编写一个类继承TagSupport类，然后再重写doStartTag方法。
示例代码如下：
TagDemo1.java
package me.gacl.web.tag;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
/**
* @author gacl
* TagSupport类实现了Tag接口，TagDemo1继承TagSupport类
*
*/
public class TagDemo1 extends TagSupport {
/* 重写doStartTag方法，控制标签体是否执行
* @see javax.servlet.jsp.tagext.TagSupport#doStartTag()
*/
@Override
public int doStartTag() throws JspException {
//如果这个方法返回EVAL_BODY_INCLUDE，则执行标签体，如果返回SKIP_BODY，则不执行标签体
//return Tag.EVAL_BODY_INCLUDE;
return Tag.SKIP_BODY;
}
}
在WEB-INF目录下的tld文件中添加对该标签处理类的描述，如下：
<tag>
<name>demo1</name>
<tag-class>me.gacl.web.tag.TagDemo1</tag-class>

<body-content>JSP</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gacl" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>控制标签体是否执行</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 demo1标签是带有标签体的，标签体的内容是"孤傲苍狼"这几个字符串--%>
<gacl:demo1>
孤傲苍狼
</gacl:demo1>
</body>
</html>

运行效果如下：
　
3.2、控制整个jsp页面是否执行
编写一个类实现tag接口，控制doEndTag()方法的返回值，如果这个方法返回EVAL_PAGE，则执行标签余下的jsp页面，如果返回SKIP_PAGE，则不执行余下的jsp。
示例代码如下：
TagDemo2.java
package me.gacl.web.tag;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
/**
* @author gacl
* TagSupport类实现了Tag接口，TagDemo2继承TagSupport类
*/
public class TagDemo2 extends TagSupport{
/* 重写doEndTag方法，控制jsp页面是否执行
* @see javax.servlet.jsp.tagext.TagSupport#doEndTag()
*/
@Override
public int doEndTag() throws JspException {
//如果这个方法返回EVAL_PAGE，则执行标签余下的jsp页面，如果返回SKIP_PAGE，则不执行余下的jsp
return Tag.SKIP_PAGE;
//return Tag.EVAL_PAGE;
}
}
在WEB-INF目录下的tld文件中添加对该标签处理类的描述，如下：
<tag>
<name>demo2</name>
<tag-class>me.gacl.web.tag.TagDemo2</tag-class>

<body-content>empty</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gacl" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>控制jsp页面是否执行</title>
</head>
<body>
<h1>jsp页面的内容1</h1>
<%--在jsp页面中使用自定义标签 demo2标签是不带标签体的--%>
<gacl:demo2/>
<h1>jsp页面的内容2</h1>
</body>
</html>

运行效果如下：
　
3.3、控制jsp页面内容重复执行
编写一个类实现Iterationtag接口，控制doAfterBody()方法的返回值，如果这个方法返回EVAL_BODY_AGAIN，则web服务器又执行一次标签体，依次类推，一直执行到doAfterBody方法返回SKIP_BODY，则标签体才不会重复执行。
示例代码如下：
TagDemo3.java
package me.gacl.web.tag;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.IterationTag;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
public class TagDemo3 extends TagSupport {
int x = 5;
@Override
public int doStartTag() throws JspException {
return Tag.EVAL_BODY_INCLUDE;
}
/* 控制doAfterBody()方法的返回值，
* 如果这个方法返回EVAL_BODY_AGAIN，则web服务器又执行一次标签体，
* 依次类推，一直执行到doAfterBody方法返回SKIP_BODY，则标签体才不会重复执行。
* @see javax.servlet.jsp.tagext.TagSupport#doAfterBody()
*/
@Override
public int doAfterBody() throws JspException {
x--;
if(x>0){
return IterationTag.EVAL_BODY_AGAIN;
}else{
return IterationTag.SKIP_BODY;
}
}
}
在WEB-INF目录下的tld文件中添加对该标签处理类的描述，如下：
<tag>
<name>demo3</name>
<tag-class>me.gacl.web.tag.TagDemo3</tag-class>

<body-content>JSP</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gacl" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>控制页面内容重复执行5次</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 demo3标签--%>
<gacl:demo3>
<h3>jsp页面的内容</h3>
</gacl:demo3>
</body>
</html>
运行效果如下：

3.4、修改jsp页面内容输出
编写一个类实现BodyTag接口，控制doStartTag()方法返回EVAL_BODY_BUFFERED，则web服务器会创建BodyContent对象捕获标签体，然后在doEndTag()方法体内，得到代表标签体的bodyContent对象，从而就可以对标签体进行修改操作。
SUN公司针对BodyTag接口提供了一个默认的实现类BodyTagSupport，BodyTagSupport类中实现了BodyTag接口的所有方法，因此我们可以编写一个类继承BodyTagSupport类，然后再根据需要重写doStartTag方法和doEndTag()方法。
示例代码如下：
TagDemo4.java
package me.gacl.web.tag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTag;
import javax.servlet.jsp.tagext.BodyTagSupport;
import javax.servlet.jsp.tagext.Tag;
/**
* @author gacl
* BodyTagSupport类实现了BodyTag接口接口，TagDemo4继承 BodyTagSupport类
*/
public class TagDemo4 extends BodyTagSupport {
/* 控制doStartTag()方法返回EVAL_BODY_BUFFERED
* @see javax.servlet.jsp.tagext.BodyTagSupport#doStartTag()
*/
@Override
public int doStartTag() throws JspException {
return BodyTag.EVAL_BODY_BUFFERED;
}
@Override
public int doEndTag() throws JspException {
//this.getBodyContent()得到代表标签体的bodyContent对象
BodyContent bodyContent = this.getBodyContent();
//拿到标签体
String content = bodyContent.getString();
//修改标签体里面的内容，将标签体的内容转换成大写
String result = content.toUpperCase();
try {
//输出修改后的内容
this.pageContext.getOut().write(result);
} catch (IOException e) {
throw new RuntimeException(e);
}
return Tag.EVAL_PAGE;
}
}
在WEB-INF目录下的tld文件中添加对该标签处理类的描述，如下：
<tag>
<name>demo4</name>
<tag-class>me.gacl.web.tag.TagDemo4</tag-class>

<body-content>JSP</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gacl" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>修改jsp页面内容输出</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 demo4标签--%>
<gacl:demo4>
<h3>xdp_gacl</h3>
</gacl:demo4>
</body>
</html>
运行效果如下：

四、jsp传统标签开发总结
在现在的jsp标签开发中，很少直接使用传统标签来开发了，目前用得较多的都是简单标签，所以Jsp的传统标签开发了解一下即可，下一篇重点介绍jsp简单标签的开发

(二十五)——jsp简单标签开发(一)
javaweb学习总结(二十五)——jsp简单标签开发(一)
一、简单标签(SimpleTag)
由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广， SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。

实现SimpleTag接口的标签通常称为简单标签。简单标签共定义了5个方法：
setJspContext方法
setParent和getParent方法
setJspBody方法
doTag方法(非常重要)，简单标签使用这个方法就可以完成所有的业务逻辑
二、SimpleTag方法介绍
2.1、setJspContext方法
用于把JSP页面的pageContext对象传递给标签处理器对象
2.2、setParent方法
用于把父标签处理器对象传递给当前标签处理器对象
2.3、getParent方法
用于获得当前标签的父标签处理器对象
2.4、setJspBody方法
用于把代表标签体的JspFragment对象传递给标签处理器对象
2.5、doTag方法
用于完成所有的标签逻辑，包括输出、迭代、修改标签体内容等。在doTag方法中可以抛出javax.servlet.jsp.SkipPageException异常，用于通知WEB容器不再执行JSP页面中位于结束标记后面的内容，这等效于在传统标签的doEndTag方法中返回Tag.SKIP_PAGE常量的情况。
三、SimpleTag接口方法的执行顺序
当web容器开始执行标签时，会调用如下方法完成标签的初始化：
1. WEB容器调用标签处理器对象的setJspContext方法，将代表JSP页面的pageContext对象传递给标签处理器对象。
2. WEB容器调用标签处理器对象的setParent方法，将父标签处理器对象传递给这个标签处理器对象。注意，只有在标签存在父标签的情况下，WEB容器才会调用这个方法。
3. 如果调用标签时设置了属性，容器将调用每个属性对应的setter方法把属性值传递给标签处理器对象。如果标签的属性值是EL表达式或脚本表达式，则WEB容器首先计算表达式的值，然后把值传递给标签处理器对象。
4. 如果简单标签有标签体，WEB容器将调用setJspBody方法把代表标签体的JspFragment对象传递进来。
5. 执行标签时WEB容器调用标签处理器的doTag()方法，开发人员在方法体内通过操作JspFragment对象，就可以实现是否执行、迭代、修改标签体的目的。
四、开发简单标签实现页面逻辑
SUN公司针对SimpleTag接口提供了一个默认的实现类SimpleTagSupport，SimpleTagSupport类中实现了SimpleTag接口的所有方法，因此我们可以编写一个类继承SimpleTagSupport类，然后根据业务需要再重写doTag方法。
4.1、控制jsp页面某一部分内容是否执行
　编写一个类继承SimpleTagSupport，然后再重写doTag方法，在doTag方法里面不调用jspFrament.invoke方法即可。
示例代码如下：
SimpleTagDemo1.java
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo1类继承SimpleTagSupport
*/
public class SimpleTagDemo1 extends SimpleTagSupport {
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，控制标签体是否执行
*/
@Override
public void doTag() throws JspException, IOException {
//得到代表jsp标签体的JspFragment
JspFragment jspFragment = this.getJspBody();
//得到jsp页面的的PageContext对象
//PageContext pageContext = (PageContext) jspFragment.getJspContext();
//调用JspWriter将标签体的内容输出到浏览器
//jspFragment.invoke(pageContext.getOut());
//将标签体的内容输出到浏览器，注释下面一行就不显示
jspFragment.invoke(null);
}
}
在WEB-INF目录下新建一个simpletag.tld文件，然后在simpletag.tld文件中添加对该标签处理类的描述，如下：

simpletag.tld文件代码如下：
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">

<description>孤傲苍狼开发的SimpleTag自定义标签库</description>

<tlib-version>1.0</tlib-version>
<short-name>GaclSimpleTagLibrary</short-name>

<uri>/simpletag</uri>


<tag>
<description>SimpleTag(简单标签)Demo1</description>

<name>demo1</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo1</tag-class>

<body-content>scriptless</body-content>
</tag>
</taglib>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/simpletag" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>用简单标签控制标签体是否执行</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 demo1标签是带有标签体的，标签体的内容是"孤傲苍狼"这几个字符串--%>
<gacl:demo1>
孤傲苍狼
</gacl:demo1>
</body>
</html>

运行效果如下：

4.2、控制jsp页面内容重复执行
编写一个类继承SimpleTagSupport，然后再重写doTag方法，在doTag方法里面重复调用jspFrament.invoke方法即可。
示例代码如下：
SimpleTagDemo2.java
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo2类继承SimpleTagSupport
*/
public class SimpleTagDemo2 extends SimpleTagSupport {
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，控制标签执行5次
*/
@Override
public void doTag() throws JspException, IOException {
// 得到代表jsp标签体的JspFragment
JspFragment jspFragment = this.getJspBody();
for (int i = 0; i < 5; i++) {
// 将标签体的内容输出到浏览器
jspFragment.invoke(null);
}
}
}
在WEB-INF目录下的simpletag.tld文件中添加对该标签处理类的描述，如下：
<tag>

<name>demo2</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo2</tag-class>

<body-content>scriptless</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/simpletag" prefix="gacl" %>
<!DOCTYPE HTML>
<html>
<head>
<title>用简单标签控制标签体执行5次</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 --%>
<gacl:demo2>
孤傲苍狼<p/>
</gacl:demo2>
</body>
</html>

运行效果如下：

4.3、修改jsp页面内容输出
编写一个类继承SimpleTagSupport，然后再重写doTag方法，在doTag方法调用jspFrament.invoke方法时，让执行结果写一个自定义的缓冲中即可，然后开发人员可以取出缓冲的数据修改输出。
示例代码如下：
SimpleTagDemo3.java
package me.gacl.web.simpletag;
import java.io.IOException;
import java.io.StringWriter;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo3类继承SimpleTagSupport
*/
public class SimpleTagDemo3 extends SimpleTagSupport {
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，修改标签体里面的内容，将标签体的内容转换成大写
*/
@Override
public void doTag() throws JspException, IOException {
// 得到代表jsp标签体的JspFragment
JspFragment jspFragment = this.getJspBody();
StringWriter sw = new StringWriter();
//将标签体的内容写入到sw流中
jspFragment.invoke(sw);
//获取sw流缓冲区的内容
String content = sw.getBuffer().toString();
content = content.toUpperCase();
PageContext pageContext = (PageContext) this.getJspContext();
//将修改后的content输出到浏览器中
pageContext.getOut().write(content);
}
}
在WEB-INF目录下的simpletag.tld文件中添加对该标签处理类的描述，如下：
<tag>

<name>demo3</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo3</tag-class>

<body-content>scriptless</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%--<%@taglib uri="/simpletag" prefix="gacl" %>--%>
<%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录 --%>
<%@taglib uri="/WEB-INF/simpletag.tld" prefix="gacl"%>
<!DOCTYPE HTML>
<html>
<head>
<title>用简单标签修改jsp页面内容输出</title>
</head>
<body>
<%--在jsp页面中使用自定义标签 --%>
<gacl:demo3>
gacl_xdp
</gacl:demo3>
</body>
</html>
运行效果如下：

4.4、控制整个jsp页面是否执行
编写一个类继承SimpleTagSupport，然后再重写doTag方法，在doTag方法抛出SkipPageException异常即可，jsp收到这个异常，将忽略标签余下jsp页面的执行。
示例代码如下：
SimpleTagDemo4.java
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo4类继承SimpleTagSupport
*/
public class SimpleTagDemo4 extends SimpleTagSupport {
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，控制标签余下的Jsp不执行
*/
@Override
public void doTag() throws JspException, IOException {
//抛出一个SkipPageException异常就可以控制标签余下的Jsp不执行
throw new SkipPageException();
}
}
在WEB-INF目录下的simpletag.tld文件中添加对该标签处理类的描述，如下：
<tag>

<name>demo4</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo4</tag-class>

<body-content>empty</body-content>
</tag>
在jsp页面中导入并使用自定义标签，如下：
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%--<%@taglib uri="/simpletag" prefix="gacl" %>--%>
<%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录 --%>
<%@taglib uri="/WEB-INF/simpletag.tld" prefix="gacl"%>
<!DOCTYPE HTML>
<html>
<head>
<title>用简单标签控制标签余下的Jsp不执行</title>
</head>
<body>
<h1>孤傲苍狼</h1>
<%--在jsp页面中使用自定义标签 --%>
<gacl:demo4/>

<h1>白虎神皇</h1>
</body>
</html>
运行效果如下：

五、简单标签开发的一些注意细节
5.1、标签类编写细节
开发标签类时，不要直接去实现SimpleTag接口，而是应该继承SimpleTagSupport类，SimpleTagSupport类是SimpleTag接口的一个默认实现类，通过继承SimpleTagSupport类，就可以直接使用SimpleTagSupport类已经实现的那些方法，如果SimpleTagSupport类的方法实现不满足业务要求，那么就可以根据具体的业务情况将相应的方法进行重写。
5.2、tld文件中标签体类型设置细节
我们开发好一个简单标签后，需要在tld文件中添加对该标签的描述，例如：
<tag>

<name>demo2</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo2</tag-class>

<body-content>scriptless</body-content>
</tag>
开发好一个标签后，在tld文件中使用<tag>来描述一个标签，描述的内容包括标签名(name)，标签处理器类(tag-class)，标签体的内容(body-content)。
tld文件中有四种标签体(body-content)类型：empty、JSP、scriptless、tagdependent
简单标签标签体的细节注意问题：
在简单标签(SampleTag)中标签体body-content的值只允许是empty、scriptless、tagdependent，不允许设置成JSP,如果设置成JSP就会出现异常：
The TLD for the class me.gacl.web.simpletag.SimpleTagDemo1 specifies an invalid body-content (JSP) for a SimpleTag
body-content的值如果设置成empty，那么就表示该标签没有标签体，如果是设置成scriptless，那么表示该标签是有标签体的，但是标签体中的内容不可以是<%java代码%>，例如：
<gacl:xdpdemo1>
<%
//嵌套在标签体中的java代码
int i= 0;
%>
孤傲苍狼
</gacl:xdpdemo1>
否则运行标签时就会出现如下错误：
Scripting elements ( <%!, <jsp:declaration, <%=, <jsp:expression, <%, <jsp:scriptlet ) are disallowed here
jsp标签技术出现的目的就是为了移除在jsp页面上编写的java代码的，如果在jsp标签中允许出现java代码，那么就违背了jsp标签技术设计时的初衷了。所以在简单标签的标签体中是不允许出现java代码的。
传统标签标签体的细节注意问题：
在传统标签中标签体body-content的值允许是empty、JSP、scriptless、tagdependent，body-content的值如果是设置成JSP，那么表示该标签是有标签体的，并且标签体的内容可以是任意的，包括java代码，如果是设置成scriptless，那么表示该标签是有标签体的，但是标签体的内容不能是java代码

如果传统标签和简单标签的标签体body-content的值设置成tagdependent，那么就表示标签体里面的内容是给标签处理器类使用的，tagdependent用得比较少，了解一下即可
5.3、tld文件中标签库的uri设置细节
如果在一个项目中使用或者开发了多个标签库，例如：

那么标签库的uri不能设置成相同的，否则在Jsp页面中通过uri引用标签库时就不知道引用哪一个标签库了，如果真的有那么巧，两个标签库的uri是刚好一样的，如下图所示：

那么在jsp页面中引用标签库时如果"<%@taglib uri="/gacl" prefix="gacl" %>"这样引用，那么就无法判断当前引用的标签库到底是gacl.tld标签库中的标签还是simpletag.tld标签库中的标签，因为两个标签库的uri刚好都是"/gacl"，在两个标签库的引用uri一样的情况下，为了能够在jsp中区别到底引用的是哪个标签库，可以换一种引用方式：<%@taglib uri="要引用的标签库的tld文件目录" prefix="gacl"%>，使用taglib指令引入标签库时，taglib指令的uri属性指定为标签库的tld文件目录，这样就可以区别开了，例如：
引用gacl.tld标签库：<%@taglib uri="/WEB-INF/gacl.tld" prefix="gacl"%>、
引用simpletag.tld标签库：<%@taglib uri="/WEB-INF/simpletag.tld" prefix="gacl"%>
所以当在项目中引用了多个标签库，如果标签库的uri刚好是一样的，就可以用这种方式解决。
六、简单标签开发步骤总结
1、编写一个类继承SimpleTagSupport类，然后根据业务需要重写SimpleTagSupport类中已经实现了的方法，一般情况下只需要重写doTag()方法即可。
2、在WEB-INF目录下创建一个tld文件，在tld文件中添加对该标签的描述。tld文件不一定放在WEB-INF目录下，也可以放在别的目录，习惯是放在WEB-INF目录下。

(二十六)——jsp简单标签标签库开发(二)
一、JspFragment类介绍
javax.servlet.jsp.tagext.JspFragment类是在JSP2.0中定义的，它的实例对象代表JSP页面中的一段符合JSP语法规范的JSP片段，这段JSP片段中不能包含JSP脚本元素。
WEB容器在处理简单标签的标签体时，会把标签体内容用一个JspFragment对象表示，并调用标签处理器对象的setJspBody方法把JspFragment对象传递给标签处理器对象。JspFragment类中只定义了两个方法，如下所示：
getJspContext方法
用于返回代表调用页面的JspContext对象.
public abstract void invoke(java.io.Writer out)
用于执行JspFragment对象所代表的JSP代码片段，参数out用于指定将JspFragment对象的执行结果写入到哪个输出流对象中，如果传递给参数out的值为null，则将执行结果写入到JspContext.getOut()方法返回的输出流对象中。(简而言之，可以理解为写给浏览器)
1.1、invoke方法详解
JspFragment.invoke方法是JspFragment最重要的方法，利用这个方法可以控制是否执行和输出标签体的内容、是否迭代执行标签体的内容或对标签体的执行结果进行修改后再输出。例如：
在标签处理器中如果没有调用JspFragment.invoke方法，其结果就相当于忽略标签体内容；
在标签处理器中重复调用JspFragment.invoke方法，则标签体内容将会被重复执行；
若想在标签处理器中修改标签体内容，只需在调用invoke方法时指定一个可取出结果数据的输出流对象（例如StringWriter），让标签体的执行结果输出到该输出流对象中，然后从该输出流对象中取出数据进行修改后再输出到目标设备，即可达到修改标签体的目的。
二、开发带属性的标签
自定义标签可以定义一个或多个属性，这样，在JSP页面中应用自定义标签时就可以设置这些属性的值，通过这些属性为标签处理器传递参数信息，从而提高标签的灵活性和复用性。
要想让一个自定义标签具有属性，通常需要完成两个任务：
在标签处理器中编写每个属性对应的setter方法
在TLD文件中描术标签的属性
为自定义标签定义属性时，每个属性都必须按照JavaBean的属性命名方式，在标签处理器中定义属性名对应的setter方法，用来接收 JSP页面调用自定义标签时传递进来的属性值。例如属性url，在标签处理器类中就要定义相应的setUrl(String url)方法。
在标签处理器中定义相应的set方法后，JSP引擎在解析执行开始标签前，也就是调用doStartTag方法前，会调用set属性方法，为标签设置属性。
2.1、开发带属性的标签范例
范例1：通过标签的属性控制标签体的执行次数
示例代码如下：
SimpleTagDemo5.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo5类继承SimpleTagSupport
* 通过标签的属性控制标签体的执行次数
*/
public class SimpleTagDemo5 extends SimpleTagSupport {
/**
* 定义标签的属性
*/
private int count;
/**count属性对应的set方法
* @param count
*/
public void setCount(int count) {
this.count = count;
}
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，通过标签的属性控制标签体的执行次数
*/
@Override
public void doTag() throws JspException, IOException {
for (int i = 0; i < count; i++) {
this.getJspBody().invoke(null);
}
}
}
复制代码
在WEB-INF目录下的tld文件中添加对该标签的描述，如下所示：
复制代码
<tag>

<name>demo5</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo5</tag-class>

<body-content>scriptless</body-content>

<attribute>
<description>描述标签的count属性</description>

<name>count</name>
<required>true</required>

<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
复制代码
在jsp页面引入标签库并使用自定义标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%--< %@taglib uri="/simpletag" prefix="gacl" %>--%>
<%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录 --%>
<%@taglib uri="/WEB-INF/simpletag.tld" prefix="gacl"%>
<!DOCTYPE HTML>
<html>
<head>
<title>通过标签的属性控制标签体的执行次数</title>
</head>
<body>
<%--在jsp页面中使用自定义标签，标签有一个count属性 --%>
<gacl:demo5 count="2">
<h1>孤傲苍狼</h1>
</gacl:demo5>
</body>
</html>
复制代码
运行效果如下：

如果标签的属性值是8种基本数据类型，那么在JSP页面在传递字符串时，JSP引擎会自动转换成相应的类型，但如果标签的属性值是复合数据类型，那么JSP引擎是无法自动转换的
范例2：标签接收的属性值是一个复合数据类型，该如何给标签的属性赋值
示例代码如下：
SimpleTagDemo6.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import java.util.Date;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* SimpleTagSupport类实现了SimpleTag接口，
* SampleTagDemo6类继承SimpleTagSupport
* 标签的属性说明
*/
public class SimpleTagDemo6 extends SimpleTagSupport {
/**
* 定义标签的属性
*/
private Date date;
/**date属性对应的set方法
* @param date
*/
public void setDate(Date date) {
this.date = date;
}
/* 简单标签使用这个方法就可以完成所有的业务逻辑
* @see javax.servlet.jsp.tagext.SimpleTagSupport#doTag()
* 重写doTag方法，输出date属性值
*/
@Override
public void doTag() throws JspException, IOException {
this.getJspContext().getOut().write(date.toLocaleString());
}
}
复制代码
在WEB-INF目录下的tld文件中添加对该标签的描述，如下所示：
复制代码
<tag>

<name>demo6</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo6</tag-class>

<body-content>empty</body-content>

<attribute>
<description>描述标签的date属性</description>

<name>date</name>
<required>true</required>

<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
复制代码
在jsp页面引入标签库并使用自定义标签
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%--< %@taglib uri="/simpletag" prefix="gacl" %>--%>
<%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录 --%>
<%@taglib uri="/WEB-INF/simpletag.tld" prefix="gacl"%>
<!DOCTYPE HTML>
<html>
<head>
<title>如果标签接收的属性值是一个复合数据类型，该如何给标签的属性赋值</title>
</head>
<body>
<%--
在jsp页面中使用自定义标签，标签有一个date属性，是一个复合数据类型
如果标签的属性值是8种基本数据类型，那么在JSP页面在传递字符串时，JSP引擎会自动转换成相应的类型
但如果标签的属性值是复合数据类型，那么JSP引擎是无法自动转换的，
这里将一个字符串赋值给demo6标签的date属性，在运行标签时就会出现如下错误：
Unable to convert string "1988-05-07" to class "java.util.Date" for attribute "date":
Property Editor not registered with the PropertyEditorManager
<gacl:demo6 date="1988-05-07">
</gacl:demo6>
--%>
<%--如果一定要给标签的复合属性赋值，那么可以采用表达式的方式给复合属性赋值，如下所示： --%>
<%
Date d = new Date();
request.setAttribute("date", d);
%>
<gacl:demo6 date="${date}"/>
<hr/>
<gacl:demo6 date="<%=new Date()%>"/>
</body>
</html>
复制代码
运行效果如下：

2.1、tld文件中用于描述标签属性的<attribute>元素说明
<tag>元素的<attribute>子元素用于描述自定义标签的一个属性，自定义标签所具有的每个属性都要对应一个<attribute>元素
例如：
复制代码
<tag>

<name>demo5</name>

<tag-class>me.gacl.web.simpletag.SimpleTagDemo5</tag-class>

<body-content>scriptless</body-content>

<attribute>
<description>描述标签的count属性</description>

<name>count</name>
<required>true</required>

<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
复制代码
<attribute>元素的子元素说明：

到此，简单标签的开发技术就算是全部讲完了，在下一篇博文中会编写一些自定义标签的案例来加深自定标签技术的学习和理解。

(二十七)——jsp简单标签开发案例和打包
一、开发标签库
1.1、开发防盗链标签
1、编写标签处理器类：RefererTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* 防盗链标签RefererTag
*/
public class RefererTag extends SimpleTagSupport {
/**
* 网站域名
*/
private String site;
/**
* 要跳转的页面
*/
private String page;
@Override
public void doTag() throws JspException, IOException {
//获取jsp页面的PageContext对象
PageContext pageContext = (PageContext) this.getJspContext();
//通过PageContext对象来获取HttpServletRequest对象
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
//获取请求的来路(Referer)
String referer = request.getHeader("referer");
//如果来路是null或者来路不是来自我们自己的site，那么就将请求重定向到page页面
if (referer == null || !referer.startsWith(site)) {
//获取HttpServletResponse对象
HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();
String webRoot = request.getContextPath();
if (page.startsWith(webRoot)) {
//重定向到page页面
response.sendRedirect(page);
} else {
//重定向到page页面
response.sendRedirect(webRoot+page);
}
//重定向后，控制保护的页面不要执行
throw new SkipPageException();
}
}
public void setSite(String site) {
this.site = site;
}
public void setPage(String page) {
this.page = page;
}
}
复制代码
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
复制代码
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">
<description>孤傲苍狼开发的简单标签库</description>
<tlib-version>1.0</tlib-version>
<short-name>TagLib</short-name>
<uri>/gaclTagLib</uri>
<tag>

<name>referer</name>

<tag-class>me.gacl.web.simpletag.RefererTag</tag-class>

<body-content>empty</body-content>

<attribute>
<description>描述标签的site属性</description>

<name>site</name>
<required>true</required>

<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<description>描述标签的page属性</description>

<name>page</name>
<required>true</required>

<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>
复制代码
3、测试：在jsp页面中导入标签库并使用防盗链标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="gacl" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="gacl"%>
--%>
< %--在Jsp页面中使用防盗链标签
当用户尝试直接通过URL地址(http://localhost:8080/JavaWeb_JspTag_study_20140816/simpletag/refererTagTest.jsp)访问这个页面时，
防盗链标签的标签处理器内部就会进行处理，将请求重定向到/index.jsp
--%>
<gacl:referer site="http://localhost:8080" page="/index.jsp"/>
<!DOCTYPE HTML>
<html>
<head>
<title>防盗链标签测试</title>
</head>
<body>
网站内部资料
</body>
</html>
复制代码
运行效果如下：

1.2、开发<c:if>标签
1、编写标签处理器类：IFTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* 开发if标签
*/
public class IFTag extends SimpleTagSupport {
/**
* if标签的test属性
*/
private boolean test;
@Override
public void doTag() throws JspException, IOException {
if (test) {
this.getJspBody().invoke(null);
}
}
public void setTest(boolean test) {
this.test = test;
}
}
复制代码
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
复制代码
<tag>
<description>if标签</description>
<name>if</name>
<tag-class>me.gacl.web.simpletag.IFTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<description>if标签的test属性</description>
<name>test</name>
<rtexprvalue>true</rtexprvalue>
<required>true</required>
</attribute>
</tag>
复制代码
3、测试：在jsp页面中导入标签库并使用if标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>if链标签测试</title>
</head>
<body>
< %--if标签的test属性值为true ,标签体的内容会输出--%>
<c:if test="true">
<h3>网站内部资料</h3>
</c:if>
< %--if标签的test属性值为false ,标签体的内容不会输出--%>
<c:if test="false">
这里的内部不输出
</c:if>
</body>
</html>
复制代码
运行效果如下：

1.3、开发<c:when><c:otherwise>标签
这个标签的开发稍微有一点难度，因为这里面涉及到两个标签处理器类共享同一个变量的问题，如下：
复制代码
<c:when test="${user != null}">
用户不为空
</c:when>
<c:otherwise>
用户为空
</c:otherwise>
复制代码
<c:when>标签和<c:otherwise>标签对应着两个不同的标签处理器类，我们希望做到的效果是，如果<c:when>标签执行了，那么就<c:otherwise>标签就不要再执行，那么这里面就涉及到一个问题：<c:when>标签执行的时候该如何通知<c:otherwise>标签不要执行了呢？这个问题就涉及到了两个标签处理器类如何做到相互通讯的问题，如果<c:when>标签执行了，就要通过某种方式告诉<c:otherwise>标签不要执行，那么该如何做到这样的效果呢？让<c:when>标签处理器类和<c:otherwise>标签处理器类共享同一个变量就可以做到了，那么又该怎么做才能够让两个标签处理器类共享同一个变量呢，标准的做法是这样的：让两个标签拥有同一个父标签。
　1、开发父标签：ChooseTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* when标签和otherwise标签的父标签
*/
public class ChooseTag extends SimpleTagSupport {
/**
* 定义一个boolean类型的属性，该属性用于标识该标签下的某一个子标签是否已经执行过了，
* 如果该标签下的某一个子标签已经执行过了，就将该属性设置为true
*/
private boolean isExecute;
@Override
public void doTag() throws JspException, IOException {
//输出标签体中的内容
this.getJspBody().invoke(null);
}
public boolean isExecute() {
return isExecute;
}
public void setExecute(boolean isExecute) {
this.isExecute = isExecute;
}
}
复制代码
2、开发when标签和otherwise标签
WhenTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* when标签
*/
public class WhenTag extends SimpleTagSupport {
/**
* test属性，该属性值为true时，输出标签体中的内容
*/
private boolean test;
@Override
public void doTag() throws JspException, IOException {
//获取标签的父标签
ChooseTag parentTag = (ChooseTag) this.getParent();
if (test == true && parentTag.isExecute() == false) {
//输出标签体中的内容
this.getJspBody().invoke(null);
//将父标签的isExecute属性设置为true，告诉父标签，我(when标签)已经执行过了
parentTag.setExecute(true);
}
}
public void setTest(boolean test) {
this.test = test;
}
}
复制代码
OtherWiseTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* otherwise标签
*/
public class OtherWiseTag extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
//获取标签的父标签
ChooseTag parentTag = (ChooseTag) this.getParent();
//如果父标签下的when标签没有执行过
if (parentTag.isExecute() == false) {
//输出标签体中的内容
this.getJspBody().invoke(null);
//设置父标签的isExecute属性为true，告诉父标签，我(otherwise标签)已经执行过了
parentTag.setExecute(true);
}
}
}
复制代码
3、在WEB-INF目录下tld文件中添加对ChooseTag、WhenTag、OtherWiseTag这三对标签的描述，如下：
复制代码
<tag>
<description>choose标签</description>
<name>choose</name>
<tag-class>me.gacl.web.simpletag.ChooseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
<tag>
<description>when标签</description>
<name>when</name>
<tag-class>me.gacl.web.simpletag.WhenTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<description>when标签的test属性</description>
<name>test</name>
<rtexprvalue>true</rtexprvalue>
<required>true</required>
</attribute>
</tag>
<tag>
<description>otherwise标签</description>
<name>otherwise</name>
<tag-class>me.gacl.web.simpletag.OtherWiseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
复制代码
4、测试：在jsp页面中导入标签库并测试when和otherwise标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>when和otherwise标签测试</title>
</head>
<body>
<c:choose>
<c:when test="${user==null}">
when标签标签体输出的内容：
<h3>用户为空</h3>
</c:when>
<c:otherwise>
用户不为空
</c:otherwise>
</c:choose>
<hr/>
<c:choose>
<c:when test="${user!=null}">
用户不为空
</c:when>
<c:otherwise>
otherwise标签标签体输出的内容：
<h3>用户为空</h3>
</c:otherwise>
</c:choose>
</body>
</html>
复制代码
运行效果如下：

1.4、开发foreach迭代标签
1、编写标签处理器类：ForEachTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* ForEach迭代标签
*/
public class ForEachTag extends SimpleTagSupport {
/**
* 存储集合
*/
private List items;
/**
* 迭代集合时使用的变量
*/
private String var;
public void setItems(List items) {
this.items = items;
}
public void setVar(String var) {
this.var = var;
}
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) this.getJspContext();
Iterator it = items.iterator();
while (it.hasNext()) {
//得到一个迭代出来的对象
Object object = (Object) it.next();
//将迭代出来的对象存放到pageContext对象中
pageContext.setAttribute(var, object);
//输出标签体中的内容
this.getJspBody().invoke(null);
}
}
}
复制代码
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
复制代码
<tag>
<description>foreach标签</description>
<name>foreach</name>
<tag-class>me.gacl.web.simpletag.ForEachTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<description>foreach标签的items属性</description>
<name>items</name>
<rtexprvalue>true</rtexprvalue>
<required>true</required>
</attribute>
<attribute>
<description>foreach标签的var属性</description>
<name>var</name>
<rtexprvalue>false</rtexprvalue>
<required>true</required>
</attribute>
</tag>
复制代码
3、测试：在jsp页面中导入标签库并使用foreach标签
复制代码
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>foreach标签测试</title>
</head>
<%
List<String> data = http://www.mamicode.com/new ArrayList();
data.add("孤傲苍狼");
data.add("xdp");
//将集合存储到pageContext对象中
pageContext.setAttribute("data", data);
%>
<body>
< %--迭代存储在pageContext对象中的data集合 --%>
<c:foreach items="${data}" var="str">
${str}<br/>
</c:foreach>
</body>
</html>
复制代码
运行效果如下：

目前这个foreach标签的功能较弱，只能遍历list集合，下面我们改造一下，使我们的foreach标签可以遍历所有集合类型，修改后foreach标签的代码如下：
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* ForEach迭代标签
*/
public class ForEachTag extends SimpleTagSupport {
/**
* 存储数据
*/
private Object items;
/**
* 迭代集合时使用的变量
*/
private String var;
/**
* 集合，用于存储items中的数据
*/
private Collection collection;
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) this.getJspContext();
//迭代collection集合
Iterator it = collection.iterator();
while (it.hasNext()) {
//得到一个迭代出来的对象
Object object = (Object) it.next();
//将迭代出来的对象存放到pageContext对象中
pageContext.setAttribute(var, object);
//输出标签体中的内容
this.getJspBody().invoke(null);
}
}
public void setVar(String var) {
this.var = var;
}
public void setItems(Object items) {
if (items instanceof Collection) {
collection = (Collection) items;//list
}else if (items instanceof Map) {
Map map = (Map) items;
collection = map.entrySet();//map
}else if (items.getClass().isArray()) {
collection = new ArrayList();
//获取数组的长度
int len = Array.getLength(items);
for (int i = 0; i < len; i++) {
//获取数组元素
Object object = Array.get(items, i);
collection.add(object);
}
}
this.items = items;
}
}
复制代码
测试功能增强后的foreach标签，如下：
复制代码
<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="java.util.HashSet"%>
<%@page import="java.util.Set"%>
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@ page language="java" pageEncoding="UTF-8"%>
<%--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
<%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>foreach标签测试</title>
</head>
<%
//list集合
List<String> listData = http://www.mamicode.com/new ArrayList();
listData.add("孤傲苍狼");
listData.add("xdp");
//对象数组
Integer intObjArr[] = new Integer[]{1,2,3};
//基本数据类型数组
int intArr[] = new int[]{4,5,6};
//map集合
Map<String,String> mapData = http://www.mamicode.com/new HashMap();
mapData.put("a", "aaaaaa");
mapData.put("b", "bbbbbb");
//将集合存储到pageContext对象中
pageContext.setAttribute("listData", listData);
pageContext.setAttribute("intObjArr", intObjArr);
pageContext.setAttribute("intArr", intArr);
pageContext.setAttribute("mapData", mapData);
%>
<body>
< %--迭代存储在pageContext对象中的list集合 --%>
<c:foreach items="${listData}" var="str">
${str}<br/>
</c:foreach>
<hr/>
< %--迭代存储在pageContext对象中的数组 --%>
<c:foreach items="${intObjArr}" var="num">
${num}<br/>
</c:foreach>
<hr/>
< %--迭代存储在pageContext对象中的数组 --%>
<c:foreach items="${intArr}" var="num">
${num}<br/>
</c:foreach>
<hr/>
< %--迭代存储在pageContext对象中的map集合 --%>
<c:foreach items="${mapData}" var="me">
${me}<br/>
</c:foreach>
</body>
</html>
复制代码
测试结果：

1.5、开发html转义标签
输出html 文本需要转义
1、编写标签处理器类：HtmlEscapeTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import java.io.StringWriter;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* html转义标签
*/
public class HtmlEscapeTag extends SimpleTagSupport {
/**
* @param message
* @return 转义html标签
*/
private String filter(String message) {
if (message == null){
return (null);
}
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuilder result = new StringBuilder(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case ‘<‘:
result.append("<");
break;
case ‘>‘:
result.append(">");
break;
case ‘&‘:
result.append("&");
break;
case ‘"‘:
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}
@Override
public void doTag() throws JspException, IOException {
StringWriter sw = new StringWriter();
//将标签体中的内容先输出到StringWriter流
this.getJspBody().invoke(sw);
//得到标签体中的内容
String content = sw.getBuffer().toString();
//转义标签体中的html代码
content = filter(content);
//输出转义后的content
this.getJspContext().getOut().write(content);
}
}
复制代码
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
复制代码
<tag>
<description>HtmlEscape标签</description>
<name>htmlEscape</name>
<tag-class>me.gacl.web.simpletag.HtmlEscapeTag</tag-class>
<body-content>scriptless</body-content>
</tag>
复制代码
3、测试：在jsp页面中导入标签库并使用htmlEscape标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>html转义标签测试</title>
</head>
<body>
<c:htmlEscape>
<a href="http://www.cnblogs.com">访问博客园</a>
</c:htmlEscape>
</body>
</html>
复制代码
运行结果：

1.6、开发out输出标签
1、编写标签处理器类：OutTag.java
复制代码
package me.gacl.web.simpletag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
/**
* @author gacl
* 开发输出标签
*/
public class OutTag extends SimpleTagSupport {
/**
* 要输出的内容
*/
private String content;
/**
* 是否将内容中的html进行转义后输出
*/
private boolean escapeHtml;
public void setContent(String content) {
this.content = content;
}
public void setEscapeHtml(boolean escapeHtml) {
this.escapeHtml = escapeHtml;
}
@Override
public void doTag() throws JspException, IOException {
if (escapeHtml == true) {
//转义内容中的html代码
content = filter(content);
//输出转义后的content
this.getJspContext().getOut().write(content);
}else {
this.getJspContext().getOut().write(content);
}
}
/**
* @param message
* @return 转义html标签
*/
private String filter(String message) {
if (message == null){
return (null);
}
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuilder result = new StringBuilder(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case ‘<‘:
result.append("<");
break;
case ‘>‘:
result.append(">");
break;
case ‘&‘:
result.append("&");
break;
case ‘"‘:
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}
}
复制代码
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
复制代码
<tag>
<description>out标签</description>
<name>out</name>
<tag-class>me.gacl.web.simpletag.OutTag</tag-class>
<body-content>empty</body-content>
<attribute>
<description>out标签的content属性，表示要输出的内容</description>
<name>content</name>
<rtexprvalue>true</rtexprvalue>
<required>true</required>
</attribute>
<attribute>
<description>out标签的escapeHtml属性，表示是否将内容中的html进行转义后输出</description>
<name>escapeHtml</name>
<rtexprvalue>true</rtexprvalue>
<required>false</required>
</attribute>
</tag>
复制代码
3、测试：在jsp页面中导入标签库并使用out标签
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--在jsp页面中导入自定义标签库 --%>
<%@taglib uri="/gaclTagLib" prefix="c" %>
< %--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
<%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
--%>
<!DOCTYPE HTML>
<html>
<head>
<title>out标签测试</title>
</head>
<body>
< %--使用out标签输出content属性的内容 --%>
<c:out content="<a href=http://www.mamicode.com/‘http://www.cnblogs.com‘>访问博客园"/>
<hr/>
< %--使用out标签输出 content属性的内容，内容中的html代码会进行转义处理--%>
<c:out content="<a href=http://www.mamicode.com/‘http://www.cnblogs.com‘>访问博客园" escapeHtml="true"/>
</body>
</html>
复制代码
运行效果如下：

二、打包开发好的标签库
我们的标签库开发好之后，为了方便别人使用，可以将开发好的标签库打包成一个jar包，具体的打包步骤如下：
1、新建一个普通的java工程，例如：taglib

2、将在JavaWeb_JspTag_study_20140816这个web工程中开发好标签库的java代码拷贝到普通java工程taglib项目中，如下：

此时，我们可以看到，拷贝到taglib项目的标签代码都有错误，这是因为taglib项目中缺少了javaEE的jar包，而标签类是是基于javaEE API进行开发的，所以还需要将javaEE的jar包添加到taglib项目中。
在taglib项目中创建一个【lib】文件夹，用于存放标签类依赖的javaEE的jar包。找到tomcat服务器目录下的lib文件夹，如下图所示：

将【jsp-api.jar】和【servlet-api.jar】这两个jar包拷贝到tagib项目中的lib文件夹中，然后添加【jsp-api.jar】和【servlet-api.jar】这两个jar包的引用，如下所示：

在taglib项目中引用了【jsp-api.jar】和【servlet-api.jar】这两个jar包后，标签类中的代码就不再报错了
3、在taglib项目中添加一个【META-INF】文件夹，如下所示：

将位于WEB-INF目录下的标签库对应的tld文件拷贝到taglib项目的【META-INF】文件夹中

4、将taglib项目打包成jar包

此时就可以看到我们打包好的jar包了，如下所示：

将标签库打包成jar包之后，以后哪个web项目要使用标签库，那么就将打包好的标签库jar包添加到web项目中就可以使用标签库中的标签了。

(二十八)——JSTL标签库之核心标签
一、JSTL标签库介绍
JSTL标签库的使用是为弥补html标签的不足，规范自定义标签的使用而诞生的。使用JSLT标签的目的就是不希望在jsp页面中出现java逻辑代码
二、JSTL标签库的分类
核心标签(用得最多)
国际化标签(I18N格式化标签)
数据库标签(SQL标签，很少使用)
XML标签(几乎不用)
JSTL函数(EL函数)
三、核心标签库使用说明
JSTL的核心标签库标签共13个，使用这些标签能够完成JSP页面的基本功能，减少编码工作。
从功能上可以分为4类：表达式控制标签、流程控制标签、循环标签、URL操作标签。
（1）表达式控制标签：out标签、set标签、remove标签、catch标签。
（2）流程控制标签：if标签、choose标签、when标签、otherwise标签。
（3）循环标签：forEach标签、forTokens标签。
（4）URL操作标签：import标签、url标签、redirect标签、param标签。
在JSP页面引入核心标签库的代码为：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
3.1、表达式控制标签——out标签使用总结
3.1.1、<c:out>标签的功能
<c:out>标签主要是用来输出数据对象（字符串、表达式）的内容或结果。
在使用Java脚本输出时常使用的方式为： <% out.println(“字符串”)%> 或者 <%=表达式%> ，在web开发中，为了避免暴露逻辑代码会尽量减少页面中的Java脚本，使用<c:out>标签就可以实现以上功能。
<c:out value=http://www.mamicode.com/”字符串”>
<c:out value=http://www.mamicode.com/”EL表达式”>
JSTL的使用是和EL表达式分不开的，EL表达式虽然可以直接将结果返回给页面，但有时得到的结果为空，<c:out>有特定的结果处理功能，EL的单独使用会降低程序的易读性，建议把EL的结果输入放入<c:out>标签中。
3.1.2、<c:out>标签的语法
<c:out>标签的使用有两种语法格式：
【语法1】：<c:out value=http://www.mamicode.com/”要显示的数据对象” [escapeXml=”true|false”] [default=”默认值”]/>
【语法2】：<c:out value=http://www.mamicode.com/”要显示的数据对象” [escapeXml=”true|false”]>默认值
这两种方式没有本质的区别，只是格式上的差别。[escapeXml=”true|false”] [default=”默认值”]这些使用[]属性表示是不是必须的。
3.1.3、<c:out>标签的属性

3.1.4、<c:out>标签的使用范例
复制代码
<%@ page language="java" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: --表达式控制标签“out”标签的使用</title>
</head>
<body>
<h3><c:out value="http://www.mamicode.com/下面的代码演示了c:out的使用，以及在不同属性值状态下的结果。"/></h3>
<hr/>
<ul>
< %--（1）直接输出了一个字符串。 --%>
<li>（1）<c:out value="http://www.mamicode.com/JSTL的out标签的使用" /></li>
<li>（2）<c:out value="http://www.mamicode.com/点击链接到博客园" /></li>
< %--escapeXml="false"表示value值中的html标签不进行转义，而是直接输出 --%>
<li>（3）<c:out value="http://www.mamicode.com/点击链接到博客园" escapeXml="false"/></li>
< %--(4）字符串中有转义字符，但在默认情况下没有转换。 --%>
<li>（4）<c:out value="http://www.mamicode.com/<未使用字符转义>" /></li>
< %--（5）使用了转义字符&lt和&gt分别转换成<和>符号。 --%>
<li>（5）<c:out value="http://www.mamicode.com/<使用字符转义>" escapeXml="false"></c:out></li>
< %--（6）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
<li>（6）<c:out value="http://www.mamicode.com/${null}">使用了默认值</c:out></li>
< %--（7）未设定默认值，输出结果为空。 --%>
<li>（7）<c:out value="http://www.mamicode.com/${null}"></c:out></li>
< %--（8）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
<li>（8）<c:out value="http://www.mamicode.com/${null}" default="默认值"/></li>
< %--（9）未设定默认值，输出结果为空。 --%>
<li>（9）<c:out value="http://www.mamicode.com/${null}"/></li>
</ul>
</body>
</html>
复制代码
运行结果如下：

3.2、表达式控制标签——set标签使用总结
3.2.1、<c:set>标签的功能
<c:set>标签用于把某一个对象存在指定的域范围内，或者将某一个对象存储到Map或者JavaBean对象中。
3.2.2、<c:set>标签的语法
<c:set>标签的编写共有4种语法格式。
语法1：存值，把一个值放在指定的域范围内。
<c:set value=http://www.mamicode.com/”值1” var=”name1” [scope=”page|request|session|application”]/>
含义：把一个变量名为name1值为“值1”的变量存储在指定的scope范围内。
语法2：
<c:set var=”name2” [scope=”page|request|session|application”]>
值2
</c:set>
含义：把一个变量名为name2，值为值2的变量存储在指定的scope范围内。
语法3：
<c:set value=http://www.mamicode.com/”值3” target=”JavaBean对象” property=”属性名”/>
含义：把一个值为“值3”赋值给指定的JavaBean的属性名。相当与setter()方法。
语法4：
<c:set target=”JavaBean对象” property=”属性名”>
值4
</c:set>
含义：把一个值4赋值给指定的JavaBean的属性名。
从功能上分语法1和语法2、语法3和语法4的效果是一样的，只是把value值放置的位置不同，至于使用那个根据个人的喜爱，语法1和语法2是向scope范围内存储一个值，语法3和语法4是给指定的JavaBean赋值。
3.2.3、<c:set>标签的属性

3.2.4、<c:set>标签的使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
< %--使用JSP的指令元素指定要使用的JavaBean --%>
<jsp:useBean id="person" class="javabean.Person"/>
< %--负责实例化Bean，id指定实例化后的对象名，可以通过${person}得到person在内存中的值
（或者使用person.toString()方法）。 --%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: --表达式控制标签“set”标签的使用</title>
</head>
<body>
<h3>代码给出了给指定scope范围赋值的示例。</h3>
<ul>
< %--通过<c:set>标签将data1的值放入page范围中。--%>
<li>把一个值放入page域中:<c:set var="data1" value="http://www.mamicode.com/xdp" scope="page"/></li>
< %--使用EL表达式从pageScope得到data1的值。--%>
<li>从page域中得到值：${pageScope.data1}</li>
< %--通过<c:set>标签将data2的值放入request范围中。--%>
<li>把一个值放入request域中:<c:set var="data2" value="http://www.mamicode.com/gacl" scope="request"/></li>
< %--使用EL表达式从requestScope得到data2的值。--%>
<li>从request域中得到值：${requestScope.data2}</li>
< %--通过<c:set>标签将值name1的值放入session范围中。--%>
<li>把一个值放入session域中。<c:set value="http://www.mamicode.com/孤傲苍狼" var="name1" scope="session"></c:set></li>
< %--使用EL表达式从sessionScope得到name1的值。--%>
<li>从session域中得到值:${sessionScope.name1} </li>
< %--把name2放入application范围中。 --%>
<li>把一个值放入application域中。<c:set var="name2" scope="application">白虎神皇</c:set></li>
< %--使用EL表达式从application范围中取值，用<c:out>标签输出使得页面规范化。 --%>
<li>使用out标签和EL表达式嵌套从application域中得到值：
<c:out value="http://www.mamicode.com/${applicationScope.name2}">未得到name的值</c:out>
</li>
< %--不指定范围使用EL自动查找得到值 --%>
<li>未指定scope的范围，会从不同的范围内查找得到相应的值：${data1}、${data2}、${name1}、${name2}</li>
</ul>
<hr/>
<h3>使用Java脚本实现以上功能</h3>
<ul>
<li>把一个值放入page域中。<%pageContext.setAttribute("data1","xdp");%></li>
<li>从page域中得到值:<%out.println(pageContext.getAttribute("data1"));%></li>
<li>把一个值放入request域中。<%request.setAttribute("data2","gacl");%></li>
<li>从request域中得到值:<%out.println(request.getAttribute("data2"));%></li>
<li>把一个值放入session域中。<%session.setAttribute("name1","孤傲苍狼");%></li>
<li>从session中域得到值:<%out.println(session.getAttribute("name1"));%></li>
< %--out.println()方法与<%=%>表达式输出功能一样
但使用表达式输出（<%=%>）明显要比使用out.println()输出更好。
--%>
<li><%=session.getAttribute("name1") %></li>
<li>把另一个值放入application域中。<%application.setAttribute("name2","白虎神皇");%></li>
<li> 从application域中得到值：<%out.println(application.getAttribute("name2"));%></li>
<li><%=application.getAttribute("name2")%></li>
<li>未指定scope的范围，会从不同的范围内查找得到相应的值：
<%=pageContext.findAttribute("data1")%>、
<%=pageContext.findAttribute("data2")%>、
<%=pageContext.findAttribute("name1")%>、
<%=pageContext.findAttribute("name2")%>
</li>
</ul>
<hr/>
<h3>操作JavaBean，设置JavaBean的属性值</h3>
< %--设置JavaBean的属性值，等同与setter方法，Target指向实例化后的对象，property指向要插入值的参数名。
注意：使用target时一定要指向实例化后的JavaBean对象，也就是要跟<jsp:useBean>配套使用，
也可以java脚本实例化，但这就失去了是用标签的本质意义。
使用Java脚本实例化：
< %@page import="javabean.Person"%
<% Person person=new Person(); %>
--%>
<c:set target="${person}" property="name">孤傲苍狼</c:set>
<c:set target="${person}" property="age">25</c:set>
<c:set target="${person}" property="sex">男</c:set>
<c:set target="${person}" property="home">中国</c:set>
<ul>
<li>使用的目标对象为：${person}</li>
<li>从Bean中获得的name值为：<c:out value="http://www.mamicode.com/${person.name}"></c:out></li>
<li>从Bean中获得的age值为：<c:out value="http://www.mamicode.com/${person.age}"></c:out></li>
<li>从Bean中获得的sex值为：<c:out value="http://www.mamicode.com/${person.sex}"></c:out></li>
<li>从Bean中获得的home值为：<c:out value="http://www.mamicode.com/${person.home}"></c:out></li>
</ul>
<hr/>
<h3>操作Map</h3>
<%
Map map = new HashMap();
request.setAttribute("map",map);
%>
< %--将data对象的值存储到map集合中 --%>
<c:set property="data" value="http://www.mamicode.com/gacl" target="${map}"/>
${map.data}
</body>
</html>
复制代码
jsp页面中使用到的javabean.Person类的代码如下：
复制代码
package javabean;
/**
* 项目名称：JSTLStudy
* 类名称：Person
* 类描述：一个只有getter和setter方法的JavaBean或者说一个pojo(简单的Java对象(Plain Old Java Objects))类，
* 作为一个vo（数据传输对象）。定义了四个变量age、name、sex和home。
*/
public class Person {
private String age;
private String home;
private String name;
private String sex;
public String getAge() {
return age;
}
public String getHome() {
return home;
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public void setAge(String age) {
this.age = age;
}
public void setHome(String home) {
this.home = home;
}
public void setName(String name) {
this.name = name;
}
public void setSex(String sex) {
this.sex = sex;
}
}
复制代码
运行结果如下：

3.3、表达式控制标签——remove标签使用总结
3.3.1、<c:remove>标签的功能
<c:remove>标签主要用来从指定的JSP范围内移除指定的变量。
3.3.2、<c:remove>标签的语法
<c:remove var=”变量名” [scope=”page|request|session|application”]/>
其中var属性是必须的，scope可以以省略。
3.3.3、<c:remove>标签的使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: --表达式控制标签“remove”标签的使用</title>
</head>
<body>
<ul>
<c:set var="name" scope="session">孤傲苍狼</c:set>
<c:set var="age" scope="session">25</c:set>
<li><c:out value="http://www.mamicode.com/${sessionScope.name}"></c:out></li>
<li><c:out value="http://www.mamicode.com/${sessionScope.age}"></c:out></li>
< %--使用remove标签移除age变量 --%>
<c:remove var="age" />
<li><c:out value="http://www.mamicode.com/${sessionScope.name}"></c:out></li>
<li><c:out value="http://www.mamicode.com/${sessionScope.age}"></c:out></li>
</ul>
</body>
</html>
复制代码
运行结果如下：

3.4、表达式控制标签——catch标签使用总结
3.4.1、<c:catch>标签的功能
<c:catch>标签用于捕获嵌套在标签体中的内容抛出的异常。
3.4.2、<c:catch>标签的语法
其语法格式如下：<c:catch [var="varName"]>容易产生异常的代码</c:catch>
var属性用于标识<c:catch>标签捕获的异常对象，它将保存在page这个Web域中。
3.4.3、<c:catch>标签的使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: --表达式控制标签“catch”标签实例</title>
</head>
<body>
<h4>catch标签实例</h4>
<hr>
< %--把容易产生异常的代码放在<c:catch></c:catch>中，
自定义一个变量errorInfo用于存储异常信息 --%>
<c:catch var="errorInfo">
< %--实现了一段异常代码，向一个不存在的JavaBean中插入一个值--%>
<c:set target="person" property="hao"></c:set>
</c:catch>
< %--用EL表达式得到errorInfo的值，并使用<c:out>标签输出 --%>
异常：<c:out value="http://www.mamicode.com/${errorInfo}" /><br />
异常 errorInfo.getMessage：<c:out value="http://www.mamicode.com/${errorInfo.message}" /><br />
异常 errorInfo.getCause：<c:out value="http://www.mamicode.com/${errorInfo.cause}" /><br />
异常 errorInfo.getStackTrace：<c:out value="http://www.mamicode.com/${errorInfo.stackTrace}" />
</body>
</html>
复制代码
运行结果如下：

3.5、流程控制标签——if标签使用总结
3.5.1、<c:if>标签的功能
<c:if>标签和程序中的if语句作用相同，用来实现条件控制。
3.5.2、<c:if>标签的语法
【语法1】：没有标签体内容(body)
<c:if test="testCondition" var="varName" [scope="{page|request|session|application}"]/>
【语法2】：有标签体内容
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|application}"]>
标签体内容
</c:if>
【参数说明】：
（1）test属性用于存放判断的条件，一般使用EL表达式来编写。
（2）var属性用来存放判断的结果，类型为true或false。
（3）scopes属性用来指定var属性存放的范围。
3.5.3、<c:if>标签的属性

3.5.4、<c:if>标签的使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: --流程控制标签 if标签示例</title>
</head>
<body>
<h4>if标签示例</h4>
<hr>
<form action="JSTL_if_tag.jsp" method="post">
<input type="text" name="uname" value="http://www.mamicode.com/${param.uname}">
<input type="submit" value="http://www.mamicode.com/登录">
</form>
< %--使用if标签进行判断并把检验后的结果赋给adminchock，存储在默认的page范围中。 --%>
<c:if test="${param.uname==‘admin‘}" var="adminchock">
< %--可以把adminchock的属性范围设置为session，这样就可以在其他的页面中得到adminchock的值，
使用<c:if text=”${adminchock}”><c:if>判断，实现不同的权限。 --%>
<c:out value="http://www.mamicode.com/管理员欢迎您！"/>
</c:if>
< %--使用EL表达式得到adminchock的值，如果输入的用户名为admin将显示true。 --%>
${adminchock}
</body>
</html>
复制代码
运行结果如下：

3.6、流程控制标签——choose标签、when标签、otherwise标签配合使用讲解
3.6.1、<c:choose>、<c:when>和<c:otherwise>标签的功能
<c:choose>、<c:when>和<c:otherwise>这3个标签通常情况下是一起使用的，<c:choose>标签作为<c:when>和<c:otherwise>标签的父标签来使用。
使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似 “if-else if-else” 的复杂条件判断结构。
3.6.2、语法
　<c:choose>
<c:when test="条件1">
//业务逻辑1
<c:when>
　<c:when test="条件2">
//业务逻辑2
<c:when>
　<c:when test="条件n">
//业务逻辑n
<c:when>
<c:otherwise>
//业务逻辑
　</c:otherwise>
　</c:choose>
3.6.3、使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- choose及其嵌套标签标签示例</title>
</head>
<body>
<h4>choose及其嵌套标签示例</h4>
<hr/>
< %--通过set标签设定score的值为85 --%>
<c:set var="score" value="http://www.mamicode.com/85"/>
<c:choose>
< %--使用<c:when>进行条件判断。
如果大于等于90，输出“您的成绩为优秀”；
如果大于等于70小于90，输出“您的成绩为良好”；
大于等于60小于70，输出“您的成绩为及格”；
其他（otherwise）输出“对不起，您没能通过考试”。
--%>
<c:when test="${score>=90}">
你的成绩为优秀！
</c:when>
<c:when test="${score>70 && score<90}">
您的成绩为良好!
</c:when>
<c:when test="${score>60 && score<70}">
您的成绩为及格
</c:when>
<c:otherwise>
对不起，您没有通过考试！
</c:otherwise>
</c:choose>
</body>
</html>
复制代码
运行结果如下：

3.7、循环标签——forEach标签使用总结
3.7.1、<c:forEach>标签的功能
该标签根据循环条件遍历集合（Collection）中的元素。
3.7.2、<c:forEach>标签的语法
　<c:forEach
var=”name”
items=”Collection”
varStatus=”StatusName”
begin=”begin”
end=”end”
step=”step”>
本体内容
</c:forEach>
【参数解析】：
（1）var设定变量名用于存储从集合中取出元素。
（2）items指定要遍历的集合。
（3）varStatus设定变量名，该变量用于存放集合中元素的信息。
（4）begin、end用于指定遍历的起始位置和终止位置（可选）。
（5）step指定循环的步长。
3.7.3、<c:forEach>标签属性
循环标签属性说明
属性名称是否支持EL表达式属性类型是否必须默认值
var NO String 是无
items YES Arrays
Collection
Iterator
Enumeration
Map
String []args 是无
begin YES int 否 0
end YES int 否集合中最后一个元素
step YES int 否 1
varStatus NO String 否无
　　

　　

其中varStatus有4个状态属性，如下表所示：
varStatus的4个状态
属性名类型说明
index int 当前循环的索引值
count int 循环的次数
frist boolean 是否为第一个位置
last boolean 是否为最后一个位置

3.7.4、<c:forEach>使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@page import="java.util.ArrayList"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- forEach标签实例</title>
</head>
<body>
<h4><c:out value="http://www.mamicode.com/forEach实例"/></h4>
<%
List<String>list = new ArrayList<String>();
list.add(0, "贝贝");
list.add(1, "晶晶");
list.add(2, "欢欢");
list.add(3, "莹莹");
list.add(4, "妮妮");
request.setAttribute("list", list);
%>
<B><c:out value="http://www.mamicode.com/不指定begin和end的迭代：" /></B><br>
< %--不使用begin和end的迭代，从集合的第一个元素开始，遍历到最后一个元素。 --%>
<c:forEach var="fuwa" items="${list}">
 <c:out value="http://www.mamicode.com/${fuwa}"/><br/>
</c:forEach>
<B><c:out value="http://www.mamicode.com/指定begin和end的迭代：" /></B><br>
< %--指定begin的值为1、end的值为3、step的值为2，
从第二个开始首先得到晶晶，每两个遍历一次，
则下一个显示的结果为莹莹，end为3则遍历结束。 --%>
<c:forEach var="fuwa" items="${list}" begin="1" end="3" step="2">
 <c:out value="http://www.mamicode.com/${fuwa}"/><br/>
</c:forEach>
<B><c:out value="http://www.mamicode.com/输出整个迭代的信息：" /></B><br>
< %--指定varStatus的属性名为s，并取出存储的状态信息 --%>
<c:forEach var="fuwa"
items="${list}"
begin="3"
end="4"
varStatus="s"
step="1">
 <c:out value="http://www.mamicode.com/${fuwa}" />的四种属性：<br>
    所在位置，即索引：<c:out value="http://www.mamicode.com/${s.index}" /><br>
    总共已迭代的次数：<c:out value="http://www.mamicode.com/${s.count}" /><br>
    是否为第一个位置：<c:out value="http://www.mamicode.com/${s.first}" /><br>
    是否为最后一个位置：<c:out value="http://www.mamicode.com/${s.last}" /><br>
</c:forEach>
</body>
</html>
复制代码
运行结果如下：

3.8、循环标签——forTokens标签使用总结
3.8.1、<c:forTokens>标签的功能
该标签用于浏览字符串，并根据指定的字符将字符串截取。
3.8.2、<c:forTokens>标签的语法
语法：
<c:forTokens items=”strigOfTokens”
delims=”delimiters”
[var=”name”
begin=”begin”
end=”end”
step=”len”
varStatus=”statusName”] >
本体内容
</c:forTokens>
【参数说明】
（1）items指定被迭代的字符串。
（2）delims指定使用的分隔符。
（3）var指定用来存放遍历到的成员。
（4）begin指定遍历的开始位置（int型从取值0开始）。
（5）end指定遍历结束的位置（int型，默认集合中最后一个元素）。
（6）step遍历的步长（大于0的整型）。
（7）varStatus存放遍历到的成员的状态信息。
3.8.3、<c:forTokens>使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- forTokens标签实例</title>
</head>
<body>
<h4><c:out value="http://www.mamicode.com/forToken实例"/></h4>
<hr/>
< %--提示：分隔符的作用是根据标识，截取字符串。
如果未设定分隔符或在字符串中没有找到分隔付，将把整个元素作为一个元素截取。
在实际应用中用于在除去某些符号在页面中显示。 --%>
<c:forTokens var="str" items="北、京、欢、迎、您" delims="、">
<c:out value="http://www.mamicode.com/${str}"></c:out><br/>
</c:forTokens>
<br/>
<c:forTokens items="123-4567-8854" delims="-" var="t">
<c:out value="http://www.mamicode.com/${t}"></c:out><br/>
</c:forTokens>
<br/>
<c:forTokens items="1*2*3*4*5*6*7"
delims="*"
begin="1"
end="3"
var="n"
varStatus="s">
 <c:out value="http://www.mamicode.com/${n}" />的四种属性：<br>
    所在位置，即索引：<c:out value="http://www.mamicode.com/${s.index}" /><br>
    总共已迭代的次数：<c:out value="http://www.mamicode.com/${s.count}" /><br>
    是否为第一个位置：<c:out value="http://www.mamicode.com/${s.first}" /><br>
    是否为最后一个位置：<c:out value="http://www.mamicode.com/${s.last}" /><br>
</c:forTokens>
</body>
</html>
复制代码
运行结果如下：

3.9、URL操作标签——import标签使用讲解
3.9.1、<c:import>标签的功能
该标签可以把其他静态或动态文件包含到本JSP页面，与<jsp:include>的区别为：<jsp:include>只能包含同一个web应用中的文件。而<c:import>可以包含其他web应用中的文件，甚至是网络上的资源。
3.9.2、<c:import>标签的语法
【语法1】：
<c:import
url=”url”
[context=”context”]
[value=http://www.mamicode.com/”value”]
[scope=”page|request|session|application”]
[charEncoding=”encoding”]/>
【语法2】：
<c:import
url=”url”
varReader=”name”
[context=”context”]
[charEncoding=”encoding”]/>
【参数说明】：
（1）URL为资源的路径，当引用的资源不存在时系统会抛出异常，因此该语句应该放在<c:catch></c:catch>语句块中捕获。
（2）引用资源有两种方式：绝对路径和相对路径。
使用绝对路径的示例如下：<c:import url=”http://www.baidu.com”>
使用相对路径的示例如下：<c:import url=”aa.txt”>，aa.txt放在同一文件目录。
（3）如果以“/”开头表示应用的根目录下。例如：tomcat应用程序的根目录文件夹为webapps。导入webapps下的文件bb.txt的编写方式为：<c:import url=”/bb.txt”>
如果访问webapps管理文件夹中其他web应用就要用context属性。
（4）context属性用于在访问其他web应用的文件时，指定根目录。例如，访问root下的index.jsp的实现代码为：<c:import url=”/index.jsp” context=”/root”>
等同于webapps/root/index.jsp
（5）var、scope、charEncoding、varReader是可选属性。
3.9.3、<c:import>标签的使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- import标签实例</title>
</head>
<body>
<h4><c:out value="http://www.mamicode.com/import实例"/></h4>
<hr/>
<h4><c:out value="http://www.mamicode.com/绝对路径引用的实例" /></h4>
< %--使用绝对路径导入百度首页，
导入时使用<c:catch></c:catch>捕获异常。
--%>
<c:catch var="error1">
<c:import url="http://wwww.baidu.com" charEncoding="utf-8"/>
</c:catch>
${error1}
<hr/>
<h4>
<c:out value="http://www.mamicode.com/相对路径引用本应用中的文件" />
</h4>
< %--使用相对路径导入同一文件夹下的“JSTL的import标签使用说明”文件，
接收的字符编码格式使用charEncoding设置为utf-8。 --%>
<c:catch var="error2">
<c:import url="JSTL的import标签使用说明" charEncoding="utf-8"/>
</c:catch>
${error2}
<hr/>
<h4><c:out value="http://www.mamicode.com/使用字符串输出相对路径引用的实例，并保存在session范围内" /></h4>
< %--导入“JSTL的import标签使用说明.txt”，
使用var定义的变量接收要导入的文件，并存储在session中，
如果在其他页面同样也要导入该文件，只须使用<c:out>输出“JSTL的import标签使用说明.txt”的值即可。
--%>
<c:catch var="error3">
<c:import
var="myurl"
url="JSTL的import标签使用说明"
scope="session"
charEncoding="utf-8"/>
<c:out value="http://www.mamicode.com/${myurl}"></c:out>
<hr/>
<c:out value="http://www.mamicode.com/${myurl}" />
</c:catch>
${error3}
</body>
</html>
复制代码
3.10、URL操作标签——url标签使用总结
3.10.1、<c:url>标签的功能
<c:url>标签用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。
3.10.2、<c:url>标签的语法
【语法1】：指定一个url不做修改，可以选择把该url存储在JSP不同的范围中。
<c:url
value=http://www.mamicode.com/”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]/>
【语法2】：配合 <c:param>标签给url加上指定参数及参数值，可以选择以name存储该url。
<c:url
value=http://www.mamicode.com/”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]>
<c:param name=”参数名” value=http://www.mamicode.com/”值”>
</c:url>
3.10.3、<c:url>标签的主要属性

3.10.4、<c:url>标签使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- url标签实例</title>
</head>
<body>
<c:out value="http://www.mamicode.com/url标签使用"></c:out>
<h4>使用url标签生成一个动态的url，并把值存入session中.</h4>
<hr/>
<c:url value="http://www.baidu.com" var="url" scope="session">
</c:url>
<a href="http://www.mamicode.com/${url}">百度首页(不带参数)</a>
<hr/>
<h4>
配合 <c:param>标签给url加上指定参数及参数值，生成一个动态的url然后存储到paramUrl变量中
</h4>
<c:url value="http://www.baidu.com" var="paramUrl">
<c:param name="userName" value="http://www.mamicode.com/孤傲苍狼"/>
<c:param name="pwd">123456</c:param>
</c:url>
<a href="http://www.mamicode.com/${paramUrl}">百度首页(带参数)</a>
</body>
</html>
复制代码
3.11、URL操作标签——redirect标签使用总结
3.11.1、<c:redirect>标签的功能
该标签用来实现请求的重定向。同时可以配合使用<c:param>标签在url中加入指定的参数。
3.11.2、<c:redirect>标签的语法
【语法1】：
<c:redirect url=”url” [context=”context”]/>
【语法2】：
<c:redirect url=”url”[context=”context”]>
<c:param name=”name1” value=http://www.mamicode.com/”value1”>
</c:redirect>
【参数说明】：
（1）url指定重定向页面的地址，可以是一个string类型的绝对地址或相对地址。
（2）context用于导入其他web应用中的页面。
3.11.3、<c:redirect>标签的属性

3.11.4、<c:redirect>标签使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入JSTL核心标签库 --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML>
<html>
<head>
<title>JSTL: -- redirect标签实例</title>
</head>
<body>
<c:redirect url="http://www.baidu.com">
< %--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
<c:param name="uname">GACL</c:param>
<c:param name="password">123</c:param>
</c:redirect>
</body>
</html>
复制代码
3.12、<c:param>标签使用总结
在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。
<c:param>标签在为一个URL地址附加参数时，将自动对参数值进行URL编码，例如，如果传递的参数值为“中国”，则将其转换为“%d6%d0%b9%fa”后再附加到URL地址后面，这也就是使用<c:param>标签的最大好处。
示例1：与<c:url>标签嵌套使用
<c:url value="http://www.baidu.com" var="paramUrl">
<c:param name="userName" value="http://www.mamicode.com/孤傲苍狼"/>
<c:param name="pwd">123456</c:param>
</c:url>
<a href="http://www.mamicode.com/${paramUrl}">百度首页(带参数)</a>
示例2：与<c:redirect>标签嵌套使用
<c:redirect url="http://www.baidu.com">
< %--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
<c:param name="uname">GACL</c:param>
<c:param name="password">123</c:param>
</c:redirect>
关于JSTL核心标签库中的标签掌握以上的那些标签基本上就可以应付开发了。

(二十九)——EL表达式
一、EL表达式简介
EL 全名为Expression Language。EL主要作用：
1、获取数据
EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域中检索java对象、获取数据。(某个web域中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
2、执行运算
利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null}
3、获取web开发常用对象
EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。
4、调用Java方法
EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
1.1、获取数据
使用EL表达式获取数据语法："${标识符}"
EL表达式语句在执行时，会调用pageContext.findAttribute方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
EL表达式可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据
el表达式获取数据范例：
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@page import="me.gacl.domain.Person"%>
<%@page import="me.gacl.domain.Address"%>
<!DOCTYPE HTML>
<html>
<head>
<title>el表达式获取数据</title>
</head>
<body>
<%
request.setAttribute("name","孤傲苍狼");
%>
< %--${name}等同于pageContext.findAttribute("name") --%>
使用EL表达式获取数据：${name}
<hr>

<%
Person p = new Person();
p.setAge(12);
request.setAttribute("person",p);
%>
使用el表达式可以获取bean的属性：${person.age}
<hr>

<%
Person person = new Person();
Address address = new Address();
person.setAddress(address);
request.setAttribute("person",person);
%>
${person.address.name}
<hr>

<%
Person p1 = new Person();
p1.setName("孤傲苍狼");
Person p2 = new Person();
p2.setName("白虎神皇");
List<Person> list = new ArrayList<Person>();
list.add(p1);
list.add(p2);
request.setAttribute("list",list);
%>

${list[1].name}

<c:forEach var="person" items="${list}">
${person.name}
</c:forEach>
<hr>

<%
Map<String,String> map = new LinkedHashMap<String,String>();
map.put("a","aaaaxxx");
map.put("b","bbbb");
map.put("c","cccc");
map.put("1","aaaa1111");
request.setAttribute("map",map);
%>

${map.c}
${map["1"]}
<hr>

<c:forEach var="me" items="${map}">
${me.key}=${me.value}<br/>
</c:forEach>
<hr>
</body>
</html>
复制代码
运行效果如下：
s
1.2、执行运算
语法：${运算表达式}，EL表达式支持如下运算符：
1、关系运算符

2、逻辑运算符：

3、empty运算符：检查对象是否为null(空)
4、二元表达式：${user!=null?user.name :""}
5、[ ] 和 . 号运算符
使用EL表达式执行运算范例：
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@page import="me.gacl.domain.User"%>
<!DOCTYPE HTML>
<html>
<head>
<title>el表达式运算符</title>
</head>
<body>
<h3>el表达式进行四则运算：</h3>
加法运算：${365+24}<br/>
减法运算：${365-24}<br/>
乘法运算：${365*24}<br/>
除法运算：${365/24}<br/>
<h3>el表达式进行关系运算：</h3>
< %--${user == null}和 ${user eq null}两种写法等价--%>
${user == null}<br/>
${user eq null}<br/>
<h3>el表达式使用empty运算符检查对象是否为null(空)</h3>
<%
List<String> list = new ArrayList<String>();
list.add("gacl");
list.add("xdp");
request.setAttribute("list",list);
%>
< %--使用empty运算符检查对象是否为null(空) --%>
<c:if test="${!empty(list)}">
<c:forEach var="str" items="${list}">
${str}<br/>
</c:forEach>
</c:if>
<br/>
<%
List<String> emptyList = null;
%>
< %--使用empty运算符检查对象是否为null(空) --%>
<c:if test="${empty(emptyList)}">
对不起，没有您想看的数据
</c:if>
<br/>
<h3>EL表达式中使用二元表达式</h3>
<%
session.setAttribute("user",new User("孤傲苍狼"));
%>
${user==null? "对不起，您没有登陆 " : user.username}
<br/>
<h3>EL表达式数据回显</h3>
<%
User user = new User();
user.setGender("male");
//数据回显
request.setAttribute("user",user);
%>
<input type="radio" name="gender" value="http://www.mamicode.com/male" ${user.gender==‘male‘?‘checked‘:‘‘}>男
<input type="radio" name="gender" value="http://www.mamicode.com/female" ${user.gender==‘female‘?‘checked‘:‘‘}> 女
<br/>65 </body>
</html>
复制代码
运行结果如下：

1.3、获得web开发常用对象
EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。
语法：${隐式对象名称}：获得对象的引用
隐含对象名称:
1.pageContex : 对应于JSP页面中的pageContext对象（注意：取的是pageContext对象。）
2.pageScope : 代表page域中用于保存属性的Map对象
3.requestScope : 代表request域中用于保存属性的Map对象
4.sessionScope : 代表session域中用于保存属性的Map对象
5.applicationScope : 代表application域中用于保存属性的Map对象
6.param : 表示一个保存了所有请求参数的Map对象
7.paramValues : 表示一个保存了所有请求参数的Map对象，它对于某个请求参数，返回的是一个string[]
8.header : 表示一个保存了所有http请求头字段的Map对象，注意：如果头里面有“-” ，例Accept-Encoding，则要header[“Accept-Encoding”]
9.headerValues : 表示一个保存了所有http请求头字段的Map对象，它对于某个请求参数，返回的是一个string[]数组。注意：如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
10.cookie : 表示一个保存了所有cookie的Map对象
11.initParam : 表示一个保存了所有web应用初始化参数的map对象
测试EL表达式中的11个隐式对象：
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>el隐式对象</title>
</head>
<body>
<br/>---------------1、pageContext对象：获取JSP页面中的pageContext对象------------------------<br/>
${pageContext}
<br/>---------------2、pageScope对象：从page域(pageScope)中查找数据------------------------<br/>
<%
pageContext.setAttribute("name","孤傲苍狼"); //map
%>
${pageScope.name}
<br/>---------------3、requestScope对象：从request域(requestScope)中获取数据------------------------<br/>
<%
request.setAttribute("name","白虎神皇"); //map
%>
${requestScope.name}
<br/>---------------4、sessionScope对象：从session域(sessionScope)中获取数据------------------------<br/>
<%
session.setAttribute("user","xdp"); //map
%>
${sessionScope.user}
<br/>---------------5、applicationScope对象：从application域(applicationScope)中获取数据------------------------<br/>
<%
application.setAttribute("user","gacl"); //map
%>
${applicationScope.user}
<br/>--------------6、param对象：获得用于保存请求参数map，并从map中获取数据------------------------<br/>

${param.name}

<form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
<input type="text" name="username" value="http://www.mamicode.com/${param.username}">
<input type="submit" value="http://www.mamicode.com/注册">
</form>
<br/>--------------7、paramValues对象：paramValues获得请求参数 //map{"",String[]}------------------------<br/>

${paramValues.like[0]}
${paramValues.like[1]}
<br/>--------------8、header对象：header获得请求头------------------------<br/>
${header.Accept}<br/>
< %--${header.Accept-Encoding} 这样写会报错
测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
--%>
${header["Accept-Encoding"]}
<br/>--------------9、headerValues对象：headerValues获得请求头的值------------------------<br/>
< %--headerValues表示一个保存了所有http请求头字段的Map对象，它对于某个请求参数，返回的是一个string[]数组
例如：headerValues.Accept返回的是一个string[]数组，headerValues.Accept[0]取出数组中的第一个值
--%>
${headerValues.Accept[0]}<br/>
< %--${headerValues.Accept-Encoding} 这样写会报错
测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
headerValues["Accept-Encoding"]返回的是一个string[]数组，headerValues["Accept-Encoding"][0]取出数组中的第一个值
--%>
${headerValues["Accept-Encoding"][0]}
<br/>--------------10、cookie对象：cookie对象获取客户机提交的cookie------------------------<br/>

${cookie.JSESSIONID.value} //保存所有cookie的map
<br/>--------------11、initParam对象：initParam对象获取在web.xml文件中配置的初始化参数------------------------<br/>
< %--

<context-param>
<param-name>xxx</param-name>
<param-value>yyyy</param-value>
</context-param>
<context-param>
<param-name>root</param-name>
<param-value>/JavaWeb_EL_Study_20140826</param-value>
</context-param>
--%>
< %--获取servletContext中用于保存初始化参数的map --%>
${initParam.xxx}<br/>
${initParam.root}
</body>
</html>
复制代码
RegisterServlet的代码如下：
复制代码
package me.gacl.web.controller;
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 RegisterServlet extends HttpServlet {
/*
* 处理用户注册的方法
*/
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//1、接收参数
String userName = request.getParameter("username");
/**
* 2、直接跳转回/ELDemo03.jsp页面，没有使用request.setAttribute("userName", userName)将userName存储到request对象中
* 但是在ELDemo03.jsp页面中可以使用${param.username}获取到request对象中的username参数的值
*/
request.getRequestDispatcher("/ELDemo03.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
复制代码
测试结果如下：

注意:
测试header和headerValues时，如果头里面有“-” ，例Accept-Encoding，则要header["Accept-Encoding"]、headerValues["Accept-Encoding"]
测试cookie时，例${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value}
1.4、使用EL调用Java方法
EL表达式语法允许开发人员开发自定义函数，以调用Java类的方法。语法：${prefix：method(params)}
在EL表达式中调用的只能是Java类的静态方法，这个Java类的静态方法需要在TLD文件中描述，才可以被EL表达式调用。
EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能。
1.5、EL Function开发步骤
一般来说， EL自定义函数开发与应用包括以下三个步骤：
1、编写一个Java类的静态方法
2、编写标签库描述符（tld）文件，在tld文件中描述自定义函数。
3、在JSP页面中导入和使用自定义函数
示例：开发对html标签进行转义的el function
1、编写html转义处理工具类，工具类中添加对html标签进行转义的静态处理方法，如下：
复制代码
package me.gacl.util;
/**
* @ClassName: HtmlFilter
* @Description: html转义处理工具类
* @author: 孤傲苍狼
* @date: 2014-8-27 上午12:09:15
*
*/
public class HtmlFilter {
/**
* @Method: filter
* @Description: 静态方法，html标签转义处理
* @Anthor:孤傲苍狼
*
* @param message 要转义的内容
* @return 转义后的内容
*/
public static String filter(String message) {
if (message == null)
return (null);
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuffer result = new StringBuffer(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case ‘<‘:
result.append("<");
break;
case ‘>‘:
result.append(">");
break;
case ‘&‘:
result.append("&");
break;
case ‘"‘:
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}
}
复制代码
2、在WEB-INF目录下编写标签库描述符（tld）文件，在tld文件中描述自定义函数

elFunction.tld的代码如下：
复制代码
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">
<tlib-version>1.0</tlib-version>
<short-name>EL Function</short-name>

<uri>/ELFunction</uri>

<function>
<description>html标签转义处理方法</description>

<name>filter</name>

<function-class>me.gacl.util.HtmlFilter</function-class>

<function-signature>java.lang.String filter(java.lang.String)</function-signature>
</function>
</taglib>
复制代码
3、在JSP页面中导入和使用自定义函数
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
< %--引入EL自定义函数库 --%>
<%@taglib uri="/ELFunction" prefix="fn" %>
<!DOCTYPE HTML>
<html>
<head>
<title>使用EL调用Java方法</title>
</head>
<body>
< %--使用EL调用filter方法--%>
${fn:filter("<a href=http://www.mamicode.com/‘‘>点点")}
</body>
</html>
复制代码
运行结果如下：

1.6、开发EL Function注意事项
编写完标签库描述文件后，需要将它放置到<web应用>\WEB-INF目录中或WEB-INF目录下的除了classes和lib目录之外的任意子目录中。
TLD文件中的<uri> 元素用指定该TLD文件的URI，在JSP文件中需要通过这个URI来引入该标签库描述文件。
<function>元素用于描述一个EL自定义函数，其中：
<name>子元素用于指定EL自定义函数的名称。
<function-class>子元素用于指定完整的Java类名，
<function-signature>子元素用于指定Java类中的静态方法的签名，方法签名必须指明方法的返回值类型及各个参数的类型，各个参数之间用逗号分隔。
1.7、EL注意事项
EL表达式是JSP 2.0规范中的一门技术。因此，若想正确解析EL表达式，需使用支持Servlet2.4/JSP2.0技术的WEB服务器。
注意：有些Tomcat服务器如不能使用EL表达式
（1）升级成tomcat6
（2）在JSP中加入<%@ page isELIgnored="false" %>
1.8、EL表达式保留关键字

所谓保留字的意思是指变量在命名时，应该避开上述的名字，以免程序编译时发生错误，关于EL表达式的内容的总结就这么多。

(三十)——EL函数库
一、EL函数库介绍
由于在JSP页面中显示数据时，经常需要对显示的字符串进行处理，SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。
这些EL函数在JSTL开发包中进行描述，因此在JSP页面中使用SUN公司的EL函数库，需要导入JSTL开发包，并在页面中导入EL函数库，如下所示：
MyEclipse自带的JSTL开发包：

fn.tld就是EL函数库的对应的tld描述文件，如下图所示：

在页面中使用JSTL定义的EL函数：<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
EL函数集:
static boolean contains(String input, String substring)
static boolean containsIgnoreCase(String input, String substring)
static boolean endsWith(String input, String suffix)
static String escapeXml(String input)
static int indexOf(String input, String substring)
static String join(String[] array, String separator)
static int length(Object obj)
static String replace(String input, String before, String after)
static String[] split(String input, String delimiters)
static boolean startsWith(String input, String prefix)
static String substring(String input, int beginIndex, int endIndex)
static String substringAfter(String input, String substring)
static String substringBefore(String input, String substring)
static String toLowerCase(String input)
static String toUpperCase(String input)
static String trim(String input)

二、EL函数使用范例
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@page import="me.gacl.domain.User"%>
< %--引入EL函数库 --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<!DOCTYPE HTML>
<html>
<head>
<title>EL函数库中的方法使用范例</title>
</head>
<body>
<h3>fn:toLowerCase函数使用范例：</h3>
< %--fn:toLowerCase函数将一个字符串中包含的所有字符转换为小写形式，并返回转换后的字符串，
它接收一个字符串类型的参数。fn:toLowerCase("")的返回值为空字符串--%>
< %--fn:toLowerCase("Www.CNBLOGS.COM") 的返回值为字符串“www.cnblogs.com” --%>
fn:toLowerCase("Www.CNBLOGS.COM")的结果是：${fn:toLowerCase("Www.CNBLOGS.COM")}
<hr/>
<h3>fn:toUpperCase函数使用范例：</h3>
< %--fn:toUpperCase函数将一个字符串中包含的所有字符转换为大写形式，并返回转换后的字符串，
它接收一个字符串类型的参数。fn:toUpperCase("")的返回值为空字符串--%>
fn:toUpperCase("cnblogs.com")的结果是：${fn:toUpperCase("cnblogs.com")}
<hr/>
<h3>fn:trim函数使用范例：</h3>
< %--fn:trim函数删除一个字符串的首尾的空格，并返回删除空格后的结果字符串，
它接收一个字符串类型的参数。需要注意的是，fn:trim函数不能删除字符串中间位置的空格。--%>
fn:trim(" cnblogs.com ")的结果是：${fn:trim(" cnblogs.com ")}
<hr/>
<h3>fn:length函数使用范例：</h3>
< %--fn:length函数返回一个集合或数组大小，或返回一个字符串中包含的字符的个数，返回值为int类型。
fn:length函数接收一个参数，这个参数可以是<c:forEach>标签的items属性支持的任何类型，
包括任意类型的数组、java.util.Collection、java.util.Iterator、java.util.Enumeration、
java.util.Map等类的实例对象和字符串。
如果fn:length函数的参数为null或者是元素个数为0的集合或数组对象，则函数返回0；如果参数是空字符串，则函数返回0
--%>
<%
List<String> list = Arrays.asList("1","2","3");
request.setAttribute("list",list);
%>
fn:length(list)计算集合list的size的值是：${fn:length(list)}
<br/>
fn:length("cnblogs.com")计算字符串的长度是：${fn:length("cnblogs.com")}
<hr/>
<h3>fn:split函数使用范例：</h3>
< %--
fn:split函数以指定字符串作为分隔符，将一个字符串分割成字符串数组并返回这个字符串数组。
fn:split函数接收两个字符串类型的参数，第一个参数表示要分割的字符串，第二个参数表示作为分隔符的字符串
--%>
fn:split("cnblogs.com",".")[0]的结果是：${fn:split("cnblogs.com",".")[0]}
<hr/>
<h3>fn:join函数使用范例：</h3>
< %--
fn:join函数以一个字符串作为分隔符，将一个字符串数组中的所有元素合并为一个字符串并返回合并后的结果字符串。
fn:join函数接收两个参数，第一个参数是要操作的字符串数组，第二个参数是作为分隔符的字符串。
如果fn:join函数的第二个参数是空字符串，则fn:join函数的返回值直接将元素连接起来。
--%>
<%
String[] StringArray = {"www","iteye","com"};
pageContext.setAttribute("StringArray", StringArray);
%>
< %--fn:join(StringArray,".")返回字符串“www.iteye.com”--%>
fn:join(StringArray,".")的结果是：${fn:join(StringArray,".")}
<br/>
< %--fn:join(fn:split("www,iteye,com",","),".")的返回值为字符串“www.iteye.com”--%>
fn:join(fn:split("www,iteye,com",","),".")的结果是：${fn:join(fn:split("www,iteye,com",","),".")}
<hr/>
<h3>fn:indexOf函数使用范例：</h3>
< %--
fn:indexOf函数返回指定字符串在一个字符串中第一次出现的索引值，返回值为int类型。
fn:indexOf函数接收两个字符串类型的参数，如果第一个参数字符串中包含第二个参数字符串，
那么，不管第二个参数字符串在第一个参数字符串中出现几次，fn:indexOf函数总是返回第一次出现的索引值；
如果第一个参数中不包含第二个参数，则fn:indexOf函数返回-1。如果第二个参数为空字符串，则fn:indexOf函数总是返回0。
--%>
fn:indexOf("www.iteye.com","eye")的返回值为：${fn:indexOf("www.iteye.com","eye")}
<hr/>
<h3>fn:contains函数使用范例：</h3>
< %--
fn:contains函数检测一个字符串中是否包含指定的字符串，返回值为布尔类型。
fn:contains函数在比较两个字符串是否相等时是大小写敏感的。
fn:contains函数接收两个字符串类型的参数，如果第一个参数字符串中包含第二个参数字符串，则fn:contains函数返回true，否则返回false。
如果第二个参数的值为空字符串，则fn:contains函数总是返回true。
实际上，fn:contains(string, substring)等价于fn:indexOf(string, substring) != -1
忽略大小的EL函数：fn:containsIgnoreCase
--%>
<%
User user = new User();
String likes[] = {"sing","dance"};
user.setLikes(likes);
//数据回显
request.setAttribute("user",user);
%>
< %--使用el函数回显数据 --%>
<input type="checkbox" name="like"
vlaue="sing" ${fn:contains(fn:join(user.likes,","),"sing")?‘checked‘:‘‘}/>唱歌
<input type="checkbox" name="like"
value="http://www.mamicode.com/dance" ${fn:contains(fn:join(user.likes,","),"dance")?‘checked‘:‘‘}/>跳舞
<input type="checkbox" name="like"
value="http://www.mamicode.com/basketball" ${fn:contains(fn:join(user.likes,","),"basketball")?‘checked‘:‘‘}/>蓝球
<input type="checkbox" name="like"
value="http://www.mamicode.com/football" ${fn:contains(fn:join(user.likes,","),"football")?‘checked‘:‘‘}/>足球
<hr/>
<h3>fn:startsWith函数和fn:endsWith函数使用范例：</h3>
< %--
fn:startsWith函数用于检测一个字符串是否是以指定字符串开始的，返回值为布尔类型。
fn:startsWith函数接收两个字符串类型的参数，如果第一个参数字符串以第二个参数字符串开始，则函数返回true，否则函数返回false。
如果第二个参数为空字符串，则fn:startsWith函数总是返回true。
与fn:startsWith函数对应的另一个EL函数为：fn:endsWith，用于检测一个字符串是否是以指定字符串结束的，返回值为布尔类型。
--%>
fn:startsWith("www.iteye.com","iteye")的返回值为：${fn:startsWith("www.iteye.com","iteye")}
<br/>
fn:endsWith("www.iteye.com","com")的返回值为：${fn:endsWith("www.iteye.com","com")}
<hr/>
<h3>fn:replace使用范例：</h3>
< %--
fn:replace函数将一个字符串中包含的指定子字符串替换为其它的指定字符串，并返回替换后的结果字符串。
fn:replace方法接收三个字符串类型的参数，第一个参数表示要操作的源字符串，第二个参数表示源字符串中要被替换的子字符串，
第三个参数表示要被替换成的字符串。
--%>
fn:replace("www iteye com ", " ", ".")的返回值为字符串：${fn:replace("www iteye com", " ", ".")}
<hr/>
<h3>fn:substring使用范例：</h3>
< %--
fn:substring函数用于截取一个字符串的子字符串并返回截取到的子字符串。
fn:substring函数接收三个参数，第一个参数是用于指定要操作的源字符串，第二个参数是用于指定截取子字符串开始的索引值，
第三个参数是用于指定截取子字符串结束的索引值，第二个参数和第三个参数都是int类型，其值都从0开始。
--%>
fn:substring("www.it315.org", 4, 9) 的返回值为字符串：${fn:substring("www.it315.org", 4, 9)}
<h3>fn:substringAfter函数和fn:substringBefore函数使用范例：</h3>
< %--
fn:substringAfter函数用于截取并返回一个字符串中的指定子字符串第一次出现之后的子字符串。
fn:substringAfter函数接收两个字符串类型的参数，第一个参数表示要操作的源字符串，第二个参数表示指定的子字符串
与之对应的EL函数为：fn:substringBefore
--%>
fn:substringAfter("www.it315.org",".")的返回值为字符串：${fn:substringAfter("www.it315.org",".")}
<br/>
fn:substringBefore("www.it315.org",".")的返回值为字符串：${fn:substringBefore("www.it315.org",".")}
<hr/>
</body>
</html>
复制代码
jsp页面中使用到的me.gacl.domain.User类的代码如下：
复制代码
package me.gacl.domain;
public class User {
/**
* 兴趣爱好
*/
private String likes[];
public String[] getLikes() {
return likes;
}
public void setLikes(String[] likes) {
this.likes = likes;
}
}
复制代码
运行结果如下：

(三十一)——国际化(i18n)
javaweb学习总结(三十一)——国际化(i18n)
一、国际化开发概述
软件的国际化：软件开发时，要使它能同时应对世界不同地区和国家的访问，并针对不同地区和国家的访问，提供相应的、符合来访者阅读习惯的页面或数据。
国际化(internationalization)又称为 i18n(读法为i 18 n，据说是因为internationalization(国际化)这个单词从i到n之间有18个英文字母，i18n的名字由此而来)
二、合格的国际化软件
软件实现国际化，需具备以下两个特征：
1、对于程序中固定使用的文本元素，例如菜单栏、导航条等中使用的文本元素、或错误提示信息，状态信息等，需要根据来访者的地区和国家，选择不同语言的文本为之服务。
2、对于程序动态产生的数据，例如(日期，货币等)，软件应能根据当前所在的国家或地区的文化习惯进行显示。
三、固定文本元素的国际化
对于软件中的菜单栏、导航条、错误提示信息，状态信息等这些固定不变的文本信息，可以把它们写在一个properties文件中，并根据不同的国家编写不同的properties文件。这一组properties文件称之为一个资源包。
3.1、创建资源包和资源文件
一个资源包中的每个资源文件都必须拥有共同的基名。除了基名，每个资源文件的名称中还必须有标识其本地信息的附加部分。例如：一个资源包的基名是“myproperties”，则与中文、英文环境相对应的资源文件名则为: "myproperties_zh.properties" "myproperties_en.properties"

每个资源包都应有一个默认资源文件，这个文件不带有标识本地信息的附加部分。若ResourceBundle对象在资源包中找不到与用户匹配的资源文件，它将选择该资源包中与用户最相近的资源文件，如果再找不到，则使用默认资源文件。例如：myproperties.properties
3.2、资源文件的书写格式
资源文件的内容通常采用"关键字＝值"的形式，软件根据关键字检索值显示在页面上。一个资源包中的所有资源文件的关键字必须相同，值则为相应国家的文字。
并且资源文件中采用的是properties格式文件，所以文件中的所有字符都必须是ASCII字码，属性(properties)文件是不能保存中文的，对于像中文这样的非ACSII字符，须先进行编码。
例如：
国际化的中文环境的properties文件

国际化的英文环境的properties文件

java提供了一个native2ascII工具用于将中文字符进行编码处理，native2ascII的用法如下所示：

3.3、编程实现固定文本的国际化
在JavaAPI中提供了一个ResourceBundle 类用于描述一个资源包，并且 ResourceBundle类提供了相应的方法getBundle，这个方法可以根据来访者的国家地区自动获取与之对应的资源文件予以显示。
ResourceBundle类提供了一个静态方法getBundle，该方法用于装载资源文件，并创建ResourceBundle实例：
Locale currentLocale = Locale.getDefault();
ResourceBundle myResources = ResourceBundle.getBundle(basename, currentLocale);
basename为资源包基名(且必须为完整路径)。
如果与该locale对象匹配的资源包子类找不到。一般情况下，则选用默认资源文件予以显示。
加载资源文件后，程序就可以调用ResourceBundle 实例对象的 getString 方法获取指定的资源信息名称所对应的值。
String value = http://www.mamicode.com/myResources.getString(“key");
范例：根据国家地区自动获取与之对应的资源文件
复制代码
package me.gacl.i18n;
import java.util.Locale;
import java.util.ResourceBundle;
/**
* @ClassName: I18NTest
* @Description: 编程实现固定文本的国际化
* @author: 孤傲苍狼
* @date: 2014-8-29 下午9:34:05
*
*/
public class I18NTest {
public static void main(String[] args) {
//资源包基名(包名+myproperties)
String basename = "me.gacl.i18n.resource.myproperties";
//设置语言环境
Locale cn = Locale.CHINA;//中文
Locale us = Locale.US;//英文
//根据基名和语言环境加载对应的语言资源文件
ResourceBundle myResourcesCN = ResourceBundle.getBundle(basename,cn);//加载myproperties_zh.properties
ResourceBundle myResourcesUS = ResourceBundle.getBundle(basename,us);//加载myproperties_en.properties
//加载资源文件后，程序就可以调用ResourceBundle实例对象的 getString方法获取指定的资源信息名称所对应的值。
//String value = http://www.mamicode.com/myResources.getString(“key");
String usernameCN = myResourcesCN.getString("username");
String passwordCN = myResourcesCN.getString("password");
String usernameUS = myResourcesUS.getString("username");
String passwordUS = myResourcesUS.getString("password");
System.out.println(usernameCN+"--"+passwordCN);
System.out.println(usernameUS+"--"+passwordUS);
}
}
复制代码
运行结果：

3.4、在WEB应用中实现固定文本的国际化
如下所示：
复制代码
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
<head>
<title>国际化(i18n)测试</title>
</head>
<%
//加载i18n资源文件，request.getLocale()获取访问用户所在的国家地区
ResourceBundle myResourcesBundle = ResourceBundle.getBundle("me.gacl.i18n.resource.myproperties",request.getLocale());
%>
<body>
<form action="" method="post">
<%=myResourcesBundle.getString("username")%>：<input type="text" name="username"/><br/>
<%=myResourcesBundle.getString("password")%>：<input type="password" name="password"/><br/>
<input type="submit" value="http://www.mamicode.com//js/login.js"></script>
<%--使用绝对路径的方式引用css样式--%>
<link rel="stylesheet" href="http://www.mamicode.com/${pageContext.request.contextPath}/css/index.css" type="text/css"/>
综合范例：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>"/"代表webapps目录的常见应用场景</title>
<%--使用绝对路径的方式引用js脚本--%>
<script type="text/javascript" src="http://www.mamicode.com/${pageContext.request.contextPath}/js/index.js"></script>
<%--${pageContext.request.contextPath}与request.getContextPath()写法是得到的效果是一样的--%>
<script type="text/javascript" src="http://www.mamicode.com//js/login.js"></script>
<%--使用绝对路径的方式引用css样式--%>
<link rel="stylesheet" href="http://www.mamicode.com/${pageContext.request.contextPath}/css/index.css" type="text/css"/>
</head>

<body>
<%--form表单提交--%>
<form action="${pageContext.request.contextPath}/servlet/CheckServlet" method="post">
<input type="submit" value="http://www.mamicode.com/提交">
</form>
<%--超链接跳转页面--%>
<a href="http://www.mamicode.com/${pageContext.request.contextPath}/index.jsp">跳转到首页</a>
</body>
</html>

Request getParameter() 和getAttribute() 区别
getParameter 是用来接受用post个get方法传递过来的参数的. 一般通过表单和链接传递的参数使用getParameter
getAttribute 必须先setAttribute.

一般可以用getParameter得到页面字符串参数
getAttribute()可以得到对象
getParameter可以得到页面传来的参数如？id=123之类的。
getAttribute()常用于servlet页面传递参数给jsp

getParameter()得到的值如果下次不提交或保存起来的话，下次重定向后就没了

（1）request.getParameter() 取得是通过容器的实现来取得通过类似post，get等方式传入的数据，request.setAttribute()和getAttribute()只是在web容器内部流转，仅仅是请求处理阶段。

（2）request.getParameter() 方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据。request.getParameter()方法返回String类型的数据。

request.setAttribute() 和 getAttribute() 方法传递的数据只会存在于Web容器内部

还有一点就是，HttpServletRequest 类有 setAttribute() 方法，而没有setParameter() 方法。

路径
1 取出部署的应用程序路径
使用<%=request.getContextPath()%>和使用${pageContext.request.contextPath}达到同样的效果

<link rel="stylesheet" href="http://www.mamicode.com/${pageContext.request.contextPath}/themes/default/css/ueditor.css" type="text/css"/>

<script type="text/javascript" src="http://www.mamicode.com/${pageContext.request.contextPath}/ueditor1_3_6-gbk-jsp/ueditor.config.js"></script>
<script type="text/javascript" src="http://www.mamicode.com//ueditor1_3_6-gbk-jsp/ueditor.all.js"></script>

getResourceAsStream
/**
* 通过ServletContext对象读取项目根目录下的db1.properties配置文件
*/
InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db1.properties");
this.getClass().getClassLoader().getResource("/").getPath();
XmlUtils.class.getClassLoader().getResource("DB.xml");
request.getContextPath()+"/servlet/LoginUIServlet"
Thread.currentThread().getContextClassLoader().getResources(packageDirName);
String realPath = this.getServletContext().getRealPath("/download/1.JPG");

Eclipse 设置
项目输出路径 : Chapter6/WebContent/WEB-INF/classes
WebContent\WEB-INF\classes
Tomcat
1 Tomcat 无法运行
org.apache.catalina.LifecycleException:Failed to start component [StandardEngine[Catalina].StandardHost[localhost].StandardContext

@WebServlet("/Example6_2") //一定要加这个 , 这个重复会导致tomcat 无法启动

2 Tomcat 无法运行
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>Chapter5</display-name>

<servlet>
<servlet-name>Example1</servlet-name>
<servlet-class>com.examples.Example1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Example1</servlet-name>
<url-pattern>/servlet/Example1</url-pattern> 
</servlet-mapping>
</web-app>

结尾

java web -- gacl 汇总

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > java web -- gacl 汇总

java web -- gacl 汇总

abcdefghjkl

看完仍有疑问？有类似问题直接问程序猿