javaWeb核心技术第七篇之HTTP、Tomcat、Servlet、Request和Response

- Web服务器
  - 概念:
    - web资源:
      "英文直译"网"的意思
      资源:一切数据文件
      web资源:通过网络可以访问到的资源,通常指的是一切放在服务器上的文件"
    - web资源的分类:
      - 静态的web资源:
        "    内容是一成不变的"
      - 动态的web资源:
        "    内容有可能在不同的时间或者不同的人访问的时候会发生改变的"
    - web技术分类
      - 静态的web技术
        "    例如: html  css  js  ....."
      - 动态的web技术
        "    例如:servlet  jsp"
    - 软件的架构
      - c/s架构(Client/Server   客户端/服务器)
        "    例如:qq  迅雷  lol"
      - b/s架构(Browser/Server   浏览器/服务器)
        "    例如:京东  淘宝  "
      - 区别
        - c/s:需要客户下载客户端,页面比较炫,和服务器交互少,可以在客户端处理部分业务逻辑,可降低服务器的压力.需要维护客户端和服务器端
        - b/s:只需要客户有一个浏览器,一切页面从服务器加载,和服务器交互频繁,由服务器处理业务逻辑,服务器压力较大.只需要维护服务器端.
    - 通讯机制
      - 基于http协议
        - 浏览器发送给服务器的内容:请求(request)
        - 服务器返回给浏览器的内容:响应(response)
        - 注意:先有请求,后有响应,一次请求对应一次响应
  - web服务器
    - 作用:将我们编写好的网页发布出去,别人就可以通过网络访问
    - 常见的web服务器
      "名称        厂商            特点
      Weblogic     oracle        大型的收费的支持javaEE所有规范的web服务器(servlet和jsp)
      websphere     ibm            大型的收费的支持javaEE所有规范的web服务器(servlet和jsp)
      tomcat     apache        小型的免费的支持servlet和jsp规范的"web服务器""
    - Tomcat服务器★

        Tomcat如何优化?
            : 优化连接配置.修改连接数,关闭客户端的dns查询(DNS查询需要占用网络，再获取对方ip的时候会消耗一定的时间)
            : 优化jdk,扩大tomcat使用的内存,默认为128M
      - 下载
        - http://tomcat.apache.org/download-70.cgi
        - core:
          - zip:可以在window上运行的(我们今天使用)
          - tar.gz:运行在linux上的
      - 安装
        - 解压缩即可
      - 目录结构
        - bin:存放可执行的文件
        - ★conf:存放配置文件
        - lib:存放的是tomcat运行时和项目运行时必须的jar包
        - logs:存放的是日志文件(catalina.out)
        - temp:存放临时文件(不用管)
        - ★★webapps:存放要发布的web项目
        - ★work:存放项目运行时产生的java文件和class文件
      - 启动
        "    双击 tomcat目录下/bin/startup.bat"
      - 关闭
        "    方式1:点 x
            方式2:ctrl + c
            (记住)方式3:双击 tomcat目录下/bin/shutdown.bat"
      - 配置
        - 常见问题
          - 一闪而过
            "查看JAVA_HOME是否配置正确"
          - 端口占用: 可以修改Tomcat的端口号
            "修改 tomcat目录下/conf/server.xml 大约70行
                             <Connector port="" protocol="HTTP/1.1"
                               connectionTimeout=""
                               redirectPort="" />
                        需要将  修改成其他的端口号
                        端口号:~
                            ~:系统预留的端口号 一般不要使用 但是可以使用80端口
                            80端口是http协议的默认端口号,访问的时候可以不写端口号"
      - 访问格式
        - tomcat的访问路径(8080是tomcat的默认的端口号)
          "    http://localhost:8080"
        - 格式:http://ip地址:端口号/项目名/资源?参数名称=值&参数名称=值
- web项目
  - 目录结构:★
    "myweb(目录名:项目名)
                |
                |---资源文件  html img css js
                |---WEB-INF(目录:特点,通过浏览器直接访问不到)
                |        |
                |        |---lib(目录:项目运行的jar包)
                |        |---classes(目录:存放的class文件)
                |        |---web.xml(核心配置文件,在servlet2.5版本中必须有,serlvet3.0版本不是必须的)"
  - 项目访问路径:
    "http://localhost:80/myweb/1.html
    协议://ip地址:端口/项目名称/资源"
  - Tomcat和Eclipse整合
- Http协议:
  - 协议:规定内容的传输的格式
  - http协议:
    "用来制定互联网上数据的传输格式"
  - 包含:
    - 浏览器发送给服务器的内容  请求
      "规定请求数据的格式"
    - 服务器返回给浏览器的内容  响应
      "规定响应数据的格式"
  - 请求的格式:
    "请求行 请求头 请求体"
    - 请求行:请求的第一行
      - 格式:请求方式 请求资源 协议/版本
        "例如:  GET /33/1.html HTTP/1.1"
      - 请求方式:
        "常见的两种 get和post
        get请求:请求参数会在地址栏上显示,参数大小有限制,不安全
              http://ip地址:端口号/项目名/资源?参数名称=值&参数名称=值
        post请求:请求参数不在地址栏上显示,参数大小不受限制.较为安全
            格式:
                参数名称=值&参数名称=值"
    - 请求头
      - 格式: key/value的格式 (value可以为多个值的)
      - 常见的请求头
        - Accept: text/html,image/*        --支持数据类型
        - Accept-Charset: ISO-8859-1    --字符集
        - Accept-Encoding: gzip        --支持压缩
        - Accept-Language:zh-cn         --语言环境
        - Host: www.baidu.cn:80        --访问主机
        - If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT      --缓存文件的最后修改时间
        - Referer: http://www.baidu.com/index.jsp     --来自哪个页面、防盗链
        - User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)
          "扩展知识:
              Trident内核代表产品Internet Explorer，又称其为IE内核
              Gecko内核代表作品Mozilla FirefoxGecko,火狐
              Chrome内核代表作品Chrome,谷歌"
        - Cookie
        - Connection: close/Keep-Alive       --链接状态
      - 重要的头:
        - Referer  User-Agent Cookie If-Modified-Since
    - 请求体
      "和请求头之间有一个空行
      post请求的参数:只有表单提交的时候明确了method="post"这时候是post请求,其他的都是get请求
      参数名称=值&参数名称=值
      username=jack&password=1234"
  - 响应的格式:
    "响应行 响应头 响应体"
    - 响应行:响应信息的第一行
      - 格式:
        - 协议/版本 响应的状态码 状态码说明
      - 例如:
        - HTTP/1.1 200 OK
      - 状态码:
        - 1xx    :请求已发送
        - 2xx    :响应已完成
          - 200:响应成功(请求成功)
        - 3xx    :需要浏览器进一步操作才可以完成
          - 302:重定向(配合location头使用)
          - 304:读缓存(Not Modified表示没有改变)
        - 4xx :用户访问错误(Not Found 表示:路径写错了,你访问的路径不存在)
          - 404:用户访问的资源不存在
        - 5xx :服务器内部错误(其实就是代码有问题,改代码)
          - 500:服务器内部异常
    - 响应头
      - 格式: key/value的格式 (value可以为多个值的)
      - 常见的响应头
        - Location: http://www.it315.org/index.jsp     --跳转方向
        - Server:apache tomcat            --服务器型号
        - Content-Encoding: gzip             --数据压缩
        - Content-Length: 80             --数据长度
        - Content-Language: zh-cn         --语言环境
        - Content-Type: text/html; charset=GB2312         --数据类型(MIME类型)  大类型/小类型 text/css  text/javascript  image/jpeg image/bmp
        - Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT    --最后修改时间
        - Refresh: 1;url=http://www.it315.org        --定时刷新
        - Content-Disposition: attachment; filename=aaa.zip    --下载
        - Set-Cookie:SS=Q0=5Lb_nQ; path=/search
        - Expires: -1                    --缓存
        - Cache-Control: no-cache              --缓存
        - Pragma: no-cache                   --缓存
        - Connection:Keep-Alive               --连接
      - 重点的头:
        - Set-Cookie Location Content-Type Refresh Content-Disposition Last-Modified
    - 响应体
      "和响应头之间有一个空行,
      浏览器解析的内容"
- servlet入门:
  "本质上就是一个运行在服务器上的类"
  - 作用:1.接受请求   2.调用Service  处理业务逻辑   3.生成响应结果
  - 入门步骤:
    - 1.编写一个类
      - 必须实现Servlet接口
      - 重写里面的方法
    - 2.编写配置文件(项目下 web-inf/web.xml)
      "注册servlet   绑定路径
                  <!-- 注册servlet
                      servlet-name:给servlet起个名称 名称自定义,保证唯一
                      servlet-class:serlvet的全限定名(包名+类名)
                  -->
                  <servlet>
                      <servlet-name>helloservlet</servlet-name>
                      <servlet-class>cn.baidu.demo.HelloServlet</servlet-class>
                  </servlet>

                  <!-- 绑定路径
                      servlet-name:在servlet标签中给servlet起好的名称
                      url-pattern:路径  暂时都以"/"开头
                   -->
                  <servlet-mapping>
                      <servlet-name>helloservlet</servlet-name>
                      <url-pattern>/hello</url-pattern>
                  </servlet-mapping>"
    - 3.测试
      "            localhost/项目名/绑定的路径
                  localhost/33/hello"

在服务器中,为什么需要项目部署?  为了让网络通过服务器访问到项目

回顾:
    tomcat服务器和Http协议:
    web服务器:
        概念:
            web资源:
            web资源分类:
                静态的web资源:内容一层不变
                动态的web资源:根据不同的人和不同的时间,可能会发生变化
            web技术:
                静态的web技术:html css js...
                动态的web技术:Servlet jsp
            结构:
                B/S(浏览器/服务器):
                C/S(客户端/服务器):
            通讯机制:
                基于HTTP协议
                一次请求一次响应,先有请求后有响应
        web服务器:
            Tomcat:
                下载:
                安装:
                目录结构:
                    bin:
                    conf:
                    webapps:
                    work:
                启动:
                    bin/startup.bat
                关闭:
                    X
                    ctrl + c
                    ★ bin/shutdown.bat
                访问:
                    协议://地址:端口/资源
        web项目:
            项目名称:
                |-------html
                |-------css
                |-------js
                |-------img
                |-------WEB-INF
                |-----------lib
                |-----------classes
                |-----------web.xml
        http:
            请求:浏览器发送给服务器的内容(request)
                请求行
                    请求信息的第一行
                        请求方式 请求的资源 协议/版本        http/1.0 http/1.1
                请求头
                    格式:
                        key/value  (value可以为多个值)
                请求体
                    当请求是post的时候,存放post请求所携带的参数
            响应:服务器返回给浏览器的内容(response)
                响应行
                    响应信息的第一行
                        协议/版本 状态码 说明
                响应头
                    格式:
                        key/value  (value可以为多个值)
                响应体
                    浏览器解析的内容
////////////////////////////////////////////
servlet:

案例-使用servlet完成用户登录功能
    需求分析:
        用户在表单中填写完用户名和密码后,点击登录的时候,向服务器发送登录的请求,
        在服务器上处理请求,处理完毕后将处理信息响应到页面
            处理结果:
                登录成功:欢迎...登录...
                登录失败:用户名或密码错误
                异常:当前功能正在维护....
        技术分析:
            html:表单
                form
                    action:提交路径
                    method:提交方式
                        get
                        post
            servlet:
                request
                response
    ////////////////
    项目:
        com.baidu.web
        com.baidu.service
        com.baidu.dao
        com.baidu.domain
        com.baidu.utils

        导入jar包
        导入工具类
- Servlet的概述
  - Servlet就是运行在web服务器上的java程序，本质上就是一个类.
    "一个类要想通过浏览器被访问到,那么这个类就必须直接或间接的实现Servlet接口"
  - 作用:
    - 接收浏览器的请求
    - 处理请求
    - 生成响应信息
- Servlet入门★
  - 1.编写一个类
    "    实现servlet接口
        重写Service(request,response)方法"
  - 2.编写配置文件(web.xml)
    "    注册servlet
        绑定路径"
  - 3.测试
    "    http://localhost:8080/项目名称/绑定路径"
- Servlet API
  "查询javaEE的API"
  - Servlet:接口
    - (掌握★)init:初始化(第一次访问Servlet的实现类时候进行初始化,也就是说开启实现Servlet类和继承Servlet类的实现类,或者说是开启继承Servlet类的实现类和Servlet类的实现类)
    - (掌握★)service:提供服务(每次访问都执行都提供服务)
    - (掌握★)destroy:销毁(Servlet开启后,调用这个方法就是关闭或者销毁继承类)(服务器正常关闭,会把每一个servlet都给销毁了.(销毁的是Servlet的对象,也就是实现类的对象))
    - (理解)getServletConfig():获取当前Servlet的配置对象
    - (了解)getServletInfo():获取Servlet信息
  - GenericServlet:(通用Servlet)
    "实现了servlet接口的抽象类,
    实现servlet中除service方法之外的所有方法"
  - HttpServlet:
    "继承GenericServlet,实现了Servlet的所有方法."
- Servlet的生命周期★
  "从创建到死亡的过程"
  - init:初始化
  - service:提供服务
  - destroy:销毁
  - 面试题总结:
    "当浏览器第一次访问该servlet的时候,服务器会给我们创建该servlet的对象,并调用init()方法进行初始化,init()方法执行完毕后service方法会跟着执行.
    以后再访问该servlet的时候,服务器不会给我们创建该servlet的对象,也不会调用init()方法进行初始化,但是会调用service()方法给我们提供服务,并且是访问一次调用一次.
    当服务器正常关闭的时候或项目从服务器中移除的时候,服务器会的调用destroy()方法,将该servlet的对象销毁
    ★: 不论访问多少次只有一个servlet对象"
    这个servlet是一个单实例,多线程的.
package com.baidu_02;

import java.io.IOException;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ServletDemo implements Servlet{

    /*
     * 初始化:init
     * 调用者:tomcat服务器
     * 执行时机:servlet第一次访问的时候
     * 执行次数:1次
     */
    public void init(ServletConfig config) throws ServletException {
        System.out.println("ServletLife 的init方法执行了, ServletLife出生了...55555");
    }
    //提供服务的service
//        调用者:tomcat服务器
//          执行时机:每次访问的时候
//         执行次数:访问一次执行一次
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("ServletLife 的service方法执行了,为您提供服务...66666");
    }

//销毁:destroy
//    调用者:tomcat服务器
//     执行时机:服务器正常关闭和项目从服务器移除
//     执行次数:1次
    //分为两种,一种是正常销毁,另一种是不正常销毁,正常服务器死亡销毁例如在Servers窗口点击了红色按钮.另一种是不正常服务器死亡销毁了,比如宕机就是断电,或者在Console点击了红色按钮(服务器就是死掉了,后面的也就不执行了)
    public void destroy() {
        System.out.println("ServletLife 的destory方法执行了...死亡了...44444444");
    }

    /*
     * 获取当前的Servlet的配置信息(web.xml中配置信息)
     */
    public ServletConfig getServletConfig() {

        return null;
    }

    /*
     * 当前servlet的基本信息
     */
    @Override
    public String getServletInfo() {

        return null;
    }

}

- Servlet配置:
  - servlet标签:(注册Servlet)
    - servlet-name:给Servlet起名称
    - servlet-class:Servlet全限定名(包名+类名)
  - servlet-mapping标签:(绑定路径)
    - servlet-name:已经注册好的Servlet名称
    - url-pattern:
      - .完全匹配: /a/b/hello      以"/"开始
      - .目录匹配: /a/*               以"/"开始,以"*"结尾
      - 3.后缀名匹配:  .jsp   .action    以"."开始,匹配后缀名
      - 注意事项:
        "一个路径只能对应一个servlet,
        一个servlet可以对应多个路径"
  - Tomcat的web.xml文件(了解)
    "作用:处理其他servlet都处理不了的请求"
    - DefaultServlet 在tomcat的conf/web.xml中配置的
      "我们项目的web.xml配置文件优先匹对,匹对不上再找Tomcat的web.xml"
  - servlet中的其他标签:
    - init-param(了解):配置servlet的初始化参数的
      "<init-param>
              <param-name>Str</param-name>
              <param-value>tom123</param-value>
          </init-param>"
    - load-on-startup:修改servlet的初始化时机的
      "<load-on-startup>正整数</load-on-startup>
      设置servlet的初始化时机,随着服务器的启动而初始化.
      数字越小初始化的优先级越高"
  - 路径:
    - 相对路径(很少使用,了解即可)
      - ./ 当前目录下  ./也可以省略不写
      - ../ 上一级目录
    - 绝对路径
      - 带协议和主机的绝对路径(访问站外资源)
        "http://localhost:80/34/js/jquery-1.11.3.min.js"
      - 不带协议和主机的绝对路径(访问站内资源)
        "/34/js/jquery-1.11.3.min.js"
  - 访问项目时,设置默认首页
    - 在web.xml中 通过welcome-file-list标签设置的(可以删除)
      "访问的时候直接写项目名称,就可以访问到默认设置的资源"
  - ServletConfig(了解)
    "Servlet的配置对象"
    - 作用:
      "获取Servlet的名称
      获取Servlet的初始化参数
      获取上下文对象(全局管理者ServletContext)"
    - 创建
      "    服务创建Servlet的同时,也创建了Servlet的配置对象,通过Servlet的init方法传递给Servlet."
    - 获取:
      "通过 getServletConfig方法获取即可"
    - 常见的方法:
      - 获取servlet的名称(注册到tomcat的名称)
        "String getServletName()"
      - 获取serlvet的初始化参数
        "String getInitParameter(String name)"
      - 获取上下文(全局管理者ServletContext)
        "ServletContext getServletContext()"

/*

/*

案例1-统计CountServlet被访问的次数
    需求分析:
        服务器上有一个CountServlet,要统计CountServlet被访问的次数.通过调用ShowServlet展示CountServlet被访问的次数
    技术分析:
        ServletContext对象

案例2-文件下载
    需求分析:
        将服务器上的文件保存到本地
    技术分析:
        Response
    步骤分析:
        //设置两个头
            //设置文件的类型
              response.setContentType(文件mime类型);
            //设置文件下载专用头
              response.setHeader("content-disposition","attachment;filename="+文件名称);

            //设置一个流
             输出流

案例3-点击切换验证码
    作用:
        防止暴力破解

- ServletContext:
  "上下文对象,全局管理者,知晓一个项目中所有Servlet的一切信息"
  - 作用:
    "获取全局的初始化参数
    获取文件的mime类型
    资源共享
    获取资源的路径"
  - 生命周期
    - 创建:当服务器启动的时候,服务器会为每一个项目创建servletcontext对象,一个项目只有一个servletcontext对象
    - 销毁:项目从服务器上移除或者服务器正常关闭的时候
  - 获取方式
    - 方式1:通过ServletConfig对象获取
      "ServletContext ServletConfig().getServletContext();"
    - 方式2:通过getServletContext方法获取
      "ServletContext getServletContext();"
  - 常用方法:
    - (理解)获取指定的项目初始化参数
      "String getInitParameter(String name)"
    - (了解)获取项目所有初始化参数名称
      "Enumeration getInitParameterNames()"
    - (掌握)获取一个文件的mime类型
      "String getMimeType(String 文件名)"
    - (掌握)资源共享: 相当于一个map集合
      - setAttribute(String name,Object value):设置
      - getAttribute(String name):获取指定的属性值
      - removeAttribute(String name):移除指定的属性
    - (掌握)获取资源在服务器上的路径
      "String getRealPath(String filepath)
      注意:
          filepath:直接从项目的根目录开始写
          getRealPath("/")  ---> d:/tomcat/webapps/14"
    - (理解)以流的方式返回一个文件
      "InputStream getResourceAsStream(String filepath)"
- response
  "设置服务器发送给浏览器的内容"
  - 操作响应行
    "格式:
        协议/版本  状态码  状态说明
    状态码分类:
        1xx:已发送请求
        2xx:响应完成
            200:正常完成响应
        3xx:还需浏览器进一步操作
            302:重定向 配合响应头location使用
            304:读缓存
        4xx:用户操作错误
            404:用户访问的资源不存在
        5xx:服务器错误
            500:程序异常"
    - 常用方法
      - (理解)setStatus(int code):针对1   2   3
      - (了解)sendError(int code):针对 4   5
  - 操作响应头
    "格式:
        key/value形式(value可以为多个值)"
    - 常用方法
      - (重点)setHeader(String name,String value);
        "设置一个字符串形式的响应头"
      - 了解:
        "setIntHeader(String name,int value);设置一个整型的响应头
        setDateHeader(String name,long value);设置一个时间的响应头
        追加:
        addHeader(String name,String value):追加一个字符串形式的响应头 若无设置则设置,若已设置则追加
        addIntHeader(String name,int value);追加一个整型的响应头
        addDateHeader(String name,long value);追加一个时间的响应头
        "
    - 常见的响应头
      - location:重定向
        "需要配合302状态码一起使用"
        - 方式1(了解):
          "response.setStatus(302);
          response.setHeader("location","路径");"
        - 方式2(掌握):
          "response.sendRedirect("路径");"
      - refresh:定时刷新
        - java中(使用比较少)
          "response.setHeader("refresh","秒数;url=跳转的路径"); 几秒之后跳转到指定的路径上"
        - html中
          "<meta http-equiv="refresh" content="3;url=/14/2.html">"
      - content-type:设置文件的mime类型
      //tomcat传递方式都是以iso-8859-1编码传递的
        "设置文件的mime类型 并且通知浏览器用什么编码打开"
        - 方式1(了解):
          "格式:
              response.setHeader("content-type","mime类型;charset=编码");"
        - 方式2(掌握):
          "response.setContentType("文件的mime类型;charset=utf-8");"
      - content-disposition:文件下载专用头
        "response.setHeader("content-disposition","attachment;filename="+文件名称);"
  - 操作响应体
    "页面上需要解析的内容"
    - 常用方法:
      - PrintWriter getWriter():字符流
      - ServletOutputStream getOutputStream():字节流
      - 注意事项:
        "自己编写的文件   一般都使用字符流输出 如:txt  html等
        音频,视频等文件使用字节流输出
        字节流和字符流互斥,不能同时使用
        服务器会帮我们释放资源,建议自己关闭;底层使用的缓存流
        "

HTTP & Tomcat

    1. web服务器

        web资源：通过网络可以访问到的资源，通常指放在服务器上的文件

            1. 静态web资源：

                内容是一成不变的

            2. 动态web资源：

                内容有可能随着访问时间和人不同而发生改变

            3. 静态web技术：

                html css js

            4. 动态web技术：

                servlet jsp

        软件架构：

            1. c/s架构（Client/Server 客户端/服务器）

            2. b/s架构（Browser/Server 浏览器/服务器）

        通讯机制：

            1. 基于http协议

                浏览器发送给服务器的内容：请求（request）

                服务器返回给浏览器的内容：响应（response）

                注意：先有请求，后有响应，一次请求对应一次响应

        web服务器：

            常见的web服务器

            Weblogic    oracle        大型收费支持javaEE所有规范的web服务器（servlet和jsp）

            websphere    ibm        大型收费支持javaEE所有规范的web服务器（servlet和jsp）

            tomcat        apache        小型免费支持servlet和jsp规范的web服务器

        Tomcat服务器

            下载

                http://tomcat.apache.org/download-70.cgi

                zip 可以在windows上使用

                tar.gz 运行在linux上

            目录结构

                bin:    存放可执行的文件

                conf:    存放配置文件

                lib:    存放的是tomcat运行时和项目运行时必须的jar包

                logs:    存放的是日志文件

                temp:    临时文件

                webapps:    需要发布的项目放在这

                work:    存放项目运行时产生的java和class文件

            启动tomcat

                运行tomcat目录下 /bin/startup.bat

            关闭tomcat

                1. 直接关闭

                2. 运行 /bin/shutdown.bat

            tomcat配置：

                修改tomcat端口号：

                /conf/server.xml 大约70行

                <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"

                   redirectPort="8443" />

                （0-1024是系统预留的端口号，一般不要使用，但是可以使用90端口，

                80端口是http协议的默认端口号，访问的时候可以不写端口号）

            访问格式：

                http://localhost:8080

                http://ip:端口号/项目名/资源?参数名=值&参数名=值

        Http协议：

            协议：规定内容的传输的格式

            http协议：规定互联网上数据的传输的格式

            请求：

            响应：

                状态码：

                    1xx: 请求已经成功发送

                    2xx: 响应已经完成

                        200：响应成功（请求成功）

                    3xx: 需要浏览器进一步操作才可以完成

                        302：重定向（配合location头使用）

                        304: 读缓存

                    4xx：用户访问错误

                        404：用户访问的资源不存在

                    5xx：服务器内部错误

                        500：服务器内部异常

        Eclipse上配置Tomcat：

            1. Window --> Preference --> 搜索server --> 选择Runtime Environments

            2. 将tomcat安装地址，添加到Server Runtime Environments列表中

            3. 创建一个动态 web project，在servers窗口中添加你的tomcat服务器

            4. 在servers窗口双击服务器，

                1. 配置项目工作空间，2. 选择部署路径

                添加项目，开启服务器

Servlet:

    一个类如果想要被（浏览器）访问到，就必须直接或者间接的实现Servlet接口

    作用：

        1. 接受浏览器的请求

        2. 处理请求

        3. 生成响应信息

    入门使用：

        1. 编写一个类

            实现servlet接口

            重写Service(request, response)方法

        2. 编写配置文件（web.xml）

            将访问路径与java类绑定起来

        3. 测试

            http://192.xxx.xxx.xx:8888/项目名/路径名

    Servlet API

        Servlet接口：

            init() -- 初始化时

            service()

            destory() -- 销毁时（正常关闭服务器或者删除项目）

            getServletConfig() -- 获取当前Servlet的配置对象

            getServletInfo() -- 获取Servlet信息

        GenericServlet（抽象类，继承Servlet）

            实现了出了service方法外的所有方法

        HttpServlet（也是抽象类）:

            继承了GenericService实现了所有Servlet的方法

        方法详细说明：

            根据反射，利用xml文件创建servlet对象，创建三个参数对象：

            request response servletconfig

            初始化方法：init方法中，利用this.config = config，为全局变量赋值

            getServletConfig() 方法就是获取私有全局变量的方法

            servletConfig对象就是配置文件信息对象，可以获取web.xml中信息

            （可以获取到web.xml中自定义的key value 参数）

            HttpServlet中的service方法：

                String method = reg.getMethod();

                if(method == "get"){

                    doGet(request, response);

                } else if (method == "post"){

                    doPost(resquest, response);

                }

    Servlet的生命周期：

        当浏览器第一次访问该servlet的时候,服务器会给我们创建该servlet的对象,

        并调用inizgt()方法进行初始化,init()方法执行完毕后service方法会跟着执行.

        以后再访问该servlet的时候,服务器不会给我们创建该servlet的对象,

        也不会调用init()方法进行初始化,但是会调用service()方法给我们提供服务,

        并且是访问一次调用一次.

        当服务器正常关闭的时候或则项目从服务器中移除的时候,

        服务器会的调用destroy()方法,将该servlet的对象销毁

        ★: 不论访问多少次只有一个servlet对象

        ServletConfig:

            1. 封装了servlet的配置信息，一个servlet有一个ServletConfig

            2. Servlet创建时，会调用有参init方法，创建ServletConfig（再调用无参init）

                拿到ServletConfig对象：getServletConfig();

            3. 作用：

                1. 拿到web.xml中的servlet的名字：<servlet-name></servlet-name>

                2. 拿到web.xml中该servlet自定义参数标签中的值（根据键）

                    <init-param>
                        <param-name>name</param-name>
                        <param-value>value</param-value>
                    </init-param>

                    String value = config.getInitParameter("name");

                3. 拿到ServletContext对象

                    config.getServletContext();

        ServletContext:

            1. 封装了整个web应用信息，一个项目有一个ServletContext

            2. 获取ServletContext对象：

                直接：this.getServletContext();

                public ServletContext getServletContext(){

                    return getServletConfig().getServletContext();

                }

            3. 作用：

                1. 获取整个web应用的全局初始化参数

                    String value = context.getInitParameter("name");

                    web.xml中：

                    <context-param>

                        <param-name>name</param-name>

                        <param-value>tom</param-value>

                    </context-param>

                2. 存储数据：ServletContext是一个域对象

                    所有servlet都可以将数据存进去，共同使用

                    存、取、删：

                    setAttribute(name,value);  String,Object

                    getAttribute(name);    String

                    removeAttribute(name);    String

        Response:

            设置服务器发送给浏览器的内容

            1. 操作响应行：

                格式： 协议/版本  状态码  状态说明

                状态码分类：

                    1xx：已发送请求

                    2xx：响应完成

                        200：正常完成响应

                    3xx：还需要浏览器进一步操作

                        302：重定向，配合响应头中的location使用

                        304：读缓存

                    4xx：用户操作错误

                        404：用户访问的资源不存在

                    5xx：服务器错误

                        500：程序异常

                方法：

                    setStatus(int code)针对 1 2 3

                    sendError(int code) 针对 4 5

            2. 操作响应头：

                格式：  key/value

                方法：

                    setHeader(String name, String value);

                其他方法：

                    setIntHeader(String name, int value);
                    setDataHeader(String name, long value);
                    addHeader(String name, String value);没有就设置，有就追加
                    addIntHeader(String name, int value);
                    addDateHeader(String name, long value);

                常见的响应头：

                    1. location：重定向

                        让浏览器重新访问其他服务器资源

                        （算是重新访问，地址栏跟新）

                        操作响应内容：需要同时配合302状态码使用

                        response.setStatus(302);
                        response.setHeader("location","路径");

                        简便、常用使用方法：

                        response.sendRedirect("路径");

                    2. refresh：定时刷新

                        java：（少）

                        response.setHeader("refresh","秒数;url=");

                        html：

                        <meta http-equiv="refresh" content="3;url=路径">

                    3. content-type：设置文件类型

                        设置文件类型，并通知浏览器用什么编码打开

                        常见互联网媒体类型（MIME类型）

                            text/html ： HTML格式

                            text/plain ：纯文本格式 

                            text/xml ：  XML格式

                               image/gif ：gif图片格式 

                            image/jpeg ：jpg图片格式

                            image/png：png图片格式

                response.setHeader("content-type","text/html;charset=utf-8");

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

                    PS：中文乱码原因

                    http协议响应头不支持中文，同一采用ISO-8859-1编码

                    浏览器：火狐、谷歌采用 UTF-8  IE采用GBK

                    文件下载 --> 经过响应头（文字 --> ISO字节）--> 客户端

                    文件上传 --> 经过响应头（字节 --> ISO文字）--> 服务端

                    待商议

                    4. 文件下载

                    步骤：

                        1. 获取前端传来的文件名

                        2. 根据文件名，使用ServletContext对象

        response.setHeader("content-disposition","attachment;filename="+文件名称);

                    下载之前要将文件名字反编码成 ISO-8859-1 文字

                    传送到头文件中，头文件按照ISO解码，发送给浏览器

                    火狐、谷歌将字节编码成UTF-8显示，IE编码成GBK

    PS:

    1. 发送get请求，参数中空格处理：

处理方式1：

http://baidu.com?name=han&content=hello world

url = “http://baidu.com?name=han&content=”+URLEncoder.encode（“hello world”，“utf-8”）； 

    2. 文件下载中，在响应头中设置的文件名里面包含空格，使下载文件时无法获取空格之后的文件名

    处理方式：

        设置响应头时，使用双引号将文件名括起来

        response.setHeader("content-disposition", "attachment;filename=\""+name+"\"");

        request:

            请求行 请求头 请求体

            requestAPI：

                request.getMethod()    获取请求方式

                request.getContextPath()    获取本项目名

                request.getServletPath()    获取本servlet名

                request.RemoteAddr()    获取客户IP地址

            请求头：

                获取头信息

                    request.getHeader(String name)

            请求体：

                请求体中包含了请求携带的参数

                get方式没有请求体，post有

                获取参数的方法：

                request.getParameter(String name); String 

                    根据参数名获取参数值

                request.getParameterValues(String name); String[]

                    根据参数名获取一组参数值（checkbox）

                request.getParameterMap(); Map(String name, String[] values)

                    获取表单提交上来的所有参数值，以name为键，

                    存放在Map中（可以配合BeanUtils使用，使用populate方法，

                    直接给Bean对象赋值）

            获取中文参数乱码：

                接受到http流传送来的中文，需要手动处理乱码

                以ISO格式将乱码解码，在按照想要的格式重新编码

                若是post请求，参数在请求体中，可以直接使用api让tomcat处理

                get:

                    new String(str.getBytes("iso-8859-1"),"utf-8");

                post:

                    request.setCharacterEncoding("utf-8")

            页面、后台跳转方式：请求转发

                请求转发：

                    并不以向浏览器发送响应信息作为本次请求的结束，

                    而是将同一个request对象继续传送到下一个页面、后台程序

                    中去，一直使用客户方发送的第一个请求。

                使用：

                request.getRequestDispatcher("路径").forward(request, response)

                特点：

                    1. 地址栏访问地址不变，一直是第一次请求时的访问地址

                    2. 一直使用同一个request对象，可以使用request对象传递数据

                    3. 每次跳转都视为服务器内部跳转，相对路径为本服务器地址内

                       每次跳转之后相对路径都会变为服务器根目录，不是某个页面

                       或程序（路径需要从项目名写起）

                重定向（sendRedirect）的不同点：

                    1. 地址栏每次跳转都改变，显示最新访问的路径

                    2. request每次跳转都会结束生命周期，不可使用它来传参

                    3. 可以访问服务器之外的资源（跳转到其他ip地址）

简单来说，如果只是返回页面，不关乎地址问题，那就转发

如果需要进行下一步业务操作，从而需要改变地址，那就重定向吧

重定向时的网址可以是任何网址
　　转发的网址必须是本站点的网址
重定向与请求转发使用
前后两个页面 有数据传递 用请求转发，没有则用重定向。
比如servlet查询了数据需要在页面显示，就用请求转发。
比如servlet做了update操作跳转到其他页面，就用重定向。    

回顾:

Request
    行
        获得请求方式 : request.getMethod();
        获得项目名称 : request.getContextPath()
        获得资源名称 : request.getServletPath()
        获得远程主机的地址: request.getRemoteAddr()
    头
        Request.getHeader(name) : 根据名称获得一个指定的头信息
    体(请求参数)
        Request.getParameter(name) : 根据名称获得一个指定的value
        Request.getParameterValues(name) : 根据名称获得一组指定的value
        Request.getParameterMap() : 获得所有的表单中键值对
    请求转发:
       request.getRequestDispatcher("路径").forward(request.response)
    重定向:
        request.sendRedirect("路径")
    乱码处理
        Get
            new String(乱码.getBytes(iso-8859-1),"编码");
        Post
            Request.setCharacterEncoding(编码)   通知tomcat处理
            response.setHeader("content-type","text/html;charset=utf-8")