十天学会servlet和jsp

=====================
第一天
=====================
1、web开发的背景知识(了解)
 (1)二层的c/s：
  特点：使用数据库允当服务器(数据库不仅要保存数据，
  还需要编写大量的业务处理逻辑，客户端负责界面
  及部分的业务处理逻辑)。
  缺点：可移值性差(比如，要换数据库，就需要重新写一次
  业务处理逻辑，因为数据库的编程语言是不一样的)。另外，
  要求客户端跟数据库之间保持一个数据库连接，所以，
  不适合开发大型的应用(数据库能够提供的数据库连接的
  个数是有限制的)。
 (2)三层的c/s:
  特点： 数据库只负责管理数据，所有的业务逻辑写在
  应用服务器里面，客户端负责界面。
  缺点：客户端需要单独安装，开发相对比较复杂(需要开
  发通讯处理模块，需要自定义协议)。
 (3) b/s：
  特点： 数据库只负责管理数据，所有的业务逻辑写在
  web服务器里面,客户端使用标准的浏览器。
  其实，b/s架构从本质上讲，是一种标准化的c/s：即
 使用标准化的通讯协议(http协议),标准化的客户端程序(
 浏览器)，标准化的服务器(比如tomcat)。
  优点：客户端不再需要安装，另外，开发相对简化(
  通讯模块不再需要开发了，也不再需要自定义协议)。
  
2、什么是servlet?
 sun公司制订的一种用于扩展web服务器功能的组件规范。
 (1)扩展web服务器功能:
  1)早期的web服务器(比如，apache ws,
  iis)只能够处理静态资源(即需要事先将html文件写好)
  的请求,不能够处理动态资源(需要依据用户的请求进行
  计算然后生成对应的html)的请求。
  2)早期，可以使用cgi程序来扩展web服务器：
    cgi程序可以使用很多语言来开发，比如perl,c等等
  都可以，但是，cgi程序有几个问题(比如，开发复杂，可
  移植差，性能不是特别好，因为会启动过多的cgi进程)。
  3)servlet也可以扩展web服务器(即动态生成页面)功能:
   方案一：
    浏览器发请求给web服务器(比如,apache ws,
    iis,这些web服务器本身是不能够处理静态资源的
    请求的),web服务器判断是否需要计算，如果需要，
    会调用servlet容器,servlet容器再去调用servlet
    处理请求。
   方案二:
    浏览器直接发请求给servlet容器(比如tomcat,jetty)
   ,因为servlet容器除了可以运行servlet之外，同时，也
   可以允当简单的web服务器。
 (2)组件规范
  1)组件:
   符合一定规范，实现部分功能的，并且可以部署在
  相应的容器里面运行的程序模块。
   servlet就是一个组件，我们在写servlet时，不需要
  考虑网络编程相关的问题，这些问题都由servlet容器去解决。
  2)容器:
   符合一定规范，为组件提供运行环境和相应的基础
  服务的程序。
3、如何开发一个servlet?
 step1,写一个java类(servlet只能够使用java语言来开发),
 该类需要实现Servlet接口或者继承HttpServlet抽象类。
 step2,编译
 step3,打包
   appname(应用名)
    WEB-INF
     classes(.class文件) 
     lib(可选, .jar文件)
     web.xml(部署描述文件)
 step4,部署
   将step3创建的整个文件夹拷贝到servlet容器特定的
 文件夹下面。或者也可以将整个文件夹先使用jar命令
 压缩成.war文件然后再拷贝。
 step5,访问
   启动servlet容器(web服务器),在浏览器地址栏输入
  http://ip:port/appname/servlet-url
  其中，servlet-url参见web.xml。
  
4、tomcat的安装与简单的使用
 (1)安装
  step1, 找到tomcat的压缩文件(比如
  /opt/apache-tomcat5.5.23.tar.gz)
  ,然后解压到/home/soft01
  (也可以去www.apache.org去下载tomcat)
  step2, 配置环境变量(大家现在可以不用配置)
   cd /home/soft01
   vi .bash_profile
   在该文件当中，添加
   JAVA_HOME: JDK的安装路径，比如
   /opt/java6.0
   CATALINA_HOME: tomat的安装路径,
   比如 /home/soft01/apache-tomcat5.5.23
   PATH:  /home/soft01/apache-tomcat5.5.23/bin
 step3,启动tomcat
   cd /home/soft01/apache-tomcat5.5.23/bin
   sh startup.sh (或者 sh catalina.sh run)
   接下来，打开浏览器，输入:
   http://localhost:8080
 step4,关闭tomcat
   cd /home/soft01/apache-tomcat5.5.23/bin
   sh shutdown.sh
 (2)tomcat的几个主要文件夹的作用
  1)bin: 是一些可执行文件(比如，启动和关闭tomcat)
  2)common: 放置可以被部署到该服务器上面的所
  有的程序都可以访问的jar文件。
  3)conf:服务器的配置文件。
  4)webapps:tomcat的部署文件夹。
  
5、使用myeclipse来开发servlet
 step1, 启动myeclipse
 step2, 让myeclipse能够管理tomcat。
 step3, 创建一个web工程
   http://localhost:8080/web01/greeting
   
6、servlet是如何运行的?
 比如，我们在浏览器地址栏输入   
 http://localhost:8080/web01/greeting:
 step1,浏览器依据ip,port建立与servlet容器之间的连接。
 step2,浏览器将请求数据打包，然后发送请求。
 step3,servlet容器解析请求数据包，将解析之后的结果
 封装到request对象，并且，还要创建一个response对象。
 step4,servlet容器依据请求资源路径找到servlet的配置，
 然后创建servlet对象。
 step5,servlet容器接下来会调用servlet对象的service
 方法，并且会将事先创建好的request,response对象作为
 参数传递进来。可以通过request对象提供的方法来获得
 请求参数值或者其它一些有用的数据，也可以将处理结果
 写到response对象里面去。
 step6,servlet容器从response对象里面取出处理结果，然后
 打包，发送给浏览器。
 step7,浏览器解析响应数据包，取出数据，生成相应的界面。
 
7,常见的错误及解决方式
 (1) 404:
  404是一个状态码，状态码是一个3位数，表示服务器
 处理的状态。404表示服务器依据请求资源路径，找不到
 对应的资源。
  解决方式： 依据http://ip:port/appname/servlet-url
 规则仔细检查你输入的请求地址。如果没有问题，再检查
 servlet-name是否一致。
 (2) 500:
  系统出错。
  解决方式：检查源代码，检查配置文件(web.xml)。
 (3) 405:
  容器找不到处理方法
  解决方式：仔细检查service方法的签名 
 
-------------------------------------------------- 
=====================
第二天
=====================
===============
1、http协议(了解)
 (1)什么是http协议(超文本传输控制协议)?
  由w3c定义的一种应用层协议，用来定义浏览器与web
 服务器之间通讯的过程及数据的格式。
  1),浏览器与服务器之间通讯的过程:
   step1,浏览顺建立与服务器之间的连接
   step2,浏览器打包(按照http协议的要求)，发送请求 
   step3,服务器打包，发送响应
   step4,服务器关闭连接
  特点： 一次请求，一次连接。
  优点： 服务器可以利用有限的连接尽可能为更多的客户端
 服务。
  2),数据的格式
   a,请求数据包
    请求行: 请求方式 请求资源路径 协议的类型和版本
    若干消息头:
     消息头是一些键值对，一般由浏览器或者服务器
    自动生成，表示特定的含义。比如，浏览器可以
    发送user-agent消息头告诉服务器浏览器的类型和版本。
    实体内容:
     只有发送post请求时，浏览器才会将请求参数添加到
    这儿，如果是get请求，请求参数会添加到请求资源
    路径的后面。
   b,响应数据包
    状态行: 协议的类型和版本 状态码 状态描述
     状态码是一个3位数字，由w3c定义的，表示服务器
    处理请求的一种状态，比如:
     404:依据请求资源路径，找不到对应的资源
     500:系统出错
     200:正常
    若干消息头:
     比如，服务器可以向浏览器发送一个content-type
     的消息头，告诉浏览器返回的数据类型。
    实体内容:
     程序处理的结果
2、get请求与post请求
 (1)哪一些情况下，浏览器发送get请求
  a,直接在浏览器地址栏输入某个地址
  b,点击链接
  c,表单默认提交 
 (2)哪一些情况下，浏览器发送post请求
   a, 表单设置了method="post"。
 (3)get请求的特点
  a, 会将请求参数添加到请求资源路径的后面，只能够提交
 少量的数据给服务器。
  b,请求参数会显示在浏览器地址栏,不安全(比如，路由器
  会记录这个地址)。
 (4)post请求的特点
  a,会将请求参数添加到实体内容里面，能够提供大量的数据
 给服务器。
  b,请求参数不会显示在浏览器地址栏，相对安全(post方式
  并不会对请求参数加密)。
 
3、web编码中的编码问题
 1)常识：
  a,java语言会将所有字符以unicode编码格式保存在内存里面。
  b,编码：将以unicode编码格式对应的字节数组转换成某种
  c,本地编码格式(gbk,gb2312,utf-8)对应的字节数组。 
 解码：将某种本地编码格式对应的字节数组转换成unicode
 编码格式对应的字节数组。 
 2)如果服务器端某个servlet要输出中文给客户端，需要
 添加如下的代码：
  response.setContentType("text/html;charset=utf-8");
  这行代码的作用有两个：
  第1个：out.println时，使用正确的编码格式进行编码
  (unicode -- >utf-8)
  第2个：设置了content-type消息头的内容，浏览器
  会按照指定的编码格式来打开这个页面(解码)
  
4、表单的处理
 (1)如何获得表单中的请求参数值?
  a, String request.getParameter(String paraName); 
  要注意：
   a1, paraName不正确，会获得null。
   a2, 在文本输入框中，如果不输入，会获得空字符串。
  b, String[] request.getParameterValues(String paraName);
  如果有多个参数名称相同，使用该方法。
 (2)如果表单中有中文参数值，如何处理?
  当表单提交的时候，浏览器会对表单中的参数值进行编码
 (会使用打开表单所在的页面时的编码格式来编码)。服务器
 在默认情况下，会使用iso-8859-1进行解码，就有可能发生
 乱码问题。
  解决方式一:
   step1, 保证表单所在的页面使用指定的编码格式打开。
   比如，对于html文件，可以添加:
   <!-- 模拟content-type消息头 -->
  <meta http-equiv="content-type"
  content="text/html;charset=utf-8"/>
  并且，要设置method="post"。
   step2, 在服务器端
   //告诉服务器使用指定的编码格式进行解码
   //只对post请求有效。
   request.setCharacterEncoding("utf-8");
  解决方式二:
   step1,同上。不要求设置method属性。
   step2,
   name = new String(name.getBytes("iso-8859-1"),
    "utf-8");
    
 去ftp下载 mysql-connector-java-5.1.7-bin.jar
 这是mysql的jdbc驱动程序
5、mysql数据库的简单使用
 1)登录数据库(使用root用户登录)
 mysql  -uroot;
 2)查看有哪些数据库实例
 show databases;
 3)创建一个新的数据库
  创建一个名叫jd1303db的数据库，该数据库的默认
  字符集是utf-8
  create database jd1303db default character set utf8;
 4)使用某个数据库
  use jd1303db;
  5)查看当前数据库有哪些表
   show tables;
  6)建表
   create table t_emp(
    id int primary key auto_increment,
    name varchar(50),
    salary double,
    age int
   );
  primary key:主健约束
  auto_increment:自增长列，在插入记录时，由数据库
  自动赋值。
  insert into t_emp(name,salary,age) values('tom',20000,20);
 
6、servlet如何访问数据库
 step1,将数据库驱动拷贝到WEB-INF\lib下。
 step2,编写jdbc代码访问数据库，需要注意异常的处理。 
  
------------------------------------------------------------------ 
============================
第三天
============================
1、重定向
 (1)什么是重定向?
  服务器向浏览器发送302状态码和一个Location
 消息头(包含了一个地址，称之为重定向地址),浏览器
 会立即向重定向地址发请求。
 (2)编程
  response.sendRedirect(String url);
  url是重定向地址。
 (3)需要注意的问题
  a,重定向之前，不能够调用out.close()。
  b,重定向之前，会先清空response缓存的数据。
 (4)特点
  a,重定向地址是任意的。
  b,重定向之后，浏览器的地址是新的地址
  
练习：
  完成修改员工操作。
  
2、dao (data access object)
 (1)什么是dao?
  封装了数据访问逻辑的模块。
 (2)如何写一个dao?
  step1,  entity 实体类
  实体类与表对应，是为了方便对数据库中的记录进行操作
  而设计的一个普通的java类。
  step2, DAO接口
   在DAO接口当中，声明对某个表的所有操作相关的方法。
  基本原则： 接口中声明的方法不要涉及任何具体的实现。
  step3, DAO实现
   使用具体的数据库访问技术来实现DAO接口中声明的方法。 
  step4, 工厂
    什么是设计模式：是为了解决一类相似的问题提出的
   解决方案。
    工厂设计模式：工厂将对象的创建过程对外屏蔽，
   为调用者提供符合接口要求的对象(产品)。
   比如：
    Connection conn = DriverManager.get...
============================
第四天
============================
1、servlet容器如何处理请求资源路径?
 比如，在浏览器地址栏输入
 http://ip:port/web04/abc.html
 请求资源路径是:  /web04/abc.html
 step1, 容器依据应用名找到应用所在的文件夹。
 step2,容器会假设要访问的是一个servlet,会比较
 web.xml文件中<url-pattern>是否与"/abc.html"一致:
  a,精确匹配：
  b,通配符匹配：使用"*"来匹配任意的字符。
  比如<url-pattern>/*</url-pattern>
  /aaa   /aaa.bbb   /aaa/bbb/ccc
  c,后缀匹配：使用"*."开头，后接任意的字符。
  比如<url-pattern>*.do</url-pattern>
  会匹配所有以".do"结尾的请求。
    /adfasdfasd.do
 step3,如果都不匹配，容器会查找静态页面，如果找到，
 就返回，找不到，返回404。
 
2、如何让一个servlet处理多种请求?
 step1, 使用后缀匹配模式。
 step2, 分析请求资源路径，然后分别处理：
  String uri = request.getRequestURI();
3、servlet的生命周期
 (1)什么是servlet的生命周期
  指的是容器如何创建servlet对象，如何分配其资源，如果
 调用其方法来处理请求以及如何销毁servlet对象的整个过程。
 (2)生命周期分成哪几个阶段:
  1)实例化:
   a, 容器调用servlet的构造器，创建一个servlet实例。
   b,什么时候实例化?
    情况1：只有请求到达容器之后，容器才会创建。
    情况2:  容器启动之后，会立即创建servlet实例,
    该servlet必须要配置load-on-startup参数。
  2)初始化:
   a, 容器在将servlet实例化之后，会立即调用其
   init(ServletConfig config)方法。
   b,init方法只会执行一次
   c, 容器在调用init方法之前，会先创建一个符合
   ServletConfig接口要求的对象，然后再把该对象
   作为参数传过init方法。
   d,GenericServlet已经实现了init方法(将Servlet
   Config对象保存下来了)。
   e, 初始化参数:
     step1, 使用<init-param>配置初始化参数
     step2,使用ServletConfig提供的getInit
     Parameter方法来访问。
   f, 如果要实现自已的初始化处理逻辑，建议override
   init()方法。
  3)就绪:
   a, servlet容器在收到请求之后，会调用servlet对象的
   service方法来处理请求。
   b,HttpServlet已经实现了service方法，该方法依据请求
   类型分别调用doGet,doPost方法。
   c,写一个servlet，可以选择override HttpServlet的
   doGet,doPost方法或者override HttpServlet的service
   方法。
  4)销毁：
   a,容器在删除servlet对象之前，会调用其destroy方法。
   b,容器会使用自身的算法来决定何时销毁servlet对象。
   c, 可以在destroy方法里面编写释放资源的代码。
   d,destroy方法只会执行一次。
 (3)相关的几个接口与类
   a,Servlet接口
    init(ServletConfig config): 初始化
    service(ServletRequest req,ServletResponse res):
    destory():
   b,GenericServlet抽象类
    实现了Servlet接口中的部分方法，主要是实现了
    init,destroy方法。
   c,HttpServlet抽象类
    继承了GenericServlet,主要是实现了service方法。
   d, ServletConfig接口
   e, ServletRequest接口是HttpServletRequest
   接口的父接口。
   f, ServletResponse接口是HttpServletResponse
   接口的父接口。
   
 练习：
   给某种产品计价：
    出售的价格(price) = 原始价格(basePrice) *
    (1 + 税率)。
    比如
     1000 * (1 + 0.08)
     
4、将中文插入mysql数据库：
 step1,保证应用程序能够正确获得中文
 step2,jdbc:mysql://localhost:3306/jd1303db?
 useUnicode=true&characterEncoding=utf8
 告诉jdbc驱动，在输出时，使用utf-8这种编码格式进行编码。
 
 
===========================================================
第五天
===========================================================
1、jsp基础
 (1)什么是jsp?
 (java server page: java服务器端页面技术)
 sun公司制订的一种服务器端动态页面生成技术规范。
 因为直接使用servlet虽然也可以生成动态页面，但是
 过于繁琐(需要使用out.println输出),并且难以维护(如果
 要修改页面，就必须修改java源代码),所以,sun公司
 制订了一种新的规范专门用于生成动态页面，即jsp。
  jsp其实就是一个以.jsp为后缀的文件，该文件当中主要
 包含html和java代码。容器会将.jsp文件转换成.java文件(
 其实就是一个servlet),然后调用。
 (2)如何写一个jsp?
  step1,写一个以.jsp为后缀的文件
  step2,在该文件当中，可以添加如下的内容:
   1)html (css,js) : 直接写。
   2)java代码:
    a, java代码片断:
     <%  java代码    %>
    b, jsp表达式:
     <%=    %>
   3)指令:
    a,什么是指令?
     告诉容器，在将.jsp文件转换成.java文件时，
    做一些额外的处理。比如，导包。
    b,语法
     <%@指令名称 属性=属性值 %>
    c,page指令
     import属性：导包。
     比如  <%@page import="java.util.*"%>
     <%@page import="java.util.*,java.text.*"%>
     contentType属性：设置response.setContentType
     的内容。
     比如 
     <%@page contentType="text/html;charset=utf-8"%>
     pageEncoding属性：告诉容器, jsp文件的编码格式是
     什么。因为容器需要读取jsp文件的内容(也就是
     解码: 本地编码格式 --->unicode),有些容器不能够
     正确识别jsp文件的编码格式，所以最好加上该属性。
    d, include指令
     file属性： 告诉容器，在将.jsp文件转换成
     .java文件时，在指令所在的位置插入file指定的
     文件的内容。
     比如   <%@include file="header.jsp"%>
   4)隐含对象
    a,什么是隐含对象?
     在jsp文件当中，可以直接使用的对象，比如
    out,request,response。
    b,为什么可以直接使用这些隐含对象呢?
     因为容器会自动添加创建或者获得这些对象的语句。
 (3) jsp是如何运行的?
  step1, 容器要将.jsp文件转换成一个.java文件(其实就是一个
  servlet)。
   1) html   ----->  service方法里，使用out.write输出。
   2) <%   %> -----> service方法里，照搬。
   3) <%=  %> -----> service方法里，使用out.print输出。
  step2, 容器接下来会调用这个servlet。
  
 练习： 编写emplist.jsp,输出员工列表。
  去ftp下载 day05/emsdemo.zip
  
2、转发
 (1)什么是转发?
  一个web组件(servlet/jsp)将未完成的处理通过容器
 转交给另外一个web组件继续完成。
  最常见的情况是：一个servlet 将数据转交给一个
  jsp，由该jsp生成相应的页面。
 (2)如何转发
  step1,先绑订数据
   request.setAttribute(String name,Object obj);
  step2,获得转发器
   RequestDispatcher rd =
   request.getRequestDispatcher(String url);
  step3,转发
   rd.forward(request,response);
   在转发的目的地组件上，一般使用
   Object request.getAttribute(String name);取
   出数据，然后进行下一步的处理。
 (3)注意的问题
   a,转发之前，不能调用out.close();
   b,转发之前，容器会清空response缓存中的数据。
 (4)特点
   a,转发的目的地只能够是同一个应用内部的某个地址。
   b,转发之后，浏览器地址栏的地址不变。
=====================================================
第六天
=====================================================
1、如何处理servlet产生的系统异常?
 方式1: 使用转发
  step1, 绑订错误提示信息。
  step2,转发到某个错误处理页面(比如,error.jsp)。
 方式2: 让容器来处理
  step1, 编写一个错误处理页面(error.jsp)
  step2, 将异常抛出给容器
     throw new ServletException(e)
  step3, 配置错误处理页面，让容器知道出现异常后，
  应该调用哪一个页面。
     <error-page>
      <exception-type>javax.servlet.ServletException</exception-type>
      <location>/error.jsp</location>
     </error-page>
    
2、相对路径与绝对路径
 链接地址  <a href="list.do"></a>
 表单提交地址 <form action="add.do">
 重定向 response.sendRedirect("list.jsp");
 转发  request.getRequestDispatcher("listEmp.jsp");
 (1)什么是相对路径?
  不以"/"开头的路径。
 (2)什么是绝对路径?
  以"/"开头的路径。
 (3)怎样写绝对路径?
  链接地址、表单提交地址、重定向绝对路径应该从应用名开始写，
  而转发应该从应用名之后开始。
  //返回  /appname
  String request.getContextPath()
  
 相对地址在转发的时候容易出错
 
-------------------------------------------------------------
 create table t_user(
  id int primary key auto_increment,
  username varchar(30) unique,
  pwd varchar(30),
  age int
 );
 insert into t_user(username,pwd,age)
 values('tom','test',22);
 
 unique:唯一性约束
=====================================================
第七天
=====================================================
1、转发(一个请求)与重定向(多个请求)的区别
 (1)转发所涉及的组件可以共享request,response
 对象，而重定向不可以。
  request,response是在请求到达容器之后创建的，
 一旦响应发送完毕，容器会立即删除这两个对象。
 (2)转发的地址必须是同一个应用内部的某个地址，而
 重定向的地址不限止。
 (3)转发之后浏览器地址栏的地址不变，而重定向会变。
 (4)转发是一件事未完成，而重定向是一件事情已经做完，再
 去做另一件事情。
 
2、状态管理
 (1)什么是状态管理
  将客户端(浏览器)与服务器之间多次交互当作一个整体
 来看，并且将多次交互所涉及的数据(状态)保存下来。
 (2)如何进行状态管理
  第一类方式：将状态保存在客户端
  第二类方式: 将状态保存在服务器端
 (3)cookie技术:
  1) 什么是cookie?
  a,cookie是一种客户端的状态管理技术
  b,当浏览器向服务器发送请求的时候，服务器会将
  少量的数据以set-cookie消息头的方式发送给浏览器，
  浏览器会将这些数据保存下来。当浏览器再次访问
  服务器时，会将这些数据以cookie消息头的方式发送
  给服务器。
  2)如何创建一个cookie?
   Cookie c = new Cookie(String name,String value); 
   response.addCookie(c);
  3)cookie的查询
   Cookie[] request.getCookies();
   注意，该方法有可能返回null。
   String cookie.getName();
   String cookie.getValue();
  4)cookie的生存时间
   cookie.setMaxAge(int seconds);
   注意：单位是秒
   seconds >0 : 浏览器会将cookie保存在硬盘上，超过
   指定的时间，会删除该cookie。
   seconds < 0 : 缺省值，浏览器会将cookie保存在内存
   里，只要浏览器不关闭，cookie一直保存，当浏览器
   关闭，cookie会被清空。
   seconds = 0 : 删除cookie
     比如，要删除一个名叫userId的cookie:
     Cookie c = new Cookie("userId","");
     c.setMaxAge(0);
     response.addCookie(c);
  5)cookie的编码问题
   cookie只能保存ascii字符，对于不合法的字符(比如中文)
   需要进行编码，即转换成合法的ascii字符。
  
  6)cookie的路径问题
   a,什么是cookie的路径问题?
    浏览器在向服务器发送请求时，会比较cookie
   的路径与要访问的服务器的路径是否匹配，只有
   匹配的cookie才会发送给服务器。
   b, cookie的默认路径
    默认路径等于创建该cookie的组件的路径。
   c,匹配规则
    浏览器要访问的路径必须是cookie的路径或者
   其子路径时，才会发送对应的cookie。
   d, 设置cookie的路径
     cookie.setPath(String path);
    比如  cookie.setPath("/web07");
    将cookie的路径一般设置为应用名，这样可以保证
   该cookie可以被该应用的其它组件都能访问到。
  7) cookie的限制
   a, cookie可以被用户禁止。
   b, cookie不安全,敏感数据，比如密码，帐号等等
   需要加密。
   c, cookie的大小有限制，大约是4k左右(
   具体大小跟浏览器有关系)。
   d, cookie的个数也有限制，大约是300个(具体
   个数跟浏览器有关系)。
   e, cookie只能够保存字符串。
 (4)session技术
  1)什么是session?
   a, session是一种服务器端的状态管理技术。
   b, 当浏览器访问服务器时，服务器创建一个
   session对象(该对象有一个唯一的id号，称之为
   sessionId),服务器在默认情况下，会将sessionId
   以cookie的方式(set-cookie消息头)发送给浏览器,
   浏览器会将sessionId保存到内存。当浏览器再次
   访问服务器时，会将sessionId发送给服务器，
   服务器依据sessionId就可以找到之前创建的session
   对象。
  2)如何获得session对象?
   方式一:
     HttpSession s = request.getSession(boolean flag);
     当flag=true时:
      服务器会先查看请求当中有没有sessionId,
     如果没有，则创建一个session对象。
     如果有，会依据sessionId查找对应的session
     对象，如果找到，则返回该session对象，如果
     找不到，则创建一个新的session对象。
     当flag = false时：
      服务器会先查看请求当中有没有sessionId,
     如果没有，会返回null。
     如果有，会依据sessionId查找对应的session
     对象，如果找到，则返回该session对象，如果
     找不到，返回null。
   方式二:
     HttpSession s = request.getSession();
     等价于 request.getSession(true)。
   
  
================================================
第八天
================================================

 3)常用方法
  String session.getId();
  //obj类型最好实现Serializable接口，因为
  //服务器在持久化session时，会使用java序列化协议。
  session.setAttribute(String name,Object obj);
  //如果name对应的值不存在，返回null。
  Object session.getAttribute(String name);
  //解除绑订
  session.removeAttribute(String name);
 4)session超时
  所谓session的超时，指的是服务器会空闲时间过长的
 session对象从内存空间里删除掉。原因是，过多的session
 的对象会占用服务器过多的内存空间。
  大部分服务器都会有一个缺省的超时限制，一般是
 30分钟。可以修改服务器的缺省的超时限制。
  比如，可以修改tomcat的web.xml配置文件(conf/web.xml)
   <session-config>
         <session-timeout>30</session-timeout>
     </session-config>
     修改完之后，需要重新启动服务器。
     也可以将以上配置放到某个应用的web.xml文件当中。
     另外，还有一个方法:
      session.setMaxInactiveInterval(int seconds);
    5)删除session
      session.invalidate();
 6)session案例:
  a, session验证
   step1, 在登录成功以后，在session对象上绑订数据
   比如： session.setAttribute("user",user); 
   step2, 对需要保护的资源(只有登录成功以后，才能
   访问的资源，比如 main.jsp) ,添加session验证代码:
    Object obj = session.getAttribute("user");
    if(obj == null){
     //跳转到登录页面
    }
    
  b,验证码
   
========================================    
第九天
========================================
1、用户禁止cookie,如何继续使用session?(了解)
 (1)当用户禁止cookie以后，服务器仍然会发送sessionId
 (以set-cookie消息头的方式)，但是，浏览器会拒绝接受，
 这样，session机制会失效。
 (2)可以使用url重写来解决该问题
  a,什么是url重写?
   如果某个组件需要session机制的支持，则不能
  直接使用该组件的地址去访问，而应该使用服务器
  生成的组件的地址(会在组件的地址后面添加sessionId)
  去访问。
  b,如何重写?
   //用于链接地址，表单提交地址。
   response.encodeURL(String url);
   //用于重定向
   response.encodeRedirectURL(String url);
   比如:
    response.sendRedirect(
    response.encodeRedirectURL("list.jsp"));
   转发不用考虑。
2、session的优缺点
 优点：
  session相对安全
  session能够保存的数据类型更丰富
  session能够保存的数据大小更大
 缺点：
  session需要将所有数据写在服务器端，所以，
 服务器会占用过多的内存空间。可以考虑使用cookie
 来代替或者使用数据库来保存状态(即数据)。 
 
3、过滤器
 (1)什么是过滤器?
  servlet规范当中定义的一种特殊的组件，用来拦截
 容器的调用过程并进行相应的处理。
 (2)如何写一个过滤器
  step1,写一个java类，实现Filter接口。
  step2,将处理逻辑写在doFilter方法里面。
  step3,配置过滤器(web.xml)
 (3)过滤器的初始化参数
  step1,在web.xml，使用<init-param>配置
  初始化参数。
  step2, 使用FilterConfig.getInitParameter(String
  paraname)来获取初始化参数值。
 (4)过滤器的优先级
  当有多个过滤器都满足过滤的条件，则容器依据
  <filter-mapping>的先后顺序来调用过滤器。 
 (5)优点：
  a,可以将多个web组件相同或者相近的处理逻辑
  (比如，session验证、权限的管理、编码的处理等等)集中
  写在过滤器里面，方便代码的维护。 
  b,可以实现代码的“可插拔性”：删除或者添加某些模块，不
  会影响到整个程序的正常运行。
  
4、上传文件(扩展)
 step1, 设置表单的enctype属性：
  <form action="" method="post"
  enctype="multipart/form-data">。
  (http协议的要求)
 step2,在服务器端，不能够直接使用
 request.getParameter方法，需要使用
 InputStream request.getInputStream()
 获得一个输入流，然后分析该流来获得数据。
 一般使用一些工具来分析，比如apache提供的
 commons-fileupload.jar。
  首先，需要将相应的.jar文件拷贝到WEB-INF\lib下。
 然后，使用其api来分析InputStream。
  
=======================================================
第十天
=======================================================  
1、监听器
 (1)什么是监听器?
 servlet规范当中定义的一种特殊的组件，用来监听
servlet容器产生的事件并进行处理。
 事件主要有两大类:
  a, 生命周期相关的事件：容器创建或者销毁request,
  session,ServletContext三个对象时产生的事件。
  b, 绑订相关的事件：调用了request,session,
  ServletContext的setAttribute,removeAttribute产生
  的事件。
 (2)如何去写一个监听器?
  step1, 先写一个java类，实现相应的监听器接口。
  要依据监听的事件类型来选择相应的监听器接口(
  比如，要监听session的创建和销毁，要用
  HttpSessionListener接口)。
  step2,在接口所声明的方法里面，实现相应的处理逻辑。
  step3,注册监听器(web.xml)。
  在线人数
  
2、ServletContext接口
 (1)容器在启动的时候，会为每一个应用创建唯一的一个符合
 ServletContext接口的实例，称之为Servlet上下文。
 Servlet上下文会一直存在，除非容器关闭或者应用被
 卸载。
 (2)如何获得ServletContext?
  a, GenericServlet.getServletContext();
  b, HttpSession.getServletContext();
  c, ServletConfig.getServletContext();
  d, FilterConfig.getServletContext();
 (3)作用
  a, 依据逻辑路径获得实际部署时的物理路径
   String  getRealPath(String path);
  b,绑订数据
   setAttribute,getAttribute,removeAttribute
  request,session,servlet上下文都有这三个方法，
 在满足需要的情况下，应该优先使用生命周期短的。
  c, 访问全局的初始化参数
   String getInitParameter(String paramName);

3、servlet线程安全问题
 (1)servlet为什么会有线程安全问题?
  默认情况下，servlet在容器内部只有一个实例；
 如果有多个请求同时访问某个servlet，容器会启动多个
 线程来调用这个servlet实例，就有可能发生线程安全问题：
 比如，多个线程同时去修改servlet实例的某个属性。
 (2)如何解决?
  a,使用synchronized关键字加锁
  b,让servlet实现SingleThreadModel接口(不建议使用)
 容器会为每一个线程创建一个对应的servlet实例来处理请求。
 因为会产生过多的servlet实例，所以，建议少用。
====================================================

====================================================
servlet小结
 1、servlet基础
  (1)什么是servlet?
  (2)什么是servlet容器?
  (3)servlet依不依赖某个特定的servlet容器?
  (4)如何开发一个servlet?
  (5)http协议(了解)
   http协议是什么?
   http协议的特点?
   状态码是什么?
   消息头是什么？常见的消息头有哪一些？
   请求数据包与响应数据包的格式?
  (6)get请求与post请求
   哪一些是get请求，哪一些是post请求，各自的特点。
 2、servlet核心
  (1)表单的处理
   a,获得请求参数值:
    String request.getParameter(String paraname);
    String[] request.getParameterValues(String paraname);
   b,中文参数值:
    step1,要保证表单所在的页面按照指定的编码格式打开。
     html:  <meta http-equiv="content-type"
     content="text/html;charset=utf-8">
     jsp: <%@page pageEncoding="utf-8"
     contentType="text/html;charset=utf-8"%>
     step2,
       方式一:  request.setCharacterEncoding("utf-8");
       方式二:  new String(str.getBytes("iso-8859-1"),
       "utf-8");
  (2)容器如何处理请求资源路径?
  (3)如何让一个servlet处理多种请求?
  (4)转发与重定向
   a, 什么是重定向？
   b,如何重定向 ?
     response.sendRedirect(String url);
   c, 重定向的特点？
   d, 编程需要注意的问题
   e,什么是转发?
   f,如何转发?
    request.setAttribute(String name,Object obj);
    RequestDispatcher rd =
    request.getRequestDispatcher(String url);
    rd.forward(request,response);
    Object request.getAttribute(String name);
   g, 转发的特点
   h,转发与重定向的区别
   (5)servlet的生命周期
    a,分成哪几个阶段
    b, servlet在什么时候实例化?
    c, load-on-startup参数
    d, 如何override init方法?
    e,初始化参数如何配置?
    f,生命周期相关的几个接口与类?
    Servlet接口,GenericServlet抽象类,
    HttpServlet抽象类,ServletConfig接口,
    ServletRequest/ServletResponse接口
 3、状态管理
  (1)什么是状态管理?
  (2)cookie
   a,什么是cookie?
   b,如何创建cookie?
    Cookie c = new Cookie(String name,String value);
    response.addCookie(c);
   c,查询
    Cookie[] request.getCookies();
    String cookie.getName();
    String cookie.getValue();
   d, 编码问题
    String URLEncoder.encode(String str,String code); 
    String URLDecoder.decode(String str,String code);
   e,生存时间
     cookie.setMaxAge(int seconds);
   f, 路径问题
    cookie.setPath(String path);
   g, cookie的限制 
  (3)session
   a,什么是session?
   b,如何获得一个session?
    HttpSession s = request.getSession();
    HttpSession s = request.getSession(boolean flag);
   c,常用方法
    setAttribute,getAttribute,removeAttribute
    String getId()
   d,超时
    session.setMaxInactiveInterval(int seconds);
   e, 删除
    session.invalide(); 
   f, session的优点与缺点
   g, 如果用户禁止cookie,如何继续使用session?
    url重写(response.encodeURL, response.encodeRedirectURL)
 4、数据库访问
  (1)使用jdbc访问数据库
  (2) dao
  5、过滤器和监听器
   (1)什么是过滤器
   (2)如何写一个过滤器?
   (3)过滤器的初始化参数
   (4)过滤器的优先级
   (5)过滤器的优点
   (6)什么是监听器
   (7)如何写一个监听器
   (8) ServletContext接口
  6、典型案例和扩展
    员工管理
    session验证
    验证码
=============================================

=============================================