servlet

wahxsm

于 2015-12-07 11:02:24 发布

阅读量1.3k

点赞数

分类专栏： servlet 文章标签： servlet

servlet 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1网络应用程序架构
（1）主机/终端
   特点：
     主机负责所有的计算（处理业务）
     终端只负责输入输出（不做任何计算）

   优点：
       可靠，安全，i/o能力强
   缺点：
       昂贵，扩展困难

 （2）client/server
    1）两层的client/server（目前不流行）

       客户端 <==============>   数据库

     （少量的业务处理）          （除了保存数据，
                                 还负责处理大量的业务逻辑）
      （vc,vb,deph1
    可视化编程语言）


         特点：使用数据库充当服务器，（大量的业务逻辑
               是使用数据库特定的编程语言实现的）
               客户端提供界面和少量的业务逻辑处理。

         优点：可视化编程语言开发速度快
         缺点：不好移植,不适合开发大型应用
          （要求客户端与数据库服务器建立一个持续链接）


   oracle编程语言：pl/sql
   sqlserver编程语言:transql

    2）三层的client/server(cs)

        客户端 <=========> 应用服务器 <=========> 数据库

    客户端：界面
          （a界面(gui) b通信模块）
        （vb,vc,dephi,java(swing)）

    应用服务器:负责所有的业务逻辑处理
        （一般用java来写。 也有C\C++写的，但是移植性差）

    数据库：数据的存储和管理crud


    应用服务器:a通信模块 b业务模块

     特点：所有的业务处理都由应用服务器来做
     优点：可移植性好（一般应用服务器用java来写）
            适合开发大型的应用
     缺点：客户端需要单独安装和维护
          开发复杂




tcp/ip socket编程

自定义协议 打包

（3）browser/web server(简称bs)

   browser <---HTTP协议-----> web server <--------> db


    browser:浏览器里面有通信模块

    web server:Tomcat（雄猫）www.apache.org
        里面有通信模块

HTTP协议：由W3C制定的。
   BS特点：
    使用浏览器充当客户端，
    使用web服务器充当应用服务器
    使用标准化的http协议来通信
  优点：
    开发相对简单（不需要开发通信模块
    不需要自定义协议）
    不需要单独安装客户端了。

2，什么是servlet
  sun公司制订的一种用来扩展web服务器功能的组件规范。
   （1）扩展web服务器功能
    web服务器收到请求之后，可以调用servlet来处理

   （2）组件规范
    a,什么是组件？
      符合规范，并且实现了部分功能的软件模块。
      组件一般需要部署到相应的容器里面才能运行。
        b什么是容器？
      符合规范，提供组件的运行环境的程序。

    tomcat提供了一个servlet容器。
    注：有些web服务器，比如iis，apache httpserver没有提供servlet容器，
    需要另外再切入或者调用单独的servlet容器才能运行servlet。（部署实施的人负责）

    组件不依赖特定的容器的，比如：
    我们开发了一个servlet，可以部署到其他的
        web服务器：weblogic,jetty,was等服务器。
    （因为里面都提供了符合规范的容器）

3，如何写一个servlet？

   step1，写一个Java类，实现servlet接口或者
  继承HttpServlet抽象类
  step2,编译
  step3,打包：即创建一个具有如下结构的文件夹：
    appname
      WEB-INF
        classes(放.class字节码文件)
        lib(可选，放.jar文件)
        web.xml(部署描述文件)
   step4，部署
    将step3创建好的整个文件夹拷贝到特定文件夹下面，比如：
    tomcat一般可以拷贝到webapps下面。
   step5.启动服务器，访问
    http://ip:port/appname/url-pattern
    http://localhost:8080/firstweb/hello

4，安装tomcat
   （www.apache.org下载5.5以上版本）
 step1,将tomcat安装压缩问价解压
   到/home/soft01下
   /opt/**.tar.gz
  step2，配置环境变量。
    JAVA_HOME:jdk安装路径
    CATALINA_HOME:tomcat安装路径
    PATH：添加：tomcat安装路径/bin

  step3启动tomcat
   cd /home/soft01/tomcat5/bin
   startup.sh（或者sh catalina.sh run）
   (windows环境下:双击startup.bat)

  step4:访问tomcat
  打开浏览器，输入http://localhost:8080

5，写一个helloServlet
  http://ip:port/firstweb/hello
  http://localhost:8080/web01/hello
   Hello kitty


   javac -cp servlet-api.jar -d . HelloServlet.java

-cp告诉编译器编译的时候可以找这个jar包
-d  就是放在哪， 小圆点.是当前目录


5, 使用myeclipse (或 netbeans jbuilder wsad)

 step1,启动myeclipse， 配置tomcat
  configer server -->servers---> tomcat  6.x-->Enable
  tomcat安装目录选中

+ JDK
  Launch，先用run mode（初学者）（debug mode是调试模式）
  paths  右上按钮,找到tomcat的bin目录，选中3个jar文件
  配置完毕。

step2创建一个web工程

  Javaee
    sun公司为了解决企业级开发中的系列问题
    而制定的一系列规范和相应的api

   子规范：
   servlet
   jsp
   jms
   jta

    例如：   完成异步消息的处理： 使用jms规范


6，servlet是如何运行的？

 http://localhost:8080/web01/hello?uname=tom
 http://localhost:8088/web01/hello?uname=tom

  ?uname=tom
  参数名 参数值
  hello tom

  比如，在；浏览器地址栏输入：
http://ip:port/firstweb/hello？uname=tom

  step1,浏览器依据ip,port建立连接
  step2，浏览器将相关数据（比如
  请求资源路径，请求参数）打包，然后发送请求。

  step3，服务器解析请求数据包，然后将
  解析之后的数据保存到request对象上，
  同时，服务器还会创建一个response对象
  step4服务器依据请求资源路径找到servlet类名，创建servlet对象
  然后调用service方法
 （服务器会将之前创建好的request，response作为参数传进来）

  step5，在service方法里面，通过请求对象来获得请求数据（比如，请求参数）
   然后进行相应的处理，最后将处理结果
  写到response对象上。
  step6，服务器从response对象上取之前保存的处理结果，然后
  打包，发送给浏览器
  step7，浏览器响应数据包，然后依据解析的结果生成新的页面。
------------------------------
what：
  tomcat ： web服务器，同时也提供了运行servlet的容器

how：

 servlet HttpServlet 

  appname
    WEB-INF
      classes
      lib
      web.xml

webapps




jar命令压缩web工程为.war后缀的文件
  http://ip:port/appname/url-pattern


1,http是什么
 超文本传输协议(hypertext transfer protocol)

  由W3C（万维网联盟）组织制订的网络应用层协议
  浏览器与web服务器之间如何通信，以及通信所使用的数据格式

（1）如何通信

  browser           web server 之间
           1.建立连接
           2.浏览器将请求数据打包，发送给server
           3.web服务器将响应数据打包，发送给浏览器
           4.web服务器关闭连接

 特点：1次请求，1次连接。
 有点：web服务器可以利用有限的连接资源为尽可能多的客户端服务。（效率高
 缺点：无状态


（2）数据格式
   1）请求数据包  
    a，请求行 (包头):请求方式  请求资源路径 协议类型和版本
    b，若干消息头
       一般是由w3c定义的一些键值对，浏览器
        与web服务器之间可以通过这些消息头来传递一些特定的信息
           比如，浏览器可以发送“user-agent”消息头，告诉web服务器浏览器的类型和
           版本。（有时可通过代码主动生成消息头）

    c，实体内容  https://（带s表加密）
           只有发送post请求时，才有数据（请求参数）

   2）响应数据包

      a，状态行：协议类型和版本 状态码 状态描述
                注：状态码，3位数字，w3c定义，表web server处理请求的的状态
                 200：正确
                 500：系统错误
                 404：依据地址找不到对应的资源
      b，若干消息头
          服务器也可以发送一些消息头给浏览器
           比如“context-type”消息头，告诉浏览器
           服务器返回的数据类型
      c，实体内容
         程序处理的结果（html文档，图片，视频等）


建工程的时候Context root URL是真正的部署名
myeclipse:
properties-->myeclipse--> web--> web context-root改名

eclipse:
properties--> web project settings--> context-root改名

抓包：
window-->show view -->other -->myeclipse Common-->TCP/IP Monitor
配置：右键空白 点propties--> add -->
port:8888(比如)
host name：  localhost:8080
--> OK --> start
(代理服务器)

http://localhost:8888/web02/hello

2，两种请求方式：
 （1）get方式
     1）哪些情况，会发送get请求
      a,直接输入某个地址
      b，点击链接
      c,表单默认提交的方式
      2）get请求特点
          a，会将请求参数加到请求资源路径的后面
            只能提交少量的数据（因为请求行最多只能存放约2k左右的数据）
          b，会将请求参数显示在浏览器地址栏
            （不安全，比如路由器会记录请求地址）
  (2)post方式
     1）哪些情况，会发送post请求
        设置表单的method="post"。
     2）post请求特点
        a，会将请求参数添加到实体内容里面，可以提交
           大量的数据。
         b，不会将请求参数显示在地址栏，相对安全。
            （注意：不管是什么请求，都不会对请求数据加密，
             一般使用https协议加密）
----------------
request包内容：
表头：
GET /web02/hello HTTP/1.1

若干消息头：
key : value

-----------------



3,servlet如何输出中文

  （1）为什么会乱码
     out输出默认编码：iso-8859-1  一个字节一个字符
   （2）解决
          response.setContentType("text/html;charset=utf-8");
    或者  response.setContentType("text/html;charset=gbk");

4，常见的错误及处理方式
  （1）404
        1）错误原因
            a,应用没部署
            b，请求地址写错了
                 按照http://ip:port/appname/url-pattern
            c，<servlet-name>不一致
  （2）500
         1）错误原因
            a,程序运行时出错（代码写错了）
            b，<servlet-class>写错

  （3）405
        1）错误原因
          a，服务器找不到处理方法。（例如service方法名写错）

   （4）200为正确，非错误

5，表单包含了中文参数值如何处理
  （1）为什么会有乱码？
    当表单提交时。浏览器会检查请求参数值，
   是中文，会按照打开该表达所在的页面时的字符集来编码。
   （比如按照utf-8来编码）

    服务器默认情况下，会使用“iso-8859-1”来解码
   （2）如何解决？
     step1，保证浏览器使用指定的字符集打开页面。
        <meta http-equiv="content-type" content="text/html;charset=utf-8">
     step2,服务器端使用对应的字符集解码
         方式一：
            request.setCharacterEncoding("utf-8");
            注意：只针对post请求有效(只针对请求包的实体内容)
           （常用，注意前提：设定为post）

         方式二：
        str = new String(str.getBytes("iso-8859-1"),"utf-8");
                先拿到字节数组，然后解码
             （不停的转码，麻烦）

6，如何获得请求参数值？
   (1)  String request.getParameter(String paraName)
     注意：
       a,paraName必须与实际传递的参数名一致，否则会获得null
       b,有可能获得空字符串

    对于多选课和单选框，如何不选择任何选项，会获得null值


7，servlet如何使用JDBC访问数据库
  step1,将jdbc驱动拷贝到WEB-INF\lib下
   服务器一般都提供了自己的类加载器（比如tomcat就提供了
   自己的类加载器），这些类加载器会从
   WEB-INF\lib下查找字节码文件。

  step2，在servlet类里面，使用jdbc提供的ff
   来访问数据库，要注意异常的处理。
 8，mysql数据库的简单使用
  （1）登录mysql
    终端：   mysql -uroot
   （2）查看当前有哪些数据库
    show databases;
    (3)创建一个新数据库(同时设置字符集)
    create database jsd1407 default character set utf8;
    （4）使用指定的数据库
    use jsd1407
    (5)查看当前数据库有哪些表
     show tables;
    (6)建表
   create table emp(
    id int primary key auto_increment,
    name varchar(50),
    salary double,
    age int
);

auto_increment：自增长列，插入数据时，数据库自动为该列赋一个自动增长的值

 insert into emp(name,salary,age)
 values('sally',20000,32);

select * from emp;

停止服务
  出“系统繁忙”错误
-----------------------------------
1,http协议
  （1）what
    a，通信

    b，数据格式

        请求数据包
           请求行get post（delete，put请求是ajax带的）
           消息头 user-agent
           实体内容

              post             

        响应数据包
            状态行
            消息头 content-type image/jepg
        实体内容

   （2）get/post
       get：地址，连接，表单默认。只能放少量数据

       post（method="post"）
       https（加密，需要配置，生成证书等）

2，表单
   utf-8  iso-8859-1(ascii)
   <meta http-equiv="content-type" content="text/html;charset=utf-8">

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


3,输出中文
  response.setContentType("text/html;charset=utf-8")

4,读取请求参数
  request.getParameter("uname");
  request.getParameterValues("intrest");

5，访问数据库
  JDBC的.jar包放进WEB-INF\lib
  jdbc sql
    系统异常

  http://ip:port/appname/list

以下信息表示这个驱动没有在tomcat注册过，所以报可能内存泄露的错误。
（这里可不用管）

严重: The web application [/web03] registered the JDBC driver [com.mysql.jdbc.Driver] but failed to unregister it when the web application was stopped. To prevent a memory leak, the JDBC Driver has been forcibly unregistered.
2015-12-6 13:41:12 org.apache.catalina.loader.WebappClassLoader clearReferencesThreads
严重: The web application [/web03] appears to have started a thread named [MySQL Statement Cancellation Timer] but has failed to stop it. This is very likely to create a memory leak.



1，重定向
  （1）什么是重定向？
       服务器通知浏览器向一个新的地址发送请求。

   一般服务器可以发送一个302状态码和一个Location
   消息头（值是一个地址，一般称之为重定向地址），
   浏览器收到之后，会立即向重定向地址发请求

response:

HTTP/1.1 302 Found
server:...
Location:http://locahost:8080/web03/list
...


   （2）如何重定向?
       response.sendRedirect(String url);


   （3）重定向之前，服务器会清空response对象上缓存的数据。
   （4）特点
        a,重定向之后浏览器地址会变
        b，重定向地址是任意的。

2，servlet容器如何处理请求资源路径
  比如，在浏览器地址栏输入
      浏览器会将“http://ip:port/web03_2/abc.html”
     作为请求资源路径发送给servlet容器（tomcat）
   step1，依据应用名找到应用所在的文件夹。
   step2，容器会先假设访问的是一个servlet，
    会从web.xml文件当中查找对应的servlet来处理
     (1)精确匹配
      <url-pattern>/abc.html</url-pattern>
         (假设abc.html文件同时存在，也不访问abc.html这个文件)

     (2)通配符匹配
      使用“*”来匹配0个或多个字符
     比如：
         <url-pattern>/*</url-pattern>
         <url-pattern>/abc/*</url-pattern>


       (3)后缀匹配
         使用“*.”开头，后接多个字符
         <url-pattern>/*.do</url-pattern>
         匹配所有以“.do”结尾的请求
    step3，如果以上均不匹配，会查找文件。找到了就返回，
         找不到就返回404

  （servlet其实是单例，只创建一个对象）
3，让一个servlet处理多种请求
   step1，使用后缀匹配
       <url-pattern>/*.do</url-pattern>

   step2,分析请求资源路径，依据分析结果，调用
      不同的分支来处理。
          //获得请求资源路径
      String uri = request.getRequestURI();

junit：右键--> other -->java -->Junit -->Junit test case
        junit4

package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet{
    public void service(HttpServletRequest request,
            HttpServletResponse response)
    throws ServletException,IOException{
        //读请求参数值
        String uname=request.getParameter("uname");
        /*
         * 消息头：告诉浏览器，服务器返回数据的类型。
         */
        response.setContentType("text/html");
        //通过response获得输出流
        PrintWriter out = response.getWriter();
        //输出
        out.println("<div style='font-size:60px;'>Hello "
                +uname+"</div>");

        //out.close()方法包含flush方法，
        //out.close()不写也可，因为servlet执行完毕会自动调用
        out.close();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <servlet>
    <servlet-name>helloServlet</servlet-name>
    <!-- 写完整的类名 反射 -->
    <servlet-class>web.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <!-- 注意要上下一致 -->
    <servlet-name>helloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
</web-app>

—-(2)———————————————

package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet{
    //如果没有继承HttpServlet，会报500错误

    public void service(HttpServletRequest request,
            HttpServletResponse response)
    throws ServletException,IOException{
        /*
         * 方式一：
         * 设置解析请求数据的编码集
         * 注意：request.setCharacterEncoding("utf-8")
         * 只针对post请求有效(只针对请求包的实体内容)
         */
        request.setCharacterEncoding("utf-8");

        //Integer.parseInt("111a");//会报500错误

        //读请求参数值
        String uname=request.getParameter("uname");

        String[] intrest = request.getParameterValues("intrest");
        for(int i=0;i<intrest.length;i++){
            System.out.println(intrest[i]);
        }


        /*
         * 方式二，需要不停的转换，不推荐
         */
        //uname = new String(
        //      uname.getBytes("iso-8859-1"),"utf-8");

        /*
         * 消息头：告诉浏览器，服务器返回数据的类型。
         */
        response.setContentType("text/html;charset=utf-8");
        //通过response获得输出流
        PrintWriter out = response.getWriter();
        /*
         * 输出 编码  unicode(2个字节表示一个字符)
         * out输出默认编码：iso-8859-1  一个字节一个字符
         * 如果setContentType方法指定的charset=某字符集，
         * 则会使用该字符集去编码
         */
        out.println("<div style='font-size:60px;'>Hello你好 "
                +uname+"</div>");

        //out.close()方法包含flush方法，
        //out.close()不写也可，因为servlet执行完毕会自动调用
        out.close();
    }
}

package web;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;



public class AddEmpServlet extends HttpServlet{

    public void service(HttpServletRequest request,
            HttpServletResponse response)
    throws ServletException,IOException{
        /*
         * 方式一：
         * 设置解析请求数据的编码集
         * 注意：request.setCharacterEncoding("utf-8")
         * 只针对post请求有效(只针对请求包的实体内容)
         */
        request.setCharacterEncoding("utf-8");

        /*
         * 服务器端通常检查参数是否为null，此处暂时不做
         */
        //读请求参数值
        String name=request.getParameter("empname");
        String salary=request.getParameter("salary");
        String age=request.getParameter("age");

        /*
         * 消息头：告诉浏览器，服务器返回数据的类型。
         */
        response.setContentType("text/html;charset=utf-8");
        //通过response获得输出流
        PrintWriter out = response.getWriter();
        /*
         * 输出 编码  unicode(2个字节表示一个字符)
         * out输出默认编码：iso-8859-1  一个字节一个字符
         * 如果setContentType方法指定的charset=某字符集，
         * 则会使用该字符集去编码
         */
        //out.println("<div style='font-size:30px;'> "
                //+empname+salary+age+"</div>");

        //插入数据库
        Connection conn = null;
        PreparedStatement stat = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsd1407?useUnicode=true&characterEncoding=utf8", "root", "zaq12wsx");
            stat = conn.prepareStatement(
                    "INSERT INTO emp(name,salary,age) " +
                    "VALUES(?,?,?)");
            //oracle :  (seq.nextval,?,?)

            stat.setString(1, name);
            stat.setDouble(2,Double.parseDouble(salary));
            stat.setInt(3, Integer.parseInt(age));

            stat.executeUpdate();
            out.println("添加员工成功");

        } catch (Exception e) {
            //记录日志,应该写到文件或数据库，此处暂用e.printStackTrace()处理
            e.printStackTrace();//打印异常的堆栈信息
            /*
             * 看异常是否能恢复，如果不能恢复
             * （比如数据库服务停止，网络中断等产生的异常，一般称为系统异常），
             * 则提示用户稍后重试
             * 
             * （能恢复的异常叫应用异常）
             */
            out.println("系统繁忙，请稍后重试");

        }finally{

            //stat.close();//用连接的时候，先关闭结果集，再关闭statement,再关闭连接
            //此处只需关闭conn（stat会自动关闭）

            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                }
            }
        }


        //out.close()方法包含flush方法，
        //out.close()不写也可，因为servlet执行完毕会自动调用
        out.close();
    }
}

package web;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

public class Test {

    /**
     * @param args
     * @throws UnsupportedEncodingException 
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "过儿";
        //編碼
        String str2 = URLEncoder.encode(str,"utf-8");
        System.out.println(str2);

        //解碼
        String str3 = URLDecoder.decode(str2, "UTF-8");
        System.out.println(str3);
    }

}

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>MyHtml.html</title>


    <!-- 模拟content-type消息头  告诉浏览器解析信息-->
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

  </head>

  <body style="font-size:24px;font-style:italic;">
    <form action="hello" method="post">
      <fieldset>
        <legend>欢迎</legend>
        用户名:<input name="uname"/>

        <br/>
        爱好：放鱼<input type="checkbox" name="intrest" value="fishing" checked="checked"/>
        做饭<input type="checkbox" name="intrest" value="cooking"/>
        足球<input type="checkbox" name="intrest" value="football"/>
        <br/>
         <input type="submit" value="提交"/>
      </fieldset>
    </form>
  </body>
</html>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>MyHtml.html</title>

    <!-- 模拟content-type消息头  告诉浏览器解析信息-->
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

  </head>

  <body style="font-size:24px;font-style:italic;">
    <form action="add" method="post">
      <fieldset>
        <legend>欢迎</legend>
        员工姓名<input name="empname"/><br/>
        工资<input name="salary"/><br/>
        年龄<input name="age"/><br/>
         <input type="submit" value="提交"/>
      </fieldset>
    </form>
  </body>
</html>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <servlet>
    <servlet-name>helloServlet</servlet-name>
    <!-- 写完整的类名 反射 -->
    <servlet-class>web.HelloServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>addEmpServlet</servlet-name>
    <servlet-class>web.AddEmpServlet</servlet-class>
  </servlet>


  <servlet-mapping>
    <!-- 注意name要上下一致 -->
    <servlet-name>helloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
   <servlet-mapping>
    <servlet-name>addEmpServlet</servlet-name>
    <url-pattern>/add</url-pattern>
  </servlet-mapping>
</web-app>

–(3)————————————

dao

package dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import util.DBUtil;
import entity.Employee;
//junit 单元测试 白盒测试
public class EmployeeDAO {
    public void save(Employee e) throws Exception{
        Connection conn = null;
        try {
            conn = DBUtil.getConnection();

            PreparedStatement stat = conn.prepareStatement(
                    "INSERT INTO emp(name,salary,age) " +
                    "VALUES(?,?,?)");
            stat.setString(1, e.getName());
            stat.setDouble(2, e.getSalary());
            stat.setInt(3, e.getAge());

            stat.executeUpdate();

        } catch (Exception e1) {
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }

    public List<Employee> findAll() throws Exception{
        List<Employee> employees = new ArrayList<Employee>();
        Connection conn =null;

        try {
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "SELECT * FROM emp");
            ResultSet rs = stat.executeQuery();

            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                double salary = rs.getDouble("salary");
                int age = rs.getInt("age");
                Employee e = new Employee(id,name,salary,age);
                employees.add(e);
            }

        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.closeConnection(conn);
        }
        return employees;

    }
    public void deleteById(int id) throws Exception{
        Connection conn =null;
        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "DELETE FROM emp WHERE id=?");
            stat.setInt(1, id);
            stat.executeUpdate();
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }
    public Employee loadById(int id) throws Exception{
        Employee e = null;
        Connection conn = null;

        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "SELECT * FROM emp WHERE id=?");
            stat.setInt(1, id);
            ResultSet rs = stat.executeQuery();
            if(rs.next()){
                e = new Employee(
                        id,
                        rs.getString("name"),
                        rs.getDouble("salary"),
                        rs.getInt("age"));
            }
        }catch(Exception e1){
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }

        return e;
    }

    public void modify(Employee e) throws Exception{
        Connection conn =null;

        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "UPDATE emp  SET name=?,salary=?,age=? where id=?");
            stat.setString(1, e.getName());
            stat.setDouble(2, e.getSalary());
            stat.setInt(3, e.getAge());
            stat.setInt(4, e.getId());
            stat.executeUpdate();
        }catch(Exception e1){
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }
}

DAOtest

package dao;

import java.util.List;

import junit.framework.TestCase;
import entity.Employee;
/**
 * junit：右键--> other -->java -->Junit -->Junit test case
        junit4
 * @author Administrator
 * windows-->show view -->outline
 *
 */
public class EmployeeDAOTest extends TestCase {

    public void testSave() throws Exception {
//      //fail("Not yet implemented");
        EmployeeDAO dao = new EmployeeDAO();
        Employee e = new Employee();
        e.setName("kkk");
        e.setSalary(20000);
        e.setAge(33);
        dao.save(e);

    }

    public void testFindAll() throws Exception {
        EmployeeDAO dao = new EmployeeDAO();
        List<Employee> employees = dao.findAll();
        System.out.println(employees);
    }

    public void testDeleteById() throws Exception {
        EmployeeDAO dao = new EmployeeDAO();
        dao.deleteById(8);
    }

    public void testLoadById() throws Exception {
        EmployeeDAO dao = new EmployeeDAO();
        Employee e = dao.loadById(1);
        System.out.println(e);
    }

    public void testModify() throws Exception {
        EmployeeDAO dao = new EmployeeDAO();
        Employee e = new Employee();
        e.setId(3);
        e.setName("Sherry");
        e.setSalary(20000);
        e.setAge(33);
        dao.modify(e);
    }

}

emp实体类

package entity;
/**
 * 实体类
 * 用于封装从数据库查询出来的记录的
 * @author Administrator
 *
 */
public class Employee {
    private int id;
    private String name;
    private double salary;
    private int age;
    public Employee() {
        super();
    }
    public Employee(int id, String name, double salary, int age) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    //通常加实体类的时候会加toString方法
    @Override
    public String toString() {
        return "("+id+","+name+","+salary+","+age+")";
    }


}

DB工具类

package util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
 * JDBC工具类
 */
public class DBUtil {
    public static Connection getConnection() throws Exception{
        Connection conn = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            /*
                     * ?useUnicode=true&characterEncoding=utf8
                     * 这两个选项参数的作用是告诉jdbc驱动使用
                     *"utf-8"来编码和解码。
                     */
            conn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/jsd1407?useUnicode=true&characterEncoding=utf8",
                    "root",
                    "zaq12wsx");

        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return conn;
    }

    public static void closeConnection(Connection conn){
        if(conn != null){
            try {
                /*
                 * 连接建好后，才会返回connection对象
                 * 所以打印getConnection（）来测试方法的正确与否
                 */
                conn.close();
            } catch (SQLException e) {
            }
        }
    }

    public static void main(String[] args){

        try {
            System.out.println(getConnection());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

添加员工

package web;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;
import entity.Employee;

import util.DBUtil;



public class AddEmpServlet extends HttpServlet{

    public void service(HttpServletRequest request,
            HttpServletResponse response)
    throws ServletException,IOException{
        /*
         * 方式一：
         * 设置解析请求数据的编码集
         * 注意：request.setCharacterEncoding("utf-8")
         * 只针对post请求有效(只针对请求包的实体内容)
         */
        request.setCharacterEncoding("utf-8");

        /*
         * 服务器端通常检查参数是否为null，此处暂时不做
         */
        //读请求参数值
        String name=request.getParameter("empname");
        String salary=request.getParameter("salary");
        String age=request.getParameter("age");

        /*
         * 消息头：告诉浏览器，服务器返回数据的类型。
         */
        response.setContentType("text/html;charset=utf-8");
        //通过response获得输出流
        PrintWriter out = response.getWriter();
        /*
         * 输出 编码  unicode(2个字节表示一个字符)
         * out输出默认编码：iso-8859-1  一个字节一个字符
         * 如果setContentType方法指定的charset=某字符集，
         * 则会使用该字符集去编码
         */
        //out.println("<div style='font-size:30px;'> "
                //+empname+salary+age+"</div>");

        //插入数据库

        try {
            /**
            conn = DBUtil.getConnection();
            //Class.forName("com.mysql.jdbc.Driver");
              //conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsd1407", "root", "zaq12wsx");

            stat = conn.prepareStatement(
                    "INSERT INTO emp(name,salary,age) " +
                    "VALUES(?,?,?)");
            //oracle :  (seq.nextval,?,?)

            stat.setString(1, name);
            stat.setDouble(2,Double.parseDouble(salary));
            stat.setInt(3, Integer.parseInt(age));

            stat.executeUpdate();
            */

            //out.println("添加员工成功");
            /*
             * 重定向之前，服务器会清空response对象上缓存的数据。
             * 所以，"添加员工成功"不显示
             * 
             * out.println()实际上还没发送，
             * 而是保存在response对象上
             * 解决方法如下为使用JS：
             */
            /*
             * setTimeOut(function(){
             * location='list'},1000)
             */
            /*
            out.println("添加员工成功");
            out.close();*/

            EmployeeDAO dao = new EmployeeDAO();
            Employee e = new Employee();
            e.setName(name);
            e.setSalary(Double.parseDouble(salary));
            e.setAge(Integer.parseInt(age));
            dao.save(e);
            response.sendRedirect("list");

            //可指定网址：
            //response.sendRedirect("http://www.tmooc.cn/web/library/library.html");
            //System.out.println("重定向之后的代码会执行");
            //out.println("<a href='list'>员工列表</a>");

        } catch (Exception e) {
            //记录日志,应该写到文件或数据库，此处暂用e.printStackTrace()处理
            e.printStackTrace();//打印异常的堆栈信息
            /*
             * 看异常是否能恢复，如果不能恢复
             * （比如数据库服务停止，网络中断等产生的异常，一般称为系统异常），
             * 则提示用户稍后重试
             * 
             * （能恢复的异常叫应用异常）
             */
            out.println("系统繁忙，请稍后重试");

        }/*finally{

            //stat.close();//用连接的时候，先关闭结果集，再关闭statement,再关闭连接
            //此处只需关闭conn（stat会自动关闭）
            DBUtil.closeConnection(conn);
            /*
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                }
            }*/
        //}


        //out.close()方法包含flush方法，
        //out.close()不写也可，因为servlet执行完毕会自动调用
        out.close();
    }
}

删除员工

package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;

public class DelEmpServlet extends HttpServlet{
    public void service(HttpServletRequest request,
            HttpServletResponse response) throws
            ServletException,IOException{
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        int id = Integer.parseInt(request.getParameter("id"));

        try{
            EmployeeDAO dao = new EmployeeDAO();
            dao.deleteById(id);
            response.sendRedirect("list");
        }catch(Exception e){
            e.printStackTrace();
            out.println("稍后重试");
        }

    }

}

员工一览

package web;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;
import entity.Employee;

public class ListEmpServlet extends HttpServlet{
    public void service(HttpServletRequest request,
            HttpServletResponse response) throws
            ServletException,IOException{
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        try {
            EmployeeDAO dao = new EmployeeDAO();
            List<Employee> employees = dao.findAll();

            out.println("<table width='60%' border='1' cellspacing='0' cellpadding='0'>");
            out.println("<tr><td>ID</td><td>姓名</td><td>薪水</td><td>年龄</td><td>操作</td></tr>");


            for(int i=0;i<employees.size();i++){
                Employee e = employees.get(i);
                int id = e.getId();
                out.println("<tr><td>"+
                        e.getId()+"</td><td>"+
                        e.getName()+"</td><td>"+
                        e.getSalary()+"</td><td>"+
                        e.getAge()+"</td><td><a href='del?id="+id+"'>删除</a>" +
                                "&nbsp;<a href='load?id="+id+"'>修改</a></td></tr>");
            }

            out.println("</table>");
            out.println("<a href='addEmp.html'>添加员工</a>");
        } catch (Exception e) {
            e.printStackTrace();
            out.println("稍后重试");
        }
    }

}

修改第一步：load

package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;
import entity.Employee;

public class LoadEmpServlet extends HttpServlet{
    public void service(HttpServletRequest request,
            HttpServletResponse response) throws
            ServletException,IOException{
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        int id = Integer.parseInt(request.getParameter("id"));
        try{
            EmployeeDAO dao = new EmployeeDAO();

            Employee e = dao.loadById(id);
            if(e != null){
                String name = e.getName();
                double salary = e.getSalary();
                int age = e.getAge();

                out.println("<form action='modify' method='post'>");
                out.println("id:"+id+"<br/>");
                out.println("姓名:<input name='name' value='"+name+"'/><br/>");
                out.println("薪水:<input name='salary' value='"+salary+"'/><br/>");
                out.println("年龄:<input name='age' value='"+age+"'/><br/>");
                //隐藏域
                out.println("年龄:<input type='hidden' name='id' value='"+id+"'/><br/>");

                out.println("<input type='submit' value='提交'/>");

                out.println("</form>");
            }
        }catch(Exception e){
            e.printStackTrace();
            out.println("稍后重试");
        }
    }

}

修改员工第二部

package web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;
import entity.Employee;

public class ModifyEmpServlet extends HttpServlet{
    public void service(HttpServletRequest request,
            HttpServletResponse response) throws
            ServletException,IOException{
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        int id = Integer.parseInt(request.getParameter("id"));
        String name = request.getParameter("name");
        String salary = request.getParameter("salary");
        String age = request.getParameter("age");

        Employee e = new Employee(id,name,Double.parseDouble(salary),Integer.parseInt(age));
        try{
            EmployeeDAO dao = new EmployeeDAO();
            dao.modify(e);
            response.sendRedirect("list");

        }catch(Exception e1){
            e1.printStackTrace();
            out.println("稍后重试");
        }
    }

}

添加员工html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>addEmp.html</title>

    <!-- 模拟content-type消息头  告诉浏览器解析信息-->
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

  </head>

  <body>
    <form action="add" method="post">
      <fieldset>
        <legend>欢迎</legend>
        姓名<input name="name" /><br/><br/>
        工资<input name="salary" /><br/><br/>
        年龄<input name="age" /><br/><br/>
        <input type="submit" value="提交">
      </fieldset>
    </form>
  </body>
</html>

xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <servlet>
    <servlet-name>ListEmpServlet</servlet-name>
    <servlet-class>web.ListEmpServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>addEmpServlet</servlet-name>
    <servlet-class>web.AddEmpServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>delEmpServlet</servlet-name>
    <servlet-class>web.DelEmpServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>loadEmpServlet</servlet-name>
    <servlet-class>web.LoadEmpServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>modifyEmpServlet</servlet-name>
    <servlet-class>web.ModifyEmpServlet</servlet-class>
  </servlet>


  <servlet-mapping>
    <servlet-name>ListEmpServlet</servlet-name>
    <url-pattern>/list</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>addEmpServlet</servlet-name>
    <url-pattern>/add</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>delEmpServlet</servlet-name>
    <url-pattern>/del</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>loadEmpServlet</servlet-name>
    <url-pattern>/load</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>modifyEmpServlet</servlet-name>
    <url-pattern>/modify</url-pattern>
  </servlet-mapping>
</web-app>

—(3_2)合并servlet uri（mysql和oracle）————————-

DBUtil

package util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
 * JDBC工具类
 */
public class DBUtil {
    public static Connection getConnection() throws Exception{
        Connection conn = null;

        try {
            /*mysql:
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/jsd1407",
                    "root",
                    "zaq12wsx");
            */
            //oracle
            Class.forName("oracle.jdbc.driver.OracleDriver");
            conn = DriverManager.getConnection(
                    "jdbc:oracle:thin:@localhost:1521:xe",
                    "system",
                    "zaq12wsx");
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return conn;
    }

    public static void closeConnection(Connection conn){
        if(conn != null){
            try {
                /*
                 * 连接建好后，才会返回connection对象
                 * 所以打印getConnection（）来测试方法的正确与否
                 */
                conn.close();
            } catch (SQLException e) {
            }
        }
    }

    public static void main(String[] args){

        try {
            System.out.println(getConnection());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

EmployeeDAO

package dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import util.DBUtil;
import entity.Employee;
//junit 单元测试 白盒测试
public class EmployeeDAO {
    public void save(Employee e) throws Exception{
        Connection conn = null;
        try {
            conn = DBUtil.getConnection();

            /*mysql
            PreparedStatement stat = conn.prepareStatement(
                    "INSERT INTO emp(name,salary,age) " +
                    "VALUES(?,?,?)");
                    */

            //Oracle
            PreparedStatement stat = conn.prepareStatement(
                    "INSERT INTO emp(id,name,salary,age) " +
                    "VALUES(emp_id_seq.nextval,?,?,?)");
            stat.setString(1, e.getName());
            stat.setDouble(2, e.getSalary());
            stat.setInt(3, e.getAge());

            stat.executeUpdate();

        } catch (Exception e1) {
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }

    public List<Employee> findAll() throws Exception{
        List<Employee> employees = new ArrayList<Employee>();
        Connection conn =null;

        try {
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "SELECT * FROM emp");
            ResultSet rs = stat.executeQuery();

            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                double salary = rs.getDouble("salary");
                int age = rs.getInt("age");
                Employee e = new Employee(id,name,salary,age);
                employees.add(e);
            }

        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.closeConnection(conn);
        }
        return employees;

    }
    public void deleteById(int id) throws Exception{
        Connection conn =null;
        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "DELETE FROM emp WHERE id=?");
            stat.setInt(1, id);
            stat.executeUpdate();
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }
    public Employee loadById(int id) throws Exception{
        Employee e = null;
        Connection conn = null;

        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "SELECT * FROM emp WHERE id=?");
            stat.setInt(1, id);
            ResultSet rs = stat.executeQuery();
            if(rs.next()){
                e = new Employee(
                        id,
                        rs.getString("name"),
                        rs.getDouble("salary"),
                        rs.getInt("age"));
            }
        }catch(Exception e1){
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }

        return e;
    }

    public void modify(Employee e) throws Exception{
        Connection conn =null;

        try{
            conn = DBUtil.getConnection();
            PreparedStatement stat = conn.prepareStatement(
                    "UPDATE emp  SET name=?,salary=?,age=? where id=?");
            stat.setString(1, e.getName());
            stat.setDouble(2, e.getSalary());
            stat.setInt(3, e.getAge());
            stat.setInt(4, e.getId());
            stat.executeUpdate();
        }catch(Exception e1){
            e1.printStackTrace();
            throw e1;
        }finally{
            DBUtil.closeConnection(conn);
        }
    }
}

ActionServlet

package web;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dao.EmployeeDAO;
import entity.Employee;

public class ActionServlet extends HttpServlet{
    public ActionServlet(){
        //servlet其实是单例，只创建一个对象
        System.out.println("ActionServlet's constructor..");
    }

    public void service(HttpServletRequest request,
            HttpServletResponse response)
    throws ServletException,IOException{
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();

        //System.out.println("ActionSevlet service");

        //获得请求资源路径
        String uri = request.getRequestURI();
        //System.out.println("uri:"+uri);

        //分析请求资源路径
        String action = uri.substring(uri.lastIndexOf("/")+1,uri.lastIndexOf("."));
        //System.out.println("action:"+action);
        //依据分析结果调用不同的名字来处理

        //获取列表
        if("list".equals(action)){
            try {
                EmployeeDAO dao = new EmployeeDAO();
                List<Employee> employees = dao.findAll();

                out.println("<table width='60%' border='1' cellspacing='0' cellpadding='0'>");
                out.println("<tr><td>ID</td><td>姓名</td><td>薪水</td><td>年龄</td><td>操作</td></tr>");


                for(int i=0;i<employees.size();i++){
                    Employee e = employees.get(i);
                    int id = e.getId();
                    out.println("<tr><td>"+
                            e.getId()+"</td><td>"+
                            e.getName()+"</td><td>"+
                            e.getSalary()+"</td><td>"+
                            e.getAge()+"</td><td><a href='del.do?id="+id+"'>删除</a>" +
                                    "&nbsp;<a href='load.do?id="+id+"'>修改</a></td></tr>");
                }

                out.println("</table>");
                out.println("<a href='addEmp.html'>添加员工</a>");
            } catch (Exception e) {
                e.printStackTrace();
                out.println("系统繁忙");
            }
            //添加员工
        }else if("add".equals(action)){

            //读请求参数值
            String name= request.getParameter("name");
            String salary= request.getParameter("salary");
            String age= request.getParameter("age");
            try {
                Employee e = new Employee();
                e.setName(name);
                e.setSalary(Double.parseDouble(salary));
                e.setAge(Integer.parseInt(age));

                EmployeeDAO dao = new EmployeeDAO();
                dao.save(e);
                response.sendRedirect("list.do");
            } catch (Exception e) {
                e.printStackTrace();
                out.println("系统繁忙");
            }   
            //删除员工
        }else if("del".equals(action)){
            int id = Integer.parseInt(request.getParameter("id"));

            try{
                EmployeeDAO dao = new EmployeeDAO();
                dao.deleteById(id);
                response.sendRedirect("list.do");
            }catch(Exception e){
                e.printStackTrace();
                out.println("稍后重试");
            }
            //修改第一步load
        }else if("load".equals(action)){
            int id = Integer.parseInt(request.getParameter("id"));
            try{
                EmployeeDAO dao = new EmployeeDAO();

                Employee e = dao.loadById(id);
                if(e != null){
                    String name = e.getName();
                    double salary = e.getSalary();
                    int age = e.getAge();

                    out.println("<form action='modify.do' method='post'>");
                    out.println("id:"+id+"<br/>");
                    out.println("姓名:<input name='name' value='"+name+"'/><br/>");
                    out.println("薪水:<input name='salary' value='"+salary+"'/><br/>");
                    out.println("年龄:<input name='age' value='"+age+"'/><br/>");
                    //隐藏域
                    out.println("年龄:<input type='hidden' name='id' value='"+id+"'/><br/>");

                    out.println("<input type='submit' value='提交'/>");

                    out.println("</form>");
                }
            }catch(Exception e){
                e.printStackTrace();
                out.println("稍后重试");
            }
            //修改员工第二部,modify
        }else if("modify".equals(action)){
            int id = Integer.parseInt(request.getParameter("id"));
            String name = request.getParameter("name");
            String salary = request.getParameter("salary");
            String age = request.getParameter("age");

            Employee e = new Employee(id,name,Double.parseDouble(salary),Integer.parseInt(age));
            try{
                EmployeeDAO dao = new EmployeeDAO();
                dao.modify(e);
                response.sendRedirect("list.do");

            }catch(Exception e1){
                e1.printStackTrace();
                out.println("稍后重试");
            }
        }
    }

}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>web.ActionServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

addEmp.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>addEmp.html</title>

    <!-- 模拟content-type消息头  告诉浏览器解析信息-->
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

  </head>

  <body>
    <form action="add.do" method="post">
      <fieldset>
        <legend>欢迎</legend>
        姓名<input name="name" /><br/><br/>
        工资<input name="salary" /><br/><br/>
        年龄<input name="age" /><br/><br/>
        <input type="submit" value="提交">
      </fieldset>
    </form>
  </body>
</html>