servlet 理解 --servlet笔记

http 80
smtp 25
pop3 110
ftp 23
https 443

Host里面

<Context path="/itcast" docBase="c:\news"/>
改动了server.xml文件后要重启Tomcat服务器。
<Context path="" docBase="c:\news"/> 默认的web应用

请求头/消息头：
Accept:告诉服务器，客户机支持的数据类型
Accept-Charset：用于告诉服务器，客户机支持的编码类型
Accept-Encoding：客户机支持的压缩方式
Accept-Language：客户机的语言环境
Host：客户机告诉服务器，想访问的主机名
if-Modified-Since：客户机通过这个头告诉服务器
资源的缓存时间
Referef：客户机就通过这个头，告诉服务器，他是从那个资源来访问服务器的（防盗链）
User-Agent：客户机就通过这个头，告诉服务器客户机的软件环境。
Cookie：客户机就通过这个头，可以向服务器带数据
Connection：告诉服务器，访问后是关闭还是保持链接
Date：当前的时间

响应头：
Location：这个头配合302状态码，告诉客户找谁

Server:服务器通过这个头，告诉浏览器服务器的类型
Content-Encoding：服务器通过这个头，告诉数据的压缩方式。
Content-Length：回送浏览器的数据长度

Content-type：回送浏览器的数据类型。

Last-Modified：告诉浏览器当前资源的缓存时间

Refresh：告诉浏览器，隔多长时间刷新一次

Content- Disposition：服务器通过这个头，告诉浏览器以下在方式打开数据

Transfer-Encoding 告诉浏览器的传送方式
ETag：缓存相关的头。

Expires：告诉浏览器把数据缓存多长时间

Cache-Control；no-cache
Pragme：no-cache
服务器通过以上两个头，也是控制浏览器不要缓存数据。
Connection：
Date：
××××××××××××××××××××××

Servlet

C/S模式的软件客户端/服务器比如QQ,或者一些大型游戏
用户需要先下载软件的客户端,然后才可以使用.

B/S模式的软件浏览器/服务器我们上网时候所访问网站的基本全是B/S模式的项目.
用户不需要下载任何东西,只需要用到浏览器就可以访问到这个项目.

我们在java中要学习的web项目,就是B/S架构的项目.

web项目中,其实就是俩个软件之间的信息交换,客户端机器中的浏览器软件和服务器端机器中的web服务器软件之间
的交换,比如在我们的学习中,就是客户端的浏览器和服务器端的tomcat进行信息交换。

浏览器和tomcat是俩个不同的软件,但是在开发这俩个软件的时候,都是加入对http协议的支持,
所有它们俩个进行信息交换的时候,是通过http协议规定的方式进行交换的:客户端先发送一个请求,
然后服务器端接收到请求后再返回给客户端一个响应,并且把客户端所请求的资源返回给客户端.

我们要做的时候就是,开发一个web项目,然后把这个web项目放到tomcat里面指的的位置,
然后再运行这个tomcat软件,在tomcat运行过程中,其他计算机里面,只要是网络和我们这个服务器是通的,
那么都可以通过浏览器来访问我们这个web项目。

在用浏览器访问tomcat的时候,tomcat会按照浏览器发送的这个请求里面的内容,
把浏览器想访问的页面从web项目中找到并返回给这个浏览器,或者是tomcat去调用web项目所写的某些java类中的方法
(其实就调用servlet中的方法)

注意:web项目中,任何一个类里面都不需要写main方法,整个项目的运行,对象的创建,方法的调用,都是
由tomcat处理的,我们不需要去管. tomcat根据客户端的要求,会调用某个servlet中的指定方法,
然后在这个指定方法里面,我们可以写上调用我们自己写的某个类的方法,类似的这样方法相互调用下去,
最后调用到我们sql语句的执行,这样我们的一个功能就走完了,比如说登录或者注册功能。

一个web项目最基本的项目结构:
项目名字:WebTest
1.文件夹WebTest,项目名字是随便起的

2.WebTest文件中有文件WEB-INF,WEB-INF这个名字是固定的

3.WEB-INF文件夹中:classes文件夹,lib文件夹,web.xml文件,这个名字都是固定的。
web.xml文件在tomcat目录中的conf目录里面有一个web.xml模板.

注意:
WebTest文件夹下面还可以放页面,css样式、js文件、图片等等.
classes文件夹中放的是编译后的.class文件
lib文件夹中放的是当前项目中运行所需要的jar包
servlet

tomcat服务器:
bin 目录:启动、关闭tomcat相关的命令。
conf目录:tomcat的配置文件
lib 目录:tomcat中可以同时部署多个项目,多个项目都需要用到的相同jar包,就可以放在这个目录。
logs目录:记录tomcat日常运行的情况或者错误信息。
temp目录:tomcat运行期间可能会产生一些临时文件,这写临时文件就会放在这个目录.
webapps目录:我们开发好的web项目就是需要放到这个指定的目录下面,默认里面已经有一些tomcat自带
的项目样例了.
work目录:编译jsp页面时候需要用到的一个目录.

webapps
部署

http://IP:port/项目名字/项目在资源

http://127.0.0.1:8002/WebTest/hello.html

http://172.16.4.81:8002/WebTest/hello.html

servlet-api.jar在tomcat的lib目录中

servlet-api.jar和FristServletTest.java都在桌面
编译java文件所在的命令窗口的路径也在桌面

javac -cp servlet-api.jar -d . FristServletTest.java

package com.briup.test;

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

import java.io.IOException;
import java.io.PrintWriter;

public class FristServletTest extends HttpServlet{

public void doGet(HttpServletRequest req,HttpServletResponse resp)throws ServletException,
IOException{

PrintWriter out = resp.getWriter();

out.println("hello jd1307 world");
out.flush();

out.close();

}

编译完之后,把这个.class文件已经包目录,放到项目中的classes目录里面,然后再项目中的web.xml文件进行配置,
配置的目的是:想把一个路径映射成我们自己一个servlet,这个我们在浏览器里面就可以用个这个映射的路径来来访问
这个servlet了.

例如:
web.xml文件中加入:
<servlet>
<servlet-name>firstservlet</servlet-name>
<servlet-class>com.briup.test.FristServletTest</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>firstservlet</servlet-name>
<url-pattern>/first</url-pattern>
</servlet-mapping>

servlet>中的<servlet-name>子标签:
给你要描述的servlet起一个名字,这个是名字是随便起的,目的是为了在下面做映射的时候能够再找到这个servlet

<servlet>中的<servlet-class>子标签:
这个servlet的package.类名

<servlet-mapping>中的<servlet-name>子标签:
指明这个映射是给哪一个servlet的做的映射,通过之前随便起的servlet的名字找。

<servlet-mapping>中的<url-pattern>子标签:
这个就是我们要映射的路径,将来浏览器里面输入这个路径就相当于要访问我们这个servlet。
注意:这个路径一定是以/开头的:/a /a/b /a/b/hello

servlet
1.什么是servlet
servlet其实就是java里面一种java类,只不过这种java类有一些特殊的作用,所以我们就叫它servlet
2.servlet的作用
可以让浏览器直接通过一个路径去访问。(一般的java类是做不到这一点的)

3.怎么写一个类,能成为一个servlet
三种方式:
a.实现一个接口:javax.servlet.Servlet
b.继承一个抽象类:javax.servlet.GenericServlet
c.继承一个抽象类javax.servlet.http.HttpServlet
这种是之后一直要用的方法.

注意:Servlet接口中,有五个抽象方法,其实最重要的一个方法是:service(ServletRequestreq,ServletResponse res)
抽象类GenericServlet实现了接口Servlet,但是留了一个抽象方法没有实现,就是上面所提到
的service方法,除此之外,GenericServlet里面还增加了
一些新的方法.
抽象类HttpServlet,继承了GenericServlet,但是HttpServlet中没有任何抽象方法,除了从父类继承过来的方法之外
,里面还有很多新的方法:doXxx方法,另外需要注意的是,HttpServlet里面有俩个service方法,但是俩个方法
的参数类型不同.

i.Servlet接口中的service方法.
因为无论我们使用哪一种方式去写出来的一个servlet类的中,一定会有一个方法叫做service,
这个方法是Servlet接口中的定义的,tomcat服务器接收到客户端请求后,帮我们调用servlet中的方法的时候,
它只会调用这一个service方法.
注意这个service方法中参数的类型:
service(ServletRequestreq,ServletResponse res)

ii.GenericServlet中的俩个init方法
带参数的init(ServletConfig config)方法是从Servlet接口中实现的,还有一个是这个类直接定义的,
无参的init()方法.
tomcat服务器创建servlet对象的时候,会帮我们去调用init(ServletConfig config)进行servlet类中
的初始化工作,所以如果我们想在servlet类中初始化自己的一些相关数据的话,需要去重写这个init方法。
有参数的init方法中调用了无参的init方法,所以将来我们只需要重写这个无参的init方法就可以了。
这样我们就不需要再专门对这个init(ServletConfig config)方法中的参数进行处理了。

iii.HttpServlet中的俩个service方法

这个是从Servlet接口中实现的方法.
service(ServletRequest req, ServletResponse res){
//强转参数类型
HttpServletRequest request = (HttpServletRequest)req;
HttpServletResponse response = (HttpServletResponse)res;

//调用新定义的service方法
service(request,response);

}

HttpServlet中新定义的方法
service(HttpServletRequest req, HttpServletResponse resp){
//拿到当前请求的类型 get/post
String method = req.getMethod();

//判断请求的方法然后去调用doXxx方法
if(method.equals("GET")){
doGet(req,resp);
}
if(method.equals("POST")){
doPost(req,resp);
}
...
..
}

http://ip:port/项目名字/资源路径

http://127.0.0.1:8002/jd1307_servlet/servlet1

4.servlet的生命周期
servlet的对象是单例:在web项目整个运行期间,每一个servlet类只会有一个对象存在.默认情况下,
这一个对象是在servlet第一次被访问的时候才会创建的,而且之后不管再访问多少次这个servlet,
也不会再去创建它的的对象的.(我们可以设置某一个servlet的对象在服务器启动的时候就被创建出来)

这些操作(方法的调用)都是由服务器来做的:
1.默认情况下,第一次被访问的时候创建servlet对象(调用无参构造器)
2.调用init(ServletConfig config)方法
在servlet对象实例化之后,tomcat服务器会立马调用这个方法给servlet的实例进行初始化工作。
3.客户端访问的时候,会调用service(ServletRequest req,ServletResponse res)方法
4.在销毁servlet对象的时候会调用destroy()方法.

通过web.xml文件中设置,可以让servlet的对象是在服务器启动的时候被创建出来.
web.xml:
<servlet>
<servlet-name>LifeServletTest</servlet-name>
<servlet-class>com.briup.servlet.LifeServletTest</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

加入<load-on-startup>标签,表示这个servlet需要在启动服务器的时候就被创建对象.其中,标签可以
要放一个数字,这个数字的大小就决定了多个servlet对象被创建的顺序,数字越小越先创建.
(如果我们配置了多个servlet在启动服务器的时候被创建对象的话)

5.servlet的线程安全问题
问题产生的原因:
1.servlet是单例,一个servlet类只有一个对象在项目运行期间。
2.web项目项目本身就有多线程的特点,虽然我们在代码中没有写和线程相关的东西,但是这个多线程的特点
是由服务器给我们提供出来的,一个客户端发送了一个请求,服务器接收到请求后就会建一个线程去处理这个
请求。
所以就有可能出现这样的情况:俩个线程同时去访问同一个servlet对象.

如何解决/防止
1.加锁synchronized
2.尽量少的定义成员变量
因为只有成员变量才会产生线程安全的问题(在多个线程访问同一个对象的时候),
方法中的局部变量是没有这样的问题的.
3.其他(实现一些安全性的接口)
也可以实现接口：SingleThreadModel 但其保证池中只有一个servlet，效率极低，已经被
废弃了。

6.客户端向服务器发请求并且传参
客户端向服务器发送请求可以是get方式，也可以是post方式，所以我们向服务器传参数也分为get方式和post方式传参数
1.哪些方式的请求属于get/post方式
get方式：
a.浏览器中输入地址然后回车
b.超链接
c.在页面中引入的css样式文件也算是get方式。
d.页面中引入的js的文件
e.<img src="图片路径"/>也是get请求
f.form表单中的method=“get”也是get请求
g.在我们的ajax中可以设置异步提交请求的方式为get
h.其他

post方式：
a.form表单中的method=“post”也是post请求

g.在我们的ajax中可以设置异步提交请求的方式为post
f.其他

2.get和post的特点及其区别
它们各自的特点及其区别主要是体现在所传递的参数上面。
a.get方式提交的时候传参
参数是直接放在请求的url后面的
例如：
要请求的url为：
http://ip:prot/WebTest/firstServlet
传参：
http://ip:prot/WebTest/firstServlet？name=tom
http://ip:prot/WebTest/firstServlet？name=tom&password=123 参数没有引号，直接写。

这种方式传参的特点：
1.从浏览器的地址栏中，可以直接看到所传的参数，（不安全）
2.参数直接放在url后面
3.参数的长度有限制，不能把一个很差不过的数据通过get方式传参(限制和浏览器是有关的)。

b.post方式提交的时候传参
参数是放在请求的体部的
这种方式传参的特点：
1.参书放在请求的体部而不是url后面
2.浏览器的地址栏中看不到所传的参数
3，因为参数不用出现在地址栏中。所以参数的长度是没有限制的

7.服务器端如何接受客户端传递过来的参数：
客户端都是以这样的形式传参数的：
参数名字=参数值
所有在servlet中我们需要用参数的名字来拿参数值、
String value = request.getParameter("key");
其中key就是参数的名字，value就是参数值。不管传的值本事是什么类型，servlet中参数接到一户只能是
字符串或者字符串类型数组。
如果客户端用的是多选框，这个时候传过来的参数就要用一个字符串类型数组来接受
String[] likes = req.getParameterValues("like");
在表单中，参数值就是用户所填写的内容或者所选的选项的value值，参数名字就是每一个input或者其它输入元素
中name属性的值。
例如：<input type="text" name="name"/><br/>参数的名字就是name属性的值：name
参书的值就是将来用户所填写的内容
在servlet中，不管是get方式，还是post方式提交的时候，来到servlet里面以后，都是用相同的方式来取得数据；
req.getParameter("id");
req.getParameter("name");
req.getParameter("password");

8.中文乱码的问题
1.get方式提交数据，servlet取到后乱码
需要修改tomact中的配置文件，然后重新启动tomact服务器
servlet.xml：在这个文件中找到修改端口号的那个标签，然后加入一个新的属性：URIEnoding="UTF-8",或者
是写出GBK，GB2312
<Connector connectionTimeout="20000" port="8002" protocol="HTTP/1.1" redirectPort="8443"
URIEncoding="GBK"
/>
2.post方式提交数据，servlet取到后乱码
在代码中，我们去接受数据之前，也就是调用getParameter方法之前，先要转换一下接受数据的编码：
req.setCharacterEncoding("GBK");
注意：其实不管是get方式或者是post方式提交数据，我们最后是在Eclipse/中打印出来，所以我们
最后还是要看看工具中是用什么编码显示的我们的数据的，点击一下文件或者项目名字后右键，
properties选项中可以看到这个编码。

3.servlet向浏览器返回数据的时候，有中文，浏览器显示乱码
在代码中，获得输出流之前面我们要先设置输出流是用什么编码把数据写回去的：
resp.setCharacterEncoding("GBK");

同时我们还可以通知浏览器我们传输的数据是用什么样的编码：
resp.setContentType("text/html;charset=GBK");

注意:在我们使用的浏览器中,也是可以调整编码的设置的,就是我们
可以自己选择一种编码来显示当前页面的内容,同时浏览器也会有自己一个默认的显示
编码.当浏览器不知道服务器传过来的的数据是用什么编码的时候,浏览器会用默认的编码来显示.

××服务器处理post和get请求是不一样的：因为传递参数的方式是不一样的。

servlet中的跳转.
a.服务器内部跳转
1.跳转到一个页面
2.跳转到另外一个servlet
page="页面/servlet"
//获得一个跳转对象(服务器内部跳转)
RequestDispatcher rd = req.getRequestDispatcher(page);
//跳转
rd.forward(req,resp);

特点:
1.不管servlet服务器内部跳转多少次,浏览器地址栏中显示的地址都是第一次访问到的servlet的地址
2.服务器内部跳转其实就是把request和response对象进行转发,转发到另外一个服务器内部的一个资源中,
如果转发的对象是一个页面,那么就把这个页面返回给浏览器,如果转发的对象是另外一个servlet,那么会调用到
这个servlet里面的service方法,然后把之前那个request和response当做参数传送传进来.

3.在服务器内部跳转的过程中，每一个环节中所用到的req,res对象都是同一个res和req对象。

b.客户端重定向
1.跳转到一个页面
2.跳转到另外一个servlet

String page = "页面/servlet";
resp.sendRedirect(page);

特点:
1.跳转之后,浏览器中显示的是跳转到的那个资源(页面/servlet)的地址,而不是第一次访问的servlet地址.

2.客户端重定向，其实就是让客户端浏览器重新再发一次新的的请求到要跳转的资源。
所以在客户端重定向中我们使用的对象是response,因为response这个对象的作用就是向客户端传递数据
传递消息用的。

3.在客户端重定向的过程中，每一个环节用到的request对象，都是浏览器发送的新的request对象。
//4.在客户端重定向的过程中,每个环节中所用到的request,response对象都是浏览器新发出的。

10.WEB项目中的路径问题：
路径WebRoot/path/ 下面
俩个页面:
pathA.html
A页面中有超链接,链接到B页面
<a href="pathB.html">pathB.html</a>

pathB.html

一个servlet的映射路径:
/PathServletTest
这个servlet里面服务器内部直接跳转到A页面

注意: 相对路径,指的是相对于当前路径,当前路径指的是当前地址栏里面的路径.

正常情况:
直接访问A页面:
...jd1307_servlet/path/pathA.html
点击超链接:href="pathB.html"
...jd1307_servlet/path/pathB.html

404的情况:
先访问servlet,再跳转到A页面:
...jd1307_servlet/PathServletTest
这时候页面显示的是A页面,因为servlet跳转了.
点击超链接:href="pathB.html"
...jd1307_servlet/pathB.html

因为要访问到pathB.html需要这样的路径:...jd1307_servlet/path/pathB.html

所以上面的这种情况就报错了 404

11.路径最左边的/
注意：如果路径最左没有/，那么路径就是要按照当前路径算，如果有/，那么这个路径要按照这个/所代表的含义来算
例如：一个servlet的映射路径
/servlet/test/myfristservlet
这里的第一个/就是我们要讨论的，路径中其他的/都是表示路径的分割。
这个/一般会有两种情况：
http://ip:port/
1，代表地址栏中端口号的那个/
http://ip:port/项目名称/
2，代表地址栏中项目名字后的那个/
注意在：这里指的都是路径最左面的/
a，html页面中的/代表地址栏中端口号后面的那个/
b，web.xml文件中的/代表地址栏中项目名字后面的那个/
c，服务器内部跳转中的/代表地址栏中项目名字后面的那个/
d，客户端重定向中的/代表地址栏中端口号后面的那个/
××可以总结为：资源给浏览器用的话，就是代表地址栏中端口号的那个/
资源给服务器用的话，就是代表代表地址栏中项目名字后的那个/
12. HttpServletRequest HttpSession ServletContext
这三个对象可以在服务器内部帮我们保存数据以及传递数据。

类型

HttpServletRequest
HttpSession
ServletContext

HttpServletRequest:保存数据
key 必须是String ，value是Object类型
request.setAttribute("key", value);
取数据:
通过key拿到value值,需要的话可以强转
Object o = request.getAttribute("key");

作用范围：HttpServletRequest 的存/取数据只能在一次请求之内起作用，比如服务器内部跳转的时候（因为
内部跳转客户端只发一次请求）

注意：客户端重定向是不行的，因为客户端重定向会发出多个请求。

HttpSession：

保存数据和取数据：
和上面的request一模一样的操作，只是对象名称变化了，上面的是HttpServletRequest这个叫HttpSession，
作用范围：在一个会话之中起作用，一个会话可以包括很多个request 请求，所以放在session可以被多个请求
所共享。

ServletContext：

保存数据和取数据：
和上面的HttpRequest一模一样的操作，只是对象名称变化了，上面的是HttpServletRequest这个叫HttpSession，

获取ServletContext：
//req.getSession().getServletContext();
ServletContext servletContext = this.getServletContext();
//this.getServletConfig().getServletContext();

作用范围：整个项目在运行期间，只有一个ServletContext对象，所以这个对象是所有人共享的，大家都可以
向这个对象里面存值，也可以再拿出来，因为这个对象一个项目中只有一个。

作用范围：HttpRequest<HttpSession<ServletContext

page<request<session<application 这page是之后我们在jsp中要学习的另一个范围,页面范围,
只在一个页面中起作用。)

***页面提交过来的数据用getParameter（）来获取，在服务器内部时用getAttribute（）来获取……

13.会话追踪技术， session
http协议是无状态的访问，就是说当前这次访问是不会知道之前访问的时候的那个状态是什么样子的，（http协议
的访问是不会帮我们保持访问的记录/痕迹的）有些时候我们是不需要知道之前访问的状态的，比如我们访问一些静
态页面（校园网站的时候），第一次访问点击了页面中的校风采，第二次点击了学生作品，这两次访问完全可以没有
任何状态，也不需要各自访问的状态。但是有些访问，我们是一定要知道之前几次访问的状态的。
比如：在购物网站的
时候，第一次访问点击购买了一个手机，第二次访问，点击购买了一个电脑，第三次访问点击结算，这时我
们就必须知道前两次访问的时候购买了什么，要不然就没有办法结算。
所以我们就有了会话追踪技术来解决这个访问无状态的问题。

session和cookie
session是保持在服务器端的一个对象，客户端是没有session的，
cookie是在客户端和服务器端都会有cookie的。但是存在的形式不一样。在客户端是以文件的形式存在的（浏览器管
理的文件）
在服务器端是以一个java对象存在的。

cookie的作用：和session一样，是用来保存用户访问的数据的。但是session是把数据保存在服务器端的内存里面
cookie是把数据保存在客户端的文件里面。

客户端访问服务器的时候，服务器会给这个客户端创建一个会话，也就是一个session对象。服务器内存里面可以
有好多个session对象，对应多个不同客户端，每一个session对象，都有唯一的id值：叫做：JSESSIONID

服务器端给客户端产生一个session对象后，会通过这次访问的response对象把这个session的JSESSIONID的值
放回给浏览器，浏览器接受到后会把这个值以一个cookie文件的形式保存起来

之后，这个浏览器再次请求到服务器的时候，就会把之前保存在cookie文件中的JSESSIONID的值传给服务器，
服务器通过这个JSESSIONID的值，就能够知道服务器内部中是哪一个session对象和当前这个客户端对应

这样以来，最后就能达到一个效果，我们客户端的每一次访问，，在服务器端都能够拿到相同的一个session对象，
从而实现不同请求之间通过相同的session对象进行数据的共享。

如何从服务器中向客户端写cookie
Cookie c1= new Cookie("name", "tom");
Cookie c2= new Cookie("msg", "hello");
c1.setMaxAge(60*60*24*365);
c2.setMaxAge(60*60*24*365);

resp.addCookie(c1);
resp.addCookie(c2);

最后response对象会把cookie带回到浏览器，并又浏览器把cookie对象中的内容保存到对应的一个cookie的文件中

注意：如果没有设置cookie生效的时间
那么这个cookie就是会话cookie，当会话结束（浏览器关闭）的时候cookie就会失效了

如何在servlet中拿到从浏览器中发送过来的cookie文件中的数据：
HttpSession session = req.getSession();
PrintWriter out = resp.getWriter();
//从request中拿到一个cookie数组
//如果没有任何cookie数据则返回null
Cookie[] cookies = req.getCookies();
if (cookies!=null) {
//遍历数据，拿出key和value
for (Cookie cookie : cookies) {
String key = cookie.getName();
String value=cookie.getValue();
int i = cookie.getVersion();

out.println("key="+key+" "+"value="+value+"i="+i);

}

out.flush();
out.close();
}
注意：session对象的创建时间。只有当用到session对象的时候，服务器才创建，要是用不到的话，就不会
创建session对象。

14.URL重写：

也属于会话追踪的技术之一

URL重写解决了这样一个问题：

当浏览器把cookie禁用之后，浏览器在发请求的时候，就不会把cookie带到服务器端（其中最重要的也包括

JSESSIONID）因为禁用cookie之后，浏览器会拒绝一切站点向浏览器写入cookie的（注意再禁用之前是否已经有一些
已经存在的cookie了）。这样的话，在多个请求就不能在服务器端拿到同一个session对象了（因为
发送请求的时候没有把JSESSIONID的值传给服务器。）。
把JSESSIONID 从客户端传给服务器有两种方式，：
1，JSESSIONID保存在cookie文件中，通过请求的时候把cookie文件带到服务器。
2，通过传参的方式把JSESSIONID的值通过要访问的URL传给服务器，（URL重写）

如何实现URL重写：
HttpSession session = req.getSession();
session.setAttribute("msg", "heello");
String url=resp.encodeURL("GetDataFromSession");
PrintWriter writer = resp.getWriter();

writer.println("<html>");
writer.println("<body>");
writer.println("<h1>");
writer.println("<a href='"+url+"'>GetDataFromSession</a>");
writer.println("</h1>");
writer.println("</body>");
writer.println("</html>");
writer.flush();
writer.close();

String url=resp.encodeURL("GetDataFromSession");
这个方法参数就是我们要访问的URL，这个方法参数就是我们要访问的URL，这个方法会把重写后的URL以
字符串的形式返回。主要是把JSESSIONID带过去。

15.Filter（过滤器）：
作用：在一个请求去访问某个资源的时候，filter可以在这个请求访问到这个资源之前，把请求拦截住，
然后做出一系列处理或者是判断，（比如编码的转换，信息的过滤，权限的判断，是否登录的验证等等）。
最后Filter再决定是否要让这个请求去访问那个资源。

如何写一个Filter：
写一个java类，然后实现javax.Servlet.Filter接口

接口中有三个方法，分别是：init(FilterConfig arg0)；doFilter(ServletRequest req, ServletResponse res,
FilterChain chain)；destroy()；

init：这个过滤器类被服务器创建对象的时候会调用到这个方法，服务器启动的时候就会调用。
destroy：过滤器对象被销毁的时候会调用这个方法
doFilter：当过滤器拦截到请求的时候，会调用这个doFilter。

@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {

req.setCharacterEncoding("GBK");
res.setCharacterEncoding("GBK");
res.setContentType("text/html;charset=GBK");

//当前过滤器放行这次访问
chain.doFilter(req, res);

}

这个方法有三个参数，第三个参数表示的是一个过滤器链对象，因为同一个请求一次要通过两个
三个或更多的过滤器，在web中把这样多个过滤器看做一个过滤器链条对象，就是用这个FilterChain类型
对象来表示，

chain.doFilter(req,res);表示把当前的req和res传给这用调用这个个过滤器链条中的下一个过滤器进行过滤，
如果说链条中已经没有下一个过滤器，那个就把这次访问放行，让她去访问它真正要访问的资源。
（过滤器过滤的顺序，是按照在web.xml文件中的配置的顺序过滤的。）
注意：如果这次访问没有符合过滤器中的条件，那么我们就不用调用chain.doFilter(req, res);不进行放行
而是可以直接进行跳转（服务器跳转，或者客户端重定向），跳转到一个页面，
页面中提示用户一些，为什么这次不让他去访问，比如：还没有登录呀，权限不够呀等等原因。
最后还需要在web.xml文件中进行配置：
例如:
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>com.briup.filter.EncodingFilter</filter-class>

</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>


</filter-mapping>

这个配置和servlet的配置很相似。
<url-pattern>/*</url-pattern>
表示当前这个过滤器，要拦截的路径是/*表示项目中所用的资源。
<url-pattern>/servlet/*</url-pattern>
表示当前这个过滤器，要拦截的路径是/servlet/*，也就是项目下面的servlet下面的所有资源
<url-pattern>/firstServlet</url-pattern>
这个表示拦截的路径是/firstServlet。也就是说这个时候这个过滤器只会拦截者一个路径。

如果要拦截的路径有两个，我们可以配置两个<filter-mapping>标签分别都去和同一个
<filter>标签对应。

注意：1.这里的/代表地址栏中项目名字后面的/
2.某一个资源是不是会被拦截，看得是地址栏中会不会出现我们在web.xml文件中
所配置的要拦截的路径。

16监听器（Listener）
.
作用：监听web中的一些事件的发生，如果某些事件一旦发生了，那么这个监听器就会调用某些方法进行处理。
比如：在web中，可以监听request对象的创建和销毁。

如何去写一个监听器：
1.写一个类，实现一个特定的接口，
2.在xml文件进行配置。
web.xml:
比如:监听request对象的创建和销毁需要实现implements ServletRequestListener
<listener>
<listener-class>com.briup.listener.RequestListener</listener-class>
</listener>

比如：监听session对象的创建和销毁 implements HttpSessionListener

<listener>
<listener-class>com.briup.listener.SessionListener</listener-class>
</listener>
监听application对象的创建和销毁要实现接口implements ServletContextListener
<listener>
<listener-class>com.briup.listener.ApplicationListener</listener-class>
</listener>

配置session的过期时间：
//分钟；
<session-config>
<session-timeout>30</session-timeout>
</session-config>

JSP
属于动态网页技术的一种.
(servlet、jsp、PHP、asp等等)
1.jsp是什么
java server page(JSP)
后缀名以.jsp结尾的页面文件.
.html文件是静态页面.
.jsp是动态页面.

2.jsp页面中可以写哪些内容
1.html标签
2.css
3.javascript
4.java代码
5.EL表达式
6.jstl标签

3.jsp是如何工作的
1.jsp页面其实就是一个servlet。
2.jsp页面的运行需要服务器的支持。
3.服务器中的jsp引擎可以帮我们去运行jsp页面。（注意并不是所用的服务器都有这样的引擎
引擎其实就是别人写好的jar包或者是代码。
）
4，jsp页面在运行之前，要经过几个步骤：
首先jsp页面要被翻译成.java文件。
然后在编译成.class文件。然后再运行.calss文件。
5.jsp翻译成的.java文件中,其实就是写了一个servlet,在这个类中的方法里面,用io流,
把jsp页面中的内容一行一行的输出给了浏览器。因为这是在java类中的方法里面做的事情,
所有很多数据我们都可以用变量来表示,同时也可以调用其他类中的方法.
(在这里,jsp动态页面的效果也就体现出来.)
6.运行jsp页面过程中,jsp引擎帮我们去翻译或者
编译成的.java文件和.class文件都保存在了tomcat中的work目录里面。
7.通过上述jsp的特点可知：写好的一个jsp项目之后，第一次部署运行的时候，整个项目的运行速度会慢一
些，因为第一次访问运行jsp的时候，需要先翻译成.java文件，编译成.class文件，最后再运行，这个过程
会耗费一些时间，但是第二次访问运行的时候会比较快一些了。
8.访问项目中的一个jsp页面的时候，服务器首先会检查你所访问的jsp页面是否存在，如果不存在，服务器
直接给你返回404，如果存在，服务器会进一步检查有没有和这个jsp页面对象的.class文件，如果有的话
就直接运行这个.class文件。如果没有的话，就先把这个jsp页面翻译成.java，然后在编译成.class。最后
再运行这个.class文件。
9.jsp页面其实就是在html页面中直接写上java代码，但是在一个jsp页面中，你可以没有任何html中的代码
也可以只有java代码，没有html中的代码。也可以只有html中的代码，没有java 中的代码。
10.servlet能做的事情，jsp全能做。但是jsp能做的事情，servlet不一定能做，比如：标签。

4.如何写一个jsp页面以及在页面中如何写java代码，
jsp页面中的主要写的东西分为三部分：
1.jsp的脚本元素
表达式(expression)
形式:<%= %>
例如:<%="hello" %>
<%=1+1 %>
<%=s.getName() %>

将来翻译到java文件中的位置:
_jspService方法中的
out.print(..)里面的参数.
例如上面那几个例子会翻译成
out.print("hello");
out.print(1+1);
out.print(s.getName());

所以System.out.prntln()这个方法的参数可以写什么,那么我们这个jsp页面中表达式
里面就可以写什么.
注意:在jsp中的表达式里面不需要加;号。

脚本(scriptlet)
形式:<% ... %>
<%
....
%>
例如:
<%
Student s = new Student();

String name = "tom";

String username = s.getName();

List<String> list = new ArrayList<String>();
list.add("hello")

%>
将来翻译到java文件中的位置:
脚本中的代码将来会被直接翻译到_jspService这个方法中.

在一个方法中我们可以写什么样的代码,那么在脚本中就可以写什么样的代码.

注意:在脚本中所写的代码,代码的最后是要加上;号的.因为我们在一个方法
里面所写的没一句代码后面都是要加;号。
在脚本声明的变量,我们是可以在表达式里面使用的,但是要注意要先声明变
量再使用变量.只要查看脚本和表达式分别翻译到java文件中的位置,就可以很清楚
的认识到这一点.

声明(declaration)
形式:<%!
.....
%>
例如:
<%!
private String address;

public String go(){
System.out.println("hello world jd1307");
return "this is go()";
}

%>

将来翻译到java文件中的位置:
直接将声明中的代码翻译到java文件里面所定义的类中。
所以我们直接可以在一个类中写什么,就可以在声明中写什么.
(一般在声明中会去定义一些类中的成员变量或者方法)
注意：这里面的代码，定义变量的时候要加；号，定义方法的时候不加；号，
这是和我们写一个java类语法是一样的。

2.jsp的指令元素
jsp的指令是给jsp引擎看的，让jsp引擎在翻译jsp页面成java文件的时候
知道需要注意哪些地方的设置，比如：页面中的编码，页面中脚本里面所用的编程语言，
翻译的java文件中需要引入哪些其他包下的java类等等。
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%@page isErrorPage="true" %>
<%@include file="" %>
<%@taglib uri="" prefix="" %>

page指令：
//表示当前页面中的编程语言是java，目前这个属性值只能写java
language="java"
//在当前页面中要引入哪些包下的类，
import="java.util.*"
也可以同时导两个包，中间用“，”分隔
//设置jsp页面保存时候所用的编码
pageEncoding="gbk"
//设置服务器将来使用io流把jsp页面内容一行行的输出给浏览器的时候，所使用什么编码
向浏览器输出。
contentType="text/html;charset=utf-8"

//设置jsp页面被翻译成java文件的时候，java文件的类是继承哪个父类，这个属性不用设置，jsp
会有一个默认的父类去继承的，
extends=""
//设置当前页面是不是支持session的使用，默认的true，但是你也可以设置成false，但一般
我们是不会改变的。
session=“true”
//设置当前这个jsp页面是否是线程安全的。
isThreadSafe=“true”

//如果a.jsp页面中设置了errorPage=“b.jsp”，那么a.jsp页面在运行的时候一旦出错，就会
跳到“b.jsp”；
errorPage=“”

//如果一个页面中设置了isErrorPage=“true”，那么就表示这个页面上用来专门显示错误信息
的页面，然后在这个页面中就能够使用到隐藏对象exception来显示出错误的信息了。
isErrorPage=“true

//在当前页面使用include指令可以把另外一个页面的内容，引入到当前页面。
一个页面包含/引入另外一个页面有两种方式：静态包含，动态包含，
这个include指令就属于静态包含。
静态包含特点：例如a.jsp页面中静态包含了b.jsp页面，那么在翻译期间，jsp引擎在翻译a.jsp
成为a_jsp.java文件的时候，发现jsp页面中有include指令，这时候jsp引擎就会把被包含的
页面b.jsp中内容原封不动的拿到a_jsp.java中，然后用io输出出去。
include指令：
<%@include file="" %>

//在当前jsp页面中引入一些特殊的标签库，比如：jstl标签，或者是struts2的标签库等等。
taglib指令：

3.jsp的动作元素。
<jsp:useBean id="s" class="com.briup.bean.Student" scope="page"></jsp:useBean>

<jsp:setProperty property="name" value="tom" name="s"/>
<jsp:getProperty property="name" name="s"/>
相当于代码：
<%
PageContext pageContext = null;
_jspx_page_context = pageContext;
com.briup.bean.Student s = null;
synchronized (_jspx_page_context) {
s = (com.briup.bean.Student) _jspx_page_context.getAttribute("s", PageContext.PAGE_SCOPE);
if (s == null){
s = new com.briup.bean.Student();
_jspx_page_context.setAttribute("s", s, PageContext.PAGE_SCOPE);
}
%>

<jsp:setProperty property="name" value="tom" name="s"/>
相当于代码：
<%

org.apache.jasper.runtime.JspRuntimeLibrary.introspecthelper(_jspx_page_context.findAttribute("s"),
"name", "tom", null, null, false);

%>
<jsp:getProperty property="name" name="s"/>
相当于代码：
<%

out.write(org.apache.jasper.runtime.JspRuntimeLibrary.toString
((((com.briup.bean.Student)_jspx_page_context.findAttribute("s")).getName())));

%>

//页面跳转：跳转的同时还可以穿参数，

<jsp:forward page="target.jsp">
<jsp:param value="wukaifeng" name="name"/>
</jsp:forward>

<jsp:include page="foot2.jsp">
<jsp:param value="wukaifeng" name="name"/>
</jsp:include>

动态包含特点：在把jsp文件翻译成java文件的期间，动态包含并不会去把被包含的页面原封不动的拿过来
，而是会把动态包含的这个标签翻译成一个方法的调用，将来运行页面调用到这个方法的时候才会去拿
被包含页面的内容，同时还可以给动态包含的页面传参数，静态包含是不能传参数的。

//使用jsp的动作元素向浏览器输出一个标签
<font color="red">hello</font>

<jsp:element name="font">
<jsp:attribute name="color">blue</jsp:attribute>
<jsp:body>hello</jsp:body>

用标签的话，会更灵活一些。

×××客户端重定向后，后面的内容会输出，
××××服务器内部转发，后面的内容不会输出。

5.在jsp页面中代码中直接使用的对象：
一共有9个内置对象可以直接使用，

类型名字
PageContext pageContext
HttpServletRequest request

HttpSession session
ServletContext application
Object page
HttpServletResponse response
JspWriter out
ServletConfig config
Throwable exception

注意：为什么这个九个对象可以直接使用，因为他们都是在_jspService这个方法中默认声明出来，
而我们在表达式和脚本直接使用这些对象，写java代码的时候可以直接使用这些对象。

四个范围对象，在一定范围内可以存取数据：
//页面范围（只能在同一个页面中起作用）
pageContext：
request
session
application

page
//虽然名字叫page，但是这个并不是页面范围对象，它是Object类型的对象，表示当前这个页面本身。

out
//用于向浏览器输出内容的输出流。
config
//用于获得和servlet相关的信息，
exception
//这个对象其实我们并不能直接使用，需要相关设置后，才能使用，这个可以算是一个隐藏对象。
这个对象表示将来这个jsp页面运行出错的时候所抛出的异常对象。

6.jsp页面中的注释

第一种：

特点：1.用户在浏览器中查看源代码【能】看到这个注释，
2.在服务器端，这个jsp页面被编译成的java中，也【能】看到这个注释。
第二种：
<%--
jsp中独有的注释方式（隐藏注释）
--%>

特点：1.用户在浏览器中查看源代码【不能】看到这个注释，
2.在服务器端，这个jsp页面被编译成的java中，也【不能】看到这个注释。
3.只能在jsp的源码中看到这个注释。

第三种：
java中的注释方式，但是这种注释方式只能写在jsp脚本或者声明里面。
<%
//在脚本，和声明里面可以用这个注释。
/*
也可以用这个注释哦

*/

/**
还可以用这个注释！

*/
%>
特点：1.用户在浏览器中查看源代码【不能】看到这个注释，
2.在服务器端，这个jsp页面被编译成的java中，【能】看到这个注释。
3.但只能用在脚本和声明里面。

7.jsp页面中的路径
一般情况下，jsp中路径问题是和我们在servlet中讨论的html里面的路径问题是一样的，，
但是在jsp中有一种情况要特殊对待：：
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+
request.getServerPort()+path+"/";

相当于：http://127.0.0.1:8802/jd1307_jsp/
只要有这个东西<base href="<%=basePath%>"> 将来都是相对于这个路径。

如果在jsp页面中有上面提到的两个东西，那么在这个jsp页面中，我们再去写上一个相对路径（最左边没有加/
的那种路径），他就不是相对于地址栏中的当前路径来，而是要相对于这个basePath变量代表的路径了

<base href="<%=basePath%>">这个标签的作用：
在没有这个标签的情况下，页面中相对路径的跳转，都是参照地址栏中的当前路径来跳转，但是页面中加上这个
<base>标签后，页面中的相对路径的跳转都是要参照这个标签中所写的路径来跳转。
注意：这里说的相对路径的跳转，指的是最左边没有/的那种路径的跳转。
但这种不合适动作元素。//<jsp:forward page="login.jsp"></jsp:forward>
其只是用于，css的引入，表单的提交，javascript，超链接。

8.EL表达式：
形式${写上你要拿的值}(只有在jsp页面中才可以用el表达式，servlet中是不可以用的)

作用：从一个范围里面取值或者是从一个对象中取值或者是向页面中输出值，
1.接受客户端参数：
${param.name1 }
2.从指定范围中取值
${pageScope.name2 }
${requestScope.name3 }
${sessionScope.name4 }
${applicationScope.name5 }
3.可以不指定范围去取值
${name}
这时候会按照pageContext，request，session，application这样一个顺序依次的去找，有没有一个叫做name
的值存在，一旦找到就输出，最终没找到，就什么也不输出。+
4.取出一个对象中的属性值。
${requestScope.student.id}
${requestScope.student.name}
${requestScope.student.age}
或者：
${student.id}
${student.name}
${student.age}
或者
${student["id"]}
${student["name"]}
${student["id"]}
注意：比如${student.id}表示是要调用student对象中的getId方法，至于对象中有没有id属性
对这个操作没有任何影响。
如果student类中有一方法是getAderess，并返回一个Address类的一个对象，Address类中有一个方法
叫getCity，这个时候我们就可以这样写去拿city属性的值。
${student.address.city}
5.输出字符串
用el表达式可以输出字符串：
${"hello" }

6.输出表达式（运算结果，或者Boolean表达式）
<h1>
el表达式输出运算结果，和bollean表达式
</h1>
${1+7}//直接输出计算结果
${1*9*9*8*6+7 }
${1>3}//输出判断结果，ture/false
${empty "" }
${empty "fff" }//取否
${not empty "fff" }
${! empty "fff" }
${param.score>50} 
${param.score>50?"good":"bad"}

7.输出数组，集合中的元素

<h1>输出数组和集合中的元素</h1>
<%
String [] str={"hello","world"};
List <String> list = new ArrayList<String>();
list.add("zhangsan");
list.add("lisi");
Map<String,Integer> map = new HashMap<String,Integer>();

map.put("a",100);
map.put("b",200);
map.put("c",300);

request.setAttribute("str",str);
request.setAttribute("list",list);
request.setAttribute("map",map);

%>

${str[0]}<br/>
${list[1] }<br/>
${map["a"]}<br>

9.JSTL标签库
JSP Standard Tag Library(JSTL)
1.让web项目支持JSTL标签库
在myeclipse中,建一个web项目的时候,在对话框下面会有提示在当前项目是否需要加入JSTL标签库的支持.
(J2EE5.0是默认会加入对JSTL的支持的)
在eclipse中,建一个文本项目,默认都是不支持JSTL,所以需要我们自己把JSTL的jar包导入
到项目中(复制粘贴到项目中的lib目录):jstl.jar standard.jar

2.把JSTL标签库导入到某一个jsp页面中
使用jsp中的taglib指令:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

prefix="c"相当于给这个标签库起一个别名,将来在页面中就是用以c开头的标签来使用标签库中的标签。
这个别名也可以叫其他的名字。

<c:forEach items="${students}" var="s">
遍历List集合：
students是放进request对象中的一个List集合，集合中存放的是Students类型的对象。
items=“”属性值是要遍历的集合
var=“”属性值是每次遍历到的对象用什么名字的变量去接收。（放的范围是pageContext范围）
<tr>
<td>${s.id }</td>
<td>${s.name }</td>
<td>${s.age }</td>
</tr>

</c:forEach>

遍历map集合：
map是一个Map类型的集合，放到了request对象中，entry是我们定义的一个变量。
用做接受每次遍历到的集合中的一组键值对，我们可以通过entry.key和entry.value
分别拿到这次变量的key值和value值。

<c:forEach items="${map}" var="entry">

<tr>
<td>${entry.value.id }</td>
<td>${entry.value.name }</td>
<td>${entry.value.age }</td>
</tr>

</c:forEach>
<c:out>标签：
<h1>使用out标签输出内容</h1>

<c:out value="hello"></c:out>
<c:out value="${5+5}"></c:out>
<c:out value="${students[1].id}"></c:out>
<c:out value="${map[5].name}"></c:out>

<c:set>标签：
<h1>set标签</h1>
<c:set var="name" value="zhangsan" scope="page"></c:set>
${pageScope.name }
可以向某一个范围内放一个值。

<h1>remove标签</h1>
<c:remove var="name" scope="page"/>
从某个范围对象中把某个值给移除掉。

<c:if>标签：相当于if(){};if(){};if(){};

<%
request.setAttribute("score",90);
%>
<c:if test="${score>85}">
<font color="red">考得不错哦！</font>
</c:if>

<c：choose>标签：相当于if(){}else if(){}else{}

<h1>choose标签</h1>

<c:choose >
<c:when test="${score>85}">优</c:when>
<c:when test="${score>80}">良</c:when>
<c:when test="${score>70}">中</c:when>
<c:when test="${score>60}">及格</c:when>
<c:otherwise>差</c:otherwise>

</c:choose>

--------------------------------------------

HTTP协议状态码的含义

　　号码含义
-----------------------------------------
"100":Continue
"101":witchingProtocols
"200":OK
"201":Created
"202":Accepted
"203":Non-AuthoritativeInformation
"204":NoContent
"205":ResetContent
"206":PartialContent
"300":MultipleChoices
"301":MovedPermanently
"302":Found
"303":SeeOther
"304":NotModified
"305":UseProxy
"307":TemporaryRedirect
"400":BadRequest
"401":Unauthorized
"402":PaymentRequired
"403":Forbidden
"404":NotFound
"405":MethodNotAllowed
"406":NotAcceptable
"407":ProxyAuthenticationRequired
"408":RequestTime-out
"409":Conflict
"410":Gone
"411":LengthRequired
"412":PreconditionFailed
"413":RequestEntityTooLarge
"414":Request-URITooLarge
"415":UnsupportedMediaType
"416":Requestedrangenotsatisfiable
"417":ExpectationFailed
"500":InternalServerError
"501":NotImplemented
"502":BadGateway
"503":ServiceUnavailable
"504":GatewayTime-out
"505":HTTPVersionnotsupported

HTTP状态码

1**：请求收到，继续处理
2**：操作成功收到，分析、接受
3**：完成此请求必须进一步处理
4**：请求包含一个错误语法或不能完成
5**：服务器执行一个完全有效请求失败

100——客户必须继续发出请求
101——客户要求服务器根据请求转换HTTP协议版本

200——交易成功
201——提示知道新文件的URL
202——接受和处理、但处理未完成
203——返回信息不确定或不完整
204——请求收到，但返回信息为空
205——服务器完成了请求，用户代理必须复位当前已经浏览过的文件
206——服务器已经完成了部分用户的GET请求

300——请求的资源可在多处得到
301——删除请求数据
302——在其他地址发现了请求数据
303——建议客户访问其他URL或访问方式
304——客户端已经执行了GET，但文件未变化
305——请求的资源必须从服务器指定的地址得到
306——前一版本HTTP中使用的代码，现行版本中不再使用
307——申明请求的资源临时性删除

400——错误请求，如语法错误
401——请求授权失败
402——保留有效ChargeTo头响应
403——请求不允许
404——没有发现文件、查询或URl
405——用户在Request-Line字段定义的方法不允许
406——根据用户发送的Accept拖，请求资源不可访问
407——类似401，用户必须首先在代理服务器上得到授权
408——客户端没有在用户指定的饿时间内完成请求
409——对当前资源状态，请求不能完成
410——服务器上不再有此资源且无进一步的参考地址
411——服务器拒绝用户定义的Content-Length属性请求
412——一个或多个请求头字段在当前请求中错误
413——请求的资源大于服务器允许的大小
414——请求的资源URL长于服务器允许的长度
415——请求资源不支持请求项目格式
416——请求中包含Range请求头字段，在当前请求资源范围内没有range指示值，请求也不包含If-Range请求头字段
417——服务器不满足请求Expect头字段指定的期望值，如果是代理服务器，可能是下一级服务器不能满足请求

500——服务器产生内部错误
501——服务器不支持请求的函数
502——服务器暂时不可用，有时是为了防止发生系统过载
503——服务器过载或暂停维修
504——关口过载，服务器使用另一个关口或服务来响应用户，等待时间设定值较长
505——服务器不支持或拒绝支请求头中指定的HTTP版本

------------------------------------------

response.setContentType() ;

* = application/octet-stream
.001 = application/x-001
.301 = application/x-301
.323 = text/h323
.906 = application/x-906
.907 = drawing/907
.a11 = application/x-a11
.acp = audio/x-mei-aac
.ai = application/postscript
.aif = audio/aiff
.aifc = audio/aiff
.aiff = audio/aiff
.anv = application/x-anv
.asa = text/asa
.asf = video/x-ms-asf
.asp = text/asp
.asx = video/x-ms-asf
.au = audio/basic
.avi = video/avi
.awf = application/vnd.adobe.workflow
.biz = text/xml
.bmp = application/x-bmp
.bot = application/x-bot
.c4t = application/x-c4t
.c90 = application/x-c90
.cal = application/x-cals
.cat = application/vnd.ms-pki.seccat
.cdf = application/x-netcdf
.cdr = application/x-cdr
.cel = application/x-cel
.cer = application/x-x509-ca-cert
.cg4 = application/x-g4
.cgm = application/x-cgm
.cit = application/x-cit
.class = java/*
.cml = text/xml :客户端浏览器按XML格式进行解析文档
.cmp = application/x-cmp
.cmx = application/x-cmx
.cot = application/x-cot
.crl = application/pkix-crl
.crt = application/x-x509-ca-cert
.csi = application/x-csi
.css = text/css :客户端浏览器按CSS格式进行解析文档
.cut = application/x-cut
.dbf = application/x-dbf
.dbm = application/x-dbm
.dbx = application/x-dbx
.dcd = text/xml :客户端浏览器按XML格式进行解析文档
.dcx = application/x-dcx
.der = application/x-x509-ca-cert
.dgn = application/x-dgn
.dib = application/x-dib
.dll = application/x-msdownload
.doc = application/msword
.dot = application/msword
.drw = application/x-drw
.dtd = text/xml :客户端浏览器按XML格式进行解析文档
.dwf = Model/vnd.dwf
.dwf = application/x-dwf
.dwg = application/x-dwg
.dxb = application/x-dxb
.dxf = application/x-dxf
.edn = application/vnd.adobe.edn
.emf = application/x-emf
.eml = message/rfc822
.ent = text/xml :客户端浏览器按XML格式进行解析文档
.epi = application/x-epi
.eps = application/x-ps
.eps = application/postscript
.etd = application/x-ebx
.exe = application/x-msdownload
.fax = image/fax
.fdf = application/vnd.fdf
.fif = application/fractals
.fo = text/xml :客户端浏览器按XML格式进行解析文档
.frm = application/x-frm
.g4 = application/x-g4
.gbr = application/x-gbr
.gcd = application/x-gcd
.gif = image/gif
.gl2 = application/x-gl2
.gp4 = application/x-gp4
.hgl = application/x-hgl
.hmr = application/x-hmr
.hpg = application/x-hpgl
.hpl = application/x-hpl
.hqx = application/mac-binhex40
.hrf = application/x-hrf
.hta = application/hta
.htc = text/x-component
.htm = text/html :客户端浏览器按超文本格式进行解析文档
.html = text/html :客户端浏览器按超文本格式进行解析文档
.htt = text/webviewhtml
.htx = text/html :客户端浏览器按超文本格式进行解析文档
.icb = application/x-icb
.ico = image/x-icon
.ico = application/x-ico
.iff = application/x-iff
.ig4 = application/x-g4
.igs = application/x-igs
.iii = application/x-iphone
.img = application/x-img
.ins = application/x-internet-signup
.isp = application/x-internet-signup
.IVF = video/x-ivf
.java = java/*
.jfif = image/jpeg
.jpe = image/jpeg
.jpe = application/x-jpe
.jpeg = image/jpeg
.jpg = image/jpeg
.jpg = application/x-jpg
.js = application/x-javascript
.jsp = text/html :客户端浏览器按超文本格式进行解析文档
.la1 = audio/x-liquid-file
.lar = application/x-laplayer-reg
.latex = application/x-latex
.lavs = audio/x-liquid-secure
.lbm = application/x-lbm
.lmsff = audio/x-la-lms
.ls = application/x-javascript
.ltr = application/x-ltr
.m1v = video/x-mpeg
.m2v = video/x-mpeg
.m3u = audio/mpegurl
.m4e = video/mpeg4
.mac = application/x-mac
.man = application/x-troff-man
.math = text/xml
.mdb = application/msaccess
.mdb = application/x-mdb
.mfp = application/x-shockwave-flash
.mht = message/rfc822
.mhtml = message/rfc822
.mi = application/x-mi
.mid = audio/mid
.midi = audio/mid
.mil = application/x-mil
.mml = text/xml
.mnd = audio/x-musicnet-download
.mns = audio/x-musicnet-stream
.mocha = application/x-javascript
.movie = video/x-sgi-movie
.mp1 = audio/mp1
.mp2 = audio/mp2
.mp2v = video/mpeg
.mp3 = audio/mp3
.mp4 = video/mpeg4
.mpa = video/x-mpg
.mpd = application/vnd.ms-project
.mpe = video/x-mpeg
.mpeg = video/mpg
.mpg = video/mpg
.mpga = audio/rn-mpeg
.mpp = application/vnd.ms-project
.mps = video/x-mpeg
.mpt = application/vnd.ms-project
.mpv = video/mpg
.mpv2 = video/mpeg
.mpw = application/vnd.ms-project
.mpx = application/vnd.ms-project
.mtx = text/xml
.mxp = application/x-mmxp
.net = image/pnetvue
.nrf = application/x-nrf
.nws = message/rfc822
.odc = text/x-ms-odc
.out = application/x-out
.p10 = application/pkcs10
.p12 = application/x-pkcs12
.p7b = application/x-pkcs7-certificates
.p7c = application/pkcs7-mime
.p7m = application/pkcs7-mime
.p7r = application/x-pkcs7-certreqresp
.p7s = application/pkcs7-signature
.pc5 = application/x-pc5
.pci = application/x-pci
.pcl = application/x-pcl
.pcx = application/x-pcx
.pdf = application/pdf :客户端浏览器按PDF格式进行解析文档
.pdf = application/pdf
.pdx = application/vnd.adobe.pdx
.pfx = application/x-pkcs12
.pgl = application/x-pgl
.pic = application/x-pic
.pko = application/vnd.ms-pki.pko
.pl = application/x-perl
.plg = text/html
.pls = audio/scpls
.plt = application/x-plt
.png = image/png
.png = application/x-png
.pot = application/vnd.ms-powerpoint
.ppa = application/vnd.ms-powerpoint
.ppm = application/x-ppm
.pps = application/vnd.ms-powerpoint
.ppt = application/vnd.ms-powerpoint
.ppt = application/x-ppt
.pr = application/x-pr
.prf = application/pics-rules
.prn = application/x-prn
.prt = application/x-prt
.ps = application/x-ps
.ps = application/postscript
.ptn = application/x-ptn
.pwz = application/vnd.ms-powerpoint
.r3t = text/vnd.rn-realtext3d
.ra = audio/vnd.rn-realaudio
.ram = audio/x-pn-realaudio
.ras = application/x-ras
.rat = application/rat-file
.rdf = text/xml
.rec = application/vnd.rn-recording
.red = application/x-red
.rgb = application/x-rgb
.rjs = application/vnd.rn-realsystem-rjs
.rjt = application/vnd.rn-realsystem-rjt
.rlc = application/x-rlc
.rle = application/x-rle
.rm = application/vnd.rn-realmedia
.rmf = application/vnd.adobe.rmf
.rmi = audio/mid
.rmj = application/vnd.rn-realsystem-rmj
.rmm = audio/x-pn-realaudio
.rmp = application/vnd.rn-rn_music_package
.rms = application/vnd.rn-realmedia-secure
.rmvb = application/vnd.rn-realmedia-vbr
.rmx = application/vnd.rn-realsystem-rmx
.rnx = application/vnd.rn-realplayer
.rp = image/vnd.rn-realpix
.rpm = audio/x-pn-realaudio-plugin
.rsml = application/vnd.rn-rsml
.rt = text/vnd.rn-realtext
.rtf = application/msword
.rtf = application/x-rtf
.rv = video/vnd.rn-realvideo
.sam = application/x-sam
.sat = application/x-sat
.sdp = application/sdp
.sdw = application/x-sdw
.sit = application/x-stuffit
.slb = application/x-slb
.sld = application/x-sld
.slk = drawing/x-slk
.smi = application/smil
.smil = application/smil
.smk = application/x-smk
.snd = audio/basic
.sol = text/plain
.sor = text/plain
.spc = application/x-pkcs7-certificates
.spl = application/futuresplash
.spp = text/xml
.ssm = application/streamingmedia
.sst = application/vnd.ms-pki.certstore
.stl = application/vnd.ms-pki.stl
.stm = text/html
.sty = application/x-sty
.svg = text/xml
.swf = application/x-shockwave-flash :客户端浏览器按 Flash 格式进行解析文档
.tdf = application/x-tdf
.tg4 = application/x-tg4
.tga = application/x-tga
.tif = image/tiff
.tif = application/x-tif
.tiff = image/tiff
.tld = text/xml
.top = drawing/x-top
.torrent = application/x-bittorrent
.tsd = text/xml
.txt = text/plain :客户端浏览器按纯文本格式进行解析文档
.uin = application/x-icq
.uls = text/iuls
.vcf = text/x-vcard
.vda = application/x-vda
.vdx = application/vnd.visio
.vml = text/xml
.vpg = application/x-vpeg005
.vsd = application/vnd.visio
.vsd = application/x-vsd
.vss = application/vnd.visio
.vst = application/vnd.visio
.vst = application/x-vst
.vsw = application/vnd.visio
.vsx = application/vnd.visio
.vtx = application/vnd.visio
.vxml = text/xml
.wav = audio/wav
.wax = audio/x-ms-wax
.wb1 = application/x-wb1
.wb2 = application/x-wb2
.wb3 = application/x-wb3
.wbmp = image/vnd.wap.wbmp
.wiz = application/msword
.wk3 = application/x-wk3
.wk4 = application/x-wk4
.wkq = application/x-wkq
.wks = application/x-wks
.wm = video/x-ms-wm
.wma = audio/x-ms-wma
.wmd = application/x-ms-wmd
.wmf = application/x-wmf
.wml = text/vnd.wap.wml
.wmv = video/x-ms-wmv
.wmx = video/x-ms-wmx
.wmz = application/x-ms-wmz
.wp6 = application/x-wp6
.wpd = application/x-wpd
.wpg = application/x-wpg
.wpl = application/vnd.ms-wpl
.wq1 = application/x-wq1
.wr1 = application/x-wr1
.wri = application/x-wri
.wrk = application/x-wrk
.ws = application/x-ws
.ws2 = application/x-ws
.wsc = text/scriptlet
.wsdl = text/xml
.wvx = video/x-ms-wvx
.xdp = application/vnd.adobe.xdp
.xdr = text/xml
.xfd = application/vnd.adobe.xfd
.xfdf = application/vnd.adobe.xfdf
.xhtml = text/html
.xls = application/vnd.ms-excel
.xls = application/x-xls
.xlw = application/x-xlw
.xml = text/xml
.xpl = audio/scpls
.xq = text/xml
.xql = text/xml
.xquery = text/xml
.xsd = text/xml
.xsl = text/xml
.xslt = text/xml
.xwd = application/x-xwd
.x_b = application/x-x_b
.x_t = application/x-x_t

-----------------------------------------

servlet 理解 --servlet笔记相关推荐

Head First Servlet JSP读书笔记
Head First Servlet && JSP 引子 Sun 考试-SCJP->SWCCD,$200 学习原则图胜于文采用交谈式学习风格 Keep Attention,T ...
Servlet入门学习笔记
Servlet入门基本概述 Servlet(Server Applet),全称Java Servlet,未有中文译文.是用Java编写的服务器端程序.其主要功能在于交互式地浏览和修改数据,生成动态W ...
head first servlet jsp 学习笔记
1.web服务器和客户做什么?他们如何交流直白的讲,用户可以通过web浏览器请求一些资源,web服务器得到这些请求之后,查找资源,然后向用户返回一些结果. 这个服务器,可能是是物理主机,可能是web ...
什么是servlet？servlet的作用？——计算机网络系列学习笔记
1. servlet的概念简单来说servlet是运行在服务器上的java程序 servlet由servlet容器管理,servlet容器也叫 servlet引擎,是servlet的运行环境,给发送 ...
理解Servlet和Servlet容器、Web容器等概念
Tomcat容器属于web容器的一种,web容器还包括weblogic容器.JBoss容器等:而Tcomcat.webLogic等包含servlet容器. web容器:可以部署多个WEB应用程序的环境 ...
[Servlet] 初识Servlet
什么是Servlet? 定义 Servlet的全称是 Server Applet,顾名思义,就是用 Java 编写的服务器端程序. Servlet 是一个 Java Web开发标准,狭义的Servle ...
错误javax.servlet.ServletException: Servlet.init() for servlet com.hank.controller.UserLogin threw exc
错误javax.servlet.ServletException: Servlet.init() for servlet com.hank.controller.UserLogin threw exc ...
java web servlet、servlet容器 HTTP服务器和mvc三层架构或者说servlet属于哪一层的，给我搞的晕晕的，今天终于弄明白了
0 我们先看Web容器是什么? 首先,让我们简单回顾一下web技术的发展历史,可以帮助你理解web容器的由来. 早期的web应用主要用于浏览新闻等静态页面,HTTP服务器(比如Apache,Nginx ...
【Servlet】Servlet 详解（使用+原理）
文章目录 1. Servlet 介绍 1.1 什么是 Servlet 1.2 Servlet 的主要工作 2. Servlet 程序创建步骤 2.1 创建项目 2.2 引入依赖 2.3 创建目录 2. ...

servlet 理解 --servlet笔记

servlet 理解 --servlet笔记相关推荐

最新文章

热门文章