1、JavaEE三层架构

6、Web项目架构与数据库使用 - 图1

客户端提交发送到后端的数据，会先在Web层获取并封装成Bean对象，然后调用Service层的方法处理业务，再调用Dao层的方法与数据库交互实现数据的持久化存储

分层的目的是为了解耦，所谓的解耦就是降低代码的耦合度，方便项目后期的维护与升级。

6、Web项目架构与数据库使用 - 图2

在BookS这个项目中，src文件夹用来存放源代码，web用来存放页面资源

在src这个文件夹中有一个总包“com.chang”存在，以及存放连接数据库所需的配置文件“jdbc.properties”。

在“com.chang”包中又存在6个包，其各自功能如下：

包名 作用
dao 服务于service层，实现业务数据的增删改查。
pojo 存放业务所需要的对象，例如User对象
service 存放针对某一对象所要做的操作，例如增删改查
test 针对一些工具类、或者对象方法进行测试
utils 工具类，用来存放一些工具，例如连接数据库
web 视图层，通过servlet获取前端的数据

针对具体使用流程，可将上述表格中的内容稍作调整，（代码编写过程中可将第2到第5顺序调换 1->5->4->3->2->6)，6可以穿插进行

包名 作用
pojo 存放User对象
web 获取前端数据，例如名称、密码、验证码，然后可构建一个User对象，针对次对象，要进行业务处理，则需要用到service包中UserService类，“private UserService userService = new UserServiceImpl();”然后使用相关方法“userService.registUser(User);”
service 为了更好的解耦，首先编写UserService的接口，然后在impl包中编写UserServiceImpl实现类，在此类中因为要实现与数据库的交互，所以要在dao包中实现UserDao类，“private UserDao userDao = new UserDaoImpl();”，“userDao.saveUser(user);”
dao 在此包中除了要编写实现某类对象数据库操作的接口以及实现类，还要编写基础类，具体实现类要继承实现类并实现接口方法，例如UserDaoImpl extends BaseDao implements UserDao。在BaseDao类中要实现具体的增删改查，则要使用utils包中的JdbcUtils类，以及一些其他的官方包“private QueryRunner queryRunner=new QueryRunner();”
utils 在这个包中编写JdbcUtils方法读取src目录下的配置文件，实现与数据库的连接、关闭操作
test 在这个包中对实现的方法进行测试，例如JdbcUtils、UserService、UserDao

6、Web项目架构与数据库使用 - 图3

2、创建项目需要的数据库和表

在终端的MySQL中输入如下命令：

  1. drop database if exists book;
  2. create database book;
  3. use book;
  4. create table t_user(
  5. `id` int primary key auto_increment,
  6. `username` varchar(20) not null unique,
  7. `password` varchar(32) not null,
  8. `email` varchar(200)
  9. );
  10. insert into t_user(`username`,`password`,`email`) values('admin','admin','admin@atguigu.com');
  11. select * from t_user;

6、Web项目架构与数据库使用 - 图4

3、编写数据库表对应的JavaBean对象

User

  1. package com.chang.pojo;
  3. public class User {
  4.     private Integer id;
  5.     private String username;
  6.     private String password;
  7.     private String email;
  9.     public User() {}
  11.     public User(Integer id, String username, String password, String email) {
  12.         this.id = id;
  13.         this.username = username;
  14.         this.password = password;
  15.         this.email = email;
  16.     }
  18.     public Integer getId() {return id;}
  20.     public void setId(Integer id) {this.id = id;}
  22.     public String getUsername() {return username;}
  24.     public void setUsername(String username) {this.username = username;}
  26.     public String getPassword() {return password;}
  28.     public void setPassword(String password) {this.password = password;}
  30.     public String getEmail() {return email;}
  32.     public void setEmail(String email) {this.email = email;}
  34.     @Override
  35.     public String toString() {
  36.         return "User{" +
  37.                 "id=" + id +
  38.                 ", username='" + username + '\'' +
  39.                 ", password='" + password + '\'' +
  40.                 ", email='" + email + '\'' +
  41.                 '}';
  42.     }
  43. }

4、编写工具类 JdbcUtils

4.1、导入jar包（数据库和连接池需要）

放在WEB-INF文件夹的lib中

Druid首先是一个数据库连接池。Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。

6、Web项目架构与数据库使用 - 图5

4.2、在src源码目录下编写配置文件

jdbc.properties

  1. username=root
  2. password=mysql
  3. url=jdbc:mysql://localhost:3306/book
  4. driverClassName=com.mysql.jdbc.Driver
  5. initialSize=5
  6. maxActive=10

4.3、在utils文件夹中编写JdbcUtils

实现与数据库的连接以及断开

JdbcUtils

调用DruidDataSources生成一个dataSource，将读取好的配置文件放到dataSource中，之后使用getConnection()进行连接，使用close()进行关闭。

  1. package com.chang.utils;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import com.alibaba.druid.pool.DruidDataSourceFactory;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.sql.Connection;
  9. import java.sql.SQLException;
  10. import java.util.Properties;
  12. public class JdbcUtils {
  13.     private static DruidDataSource dataSource;
  14.     static {
  15.         Properties prop=new Properties();
  16.         // 读取 jdbc.properties属性配置文件
  17.         InputStream                  input=JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
  18.         try {
  19.             // 从流中加载数据
  20.             prop.load(input);
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }
  24.         // 创建 数据库连接 池
  25.         try {
  26.             dataSource=(DruidDataSource) DruidDataSourceFactory.createDataSource(prop);
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31.     /**
  32.      * 获取数据库连接池中的连接
  33.      * @return 如果返回null,说明获取连接失败<br/>有值就是获取连接成功
  34.      */
  35.     public static Connection getConnection(){
  36.         Connection conn=null;
  37.         try {
  38.             conn=dataSource.getConnection();
  39.         } catch (SQLException e) {
  40.             e.printStackTrace();
  41.         }
  42.         return conn;
  43.     }
  44.     /**
  45.      * 关闭连接，放回数据库连接池
  46.      * @param conn
  47.      */
  48.     public static void close(Connection conn){
  49.         if(conn!=null){
  50.             try {
  51.                 conn.close();
  52.             } catch (SQLException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  56.     }
  57. }

4.4、对JdbcUtils进行测试

在测试之前先将所需的包进行导入

  • hamcrest-core-1.3.jar
  • junit-4.12.jar

在test包中生曾JdbcUtilsTest类：IDEA中的快捷键是ctrl + shift + T

  1. package com.chang.test;
  3. import com.chang.utils.JdbcUtils;
  4. import org.junit.Test;
  6. import java.sql.Connection;
  8. import static org.junit.Assert.*;
  10. public class JdbcUtilsTest {
  12.     @Test
  13.     public void testJdbcUtils() {
  14.         for(int i=0;i<100;i++){
  15.             Connection conn= JdbcUtils.getConnection();
  16.             System.out.println(conn);
  17.             JdbcUtils.close(conn);
  18.         }
  19.     }
  21. }

5、编写BaseDao实现数据库的增删改查

5.1、导入DBUtils的jar包

  1. commons-dbutils-1.3.jar

5.2、编写BaseDao

  1. package com.chang.dao.impl;
  3. import com.chang.utils.JdbcUtils;
  4. import org.apache.commons.dbutils.QueryRunner;
  5. import org.apache.commons.dbutils.handlers.BeanHandler;
  6. import org.apache.commons.dbutils.handlers.BeanListHandler;
  7. import org.apache.commons.dbutils.handlers.ScalarHandler;
  9. import java.sql.Connection;
  10. import java.sql.SQLException;
  11. import java.util.List;
  13. public class BaseDao {
  14.     //使用DBUtils操作数据库
  15.     private QueryRunner queryRunner=new QueryRunner();
  17.     /**
  18.      * update() 方法用来执行：Insert\Update\Delete语句
  19.      *
  20.      * @return 如果返回-1,说明执行失败<br/>返回其他表示影响的行数
  21.      */
  22.     public int update(String sql,Object... args){
  23.         Connection conn= JdbcUtils.getConnection();
  24.         try {
  25.             return queryRunner.update(conn,sql,args);
  26.         } catch (SQLException e) {
  27.             e.printStackTrace();
  28.         }finally {
  29.             JdbcUtils.close(conn);
  30.         }
  31.         return -1;
  32.     }
  34.     /**
  35.      * 查询返回一个javaBean的sql语句
  36.      *
  37.      * @param type 返回的对象类型
  38.      * @param sql  执行的sql语句
  39.      * @param args sql对应的参数值
  40.      * @param <T>  返回的类型的泛型
  41.      * @return 返回查找到的对象，若有多个，只返回第一个
  42.      */
  43.     public <T> T queryForOne(Class<T> type,String sql,Object... args){
  44.         Connection conn=JdbcUtils.getConnection();
  45.         try {
  46.             return queryRunner.query(conn,sql,new BeanHandler<T>(type),args);
  47.         } catch (SQLException e) {
  48.             e.printStackTrace();
  49.         }finally {
  50.             JdbcUtils.close(conn);
  51.         }
  52.         return null;
  53.     }
  55.     /**
  56.      * 查询返回多个javaBean的sql语句
  57.      *
  58.      * @param type 返回的对象类型
  59.      * @param sql  执行的sql语句
  60.      * @param args sql对应的参数值
  61.      * @param <T>  返回的类型的泛型
  62.      * @return 返回查找到的对象列表
  63.      */
  64.     public <T>List<T> queryForList(Class<T> type,String sql,Object...args){
  65.         Connection conn=JdbcUtils.getConnection();
  66.         try {
  67.             return queryRunner.query(conn,sql,new BeanListHandler<T>(type),args);
  68.         } catch (SQLException e) {
  69.             e.printStackTrace();
  70.         }finally {
  71.             JdbcUtils.close(conn);
  72.         }
  73.         return null;
  74.     }
  76.     /**
  77.      * 执行返回一行一列的sql语句
  78.      * @param sql   执行的sql语句
  79.      * @param args  sql对应的参数值
  80.      * @return 返回查找到的索引行(id)，若有多个，只返回第一个
  81.      */
  82.     public Object queryForStringValue(String sql,Object...args){
  83.         Connection conn=JdbcUtils.getConnection();
  84.         try {
  85.             return queryRunner.query(conn,sql,new ScalarHandler(),args);
  86.         } catch (SQLException e) {
  87.             e.printStackTrace();
  88.         }finally {
  89.             JdbcUtils.close(conn);
  90.         }
  91.         return null;
  92.     }
  93. }

5.3、对BaseDao类进行测试

BaseDaoTest

  1. package com.chang.test;
  3. import com.chang.dao.impl.BaseDao;
  4. import org.junit.Test;
  5. import com.chang.pojo.User;
  7. import java.util.List;
  9. import static org.junit.Assert.*;
  11. public class BaseDaoTest {
  13.     private BaseDao baseDao=new BaseDao();
  14.     @Test
  15.     public void update() {
  16.         String sql = "insert into t_user(`username`,`password`,`email`) values(?,?,?)";
  17.         int getLine = baseDao.update(sql, "xiaoming", "123456", "1234@qq.com");
  18.         System.out.println(getLine);
  19.         int getLine2 = baseDao.update(sql, "xiaohong", "123456", "4321@qq.com");
  20.         System.out.println(getLine2);
  21.         /*
  22.         1
  23.         1
  24.         */
  25.     }
  27.     @Test
  28.     public void queryForOne() {
  29.         String sql="select * from t_user where password=?";
  30.         User user = baseDao.queryForOne(User.class, sql, "123456");
  31.         System.out.println(user);
  32.         /*
  33.         User{id=7, username='xiaoming', password='123456', email='1234@qq.com'}
  34.         */
  35.     }
  37.     @Test
  38.     public void queryForList() {
  39.         String sql="select * from t_user where password=?";
  40.         List<User> users = baseDao.queryForList(User.class, sql, "123456");
  41.         System.out.println(users);
  42.         /*
  43.         [User{id=7, username='xiaoming', password='123456', email='1234@qq.com'}, 
  44.          User{id=8, username='xiaohong', password='123456', email='4321@qq.com'}]
  45.         */
  46.     }
  48.     @Test
  49.     public void queryForStringValue() {
  50.         String sql="select * from t_user where password=?";
  51.         Object admin = baseDao.queryForStringValue(sql, "123456");
  52.         System.out.println(admin);
  53.         /*
  54.         7
  55.         */
  56.     }
  57. }

6、Web项目架构与数据库使用 - 图6

6、编写UserDao（对BaseDao封装）

6.1、接口：UserDao

  1. package com.chang.dao;
  3. import com.chang.pojo.User;
  5. public interface UserDao {
  6.     /**
  7.      * 根据用户名查询用户信息
  8.      * @param username 用户名
  9.      * @return 如果返回 null,说明没有这个用户。反之亦然
  10.      */
  11.     public User queryUserByUsername(String username);
  13.     /**
  14.      * 根据 用户名和密码查询用户信息
  15.      * @param username
  16.      * @param password
  17.      * @return 如果返回 null,说明用户名或密码错误,反之亦然
  18.      */
  19.     public User queryUserByUsernameAndPassword(String username,String password);
  21.     /**
  22.      * 保存用户信息
  23.      * @param user
  24.      * @return 返回-1 表示操作失败，其他是 sql 语句影响的行数
  25.      */
  26.     public int saveUser(User user);
  27. }

6.2、实现类：UserDaoImpl

  1. package com.chang.dao.impl;
  3. import com.chang.dao.UserDao;
  4. import com.chang.pojo.User;
  6. public class UserDaoImpl extends BaseDao implements UserDao {
  7.     @Override
  8.     public User queryUserByUsername(String username) {
  9.         String sql="select * from t_user where username=?";
  10.         return queryForOne(User.class,sql,username);
  11.     }
  13.     @Override
  14.     public User queryUserByUsernameAndPassword(String username, String password) {
  15.         String sql="select * from t_user where username=? and password =?";
  16.         return queryForOne(User.class,sql,username,password);
  17.     }
  19.     @Override
  20.     public int saveUser(User user) {
  21.         String sql="insert into t_user(`username`,`password`,`email`) values(?,?,?)";
  22.         return update(sql,user.getUsername(),user.getPassword(),user.getEmail());
  23.     }
  24. }

6.3、测试：UserDaoTest

  1. package com.chang.test;
  3. import com.chang.dao.UserDao;
  4. import com.chang.dao.impl.UserDaoImpl;
  5. import com.chang.pojo.User;
  6. import org.junit.Test;
  8. import static org.junit.Assert.*;
  10. public class UserDaoTest {
  12.     UserDao userDao=new UserDaoImpl();
  14.     @Test
  15.     public void queryUserByUsername() {
  16.         User user = userDao.queryUserByUsername("xiaoming");
  17.         System.out.println(user);
  18.         if (userDao.queryUserByUsername("admin1234") == null ){
  19.             System.out.println("用户名可用！");
  20.         } else {
  21.             System.out.println("用户名已存在！");
  22.         }
  23.         /*
  24.         User{id=7, username='xiaoming', password='123456', email='1234@qq.com'}
  25.         用户名可用！
  26.          */
  27.     }
  29.     @Test
  30.     public void queryUserByUsernameAndPassword() {
  31.         if ( userDao.queryUserByUsernameAndPassword("admin","admin1234") == null) {
  32.             System.out.println("用户名或密码错误，登录失败");
  33.         } else {
  34.             System.out.println("查询成功");
  35.         }
  36.         /*
  37.         用户名或密码错误，登录失败
  38.          */
  39.     }
  41.     @Test
  42.     public void saveUser() {
  43.         System.out.println( userDao.saveUser(new User(null,"wzg168", "123456", "wzg168@qq.com")) );
  44.         /*
  45.         1
  46.          */
  47.     }
  48. }

7、编写UserService

7.1、接口：UserService

  1. package com.chang.service;
  3. import com.chang.pojo.User;
  5. public interface UserService {
  6.     /**
  7.      * 注册用户
  8.      * @param user
  9.      */
  10.     public void registUser(User user);
  12.     /**
  13.      * 登录
  14.      * @param user
  15.      * @return 如果返回 null，说明登录失败，返回有值，是登录成功
  16.      */
  17.     public User login(User user);
  19.     /**
  20.      * 检查 用户名是否可用
  21.      * @param username
  22.      * @return 返回 true 表示用户名已存在，返回 false 表示用户名可用
  23.      */
  24.     public boolean existsUsername(String username);
  25. }

7.2、实现类：UserServiceImpl

  1. package com.chang.service.impl;
  3. import com.chang.dao.UserDao;
  4. import com.chang.dao.impl.UserDaoImpl;
  5. import com.chang.pojo.User;
  6. import com.chang.service.UserService;
  8. public class UserServiceImpl implements UserService {
  10.     private UserDao userDao=new UserDaoImpl();
  12.     @Override
  13.     public void registUser(User user) {
  14.         userDao.saveUser(user);
  15.     }
  17.     @Override
  18.     public User login(User user) {
  19.         return userDao.queryUserByUsernameAndPassword(user.getUsername(), user.getPassword());
  20.     }
  22.     @Override
  23.     public boolean existsUsername(String username) {
  24.         if (userDao.queryUserByUsername(username) == null) {
  25.             // 等于null,说明没查到，没查到表示可用
  26.             return false;
  27.         }
  28.         return true;
  29.     }
  30. }

7.3、测试：UserSerciceTest

  1. package com.chang.test;
  3. import com.chang.pojo.User;
  4. import com.chang.service.UserService;
  5. import com.chang.service.impl.UserServiceImpl;
  6. import org.junit.Test;
  8. import static org.junit.Assert.*;
  10. public class UserServiceTest {
  11.     UserService userService = new UserServiceImpl();
  13.     @Test
  14.     public void registUser() {
  15.         userService.registUser(new User(null, "bbj168", "666666", "bbj168@qq.com"));
  16.         userService.registUser(new User(null, "abc168", "666666", "abc168@qq.com"));
  17.     }
  19.     @Test
  20.     public void login() {
  21.         User wzg168 = userService.login(new User(null, "wzg168", "123456", null));
  22.         System.out.println(wzg168);
  23.         /*
  24.         User{id=9, username='wzg168', password='123456', email='wzg168@qq.com'}
  25.          */
  26.     }
  28.     @Test
  29.     public void existsUsername() {
  30.         if (userService.existsUsername("wzg16888")) {
  31.             System.out.println("用户名已存在！");
  32.         } else {
  33.             System.out.println("用户名可用！");
  34.         }
  35.         /*
  36.         用户名可用！
  37.          */
  38.     }
  39. }

8、编写Web层

8.1、实现用户注册的功能

8.1.1、图解用户注册的流程：

6、Web项目架构与数据库使用 - 图7

8.1.2、修改 regist.html 和 regist_success.html 页面

1、添加 base 标签

  1. <!--写 base 标签，永远固定相对路径跳转的结果-->
  2. <base href="http://localhost:8080/book/">

2、修改 base 标签对页面中所有相对路径的影响（浏览器 F12，哪个报红，改哪个）

以下是几个修改的示例：

  1. <link type="text/css" rel="stylesheet" href="static/css/style.css" >
  2. <script type="text/javascript" src="static/script/jquery-1.7.2.js"></script>

3、修改注册表单的提交地址和请求方式

6、Web项目架构与数据库使用 - 图8

8.1.3、编写 RegistServlet 程序

  1. package com.chang.web;
  3. import com.chang.pojo.User;
  4. import com.chang.service.UserService;
  5. import com.chang.service.impl.UserServiceImpl;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.io.IOException;
  13. public class RegistServlet extends HttpServlet {
  15.     private UserService userService=new UserServiceImpl();
  17.     @Override
  18.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  19.         //  1、获取请求的参数
  20.         String username=req.getParameter("username");
  21.         String password=req.getParameter("password");
  22.         String email=req.getParameter("email");
  23.         String code=req.getParameter("code");
  25.         //2、检查 验证码是否正确  === 写死,要求验证码为:abcde
  26.         if("abcde".equalsIgnoreCase(code)){
  27.             //3、检查用户名是否可用
  28.             if(userService.existsUsername(username)){
  29.                 System.out.println("用户名[" + username + "]已存在!");
  30.                 //跳回注册页面
  31.                 req.getRequestDispatcher("/pages/user/regist.html").forward(req,resp);
  32.             }else {
  33.                 //可用
  34.                 //调用Sservice保存到数据库
  35.                 userService.registUser(new User(null,username,password,email));
  36.                 //跳到注册成功页面 regist_success.html
  37.                 req.getRequestDispatcher("/pages/user/regist_success.html").forward(req,resp);
  38.             }
  39.         }else{
  40.             System.out.println("验证码[" + code + "]错误");
  41.             req.getRequestDispatcher("/pages/user/regist.html").forward(req, resp);
  42.         }
  44.     }
  45. }

8.1.4、在web.xml配置servlet

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  6.     <servlet>
  7.         <servlet-name>RegistServlet</servlet-name>
  8.         <servlet-class>com.chang.web.RegistServlet</servlet-class>
  9.     </servlet>
  10.     <servlet-mapping>
  11.         <servlet-name>RegistServlet</servlet-name>
  12.         <url-pattern>/registServlet</url-pattern>
  13.     </servlet-mapping>
  14. </web-app>

8.2、实现用户登录的功能

8.2.1、图解用户登录

6、Web项目架构与数据库使用 - 图9

8.2.2、修改 login.html 页面和 login_success.html 页面

1、添加 base 标签

  1. <!--写 base 标签，永远固定相对路径跳转的结果-->
  2. <base href="http://localhost:8080/book/">

2、修改 base 标签对页面中所有相对路径的影响（浏览器 F12，哪个报红，改哪个）

以下是几个修改的示例：

  1. <link type="text/css" rel="stylesheet" href="static/css/style.css" >
  2. <script type="text/javascript" src="static/script/jquery-1.7.2.js"></script>

3、修改 login.html 表单的提交地址和请求方式

6、Web项目架构与数据库使用 - 图10

8.2.3、编写LoginServlet程序

  1. package com.chang.web;
  3. import com.chang.pojo.User;
  4. import com.chang.service.UserService;
  5. import com.chang.service.impl.UserServiceImpl;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.io.IOException;
  13. public class LoginServlet extends HttpServlet {
  15.     private UserService userService = new UserServiceImpl();
  17.     @Override
  18.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  19.         //  1、获取请求的参数
  20.         String username = req.getParameter("username");
  21.         String password = req.getParameter("password");
  22.         // 调用 userService.login()登录处理业务
  23.         User loginUser = userService.login(new User(null, username, password, null));
  24.         // 如果等于null,说明登录 失败!
  25.         if (loginUser == null) {
  26.             //   跳回登录页面
  27.             req.getRequestDispatcher("/pages/user/login.html").forward(req, resp);
  28.         } else {
  29.             // 登录 成功
  30.             //跳到成功页面login_success.html
  31.             req.getRequestDispatcher("/pages/user/login_success.html").forward(req, resp);
  32.         }
  33.     }
  34. }

8.2.4、在web.xml配置servlet

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  6.     <servlet>
  7.         <servlet-name>RegistServlet</servlet-name>
  8.         <servlet-class>com.chang.web.RegistServlet</servlet-class>
  9.     </servlet>
  10.     <servlet-mapping>
  11.         <servlet-name>RegistServlet</servlet-name>
  12.         <url-pattern>/registServlet</url-pattern>
  13.     </servlet-mapping>
  15.     <servlet>
  16.         <servlet-name>LoginServlet</servlet-name>
  17.         <servlet-class>com.chang.web.LoginServlet</servlet-class>
  18.     </servlet>
  19.     <servlet-mapping>
  20.         <servlet-name>LoginServlet</servlet-name>
  21.         <url-pattern>/loginServlet</url-pattern>
  22.     </servlet-mapping>
  24. </web-app>