不会上传附件，就一页一页的贴吧，做得不详细，不过希望能对大家有所帮助！
中秋节到了，祝大家中秋快乐！顺便散下分！
不过在这里贴的毕竟有限，希望大家有什么问题还是多多发贴交流，大家一起讨论，一起提高！

一、Servlet基础
    1、什么是servlet?
    2、servlet的优点？
    3、什么是servlet容器？
    4、怎么写一个servlet？
二、Servlet核心
    1、核心的接口与类
            Servlet
            GenericServlet
            HttpServlet
            ServletRequest,ServletResponse
            HttpServletRequest,HttpServletResponse
            ServletConfig
            ServletContext
    2、HttpServletRequest,HttpServletResponse的常用方法
            request.getParameter();
            request.getParameterValues();
            request.getSession(); request.getSession(boolean);
            request.getRequestURI();
            request.setAttribute(), getAttribute(),removeAttribute();
            request.getRequestDispatcher();
            request.setCharacterEncoding();
            request.getCookies();
            response.getWriter();
            response.setContentType();
            response.sendRedirect();
            response.encodeURL(), encodeRedirectURL();
            response.addCookie();
    3、表单处理
            (1)如何获得表单中数据
            (2)表单中，有中文，如何处理
            (3)表单的提交方式
    4、比较get,post提交方式
            链接、表单默认提交方式、地址栏直接输入：get方式
            对于method="post" 是post方式。
            此外，还要知道两者之间的不同，查笔记。
    5、重定向与转发
            (1)什么是重定向、重定向的特点
            (2)编程
            (3)什么是转发,转发的特点
            (4)转发的编程
            (5)比较二者之间的不同。
三、http状态管理
        1、http协议的无状态特性
        2、cookie技术
            (1)什么是cookie? 特点？
            (2)cookie的创建
            (3) cookie的生存时间、路径
            (4)cookie常见的使用的场合
                记录用户的使用偏好、记住用户登录状态、
                保存购物车。
        3、session技术
            (1)什么是session?特点？
            (2)如何创建session?
                比较request.getSession()
                request.getSession(boolean)
            (3) session的几个重要方法？
                session.setAttribute(String,Object);
                session.getAttribute();
                session.removeAttribute();
                session.getServletContext();
                session.invalidate();
                session.getId();
                session.setMaxInActiveInterval();
         (4)如果禁止cookie，如何进行sessionId的跟踪？
                 url重写
                 response.encodeURL(), encodeRedirectURL();
        4、比较cookie与session技术？
        5、典型应用
            验证码
            session验证
            购物车
四、数据访问
        1、dao    是什么？优点?
        2、dao的组成？
        3、编程
五、过滤器与监听器
        1、概念
        2、过滤器的优点？
        3、过滤器的编程？
        4、监听器的编程？
六、文件上传
        1、如何使用fileupload工具来实现文件上传。
      

1、表单的处理
    （1）如果获得表单中的数据
        String request.getParameter(paramName);
        //有多个同名的paramName
        //比如 interest=fishing&interest=sleep
        String[] request.getParameterValues(paramName);
    （2）表单中的中文问题
        step1:
            对于html文件，添加
            <meta http-equiv="content-Type"
            content="text/html;charset=utf-8">
            要注意：该文件保存时所使用的编码一定也是utf-8
            作用是：要求浏览器按照指定的编码来
            显示该文档。
        step2:
            在servlet中，使用
            request.setCharacterEncoding("utf-8");
            要注意：此处的编码应该与meta中设置的一致
            作用：设置request对象的解码所采用的编码。
            默认情况下，request采用iso-8859-1编码来解码。
           
            此外，还要使用
            response.setContentType("text/html;
            charset=utf-8");
            作用有两个：
            一、response中写入数据时，所使用的编码
            二、生成一个消息头，要求浏览器按指定的
            编码来显示返回的数据。
        (3) 数据库的中文问题(mysql)
            对于某些版本的mysql jdbc驱动，需要告诉它，
            数据库当前存放数据采用的编码是什么
            jdbc:mysql://localhost:3306/sd1005db?
            useUnicode=true&characterEncoding=utf8
   
        create database sd1005db default character set utf8
2、重定向
        服务器向浏览器发送一个状态码302以及一个地址。
        浏览器收到该状态码之后，会立即向这个地址发
        送请求。
        特点：
            重定向的地址是任意的（既可以是当前服务器上的
            某个地址，也可以是其它服务器上的某个地址）。
            浏览器的地址栏的地址会发生变化。   

1、servlet的生命周期与核心类及接口
    （1）核心类与接口
        A.Servlet接口
            init(ServletConfig);
            service(ServletRequest,ServletResponse);
            destroy();
        B. GenericServlet抽象类
            对Servlet接口作了部分实现。主要是实现了
            init()方法。
        C. HttpServlet
            继承了GenericServlet,对http协议作了封装。
            实现了service()方法:
            service(HttpServletRequest,HttpServletResponse)    ;
            doGet(HttpServletRequest,HttpServletResponse)    ;
            doPost(HttpServletRequest,HttpServletResponse)    ;
            service()方法，其默认的实现是：依据请求是
            get还是post方式，来调用doGet()与doPost()方法。
    （2）servlet的生命周期
            含义：
                所谓生命周期，指的是，servlet容器如何去
                管理servlet对象的创建、调用、销毁以及其资源
                的获取与释放。
            因为开发人员不能够直接调用servlet,也就是说，
            servlet对象的创建及销毁等管理工作全部由servlet
            容器来负责。如果开发人员想干涉容器对servlet
            的管理工作，就需要对Servlet接口中的几个方法进行
            回调。
            过程：
            实例化 --》初始化--》就绪与调用--》资源释放--》销毁
            实例化：
                第一种情况：当服务器启动时，会对配置有
                load-on-startup参数的servlet进行实例化。
                第二种情况：当请求到达服务器，并且该请求
                要访问的servlet没有实例化。
                实例化就是调用servlet公开的不带参的构造器。
            初始化：
                就是容器会调用servlet的init(ServletConfig)
                方法。
                具体细节是：容器先会构造一个ServletConfig
                对象（该对象可以方便地访问servlet初始化配置
                参数等）。然后，再将该对象传给servlet实例。
                初始化的目的：一般用于获取资源。比如
                ，加载资源文件。
                初始化方法只会执行一次。
                如何override init()方法？
                A.如果override init(ServletConfig config)
                    super(config);
                    ....初始化代码
                B.也可以 override init(); //更好
                    ....初始化代码
            就绪与调用:
                经过实例化与初始化，servlet就可以接受调用。
                在默认情况下，多个请求会共享同一个servlet
                实例。
                也就是说：在同一个服务器里，某个
                servlet，只有唯一一个实例。
                while(true){
                    Socket s = ServerSocket.accept();
                    new WorkThread(s).start();
                }
               
                WorkThread extends Thread{
                    Socket s;
                    Servlet servlet;
                    public void run(){
                        servlet.service();
                    }
                }
               
                每当一个请求到达服务器，会启动一个线程来
                处理请求。而多个线程有可能会共享同一个实例（
                比如多个请求访问的是同一个servlet）。
            资源释放与销毁:
                容器会依据自己的算法决定是否销毁某个
                servlet实例，在销毁之前，会调用destroy()。
                用于释放在初始化方法中获得的资源。
    （3）线程安全问题           
                A.原因：
                多个线程可能会共享同一个servlet实例   
                如果多个线程对servlet实例进行写操作。
                B.解决方式：
                    方式一：使用synchronized
                    方式二：不建议使用
                    让servlet实现SingleThreadModel(标识接口，
                    里面没有任何方法)
                此时，每一个线程都会使用一个自己的servlet实例。
                    方式三：在servlet类当中，尽量不要对
                    属性进行写操作。
      
      
    2、url-pattern:
        servlet容器如何去分析请求路径。
        比如 http://ip:port/appName/abc
        step1: 除掉应用名之前的字符串。
                得到/abc.html
        step2: 去web.xml中，查找url-pattern,
        进行匹配：
                首先，做精确匹配：即step1中获得的字符串
                必须与url-pattern中定义的字符串完全一致。
                如果匹配不上，模糊匹配：使用通配符。
                例如：
                    /* :表示/下任意的字符串。
                    /abc/*:
                后缀方式的匹配：
                    例如：
                     *.do：匹配任意以.do结尾的字符串。
                     *.action:
                最后，如果仍然匹配不上，会查找静态资源
                ，如果找到，则返回，找不到，则404
    3、一个servlet处理多个请求。
                  
               
               
              

1、DAO
    (1)什么是dao?
        data access object 数据访问对象。
        数据访问的目的地，可以是数据库（大多数情况），
        也可以文件、目录服务器、数据仓库、第三方的程序等。
      
        概念：
            为业务逻辑模块提供的一个抽象的数据访问接口及实现。
            也就是说，dao实现了具体的数据访问，并且，为调用者
            提供了与具体实现细节无关的接口。
            这样做的目的是，当底层的数据访问细节发生改变，
            比如访问数据库使用的技术从jdbc-->hibernate,或者，
            访问设备从文件变成了数据库等等，都不会影响到
            业务逻辑模块。
    （2）dao的组成：
            dao接口:
                定义了与具体访问技术无关的数据访问方法。
            dao实现类：
                采用某种特定技术实现dao接口中定义的方法。
            dao工厂类：
                业务逻辑模块通过工厂获得某个dao对象。
            比如：
                IUserDAO
                    save();
                UserDAOJdbcImpl
                UserDAOHibernateImpl
                如果Service要调用dao，则
                IUserDAO dao = new UserDAOJdbcImpl();
                dao.save(User);
                如果现在要换成UserDAOHibernateImpl，
                此时，必须修改
                IUserDAO dao =
                new UserDAOHibernateImpl();
                这违反了“开闭”原则,就是说，软件设计时，应该
                对一个模块要尽量不去修改（“闭”），但是，
                可以增加新的模块或者功能（“开”）。
                如果这样写：
                IUserDAO dao = DAOFactory.getDAO();
                此时，只需要对工厂的配置文件做一下修改即可。
                实体类：
                    这些类的实例，其数据要写入数据库，或者，
                    反过来，要将数据库中的数据读出来，变成
                    实体类的实例。

1、http的状态管理
    (1)http协议的无状态特性
    浏览器发送请求给服务器，服务器处理完请求，生成
    响应，接下来会立即关闭连接。服务器并不会记录是哪
    一个浏览器曾经访问过。也就是说，当该浏览器再一次
    发送请求给服务器，服务器不知道该浏览器曾经访问过它。
   
    一般情况下，http协议的无状态特性是一个优势。
    因为效率比较高。但是，在一些特定的情况下，就会
    有问题：
        比如  购物车
        在购物车应用当中，用户通过浏览器与服务器之间
        有多次的交互，那么服务器必须记录这多次交互的
        过程（也就是购物的数据）。默认情况下，http协议
        是无状态的，不记录哪一个浏览器曾经访问过它。所以，
        必须对http协议进行状态的管理。
    （2）如何进行状态管理。
    A.采用cookie技术
    B.采用session技术
   
2、cookie技术
    （1）什么是cookie?
        是一种在客户端（浏览器）维护客户端状态的一种
        状态管理技术。    其基本思想是：当浏览器第一次访问
        服务器时，服务器会将数据通过设置消息头的方式，
        发送给浏览器。浏览器可以将该数据保存到内存或者保存到
        硬盘（是一个文本文件）。当浏览器下一次再去访问
        服务器时，会将该数据携带（通过设置消息头）给
        服务器。服务器就可以知道浏览器上次访问过的信息了。
    （2）cookie的使用
        A.创建cookie
        Cookie c1 = new Cookie(String name,String value);
        response.addCookie(c1);   
        cookie的值只能是ascii字符，对于中文（ascii
        字符以外的字符），都需要编码。
            URLEncoder.encode()
            URLDecoder.decode()
      
        B.读取cookie
        Cookie[] cookies = request.getCookies();
        如果浏览器发送请求时，没有携带cookie，则
        cookies = null。
      
      
        C.cookie的生存时间
            在默认情况下，浏览器会将cookie保存到内存里。
            可以设置cookie的生存时间。
            Cookie c1 = new Cookie(String name,String value);
            c1.setMaxAge(int age);
            age > 0 : cookie最长生存时间是多长，
            age < 0 : 浏览器会将cookie保存到内存里，
            浏览器关闭，cookie会删除。
            age = 0: 立即删除
        D. cookie的路径问题：
            cookie.setPath("/应用名");
            表示当前应用名底下的所有组件（jsp,servlet）
            都可以访问到该cookie
           
        servlet07
            a
                saveCookie.jsp
                getCookie.jsp
            getCookie.jsp
        要访问saveCookie.jsp，输入的路径是：
        http://localhost:8080/servlet07/a/saveCookie.jsp
        此时，相当于设置的cookie的路径是
        servlet07/a，此时，只有当前路径以及当前路径以下
        的路径可以访问到该cookie。
      
        练习：
        1）写一个Servlet，先读取cookie，如果cookie名
        为"username"的cookie不存在，则创建一个cookie,
        名称为username，值为中文的某个值。如果存在，则
        显示。
      
        2）写一个cookie工具
        CookieUtil
            addCookie(String name,String value,int age,
            String path,HttpServletResponse response);
           
            addCookie(String name,String value,String path,
            HttpServletResponse response);
            //默认时间长度是一年。
            //依据cookie name查找cookie值，找不到，返回null
            String findCookie(HttpServletRequest request,
            String name);
           
            //依据cookie name删除某个cookie
            deleteCookie(HttpServletResponse response,
            String name);
            提示：删除cookie可以参考以下代码,比如要
            删除叫name1的cookie:
                Cookie c1 = new Cookie("name1","");
                c1.setMaxAge(0);
                response.addCookie(c1);
                以上代码会删除一个叫name1的cookie。
        对于path相同的cookie
            cookie c1 = new Cookie("c1","v1");
            c1.setPath("/abc");   
            cookie c2 = new Cookie("c1","v2");
            c1.setPath("/abc");   
            response.addCookie(c1);
            response.addCookie(c2);   
3、Session技术
    (1)什么是session
    会话
    在服务器端维护客户端状态的一种状态管理技术。
    其基本思想是：当浏览器访问服务器时，服务器会
    创建一个对象（session对象，该对象有一个唯一的
    id，也称为session id）。服务器会将该id采用cookie的方式（默认情况下）。
    发送给浏览器，浏览器下一次访问服务器时，会将
    该id携带给服务器，服务器依据该id找到对应的
    session对象。浏览器操作所涉及到的数据可以保存到
    session对象里。
    (2)session的使用
        A.如何获得session?
            session只能由服务器创建。
            HttpSession session =
            request.getSession();
        方法一：request.getSession();
        方法二：request.getSession(boolean flag);
      
        request.getSession(true):
        执行过程：
            当请求到达服务器，执行到这行代码，服务器
            会查看请求中有无sessionId,若无，则创建一个
             session对象。若有，还要看该sessionId所对应
             的session对象是否还存在（服务器不会永久
             保存一个session对象，sesion对象会有一个
             失效时间，对于tomcat,30分钟，超过这个时间，就
             会删除）。若不存在，再创建一个新的，否则，
             返回原有的那个session对象。
        request.getSession(false):
            当请求到达服务器，执行到这行代码，服务器
            会查看请求中有无sessionId,若无，返回null,
            若有，如果sessionId对应的session对象还存在，
            则返回该对象，若不存在，返回null。
        request.getSession() == request.getSession(true)。
        B. 如何存取数据
            session.setAttribute(String key,Object value);     
            注意 value类应用实现序列化接口。
            Object session.getAttribute(String key);
            session.removeAttribute(String key)
      
        小例子
            计数。
        C. session的最大不活动时间
            session.setMaxInactiveInterval(int seconds);
            如果超过该时间，服务器会将session对象删除.
            默认情况下，对于tomcat,默认是30分钟。
            在conf\web.xml中配置
            <session-config>
                        <session-timeout>30</session-timeout>
                </session-config>
               
                服务器默认情况下，是通过cookie机制，将
                sessionId发送给浏览器，服务器会通过如下
                代码：
                    Cookie c = new Cookie("jsessionId","123");
                    c.setPath("/appName");
                    也就是说，浏览器一关闭， 该cookie就会删除，
                    此时，即使服务器端的session对象还存在，
                    该对象对浏览器也无意义了。
            D. 立即让session对象失效。
                    session.invalidate()。
                           
                  
           
                  
            FF：在同一台机器上，打开的多个窗口会共享
            同一个内存空间。
            IE: 一个窗口，对应一块内存空间。
           
      

1、过滤器
    (1)什么是过滤器？
        Servlet规范中定义的一种特殊类，它可以对
        Servlet容器的调用过程进行拦截，这样，就可以
        在servlet处理的前后作一些加工。
    (2)过滤器的使用
        step1
            写一个java类,实现Filter接口。
        step2
            在doFilter方法中，进行拦截处理。
        step3
            在web.xml中，配置Filter。
            对哪一些调用进行拦截。
           
    (3)过滤器的优点？
            A.过滤器是可以插拔的。即一个模块
            加入或者删除，不会影响到其它的模块的功能。
            如果一个系统能够做到可插拔性，说明系统
            维护性很好。
            B.过滤器可以将一类相似的通用的功能封装到一
            起，便于代码的维护。
   （4）如果有多个过滤器，按web.xml中配置的先后顺序执行。
   
           
2、监听器
    (1) 什么是监听器？
        是servlet规范中定义的一种特殊类，其作用是，
        对ServletContext,HttpSession,HttpServletRequest
        这三种对象的创建、销毁事件，以及这三种对象上面，
        属性值的改变（增加、删除、替换）事件进行处理。
  (2)监听器的使用？
          A.写一个类，实现特定的监听器接口（
          要依据要监听的事件类型，比如要监听的是
          HttpSession对象的创建和销毁，就要实现
          HttpSessionListener）。
          B.在接口的特定方法里，处理事件。
          C.在web.xml中配置监听器。      
         
          要统计在线人数。

 3、ServletContext
     servlet上下文
     一个web应用，在其整个生命周期当中，即当web应用
     部署之后，只要该web应用还在运行，容器会为该应用
     维护一个全局的对象，该对象是ServletContext的实例
     ，由容器创建。
     作用：
         (1)可以访问全局的初始化参数：
         即各个servlet均可以使用的初始化参数
         (2)可以用来保存一些全局性的数据。
        
     4、web应用中的相对路径与绝对路径
         四种情况,都会涉及到路径问题：
             链接
             表单提交
             转发
             重定向
         相对路径：
             不以"/"开头的路径
             比如:<a href="a.jsp">test</a>
         绝对路径：
             以"/"开头的路径:
             要注意：
                 转发： 应用名之后开始.
                 其它三种情况： 从应用名开始。   
        
     练习：
         （1）写一个CharacterEncodingFilter,可以为
         servlet添加这样一个功能：即为request对象
         设置编码。
         （2）写一个CommentFilter，可以对表单中提交
         的信息进行过滤处理：
             如果信息中包含 dog,cat,pig。不允许出现。
         （3）对shoppingcart，增加两个功能：
         A.  使用cookie保存cart。
         当用户关闭浏览器以后，下次再打开浏览器，仍然
         可以查看到购物车里面已经购买的商品。
         B.  如果用户禁止cookie，如果处理？（选做）
         （4）思考一下 cookie 与 session各自的优缺点？
  

1、上传文件
    step1:
        设置表单的enctype属性：
        <form action="" method=""
        enctype="multipart/form-data">
        </form>
        浏览器对表单中的数据不再编码，而是直接使用
        2进制字节流进行传递。此时，在服务器端，不能
        够再直接使用request.getParameter(参数名)来获得
        参数值。必须要使用request.getInputStream()获得
        一个输入流，对流中的数据进行分析。
        一般会使用工具(apache commons项目中的fileupload
        )来获得参数值。
        www.
    step2:
        使用某种工具（比如 fileupload）分析输入流。
        A.导包
            commons-fileupload-1.2.1.jar
            commons-io-1.4.jar
        B. 使用工具的api来获取数据
           
2、1、什么是jsp?
    是sun公司制订的一种服务器端动态网页生成技术的规范。
    jsp主要由html标记及内容以及部分java代码组成。
    java server page
2、jsp与servlet的关系。
    jsp本质上讲，就是一个servlet。
    jsp文件是以.jsp为后缀的一个文本文件，不需要编译。
    当请求到达服务器，要访问某个jsp文件时，jsp引擎
    会将.jsp文件先转换成.java文件（.java文件其实就是
    一个Servlet）,然后，再编译该Servlet,并调用其service()
    方法。
3、jsp的组成
    （1）html
    （2）java代码
                A.  java 代码片断
                <%   java 代码 %>
                B.  jsp表达式
                <%=java表达式%>
                C. 声明
                <%!     %>
    （3）指令
                <%@指令名 属性1＝值1 属性2＝值2%>
                告诉jsp引擎，在将jsp转换成servlet时，
                做一些额外的处理。
                A.page指令
                    <%@page import="java.util.*,java.sql.*"%>
                    导包
                    <%@page pageEncoding=""%>
                    告诉jsp引擎，要转换的jsp文件的编码是什么。
                    <%@page contentType="text/html;charset=utf-8"%>
                    相当于response.setContentType();
                    <%@page session="true"%>
                    true:表示当前jsp支持session,默认值。
              B. include指令
                      在jsp引擎将.jsp文件转换成.java文件时，将
                      另一个文件内容插入到指令所在的位置。
                      <%@include file="被包含的文件"%>
              C. taglib指令
                      导入标签库
                      <%@ taglib uri="..."  prefix="c"%>
                      uri: 是一个在.tld文件定义的字符串，用来
                      唯一标识一个标签库。
                      prefix: 标签的前缀
                      <c:if test=""></c:if>
    （4）Action Element (活动元素)
                在jsp已经运行了，让servlet引擎对jsp
                对应的servlet实例，添加一些附加的处理。
                A.<jsp:forward  page="">
                  
                B.<jsp:include>
                    动态的包含，即servlet引擎遇到该指令后，
                    会将请求交给被包含的文件来处理，也就是说，
                    会调用被包含的jsp。
                    如果要向被包含的文件传递参数
                C.<jsp:param>
                D.<jsp:useBean id="" scope="" class="">
                        id: 放置对象的key
                        scope:范围
                                page:  从PageContext中取
                                request
                                session
                                application
                        class: 类名
                    先从scope中指的范围去查找key的值为id所
                    指定的值的对象，若找不到，则依据class
                    值创建实例，并且放到对应的范围。
                    <jsp:getProperty>
                    <jsp:setProperty>
    （4）隐含对象
                由jsp引擎声明并创建的对象，可以在
                jsp文件中，直接使用。
                out
                request
                response
               
4、jsp如何转换成servlet?（jsp引擎负责转换）
    (1) html     --->  service()方法里，使用out.write()输出
    (2) <% %>  ---> service()方法里，直接照搬。
    (3) 指令---> 会对servlet源代码有影响，比如导包。
    (4) <%=%> ---> service()方法里，相当于out.println();           
   
练习:
        写一个交友系统：
        （1）注册功能
            a.需要提供 用户名、真实姓名、密码、
用户名            年龄、性别、电话。
            b.验证码
            c.注册成功，自动转到登录。
        （2）登录功能
            a.登录需要提供用户名和密码
            b.登录成功后，显示所有已注册用户的信息
用户名            （除了真实姓名与电话）
              点击"详细“，可以查看所有用户的照片。如果
              是当前用户，还可以上传自己的照片。
            c.如果没有登录系统，直接访问用户列表，则
            点击“详细”，看不到任何内容。
        （3）用户列表
                a.列出...
                b.提供详细链接
        （4）用户详细信息
                a.列出用户的真实姓名与电话
                b.当前用户还可以上传文件