Hibernate 入门01

项目结构  这个是普通java web 项目

 

依赖的jar

 

 

 

WebContent

 

准备工作&步骤

1.导入mysql 驱动包
2.导入hibernate required包
3.导入log4j 包
4.写domain
5.在domain的同一包下写配置文件
6.在hibernate-core/hibernate包的最后面的hibernate-mapping-3.0.dtd文件里面复制约束
7.编写hibernate 核心配置文件 放在src目录下 名称一定为hibernate.cfg.xml
复制hibernate-config.dtd约束

 

建表语句

CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_user_id` bigint(32) DEFAULT NULL COMMENT '负责人id',
  `cust_create_id` bigint(32) DEFAULT NULL COMMENT '创建人id',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_linkman` varchar(64) DEFAULT NULL COMMENT '联系人',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=100 DEFAULT CHARSET=utf8;

/*Data for the table `cst_customer` */

insert  into 
`cst_customer`(`cust_id`,`cust_name`,`cust_user_id`,`cust_create_id`,`cust_source`,`cust_industry`,`cust_level`,`cust_linkman`,`cust_phone`,`cust_mobile`) 
values 
(97,'张明',NULL,NULL,'网上',NULL,'高级','小黑','110','1234567890123'),
(98,'关西',NULL,NULL,'网上',NULL,'高级','白痴','114','13660500555'),
(99,'张三',NULL,NULL,'学校',NULL,'大神','小白','115','15815844555');

 

domain

实体类Customer.java

package cn.cmdzhizhu.domain;

/**
 * 客户的javabean
 * @author xlfd
 *
 */
public class Customer {
    /**
     * CREATE TABLE `cst_customer` (
     *  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
          `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
          `cust_user_id` bigint(32) DEFAULT NULL COMMENT '负责人id',
          `cust_create_id` bigint(32) DEFAULT NULL COMMENT '创建人id',
          `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
          `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
          `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
          `cust_linkman` varchar(64) DEFAULT NULL COMMENT '联系人',
          `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
          `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',

     */
    //以后使用包装类 默认值是null
    private Long cust_id;
    private String cust_name;
    private Long cust_user_id;
    
    private Long cust_create_id;
    private String cust_source;
    private String cust_industry;
    
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    
    private String cust_mobile;

    public Long getCust_id() {
        return cust_id;
    }

    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }

    public String getCust_name() {
        return cust_name;
    }

    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }

    public Long getCust_user_id() {
        return cust_user_id;
    }

    public void setCust_user_id(Long cust_user_id) {
        this.cust_user_id = cust_user_id;
    }

    public Long getCust_create_id() {
        return cust_create_id;
    }

    public void setCust_create_id(Long cust_create_id) {
        this.cust_create_id = cust_create_id;
    }

    public String getCust_source() {
        return cust_source;
    }

    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }

    public String getCust_industry() {
        return cust_industry;
    }

    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }

    public String getCust_level() {
        return cust_level;
    }

    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }

    public String getCust_linkman() {
        return cust_linkman;
    }

    public void setCust_linkman(String cust_linkman) {
        this.cust_linkman = cust_linkman;
    }

    public String getCust_phone() {
        return cust_phone;
    }

    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }

    public String getCust_mobile() {
        return cust_mobile;
    }

    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }

    @Override
    public String toString() {
        return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_user_id=" + cust_user_id
                + ", cust_create_id=" + cust_create_id + ", cust_source=" + cust_source + ", cust_industry="
                + cust_industry + ", cust_level=" + cust_level + ", cust_linkman=" + cust_linkman + ", cust_phone="
                + cust_phone + ", cust_mobile=" + cust_mobile + "]";
    }
    
    
    
}

 对应的hibernate配置文件

Customer.hbn.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <!-- 能上网 会找网络的dtd 不能上网，要自己配置本地的 -->   
<hibernate-mapping>
    <!-- 配置类和表结构的映射 -->
    <class name="cn.cmdzhizhu.domain.Customer" table="cst_customer">
        <!-- 配置id 
            见到name属性 javabean的属性
            见到column属性 是表格结构字段
        -->
        <id name="cust_id" column="cust_id">
            <!-- 主键的生成策略-->
            <generator class="native"></generator>
        </id>
        
        <!-- 配置其他属性 -->
        <property name="cust_name" column="cust_name"></property>
        <property name="cust_user_id" column="cust_user_id"></property>
        <property name="cust_create_id" column="cust_create_id"></property>
        <property name="cust_source" column="cust_source"></property>
        <property name="cust_industry" column="cust_industry"></property>
        <property name="cust_level" column="cust_level"></property>
        <property name="cust_linkman" column="cust_linkman"></property>
        <property name="cust_phone" column="cust_phone"></property>
        <property name="cust_mobile" column="cust_mobile"></property>
    </class>
</hibernate-mapping>

 

dao层

CustomerDao.java

package cn.cmdzhizhu.dao;

import java.util.List;

import org.apache.catalina.User;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.utils.HibernateUtils;

public class CustomerDao {


    /**
     * 查询所有客户
     */
    public List<Customer> getAllCustomer(){
        //获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        //创建查询接口
        Query query = session.createQuery("from Customer");
        
        //查询所有条数 select * from 表
        List<Customer> list = query.list();
        
        //提交事务
        tr.commit();
        //释放资源
        session.close();
        
        return list;
        
    }
    
    
    /**
     * 保存客户
     * @param c
     */
    public void save(Customer c){
        //先获取session
        Session session = HibernateUtils.getSession();
        
        //开启事务
        Transaction tr  = session.beginTransaction();
        //保存用户
        session.save(c);
        
        //提交事务
        tr.commit();
        
        //关闭资源
        session.close();
        
    }


    /**
     * 根据 cust_id  主键 查询并返回一个Customer 
     * @param cust_id
     * @return
     */
    public Customer getCustomerById(Long cust_id) {
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //测试查询方法的两个参数，arg0 查询javabean的class 对象 arg1 主键的值
        Customer c  = session.get(Customer.class, cust_id);
        //System.out.println(c);
        //提交事务
        tr.commit();
        //释放资源
        session.close();
        
        return c;
    }


    /**
     * 编辑更新 Customer
     * @param c
     */
    public void updateCustomer(Customer c) {
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        session.update(c);
    
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }


    /**
     * 根据 cust_id 删除客户信息
     * @param cust_id
     */
    public void deleteCustomerById(Long cust_id) {
        //加载配置文件 获取factory 对象 获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        //先查询 后删除
        Customer c = session.get(Customer.class, cust_id);
        //删除客户
        session.delete(c);
        //提交事务
        tr.commit();
        //释放资源
        session.close();
        
    }


    /**
     * 带查询条件查询所有客户
     * @param custName
     * @return
     */
    public List<Customer> getAllCustomer(String custName) {
        //查询
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        //查询
        Criteria criteria = session.createCriteria(Customer.class);
        
        //添加查询条件
        if(custName!=null && !custName.trim().isEmpty()){
            //添加查询条件
            criteria.add(Restrictions.like("cust_name", "%"+custName+"%"));
        }
        List<Customer> list = criteria.list();
        
        tr.commit();
        session.close();
        
        return list;
    }
}

 

service 层

CustomerService.java

package cn.cmdzhizhu.service;

import java.util.List;

import cn.cmdzhizhu.dao.CustomerDao;
import cn.cmdzhizhu.domain.Customer;

public class CustomerService {

    
    /**
     * 查询所有客户
     */
    public List<Customer> getAllCustomer(){
        
        return new CustomerDao().getAllCustomer();
        
    }
    
    /**
     * 保存客户
     * @param c
     */
    public void saveCustomer(Customer c){
        //调用dao
        new CustomerDao().save(c);
        
    }

    /**
     * 根据 cust_id 查询并返回一个customer对象
     * @param cust_id
     * @return
     */
    public static Customer getCustomerById(Long cust_id) {
        
        return new CustomerDao().getCustomerById(cust_id);
    }

    /**
     * 编辑更新 Customer
     * @param c
     */
    public void updateCustomer(Customer c) {
        
        new CustomerDao().updateCustomer(c);
    }

    /**
     * 根据cust_id删除客户信息
     * @param cust_id
     */
    public void deleteCustomerById(Long cust_id) {
        
        new CustomerDao().deleteCustomerById(cust_id);
        
    }

    /**
     * 带查询条件的查询所有客户
     * @param custName
     * @return
     */
    public List<Customer> getAllCustomer(String custName) {
        
     return new CustomerDao().getAllCustomer(custName);
    }
}

 

servlet层 这里是一个增删改查操作一个类，这样写不是很好，后期会把一个实体类对应的增删改查写在一个类中

CustomerList.java 

带查询条件的查询所有客户，如果条件为空则查询所有

package cn.cmdzhizhu.servlet;

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

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

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.service.CustomerService;

/**
 * 查询客户信息 并在customer/list.jsp展示
 */
public class CustomerList extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("我在CustomerList");
        //编码
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        
        //先获取请求的参数  list.jsp查询 客户
        //获取到客户的名称
        String custName = request.getParameter("custName");
        System.out.println(custName);
        
        //查询所有的方法的时候  传入进去
        List<Customer> list = new CustomerService().getAllCustomer(custName);
        
//        //调用service层 查询 所有客户  不分页
//        List<Customer> list = new CustomerService().getAllCustomer();
        
        //将list放入request域中
        request.setAttribute("list", list);
        
        //请求转发到/customer/list.jsp
        request.getRequestDispatcher("/jsp/customer/list.jsp").forward(request, response);
    }

    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
    }

}

CustomerDelete 

package cn.cmdzhizhu.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.service.CustomerService;

/**
 *根据cust_id删除客户信息
 */
public class CustomerDelete extends HttpServlet {
    private static final long serialVersionUID = 1L;


    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //编码
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        
        //接收参数
        String custId = request.getParameter("cust_id");
        Long cust_id = Long.parseLong(custId);
        
        //调用业务层  删除客户信息
        new CustomerService().deleteCustomerById(cust_id);
        
        //重定向到customer/list.jsp
        response.sendRedirect(request.getContextPath()+"/customerList");
        
    }

    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        doGet(request, response);
    }

}

CustomerEdit 

package cn.cmdzhizhu.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.service.CustomerService;

/**
 * 跳转到编辑客户信息
 */
public class CustomerEdit extends HttpServlet {
    private static final long serialVersionUID = 1L;

    
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        //接收参数
        String custid = request.getParameter("cust_id");
        Long cust_id = Long.parseLong(custid);
        
        //调用service
        Customer c = CustomerService.getCustomerById(cust_id);
        System.out.println(c);
        //将c 放入request
        request.setAttribute("customer", c);
//        //重定向到 customer/list.jsp
//        response.sendRedirect(request.getContextPath()+"/jsp/customer/list.jsp");
        //跳转到customer/list.jsp
        request.getRequestDispatcher("/jsp/customer/edit.jsp").forward(request, response);;
        
    }

    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
        doGet(request, response);
    }

}

SaveCustomer 

package cn.cmdzhizhu.servlet;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

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

import org.apache.commons.beanutils.BeanUtils;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.service.CustomerService;

/**
 * 添加客户控制器
 */
public class SaveCustomer extends HttpServlet {
    private static final long serialVersionUID = 1L;
       
    
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //接收请求参数
        request.setCharacterEncoding("utf-8");
        Map<String, String[]> map = request.getParameterMap();
        //封装数据  使用BeanUtils工具  导入jar包
        Customer c = new Customer();
        try {
            //封装数据
            BeanUtils.populate(c, map);
            //调用业务层
            new CustomerService().saveCustomer(c);
            System.out.println("添加客户成功了");
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        doGet(request, response);
    }

}

UpdateCustomer 

package cn.cmdzhizhu.servlet;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

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

import org.apache.commons.beanutils.BeanUtils;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.service.CustomerService;

/**
 * 更新在edit.jsp 编辑的信息
 */
public class UpdateCustomer extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        //接收参数
        //String custid = request.getParameter("cust_id");
//        Long cust_id = Long.parseLong(custid);
//        System.out.println(cust_id);
        Map<String, String[]> map = request.getParameterMap();
        //封装数据  使用BeanUtils工具  导入jar包
        Customer c = new Customer();
        
        try {
            //封装参数
            BeanUtils.populate(c, map);
            //调用业务层
            new CustomerService().updateCustomer(c);
            System.out.println("更新成功");
            //重定向
            response.sendRedirect(request.getContextPath()+"/customerList");
        } catch (Exception e) {
            
            e.printStackTrace();
        }
        
        
        
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        doGet(request, response);
    }

}

 

单元测试 测试hibernate是否能crud

Demo1.java

package cn.cmdzhizhu.test;

import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.cmdzhizhu.domain.Customer;
import cn.cmdzhizhu.utils.HibernateUtils;

/**
 * 测试Hibernate 框架
 * @author cmdzhizhu
 *
 */
public class Demo1 {

    
    /**
     * 测试查询的方法
     * 注意：删除或者修改，先查询再删除 或者修改
     */
    @Test
    public void testSel(){
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        //创建查询的接口
        Query query = session.createQuery("from Customer");
    
        //查询所有的数 select * from 表
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }
    
    
    
    /**
     * 测试添加或修改
     * 注意：删除或者修改，先查询再删除 或者修改
     */
    @Test
    public void testSaveOrUpdate(){
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        
        //错误演示
//        Customer c = new Customer();
//        c.setCust_id(10L);//不能自己设置
        
        //线查询再改
        Customer c= session.get(Customer.class, 95L);
        c.setCust_name("小明");
        session.saveOrUpdate(c);
    
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }
    
    
    
    
    /**
     * 测试修改方法
     * 注意：删除或者修改，先查询再删除 或者修改
     */
    @Test
    public void testUpdate(){
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //测试查询方法的两个参数，arg0 查询javabean的class 对象 arg1 主键的值
        Customer c  = session.get(Customer.class, 95l);
        
        //设置客户的信息
        c.setCust_name("小肠");
        c.setCust_level("3");
        
        //修改
        session.update(c);
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }
    
    
    
    
    
    
    
    /**
     * 测试删除的方法
     * 注意：删除或者修改，先查询再删除 或者修改
     */
    @Test
    public void testDel(){
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //测试查询方法的两个参数，arg0 查询javabean的class 对象 arg1 主键的值
        Customer c  = session.get(Customer.class, 96l);
        
        //删除客户
        session.delete(c);
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }
    
    
    /**
     * 测试get()方法，获取查询 通过主键来查询一条记录
     */
    @Test
    public void testGet(){
        //原来：加载配置文件  获取Factory对象  获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        //测试查询方法的两个参数，arg0 查询javabean的class 对象 arg1 主键的值
        Customer c  = session.get(Customer.class, 96l);
        System.out.println(c);
        //提交事务
        tr.commit();
        //释放资源
        session.close();
    }
    
    
    /**
     * 测试工具类
     */
    @Test
    public void testSave2(){
        /**
         * 1.加载配置文件
         * 2.创建SessionFactory对象  生成Session对象
         * 3.创建session对象
         * 4.开启事务
         * 5.编写保存的代码
         * 6.提交事务
         * 7.释放资源
         */
        
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        Customer c = new Customer();
        c.setCust_name("小风");
        session.save(c);
        //提交事务
        tr.commit();
        session.close();
        
        
    }
    
    
    
    /**
     * 测试保存客户
     */
    @Test
    public void testSave(){
        /**
         * 1.加载配置文件
         * 2.创建SessionFactory对象  生成Session对象
         * 3.创建session对象
         * 4.开启事务
         * 5.编写保存的代码
         * 6.提交事务
         * 7.释放资源
         */
        
        //1.加载配置文件
        Configuration config = new Configuration();
        //默认加载srv目录下hibernate.cfg,xml的配置文件
        config.configure();
        //2.创建SessionFactory对象
        SessionFactory factory = config.buildSessionFactory();
        //3.创建session对象
        Session session = factory.openSession();
        //4.开启事务
        Transaction tr = session.beginTransaction();
        //5.编写保存的代码
        Customer c = new Customer();
        //c.setCust_id(null);//主键是自动递增了
        c.setCust_name("测试");
        c.setCust_level("2");
        c.setCust_phone("114");
        
        //保存数据  操作对象就相当于操作数据库表结构
        session.save(c);
        
        //6提交事务
        tr.commit();
        //7.释放资源
        session.close();
        factory.close();
        
        
    }
    
    
}

 

web.xml 配置servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>day28Hibernate_01</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <description></description>
    <display-name>SaveCustomer</display-name>
    <servlet-name>SaveCustomer</servlet-name>
    <servlet-class>cn.cmdzhizhu.servlet.SaveCustomer</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>SaveCustomer</servlet-name>
    <url-pattern>/saveCustomer</url-pattern>
  </servlet-mapping>
  <servlet>
    <description></description>
    <display-name>CustomerList</display-name>
    <servlet-name>CustomerList</servlet-name>
    <servlet-class>cn.cmdzhizhu.servlet.CustomerList</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>CustomerList</servlet-name>
    <url-pattern>/customerList</url-pattern>
  </servlet-mapping>
  <servlet>
    <description></description>
    <display-name>CustomerEdit</display-name>
    <servlet-name>CustomerEdit</servlet-name>
    <servlet-class>cn.cmdzhizhu.servlet.CustomerEdit</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>CustomerEdit</servlet-name>
    <url-pattern>/customerEdit</url-pattern>
  </servlet-mapping>
  <servlet>
    <description></description>
    <display-name>CustomerDelete</display-name>
    <servlet-name>CustomerDelete</servlet-name>
    <servlet-class>cn.cmdzhizhu.servlet.CustomerDelete</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>CustomerDelete</servlet-name>
    <url-pattern>/customerDelete</url-pattern>
  </servlet-mapping>
  <servlet>
    <description></description>
    <display-name>UpdateCustomer</display-name>
    <servlet-name>UpdateCustomer</servlet-name>
    <servlet-class>cn.cmdzhizhu.servlet.UpdateCustomer</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>UpdateCustomer</servlet-name>
    <url-pattern>/updateCustomer</url-pattern>
  </servlet-mapping>
</web-app>