servlet学习笔记

Servlet -- 是JavaEE的一部分，是生成动态网页的技术，是一组接口的集合


一.应用体系结构
  1. c/s --> client / db sv
  2. c/s/db --> client/app server/db sv
  3. b/s  --> browser / server(存放大量静态网页html文件)
  4. b/s/db --> browser /server(少量的静态网页，以及大量的程序--servlet程序) /db sv
  
二、搭建开发环境
   1.安装server（选择tomcat6.0版本）
    1)免安装（将tomcat放在根路径下，所在目录不能含有中文）
2)需要配置JAVA_HOME环境变量（tomcat是java代码开发，运行需要jdk的配合）
3)tomcat默认端口为8080，与已安装的oracle冲突，需要修改端口
  tomcat --> conf --> server.xml --> 将8080端口改为8989，同时在该标签后添加属性URIEncoding="GBK"
   
   2.启动访问
    1)启动 --> tomcat/bin/startup.bat (注意：软件不能多次重复启动)
2)访问 --> 在浏览器地址栏输入http://ip:8989
3)关闭 --> tomcat/bin/shutdown.bat 

三、web应用1.0的开发（将编写好的html网页部署到tomcat上）
   1.tomcat目录结构
      tomcat 
   |- bin     存放启动关闭tomcat命令的目录
|- conf    存放tomcat运行过程中需要使用的配置文件
|- logs    存放日志文件
|- lib     存放库文件（tomcat运行中需要使用的jar包）
|- webapps   存放所有web应用需要的资源文件（里面的每一个文件夹代表一个web应用）
  |- abc    代表一个叫做abc的web应用
  |- myweb  如果需要开发自己的web应用，需要在webapps下新建一个目录，用来存放资源文件
  
   2.部署访问
     1）将开发好的html文件放入myweb目录（可以在myweb里建子目录管理资源文件）
2）启动服务器，在浏览器里访问
   http://192.168.0.3:8989/web应用名/资源的相对路径（html文件所在的路径）

     注意：如果html文件里含有图片，浏览器会再次向server发请求下载图片，图片路径最好使用网络路径（url）
      http://ip:port/应用名/图片路径。如果图片和html网页在同一服务器上，则协议ip和端口可以省略。
  <img src="/应用名/图片路径"/>
 
   3.基本路径概念区分
      地址栏 -->  http://192.168.0.3:8989/myweb/html/hehe?name=luxw&age=18
 
1)URL（统一资源定位符）：唯一定位网络里的任意资源
  组成 --> 协议 ip port 应用名 资源相对路径
  例如 --> http://192.168.0.3:8989/myweb/html/hehe
  
2)URI（统一资源描述符）：用来在一个服务器上唯一定位一个资源
  组成 --> /应用名/资源相对路径
  例如 --> /myweb/html/hehe
  
3)url-pattern(ServletPath):一个资源的网络名称（相对路径）
  表现形式 -->  html文件的网络名称就是本身的文件名   servlet程序的网络名需要程序员指定
  例如 --> /html/hehe    
  
4)QueryString(请求参数)：会随着请求的发送被传递给server
  组成：name=value&name=value
  例如：name=luxw&age=18
 
四、web应用2.0的开发（将能够生成动态网页的servlet程序部署到tomcat上 -- 手动部署）


  1.写程序（servlet程序）
    1）实现一个servlet程序的方式
       第一种：实现javax.servlet.Servlet接口，覆盖5个方法
            servlet程序的生命周期方法 --> init()  service()  destroy()
  第二种：继承javax.servlet.GenericServlet类，覆盖service()
       第三种：继承javax.servlet.http.HttpServlet类，覆盖service()


    2)定义一个类继承HttpServlet
      HttpServletRequest代表client向server发送的请求
 HttpServletResponse代表server向client做出的响应
      public class FirstServlet extends HttpServlet{
    public void service(HttpServletRequest request,HttpServletResponse response) 
     throws  ServletException,IOException{
//1.设置响应内容的类型
              response.setContentType("text/html"); 
            //2.获取server到client的输出流
              PrintWriter out = response.getWriter();
              //OutputStream out = response.getOutputStream();
            //3.发送结果数据
               Date d = new Date();
               out.println(d.toString());
               out.flush();   
}
 }
 注意：http协议是“一次连接协议”，response回到client时，连接自动断开，所以输出流不需要手动关闭
       随着连接断开而关闭。

  2.部署（deploy）：将servlet程序放置到tomcat上
     webapps
  |- myweb
    |- html,image
|- WEB-INF
  |- classes         存放写好的java程序（.class文件），包括包结构
  |- lib             视情况而定，存放本应用需要使用的jar包
  |- web.xml文件
  
  3.写配置文件web.xml
     <servlet>
   <servlet-name>servlet程序的简称（至少在当前文件里唯一）</servlet-name>
<servlet-class>servlet程序的全类名</servlet-class>
</servlet>
<servlet-mapping>
   <servlet-name>与上面的servlet-name保持一致，区分大小写</servlet-name>
<url-pattern>给servlet程序起网络名，以"/"开始 </url-pattern>
</servlet-mapping>
 
  4.启动服务器，浏览器访问
    地址栏 --> http://127.0.0.1:8989/myweb/first

  5.常见问题：
    1）tomcat启动时，启动窗口报错：Occurred at line 10 column 39
  解决：检查配置文件指定的行是否有错误
  
2）访问程序时浏览器报405错误
  解决：检查servlet程序的service方法声明定义是否写错
 
3）访问程序时，浏览器自动打开文件下载保存对话框
  解决：检查响应内容的类型是否正确
  
4）访问程序，浏览器报500错误：not a servlet 
  解决：检查类是否正确继承了HttpServlet
  
5）404错误
  解决：a.检查部署的是否是.class文件，是否带了包结构
        b.检查配置文件是否编写正确（servlet全类名  url-pattern是否以/开头）
c.检查部署路径是否正确（WEB-INF  web.xml）
d.检查地址栏请求路径是否正确（port，是否漏写了应用名）
    
===========================================================================================================
复习：
  1.写程序
    1）implements Servlet       extends GenericServlet        extends HttpServlet
2）生命周期：init    service    destroy
3）public void service(HttpServletRequest request,HttpServletResponse response)
      throws ServletException,IOException{
  //如果请求里带有数据  String value = request.getParameter("name");
  response.setContentType("text/html");
  PrintWriter out = response.getWriter();
  out.println(....);
  out.flush();
  }
  2.deploy
     webapps 
   |- myweb
 |- others(html,image,css,js,jsp....)
 |- WEB-INF
   |- classes 存放java程序的.class文件，包括包结构
|- lib     存放当前应用使用的jar包
|- web.xml
 tomcat默认的classpath -- classes   应用的lib   tomcat的lib
  3.写web.xml
    <servlet>  ---  <servlet-name>  <servlet-class>
<servlet-mapping> -- <servlet-name>  <url-pattern>
注意：url-pattern必须以/开头
  4.访问
     http://127.0.0.1:8989/myweb/first
===========================================================================================================
五、client端发送请求的方式
  1.手动在地址栏输入url -- 通常只用来访问web应用的首页使用
  2.将程序的地址封装到超链接的href属性里，供用户点击发出请求
     <a href="程序的url">  
  3.将程序的地址封装到form标签的action属性里，当用户点击submit按钮时发出请求。
     <form action="程序的url"  method="">
此种请求里是带有数据的，server端获取数据：
String value = request.getParameter("....");
 
   注意：如果包含有超链接或者form表单的网页 与 要指定的程序 在同一server上，则地址可以省略写成uri。
  
六、client发出request --- server做出response过程
   1.client在地址栏向server发出request
   2.server提取request里的uri（应用名 + 资源的网络路径）
   3.根据”应用名“找到应用的ServletContext对象
   4.读取ServletContext对象的信息,匹配资源的网络名和文件中的url-pattern
   5.如果匹配成功，可以获取程序的全类名
   6.如果是第一次被请求，则使用全类名，利用反射机制，创建“类的对象”（实例）
       Class a = Class.forName("全类名");
  Object obj = a.newInstance();
   7.用程序的对象调用service()
   8.service()运行，将结果通过输出流发还给client
  
    1. tomcat启动时会读取每一个web应用的配置文件，将读到的内容封装成ServletContext对象，保存在内存里。
  一个web应用只对应一个ServletContext对象。
  
  tomcat将读到的一段servlet标签的内容封装成一个ServletConfig对象保存下来。
  
       如何获取两个对象（ServletContext和ServletConfig由tomcat启动时创建）
     ServletContext application = this.getServletContext();
 ServletConfig config = this.getServletConfig();
  这两个get方法是继承自GenericServlet
  
  tomcat允许程序员在web.xml文件里定义自己的数据，定义时使用如下标签定义
   <context-param>  ---  <param-name>   <param-value>
  程序里需要使用这个值的时候，通过ServletContext对象的getInitParameter()获取
     String value = application.getInitParameter();
  
    2. tomcat会在第一次请求到达时，为“被请求的程序”创建一个对象，由这个对象为“将来”所有访问它的client服务。
  
  servlet程序对象运行在多线程环境下，是“临界资源”，需要保证数据的线程安全。保证策略：尽量不要在servlet
  程序里定义成员变量（实例和静态），如果必须使用则需要用synchronized锁住“敏感代码”。
  
七、web应用3.0开发（利用集成开发工具自动部署web应用）
  1.将已安装好的tomcat6.0配置到myeclipse开发环境里
     myeclipse --> 菜单windows --> show view --> others --> myeclipse java enterprise --> servers选项
  --> 窗口点击右键选择configure server connector --> 左边选择tomcat6.x --> 右边选择enable单选钮
  --> 选择填入tomcat安装路径 --> apply --> ok
  
  2.新建一个web project
      项目名
   |- src       ---> 与普通java项目的src功能一致，用来写java代码的目录
|- WebRoot   ---> 与tomcat里的web应用目录一致（例如：等价于原来的myweb目录）
  |- html,css,image
  |- WEB-INF ----> 与手动部署时创建的WEB-INF功能一致
     |- classes
 |- lib
 |- web.xml  --> 与手动部署时编写的web.xml一致。
 
注意： 写程序 --》写配置文件 --》部署
 
  3.部署：点击菜单里的部署按钮即可
  
-----------------------------------------------------------------------------------------------------------
复习：
  1.client向server发送请求的方式：地址栏    <a href="uri">    <form action="uri">
  2.请求响应过程
    1）ServletContext  ServletConfig
2）servlet程序的对象是“临界资源”，需要保证线程安全
  3. web3.0
-----------------------------------------------------------------------------------------------------------
八、多个servlet配合：当client的请求过于复杂时，server端可能需要多个servlet配合共同完成client的请求。
   第一种：include（包含），在Aservlet程序运行过程中，将Bservlet程序的输出结果包含到A程序的结果里，共同向
           client输出 -- 合并输出结果。   【了解】
  
  1.代码体现： 在A程序中 --》
      RequestDispatcher rd = request.getRequestDispatcher("B程序的url-pattern");
  rd.include(request,response);
  
  2.作用：做复杂页面的输出  
  
   第二种：forward（请求转发）
   
          1.特点：【重点】
   1）forward连接的多个servlet程序形成工作流，有先后顺序，只有最后一个servlet有权向client输出
2）转发动作发生在server内部，client不知晓，所以client地址栏和网页内容不匹配
3）forward连接的多个servlet处于一个request生命周期。
    
     2.代码
   RequestDispatcher rd = request.getRequestDispatcher("下一个程序的url-pattern");
rd.forward(request,response);
  
          3.forward过程中的数据传递
   request是一个存储空间（作用域），可以用来存放起了名字的数据（命名属性）
语法：
  存数据--》request.setAttribute("名字",value);    value一般是object类型即可
  取数据--》Object value = request.getAttribute("名字");
     
   第三种：请求重定向
   1.特点【重点】
 1）重定向连接的两个资源处于两个请求的生命周期，浏览器会根据response1里的地址，自动发送第二次请求
 2）浏览器地址栏会发生改变。
 
2.代码： client请求A程序，由A重定向到B，应该在A里写如下代码完成重定向
    response.sendRedirect("B程序的uri");
 
-----------------------------------------------------------------------------------------------------------
复习：
   1.include：合并多个servlet程序的输出结果
   2.forward：请求转发
     1）特点：一个请求，地址栏不变，发生在server内部，工作流（完成一件事）
2）代码：request.getRequestDispatcher("下一个程序的url-pattern").forward(request,response);
3)数据传递：借助作用域request，将数据作为命名属性存入作用域
     request.setAttribute(name,value);   Object  value = request.getAttribute(name);
   3.sendRedirect:请求重定向
     1）特点：两个请求，地址栏发生改变，第二次请求有client根据response1自动发出
2）代码：response.sendRedirect("下一个程序的uri");
 
总结：资源间跳转的主要方式，以及跳转过程中的数据传递问题
1. html --》 下一个html
       跳转方式：在A.html里做超链接，点击后跳转到B.html
    2. html --》 Servlet(有能力处理数据)
       跳转方式：
       1）在A.html里添加超链接，点击后跳转到Bservlet程序
           <a href="B程序的uri?name=value&name=value...">
 B程序通过 String value = request.getParameter("name");
       2）在A.html里添加表单元素，点击submit按钮可以跳转到B程序
           <form action="B程序的uri"> 
 本身就是传递数据用的，B程序通过 String value = request.getParameter("name");
3.XXXView.java ---> html(不具备数据处理能力)
 1）超链接    2）form    3）forward    4）sendRedirect
4.XXXView.java ---> XXXAction.java(可以处理数据)
 1）超链接   2）form
 3）forward
    request.getRequestDispatcher("B的url-pattern").forward(request,response);
数据传递： A --》 request.setAttribute(name,value);
           B --> Object value = request.getAttribute(name);
 4)sendRedirect
    response.sendRedirect("uri");
数据传递： A --》response.sendRedirct("uri?name=value");
           B --> String value =request.getParameter("name");
注意：只能传递String类型数据
5.XXXAction --》 XXXView
 1）forward   2） sendRedirect
 
------------------------------------------------------------------------------------------------------------
九.Cookie
  1.概念：server写到浏览器上的一小段字符串，由name和value两部分组成，不支持中文。
          server只能读取自己写过的cookie。
  2.代码：
    1）读浏览器上的Cookie： Cookie[] cs = request.getCookies();
    2）写cookie： 
         首先创建cookie对象 -- Cookie c = new Cookie("name",value);
添加到response即可 -- response.addCookie(c);
3)可以手动设置cookie的存活时间
   方法 -- c.setMaxAge(time);  time单位是秒
time为正数      time为0表示清除这个cookie     time为负数表示cookie一直存活到浏览器关闭。
 
十. HttpSession
   1. sendRedirect和forward只是改变了请求的方向，并不表示程序流程的结束。
  
   2. HttpSession是一个作用域，可以用来存放命名属性  【重点】
      存数据 --> session.setAttribute(name,value);
 取数据 --> Object value = session.getAttribute(name);
 移除数据 --> session.removeAttribute("name");
 
   3.获取 【重点】
      HttpSession session = request.getSession(true);
 
   4.特点【重点】
     1）生命周期比较长（比request长，可以跨越多次请求的生命周期）
   begin：用户第一次调用getSession(true)方法
end：timeout（在有效的时间内，用户没有发出任何请求，则认为用户离开）
    默认session的有效时间为30分钟，可以通过session.setMaxInactiveInterval(time)设置存活时间
2）一个用户一个session（用户指的是浏览器软件）
   用户调用getSession(true)获取session对象时，server会首先读取浏览器上的cookie，寻找叫sessionId的cookie
找到 --》 说明不是第一次申请，那么server根据cookie里的sessionid，在server内存中查找匹配的session。
找不到 --》 说明第一次申请session，那么server会创建一个新的session，同时将session的id以cookie
           的形式写入浏览器

   5.Session的存活时间
     session的存活时间一般很短:安全考虑（session到期销毁）  内存效率（session到期写入文件）
保存sessionid的cookie存活时间一般为“负数”（浏览器关闭销毁）
 
   6.常见现象解读：
     1）安全退出和关闭浏览器退出的差别。
   安全退出 -- session.removeAttribute("login");
关闭浏览器 -- 浏览器关闭，保存sessionid的cookie被销毁
     2）自动登录
   前提 -- 同一个浏览器软件，同一台机器
策略 -- 登录成功后，将username和password保存到浏览器上（cookie），设置cookie的存活时间

十一.ServletContext
  1.是web.xml文件在内存中的表现，是tomcat创建的用来保存web.xml文件信息的对象，一个web应用只有一个
    ServletContext对象
       ServletContext application1 = this.getServletContext();


  2.是一个作用域
    1）API ：可以存放命名属性
  存数据 -- application.setAttribute(name,value);
  取数据 -- Object value = application.getAttribute(name);
  移除数据 -- application.removeAttribute(name);
  
2)获取：
  ServletContext application2 = session.getServletContext();
  思考： application1 == application2  ---》 true
  
3）特点：
  生命周期长： begin--tomcat启动   end--tomcat销毁
  数据共享范围： 当前应用的所有程序共享
  
  3.三大作用域区分
    1）共同点：在服务器端存放数据
2）区别：
               生命周期       数据共享范围
   request       最短      只有用forward连接的多个servlet程序才能共享request里的数据
session      比较长     被同一个用户请求的程序可以共享该用户session里的数据
application    最长     被当前应用的所有程序共享

例如： 服务器列表（a）   部门信息（a）    用户名（s）    权限（s）    错误信息（r）   购物车（s）
       
    注意：tomcat正常关闭时，会将内存中所有处于活动状态的session写入文件SESSIONS.SER，tomcat启动时会将文件
     内容读入内存，重新恢复session对象
 
------------------------------------------------------------------------------------------------------------
复习：
   三大作用域 -- request   session   application
   
------------------------------------------------------------------------------------------------------------
十二.连接池  --- tomcat内置了连接池功能


  1. 写配置文件，要求tomcat建立连接池 tomcat --> conf --> context.xml
     <Resource
     driverClassName   url   username   password
 name="连接池的名字"    type="javax.sql.DataSource连接池资源的类型(固定的)"
 auth="Container资源的拥有者(固定的)"
 maxActive="最大连接数"   minActive="最小连接数"   maxIdle="最大空闲连接数"
/>

  2.写代码获取连接
    1）代码
  Context  context = new InitialContext();
  DataSource  ds = (DataSource)context.lookup("java:comp/env/jdbc/oracle");
  Connection conn = ds.getConnection();
  
2)代码含义
 第一句：context对象表示当前环境下，资源树的树根
 第二句：从跟开始，按照指定路径和资源名查找资源。
 第三句：从找到的连接池资源里获取连接。
 
3）概念：JNDI（java naming directory interface）
   根据给定的资源名在树状存储结构里查找资源的过程。

十三.Listener(监听器)【了解】


   1.事件监听模型： 事件源（source）    事件对象（event）    监听器（listener）
       当事件源产生特定事件对象时，监听器代码立刻自动运行
  
   2.生命周期监听器
     ServletContextListener ：监听ServletContext对象的创建和销毁，当ServletContext创建时，initialize方法
              自动运行。
HttpSessionListener
ServletRequestListener
 
   3.添加监听器
     1）写程序实现特点的监听器接口，给出事件发生后的处理代码
   class MyListener implements ServletContextListener{
   。。。。。。
}
2）写配置文件web.xml
   <listener>
  <listener-class> 监听器程序的全类名 </listener-class>
</listener>

3)所有event都有方法getSource()获取事件源。
 
十四.Filter(过滤器)【重点】
  1.常见问题：
    1）解决程序的编码问题
  ServletContext application = this.getServletContext();
  String encoding = application.getInitParamter("encoding");
  request.setCharacterEncoding(encoding);
  response.setCharacterEncoding(encoding);
2)登陆验证
  HttpSession session = request.getSession(true);
  Object value = session.getAttribute("login");
  if( value==null){
     response.sendRedirect("/Telbook_web/view/LoginView.html");
 return;
  }
 
  2.过滤器是servlet程序的屏障，在client端的请求到达指定的servlet程序之前，以及response回到client之前，
    对request和response进行检查。

  3.在web应用里添加Filter过滤器程序
    1）写程序
  class MyFilter implements Filter {
      init() -- 初始化方法
  doFilter(req,res,chain){   --- filter的功能代码
      ServletRequest req 是HttpServletRequest的父接口，需要时可以强制转换
  ServletResponse res 是HttpServletResponse的父接口
  FilterChain chain 代表过滤器和后面的servlet程序形成的工作链
  }
  destroy() --- 销毁
  }

    2）写配置文件
  <filter>
    <filter-name>filter的简称，保持唯一</filter-name>
<filter-class>filter程序的全类名</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>与上面保持一致</filter-name>
  <url-pattern>被保护的servlet程序的url-pattern，如果需要保护多个程序，可以多写几个url-pattern标签</url-pattern>
  </filter-mapping>
    3）deploy  --- 与servlet一致

  4.通过多个过滤器时，先后顺序无关紧要，默认按照配置文件里声明的先后顺序通过。
  
  5.如果一个值只有filter程序需要，可以通过<init-param>将值定义在<filter>标签里，通过FilterConfig对象获取
    注意：tomcat读取web.xml文件时，会将读到的一段关于filter标签的内容封装成FilterConfig对象。
方法： String value = filterConfig.getInitParameter("encoding");
  
  6.Filter默认只过滤来自于client端的请求，如果希望Filter全方位保护，则需要添加<dispatcher>标签
    <filter-mapping>
  |- <filter-name>
  |- <url-pattern>
  |- <dispatcher> 可选值 REQUEST（默认值）  FORWARD  INCLUDE
    注意：dispatcher标签默认值为REQUEST，如果添加了该标签，则写什么是什么