一、Servlet接口介绍

  • 概念：javaweb程序开发，项目就是一个java应用程序，用sun公司提供的接口Servlet，只要实现里面的一些接口，并按照规则把接口中的代码写完，就是一个javaweb项目。

  • 如果要完成一个javaweb项目的开发

    • 编写一个Java类，让这个java类实现Servlet接口。
    • 将编写好的javaweb项目放置到web服务器中

      二、编写入门程序

  • 编写一个Servlet实现类

    • Servlet接口，根据Servlet的API知道，Servlet存在3个生命周期的方法
      • init():用于初始化的方法，没有特殊代码处理的时候，发送请求的时候执行该方法
      • service():用于处理请求和响应的方法，程序员编写代码的部分。
      • destroy():销毁的方法，如果没有特殊代码处理，关闭服务器的时候销毁。
    • Servlet接口中，也提供了获取Servlet初始化信息的方法
      • getServletConfig();重点，该方法主要能够得到一个ServletConfig对象。后续会专门学习
      • getServletInfo():只能获取Servlet版本号等信息。一般不用。
    • Servlet的API中，提到了在程序员编写Servlet的时候，实际上不需要实现Servlet接口，可以选择继承genericServlet或者HttpServlet
      • 说明：虽然这两个类都是可以实现一个Servlet程序开发的，但是从API上可以看到，实际HttpServlet是GenericServlet的子类，因此，推荐使用HttpServlet

        2.1 用实现GenericServlet来实现javaweb程序开发

        说明：下面的程序是用继承GenericServlet类的方式进行实现javaweb程序的开发，直接提示了要重写service方法，里面的两个参数：ServletRequest和ServletResponse，分别为请求对象和响应对象。 ```java /**

        • Title: ServletDemo1

        • Description: 用继承GenerciServlet的方式进行开发javaweb项目

        • @author Alon
        • @date 2020年10月21日 上午10:11:57
        • @version 1.0 / public class ServletDemo1 extends GenericServlet{ /

        • Title: service

        • Description:

        • @param request 请求对象，获取浏览器发送给服务器的数据
        • @param response 响应对象，由服务器发送给浏览器数据
        • @throws ServletException
        • @throws IOException
        • @see javax.servlet.GenericServlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse) */ @Override public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { System.out.println(“成功请求到了服务器里面的Servlet代码”); //服务器向浏览器发送一些数据 OutputStream out = response.getOutputStream(); out.write(“123123”.getBytes()); //关闭流 out.close(); }

}

  2.    - 需要在WebContent下面的WEB-INF里面新建一个web.xml配置文件，用于配置映射信息
  3. ```xml
  4. <?xml version="1.0" encoding="UTF-8"?>
  5. <web-app version="3.1" 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">
  6. <!-- 在该配置文件中配置Servlet的映射信息，简单理解就是配置Servlet和Servlet-mapping -->
  7.     <servlet>
  8.         <!-- 配置一个Servlet的名称，建议和类名一致 -->
  9.         <servlet-name>ServletDemo1</servlet-name>
  10.         <!-- 配置对应Servlet的全路径 -->
  11.         <servlet-class>com.woniuxy.demo.ServletDemo1</servlet-class>
  12.     </servlet>
  14.     <!--配置Servlet映射信息  -->
  15.     <servlet-mapping>
  16.         <!-- 配置映射名称，要求和Servlet里面的servlet-name一致 -->
  17.         <servlet-name>ServletDemo1</servlet-name>
  18.         <!-- 映射名称 -->
  19.         <url-pattern>/demo1</url-pattern>
  20.     </servlet-mapping>
  21. </web-app>
  • 用浏览器请求到Servlet并执行

image.png

2.2 用实现HttpServlet来实现javaweb程序开发

  • 先编写Servlet代码。 ```java /**

    • Title: ServletDemo2

    • Description: 使用HttpServlet实现javaweb代码的开发

    • @author Alon
    • @date 2020年10月21日 上午11:48:41

    • @version 1.0 */ public class ServletDemo2 extends HttpServlet{

      @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

      1. doPost(request,response);

      }

      /*

      • Title: doPost

      • Description:

      • @param request 请求对象 获取浏览器向服务器发送的数据
      • @param response 响应对象 将服务器的数据发送给浏览器
      • @throws ServletException
      • @throws IOException

      • @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) */ @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { System.out.println(“请求成功”);

        //由服务器给浏览器写出数据 OutputStream out = response.getOutputStream(); out.write(“abc”.getBytes()); //关闭资源 out.close(); } }

  2. - 在web.xml配置文件中配置Servlet对应的类代码
  3. ```xml
  4. <!-- 配置ServletDemo2的映射 -->
  5.     <servlet>
  6.         <servlet-name>ServletDemo2</servlet-name>
  7.         <servlet-class>com.woniuxy.demo.ServletDemo2</servlet-class>
  8.     </servlet>
  9.     <!-- 映射配置 -->
  10.     <servlet-mapping>
  11.         <servlet-name>ServletDemo2</servlet-name>
  12.         <url-pattern>/demo2</url-pattern>
  13.     </servlet-mapping>

2.3 实现请求的步骤

  • 编写Servlet实现类，可以有两种方式，继承GenericServlet或者继承HttpServlet，建议继承HttpServlet
  • 编写好Servelt实现类之后，一定要记得在web.xml配置文件中配置映射信息。
  • 在浏览器地址栏编写请求路径：http://localhost:8080/工程名/映射名称；映射名称为：url-pattern标签之间的值，别忘了斜杠
  • 服务器会根据url-pattern对应的servlet-name中的值，再到servlet标签中找对应的servlet-name。
  • 如果找到了，根据servlet-class找到对应的java代码，并执行。如果是GenerciServlet将执行service方法，如果是HttpServlet将执行doXXX()方法。

说明：实际上HttpServlet是GenericServlet的子类，在GenericServlet里面处理请求使用的是service方法，在service方法中会自动的判断是什么请求，并处理请求，但是到了HttpServlet将service方法进行了拆分，拆分成指定请求执行指定的doXXX()方法。

2.4 初始化方法和销毁方法

  • 初始化方法：init()

初始化的方法，在启动服务器的时候是不会执行的，是在发送第一条请求的时候才会执行，只执行一次。

  1. @Override
  2. public void init() throws ServletException {
  3.     System.out.println("初始化的方法");
  4. }

  • 销毁的方法,在服务器关闭的时候执行

    1. @Override
    2. public void destroy() {
    3.   System.out.println("服务器被销毁了");
    4. }

    三、Servlet流程及原理

    3.1 浏览器请求之后解析的步骤

  • 浏览器发出请求，链接服务器

  • 发送http请求：http://localhost:8080/WebDemo2/demo2;
  • 解析出来IP地址
  • 解析出来端口号
  • 解析出来web应用程序
  • 解析出来请求访问的资源文件
  • 创建Servlet对象，并用init初始化Servlet对象
  • 调用Service方法或者别拆分出来的doxxx()方法。

  • 关闭服务器的时候，销毁Servlet对象，调用destroy方法

    3.2 Servlet对象的生命周期

  • 实现Servlet接口或者继承HttpServlet，该类所在的工程为一个web应用程序，该程序需要放到服务器里面，当服务器一旦开启，那么服务器会自动的在容器中创建一个Servlet对象。

  • 当发送第一条请求的时候，会调用init方法进行初始化Servlet对象。后续请求将不再初始化
  • 每一次调用service方法或者doGet方法或者doPost方法之前，都需要使用Servlet对象创建独立的HttpServletRequest对象和HttpServletResponse对象。
  • 调用service方法或者对应的doXXX()方法处理请求响应。

  • 当服务器关闭的时候，销毁Servlet对象。

    3.3 全局配置文件web.xml

    在web.xml配置文件里面，需要配置映射关系，配置servlet的标签和配置映射的标签servlet-mapping

    1. <!-- 配置Servlet的名称和类名全路径 -->
    2. <servlet>
    3.   <servlet-name></servlet-name>
    4. <servlet-class></servlet-class>
    5. <!-- 设置init执行顺序，要求服务器一旦启动就执行 -->
    6.   <load-on-startup>1</load-on-startup>
    7. </servlet>
    8. <!-- 配置映射关系 -->
    9. <servlet-mapping>
    10. <servlet-name></servlet-name>
    11. <url-pattern></url-pattern>
    12. </servlet-mapping>

    特别说明：Servlet中只有在第一次请求的时候，才会调用init方法，但是有的时候需要在服务器启动的时候，就执行init方法进行初始化容器。

  • 如何让服务器启动的时候就执行init方法？


    1

四、web服务器中其他对象

4.1 ServletConfig对象

  • 作用：获取配置文件（web.xml）中的参数，一些数据可以先配置在web.xml文件中，由ServletConfig对象进行获取，在servlet接口中提供了有参的init方法，参数为ServletConfig对象，在初始化Servlet对象的时候，会调用init方法，在这个时候，web服务器会自动将web.xml里面的参数加载到ServletConfig对象。并且同时将ServletConfig对象交给Servlet对象。

  • 在web.xml配置文件中配置数据

    1. <servlet>
    2.       <servlet-name>ServletDemo3</servlet-name>
    3.       <servlet-class>com.woniuxy.demo.ServletDemo3</servlet-class>
    4.       <!-- 配置初始化参数 -->
    5.       <init-param>
    6.           <param-name>age</param-name>
    7.           <param-value>18</param-value>
    8.       </init-param>
    9.   </servlet>

  • 在Servlet中获取ServletConfig对象的两种方式

    • 方式1：通过init方法获取ServletConfig对象

      1. public class ServletDemo extends HttpServlet{
      2. //声明一个全局的ServletConfig对象
      3. private ServletConfig config;
      4. public void init(ServletConfig config){
      5.    this.config = config;
      6. }  
      8. public void doPost(HttpServletRequest request,HttpServletResponse response) throws Exception{
      9.    String age = config.getInitParameter("age");
      10.    System.out.println(age);
      11. }
      12. }

    • 方式2：由Servlet对象直接获取

      1. public class ServletDemo extends HttpServlet{
      2. //推荐使用
      3. public void doPost(HttpServletRequest request,HttpServletResponse response) throws Exception{
      4.    //通过Servlet对象获取ServletConfig对象
      5.    ServletConfig config = this.getServletConfig();
      6.    String age = config.getInitParameter("age");
      7.    System.out.println(age);
      8. }
      9. }

  • 练习：在web.xml配置文件中配置上数据库链接信息，当发送请求的时候，直接获取四个参数

    • 配置参数

      1. <!-- 配置ServletDemo4 -->
      2. <servlet>
      3.    <servlet-name>ServletDemo4</servlet-name>
      4.    <servlet-class>com.woniuxy.demo.ServletDemo4</servlet-class>
      5.    <!-- 配置参数 -->
      6.    <init-param>
      7.        <param-name>driver</param-name>
      8.        <param-value>com.mysql.jdbc.Driver</param-value>
      9.    </init-param>
      10.    <init-param>
      11.        <param-name>url</param-name>
      12.        <param-value>jdbc:mysql://localhost:3306/shop?useUnicode=true&amp;characterEncoding=utf-8</param-value>
      13.    </init-param>
      14.    <init-param>
      15.        <param-name>username</param-name>
      16.        <param-value>root</param-value>
      17.    </init-param>
      18.    <init-param>
      19.        <param-name>password</param-name>
      20.        <param-value>root</param-value>
      21.    </init-param>
      22. </servlet>
      23. <servlet-mapping>
      24.    <servlet-name>ServletDemo4</servlet-name>
      25.    <url-pattern>/demo4</url-pattern>
      26. </servlet-mapping>

    • java代码

      1. @Override
      2. protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      3.    //获取ServletConfig
      4.    ServletConfig config = this.getServletConfig();
      5.    String driver = config.getInitParameter("driver");
      6.    String url = config.getInitParameter("url");
      7.    String username = config.getInitParameter("username");
      8.    String password = config.getInitParameter("password");
      9. }

      问题：当参数过多的时候，再去一个一个的根据名称获取值比较麻烦，可以一次性获取所有的参数。

      1. @Override
      2. protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      4.    //获取ServletConfig
      5.    ServletConfig config = this.getServletConfig();
      6.    //获取所有的参数名集合
      7.    Enumeration<String> e = config.getInitParameterNames();
      8.    //迭代集合
      9.    while(e.hasMoreElements()) {
      10.        String name = e.nextElement();
      11.        //根据名称获取所有的值
      12.        config.getInitParameter(name);
      13.    }
      14. }

      4.2 ServletContext对象(非常重要)

  • 一个web容器里面，只有一个ServletContext对象，获取ServletContext对象有两种方式

    • 方式1：通过ServletConfig对象中的getServeltContext()方法来获取ServletContext对象

ServletContext context = this.getServletConfig().getServletContext();

  • 方式2：可以直接通过Servlet对象中的getServletContext()方法来获取ServletConext对象，推荐方式。

ServletContext context = this.getServletContext();

  • Servlet的第一个作用：实现各个Servlet类中的数据共享。

    1. @Override
    2.   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    3.       System.out.println("请求到了Demo5");
    4.       //获取ServletContext对象
    5.       ServletContext context = this.getServletContext();
    6.       //向context对象中获取值
    7.       context.setAttribute("msg", "哈哈哈哈，我是从demo5过来的，惊喜吧");
    8.   }
    1. @Override
    2.   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    3.       //获取ServletConext对象
    4.       ServletContext context = this.getServletContext();
    5.       //获取值
    6.       String msg = (String)context.getAttribute("msg");
    7.       System.out.println("msg = "+msg);
    8.   }

  • 获取全局的配置文件值

    1. <context-param>
    2.       <param-name>age</param-name>
    3.       <param-value>18</param-value>
    4.   </context-param>
    1. @Override
    2.   public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
    3.       //获取ServletContext对象
    4.       ServletContext context = this.getServletContext();
    5.       //获取全局的配置文件参数值
    6.       String age = context.getInitParameter("age");
    7.       System.out.println("demo1的age = "+age);
    8.   }
    1. @Override
    2.   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    3.       //获取ServletContext对象
    4.       ServletContext context = this.getServletContext();
    5.       //获取参数值
    6.       String age = context.getInitParameter("age");
    7.       System.out.println("demo2的age = "+age);
    8.   }

  • 读取配置文件

使用Servlet读取工程配置文件（properties文件和XML文件），因为项目最终是在tomcat服务器里面执行的，工程运行只识别webapps里面的工程目录，而在这个目录里面根本没有src目录，原先的获取文件的路径不能使用。

  • 方式1：直接使用ServletContext里面的getReasourceAsStream()方法获取到输入流对象 ```java @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //读取到db.properties配置文件 //获取ServletContext对象 ServletContext context = this.getServletContext(); //根据context对象获取输入流 InputStream in = context.getResourceAsStream(“/WEB-INF/classes/db.properties”); //创建Properties对象 Properties prop = new Properties(); prop.load(in);

    String driver = prop.getProperty(“driver”); String url = prop.getProperty(“url”); String username = prop.getProperty(“username”); String password = prop.getProperty(“password”);

    System.out.println(“驱动：”+driver+”,请求路径：”+url+”,用户名：”+username+”,密码：”+password); }

}

  2.    - 方式2：通过ServletContext中的getRealPath()方法获得绝对路径，有了绝对路径可以再使用FileInputStream类
  3. ```java
  4. @Override
  5.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  6.         //获取ServletContext对象
  7.         ServletContext context = this.getServletContext();
  8.         //根据虚拟路径获取绝对路径
  9.         String realPath = context.getRealPath("/WEB-INF/classes/db.properties");
  10.         //创建输入流对象
  11.         FileInputStream in = new FileInputStream(new File(realPath));
  13.         Properties prop = new Properties();
  14.         prop.load(in);
  16.         String driver = prop.getProperty("driver");
  17.         String url = prop.getProperty("url");
  18.         String username = prop.getProperty("username");
  19.         String password = prop.getProperty("password");
  21.         System.out.println("驱动："+driver+",请求路径："+url+",用户名："+username+",密码："+password);
  22.     }

  • 方式3：将配置文件的位置放在webContent的目录下，要读取webContent目录下的配置文件

    1. @Override
    2. protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    3.    //获取ServletContext对象
    4.    ServletContext context = this.getServletContext();
    5.    InputStream in = context.getResourceAsStream("db.properties");
    7.    Properties prop = new Properties();
    8.    prop.load(in);
    10.    String driver = prop.getProperty("driver");
    11.    String url = prop.getProperty("url");
    12.    String username = prop.getProperty("username");
    13.    String password = prop.getProperty("password");
    15.    System.out.println("驱动："+driver+",请求路径："+url+",用户名："+username+",密码："+password);
    16. }

    4.3 Response对象

  • 当服务器接收到了请求之后，会执行doPost或者doGet方法，执行完之后会给浏览器反馈数据，完成反馈数据的对象就是response，该对象不需要程序员自己创建。

  • 常用的方法

    1. addCookie(Cookie cook)  添加一个cookie对象，后续会话管理的地方讲解
    2. addHeader(String headerName,String value)  添加一个响应头以及对应的数据
    3. sendRedirect(String location)  用response对象实现重定向
    4. setHeader(String headName,String value)  设置一个响应头及对应的数据
    5. setStatus(int sc)  设置状态码，一般不需要程序员设置，服务器会根据响应的状态返回状态码
    6. getWriter()  通过response对象获取字符输出流
    7. getOutputStream()  通过response对象获取字节输出流

  • 示例代码1：getOutputStream(),并解决乱码的问题

    1. @Override
    2.   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    3.       //设置response对象里面的编码集
    4.       resp.setCharacterEncoding("utf-8");
    5.       resp.setHeader("Content-type", "text/html;charset=utf-8");
    6.       //获取字节输出流对象
    7.       OutputStream out = resp.getOutputStream();
    9.       out.write("你追我，嘿嘿嘿，我不同意".getBytes("UTF-8"));
    10.   }

  • 示例代码2：getWriter()方法

    1. @Override
    2.   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    3.       //设置编码集
    4.       resp.setCharacterEncoding("UTF-8");
    5.       resp.setHeader("Content-type", "text/html;charset=utf-8");
    7.       //获取字符输出流
    8.       Writer out = resp.getWriter();
    9.       out.write("你好，哈哈哈哈哈，中午了，肚子饿");
    10.   }

  • 使用response对象实现重定向，当浏览器向服务器发送一个请求之后，通过doGet或者doPost方法，实现页面之间的跳转

    1. //前端代码，要求，当点击超链接之后，能够正常的执行到Servlet的代码
    2. <div id="reg">
    3.       <a href = "/WebDemo3">注册></a>
    4. </div>
    1. @Override
    2.   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    3.       System.out.println("执行到了demo3");
    5.       //经过服务器之后，再实现页面的跳转
    6.       resp.sendRedirect("/WebDemo3/page/register.html");
    7.   }

    注意：response对象可以调用sendRedirect方法实现页面之间的跳转，而且是经过服务器之后实现跳转，但是不推荐使用，对于服务器底层来说，重定向会给服务器实际发送两次请求，重定向只能单纯的实现页面跳转，不能携带数据

    4.4 request对象（重点）

  • 当浏览器向服务器发送请求之后，服务器会接受到来自浏览器的数据（用户填写的数据、请求头数据和请求的数据），request是完成前端数据交给服务器的对象

  • request常用的方法

    1. *1、getCookies();   获取Cookie对象的数组，后续会有专门的课程讲解会话管理
    2. 2、getHeader(String name);   获取请求头的相关数据
    3. 3、getMethod();   获取请求方式（一般包括get请求或者post请求）
    4. 4、getReuqestURI();   获取请求的资源路径
    5. 5、getRequestURL();    获取请求路径（包含详细的ip地址和端口号）
    6. *6、getSession();    获取一个Session对象，后续专门用会话管理的地方讲解
    7. *7、getAttribute(String name);  获取request里面存储的数据
    8. *8、setAttribute(String name,Object obj);向request域中添加一个键值对。
    9. 9、removeAttribute(String name);移除一个元素值
    10. *10、setCharacterEncoding(String name);  设置编码集
    11. 11、getLocalAddr() ;获取ip地址
    12. 12、getLocalName();获取主机名
    13. 13、getLocalPort() ;获取端口
    14. *14、getParameter(String name);获取前端传送过来的数据
    15. *15、getParameterNames();获取前端传送过来的数据名称
    16. *16、getRequestDispatcher();实现请求转发

  • 作为了解的方法 ```java @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    1.   //根据指定头名称获取响应的数据
    2.   String headValue = request.getHeader("Accept");
    3.   System.out.println("请求头："+headValue);
    5.   //获取请求方法
    6.   String method = request.getMethod();
    7.   System.out.println("请求方式："+method);
    9.   //获取当次请求的资源路径
    10.   String uri = request.getRequestURI();
    11.   System.out.println("uri = "+uri);
    13.   //获取当次的请求路径
    14.   StringBuffer url = request.getRequestURL();
    15.   System.out.println("url = "+url);
    17.   //获取请求ip地址
    18.   String ip = request.getLocalAddr();
    19.   System.out.println("ip = "+ip);
    21.   //获取当次请求的主机名
    22.   String hostName = request.getLocalName();
    23.   System.out.println("主机名："+hostName);
    25.   //获取该次请求的端口
    26.   int port = request.getLocalPort();
    27.   System.out.println("端口:"+port);

    }

}

  2. - request里面的请求转发
  3. ```java
  4. //实现Servlet类之间的请求转发
  5. /*
  6.     前端请求到RquestDemo2里面的doPost()方法，在这个方法里面不做处理，想要调用RequestDemo3里面的doPost()方法做处理
  7. */
  9. @Override
  10.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  11.         System.out.println("已经成功请求到了demo2");
  12.         //向request域里面存入键值对
  13.         request.setAttribute("name", "张三");
  15.         //将方法切换到Demo3里面去执行
  16.         //实现请求转发
  17.         RequestDispatcher rd = request.getRequestDispatcher("/demo6");
  18.         //需要转发
  19.         rd.forward(request, response);
  20.     }
  22. @Override
  23.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  24.         System.out.println("已经成功请求到了demo3");
  26.         //获取值
  27.         String name = (String)request.getAttribute("name");
  28.         System.out.println("来自于demo2的name:"+name);
  30.     }
  32. //setAttribute()和getAttribute();
  33. setAttribute()方法是向request域里面存入一个键值对
  34. getAttribute()方法是根据名称获取到request域里面对应的值。

  • request对象实现页面的请求转发

    1. @Override
    2.   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    3.       System.out.println("请求成功");
    5.       //实现页面的转发
    6.       RequestDispatcher rd = request.getRequestDispatcher("/page/login.html");
    7.       rd.forward(request, response);
    9.   }

  • 后端获取前端发送过来的数据 ```html @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    1.   //设置编码集
    2.   req.setCharacterEncoding("UTF-8");
    3.   resp.setCharacterEncoding("UTF-8");
    4.   resp.setHeader("Content-type", "text/html;charset=utf-8");
    5.   //获取前端的参数，使用方法：getParameter(String name);

// String userName = req.getParameter(“userName”); // String password = req.getParameter(“password”); // System.out.println(“用户名：”+userName+”,密码：”+password);

  1.     String comment = req.getParameter("comment");
  2.     System.out.println("他说："+comment);
  3. }
  2. - jsp页面（简单版本）
  3. ```java
  4. public class LoginServlet extends HttpServlet{
  6.     @Override
  7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  8.         doPost(req, resp);
  9.     }
  11.     @Override
  12.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  13.         //设置编码集
  14.         request.setCharacterEncoding("UTF-8");
  15.         response.setCharacterEncoding("UTF-8");
  16.         response.setHeader("Content-type", "text/html;charset=utf-8");
  18.         //获取参数
  19. //        String userName = request.getParameter("userName");
  20. //        String password = request.getParameter("password");
  21.         String userName = "root";
  22.         String password = "admin";
  24.         //判断密码和用户名是否正确
  25.         if(userName.equals("root") && password.equals("admin")) {
  26.             //将一个String类型的数据发送给前端
  27.             String str = "我终于登录成功了";
  28.             //将数据存入request域中
  29.             request.setAttribute("str", str);
  31.             User u1 = new User();
  32.             u1.setName("张三");
  33.             u1.setAge(19);
  34.             u1.setAddress("重庆");
  36.             //将整个对象存入request域中
  37.             request.setAttribute("user", u1);
  39.             User u2 = new User();
  40.             u2.setName("李四");
  41.             u2.setAge(22);
  42.             u2.setAddress("成都");
  44.             User u3 = new User();
  45.             u3.setName("王五");
  46.             u3.setAge(30);
  47.             u3.setAddress("北京");
  49.             List<User> list = new ArrayList<>();
  50.             list.add(u1);
  51.             list.add(u2);
  52.             list.add(u3);
  54.             //将集合存入request域中
  55.             request.setAttribute("list", list);
  57.             //跳转到成功页面
  58.             RequestDispatcher rd = request.getRequestDispatcher("/jsp/success.jsp");
  59.             rd.forward(request, response);
  60.         }else {
  61.             //跳转到失败的页面
  62.             RequestDispatcher rd = request.getRequestDispatcher("/jsp/error.jsp");
  63.             rd.forward(request, response);
  64.         }
  65.     }
  67. }
  • 前端jsp获取数据 ```html <%@ page language=”java” contentType=”text/html; charset=UTF-8” pageEncoding=”UTF-8”%> <%@ taglib uri=”http://java.sun.com/jsp/jstl/core“ prefix=”c”%> <!DOCTYPE html> 恭喜你，登录成功
    字符串的值：${str }

    获取对象里面的值：
    ${user.name } ${user.age } ${user.address }

    获取集合中的数据 ${list.get(0).name }

    遍历集合
    姓名 年龄 地址
    ${user.name } ${user.age } ${user.address } 

  1. <a name="ouIX4"></a>
  2. # 作业步骤

1、创建web工程，并且将服务器的servlet依赖加入（build path—->服务器的jar包） 2、导入依赖jar包（mybatis核心包和依赖包，jdbc链接包、el表达式依赖包） 3、在WEB-INF目录下新建web.xml配置文件，dtd约束去服务器里面的web.xml拷贝 4、目录结构和包的创建，目录主要放在webContent目录下，存放前端的静态页面，包用于存放java代码 5、编写前端，简单编写一个form表单，可以提交数据即可 6、编写Servlet，并在web.xml配置文件中配置映射，配置好映射之后，先去前端的form表单中添加action请求路径 7、定义一个User用户失血模型 8、在Servlet里面，编写获取数据的内容，getParameter(String name);并将获取的值存入一个user对象中 9、编写mybatis框架的SqlMapConfig.xml配置文件，并编写db.properties配置文件，在SqlMapConfig配置文件中加载 10、编写Mapper的接口 11、根据接口编写mapper.xml配置文件，要在SqlMapConfig.xml文件里面加载 12、编写Dao的实现类 13、编写业务逻辑层，包括接口和实现类

  2. - 前端代码
  3. ```html
  4. <%@ page language="java" contentType="text/html; charset=UTF-8"
  5.     pageEncoding="UTF-8"%>
  6. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  7. <!DOCTYPE html>
  8. <html>
  9. <head>
  10. <meta charset="UTF-8">
  11. <title>登录</title>
  12. </head>
  13. <body>
  14.     <form action="/WebDemo4/login" method = "post">
  15.         电话号码：<input type = "text" id = "tel" name = "tel"><br />
  16.         密码：<input type = "password" id = "password" name = "password"><br />
  17.         <input type = "submit" value = "提交">
  18.     </form>
  19. </body>
  20. </html>

  • 用户失血模型

    1. /**
    2. * 
    3. * <p>Title: User</p> 
    4. * <p>Description: 用户的失血模型</p> 
    5. * @author Alon
    6. * @date 2020年10月23日 上午10:01:27
    7. * @version 1.0
    8. */
    9. public class User {
    10.   private String tel;
    11.   private String password;
    12.   public String getTel() {
    13.       return tel;
    14.   }
    15.   public void setTel(String tel) {
    16.       this.tel = tel;
    17.   }
    18.   public String getPassword() {
    19.       return password;
    20.   }
    21.   public void setPassword(String password) {
    22.       this.password = password;
    23.   }
    24. }

  • Servlet类

    1. /**
    2. * 
    3. * <p>Title: LoginServlet</p> 
    4. * <p>Description: 登录的Servlet</p> 
    5. * @author Alon
    6. * @date 2020年10月23日 上午9:56:31
    7. * @version 1.0
    8. */
    9. public class LoginServlet extends HttpServlet{
    11.   @Override
    12.   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    13.       doPost(req, resp);
    14.   }
    16.   @Override
    17.   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    18.       //设置编码集
    19.       request.setCharacterEncoding("UTF-8");
    20.       response.setCharacterEncoding("UTF-8");
    21.       response.setHeader("Content-type", "text/html;charset=utf-8");
    23.       //获取参数
    24.       String tel = request.getParameter("tel");
    25.       String password = request.getParameter("password");
    27.       //创建User对象
    28.       User user = new User();
    29.       user.setTel(tel);
    30.       user.setPassword(password);
    32.       System.out.println("电话："+tel+",密码："+password);
    34.       //调用Service层的方法
    35.       UserService userService = new UserServiceImpl();
    37.       boolean flag = userService.userLogin(user);
    39.       if(flag) {
    40.           request.getRequestDispatcher("/page/success.jsp").forward(request, response);
    41.       }else {
    42.           request.getRequestDispatcher("/page/fail.jsp").forward(request, response);
    43.       }
    45.   }
    46. }

  • web.xml配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app version="3.1" 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">
    3.   <servlet>
    4.       <servlet-name>LoginServlet</servlet-name>
    5.       <servlet-class>com.woniuxy.servlet.LoginServlet</servlet-class>
    6.   </servlet>
    7.   <servlet-mapping>
    8.       <servlet-name>LoginServlet</servlet-name>
    9.       <url-pattern>/login</url-pattern>
    10.   </servlet-mapping>
    11. </web-app>

  • mybatis的SqlMapConfig.xml配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE configuration
    3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.    <!-- 加载properties配置文件 -->
    7.    <properties resource="db.properties"></properties>
    9.    <!-- 配置别名 -->
    10.    <typeAliases>
    11.        <package name="com.woniuxy.model"/>
    12.    </typeAliases>
    13.    <!-- 可以配置多条数据源和事务管理的标签:当前使用，以后使用了spring整合之后，不再需要 -->
    14.    <environments default="development">
    15.        <!-- 配置单条的数据源和事务管理的标签 -->
    16.        <environment id="development">
    17.            <!-- 事务管理，暂时全部交给mybatis进行管理事务 -->
    18.            <transactionManager type="JDBC" />
    19.            <!-- 配置数据源 -->
    20.            <dataSource type="POOLED">
    21.                <!-- 配置数据库的驱动 -->
    22.                <property name="driver" value="${driver}"/>
    23.                <!-- 配置数据库的链接，里面就绑定好了数据库名 -->
    24.                <property name="url" value="${url}"/>
    25.                <!-- 配置数据库的用户名 -->
    26.                <property name="username" value="${username}"/>
    27.                <!-- 配置数据库的密码 -->
    28.                <property name="password" value="${password}"/>
    29.            </dataSource>
    30.        </environment>
    31.    </environments>
    32. </configuration>

  • 数据源信息的db,properties配置文件

    1. driver=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/db_test?useUnicode=true&characterEncoding=utf-8
    3. username=root
    4. password=

  • UserMapper接口

    1. /**
    2. * 
    3. * <p>Title: UserMapper</p> 
    4. * <p>Description: 用户的Mapper接口</p> 
    5. * @author Alon
    6. * @date 2020年10月23日 上午10:39:54
    7. * @version 1.0
    8. */
    9. public interface UserMapper {
    10.   /**
    11.    * 
    12.    *<p>Title: queryUserByTel</p> 
    13.    *<p>Description:根据电话号码查询用户 </p> 
    14.    * @param tel
    15.    * @return
    16.    * @throws Exception
    17.    */
    18.   public User queryUserByTel(String tel) throws Exception;
    19. }

  • userMapper.xml配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper
    3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <!-- 配置mapper -->
    6. <mapper namespace="com.woniuxy.mapper.UserMapper">
    7.   <!-- 编写查询语句 -->
    8.   <select id="queryUserByTel" parameterType="java.lang.String" resultType="User">
    9.       SELECT tel,`password` FROM t_user WHERE tel = #{tel};
    10.   </select>
    11. </mapper>

  • UserDao的实现类

    1. /**
    2. * 
    3. * <p>Title: UserDao</p> 
    4. * <p>Description: 用户Dao的实现类</p> 
    5. * @author Alon
    6. * @date 2020年10月23日 上午10:47:55
    7. * @version 1.0
    8. */
    9. public class UserDao implements UserMapper{
    10.   //声明会话工厂
    11.   private SqlSessionFactory factory;
    12.   //在构造方法里面初始化
    13.   public UserDao() {
    14.       try {
    15.           //获取配置文件
    16.           String path = "SqlMapConfig.xml";
    17.           InputStream config = Resources.getResourceAsStream(path);
    18.           factory = new SqlSessionFactoryBuilder().build(config);
    19.       } catch (Exception e) {
    20.           e.printStackTrace();
    21.       }
    22.   }
    23.   @Override
    24.   public User queryUserByTel(String tel) throws Exception {
    25.       //开启会话
    26.       SqlSession session = factory.openSession();
    27.       //获取mapper对象
    28.       UserMapper mapper = session.getMapper(UserMapper.class);
    29.       //调用方法
    30.       User user = mapper.queryUserByTel(tel);
    31.       return user;
    32.   }
    33. }

  • UserService接口

    1. /**
    2. * 
    3. * <p>Title: UserService</p> 
    4. * <p>Description: 用户的业务层接口</p> 
    5. * @author Alon
    6. * @date 2020年10月23日 上午10:51:49
    7. * @version 1.0
    8. */
    9. public interface UserService {
    10.   /**
    11.    * 
    12.    *<p>Title: userLogin</p> 
    13.    *<p>Description: 用户登录</p> 
    14.    * @param user
    15.    * @return
    16.    * @throws Exception
    17.    */
    18.   public boolean userLogin(User user) throws Exception;
    19. }

  • UserServieImpl实现类 ```java /**

    • Title: UserServiceImpl

    • Description: 用户业务层实现类

    • @author Alon
    • @date 2020年10月23日 上午10:55:26

    • @version 1.0 */ public class UserServiceImpl implements UserService {

      @Override public boolean userLogin(User user) throws Exception {

      1. //创建Dao的对象
      2. UserMapper userDao = new UserDao();
      3. //获取传递过来的电话和密码
      4. String tel = user.getTel();
      5. String password = user.getPassword();
      7. User u = userDao.queryUserByTel(tel);
      9. //比较
      10. if(password.equals(u.getPassword())) {
      11.     return true;
      12. }
      13. return false;

      }

} ```