Servlet中的注解式开发

一、Servlet注解，简化配置

  • [x] oa项目中的web.xml文件

    • 当开发项目过大时，web.xml中需要配置的文件会非常庞大，可能会有几十兆
    • 在web.xml文件中进行Servlet信息的配置，显然开发效率较低，每一个都需要配置、
    • 而且在web.xml文件中的配置是很少需要修改的

  • [x] Servlet3.0版本之后，退出了各种Servlet基于注解式开发

    • 优点

      • 开发效率高，不需要编写大量的配置信息，直接写在Java类上使用注解进行标注
      • web.xml文件体积变小了

    • 并不是有了注解之后，web.xml文件就不需要了

      • 有的一些需要变化的信息，还是需要配置到web.xml文件中，一般都是注解+配置文件的开发模式
      • 一些不会经常变化修改的配置建议使用注解，一些可能会被修改的建议写到配置文件中

二、注解的使用

  • 第一个注解
    1. import jakarta.servlet.annotation.WebServlet;

23、Servlet中的注解式开发 - 图1

  • Servlet类上使用：@WebServlet

  • [x] Servlet注解的属性

    • name属性L：用来指定Servlet的名字，等同于<servlet-name>
    • urlPatterns属性：用来指定Servlet的映射路径，可以指定多个字符串，等同于url-pattern
    • loadOnStartUp属性：用来指定服务器在启动阶段是否加载Servlet，等同于<load-on-startup>

    • value属性

      • ⚠️如果注解的属性名是value的话，属性名可以省略@WebServlet(value = "/a")可以写为@WebServlet("/a")

  • [x] 注解对象的使用格式initPatams

    • @注解名称(属性名=属性值,属性名=属性值,属性名=属性值)

23、Servlet中的注解式开发 - 图2

  • 不需要将所有的属性都写上，只需要提供需要的（需要什么用什么）

⚠️当注解的属性是一个数组，并且数字中只有一个元素，大括号可以省略

三、模板方法设计模式解决类爆炸

  • 如果一个复杂的业务系统，类太多，会导致类爆炸（类的数量急剧增多）
  • 可以使用模板设计模式解决类爆炸

❓如何解决类爆炸问题

  • 一个请求对应一个方法
  • 一个业务对应一个Servlet类
  • 处理部门的业务的对应一个DeptServlet
  • 处理用户相关的业务对应一个UserServlet
  • 处理银行卡片业务的对应一个CardServlet
  • 通配写法

23、Servlet中的注解式开发 - 图3

  1. package oa.action;
  3. import jakarta.servlet.ServletException;
  4. import jakarta.servlet.annotation.WebServlet;
  5. import jakarta.servlet.http.HttpServlet;
  6. import jakarta.servlet.http.HttpServletRequest;
  7. import jakarta.servlet.http.HttpServletResponse;
  8. import oa.untils.DBUtil;
  10. import java.io.IOException;
  11. import java.io.PrintWriter;
  12. import java.sql.Connection;
  13. import java.sql.PreparedStatement;
  14. import java.sql.ResultSet;
  15. import java.sql.SQLException;
  17. /**
  18.  * @Author: 小雷学长
  19.  * @Date: 2022/3/23 - 21:31
  20.  * @Version: 1.8
  21.  */
  23. //模板类
  24. @WebServlet({"/dept/list", "/dept/save", "/dept/edit", "/dept/detail", "/dept/delete", "/dept/update"})
  25. //通配写法
  26. //只要是路径已"/dept"开始的，都走Servlet
  27. //@WebServlet("/dept/*")
  28. public class DeptServlet extends HttpServlet {
  30.     //模板方法
  31.     //重写Servlet方法（并没有重写doGet或者doPost
  34.     @Override
  35.     protected void service(HttpServletRequest request, HttpServletResponse response)
  36.             throws ServletException, IOException {
  38.         //获取ServletPath
  39.         String servletPath = request.getServletPath();
  41.         if ("/dept/list".equals(servletPath)) {
  42.             doList(request, response);
  43.         } else if ("/dept/save".equals(servletPath)) {
  44.             doSave(request, response);
  45.         } else if ("/dept/edit".equals(servletPath)) {
  46.             doEdit(request, response);
  47.         } else if ("/dept/detail".equals(servletPath)) {
  48.             doDeail(request, response);
  49.         } else if ("/dept/delete".equals(servletPath)) {
  50.             doDelete(request, response);
  51.         } else if ("/dept/update".equals(servletPath)) {
  52.             doUpdate(request, response);
  53.         }
  54.     }
  56.     private void doList(HttpServletRequest request, HttpServletResponse response)
  57.             throws ServletException, IOException {
  58.         {
  59.             //获取应用的根路径
  60.             String contextPath = request.getContextPath();
  62.             //设置响应的内容类型
  63.             response.setContentType("text/html");
  64.             PrintWriter out = response.getWriter();
  66.             out.print("        <!DOCTYPE html>");
  67.             out.print("<html lang='en'>");
  68.             out.print("<head>");
  69.             out.print("    <meta charset='UTF-8'>");
  70.             out.print("    <title>部门列表</title>");
  71.             out.print("</head>");
  73.             out.print("<body>");
  74.             out.print("<script type='text/javascript'>");
  75.             out.print("        function del(dno) {");
  76.             out.print("    if(window.confirm('亲，删了不可恢复哦！')){");
  77.             out.print("        document.location.href = '" + contextPath + "/dept/delete?deptno=' + dno");
  78.             out.print("    }");
  79.             out.print("}");
  80.             out.print("</script>");
  81.             out.print("<h1 align='center'>部门列表</h1>");
  82.             out.print("<hr>");
  83.             out.print("<table border='1px' align='center' width='50%'>");
  84.             out.print("    <tr>");
  85.             out.print("        <th>序号</th>");
  86.             out.print("        <th>部门编号</th>");
  87.             out.print("        <th>部门名称</th>");
  88.             out.print("        <th>操作</th>");
  89.             out.print("    </tr>");
  90.             out.print("    <!--以上是固定的-->");
  91.         /*
  92.         上面一部分是死的
  93.          */
  95.             /*
  96.              * 连接数据库
  97.              */
  98.             Connection conn = null;
  99.             PreparedStatement ps = null;
  100.             ResultSet rs = null;
  102.             try {
  104.                 //获取连接
  105.                 conn = DBUtil.getConnection();
  107.                 //获取预编译的数据库操作对象
  108.                 String sql = "select deptno,dname ,loc from dept";
  109.                 ps = conn.prepareStatement(sql);
  111.                 //执行SQL语句
  112.                 rs = ps.executeQuery();
  114.                 //处理结果集
  115.                 int i = 0;
  116.                 while (rs.next()) {
  117.                     String deptno = rs.getString("deptno");
  118.                     String dname = rs.getString("dname");
  119.                     String loc = rs.getString("loc");
  121.                     out.print("    <tr>");
  122.                     out.print("        <td>" + (++i) + "</td>");
  123.                     out.print("        <td>" + deptno + "</td>");
  124.                     out.print("        <td>" + dname + "</td>");
  125.                     out.print("        <td>");
  126.                     out.print("<a href='javascript:void(0)' onclick='del(" + deptno + ")'>删除</a>");
  127.                     out.print("            <a href='/oa/dept/edit?deptno=" + deptno + "'>修改</a>");
  128.                     out.print("            <a href='" + contextPath + "/dept/detail?deptno=" + deptno + "'>详情</a>");
  129.                     out.print("        </td>");
  130.                     out.print("    </tr>");
  132.                 }
  133.             } catch (SQLException e) {
  134.                 e.printStackTrace();
  135.             } finally {
  137.                 //释放资源
  138.                 DBUtil.close(conn, ps, rs);
  139.             }
  141.         /*
  142.         下面一部分是死的
  143.          */
  144.             out.print("    <!--一下是固定的-->");
  145.             out.print("</table>");
  146.             out.print("<hr>");
  147.             out.print("<a href='" + contextPath + "/add.html'>新增部门</a>");
  148.             out.print("</body>");
  149.             out.print("</html>");
  150.         }
  151.     }
  154.     private void doSave(HttpServletRequest request, HttpServletResponse response)
  155.             throws ServletException, IOException {
  156.         {
  159.             //获取部门信息
  160.             String deptno = request.getParameter("deptno");
  161.             String dname = request.getParameter("dname");
  162.             String loc = request.getParameter("loc");
  164.             //连接数据库执行insert语句
  165.             Connection conn = null;
  166.             PreparedStatement ps = null;
  167.             int count = 0;
  169.             try {
  170.                 conn = DBUtil.getConnection();
  172.                 String sql = "insert into dept(deptno,dname,loc) values(?,?,?)";
  173.                 ps = conn.prepareStatement(sql);
  174.                 ps.setString(1, deptno);
  175.                 ps.setString(2, dname);
  176.                 ps.setString(3, loc);
  178.                 count = ps.executeUpdate();
  180.             } catch (SQLException e) {
  181.                 e.printStackTrace();
  183.             } finally {
  184.                 DBUtil.close(conn, ps, null);
  185.             }
  187.             //判断新增成功还是失败
  188.             if (count == 1) {
  189.                 //新增成功
  190.                 //仍然跳回到部门列表页面
  191.                 //部门列表页面需要执行另一个Servlet，利用转发机制
  192.                 //转发一次请求
  193. //            request.getRequestDispatcher("/dept/list").forward(request, response);
  195.                 //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  196.                 response.sendRedirect(request.getContextPath() + "/dept/list");
  197.             } else {
  198.                 //新增失败
  199. //            request.getRequestDispatcher("/error.html").forward(request, response);
  201.                 //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  202.                 response.sendRedirect(request.getContextPath() + "/error.hmtl");
  203.             }
  206.         }
  207.     }
  209.     private void doEdit(HttpServletRequest request, HttpServletResponse response)
  210.             throws ServletException, IOException {
  211.         {
  213.             response.setContentType("text/html");
  214.             PrintWriter out = response.getWriter();
  216.             String contextPath = request.getContextPath();
  219.             out.print("<html lang='en'>");
  220.             out.print("<head>");
  221.             out.print("    <meta charset='UTF-8'>");
  222.             out.print("    <title>修改部门</title>");
  223.             out.print("</head>");
  224.             out.print("<body>");
  225.             out.print("<h1>修改部门</h1>");
  226.             out.print("<hr>");
  227.             out.print("<form action='" + contextPath + "/dept/update' method='post'>");
  230.             //获取部门编号
  231.             String deptno = request.getParameter("deptno");
  233.             //连接数据库执行insert语句
  234.             Connection conn = null;
  235.             PreparedStatement ps = null;
  236.             ResultSet rs = null;
  238.             try {
  239.                 conn = DBUtil.getConnection();
  241.                 String sql = "select dname,loc from dept where deptno=?";
  242.                 ps = conn.prepareStatement(sql);
  243.                 ps.setString(1, deptno);
  245.                 rs = ps.executeQuery();
  247.                 if (rs.next()) {
  248.                     String dname = rs.getString("dname");
  249.                     String loc = rs.getString("loc");
  251.                     //输出动态网页
  252.                     out.print("                部门编号<input type='text' name='deptno' value='" + deptno + "' readonly><br><!--readonly只读-->");
  253.                     out.print("                部门名称<input type='text' name='dname' value='" + dname + "'><br>");
  254.                     out.print("                部门位置<input type='text' name='loc' value='" + loc + "'><br>");
  256.                 }
  258.             } catch (SQLException e) {
  259.                 e.printStackTrace();
  261.             } finally {
  262.                 DBUtil.close(conn, ps, rs);
  263.             }
  265.             //判断新增成功还是失败
  267.             out.print("    <input type='submit' value='修改'><br>");
  268.             out.print("");
  269.             out.print("</form>");
  270.             out.print("");
  271.             out.print("</body>");
  272.             out.print("</html>");
  274.         }
  275.     }
  277.     private void doDeail(HttpServletRequest request, HttpServletResponse response)
  278.             throws ServletException, IOException {
  279.         {
  281.             response.setContentType("text/html");
  282.             PrintWriter out = response.getWriter();
  285.             out.print("<!DOCTYPE html>");
  286.             out.print("<html lang='en'>");
  287.             out.print("<head>");
  288.             out.print("    <meta charset='UTF-8'>");
  289.             out.print("    <title>部门详情</title>");
  290.             out.print("</head>");
  291.             out.print("<body>");
  292.             out.print("<h1>部门详情</h1>");
  293.             out.print("<hr>");
  296.             //获取部门编号
  297.             //虽然提交的是30，但服务器获取的是30这个字符串
  298.             String deptno = request.getParameter("deptno");
  301.             /*
  302.              * 连接数据库
  303.              */
  304.             Connection conn = null;
  305.             PreparedStatement ps = null;
  306.             ResultSet rs = null;
  308.             try {
  310.                 //获取连接
  311.                 conn = DBUtil.getConnection();
  313.                 //获取预编译的数据库操作对象
  314.                 String sql = "select deptno,dname,loc from dept where deptno=?";
  315.                 ps = conn.prepareStatement(sql);
  317.                 ps.setString(1, deptno);
  318.                 //这个结果集一定只有一个元素
  321.                 //执行SQL语句
  322.                 rs = ps.executeQuery();
  324.                 //处理结果集
  325.                 if (rs.next()) {
  326.                     String dname = rs.getString("dname");
  327.                     String loc = rs.getString("loc");
  329.                     out.print("部门编号" + deptno + "<br>");
  330.                     out.print("部门名称" + dname + "<br>");
  331.                     out.print("部门位置" + loc + "<br>");
  334.                 }
  335.             } catch (SQLException e) {
  336.                 e.printStackTrace();
  337.             } finally {
  339.                 //释放资源
  340.                 DBUtil.close(conn, ps, rs);
  341.             }
  343.             out.print("");
  344.             out.print("<form action='list.html'>");
  345.             out.print("    <input type='button' value='后退' onclick='window.history.back()'>");
  346.             out.print("");
  347.             out.print("</form>");
  348.             out.print("");
  349.             out.print("</body>");
  350.             out.print("</html>");
  351.         }
  352.     }
  354.     public void doDelete(HttpServletRequest request, HttpServletResponse response)
  355.             throws ServletException, IOException {
  356.         {
  358.             //根据部门编号，删除部门
  359.             //获取部门编号
  360.             String deptno = request.getParameter("deptno");
  362.             //连接数据库删除数据
  363.             Connection conn = null;
  364.             PreparedStatement ps = null;
  366.             int count = 0;
  368.             try {
  369.                 conn = DBUtil.getConnection();
  371.                 //开启事务（自动提交机制关闭）（非必要）
  372. //            conn.setAutoCommit(false);
  374.                 String sql = "delete from dept where deptno=?";
  375.                 ps = conn.prepareStatement(sql);
  376.                 ps.setString(1, deptno);
  378.                 //返回值是：影响了数据库表当中多少条记录
  379.                 count = ps.executeUpdate();
  381.                 //事务提交（非必要）
  382. //            conn.commit();
  383.             } catch (SQLException e) {
  384.                 e.printStackTrace();
  386.             } finally {
  387.                 DBUtil.close(conn, ps, null);
  388.             }
  390.             //判断删除成功还是失败
  391.             if (count == 1) {
  392.                 //删除成功
  393.                 //仍然跳回到部门列表页面
  394.                 //部门列表页面需要执行另一个Servlet，利用转发机制
  395.                 //request.getRequestDispatcher("/dept/list").forward(request, response);
  397.                 //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  398.                 response.sendRedirect(request.getContextPath() + "/dept/list");
  400.             } else {
  401.                 //删除失败
  402.                 //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  403.                 response.sendRedirect(request.getContextPath() + "/error.html");
  404.             }
  406.         }
  408.     }
  410.     private void doUpdate(HttpServletRequest request, HttpServletResponse response)
  411.             throws ServletException, IOException {
  412.         {
  415.             response.setContentType("text/html");
  416.             PrintWriter out = response.getWriter();
  418.             String deptno = request.getParameter("deptno");
  419.             String dname = request.getParameter("dname");
  420.             String loc = request.getParameter("loc");
  422.             //连接数据库执行insert语句
  423.             Connection conn = null;
  424.             PreparedStatement ps = null;
  425.             ResultSet rs = null;
  426.             int count = 0;
  428.             try {
  429.                 conn = DBUtil.getConnection();
  431.                 String sql = "update dept set dname = ?,loc = ? where deptno = ?";
  432.                 ps = conn.prepareStatement(sql);
  433.                 ps.setString(1, dname);
  434.                 ps.setString(2, loc);
  435.                 ps.setString(3, deptno);
  437.                 count = ps.executeUpdate();
  439.             } catch (SQLException e) {
  440.                 e.printStackTrace();
  442.             } finally {
  443.                 DBUtil.close(conn, ps, rs);
  444.             }
  446.             if (count == 1) {
  447.                 //更新成功
  448.                 //跳转到部门列表页面，转发机制
  449. //    request.getRequestDispatcher("/dept/list").forward(request,response);
  451. //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  452.                 response.sendRedirect(request.getContextPath() + "/dept/list");
  453.             } else {
  454.                 //更新失败
  455. //    request.getRequestDispatcher("/error.html").forward(request,response);
  457.                 //建议使用重定向,因为重定向是一次全新的请求，不会受dopost、doget方法影响
  458.                 response.sendRedirect(request.getContextPath() + "/error.html");
  459.             }
  460.         }
  461.     }
  462. }