javaweb基础之layui小demo练习

柔光的暖阳◎ 2022-12-10 07:25 83阅读 0赞

## 什么是Servlet ##

**Servlet 运行在服务端的Java小程序**，是sun公司提供一套规范（接口），用来处理客户端请求、响应给浏览器的动态资源。但**servlet的实质就是java代码**，通过java的API 动态的向客户端输出内容  
servlet三个技术点：  
1）servlet技术  
2）filter技术—过滤器  
3）listener技术—监听器

## 快速入门 ##

1）创建类继承HttpServlet类  
2）覆盖doGet和doPost  
3）在web.xml中进行servlet的配置\*\*  
**Servlet的三种方式创建**：  
实现javax.servlet.Servlet接口  
继承javax.servlet.GenericServlet类（适配器）  
继承javax.servlet.httpServlet(模板方法设计)  
配置：  
其中u**rl-pattern的配置方式**：  
1）完全匹配 访问的资源与配置的资源完全相同才能访问到  
2）目录匹配 格式：/虚拟的目录…/\* *代表任意  
3）扩展名匹配 格式：*.扩展名  
注意：第二种与第三种不要混用  
/aaa/bbb/*.abcd（错误的）  
servlet映射细节1：可以在url-pattern配置多个映射路径,servlet-name相同就行  
servlet映射细节2：可以在url-pattern配置通配符* 可以代表任意字符串  
url-pattern:*.扩展名 以*.字符串的请求都可以访问  
url-parten:/\* 任意字符串都可以访问  
url-pattern:/action/\* 以/action开头的请求都可以访问  
匹配规则：  
优先级：从高到低  
绝对匹配–>/开头匹配—>扩展名方式匹配  
如果url-parttern的值是/,表示执行默认映射，所有资源都是servlet  
**结论:url-parttern常见的写法有：**

1、/*:路径匹配
    2、*.do：扩展匹配
    3、/HelloServlet:精确匹配
    4、/test/*:长路径匹配

下面的写法是错误的:

/*.do：不能同时使用路径匹配与扩展匹配

<servlet>
            <servlet-name>LoadServlet</servlet-name>
            <servlet-class>com.doupijiang.servlet.LoadServlet</servlet-class>
        </servlet>
    
        <servlet-mapping>
            <servlet-name>LoadServlet</servlet-name>
            <url-pattern>/LoadServlet</url-pattern>
        </servlet-mapping>

## Servlet的生命周期 ##

1）Servlet本质上是一个类。但是使用它的时候，你好像从来没有new出来过，那么它是什么时候被创建的呢？  
2）Servlet都是继承自HttpServlet的，你写代码的时候会重写父类的若干个方法，如init，doGet，doPost等，你重写这么多方法，它们之间的执行顺序又是如何呢  
Servlet整个生命周期的管理，是由Servlet容器（这里是Tomcat）去维护的。  
**Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、销毁**  
(1)Servlet接口中的方法  
1）init(ServletConfig config)  
何时执行：servlet对象创建的时候执行  
ServletConfig ： 代表的是该servlet对象的配置信息  
2）service（ServletRequest  
request,ServletResponse response）  
何时执行：每次请求都会执行  
ServletRequest ：代表请求 认为ServletRequest 内部封装的是 http请求的信息  
ServletResponse ：代表响应 认为要封装的是响应的信息  
3）destroy()  
何时执行：servlet销毁的时候执行  
(2)HttpServlet类的方法  
1）init()  
2）doGet(HttpServletRequest request,HttpServletResponse response)  
3）doPost(HttpServletRequest request,HttpServletResponse response)  
4）destroy()  
(3)**Servlet的生命周期**（面试题）  
1）Servlet何时创建  
默认第一次访问servlet时创建该对象  
2）Servlet何时销毁  
服务器关闭servlet就销毁了  
3）每次访问必然执行的方法  
service(ServletRequest req, ServletResponse res)方法  
servletconfig获取servlet基本信息

## servletconfig ##

**获取web.xml 中init-param里面的初始化参数**

<servlet>
        <servlet-name>CheckServlet</servlet-name>
        <servlet-class>com.qianjiang.item.CheckServlet</servlet-class>
     <init-param>
          <param-name>username</param-name>
          <param-value>doupijiang</param-value>
        </init-param>
        <init-param>
          <param-name>password</param-name>
          <param-value>123456</param-value>
        </init-param>**
      </servlet>
      <servlet-mapping>
        <servlet-name>CheckServlet</servlet-name>
        <url-pattern>/show/CheckServlet</url-pattern>
      </servlet-mapping>

//getServletConfig()实际上就是init的config对象
    		ServletConfig servletConfig =  this.getServletConfig();
            //从配置获取用户名和密码
            String name = servletConfig.getInitParameter("username");
            String pwd = servletConfig.getInitParameter("password");
            System.out.println("内置用户名"+name);
            System.out.println("内置密码"+pwd);

或者直接：

@WebServlet(urlPatterns = "/HanderServlet",initParams =
            {@WebInitParam(name = "r_username",value = "admin"),
            @WebInitParam(name = "r_password",value = "admin")})

## ServletContext ##

ServletContext:代表的是整个应用，一个应用只有一个ServletContext对象。单实例  
域对象：在一定范围内（当前应用），使多个Servlet共享数据  
**ServletContext是一个域对象**  
什么是域对象？什么是域？  
存储数据的区域就是域对象  
ServletContext域对象的作用范围：整个web应（所有的web资源都可以随意向 servletcontext域中存取数据，数据可以共享）  
**域对象的通用的方法：**  
setAtrribute(String name,Object obj);//向ServletContext对象的Map中添加数据  
getAttribute(String name);从ServletContext对象的map中取数据  
removeAttribute(String name);//根据name移除数据  
**获取全局配置信息**  
web.xml配置全局初始化参数

<context-param>
    	<param-name>driver</param-name>
    	<param-value>com.mysql.jdbc.Driver<param-value>
    </context-param>

通过context对象获得参数

@Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获得ServletContext对象
            ServletContext context = this.getServletContext();
            //获得初始化参数
            String initParameter = context.getInitParameter("driver");
            //System.out.println(initParameter);
            resp.getWriter().write(initParameter);
        }

**获得web应用中任何资源的绝对路径**  
方法：String path = context.getRealPath(相对于该web应用的相对地址);  
例子：ServletContext context = getServletContext();  
String path = context.getRealPath("/WEB-INF/classes/com/xxx/a.properties"）；  
String path = context.getRealPath("/WEB-INF/classes/a.properties"）；  
String path = context.getRealPath("/WEB-INF/a.properties"）；

InputStream is = getServletContext().getResourceAsStream(/WEB-INF/classes/com/xxx/a.properties);
    Properties pro = new Properties();
    pro.load(is);
    String user = prop.getProperty("username");

## Servlet的请求转发 ##

实现请求转发，目标是跳转到ServletContextDemo  
ServletContext sc = getServletContext();  
RequestDispatcher rd = sc.getRequestDispatcher("/ServletContextDemo1");参数表示要跳转到哪去  
rd.forward(request,response);//将请求信息向下传递  
**req.getRequestDispatcher(“PrintServlet”).forward(req,resp);**

## 请求转发和重定向的区别 ##

重定向：

response.sendRedirect("/student_list.jsp");

**总结**  
转发在服务器端完成的；重定向是在客户端完成的  
转发的速度快；重定向速度慢  
转发的是同一次请求；重定向是两次不同请求  
转发地址栏没有变化；重定向地址栏有变化  
转发必须是在同一台服务器下完成；重定向可以在不同的服务器下完成  
问：什么时候使用转发，什么时候使用重定向？  
**如果要保留请求域中的数据，使用转发，否则使用重定向。**  
以后访问数据库，增删改使用重定向，查询使用转发。  
无论转发或重定向后续的代码都会执行

## Servlet的注解形式 ##

**metadata-complete="false"需要为false。这样注解才会成功**

注：必须要使用tomcat7以上的服务器  
　在Servlet3.0中，可以使用@WebServlet注解将一个继承于javax.servlet.http.HttpServlet的类标注为可以处理用户请求的Servlet。

**@WebServlet注解的相关属性**  
1.asyncSupported:声明Servlet是否支持异步操作模式  
2.description:Servlet的描述信息  
3.displayName:Servlet的显示名称  
4.initParams:Servlet的初始化参数  
5.name:Servlet的名称  
6.urlPatterns:Servlet的访问URL  
7.value:Servlet的访问URL  
Servlet的访问URL是Servlet的必选属性，可以选择使用urlPatterns或者value定义。  
　　像上面的Servlet3Demo可以描述成@WebServlet(name=“Servlet3Demo”,value="/Servlet3Demo")。  
　　也定义多个URL访问：  
　　如@WebServlet(name=“Servlet3Demo”,urlPatterns=\{"/Servlet3Demo","/Servlet3Demo2"\})  
　　或者@WebServlet(name=“AnnotationServlet”,value=\{"/Servlet3Demo","/Servlet3Demo2"\})

## Cookie简讲 ##

学习之前需要了解：  
1、 Http是无状态的短连接，而TCP是有状态的长连接  
Http协议(超文本传输协议)，应用层  
TCP协议（传输控制协议），传输层  
Http就是在每次请求完成后就把TCP连接关了，所以是短连接。而我们直接通过Socket编程使用TCP协议的时候，因为我们自己可以通过代码区控制什么时候打开连接什么时候关闭连接，只要我们不通过代码把连接关闭，这个连接就会在客户端和服务端的进程中一直存在，相关状态数据会一直保存着  
cookie是**浏览器的一种缓存机制,服务端给客户端的数据，存储于客户端（浏览器）**。由于是保存在客户端上的，所以存在安全问题，并且cookie是由个数和大小限制的（4KB），所以一般cookie用来存储一些比较小且安全性要求不高的数据，而且一般数据都会进行加密  
比如保存登录信息，购物车信息，网页主题保存等

public class CookieServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           //解决中文乱码
            req.setCharacterEncoding("utf-8");
            resp.setCharacterEncoding("utf-8");
            resp.setContentType("text/html;charset=utf-8");
            
            resp.getWriter().write("用户上次访问服务器的时间是:");
            //获取浏览器的cookies
            Cookie[] cookies = req.getCookies();
            //判断是否为空
            if(cookies!=null){
                for(Cookie c:cookies){
                    if(c.getName().equals("qj")){
                        System.out.println(c.getValue());
                       resp.getWriter().write(c.getValue());
                    }
                }
            }
    
            //浏览器存储cookie信息
    
            Cookie c = new Cookie("qj","豆皮江");
            //设置cookie有效期(没有设置过期时间，关闭浏览器cookie就失效)
            c.setMaxAge(30*24*60);
            // 存储cookie
            resp.addCookie(c);
        }

## Cookie来实现几天免登录小案例： ##

public class FreeLogin extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            String u_username = req.getParameter("username");
            String p_password = req.getParameter("password");
            if(p_password.equals("222222")&&u_username.equals("li111111")){
                String free = req.getParameter("freeLogin");
                if(free!=null){
                    System.out.println("开启了三天自动登录");
                    //将用户名和密码存放在了cookie，然后让前端获取cookie的信息，并存在浏览器中
                    Cookie usernameCookie=new Cookie("username",u_username);
                    Cookie passwordCookie = new Cookie("password",p_password);
                    usernameCookie.setPath(req.getContextPath()+"login.jsp");//cookie信息设置在登录页 为了下次登录直接获取到cookie的信息
                    passwordCookie.setPath(req.getContextPath()+"login.jsp");//cookie信息设置在登录页 为了下次登录直接获取到cookie的信息
                    //设置过期时间
                    usernameCookie.setMaxAge(60*60*24*3);
                    passwordCookie.setMaxAge(60*60*24*3);
    
                    //冲刷到前端
                    resp.addCookie(usernameCookie);
                    resp.addCookie(passwordCookie);
                }
                //最后间接请求转发到成功页面
               req.getRequestDispatcher("success.jsp").forward(req,resp);
            }
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    }

前端页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>登录页面</title>
        <script src="js/jquery-1.8.3.min.js"></script>
        <script src="js/FreeLogin.js"></script>
    </head>
    <body>
    <div align="center">
        <div>
            <h2>欢迎使用图书管理系统</h2>
            <form action="FreeLogin" method="Get" id="loginForm">
            用户名:<input id="username" type="text" name="username"><br/>
            密  码:<input id="password" type="password" name="password"><br/>
                <input  type="checkbox" name="freeLogin">2天免登陆<br/>
                <input type="submit" value="提交">
            </form>
    
        </div>
    </div>
    </body>
    </html>

思路：  
只要后端把cookie信息刷到前端，那么前端就可以直接通过js获取cookie信息，在有效期时间，就直接登录成功，js不仅获取cookie信息，还有操作表单中的用户名和密码填写，就这样帮我们实现了几天免登录的思想了：

在cookie有效期内每次请求这个地址，它就会直接登录成功，是没有问题的，这里就简单实现了，没有考虑其他问题了

## Session简讲（重点） ##

服务器可以为每个用户浏览器创建一个会话对象（session对象），注意：一个浏览器独占一个session对象(默认情况下)。因此，在需要保存用户数据时，服务器程序可以把用户数据写到用户浏览器独占的session中，当用户使用浏览器访问其它程序时，其它程序可以从用户的session中取出该用户的数据，为用户服务  
**服务器是如何实现一个session为一个用户浏览器服务的？**  
服务器创建session出来后，会把session的id号，以cookie的形式回写给客户机，这样，只要客户机的浏览器不关，再去访问服务器时，都会带着session的id号去，服务器发现客户机浏览器带session id过来了，就会使用内存中与之对应的session为之服务

public class SessionServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            req.setCharacterEncoding("utf-8");
            resp.setCharacterEncoding("utf-8");
            resp.setContentType("text/html;charset=utf-8");
    
            //Session对象由服务器创建 得到session
           HttpSession session =  req.getSession();
            //向session存放
           req.setAttribute("qj","豆皮江");
           //获取session的id
            String sessionId = session.getId();
            //判断session是不是新创建
            if(session.isNew()){
                resp.getWriter().print("session创建成功，session的id是"+sessionId);
            }else{
                resp.getWriter().print("服务器已经存在该session了，session的id是："+sessionId);
            }
        }

network中发现：session的Id以cookie的形式发送给客户端浏览器

public class SessionServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            req.setCharacterEncoding("utf-8");
            resp.setCharacterEncoding("utf-8");
            resp.setContentType("text/html;charset=utf-8");
    
            //Session对象由服务器创建 得到session
           HttpSession session =  req.getSession();
            //向session存放
          session.setAttribute("qj","豆皮江");
           //获取session的id
            String sessionId = session.getId();
            //判断session是不是新创建
            if(session.isNew()){
                resp.getWriter().print("session创建成功，session的id是"+sessionId);
            }else{
                resp.getWriter().print("服务器已经存在该session了，session的id是："+sessionId);
            }
           
    //         //获取session的Id
    //       String seId = session.getId();
    //        //将session的Id存储到名字为JSESSIONID的cookie中
    //       Cookie cookie= new Cookie("JSESSIONID", sessionId);
    //       //设置cookie的有效路径
    //       cookie.setPath(req.getContextPath());
    //      resp.addCookie(cookie);
    
        }

手动设置Session失效时，可以手工调用session.invalidate方法，摧毁session。

//手动设置Session失效来摧毁Session
            HttpSession s =
                      req.getSession();
    
              s.invalidate();

在web.xml文件中可以手工配置session的（服务器会自动销毁session）时间

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1"
             metadata-complete="true">
    
      <servlet>
          <servlet-name>CookieServlet</servlet-name>
          <servlet-class>com.qianjiang.item.CookieServlet</servlet-class>
        </servlet>
        <servlet-mapping>
          <servlet-name>CookieServlet</servlet-name>
          <url-pattern>/CookieServlet</url-pattern>
        </servlet-mapping>
    
      <servlet>
        <servlet-name>ImageServlet</servlet-name>
        <servlet-class>com.qianjiang.item.ImageServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>ImageServlet</servlet-name>
        <url-pattern>/ImageServlet</url-pattern>
      </servlet-mapping>
    
      <servlet>
        <servlet-name>SessionServlet</servlet-name>
        <servlet-class>com.qianjiang.item.SessionServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>SessionServlet</servlet-name>
        <url-pattern>/SessionServlet</url-pattern>
      </servlet-mapping>
      <servlet>
        <servlet-name>SessionServlet1</servlet-name>
        <servlet-class>com.qianjiang.item.SessionServlet1</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>SessionServlet1</servlet-name>
        <url-pattern>/SessionServlet1</url-pattern>
      </servlet-mapping>
    
      <servlet>
        <servlet-name>SessionServlet2</servlet-name>
        <servlet-class>com.qianjiang.item.SessionServlet2</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>SessionServlet2</servlet-name>
        <url-pattern>/SessionServlet2</url-pattern>
      </servlet-mapping>
        
          <session-config>
              <session-timeout>30</session-timeout>
           </session-config>
    </web-app>

**Session和Cookie的主要区别**  
Cookie是把用户的数据写给用户的浏览器。  
Session技术把用户的数据写到用户独占的session中。  
**Session对象由服务器创建**，开发人员可以**调用request对象的getSession方法得到session对象。**

## Filter(重点) ##

过滤器filter是**拦截请求**，并对传给请求资源的ServletRequest 或 ServletResponse 进行处理的一个对象。可以用于登录，加密和解密，会话检查，图片转换，解决中文乱码，通过Filter技术，对web服务器管理的所有资源：例如Jsp、Servlet、图片或html文件等进行拦截问题等等  
**有哪些场景是需要统一处理的呢？**  
编码过滤：统一编码。  
敏感词过滤：对一些敏感的词用其他符号代替。  
认证过滤：对用户请求进行统一的认证。  
登录和审核过滤：对用户的访问请求进行记录和审核。  
图像装换过滤：转换图像格式。  
数据压缩过滤：对用户发生的数据进行压缩，从而减少传输量。  
统一缓存控制：对某类资源如图片文件夹、css文件夹下的资源请求在response响应头上添加缓存有效期设置，对经常变化的页面如首页、新闻在response响应头上添加不缓存设置  
用户登录与权限控制：  
用户请求到达资源前判断用户是否登录(session等)，是否对资源有权限，如果没有则请求重定位到登录或出错页  
资源保护:  
当用户请求资源(mp3、图片等)前，通过判断请求参数信息，如session、referer等，决定是否允许用户下载，从而达到防盗链的功能

public class FilterDemo implements Filter {
    //Filter的创建和销毁由web服务器负责。
    //web应用程序启动时，web服务器将创建Filter的实例//对象，并调用其init方法，读取web.xml配置，完成//对象的初始化功能。
    //Filter对象只会创建一次，init方法也只会执行一次。
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("初始化状态");
        }
    
    
    //这个方法完成实际的过滤操作。当客户请求访问与过滤器关联的URL的时候，Servlet过滤器将先执行doFilter方法。FilterChain参数用于访问后续过滤器。
        @Override
        public void doFilter(ServletRequest request, ServletResponse response,
                             FilterChain chain) throws IOException, ServletException {
           request.setCharacterEncoding("utf-8");
           response.setCharacterEncoding("utf-8");
           response.setContentType("text/html;charset=utf-8");
            chain.doFilter(request,response);//请求继续走下去 ，不写 就会被拦截
        }
    
    
    //Filter对象创建后会驻留在内存，当web应用移除或服务器停止时才被销毁。
    //该方法在Filter的生命周期中仅执行一次。在这个方法中，可以释放过滤器使用的资源。
        @Override
        public void destroy() {
            System.out.println("销毁状态");
        }
    }

web.xml的写法

<servlet>
        <servlet-name>FilterTest</servlet-name>
        <servlet-class>com.qianjiang.item.FilterTest</servlet-class>
      </servlet>
      <servlet-mapping>
        <servlet-name>FilterTest</servlet-name>
        <url-pattern>/show/FilterTest</url-pattern>
      </servlet-mapping>
    
      <servlet-mapping>
        <servlet-name>FilterTest</servlet-name>
        <url-pattern>/FilterTest</url-pattern>
      </servlet-mapping>
    
      <filter>
        <filter-name>FiterDemo</filter-name>
        <filter-class>com.qianjiang.item.FiterDemo</filter-class>
        <init-param>
    		<param-name>Encoding</param-name>
    		<param-value>utf-8</param-value>
    </init-param>
      </filter>
      <filter-mapping>
        <filter-name>FiterDemo</filter-name>
        <url-pattern>/show/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
            <dispatcher>FORWARD</dispatcher>
                <dispatcher>INCLUDE</dispatcher>
      </filter-mapping>

## 监听器 ##

有了监听器，应用场景：  
统计当前在线人数：在JavaWeb应用开发中，有时候我们需要统计当前在线的用户数，此时就可以使用监听器技术来实现这个功能了。  
Session管理器：当一个Web应用创建的Session很多时，为了避免Session占用太多的内存，我们可以选择手动将这些内存中的session销毁，那么此时也可以借助监听器技术来实现  
…  
web.xml的写法

<listener>
        <listener-class>com.qianjiang.item.onLineCount</listener-class>
      </listener>

HttpSessionBindingListener接口，  
新开一个浏览器会创建一个新的session，关闭浏览器不会关闭原来的session  
执行session.invalidate方法，会调用valueUnbound方法  
HttpSessionBindingListener实例化之后放入某一个session中，就可以进行监听  
session超时，会自动调用valueUnbound方法  
使用request.getSession().setMaxInactiveInterval(10);即可设置session的失效时间为10秒

## 什么是JSP ##

Java Server Page 结合 java和html在服务端动态生成web页面的技术

## JSP基础 ##

1.基础语法  
表达式：

<%--<%=变量名或者表达式%>--%>
    <%=new Date()%>

脚本片段：

<%--jsp的脚本片段--%>
    <%
        int sum = 0;
        for (int i = 0; i <20 ; i++) {
            sum+=i;
    
        }
        out.print("<h1>sum="+sum+"</h1>");
    %>

**获取协议、获取服务名、获取端口号**

<%
        String path = request.getContextPath();
        String basePath = request.getScheme() + "://"
                + request.getServerName() + ":" + request.getServerPort()
                + path + "/";
    %>
    <%
        out.print(path);
        out.print(basePath);//http://localhost:8080/
    %>

${pageContext.request.contextPath}/sys/subjects

在代码中嵌入html元素：

<%--在代码中嵌入html元素--%>
    <%
        for (int i = 0; i <3 ; i++) {
    
    %>
    <h1>hello world <%=i%></h1>
    <%
        }
    %>

全局变量声明：

<%!
        static {
            System.out.println("loginServlet");
        }
        
        int a= 12;
    
    %>
    
    <% 
    out.print(a);
    
    %>

注意：jsp的注释不会再客户端显示  
**jsp的一些指令**  
一些比较常用的指令  
**定制一下错误页面：**  
<%@ page errorPage=“error/error.jsp”%>  
或者在web.xml配置

<error-page>
    	    <error-code>500</error-code>
    	    <location>/error/error.jsp</location>
     	 </error-page>

导入java包：  
<%@ page import=“java.util.Date” %>  
包含其他文件：  
<%@ include会将两个页面合二为一

<%@ include file="common/header.jsp"%>
            <h1>网页主体</h1>
            <%@include file="common/footer.jsp"%>

也可以用jsp标签完成  
<jsp:include 拼接页面 独立存在

<%--jsp的标签--%>
    <jsp:include page="common/header.jsp"></jsp:include>
            <h1>网页主体</h1>
    <jsp:include page="common/footer.jsp"></jsp:include>

**静态包含<%@include%>、动态包含jsp:incude的区别**:

静态包含<%@include%>，中包含的文件，只是简单的嵌入到主文件中，就是在jsp页面转化成Servlet时才嵌入到主文件中，因为运行的结果是只生成了一个Servlet。  
动态包含jsp:incude，如果被包含文件是动态的，那么就会生成两个Servlet，两个Servlet通过request和reponse进行通信。

jsp:include标签用于把另外一个资源的输出内容插入到当前JSP页面的输出内容之中，这种在JSP页面执行时的引入方式称之为动态引入。可以传递参数  
jsp:forward标签用于把请求转发给另外一个资源。它只有一个属性page,可以传递参数  
jsp:usebean标签用来加载一个将在JSP页面中使用的JavaBean

<jsp:useBean id="account1" class="com.qj.pojo.Account" scope="page"></jsp:useBean>
    ${account1.role}

type转化类型

<jsp:useBean id="account2" class="com.qj.pojo.AdminUser" scope="page" type="com.qj.pojo.User"></jsp:useBean>
    ${account2.role}

scope =“page”,scope=“session”(每次刷新代码块就不执行了)

<jsp:useBean id="account1" class="com.qj.pojo.Account" scope="page">
        ${account1.role}
    </jsp:useBean>
    
    <jsp:useBean id="account2" class="com.qj.pojo.Account" scope="session">
       <%
           for (int i = 0; i < 10; i++) {
               out.print(i);
           }
       %>
    </jsp:useBean>

jsp:setProperty标签用来设置已经实例化的Bean对象的属性。

<jsp:useBean id="account1" class="com.qj.pojo.Account" scope="page">
        ${account1.role}
    </jsp:useBean>
    
    <jsp:setProperty name="account1" property="role" value="1">
        ${account1.role}
    </jsp:setProperty>
    <jsp:setProperty name="account1" property="role" param="prole">
        ${account1.role}
    </jsp:setProperty>
    <jsp:setProperty name="account1" property="role" >
        ${account1.role}
    </jsp:setProperty>
    <jsp:setProperty name="account1" property="*" >
        ${account1.role}
        ${account1.telephone}
    </jsp:setProperty>

jsp:getProperty标签用来提取指定Bean属性的值，转换成字符串，然后输出。

<jsp:useBean id="good" class="com.qj.pojo.Goods" scope="page">
    </jsp:useBean>
    
    <jsp:getProperty name="good" property="goodName" />

<jsp:element >、  
jsp:body、  
jsp:attribute动作元素动态定义xml元素。动态是非常重要的，这就意味着xml元素在编译时动态生成的而非静态。

<a href="http://www.baidu.com"><span style="color: red">百度</span></a>
    <br/>
    
    <jsp:element name="a">
        <jsp:attribute name="href">http://www.baidu.com</jsp:attribute>
        <jsp:body>
            <jsp:element name="span">
                <jsp:attribute name="style">color: red</jsp:attribute>
            <jsp:body>百度</jsp:body>
            </jsp:element>
        </jsp:body>
    </jsp:element>

## 四大作用域 ##

A.page 只在页面中保存属性，跳转之后则无效；—使用pageContext表示  
B.request 只在一次请求中保存属性，客户端跳转无效，但是服务器跳转后依然有效；  
C.session 在一次会话中保存，无论何种跳转都可以使用，但是新开的浏览器无法使用；  
D.application 在整个服务器上保存，所有用户都可以使用。

## 九大内置对象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]  
request对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对象的作用域为一次请求  
response对象代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。  
application对象：  
将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。  
session对象：  
是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。session对象内部使用Map类来保存数据，因此保存数据的格式为 “key/value”  
config对象:  
主要作用是取得服务器的配置信息。

<context-paramter>
    	<param-name>connect</param-name>
    	<param-value>192.168.0.1</param-value>
    </context-paramter>

<%
     String c = config.getServletContext().getInitParameter("connect");
    %>

<servlet>
        <servlet-name>myConfig</servlet-name>
        <jsp-file>/jsp/configTest.jsp</jsp-file>
        <init-param>
          <param-name>constr</param-name>
          <param-value>192.168.0.1</param-value>
        </init-param>
      </servlet>
      <servlet-mapping>
        <servlet-name>myConfig</servlet-name>
        <url-pattern>/myConfig.do</url-pattern>
      </servlet-mapping>

<%
     String myConfig = config.getInitParameter("myConfig");
    %>

out对象:  
用于在Web浏览器内输出信息。  
设置大于缓存区，就不能冲刷

<%@ page contentType="text/html;charset=UTF-8" buffer="1kb" autoFlush="true" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <%
        for (int i = 0; i < 50; i++) {
            out.print(i);
        }
    %>
    </body>
    </html>

exception对象:  
是用于显示异常信息，只有在包含isErrorPage=“true” 的页面中才可以被使用。  
cookie:  
cookie是保存在客户端(浏览器)中的一小段文本信息。比如您常看到的登录页面通常有一个选项“2周内不用再登录”，便是采用cookie技术实现的。  
pageContext 存  
request 存  
session 存  
application\[ServletContext\] 存  
config  
out  
page  
exception  
response

<%
        pageContext.setAttribute("name1","doupijiang1");//保存的数据只在一个页面中有效
        request.setAttribute("name2","doupijiang2");//保存的数据只在一次请求中有效，请求转发会携带这个数据
        session.setAttribute("name3","doupijiang3");//保存的数据只有一次会话中有效，从打开浏览器到关闭浏览器
        application.setAttribute("name4","doupijiang4");//保存的数据只在服务器中国有效,从打开浏览器到关闭浏览器
    %>

结论：在同一个页面中，所有的作用域的值都能获取  
示例2：进行请求转发  
pageContext：作用域中的值获取不到，其它作用域仍然可以。  
pageContext.forward("/index.jsp");  
示例3：先访问scope.jsp,再次访问 sc2.jsp,进行了两次请求。  
pageContext和request中的数据都获取不到  
示例4：先访问scope.jsp,关闭浏览器，重新打开再次访问sc2.jsp  
pageContext request session 都失效了  
示例5：先访问scope.jsp,关闭服务器，再次访问sc2.jsp  
四个作用域都失效了…  
request:客户端向服务器发送请求，产生数据，用户看完没用了。比如：新闻，用户看完就没用的  
session:客户端向服务端发送请求，产生的数据，用户用完一会了一会还有用；比如：购物车  
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据

## JSP标签、JSTL标签、EL表达式 ##

el（Expression Language）表达式：  
$\{\}  
如判空运算  
$\{empty ‘’\}、  
$\{empty ‘ac’\}  
用来获取数据、执行数据、获取web开发的常用对象  
jsp标签：

<%
        request.setCharacterEncoding("utf-8");
    %>
    <jsp:forward page="jstltab2.jsp">
        <jsp:param name="id" value="23"/>
        <jsp:param name="sex" value="男"/>
    </jsp:forward>

<h1>从另一个页面接受过来的参数</h1>
    <%

String id = request.getParameter("id");
        String sex= request.getParameter("sex");
    	 out.print("<h1>学生id"+id+"</h1>");
    	 out.print("<h1>学生性别"+sex+"</h1>");

读取Cookie：  
A.设置Cookie：

<title>Insert title here2</title>
    <%
      Cookie cookie1 = new Cookie("country","chn");
      cookie1.setMaxAge(120);
      response.addCookie(cookie1);
    %>
    </head>

B.读取Cookie：

<hr />
      ${cookie.country.name}<br/>
      ${cookie.country.value}<br/>
      ${cookie['country'].name }<br/>
     ${cookie['country'].value }<br/>
     <hr />

**jstl表达式：（重点）**  
引入：  
<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>  
jstl标签库的使用时弥补html标签的不足；它自定义许多标签，可以供我们使用，标签的功能和java代码一样  
**核心标签**  
<c:forEach/>

<body>
        <%
            ArrayList<String> arrayList = new ArrayList<>();
            arrayList.add("豆豆");
            arrayList.add("皮皮");
            arrayList.add("江江");
    
            request.setAttribute("lists",arrayList);
    
        %>
    <c:forEach var="arrayList" items="${lists}" >
        <c:out value="${arrayList}"></c:out>
    
    </c:forEach>
    
    </body>

<c:if/>

等等。。。。

## SpringMVC时代 ##

传统的方式:一个servlet要处理多个请求，问号带参的方式很好解决

protected void service(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		
    	String cmd= request.getParameter("cmd");
    		if(cmd.equals("paperlist")){
    			index(request,response);
    		}else if(cmd.equals("login")){
    			login(request,response);
    		}else if(cmd.equals("init")){
    			initpage(request,response);
    		}else if(cmd.equals("logout")){
    			logout(request,response);
    		}else if(cmd.equals("list")){
    			list(request,response);
    		}else if(cmd.equals("add")){
    			add(request,response);
    		}else if(cmd.equals("toedit")){
    			toedit(request,response);
    		}else if(cmd.equals("edit")){
    			edit(request,response);
    		}else if(cmd.equals("toeditpwd")){
    			toeditpwd(request,response);
    		}else if(cmd.equals("editpwd")){
    			editpwd(request,response);
    		}else if(cmd.equals("paper")){
    			paper(request,response);
    		}else if(cmd.equals("stulogin")){
    			stulogin(request,response);
    		}else if(cmd.equals("answer")){
    			answer(request,response);
    		}
    	}

现在是springmvc时代，所以每一个请求就写一个接口

@Controller
    @RequestMapping("/user")
    public class UserController {
        @GetMapping("/stuLogin")
        public String subLogin(HttpServletRequest request){
            return null;
        }
    }

## 小练习 ##

此过程用了maven构建web项目的：  
pom.xml:

<dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
        </dependency>
        <dependency>
          <groupId>commons-dbutils</groupId>
          <artifactId>commons-dbutils</artifactId>
          <version>1.7</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.4</version>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.26</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>javax.servlet.jsp-api</artifactId>
          <version>2.3.3</version>
        </dependency>
        <dependency>
          <groupId>taglibs</groupId>
          <artifactId>standard</artifactId>
          <version>1.1.2</version>
        </dependency>
        <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.21</version>
        </dependency>

layui+javaweb+ajax主要完成一个分页功能（另外还做了个弹框和删除功能）  
pojo层：  
Teacher类：

public class Teacher {
        private String sn;
        private  String name;
        private String password;
        private String sex;
        private String mobile;
    
        public Teacher() {
        }
    
        public Teacher(String sn, String name, String password, String sex, String mobile) {
            this.sn = sn;
            this.name = name;
            this.password = password;
            this.sex = sex;
            this.mobile = mobile;
        }
    
        public String getSn() {
            return sn;
        }
    
        public void setSn(String sn) {
            this.sn = sn;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getMobile() {
            return mobile;
        }
    
        public void setMobile(String mobile) {
            this.mobile = mobile;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "sn='" + sn + '\'' +
                    ", name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    ", sex='" + sex + '\'' +
                    ", mobile='" + mobile + '\'' +
                    '}';
        }
    }

dao层：  
BaseDao类：

import com.alibaba.druid.pool.DruidDataSource;
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Properties;
    
    public class BaseDao {
        private static DruidDataSource druidDataSource = null;
    
        static {
            Properties properties = new Properties();
    
            try {
                properties.load(BaseDao.class.getClassLoader().getResourceAsStream("db.properties"));
    
                druidDataSource =(DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
    
    
            }catch (Exception e) {
              new RuntimeException("配置失败");
            }
        }
    
        //得到一个数据源
        public static DruidDataSource getDataSource(){
            return  druidDataSource;
        }
        //建立连接
        public  static Connection getCon() throws SQLException {
           return  druidDataSource.getConnection();
        }
        //开启事务
        public static void OpenTransaction() throws SQLException {
            druidDataSource.getConnection().setAutoCommit(false);
        }
        //提交事务
        public static  void comm() throws SQLException {
            BaseDao.getCon().commit();
    
        }
        //回滚
        public static void back() throws SQLException {
            druidDataSource.getConnection().rollback();
        }
        //关闭资源
        public static  void release(Connection connection,
                                    PreparedStatement preparedStatement,
                                    ResultSet resultSet){
    
            if(resultSet!=null){
                try{
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
    
                }
            }
        }
    }

TeacherDao类：

public class TeacherDao {
        QueryRunner queryRunner = new QueryRunner(BaseDao.getDataSource());
        
        public TeacherDao() throws SQLException {
        }
        
        //查询所有老师
        public List<Teacher> getTeacherList() throws SQLException {
            return  (List<Teacher>) queryRunner.query("select * from s_teacher",new BeanListHandler<Teacher>(Teacher.class));
        }
    
        //根据姓名来查看老师的信息
        public Teacher getTeacher(String s_name) throws SQLException {
    
            String sql = "select * from s_teacher where name = '"+s_name +"'";
            Object[] par = {};
            return  queryRunner.query(sql,new BeanHandler<Teacher>(Teacher.class),par);
        }
        //根据姓名来删除老师
        public boolean deleteTeacher(String s_name) throws SQLException {
            //delete from s_teacher where name='钱老师'
    
    //      BaseDao.getCon().setAutoCommit(false);//关闭数据库自动提交，开启事务
    
            String sql="delete from s_teacher where name ='"+s_name+"'";
    
            Object[] par={};
            try{
                queryRunner.update(sql,par);
                System.out.println("111");
    //            BaseDao.getCon().commit();
                return true;
            }catch (Exception e){
                //如果失败则默认回滚（显示说明而已）
                //BaseDao.getCon().rollback();
                e.printStackTrace();
            }
    
            return false;
        }
        //根据姓名来更新老师的信息
        public boolean updateTeacher(Teacher teacher){
            String sql ="UPDATE s_teacher SET mobile = '"+teacher.getMobile()+"+',`password`='"+teacher.getPassword()+"',sex='"+teacher.getSex()+"',`name`='"+teacher.getName()+"',sn='"+teacher.getSn()+"' where `name`='钱老师'";
    
            Object[] par = {};
            try{
                 queryRunner.update(sql,par);
                 return  true;
            } catch (SQLException e) {
               e.printStackTrace();
            }
            return false;
        }
    
        //查询老师的总记录数
        public Long countTeachers() throws SQLException {
    
            String sql = "select count(1) from s_teacher";
            Object[] par = {};
             Long a = queryRunner.query(sql,new ScalarHandler<Long>());
              return a;
    
        }
    
        //查询分页每页10条显示
        public List<Teacher> getPageTeacher(int s_currentPage,int limit) throws SQLException {
            int curPage = (s_currentPage-1)* limit;
            String sql = "select * from s_teacher limit "+curPage+" ,"+limit+"";
            Object[] par = {};
            List<Teacher> pageTeacherList =  queryRunner.query(sql,new BeanListHandler<Teacher>(Teacher.class));
            return pageTeacherList;
        }
        @Test()
         public  void  test() throws SQLException {
                TeacherDao teacherDao = new TeacherDao();
                List<Teacher> teacherList = teacherDao.getTeacherList();
                for(int i=0;i<teacherList.size();i++){
                        System.out.println(teacherList.get(i).getName());
                }
         }
        @Test()
        public  void  test1() throws SQLException {
            TeacherDao teacherDao = new TeacherDao();
           Teacher teacher = teacherDao.getTeacher("李老师");
            System.out.println(teacher.getName()+teacher.getPassword());
        }
    
        @Test()
        public  void  test2() throws SQLException {
            TeacherDao teacherDao = new TeacherDao();
            boolean num = teacherDao.deleteTeacher("张三老师");
            if(num){
                System.out.println("删除成功");
            }else{
                System.out.println("删除失败");
            }
        }
        @Test()
        public  void  test3() throws SQLException {
            TeacherDao teacherDao = new TeacherDao();
            Teacher teacher = teacherDao.getTeacher("钱老师");
            teacher.setMobile("122333323");
            teacher.setName("豆皮江老师老师");
            teacher.setPassword("12313");
            teacher.setSex("男");
            teacher.setSn("T088881001");
            boolean num = teacherDao.updateTeacher(teacher);
            if(num){
                System.out.println("修改成功");
            }else{
                System.out.println("修改失败");
            }
        }
        @Test()
        public  void test4() throws SQLException {
            TeacherDao teacherDao = new TeacherDao();
          Long n =  teacherDao.countTeachers();
            System.out.println(n);
        }
        @Test()
        public  void test5() throws SQLException {
            TeacherDao teacherDao = new TeacherDao();
            List<Teacher> list = teacherDao.getPageTeacher(2,10);
            for(int i=0;i<list.size();i++){
                System.out.println(list.get(i).toString());
    
            }
        }
    
    }

**展示老师：  
show(展示)jsp**

<%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
        <link rel="stylesheet" href="${pageContext.request.contextPath}/layui/css/layui.css">
    </head>
    <body>
    
    
    <table class="layui-table" lay-data="{width: 1300, height:360, url:'showTeacher', page:true, id:'test'}"
           lay-filter="demo">
        <thead>
        <tr>
            <th lay-data="{field:'mobile', width:160, sort: true,align:'center', fixed: true,edit:'text'}">手机号</th>
            <th lay-data="{field:'name', width:100,align:'center',edit:'text'}">姓名</th>
            <th lay-data="{field:'password', width:100, align:'center',sort: true,edit:'text'}">密码</th>
            <th lay-data="{field:'sex', width:160,align:'center',edit:'text'}">性别</th>
            <th lay-data="{field:'sn', width:160,align:'center',edit:'text'}">序列号</th>
            <th lay-data="{fixed: 'right', width:178, align:'center', toolbar: '#barDemo',edit:'text'}">操作</th>
        </tr>
        </thead>
    </table>
    
    <script type="text/html" id="barDemo">
        <a class="layui-btn layui-btn-primary layui-btn-xs" lay-event="checkTeacher">查看</a>
        <a class="layui-btn layui-btn-xs" lay-event="updateTeacher">编辑</a>
        <a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="deleteTeacher">删除</a>
    </script>
    <script src="${pageContext.request.contextPath}/layui/layui.js"></script>
    <script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery.js"></script>
    <script>
        layui.use('table', function() {
            var table = layui.table;
            var laypage = layui.laypage;
            // //监听表格复选框选择
            // table.on('checkbox(demo)', function(obj) {
            //     console.log(obj)
            // });
            //监听工具条
            table.on('tool(demo)', function(obj) {
                var data = obj.data;
                if (obj.event === 'checkTeacher') {
                    //layer.msg('name：' + data.name + ' 的查看操作');
                    layer.open({
                        type : 2,
                        title : '查看老师的信息',
                        content : 'checkTeacher?name=' + data.name,//这里通过传递老师名字这个参数来查询老师的信息(一般都是根据id来)
                        shade : 0.5,
                        area : [ '600px', '400px' ],
                        maxmin : true
                    });
                } else if (obj.event === 'deleteTeacher') {
                    layer.confirm('真的要删除行么', function(index) {
                        obj.del();
                        $.ajax({
                            type : "get",
                            url : "deleteTeacher?name=" + data.name,//这里通过传递老师这个名字来删除老师(一般根据老师的id来)
                            dataType : "json"
                        });
                        layer.close(index);
                    });
    
                } else if (obj.event === 'updateTeacher') {
                    //layer.alert('编辑行：<br>'+ JSON.stringify(data))
                    $.ajax({
                        type : "get",
                        data : data,
                        url : "updateTeacher?name=" + data.name,
                        dataType : "json"
                    });
    
                }
            });
    
        });
    </script>
    </body>
    </html>

**controller层：  
ShowTeachersController类：**

@WebServlet(value = "/showTeacher")
    public class ShowTeachersController extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            req.setCharacterEncoding("utf-8");
            resp.setCharacterEncoding("utf-8");
            resp.setContentType("text/html;charset=utf-8");
            int currentPage = Integer.parseInt(req.getParameter("page") == null ? "1" : req.getParameter("page"));
            int limit = Integer.parseInt(req.getParameter("limit") == null ? "10" : req.getParameter("limit"));
            //System.out.println("page"+currentPage+"limit:"+limit);
            ShowTeachersService showTeachersService = new ShowTeachersService();
    
            try {
                //List<Teacher> teacherList = showTeachersService.getShowTeachers();//这个是展示所有，现在，每5条数据的展示
                List<Teacher> teacherList=showTeachersService.getPageTeacher(currentPage,limit);
                //把集合对象转化成json对象
                String jsonString = JSONObject.toJSONString(teacherList);
       //      JSONObject obj = new JSONObject();
    //        obj.put("code", 0);
    //        obj.put("msg", "");
    //        obj.put("count", count);
    //        obj.put("data", limitData);
    //        PrintWriter out = resp.getWriter();
    //        String str = obj.toJSONString();
    
                //显示总记录数
                Long count = showTeachersService.getCount();
                String str = "{\"code\":0,\"msg\":\"\",\"count\":" + count+ ",\"data\":" + jsonString + "}";
                //System.out.println(str);
    
                resp.getWriter().write(str);
    
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    
        @Test()
        public  void test() throws ServletException, IOException {
    
            HttpServletRequest req = null;
            HttpServletResponse resp = null;
            showJson(req,resp);
        }
    
    
        private void showJson(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            ShowTeachersController showTeachersController = new ShowTeachersController();
            showTeachersController.doGet(req,resp);
        }
    }

**点击查看老师信息：  
check(查看).jsp:**

<%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>查询教师资料页面</title>
        <style>
            .layui-form{
                margin: 5% 0 0 40%;
            }
        </style>
        <link rel="stylesheet" href="${pageContext.request.contextPath}/layui/css/layui.css">
    </head>
    <body>
    <form  action="#" method="post" class="layui-form layui-form-pane">
        <div class="layui-form-item pane">
            <label class="layui-form-label">手机号</label>
            <div class="layui-input-inline">
                <input type="text" name="name"  value="${t.mobile}" autocomplete="off" class="layui-input ">
            </div>
        </div>
        <div class="layui-form-item pane">
            <label class="layui-form-label">姓名</label>
            <div class="layui-input-inline">
                <input type="text" name="password" value="${t.name }"  autocomplete="off" class="layui-input ">
            </div>
        </div>
        <div class="layui-form-item pane">
            <label class="layui-form-label">密码</label>
            <div class="layui-input-inline">
                <input type="text" name="password" value="${t.password }"  autocomplete="off" class="layui-input ">
            </div>
        </div>
        <div class="layui-form-item pane">
            <label class="layui-form-label">性别</label>
            <div class="layui-input-inline">
                <input type="text" name="sex" value="${t.sex } " autocomplete="off" class="layui-input ">
            </div>
        </div>
        <div class="layui-form-item pane">
            <label class="layui-form-label">序列号</label>
            <div class="layui-input-inline">
                <input type="text" name="sn" value="${t.sn }"  autocomplete="off" class="layui-input ">
            </div>
        </div>
    
        ${success }
    </form>
    <script src="${pageContext.request.contextPath}/layui/layui.js"></script>
    <script>
        layui.use('form', function(){
            var form = layui.form;
        });
    </script>
    
    </body>
    </html>

**CheckTeacherController类：**

@WebServlet("/checkTeacher")
    public class CheckTeacherController extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
               String s_name =  req.getParameter("name");
            CheckTeacherService checkTeacherService = new CheckTeacherService();
            try {
                Teacher teacher = checkTeacherService.getTeacher(s_name);
                if(teacher!=null){
                    req.setAttribute("t",teacher);
                    req.getRequestDispatcher("check.jsp").forward(req,resp);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req, resp);
        }
    }

**点击删除按钮会触发一个请求  
DeleteTeacherController类：**

@WebServlet("/deleteTeacher")
    public class DeleteTeacherController extends HttpServlet {
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req, resp);
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String s_name = req.getParameter("name");
            DeleteTeacherService deleteTeacherService = new DeleteTeacherService();
            try {
                deleteTeacherService.delTeacher(s_name);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

**点击编辑会触发一个请求:**

@WebServlet("/updateTeacher")
    public class UpdateTeacherController extends HttpServlet {
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doGet(req, resp);
        }
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String s_name = req.getParameter("name");
            System.out.println("姓名:"+s_name);
           String s_password = req.getParameter("password");
            System.out.println("密码:"+s_password);
           String s_sex = req.getParameter("sex");
            System.out.println("姓名:"+s_sex);
           String s_mobile = req.getParameter("mobile");
            System.out.println("手机号:"+s_mobile);
           String s_sn = req.getParameter("sn");
            System.out.println("昵称号:"+s_sn);
    
           //通过姓名来查到老师所有信息
            CheckTeacherService checkTeacherService = new CheckTeacherService();
            UpdateTeacherService updateTeacherService= new UpdateTeacherService();
            try {
                Teacher teacher = checkTeacherService.getTeacher(s_name);
    
                teacher.setName(s_name);
                teacher.setSex(s_sex);
                teacher.setSn(s_sn);
                teacher.setMobile(s_mobile);
                teacher.setPassword(s_password);
                //执行修改
                if(teacher!=null){
                    updateTeacherService.updateTeacher(teacher);
                    resp.sendRedirect("show.jsp");
                }else{
                    System.out.println("更新失败");
                }
    
    
            } catch (SQLException e) {
                System.out.println("修改失败");
                e.printStackTrace();
            }
    
    
        }
    }

db.properties配置：  
有的没有使用到

driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/db_student_manage_javaweb
    username=root
    password=qianjiang
    filters=stat
    initialSize=2
    maxActive=300
    maxWait=60000
    timeBetweenEvictionRunsMillis=60000
    minEvictableIdleTimeMillis=300000
    validationQuery=SELECT 1
    testWhileIdle=true
    testOnBorrow=false
    testOnReturn=false
    poolPreparedStatements=false
    maxPoolPreparedStatementPerConnectionSize=200

这里遇到过问题需要明白几点：  
1、layui自动添加，layui表格的当前页：page，每页显示的条数limit  
2、写sql语句的问题，特别是拼接（很容易报sql语句错误）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]: /images/20221123/9f9cfe3587124de191a1c79bd6d1e83a.png