javaweb进阶-Servlet基础

Servlet基础

一、HTTP协议介绍

概念

Hypertext Transfer Protocol，HTTP超文本传输协议，是一个简单的请求-响应协议。
规定了客户端和服务器之间 传输数据的一种格式

特点

默认端口号：80
基于请求/响应模型：`一次请求对应一次响应`
特点:
	1.简单快速。客户端向服务器请求服务时，只需要传送请求方法和路径。
	2.灵活。HTTP协议允许传送任意格式的数据。正在传输的类型由，content-type标明。
	3.无连接。就是每个请求都建立一个连接，请求处理完毕并发送至客户端之后就断开连接。这样明显有其缺点，就是在需要连续发送请求时，需要为每一个请求单独的再次建立连接，很浪费时间和资源。于是在HTTP协议1.1版本之后引入了可持续连接，也就是再每一个请求处理完毕后，它不会立刻就断开连接，而是再等待一段时间，如果在此期间又有新的请求过来，那么等待时间刷新，如果没有，则等待时间完毕后，连接关闭。
	4.无状态。是指协议对于每次请求的处理没有记忆能力，它不知道之前是否已经访问过，不保留访问痕迹。主要目的是为了保证数据传输的安全性。

Http请求协议包

在浏览器准备发送请求时，负责创建一个Http请求协议包，
浏览器将请求信息以二进制形式保存在Http请求协议包中的各个空间，
由浏览器负责将Http请求协议包推送到指定服务端计算机。

Http响应协议包

Http服务器在定位到被访问的资源文件后，
负责创建一个Http响应协议包。
Http服务器将定位文件内容或者文件命令以二进制形式
写入到Http响应协议包的各个空间中，
由Http服务器负责将Http响应协议包推送回发起请求的浏览器上。

二、Servlet

原理

① 当服务器接收到客户端浏览器的请求后，先解析请求的url路径，获取访问Servelt的资源路径
② 查找项目的web.xml,根据资源路径匹配web.xml中的 <servlet-mapping>中的<url-pattern> 
③ 如果没有匹配到报 404 如果匹配到了 根据<servlet-mapping>中的<servlet-name> 
④ 再去匹配 <servlet>中的<servlet-name> 如果没有匹配到 404 
⑤ 如果匹配到了执行<servlet> 中的<servlet-class> 从而以反射的方式访问到指定的Servlet，调用其方法

使用步骤

编写步骤:
    1. 创建HTML页面并设计一个表单
    2. 创建一个普通类, 并继承HTTPServlet抽象类, 并重写Service方法
    3. 在web.xml文件中注册servlet, 作为前后台连接的中间件
    4. 修改前台表单中action的请求地址
    5. 通过浏览器输入对应的地址来访问测试

Servlet生命周期

init() 初始化阶段：
	默认第一次访问servlet时初始化，只创建一次（单例模式）。
	在web.xml中，通过配置<load-on-startup>改变创建时机，
		-- 小于0，第一次访问创建(默认)
		-- 大于等于0，项目启动即创建
		
service() 服务阶段：
	访问一次，执行一次，可多次执行。
	
Destroy() 销毁阶段：
	关闭服务 或 重新加载时销毁，只执行一次。    

Servlet路径多元化（一个servlet可以配置多个url）

完全路径匹配： /a/b/c
目录匹配：    目录/*
扩展名匹配：  *.后缀

`注意：整个项目中，url唯一，不可重复配置相同的url-pattern`

    <!--注册servlet-->
    <servlet>
        <servlet-name>hello</servlet-name><!--servlet名称-->
        <servlet-class>com.wh.servlet.HelloServlet</servlet-class><!--全路径-->
    </servlet>
    <!--映射路径/虚拟路径
    -->
    <servlet-mapping>
        <servlet-name>hello</servlet-name><!--servlet名称-->
        <url-pattern>/hello</url-pattern><!--访问路径, 以 / 开头-->
        <!-- 目录匹配 -->
        <url-pattern>/aa/bb/cc</url-pattern>
        <url-pattern>/aa/bb/cc/dd/*</url-pattern>
        <!-- 扩展名匹配 -->
        <url-pattern>*.do</url-pattern>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

Servlet注解配置

Servlet的注解（@WebServlet）是Servlet3.0及以上版本支持的，主要目的是简化web.xml配置。
    
因此配置Servlet的方式有两种：
    1.web.xml中配置 Servlet  这种写法比较麻烦。 代码比较多
    2.通过注解 @WebServlet,配置了注解就不需要在web.xml中配置.

注意:一个Servlet的配置可以使用注解，也可以使用web.xml文件，但二者不能共存，只能任选其一

三、Request【浏览器---->服务器】

Http请求协议包：
	请求行  URL请求地址、method请求方式
	请求头  Cookie、请求参数【get】
	空白行  隔离作用
	请求体  请求参数【post】

获取请求行数据

getScheme()	     协议名
getServerName()  服务器名
getServerPort()  端口号
getContextPath() 项目名
getMethod()		 请求方式
queryString()	 参数字符串
getRequestURL()  完整请求url

获取请求头数据

String getHeader(String name)   根据名称获取（单个）
Enumeration getHeaderNames()    获取所有请求头名称（多个）

获取请求正文数据【请求体】

1、获取请求参数
  String getParameter(String name)		    根据参数名获取参数值
  String[] getParameterValues(String name)  根据参数名获取参数值(可以是多个值)【复选框】
  Enumeration<String> getPatameterNames()   获取所有的参数名
  Map<String,String[]>  getParameterMap()  （配合BeanUtils使用）获取所有参数的map集合
  
2、解决请求乱码
  Get方式：
    如果是Tomcat8及以上版本就不需要进行转码处理，如果是Tomcat7及之前版本可以使用以下方法进行转码：
	  String name = request.getParameter("name");
	  String encodingName=new String(name.getBytes("iso-8859-1"),"utf-8")；
	  
  Post方式：
	request.setCharacterEncoding("utf-8");

请求转发

概念：
	一种在服务器内部资源跳转的方式。浏览器请求ServletA资源时，ServletA资源不足或者没有资源，ServletA请求其他的资源然后响应给浏览器，这个过程叫请求转发;

实现：
	request.getRequestDispatcher("路径").forward(request,response);
特点：
	1. 发生在服务器内部
    2. 转发的过程中url地址不变 浏览器不知道
    3. 转发可以访问到 WEB-INF 中的资源,浏览器不能直接访问这个目录下的资源
    4. 转发的路径是当前项目下 因此转发不可以访问项目以外的资源
    5. 转发的路径一般是相对路径
    6. 转发发生一次请求中，不管转发多少次，都算是同一次请求

域对象：共享数据

request：请求作用域对象【一次请求有效】
session：会话作用域对象【一次会话有效】
servletContext：全局作用域对象【整个web应用有效】

相关方法：
	存储：void setAttribute(String name,Object obj)
	获取：Object getAttribute(String name)
	移除：void removeAttribute(String name)

四、Response【服务器---->浏览器】

Http响应协议包：
    响应行  Http状态码：200,302,404,505...
	响应头  content-type：编译器、cookie、location、refresh
	空白行  隔离作用
	响应体  返回文件内容|文件命令
		   动态文件运行后返回结果【二进制】

状态行（响应行）

不同的状态码代表不同的含义。
  1xx -信息      【服务器收到请求，需要请求者继续执行操作】
  2xx -成功      【操作被成功接收并处理】
  3xx -重定向    【需要进一步的操作以完成请求】
  4xx -客户端错误 【请求包含语法错误或无法完成请求】
  5xx -服务器错误 【服务器在处理请求的过程中发生了错误】

几中常见的状态码：
	200 响应成功
    302 资源重定向 
    304 缓存
    500 服务器端代码出错，Java异常
	404 请求资源找不到
      出现的原因：
          1.浏览器访问路径错误
          2.tomcat服务未开启，项目没有部署到tomcat服务器中
          3.你要访问的页面资源在WEB-INF文件夹中，无法访问

响应头

重要的响应头信息：
	Content-Type: 响应内容的MIME类型 （MIME类型:大类型/小类型，如：text/html）
	Content-Disposition:告诉浏览器以下载方式打开数据【文件下载】
	Location: 页面跳转
	refresh:  页面刷新或者指定时间后跳转【单位：秒】
	
设置响应头：
	response.setHeader(String key, String value);
 如：response.setHeader("Content-Type", "text/html;charset=utf-8");
 
解决响应中文乱码：
	response.setHeader("Content-Type", "text/html;charset=utf-8");

响应体

response自带的流有两个：
	response.getWriter() ==> PrintWriter  输出文本信息
	response.getOutputStream ==> ServletOutputStream 输出字节信息，比如图片、音频、视频

重定向【本质：浏览器再次发出新的请求】

概念：
	重定向是客户端行为，当客户端浏览器向AServlet发送一个请求，经过处理后向客户端做出响应，这个响应就是向服务器再次发送新的请求，去请求BServlet，而这个新请求的地址将为浏览器做出第二次响应。
	
实现：
	resp.sendRedirect("路径");

特点：
	1. 重定向发生在浏览器和服务器之间
	2. 重定向的过程url地址发生变化
	3. 重定向发生至少两次请求中
	4. 重定向访问不到WEB-INF的资源
	5. 重定向可以访问当前应用外的资源
	6. 重定向一般使用绝对路径（访问外网资源时）
注意：一般选择了request请求域，就不会选择重定向跳转。

五、文件下载

超链接下载

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>下载</title>
</head>
<body>
<!-- 使用超链接方式提供下载链接 -->

<a href="1.mp3">下载音乐</a><br>
<a href="020.mp4">下载视频</a><br>
<a href="msl.jpeg">下载图片</a><br>
<a href="tomcat.zip">下载文件</a><br>
</body>
</html>

后台下载

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

	<h2>后台形式下载</h2>
	<p><a href="downLoad?fileName=a.txt">a.txt</a></p>
	<p><a href="downLoad?fileName=liutao.jpg">liutao.jpg</a></p>
	<p><a href="downLoad?fileName=c3p0-0.9.2-pre5.jar">c3p0-0.9.2-pre5.jar</a></p>
	<p><a href="downLoad?fileName=day11_servlet.doc">day11_servlet.doc</a></p>
	<p><a href="downLoad?fileName=day11_servlet.zip">day11_servlet.zip</a></p>
	<p><a href="downLoad?fileName=柳岩.jpg">柳岩.jpg</a></p>
</body>
</html>

服务器代码：

@WebServlet("/download")
public class DownloadServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
        //先获取传过来的参数 name
        String name = req.getParameter("name");
        
        //跟浏览器之间的数据交互格式设置为以下载的方式打开数据.
        //浏览器能够识别的编码 西欧码  iso-8859-1  目前项目的默认编码是utf-8
        resp.setHeader("content-disposition","attachment;filename="+new String(name.getBytes("utf-8"),"iso-8859-1"));
        
        //获取整个web应用的唯一对象 ServletContext
        ServletContext servletContext = req.getServletContext();
        
        //获取文件
        InputStream is = servletContext.getResourceAsStream(name);
        
        //输出文件数据 (1.纯文本的输出流 PrintWriter 2.输出二进制文件ServletOutputStream )
        ServletOutputStream os = resp.getOutputStream();
        //第一种输出
        /*
        byte[] b = new byte[is.available()];
        is.read(b);  //读取数据，把数据存放到byte数组中
        os.write(b);
        */
        //第二种输出
        byte[] b = new byte[2048];
        int len = -1;
        while((len= is.read(b))!=-1){
            os.write(b,0,len);
        }
        os.close();
        is.close();
    }
}

六、文件上传

前端代码：

<form action="upload" method="post" enctype="multipart/form-data">
    <input type="file" name="uploadFile" /> <br>
    <input type="submit" values="上传" />
</form>

//表单需要提供multipart/form-data ，把表单的数据按照两个部分传递.
//表单如果需要实现文件上传，提交方式只能是post.
//表单需要提供一个用于上传文件的控件   <input type="file" name="uploadFile" />

服务器代码：

@WebServlet("/fileUpload")
@MultipartConfig   //自动完成解析工作
public class FileUploadServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      
        //解决post中文乱码
        req.setCharacterEncoding("utf-8");
        Part part = req.getPart("upload");  //此处的名字 指的是 <input type="file" name="upload" /> 中的name属性值
      
        //获取文件名字   1.jpg.bmp  2.bmp   3.gif 4.png
        String submittedFileName = part.getSubmittedFileName();  // tomcat 8 之后才有这个方法

        //获取文件后缀名
        String suffix = submittedFileName.substring(submittedFileName.lastIndexOf("."));
      
        // .bmp .jpg . png
        System.out.println(UUID.randomUUID().toString());
      
        //判断文件的后缀名是否为图片格式
        List<String> list = Arrays.asList(".jpg", ".jpeg", ".gif", ".png", ".bmp");
      
        //文件大小
        long size = part.getSize();
        if(!list.contains(suffix)){
            resp.getWriter().print("error,only "+list+"<a href='upload.html'>back</a>");
        }else if(size>1024*300){
            resp.getWriter().print("error,only "+"1M");
        }
        else{
            String newName = System.currentTimeMillis() + suffix;  // 687698970.png
            //把文件数据 保存到 服务器本地
            part.write("E:\\upload\\"+newName);
        }
    }
}

总结

1、表单：
	<form action="upload" method="post" enctype="multipart/form-data">
2、后台：
	@MultipartConfig   //自动解析
	Part part = req.getPart("name");	// 根据name属性截取文件标签
	获取文件名：part.getSubmittedFileName();
	获取文件大小: part.getSize();
	保存文件到服务器：part.write("路径"+文件名);

七、图片验证码【ValidateCode.jar】

后台：

@WebServlet("/validateCode")
public class ValidateCodeServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //指定验证码的参数
        ValidateCode validateCode = new ValidateCode(120,30,4,0);
        //获取验证码上的字符
        String code = validateCode.getCode();
        System.out.println(code);
        //生成验证码图片响应到浏览器
        validateCode.write(resp.getOutputStream());
    }
}

前端：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>验证码</title>
</head>
<body>
<form>
    <input type="text" />  <img src="validateCode" onclick="changeCode()"/>
</form>
</body>
<script src="js/jquery-1.8.3.js"></script>
<script>
    function changeCode(){
        $("img").prop("src","validateCode?a="+Math.random());
    }
</script>
</html>

八、Servlet之会话

概念

客户端服务器连接开始，请求和响应的过程中都属于一次会话。客户端和服务器交流的过程，这个过程是一个持续的过程，当关闭客户端或者服务器 该次会话结束。整个过程中都属于同一次会话，不管访问是哪个页面或者哪个Servlet都属于该会话
	
会话包含以下两种：
    客户端会话：Cookie
    服务器端会话:Session

作用

	因为HTTP协议是无状态的，不会记住上一次请求的数据。所以服务器不可能知道我们已经在上一次的HTTP请求中通过了验证。当然，最简单的解决方案就是所有的请求里面都带上用户名和密码，这样虽然可行，但大大加重了服务器的负担（对于每个request都需要到数据库验证）。
	既然直接在请求中带上用户名与密码不可行，那么就只有在服务器或客户端保存一些类似的可以代表身份的信息了，所以就有了cookie与session，cookie和session用来跟踪用户的整个会话。

客户端会话Cookie

理解：
  1. 当从浏览器发送请求到服务器后，servlet创建cookie，保存少量数据，发送浏览器。
  2. 浏览器获得服务器发送的cookie数据，将自动的保存到浏览器端。
  3. 下次访问时，浏览器将自动携带cookie数据发送给服务器。
  
原理：
	Cookie是解决HTTP无状态性的有效手段，服务器可以设置或读取Cookie中所包含的信息。当用户登录后，服务器会发送包含登录凭据的Cookie到用户浏览器客户端，而浏览器对该Cookie进行某种形式的存储（内存或硬盘）。用户再次访问该网站时，浏览器会发送该Cookie（Cookie未到期时）到服务器，服务器对该凭据进行验证，合法时使用户不必输入用户名和密码就可以直接登录。
    本质上讲，Cookie是一段文本信息。客户端请求服务器时，如果服务器需要记录用户状态，就在响应用户请求时发送一段Cookie信息。客户端浏览器保存该Cookie信息，当用户再次访问该网站时，浏览器会把Cookie做为请求信息的一部分提交给服务器。服务器检查Cookie内容，以此来判断用户状态，服务器还会对Cookie信息进行维护，必要时会对Cookie内容进行修改。

使用：
	1.Cookie创建
    Cookie cookie = new Cookie(String key,String value);
    key:表示cookie的名字
    value:表示cookie中保存的数据

    2.设置有效时间 不受浏览器关闭的影响
    // 为何要设置有效时间呢？因为浏览器关闭后该会话就结束了，因此要设置有效时间来保证浏览器关闭后Cookie会话还存在,单位为秒
    cookie.setMaxAge(int expiry); 
    //默认值为 -1 ：代表浏览器关闭后，也就是会话结束后，cookie就失效了，也就没有了；
    //expiry>0 :代表浏览器关闭后，cookie不会失效，仍然存在。并且会将cookie保存到硬盘中，直到设置时间过期才会被浏览器自动删除；
    //expiry=0：删除cookie。不管expiry=-1还是expiry>0，当设置expiry=0时，cookie都会被浏览器给删除。


    3. 发送给浏览器
    response.addCookie(cookie);

    4. 获取cookie 
    Cookie[] cookies = request.getCookies();
    if(cookies!=null) {
        for (Cookie cookie : cookies) {
            // 获取cookie的名称
            String name = cookie.getName();
            // 获取cookie的值
            String value = cookie.getValue();
            System.out.println(name+"：：："+value);
         }	
    }

特点：

1、Cookie中只能以键值对的形式保存`字符串类型`的数据
2、Cookie中保存的数据有大小限制，一般不超过`4KB`
3、Cookie是保存在`客户端`的，安全性较差
4、Cookie默认有效期是浏览器关闭即销毁，如果想持久保存Cookie对象，一定要设置有效期，并且有效期时间单位是秒。

服务端会话Session

理解：
	Session是服务器提供的一个会话对象，是第二大作用域对象。创建之后这个Session是存储到服务器中的。但Session的使用需要和浏览器建立关联，这个关联与Cookie有关，其中每一个Session对象都会对应一个sessionId，这个sessionId就被存储在Cookie中。

原理：
	首先浏览器请求服务器访问web站点时，程序需要为客户端的请求创建一个session的时候，服务器首先会检查这个客户端请求是否已经包含了一个session标识、称为SESSIONID，如果已经包含了一个sessionid则说明以前已经为此客户端创建过session，服务器就按照sessionid把这个session检索出来使用，如果客户端请求不包含session id，则服务器为此客户端创建一个session并且生成一个与此session相关联的session id，sessionid 的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个sessionid将在本次响应中返回到客户端保存，保存这个sessionid的方式就可以是cookie，这样在交互的过程中，浏览器可以自动的按照规则把这个标识发回给服务器，服务器根据这个sessionid就可以找得到对应的session
	
使用：
	1.获取session对象
    HttpSession session = request.getSession();
    2. 保存数据到session中
    session.setAttribute(String 绑定名, Object 绑定值);
    3. 获取session数据
    Object  session.getAttribute("绑定名");
    4. 有效时间 单位秒  默认30分钟
    session.setMaxInactiveInterval(int expiry);
    5. 销毁session对象
    session.invalidate();

特点：

1、存储在服务器端,安全性相比较cookie，更安全。
2、默认超时时间为30分钟
3、Session做为第二大域对象，在一个会话范围内的数据是可以共享的
4、Session存储的数据可以是任意类型
5.让session失效的方法:
	 1) 手动销毁  session.invalidate()
     2) 关闭浏览器
     3） 重启服务器
     4） 有效时间到了

cookie和session的区别【面试题】

1. Cookie和Session都是会话技术，Cookie是运行在客户端，Session是运行在服务器端。
2. Cookie有大小限制以及浏览器在存cookie的个数也有限制，Session是没有大小限制和服务器的内存大小有关。
3. Cookie只能保存字符串数据,Session可以保存任意类型数据
4. Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击。
5. Session是保存在服务器端上会存在一段时间(默认30分钟)才会消失，如果session过多会增加服务器的压力。
6. cookie默认存活时间是浏览器关闭销毁。 session默认存活时间30分钟。

九、Servlet之Filter过滤器

原理：先过滤，后放行

​ 过滤器会执行两次过滤，第一次是请求时的过滤，第二次是响应时的过滤

创建方式：

方式一：使用web.xml注册过滤器
	1. 创建一个普通类实现Filter接口
	2. 重写Filter接口中的三个方法
	3. 在web.xml文件中注册过滤器
	
方式二：使用注解方式注册过滤器
	1. 创建一个普通类继承Filter接口
	2. 重写Filter接口中的三个方法
	3. 使用注解注册过滤器

字符编码过滤器

@WebFilter("/*")
public class CharaterFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        //编码处理
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=UTF-8");
        //放行
        chain.doFilter(req,resp);
    }

    @Override
    public void destroy() {
    }
}

十、Servlet规范

一、Servlet规范介绍：

1、Servlet规范来自于JavaEE规范中的一种。
2、作用：
1.在Servlet规范中，指定了【动态资源文件】的开发步骤
2.在Servlet规范中，指定了Http服务器调用动态资源文件的规则
3.在Servlet规范中，指定了Http服务器管理动态资源文件实例对象的规则

二、Servlet实现类：

1、Servlet接口来自于Servlet规范下的一个接口，这个接口存在于Http服务器提供的jar包中
2、Tomcat服务器下lib文件中有一个Servlet-api.jar存放Servlet接口（javax.servlet.Servlet接口）
3、Servlet规范中，Http服务器能调用的【动态资源文件】必须是一个Servlet接口实现类
例子：
class Student{
//不是动态资源文件，Tomcat无权调用
}

  class Teacher implements Servlet{
      //合法动态资源文件，Tomcat有权利调用

      //调用方式
      Servlet obj = new Teacher();
      obj.doGet();
  }

三、Servlet接口实现类开发步骤

第一步：创建一个Java类继承HttpServlet类，使之成为一个Servlet接口实现类

第二步：重写HTTPServlet父类的两个方法 doGet和doPost
get
浏览器----->oneServlet.doGet();
post
浏览器----->oneServlet.doPost();

第三步：将Servlet接口实现类的信息【注册】到Tomcat服务器

  【网站】--->【web】--->【WEB-INF】--->web.xml

  <!--将Servlet接口实现类的类路径地址交给Tomcat-->
  <servlet>
    <servlet-name>name</servlet-name><!--声明一个变量存储servlet接口实现类的类路径-->
    <servlet-class>com.wh.web.OneServlet</servlet-class><!--声明servlet接口实现类的类路径-->
  </servlet>

   <!--为了降低用户访问Servlet接口实现类难度，需要设置简短的请求别名-->
   <servlet-mapping>
  	<servlet-name>name<servlet-name/>
  	<url-pattern>/one<url-pattern/><!--设置简短的请求别名，别名必须以"/"开头-->
   <servlet-mapping/>

   如果现在浏览器向Tomcat索要OneServlet时，地址为：http://localhost:8080/myWeb/one

三、Servlet对象生命周期：
1、网站中所有的Servlet接口实现类的实例对象，只能由Http服务器负责创建。
开发人员不能手动创建Servlet接口实现类的实例对象

2、在默认情况下，Http服务器接收到对于当前Servlet接口实现类第一次请求时，
自动创建这个Servlet接口实现类的实例对象

 在手动配置的情况下，可以要求Http服务器在启动时自动创建某个Servlet接口实现类的实例对象
  <servlet>
  	<servlet-name>name</servlet-name><!--声明一个变量存储servlet接口实现类的类路径-->
  	<servlet-class>com.wh.controller.OneServlet</servlet-class>
  	<load-on-startup>30</load-on-startup><!--填写一个大于0的整数即可-->
   </servlet>

3、在Http服务器运行期间，一个Servlet接口实现类只能被创建出一个实例对象

4、在Http服务器关闭时刻，自动将网站中所有的Servlet对象进行销毁

四、HttpServletResponse接口

1、介绍：
1.HttpServletResponse接口来自于Servlet规范中，在Tomcat中存放在servlet-api.jar
2.HttpServletResponse接口实现类由Http服务器提供
3.HttpServletResponse接口负责将doGet/doPost方法的执行结果写入到【响应体】中交给浏览器
4.开发人员习惯于将HttpServletResponse接口修饰的对象称为【响应对象】

2、主要功能：
1.将执行结果以二进制形式写入到【响应体】
2.设置响应头中[context-type]属性值，从而控制浏览器使用
对应编译器将响应体二进制数据编译为【文字、图片、视频、命令】
3.设置响应头中[location]属性，将一个请求地址赋值给location，
从而控制浏览器向指定服务器发送请求

五、HttpServletRequest接口

1、介绍：
1.HttpServletRequest接口来自于Servlet规范中，在Tomcat中存放在servlet-api.jar
2.HttpServletRequest接口实现类由Http服务器提供
3.HttpServletRequest接口负责在doGet/doPost方法运行时读取Http请求协议包中信息
4.开发人员习惯将HttpServletRequest接口修饰的对象称为【请求对象】

2、作用：
1.可以读取Http请求协议包中【请求行】信息
2.可以读取保存在Http请求协议包中【请求头】或者【请求体】中的请求参数信息
3.可以代替浏览器向Http服务器申请资源文件调用

六、请求对象和响应对象的生命周期

1、在Http服务器接收到浏览器发送的【Http请求协议包】之后，
自动为当前的【Http请求协议包】生成一个【请求对象】和【响应对象】

2、在Http服务器调用doGet/doPost方法时，负责将【请求对象】和【响应对象】
作为实参传入到方法中，确保doGet/doPost正确执行

3、在Http服务器准备推送【Http响应协议包】之前，负责将本次请求关联的【请求对象】和【响应对象】销毁

*****【请求对象】和【响应对象】的生命周期贯穿一次请求的处理过程
*****【请求对象】和【响应对象】相当于用户在服务端的代言人

七、欢迎资源文件

1、前提：用户可以记住网站名，但是不会记住网站资源文件名

2、默认欢迎资源文件：
用户发送了一个针对某个网站的【默认请求】时，
此时由Http服务器自动从当前网站返回的资源文件就叫做默认欢迎资源文件

  正常请求：http://localhost:8080/myWeb/index.html
  默认请求：http://localhost:8080/myWeb/

3、Tomcat对于默认欢迎资源文件的定位规则：
1.规则位置：Tomcat安装位置/conf/web.xml
2.规则命令：
index.html
index.htm
index.jsp

4、设置当前网站的默认欢迎资源文件位置：
1.规则位置：网站/web/WEB-INF/web.xml
2.规则命令：
xxxx.html

3.网站设置自定义默认文件定义规则之后，Tomcat自带定位规则将失效

八、Http状态码

1、介绍：
1.由三个数字组成的一个符号
2.Http服务器在推送响应之前，根据本次请求的处理结果，
将Http状态码写入到响应包中的【状态行】上

  3.如果Http服务器针对本次请求，返回了对应的资源文件；
    通过Http状态码通知浏览器应该如何处理这个结果

    如果Http服务器针对本次请求，无法返回对应的资源文件，
    通过Http状态码向浏览器解释不能提供服务的原因

2、分类：
1.组成：100—599，分为五个大类
2. 1xx：
最有特征 100；通知浏览器本次返回的资源文件，
并不是一个独立的资源文件，需要浏览器在接收响应包之后，
继续向Http服务器索要依赖的其他资源文件

     2xx：
  	最有特征 200；通知浏览器本次返回的资源文件，
  	是一个完整独立的资源文件，浏览器在接收到响应包之后，
  	不需要索要其他的关联文件

     3xx：
  	最有特征 302；通知浏览器本次返回的不是一个资源文件内容，
  	而是一个资源文件地址，需要浏览器根据这个地址，
  	自动发起请求来索要这个资源文件

  	response.sendRedirect("资源文件地址")写入到响应头中的location，
  	这个行为就会让Tomcat将302转态码写入到状态行

     4xx：
  	404：通知浏览器，由于在服务端没有定位到被访问的资源文件，因此无法提供帮助
  	405：通知浏览器，在服务端已经定位到被访问的资源文件(Servlet)，
  	     但是这个Servlet对于浏览器采用的请求方式不能处理

     5xx：
  	500：通知浏览器，在服务端已经定位到被访问的资源文件(Servlet)，
  	     这个Servlet可以接收浏览器采用的请求方式，
  	     但是Servlet在处理请求期间，由于Java异常导致处理失败

九、多个Servlet之间的调用规则：
1、前提条件：
某些来自于浏览器的请求，往往需要服务端中多个多个Servlet协调处理。
但是浏览器一次只能访问一个Servlet，导致用户需要手动通过浏览器发起多次请求才能得到服务。
这样增加了用户获得服务的难度，可能导致用户放弃访问当前网站。

2、提高用户使用感受规则：
无论本次请求涉及到多少个Servlet，用户只需要【手动通知】浏览器发起一次请求即可

3、多个Servlet之间调用规则：
1.重定向解决方案
2.请求转发解决方案

十、重定向解决方案
1、工作原理：用户第一次通过【手动方式】通知浏览器访问OneServlet。
OneServlet工作完成之后，将TwoServlet地址写入到响应头中的location属性，
导致Tomcat将状态码302写入到状态行。

       在浏览器接收到响应包之后，会读取到302状态。
       此时浏览器自动根据响应头中location属性地址发起第二次请求，
       访问TwoServlet去完成请求中剩余任务。

2、实现命令：
response.sendRedirect(“请求地址”);
将地址写入到响应包中的响应头中的location属性

3、特征：
1.请求地址：
既可以把当前网站内部的资源文件地址发送给浏览器（/网站名/资源文件名）
也可以把其他网站资源文件地址发送给浏览器(http://ip地址:端口号/网站名/资源文件名)

  2.请求次数：
  	浏览器至少发送两次请求，但是只有第一次请求时用户手动发送，
  	后续请求都是浏览器自动发送的。

  3.请求方式：
  	重定向解决方案中，通过地址栏通知浏览器发起下一次请求，
  	因此通过重定向解决方案调用的资源文件接收的请求方式一定是【GET】

4、缺点：
重定向解决方案需要在浏览器和服务器之间进行多次往返，
大量时间被消耗在往返次数上，增加用户等待服务的时间。

十一、请求转发解决方案

1、原理： 用户第一次通过【手动方式】要求浏览器访问OneServlet。
OneServlet工作完毕之后，通过当前请求对象代替浏览器
向Tomcat发送请求，申请调用TwoServlet。
Tomcat在接收到这个请求之后，自动调用TwoServlet来完成剩余任务。

2、实现命令：请求对象代替浏览器向Tomcat发送请求
//1、通过当前对象生成资源文件申请报告对象
RequestDispatcher report = request.getRequestDispatcher("/资源文件名")；一定要以"/"开头
//2、将报告对象发送给Tomcat
report.forward(当前请求对象,当前响应对象);

3、优点：
1.无论本次请求涉及到多少个Servlet，用户只需要手动通过浏览器发送一次请求
2.Servlet之间调用发生在服务端计算机上，节省服务端与浏览器之间的往返次数，加快了处理服务的速度。

4、特征：
1.请求次数：
在请求转发过程中，浏览器只发送一次请求

  2.请求地址：
  	只能向Tomcat服务器申请调用当前网站下的资源文件地址
  	request.getRequestDispatcher("/资源文件名");****不要写网站名****

  3.请求方式：
  	在请求转发过程中，浏览器只发送了一个Http请求协议包，	
  	参与本次请求的所有Servlet共享同一个请求协议包，
  	因此这些Servlet接收的请求方法与浏览器发送的请求方式保持一致。

十二、多个Servlet之间数据共享的实现方案
1、数据共享：
OneServlet工作完毕之后，将产生数据交给TwoServlet来使用

2、Servlet规范中提供四种数据共享方案
1.ServletContext接口
2.Cookie类
3.HttpSession接口
4.HttpServletRequest接口

十三、ServletContext接口
1、介绍：
1.来自Servle规范中的一个接口。在Tomcat中存在servlet-api.jar
在Tomcat中负责提供这个接口实现类。
2.如果两个servlet之间来自于同一个网站。彼此之间通过网站的ServletContext实例对象实现数据共享
3.开发人员习惯于将ServletContext对象称为【全局作用域对象】

2、工作原理：
每一个网站都存在一个全局作用域对象。
这个全局作用域对象【相当于】一个Map
在这个网站中的OneServlet可以将一个数据存入到全局作用域对象，
当前网站中的其他Servlet都可以从全局作用域对象中，得到这个数据进行使用

3、全局作用域对象生命周期
1.在Http服务器启动过程中，自动为当前网站在内存中创建一个全局作用域对象
2.在Http服务器运行期间，一个网站只有一个全局作用域对象
3.在Http服务器运行期间，全局作用域对象一直处于存活状态
4.在Http服务器准备关闭时，负责将当前网站中的全局作用域对象进行销毁处理
全局作用域的生命周期贯穿网站整个运行期间

4、命令实现：
【同一个网站】OneServlet将数据共享给TwoServlet

  OneServlet{
    public void doGet(HttpServletRequest request,HttpServletResponse,response){
    		//1、通过【请求对象】向Tomcat索要当前网站中的【全局作用域对象】
  	ServletContext application = request.getServletContext();
  	//2、将数据添加到全局作用域对象作为【共享数据】
  	application.setAttribute("key1",数据)；
     }
  }

  TwoServlet{
    public void doGet(HttpServletRequest request,HttpServletResponse,response){
    		//1、通过【请求对象】向Tomcat索要当前网站中的【全局作用域对象】
  	ServletContext application = request.getServletContext();
  	//2、从全局作用域对象中得到指定关键字对应数据
  	Object 数据 = application.getAttribute("key1");
     }
  }

十四、Cookie
1、介绍：
1.Cookie来自于Servlet规范中的一个工具类，存在于Tomcat提供的servlet-api.jar中
2.如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，
此时可以借助Cookie对象进行数据共享。
3.Cookie存放当前用户的私人数据，在共享数据过程中提高服务质量
4.在现实生活场景中，Cookie相当于用户在服务端得到【会员卡】

2、原理：
用户通过浏览器第一次向myWeb网站发送请求申请访问OneServlet，
OneServlet在运行期间创建一个Cookie存储与当前用户相关的数据。
OneServlet工作完毕之后，【将Cookie写入到响应头】交换给当前浏览器。
浏览器接收到响应包之后，将Cookie存储在浏览器的缓存中，
一段时间后，用户通过【同一个浏览器】再次向【同一个网站myWeb】发送请求申请访问TwoServlet时，
【浏览器需要无条件的将myWeb网站之前推送过来的Cookie，写入到请求头】，发送过去。
此时TwoServlet在运行时，就可以通过读取请求头中的cookie信息，
得到OneServlet提供的共享数据。

3、实现命令：
同一个网站中的OneServlet 与 TwoServlet 借助于Cookie实现数据共享

  OneServlet{
     public void doGet(HttpServletRequest request,HttpServletResponse,response){	
  	//1、创建一个Cookie对象，保存共享数据（当前用户数据）
  	Cookie card = new Cookie("key1","abc");
  	Cookie card1 = new Cookie("key2","efg");
  	*****cookie相当于一个map
  	*****一个cookie中只能存放一个键值对
  	*****这个键值对的key与value只能是String
  	*****键值对的key不能是中文
  	//2、将cookie写入到响应头，交给浏览器
  	resp.addCookie(card);
  	resp.addCookie(card1);
     }
  }

  浏览器/用户       <--------响应包  【200】
  				   【cookie：key1=abc;key2=efg】
  				   【】
  				   【处理结果】

  浏览器向myWeb发送请求访问TwoServlet------>请求包   【url:/myWeb/two  method:get】
  						   【
  							请求参数：XXXX
  							Cookie: key1=abc;key2=efg】
  						   【】
  						   【】
  
  TwoServlet{

      public void doGet(HttpServletRequest request,HttpServletResponse,response){
  	//1、调用请求对象从请求头得到浏览器返回的cookie
  	Cookie[] cookieArray = request.getCookies();
  	//2、循环遍历数据得到每一个cookie的key 与 value
  	for(Cookie card:cookieArray){
  	    String key = card.getName();//读取key  "key1"
  	    String value = card.getValue();//读取value  "abc"
  	    提供较好的服务。。。。
  	}  
      }
  }

4、Cookie销毁时机：
1.在默认情况下，Cookie对象存放在浏览器的缓存中，
因此只要浏览器关闭，Cookie对象就被销毁掉

  2.在手动设置情况下，可以要求浏览器将接收的Cookie
    存放在客户端计算机硬盘上，同时需要指定Cookie在硬盘上的存活时间，
    在存活时间范围内，关闭客户端计算机、关闭服务器，都不会导致Cookie被销毁，
    在存活时间到达是，Cookie自动从硬盘上被删除。
  	cookie.setMaxAge(60);//cookie在硬盘上存活60s

十五、HttpSession接口

1、介绍：
1.HttpSession接口是来自于Servlet规范的一个接口，存在于Tomcat中的servlet-api.jar
其实现类由Http服务器提供，Tomcat提供的实现类存在于servlet-api.jar

  2.如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，
    此时可以借助HttpSession接口进行数据共享。

  3.开发人员习惯于将HttpSession接口修饰的对象称为【会话作用域对象】

2、HttpSession 和 Cookie 的区别：【面试题】

  1.存储位置：
  	Cookie：存放在客户端计算机（浏览器内容/硬盘）
  	HttpSession：存放在服务端计算机内存
  
  2.数据类型：
  	Cookie对象存储的共享数据只能是String类型
  	HttpSession对象可以存储任意类型的共享数据Object

  3.数据数量：
  	一个Cookie对象只能存储一个共享数据
  	HttpSession使用map集合存储共享数据，所以可以存储任意数量的共享数据

  4.参照物：
  	Cookie相当于客户在服务端的【会员卡】
  	HttpSession相当于客户在服务端的【私人保险柜】

3、命令实现：同一个网站(myWeb)下OneServlet将数据传递给TwoServlet

       OneServlet{
  	
  	public void doGet(HttpServletRequest request,HttpServletResponse,response){
  	    
  	    //1、调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
  	    HttpSession session = request.getSession();
  	    //2、将数据添加到用户的私人储物柜
  	    session.setAttribute("key1"，共享数据);
  	    }
  	}
  	
      浏览器访问/myWeb中的TwoServlet
      
      TwoServlet{
  	
  	public void doGet(HttpServletRequest request,HttpServletResponse,response){
  	    
  	    //1、调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
  	    HttpSession session = request.getSession();
  	    //2、从会话作用域对象得到OneServlet提供的共享数据
  	    Object 共享数据 = session.getAttribute("key1");
  	    }
  	}

4、Http服务器如何将用户与HttpSession关联起来
cookie

5、getSession() 与 getSession(false)

  1.getSession()：如果当前用户在服务端已经拥有了自己的私人储物柜，
  		要求tomcat将这个私人储物柜进行返回；
  		如果当前用户在服务端尚未拥有自己的私人储物柜，
  		要求tomcat为当前用户创建一个全新的私人储物柜

  2.getSession(false)：如果当前用户在服务端已经拥有了自己的私人储物柜，
  		     要求tomcat将这个私人储物柜进行返回；
  		     如果当前用户在服务端尚未拥有自己的私人储物柜，
  		     此时tomcat返回null

6、HttpSession的销毁时机：

  1.用户与HttpSession关联时使用的Cookie只能存放在浏览器缓存中
  2.在浏览器关闭时，意味着用户与他的HttpSession关系被切断
  3.由于Tomcat无法检测浏览器何时关闭，因此在浏览器关闭时并不会
    导致Tomcat将浏览器关联的HttpSession进行销毁
  4.为了解决这个问题，Tomcat为每一个HttpSession对象设置【空闲时间】，
    这个空闲时间默认是30分钟，如果当前HttpSession对象空闲时间达到了30分钟，
    此时Tomcat认为用户已经放弃了自己的HttpSession，此时Tomcat就会销毁这个HttpSession

7、手动设置HttpSession空闲时间：

  在当前网站/web/WEB-INF/web.xml

  <session-config>
  	<session-timeout>5</session-timeout><!--当前网站中每一个session最大空闲时间为5分钟-->
  </session-config>

十六、HttpServletRequest接口实现数据共享
1、介绍：
1.在同一个网站中，如果两个Servlet之间通过【请求转发】方式进行调用，
彼此之间共享同一个请求协议包。而一个请求协议包只对应一个请求对象，
因此servlet之间共享一个请求对象，此时可以利用这个请求对象在两个Servlet之间实现数据共享。

  2.在请求对象实现Servlet之间数据共享功能时，开发人员将请求对象称为【请求作用域对象】

2、命令实现：OneServlet通过请求转发申请调用TwoServlet时，需要给TwoServlet提供共享数据

       OneServlet{
  	public void doGet(HttpServletRequest request, HttpServletResponse response){

  		//1、将数据添加到【请求作用域对象】中的attribute属性
  		request.setAttribute("key1",数据);//数据类型可以是任意类型object
  		//2、向Tomcat申请调用TwoServlet
  		request.getRequestDispatcher("/two").forward(request,response);
  	}
       }

       TwoServlet{
  	public void doGet(HttpServletRequest request, HttpServletResponse response){
  		
  		//从当前请求对象中得到OneServlet写入的共享数据
  		Object 数据 = request.getAttribute("key1");
  	}
       }

十七、Servlet扩展规范----------监听器接口
1、介绍：
1.一组来自于Servlet规范下的接口，共有8个接口。在Tomcat存在servlet-api.jar包中
2.监听器接口需要由开发人员亲自实现，Http服务器提供的jar包中并没有对应的实现类
3.监听器接口用于监控【作用域对象生命周期变化时刻】以及【作用域对象共享数据变化时刻】

2、作用域对象：
1.在Servlet规范中，认为在服务端内存中可以在某些条件下为两个Servlet之间提供
数据共享方案的对象，被称为【作用域对象】
2.Servlet规范下的作用域对象：
ServletContext：全局作用域对象
HttpSession：会话作用域对象
HttpServletRequest：请求作用域对象

3、监听器接口实现类开发规范：三步
1.根据监听的实际情况，选择对应监听器接口进行实现
2.重写监听器接口声明的【监听事件处理方法】
3.在web.xml文件将监听器接口实现类注册到Http服务器上

4、ServletContextListener接口：
1.作用：通过这个接口，可以合法的检测全局作用域对象被初始化时刻以及被销毁时刻
2.监听事件处理方法：
public void contextInitialized()：在全局作用域对象被Http服务器初始化时触发调用
public void contextDestroy()：在全局作用域对象被Http服务器销毁时触发调用

5、ServletContextAttributeListener接口：
1.作用：通过这个接口，可以合法的检测全局作用域对象中共享数据的变化时刻
2.监听事件处理方法：
public void contextAdd()：在全局作用域对象添加共享数据时触发
public void contextReplace()：在全局作用域对象更新共享数据时触发
public void contextRemove()：在全局作用域对象删除共享数据时触发

6、全局作用域对象共享数据变化时刻：
ServletContext application = request.getServletContext();

  	application.setAttribute("key1",100); //新增共享数据
  	application.setAttribute("key1",200); //更新共享数据
  	application.removeAttribute("key1"); //删除共享数据

十八、Servlet扩展规范----------Filter接口（过滤器接口）
1、介绍：
1.来自于Servlet规范下的接口，在Tomcat中存在于servlet-api.jar包中
2.Filter接口实现类由开发人员负责提供，Http服务器不负责提供
3.Filter接口在Http服务器调用资源文件之前，对Http服务器进行拦截

2、具体作用：
1.拦截Http服务器，帮助Http服务器检测当前请求的合法性
2.拦截Http服务器，对当前请求进行增强操作

3、Filter实现类开发步骤：三步
1.创建一个Java类实现Filter接口
2.重写Filter接口中的doFilter方法
3.在web.xml中，将过滤器接口实现类注册到Http服务器上

4、Filter拦截地址格式：
1.命令格式：

oneFilter
拦截地址

2.命令作用：
拦截地址通知Tomcat在调用何种资源文件之前需要调用OneFilter过滤进行拦截

  格式一：要求Tomcat在调用某一个具体文件之前，调用OneFilter拦截
  	<url-pattern>/img/xyxy.jpg</url-pattern>

  格式二：要求Tomcat在调用某一个文件夹下所有的资源文件之前，调用OneFilter拦截
  	<url-pattern>/img/*</url-pattern>

  格式三：要求Tomcat在调用任意文件夹下某种类型文件之前，调用OneFilter拦截
  	<url-pattern>*.jpg</url-pattern>

  格式四：要求Tomcat在调用网站中任意文件时，调用OneFilter拦截
  	<url-pattern>/*</url-pattern>

：

  	ServletContext application = request.getServletContext();

  	application.setAttribute("key1",100); //新增共享数据
  	application.setAttribute("key1",200); //更新共享数据
  	application.removeAttribute("key1"); //删除共享数据

十八、Servlet扩展规范----------Filter接口（过滤器接口）
1、介绍：
1.来自于Servlet规范下的接口，在Tomcat中存在于servlet-api.jar包中
2.Filter接口实现类由开发人员负责提供，Http服务器不负责提供
3.Filter接口在Http服务器调用资源文件之前，对Http服务器进行拦截

2、具体作用：
1.拦截Http服务器，帮助Http服务器检测当前请求的合法性
2.拦截Http服务器，对当前请求进行增强操作

3、Filter实现类开发步骤：三步
1.创建一个Java类实现Filter接口
2.重写Filter接口中的doFilter方法
3.在web.xml中，将过滤器接口实现类注册到Http服务器上

4、Filter拦截地址格式：
1.命令格式：

oneFilter
拦截地址

2.命令作用：
拦截地址通知Tomcat在调用何种资源文件之前需要调用OneFilter过滤进行拦截

  格式一：要求Tomcat在调用某一个具体文件之前，调用OneFilter拦截
  	<url-pattern>/img/xyxy.jpg</url-pattern>

  格式二：要求Tomcat在调用某一个文件夹下所有的资源文件之前，调用OneFilter拦截
  	<url-pattern>/img/*</url-pattern>

  格式三：要求Tomcat在调用任意文件夹下某种类型文件之前，调用OneFilter拦截
  	<url-pattern>*.jpg</url-pattern>

  格式四：要求Tomcat在调用网站中任意文件时，调用OneFilter拦截
  	<url-pattern>/*</url-pattern>