Servlet_jp笔记(完整)

web阶段
    html/css 静态网页 。file://打开html的本地网页
    Servlet 动态网页。http://172.16.9.8:8088/Hello/hello.html

web开发(企业级开发):访问网络上的html网页?
servlet?开发动态网页
动态网页和静态网页？

一:应用开发框架

C/S:客户端/服务器端
   优点：安全性高（客户端分担服务器端的功能(QQ客户端的聊天记录)）

   缺点：必须安装客户端（开发开销大）、 维护困难（不能无缝升级）

B/S:浏览器/服务器端(主流的企业级开发模式，只需要浏览器，网上银行)
   优点：不需要安装客户端，浏览器就是客户端（开发的开销小） 、维护方便（实现无缝升级）
   缺点：安全性不高、服务器端硬件要求高（服务器端的操作将会是软件的核心----->压力(并发，效率，网络传输)   如：网上售票系统）
    
                  

二：web应用

    互联网(internet)：连接全球计算机资源的网络环境，可以资源共享，通信,发送邮件等。基于TCP/IP协议：四层协议
           应用层：http,ftp,pop,file...             传输层:UDP,TCP

           网络层:ip                                         数据链路层

    万维网：www World Wide Web是互联网提供的一种服务， 基于http协议。
    web应用:就是一种万维网

J2EE  JavaEE: Servlet,JSP,Spring,Strut2,SpingMVC

三：Servlet

3.1  CGI公共网关接口

   a)早期开发动态网页，也是web开发的一门技术.
   b)CGI每次都会启动一个 进程来处理客户端发送的request,然后给客户端返回处理之后的response，即生成动态html网页，但是效率比较低。
   c)基于http协议，
   d)可以用多种语言开发。C,TCL,Prel...

3.2  Servlet

   a)代替CGI,用来开发动态网页
   b)Servlet每次都会启动一个 线程来处理客户端发送的request,然后给客户端返回处理之后的response，即生成动态html网页，效率比较高。
   c)基于http协议
   d)使用Java语言编写
   e)简单的定义:servlet是运行在服务器端的java类；servlet是j2ee的一套技术标准，一套api。在2个包中：javax.servlet.*和javax.servlet.http.*
   f)专业的定义：servlet是运行在服务器端的一个web组件。（组件：用少量的代码完成一个功能。web组件：用少量的代码完成一个与 用户请求有关的功能(比如用户注册，登录...)）   
   g)servlet的缩写:Server applet

四：web Server(web服务器，应用服务器)

服务器:一台主机，安装相关软件

web服务器:必须安装可以接受基于Http协议的请求,并且可以处理该请求，最后返回响应给客户端的软件。

软件(web容器)：常见的web容器
        Tomcat:由Apache提供的开源免费的软件
        微软公司提供IIS：ASP.NET
        商业的ejb容器： WebLogic（BEA公司所有）、WebSphere（IBM公司所有）

    客户端---->web服务器--->web应用

五：Tomcat

  bin:存放tomcat可执行的文件(启动或者关闭tomcat)
  conf:存放tomcat的配置文件
  lib:存放tomcat本身软件运行需要的jar包和部署到tomcat上的其他web应用需要的jar包。
 logs:存放tomcat的日志文件
  temp:存放临时文件
  webapps:存放部署到tomcat上的web应用
  work:存放jsp相关的servlet的文件
 
配置环境变量：CATALINA_HOME:
                            JAVA_HOME:

                           path:前加上 %CATALINA_HOME%\bin;

启动startup.bat
http://localhost:8088
http://localhost:8088/tomcat.gif

六：手动的编写servlet

6.1  web应用部署到web服务器上的结构.

  可以不需要src的源文件目录。
     ---web应用的工程名(MyServlet)    
         ---WEB-INF
          ---classes 存放字节码文件
          ---lib     存放jar包
          ---web.xml  对servlet,filter
                   ,listener的描述
      ---*.html
      ---*.js
      ---*.css
      ---image
      ---*.jsp

6.2  编写一个Servlet类

   1)extends HttpServlet,然后重写service()方法

6.3  在web.xml描述servlet

<web-app>
      <servlet>
                // 给servlet取名字，该名字任意。在一个web.xml文件中每个servlet的名字必须唯一
           <servlet-name>first</servlet-name>
               //指定该servlet的类名(全名)
         <servlet-class>com.briup.basic.HelloWorld</servlet-class>
     </servlet>
     <servlet-mapping>
            //根据Servlet名字映射出servlet
           <servlet-name>first</servlet-name>
           //为servlet指明路径（/+路径名），虚拟路径/a/b或者/a/b/c
           <url-pattern>/first</url-pattern>
     </servlet-mapping>
</web-app>

6.4  http://localhost:8088/Servlet/first

http:// 指定访问数据的http协议
localhost 指定服务器的ip地址:127.0.0.1
8088  指定web容器(Tomcat)的端口号
http://localhost:8088 ：访问web服务器 tomcat
/Servlet 指定部署到tomcat上web应用的路径
/first :代表servlet的路径( 在web.xml文件中url-pattern的内容)
  http的 状态码404：代表资源可不用

6.5  web应用的执行流程

     发送请求--->找servlet--->返回请求
   1）打开浏览器，输入地址按回车健后，发送一个基于http请求的request(浏览器)
   2）该请求被对应的web服务器中的web容器接受到， web容器在webapps下找对应的web应用，如果找到对应的web应用，会自动加载该web应用中的web.xml文件。找对应的url-pattern标签--->servlet-name标签(servlet-mapping)------>servlet-name标签(servlet标签中的)----->servlet-class标签。如果找到对应的Serlvet,然后启动线程调用该Servlet的service方法来处理请求。service方法将输出流通过web容器包装成response返回客户端。
   3）如果资源(web应用或者servlet资源)不存在,直接返回404的错误给客户端，代表该资源不存在。
   http协议的状态码
      404  资源找不到                             200  oK
      500  Java程序内部异常                405  重写方法不当
注意： Servlet是单例模式。如果是第一次加载该Servlet,容器会将该serlvet加载到虚拟机并初始化；如果第二次调用该servlet,容器不会加载并且不会初始化一个新的servlet.而是调用原有servlet的service方法来处理请求。

七：将tomcat集成到java EE版本的eclipse中

        ①点击Window--show View---Other---输出Servers进行过滤；

        ②选中Services,点击Ok；

        ③在该Services窗口中新建一个新的Server.；

       ④双击新建的Server进行配置，修改web应用保存的位置；

       ⑤鼠标右击启动Server,打开浏览器访问Tomcat.

新建Dynamic Web Project工程。
新建package,新建class,编写Servlet,配置Servlet

八：创建servlet的步骤

8.1   编写servlet

    a.继承 javax.servlet.http.HttpServlet，重写doGet,doPost的方法，先找到public service方法， ---找protected service， --找doPost,doGet...
    b.继承 javax.servlet.GenericServlet，重写service方法
    c.实现 javax.servlet.Servlet  ，重写5个方法，service方法是重点
 服务方法：Servlet接口中service方法才是服务方法

8.2  在web.xml配置servlet

interface Servlet
   ---abstract class GenericServlet
       ---abstract class  HttpServlet

http://localhost:8888/jd1713_Servlet/second

public service(ServletRequest req, ServletResponse res) {
    HttpReservletRequest r=(HttpReservletRequest)req;
    HttpReservletResponse s=(HttpReservletResponse)res;
    service(r,s)
}

ImageServlet/输出图片

image/jpeg

九  表单的处理

9.1 提交方式：一共有7种提交方式

   <form method="" action=""></form>
       action:表单提交后的走向(地址)
       method:修改表单提交的方式
 1)get
    将数据放在协议的头部，可以在浏览器的地址栏中看到。安全性不高，但是及时响应快；提交少量的数据，最多提交256个字符。格式：地址?key=value&key1=value1...
 2)post
   将数据放在协议的体部，不可以在浏览器的地址栏中看到。安全性比较高；提交大量数据，但是及时响应慢。明确指明method为post,才是post提交，否则其他的方式都是get方式提交。

9.2乱码问题

  原则：字符从编写到显示采用同一种编码方式。UTF-8  GBK  GB2312
  1)控制字符编写的编码  
    工程右击--->properties--->Resource--->Text File Encoding---->GBK,UTF-8
  2)数据传输的乱码
     a)request出现乱码
       ①当使用post提交数据，设置request.setCharacterEncoding("GBK");
     ②当使用get提交数据,还需要修改配置文件:修改tomcat的配置文件，在server.xml中之前修改端口号的标签中添加URIEncoding="GBK"（65行左右）     
     b)response出现乱码
       设置response.setCharacterEncoding("GBK");
  3)浏览器显示的乱码
    浏览器设置显示编码
  4)数据库中的乱码
     存的时候用什么编码，取的时候就用什么编码

9.3 路径问题

  1)相对路径
     相当点：当前访问的资源路径(看浏览器的地址)
  2)绝对路径
     相当点:/ 以/开头的路径
        /在web应用的前台代表是tomcat的路径（即：http://localhost:8888），如:html
        /在web应用的后台是web应用的路径（即：http://localhost:8888/web应用），如:servlet

9.4 跳转问题

  9.1 服务器内部跳转:请求分发跳转.
  特点:      a)是同一个请求                       b)能够获取请求的数据
               c)浏览器的地址不会发生改变    d)不能够访问其他应用程序的资源
     需要两步：
      第一步：获取转发器RequestDispatcher
        a)方式1：从request中获取转发器：request.getRequestDispatcher(path);参数可以相对路径也可以绝对路径
        b)方式2：从ServeltContext上下文获取转发器：getServletContext().getRequestDispatcher(path)参数必须是绝对路径
      第二步:进行跳转
       a)forward:会清空前一个response输出流中的信息
       b)include:不会清空前一个response输出流中的信息，并且保存到跳转页面中输出。
  9.2 重定向跳转：服务器外部跳转
     response.sendRedirect(path)；path可以是相对路径也可以是绝对路径。
      特点:    a)不是同一个请求，发送了两次请求     b)不能够获取请求的数据
                 c)浏览器的地址会发生改变                   d)能够访问其他应用程序的资源。
        如:http://www.baidu.com


例子：注册----》成功success.html
                 ----》失败fail.html

第三章：Servlet的生命周期

一：Servlet的生命周期由web容器来管理

第一个阶段：加载和实例化对象 只调用一次
     默认情况下第一次访问该Servlet的时候，由web容器将.class加载虚拟机，然后调用构造方法来实例化该对象。第二次访问该Servlet不会创建新的对象， 所以Servlet是单例模式。
   加载方式：
      a)延迟加载 （默认）：当第一次访问的时候加载该对象
      b)预先加载 ：当tomcat启动的时候加载该对象
   修改加载方式：web.xml指定Servlet的加载模式
        在Servlet标签中添加:
     <load-on-startup>num</load-on-startup>
     num>=0预先加载
       num越小越先加载
     num<0延迟加载
     num默认是-1

第二个阶段：初始化对象  只调用一次
    加载和实例化对象之后就调用init()
    初始化参数 init()
    传参数：web.xml
       局部参数：针对于一个Servlet： <init-param>
       全局参数：针对于所有的Servlet：<context-param>    
    如：Enumeration<String> en=config.getInitParameterNames();
        while(en.hasMoreElements()){
        String key=en.nextElement();
        String value=config.getInitParameter(key);
        }

第三个阶段：处理请求：服务方法  调用多次
     调用service()： 每一个请求来了，启动线程调用该方法处理请求。Servlet对象只有一个，属于单例模式。
     Servlet线程不安全. 如何控制：
        a）加锁synchronized (this) {}     效率低
        b）把一些受影响的变量尽量定义成局部变量。局部变量是多线程不共享的变量。

第四个阶段：销毁对象 只调用一次
     调用destory(）：当tomcat正常关闭或者当web应用重新部署的时候会销毁对象。

二：Servlet接口中的方法(共有五个方法)

//初始化servlet对象的时候被调用
void     init(ServletConfig config)

//销毁servlet对象的时候被调用
void     destroy()

//访问servlet对象的时候被调用
void     service(ServletRequest req, ServletResponse res)

//返回servlet相关信息,比如作者、版本、版权等；父类中(GenericServlet)默认返回一个空字符串 ""；如果需要的话,程序员可以自己重写这个方法
String     getServletInfo()

//返回ServletConfig对象
ServletConfig     getServletConfig()

三：ServletConfig接口中的方法(共有四个方法)

ServletConfig接口的实现类对象,表示一个servlet在web.xml文件中的配置信息

//返回servlet在web.xml文件中所配置的名字，也就是<servlet-name>这个标签中的值
String     getServletName()

//获得在web.xml中所配置的指定名字的参数值，在web.xml可以通过<init-param>标签给servlet传参
String     getInitParameter(String name)

//获得给当前servlet传的所有参数的名字
Enumeration     getInitParameterNames()

//获得ServletContext类型对象，ServletContext是web项目中非常重要的一个类型对象
ServletContext     getServletContext()

第四章：数据库访问

web应用访问数据库的方式：有两种方式

4.1  JDBC的方式获取Connection。

  但是每次都需要打开和关闭连接，效率很低。连接能一直打开，需要的时候取出来，不需要的时候由服务器保存维护。
 获取src下的配置文件的方式：获取类加载器获取文件。
  Properties p=new Properties();
  InputStream in = ConnectionFactory.class.getClassLoader().getResourceAsStream("jdbc.properties");
  p.load(in);

4.2  连接池

  可以依照tomcat中webapps下的docs文件中
    jndi-resources-howto.html和 jndi-datasource-examples-howto.html配置连接池
 

4.3  mybatis的配置

4.4  web项目的三层架构

    web项目的后台代码,整体上分成了三层
    web层
        主要是servlet
        1.接收客户端传过来的数据
        2.把数据封装成pojo/bean对象
        3.把对象交给service进行业务处理
        4.根据service业务处理的结果来决定返回什么样的界面给用户

    service层
        service层接口以及service层接口的实现类
        1.根据web层传过来的对象/数据进行业务逻辑处理
        2.在处理业务逻辑的时候,经常需要和数据库进行交互,这时候需要借助dao层对象的方法来完成
        3.根据dao层方法在数据库中的交互结果,service层就可以判断出当前这个功能是否能正常进行
        4.把最后的处理结果,通过一些方法返回给web层,以便让web层决定接下来把什么页面显示给用户

    dao层
        dao层接口以及dao层接口的实现类
        1.根据service层的需要,和数据库进行交互,最后把交互的结果返回给service层即可。

第五章：状态的持久化/会话追踪技术/状态跟踪（目的：数据的共享）

1. http协议的访问是无状态的访问。                                                                                                                                         当前的访问是不会知道之前访问的状态的. (http协议的访问是不会帮我们保存访问的记录/痕迹的)。
2. 有些时候需要记录之前的访问状态。                                                                                                                                  比如在购物网站的时候,第一次访问点击购买了一个手机,，第二次访问点击购买了一个电脑,第三次访问点击购物车结算。这个时候我们就必须知道前俩次访问的时候购买了什么,要不然就没有方法去结算。所以我们就有了会话追踪技术来解决这个访问无状态的问题。
注意：状态的持久化/状态跟踪：用来保存web应用中所产生的数据。
      会话追踪技术：Cookie,Session

3.session和cookie的位置
session：是保存在服务器端的一个对象.客户端是没有session的.
cookie：在客户端和服务器端都会有。但是存在的形式不一样：在客户端cookie是以本地文件(浏览器管理的文件)的形式存在的,
在服务器端是以java对象的形式存在.
我们平时说说的cookie都是指的客户端文件形式存在的cookie

4.session和cookie的作用
session：是在服务器端保存用户的相关信息,
cookie：是在客户端保存用户的相关信息；同时cookie还可以在客户端保存session的信息,例如session的id值,这id的全名叫 JSESSIONID

5.Cookie：
 5.1 原理：Cookie产生于服务器端，以文件的形式保存在客户端，response对象会把cookie带回到浏览器,然后浏览器把cookie对象中的内容保存到对应的一个cookie的文件中。并且每次发送请求都会将cookie的数据放在request发送给服务器端。

 5.2 创建Cookie:Cookie就是对象
  new Cookie(String key,String value)
  Cookie只能存放String类型，如：Cookie c1 = new Cookie("name","tom");Cookie c2 = new Cookie("msg","hello");

5.3 保存Cookie到客户端:把cookie放到response里面
   response.addCookie(cookie)

5.4 servlet中拿到从浏览器发送过来的cookie文件中的数据
   //从request中拿到一个cookie数组，如果没任何cookie数据则返回null
   Cookie[] cookies = request.getCookies();
   //遍历数组 拿出key和value
   for(Cookie c:cookies){
    String key = c.getName();
    String value = c.getValue();
    System.out.println(key+" : "+value);
  }

 5.5 Cookie的存活期:默认为-1，单位是秒
   setMaxAge(秒数)。如：   c1.setMaxAge(60*60*24*365);c2.setMaxAge(60*60*24*365*10);
    会话Cookie:如果是负数，将cookie保存在浏览器上。默认，
    持久Cookie：如果是正数，将cookie保存在文件中。
注意:如果没有设置cookie生效的时间,那么这个cookie就是会话cookie,当关闭浏览器的时候cookie就是失效了。

5.6 禁用Cookie
   针对浏览器来禁用Cookie，不允许在本地保存cookie文件

6.Session:会话
 6.1 原理                                                                                                                                                                               产生于服务器端，以对象的方式保存于服务器，维护于服务器。服务器端每产生一个新的session,都会分配一个唯一id值,并且将
这个ID值以Cookie的形式保存在客户端的。并且这个Cookie的键是JSESSIONID.

 6.2 创建或者获取Session,对应的类HttpSession
   1)HttpSession session=request.getSession();
        if(JSESSIONID==null){
       创建一个新的Session
    }else{
        return 获取存在的Session
    }
   2)HttpSession session=request.getSession(true);
         if(JSESSIONID==null){
       创建一个新的Session
    }else{
        return 获取存在的Session
    }
   3)HttpSession session=request.getSession(false);
      if(JSESSIONID==null){
       return null;
    }else{
        return 获取存在的Session
    }
 6.3 保存数据
 session.setAttribute(String,Object)
 session可以保存Object类型

 6.4 取出数据
 session.getAttribute(String);

 6.5 服务器端在维护session的存储结构：
    Map<JSESSIONID,Map<String,Object>>
    
 6.6 Session的生命周期(会话)
   当web应用第一次调用getSession()时，会创建一个新的Session。接下来所打开的页面都属于同一个Session。遇到以下的情况，Session会失效：
    1)关闭浏览器(session存在服务器端，取不到)
    2)服务器端手动调用invalidate()方法
    3)当Session的不活动时间超过了Session的最大存活期。不活动时间即发呆时间，不是累计的。默认最大存活期是30分钟,在tomcat的web.xml文件中可以看到默认时间。
    修改最大存活期：两种方式
        a)在Servlet源代码中修改:单位是秒
    session.setMaxInactiveInterval(60);
        b)在web应用的web.xml文件修改（511行上下）
    <!-- 修改session的存活期，单位是分钟 -->
    <session-config>
        <session-timeout>20</session-timeout>
    </session-config>

   6.7 web应用的四大范围:保存数据以及传递数据
     pageContext：指的是一个页面的范围,只在JSP中使用。属page范围
     request：指的是一个请求的范围，可以包含多个页面，内部跳转。属request范围
     session:指的是一个会话的范围，可以包含多个request。属 session范围
     ServletContext:指的是一个web应用的范围，web应用的上下文环境。可以包含多个session。属application应用

注：三大范围

2.request session application
    2.1 这三种对象可以在服务器内部帮我们保存数据以及传递数据.
            类型(接口)            对象名
           HttpServletRequest        request
           HttpSession            session
           ServletContext        application
    
    2.2 doGet或者doPost方法中怎么拿到这三种对象
        request对象：在doGet或者doPost方法的参数中
        session对象：HttpSession session = request.getSession();
        application对象：request.getServletContext();或者this.getServletContext();或者
                     request.getSession().getServletContext();或者this.getServletConfig().getServletContext();

        注意:无论哪一种方式,拿到的都是同一个application对象

2.3    这三种对象的生命周期及作用范围
    request对象
       生命周期:客户端每次发请求,服务器就会创建一个新的request对象,本次访问结束后,该request对象就会被销毁
       作用范围:使用request存/取数据只能在一次请求之内起作用.比如服务器内部跳转的时候(因为内部跳转客户端只发一次请求).
       注意:客户端重定向是不行的,因为客户端重定向会发出多个请求(多个request对象).

        session对象 (会话)
            创建session对象的三种情况:
            //1.如果request有对应的session,则返回这个session,如果request没有对应的session,则创建一个新的session并返回
            HttpSession session = request.getSession(true);
            //2.如果request有对应的session,则返回这个session,如果request没有对应的session,则返回null
            HttpSession session = request.getSession(false);
            //3.等同于request.getSession(true);
            HttpSession session = request.getSession();
            生命周期:
            request.getSession()第一次调用时创建。
            session.invalidate()调用的时候会销毁session
            注：session如果自动超时的话,也会被销毁（session默认超时时间为30分钟）
                
            作用范围:
                在一个会话之中起作用.一个会话可以包括很多个request请求,所以放在session中的数据,可以被多次请求所共享.

        application对象：ServletContext被称为应用上下文/servlet上下文
            生命周期:
                    启动tomcat服务器的时候,就会被创建
                    关闭tomcat服务器的时候,就会被销毁
                    而且每个项目在运行期间,都会有且只有一个application对象
            作用范围:整个项目在运行期间,只有一个application对象,所以这个对象是所有用户共享的,大家都可以向这个对象里面存数据,也可以再拿出来.因为这个对象一个项目中只有一个.


    2.3    使用这三种对象存/取数据
        存值:
             request.setAttribute("key", value);
             session.setAttribute("key", value);
             application.setAttribute("key", value);
        取值:
            request.getAttribute("key");
            session.getAttribute("key");
            application.getAttribute("key");


   6.8 重写URL：(也属于会话追踪技术的一种)
    1) URL重写的作用
        当前浏览器把cookie禁用之后,浏览器在发请求的时候,就不会把cookie带到服务器端了(其中最重要的也包括JSESSIONID),因为禁用cookie之后浏览器拒绝一切站点向浏览器写入cookie的(注意再禁用之前是否已经有一些已经存在的cookie了),这样的话,浏览器发送请求的时候就不能在服务器端根据JSESSIONID来拿到之前创建的session对象了(因为发送请求的时候没有把JSESSIONID的值传给服务器)。可以使用URL重写解决这个问题
    
    2) JSESSIONID从客户端传给服务器的方式
        第一种方式:  JSESSIONID保存在cookie文件中,浏览器发送请求的时候把这个cookie文件中的数据带给服务器.
        第二种方式:  通过传参的方式,把JSESSIONID的值通过要访问的URL传给服务器.(URL重写)
    
    3) URL重写的实现
        String url = response.encodeURL("url");这个方法参数就是我们要访问的URL, 这个方法会把重写后的URL以字符串的形式返回.例如:在一个超链接中,本来要访问的URL是:<a href="TestServlet">，重写后:<a href="TestServlet;jsessionid=5480EF9016295A73DC56731A2F123246">
        注意:response.encodeURL("url")方法，如果当前没有使用到session，则直接返回参数url。 同时还要注意禁用cookie后是不是已经把之前的cookie给删除了

7.session和cookie之间的关系
 7.1 客户端访问服务器的时候,假设服务器创建了一个session对象,服务器端的内存里面同时可能有好多个session对象,分别对应的不同客户端的访问,每一个session对象都有一个唯一的id值,叫做JSESSIONID。
 7.2  服务器端给客户端产生一个session对象后,会通过这次访问的response对象把这个session的JSESSIONID的值返回给浏览器,浏览器接收到后会把这个值以一个cookie文件的形式保存起来.
7.3 在此之后,这个浏览器再发请求到服务器的时候,就会把之前保存在cookie文件中的JSESSIONID的值传给服务器,服务器通过这个JESSIONID的值就能够知道服务器内存中是哪一个session对象和当前这个客户端对应.
 7.4 这样以来,就能到达一个效果,客户端的每一次访问,在服务器端都能够拿到相同的一个session对象,从而实现不同请求之间通过相同的session对象进行数据的共享.

 四：web项目中的路径

    4.1 路径中【最左边】的/
        客户端中/代表的是端口号后的这个/，http://ip:port/
            例如:  在html页面中,/TestServlet
                <a href="/TestServlet">测试</a>   点击之后,地址栏中的url变为:http://ip:port/TestServlet
                这个时候会报错404,因为缺少项目名
            例如:  在客户端重定向中,/TestServlet
                response.sendRedirect("/TestServlet");   运行之后,地址栏中的url变为:http://ip:port/TestServlet
                这个时候会报错404,因为缺少项目名。因为response是带着这个路径返回到浏览器,让浏览器解析这个路径并重新发送请求,所以这种情况还是会少一个项目名。
        
        服务器端中/代表的是项目名后的这个/    http://ip:port/项目名/
            例如:  web.xml文件中,配置servlet的映射路径
                <url-pattern>/TestServlet</url-pattern>                                                                                                            这个时候浏览器访问这个路径就需要写这样的url:http://ip:port/项目名/TestServlet
            例如:   在servlet中,进行服务器内部跳转
                String url = "/TestServlet";
                request.getRequestDispatcher(url).forward(request, response);
                这时候跳转后的地址栏中的url为:   http://ip:port/项目名/TestServlet
        
        注意:上面所讨论的/都是指的路径中最左边的/
        例如: /a/b/c/d
        除了最左边的/之后,其他的/都是正常的路径分割符


    4.2 HttpServletRequest中和路径相关的方法
        测试的时候访问的url为:http://127.0.0.1:8989/jd1617_servlet/PathServlet

        // /jd1617_servlet
        request.getContextPath();//此方法将返回该请求使用的实际上下文路径

        // /PathServlet
        request.getServletPath();

        // http://127.0.0.1:8989/jd1617_servlet/PathServlet
        request.getRequestURL();

        // /jd1617_servlet/PathServlet
        request.getRequestURI();
    
    4.3 ServletContext中和路径相关的方法
        ServletContext servletContext = getServletContext();

        // /jd1617_servlet
        servletContext.getContextPath();
        
        //获得一个绝对路径,这里/代表项目名后的/
        // D:\A_jd160405\apache-tomcat-7.0.62\webapps\jd1617_servlet\
        servletContext.getRealPath("/");
        
        //获得一个路径下面所有的资源的路径名,这里/代表项目名后的/
        // [/hello.html, /success.html, /WEB-INF/, /error.html, /param.html, /login.html, /first.html, /META-INF/]
        servletContext.getResourcePaths("/");

    4.4 相对路径和绝对路径
        在web项目中,可能会看到这几种路径, 例如:以一个htmt页面为例 hello.html
        //这个时候要分析这/代表项目名后的/,还是端口号后面的/
        /hello.html
        
        //这是一个相对路径,注意相对路径相对于的时候当前地址栏中所显示的路径
        hello.html
        例如1:
            先访问http://127.0.0.1:8989/jd1617_servlet/path.html。页面中有个超链接<a href="hello.html">测试</a>
            这个超链接中的路径就是一个相对路径,相对于当前路径,当前路径指的是地址栏中显示的路径,也就是这个路径:
            http://127.0.0.1:8989/jd1617_servlet/
            这个时候点击超链接,就在这个当前路径后面,加上所写的相对路径就可以了
            http://127.0.0.1:8989/jd1617_servlet/hello.html

        例如2:
            把path.html放到test目录下
            先访问http://127.0.0.1:8989/jd1617_servlet/test/path.html。页面中有个超链接<a href="hello.html">测试</a>
            这个超链接中的路径就是一个相对路径,相对于当前路径,当前路径指的是地址栏中显示的路径,也就是这个路径:
            http://127.0.0.1:8989/jd1617_servlet/test
            这个时候点击超链接,就在这个当前路径后面,加上所写的相对路径就可以了
            http://127.0.0.1:8989/jd1617_servlet/test/hello.html
        
            如果最后还想显示例1中的路径,那么超链接中的相对路径就要改一下:
            <a href="../hello.html">测试</a>
        
        例如3:
            path.html和hello.html在同一个test目录里面
            映射了一个servlet,路径为:<url-pattern>/servlet/PathServlet</url-pattern>
            访问这个servlet,进行服务器内部跳转,跳转到path.html
            http://127.0.0.1:8989/jd1617_servlet/servlet/PathServlet
            path.html页面中有个超链接<a href="hello.html">测试</a>
            
            这个超链接中的路径就是一个相对路径,相对于当前路径,当前路径指的是地址栏中显示的路径,也就是这个路径:
            http://127.0.0.1:8989/jd1617_servlet/servlet
            这个时候点击超链接,就在这个当前路径后面,加上所写的相对路径就可以了
            http://127.0.0.1:8989/jd1617_servlet/servlet/hello.html
            访问出错，解决办法见：例4

        例如4:
            path.html内容:
            在页面中加入一个base标签后,页面中的所有相对路径,就不再相对于地址栏中的路径,而是相对于这个base标签中所配置的路径
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
            <html>
            <head>
            <base href="http://127.0.0.1:8989/jd1617_Servlet/">
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>path.html</title>
            </head>
            <body> 
                <a href="hello.html">测试</a>
            </body>
            </html>

第六章：Filter(过滤器)

1.1 过滤器的作用

        在一个请求去访问某个资源的时候,filter可以在这个请求访问到这个资源之前,把请求拦下,然后做出一系列的处理或者判断(比如编码的转换,信息的过滤、权限的判断、是否已经登录的验证等等),最后filter再决定是否要让这个请求去访问那个资源.

   ①Filter在客户端和被访问的资源的中间位置。
   ②Filter可以在请求访问资源之前拦截请求。
   ③Filter可以在响应返回客户端之前拦截响应。

   作用：
      a.可以修改response和request中的数据。
      b.可以做日志输出
      c.可以做事务管理
      d.可以控制字符乱码
      e.可以控制用户的访问权限

1.2 编写filter过滤器

     写一个java类,然后实现javax.Servlet.Filter接口，这个接口中有三个方法:init  destroy  doFilter：
         a)init:这个过滤器类被服务器创建对象的时候会调用到这个方法。
         b)destroy:过滤器对象被销毁的时候会调用这个方法。
         c)doFilter:当过滤器拦截到请求的时候,会调用这个doFilter.
      其中最重要的doFilter方法有三个参数
       public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        FilterChain是一个接口,表示过滤器链,这个接口中只有一个方法
        public interface FilterChain {
            public void doFilter(ServletRequest request, ServletResponse response)throws IOException, ServletException;
        }

        同一个请求有可能要依次的通过俩个或者多个过滤器,在web中把这样多个过滤器看做一个过滤器链条对象,就是用这个FilterChain类型的对象来表示。 chain.doFilter(req,res)表示把当前的req和res传给这个过滤器链条中的下一个过滤器进行过滤,如果说链条中已经没有下一个过滤器,那么就把这次访问放行,让它去访问它真正要访问的资源.

    1.3 在web.xml中配置filter过滤器

        注意<filter>标签中也能使用<init-param>给过滤器传值
        例如
        <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>

        其中<url-pattern></url-pattern>有四种配置方式
        第一种 精确匹配
            <url-pattern>/test_servlet</url-pattern>表示此拦截器只会拦截/test_servlet这一个路径
        
        第二种 扩展名匹配
            <url-pattern>*.html</url-pattern>表示此拦截器只会拦截后缀名是.html的路径
        
        第三种 路径匹配
            <url-pattern>/test/*</url-pattern>表示此拦截器拦截/test路径下的所有资源
            注意：路径和扩展名匹配无法同时设置，比如下面的三个<url-pattern>都是非法的，如果设置，启动tomcat服务器会报错。
            <url-pattern>/test/*.html</url-pattern>
            <url-pattern>/*.html</url-pattern>
            <url-pattern>he*.html</url-pattern>
            另外<url-pattern>/aa/*/bb</url-pattern>这个是精确匹配，url必须是 /aa/*/bb，这里的*不是通配的含义
        
        第四种 匹配任意的url
            <url-pattern>/*</url-pattern>
        
        注意:filter过滤器只是会拦截地址栏中会出现的路径,如果是服务器内部跳转的路径,filter是不会拦截的

    1.4 多个filter过滤器的执行顺序

        如果有多个过滤器,并且多个过滤器拦截的路径有相同的部分,就有一些路径被会这多个过滤器共同拦截,那么过滤器的顺序是按照web.xml中配置的顺序从上到下执行的
        注意:一个<filter>标签可以多个<filter-mapping>标签
        例如:
          <filter>
            <filter-name>test_filter</filter-name>
            <filter-class>com.briup.web.filter.TestFilter</filter-class>
          </filter>
          <filter-mapping>
            <filter-name>test_filter</filter-name>
            <url-pattern>/hello.html</url-pattern>
          </filter-mapping> 
          <filter-mapping>
            <filter-name>test_filter</filter-name>
            <url-pattern>/first.html</url-pattern>
          </filter-mapping>

第七章：监听器(Listener)

    1.1 监听器的作用

        监听web中的一些事件的发生,如果某些事件一旦发生了，那么这个监听器就会调用指定方法进行处理.
        例如:在web中可以监听request对象的创建和销毁.

    1.2 编写Listener监听器

        写一个java类,实现指定接口，监听request相关的接口
        ServletRequestListener接口
            requestDestroyed方法
            requestInitialized方法
        ServletRequestAttributeListener接口
            attributeAdded方法
            attributeRemoved方法
            attributeReplaced方法      
        
        监听session相关的接口
        HttpSessionListener接口
            sessionCreated方法
            sessionDestroyed方法
        HttpSessionAttributeListener接口
            attributeAdded方法
            attributeRemoved方法
            attributeReplaced方法
      
        监听application相关的接口
        ServletContextListener接口
            contextInitialized方法
            contextDestroyed方法
        ServletContextAttributeListener接口
            attributeAdded方法
            attributeRemoved方法
            attributeReplaced方法

    1.3 在web.xml中配置Listener监听器

    <listener>
        <listener-class>com.briup.listener.TestListener</listener-class>
    </listener>