web学习(一)

于 2021-04-04 17:13:37 发布
阅读量139 收藏
点赞数
分类专栏： Java 文章标签： java servlet tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53529114/article/details/115430749
版权
本文详细介绍了JavaEE中的Web开发基础知识，包括Web服务器软件如Tomcat的下载、安装、配置及项目部署。讲解了Servlet的概念、生命周期、执行原理以及相关配置。还探讨了HTTP协议的基本概念、请求消息数据格式和请求响应过程。此外，通过实例展示了如何使用Servlet处理请求，获取请求头、请求参数等数据，并实现请求转发。最后，通过用户登录案例展示了实际开发中的应用。
摘要由CSDN通过智能技术生成

web学习(一)

1.web概念

1.1 web相关概念回顾

  1. 软件架构：
    1. C/S：客户端/服务器端
    2. B/S：浏览器/服务器端
  2. 资源分类：
    1. 静态资源：所有用户访问后，得到的结果都是一样的，称为静态资源。静态资源可以直接被浏览器解析
      1. 如：html，css，JavaScript
    2. 动态资源：每个用户访问后，得到的结果可能不一样，称为动态资源。动态资源被访问后，需先将动态资源转为静态资源，再返回给浏览器
      1. 如：servlet/jsp，php，asp…
  3. 网络通信三要素：
    1. IP：电子设备（计算机）在网络中的唯一标识
    2. 端口：应用程序在计算机中的唯一标识。0-65536
    3. 传输协议：规定了数据传输规则
      1. 基础协议：
        1. tcp：安全协议，三次握手。速度稍慢
        2. udp：不安全协议。速度快

1.2 服务器软件

服务器：安装了服务器软件的计算机

服务器软件：接收用户的请求，处理请求，做出响应

web服务器软件：接收用户的请求，处理请求，做出响应

  1. 在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目
  2. web容器

常见的java相关的web服务器：

  1. webLogic：Oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的
  2. webSphere：IBM公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的
  3. JBOSS：JBOSS公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的
  4. Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范servlet/jsp。开源的，免费的

JavaEE：Java语言在企业级开发中使用的技术规范的总和，一共规定了13项大的规范

2.Tomcat

Tomcat：web服务器软件

  1. 下载：Apache官网下载
  2. 安装：解压压缩包即可
    1. 注意：安装的目录不要有中文和空格
  3. 卸载：删除目录
  4. 启动
    1. bin/startup.bat，双击运行该文件即可
      1. 注意：jdk环境变量需要配置成%JAVA_HOME%的形式，否则双击闪退（我的JDK配置的全路径就闪退，重新配置成%JAVA_HOME%完美解决）
    2. 访问：浏览器输入：http://localhost:8080回车访问自己
    3. 可能遇到的问题：
      1. 黑窗口一闪而过：
        1. 原因：没有正确配置JAVA_HOME环境变量
        2. 解决方法：正确配置JAVA_HOME
      2. 启动报错：
        1. 暴力：找到被占用的端口号，并且找到对应的进程，杀死该进程。cmd查看指令：netstat -ano
        2. 温柔：修改自身的端口号
          1. conf/server.xml
          2. <Connector port=“8080” protocol=“HTTP/1.1”
            connectionTimeout=“20000”
            redirectPort=“8443” />
          3. 一般会将tomcat默认端口号修改为80。80端口号是http协议的默认端口号
            1. 好处：在访问时，可以不用输入端口号
  5. 关闭：
    1. 正常关闭：
      1. bin/shutdown.bat
      2. ctrl+c
    2. 强制关闭：
      1. 点击启动窗口的X
  6. 配置：
    1. 部署项目的方式：
      1. 直接将项目放到webapps目录下即可
        1. /hello：项目的访问路径–>虚拟目录
        2. 简化部署：将项目打成一个war包，再将war包放在webapps目录下
          1. war包会自动解压缩
      2. 配置conf/sever.xml文件
        1. 在<Host>标签体中配置
        2. <Context docBase=“E:\Date\Javaweb\web\hello” path="/hello" />
        3. docBase：项目存放的路径
        4. path：虚拟路径
      3. 在\conf\Catalina\localhost创建任意名称的xml文件。在文件中编写
        1. <Context docBase=“E:\Date\Javaweb\web\hello” />
        2. 虚拟目录：xml文件的名称
    2. 静态项目和动态项目：
      1. 目录结构：
        1. Java动态项目的目录结构：
          1. 项目的根目录：
            1. WEB-INF目录：
              1. web.xml：项目的核心配置文件
              2. classes目录：放置字节码文件的目录
              3. lib目录：放置依赖的jar包
    3. 将tomcat集成到idea中，并且创建JavaEE项目，部署项目

3.Servlet入门

3.1 概念

概念：运行在服务器的小程序

Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容。

狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。

最早支持Servlet标准的是JavaSoft的Java [Web Server](https://baike.baidu.com/item/Web Server/9306055)，此后，一些其它的基于Java的Web服务器开始支持标准的Servlet

servlet就是一个接口，定义了Java类被浏览器访问到（tomcat识别）的规则

将来我们自定义一个类，实现servlet接口，复写方法

3.2 快速入门

  1. 创建JavaEE项目

  2. 定义一个类，实现Servlet接口

    1. public class ServletDemo01 implements Servlet {}

  3. 实现接口中的抽象方法

  4. 配置servlet

    1. 在web.xml中配置

    2. <!--配置Servlet-->
<servlet>
    <servlet-name>demo01</servlet-name>
    <servlet-class>cn.web.servlet.ServletDemo01</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>demo01</servlet-name>
    <url-pattern>/demo01</url-pattern>
</servlet-mapping>

3.3 执行原理

  1. 当服务器接收到浏览器的请求后，会解析请求URL路径，获取访问Servlet的资源路径

  2. 查找web.xml文件，是否有对应的<url-pattern>标签体内容

  3. 如果有，则再找到对应的<servlet-class>全类名

  4. tomcat会将字节码文件加载进内存，并且创建其对象

  5. 调用其方法

3.4 生命周期

  1. 被创建：执行init方法，只执行一次

    1. Servlet什么时候被创建？

      1. 默认情况下，第一次被访问时，Servlet被创建

      2. 可以配置创建Servlet的创建时机

        1. 在<servlet>标签下配置

        2. <!--指定Servlet的创建时机
    1.第一次被访问时，创建
        <load-on-startup>的值为负数
    2.在服务器启动时，创建
        <load-on-startup>的值为0或正整数
-->

    2. servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的

      1. 多个用户同时访问时，可能存在线程安全问题
      2. 解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对其修改

  2. 提供服务：执行service方法，执行多次

    1. 每次访问Servlet时，service方法都会被调用一次

  3. 被销毁：之心destroy方法，执行一次

    1. Servlet被销毁时执行。服务关闭时，Servlet被销毁
    2. 只有服务器正常关闭时，才会执行的destroy方法
    3. destroy方法在Servlet关闭之前执行，一般用于释放资源

3.5 Servlet3.0

优点：支持注解配置。可以不需要web.xml了

步骤：

  1. 创建JavaEE项目，选择Servlet版本3.0以上，可以不创建web.xml
  2. 定义一个类，实现Servlet接口
  3. 复写方法
  4. 在类上使用@WebServlet注解，进行配置
    1. @WebServlet(“资源路径”)
package cn.web.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

@WebServlet("/demo2")
public class ServletDemo implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {}

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("Servlet来了...");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {}
}

3.6 Servlet体系结构

Servlet – 接口

GenericServlet – 抽象类

HttpServlet – 抽象类

GenericServlet：将Servlet接口中其他方法做了默认空实现，只有service()方法作为抽象

  1. 将来定义Servlet类时，可以继承GenericServlet，实现service()方法即可

  2. package cn.web.servlet;

import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

@WebServlet("/demo3")
public class ServletDemo03 extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("dome3");
    }
}

HttpServlet：对http协议的一种封装，简化操作

  1. 定义类继承HttpServlet

  2. 复写doGet/doPost

  3. package cn.web.servlet;

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

@WebServlet("/demo4")
public class ServletDemo04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doGet....");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doPost....");
    }
}

3.7 Servlet相关配置

  1. urlpartten：servlet访问路径
    1. 一个Servlet可以定义多个访问路径：@WebServlet({"/d5","/dd5","/ddd5"})
    2. 路径定义规则：
      1. /xxx
      2. /xxx/xxx：多层路径，目录结构
      3. *.do

​

package cn.web.servlet;

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

/**
 * Servlet路径配置
 */
//@WebServlet({"/d5","/dd5","/ddd5"})
//@WebServlet("/user/demo5")
//@WebServlet("/user/*")
//@WebServlet("/*")
@WebServlet("*.do")
public class ServletDemo05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("demo5...");
    }
}

4.IDEA与Tomcat相关配置

4.1 内容

  1. IDEA会为每一个tomcat部署的项目单独建立一份配置文件
    1. 查看控制台的log：Using CATALINA_BASE: “C:\Users\11712\.IntelliJIdea2019.3\system\tomcat_JavaEE”
  2. 工作空间项目 和 tomcat部署的web项目
    1. tomcat真正访问的是“tomcat部署的web项目”，“tomcat部署的web项目”对应着“工作空间项目”的web目录下的所有资源
    2. WEB-INF目录下的资源不能被浏览器直接访问
  3. 断点调试：使用“小虫子”启动 debug 启动

5.HTTP

5.1 概念

概念：Hyper Text Transfer Protocol 超文本传输协议

  1. 传输协议：定义了，客户端和服务器端通信时，发送数据的格式
  2. 特点：
    1. 基于TCP/IP的高级协议
    2. 默认端口号：80
    3. 基于请求/响应模型：一次请求对应一次响应
    4. 无状态的：每次请求之间相互独立，不能交互数据
  3. 历史版本：
    1. 1.0：每一次请求响应都会建立一个新的连接
    2. 1.1：复用连接

5.2 请求消息数据格式

  1. 请求行

    1. 请求方式 请求rul 请求协议/版本

    2. GET /servlet/login.html HTTP/1.1

    3. 请求方式：

      1. HTTP协议中有7中请求方式，常用有两种
      2. GET：
        1. 请求参数在请求行中，在url后
        2. 请求的url长度有限制
        3. 不太安全
      3. POST：
        1. 请求参数在请求体中
        2. 请求url长度没有限制
        3. 相对安全

  2. 请求头：客户端浏览器告诉服务器一些信息

    1. 请求头名称：请求头值

    2. 常见的请求头：

      1. User-Agent: 浏览器告诉服务器，我访问你使用的浏览器版本信息

        可以在服务器端获取该头的信息，解决浏览器的兼容性问题

      2. Referer: http://localhost/servlet/login.html

        告诉服务器，我（当前请求）从哪里来？

        作用：

        1. 防盗链
        2. 统计工作

  3. 请求空行

    1. 空行：用于分割POST请求的请求头和请求体的

  4. 请求体（正文）

    封装POST请求消息的请求参数的

字符串格式：

Chrome浏览器：

GET /servlet/login.html HTTP/1.1

Host: localhost

Connection: keep-alive

Upgrade-Insecure-Requests: 1

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9

Referer: http://localhost/servlet/login.html

Accept-Encoding: gzip, deflate, br

Accept-Language: zh-CN,zh;q=0.9,zh-TW;q=0.8,en-US;q=0.7,en;q=0.6

Edge浏览器：GET /servlet/login.html HTTP/1.1

POST /servlet/demo4 HTTP/1.1

Host: localhost

Connection: keep-alive Content-Length: 17 Cache-Control: max-age=0

Upgrade-Insecure-Requests: 1 Origin: http://localhost Content-Type: application/x-www-form-urlencoded

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.63

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9 Sec-Fetch-Site: same-origin Sec-Fetch-Mode: navigate Sec-Fetch-User: ?1 Sec-Fetch-Dest: document

Referer: http://localhost/servlet/login.html

Accept-Encoding: gzip, deflate, br

Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6

username=zhangsan

6.Request

6.1 请求响应过程

  1. 浏览器向服务器发送请求（请求消息）
  2. tomcat服务器会根据请求url中的资源路径，创建对应的ServletDemo1的对象
  3. tomcat服务器，会自动创建request和response对象。request对象中封装了请求消息数据
  4. tomcat将request对象和response对象传递给service方法，并且调用service方法
  5. 程序员（我们），可以通过request对象获取请求消息数据，可以通过response对象设置响应消息数据
  6. 服务器在给浏览器做出响应之前，会从response对象中拿程序员设置的响应消息数据

6.2 request对象和response对象

request对象和response对象是由服务器创建的，我们来使用它们

request对象是来获取请求消息

response对象是来设置响应消息

6.3 request对象结构体系

ServletRequest – 接口

| 继承

HttpServletRequest – 接口

| 实现

org.apache.catalina.connector.RequestFacade 类（tomcat）

6.4 request功能

获取请求消息数据：

  1. 获取请求行数据：

    1. GET /servlet/demo1？name=zhangsan HTTP/1.1

    2. 方法：

      1. 获取请求方式：GET

        String getMethod()

      2. ⭐️获取虚拟目录：/servlet

        String getContextPath()

      3. 获取Servlet路径：/demo1

        String getServletPath()

      4. 获取get方式请求参数：name=zhangsan

        String getQueryString()

      5. ⭐️获取请求URI：/servlet/demo1

        String getRequestURI() : /servlet/demo1

        StringBuffer getRequestURL() : http://localhost/servlet/demo1

        URL：统一资源定位符 ：http://localhost/servlet/demo1 中华人民共和国

        URI：统一资源标识符 ：/servlet/demo1 共和国

      6. 获取协议版本：HTTP/1.1

        String getProtocol()

      7. 获取客户机的IP地址：

        String getRemoteAddr()

    package cn.web.request;

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

/**
 * 演示Request对象获取请求行数据
 */
@WebServlet("/RequestDemo1")
public class RequestDemo1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
            1. 获取请求方式：GET
               String getMethod()
            2. 获取虚拟目录：/servlet
               String getContextPath()
            3. 获取Servlet路径：/RequestDemo1
               String getServletPath()
            4. 获取get方式请求参数：name=zhangsan
               String getQueryString()
            5. 获取请求URI：/servlet/RequestDemo1
               String getRequestURI() :     /servlet/RequestDemo1
               StringBuffer getRequestURL() : http://localhost/servlet/RequestDemo1
            6. 获取协议版本：HTTP/1.1
               String getProtocol()
            7. 获取客户机的IP地址：0:0:0:0:0:0:0:1
               String getRemoteAddr()
        */
        //1.获取请求方式
        String method = request.getMethod();
        System.out.println(method);//GET

        //2.获取虚拟目录
        String contextPath = request.getContextPath();
        System.out.println(contextPath);///servlet

        //3.获取Servlet路径
        String servletPath = request.getServletPath();
        System.out.println(servletPath);///RequestDemo1

        //4.获取get方式请求参数
        String queryString = request.getQueryString();
        System.out.println(queryString);//name=zhangsan

        //5.获取请求URI
        String requestURI = request.getRequestURI();
        System.out.println(requestURI);// /servlet/RequestDemo1
        StringBuffer requestURL = request.getRequestURL();
        System.out.println(requestURL);// http://localhost/servlet/RequestDemo1

        //6.获取协议版本
        String protocol = request.getProtocol();
        System.out.println(protocol);//HTTP/1.1

        //7.获取客户机的IP地址
        String remoteAddr = request.getRemoteAddr();
        System.out.println(remoteAddr);//0:0:0:0:0:0:0:1
    }
}

  2. 获取请求头数据

    方法：

    1. String getHeader(String name)：通过请求头的名称获取请求头的值
    2. Enumeration<String> getHeaderNames()：获取所有的请求头名称
    package cn.web.request;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

@WebServlet("/RequestDemo2")
public class RequestDemo2 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据
        //1.获取所有的请求头名称
        Enumeration<String> names = request.getHeaderNames();
        //2.遍历
        while (names.hasMoreElements()){
            String name = names.nextElement();
            //3.通过请求头的名称获取请求头的值
            String value = request.getHeader(name);
            System.out.println("name="+name+", value="+value);
        }
        //System.out.println(names);
    }
}

    package cn.web.request;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

@WebServlet("/RequestDemo3")
public class RequestDemo3 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:user-agent
        String agent = request.getHeader("user-agent");
        //判断agent浏览器版本
        if (agent.contains("Chrome")){
            //谷歌
            System.out.println("谷歌来了...");
        }else if(agent.contains("firefox")){
            //火狐
            System.out.println("火狐来了...");
        }
    }
}

    package cn.web.request;

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

@WebServlet("/RequestDemo4")
public class RequestDemo4 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:referer
        String referer = request.getHeader("referer");
        System.out.println(referer);//  http://localhost/servlet/login.html

        //防盗链
        if (referer != null){
            if (referer.contains("servlet")){
                //正常访问
//                System.out.println("播放电影");
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("播放电影...");
            }else {
                //盗链
//                System.out.println("想看电影吗？来爱奇艺吧...");
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("想看电影吗？来爱奇艺吧...");
            }
        }
    }
}

  3. 获取请求体数据

    请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求体中的请求参数

    步骤：

    1. 获取流对象

      BufferedReader getReader()：获取字符输入流，只能操作字符数据

      ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据

      1. 在文件上传知识点后讲解

    2. 再从流对象中拿数据

    package cn.web.request;

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

@WebServlet("/RequestDemo5")
public class RequestDemo5 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求消息体 -- 请求参数
        //1.获取字符流
        BufferedReader br = request.getReader();
        //2.读取数据
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }

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

    }
}

其他功能

  1. 获取请求参数通用方式：不论get还是post都可以使用下列方法获取请求参数

    1. String getParameter(String name)：根据参数名获取参数值 username=zs&password=123
    2. String[] getParameterValues(String name)：根据参数名获取参数值的数组 hobby=xx&hobby=game
    3. Enumeration<String> getParameterNames()：获取所有请求的参数名称
    4. Map<String,String[]> getParameterMap()：获取所有参数的map集合
    package cn.web.request;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;
import java.util.Set;

@WebServlet("/RequestDemo6")
public class RequestDemo6 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post 获取请求参数

        //根据参数名称获取参数值
//        String username = request.getParameter("username");
//        System.out.println("post");
//        System.out.println(username);

        //根据参数名称获取参数值的数组
//        String[] hobbies = request.getParameterValues("hobby");
//        for (String hobby : hobbies) {
//            System.out.println(hobby);
//        }

        //获取所有请求的参数名称
//        Enumeration<String> parameterNames = request.getParameterNames();
//        while (parameterNames.hasMoreElements()){
//            String name = parameterNames.nextElement();
//            System.out.println(name);
//            String value = request.getParameter(name);
//            System.out.println(value);
//            System.out.println("--------------------");
//        }

        //获取所有参数的map集合
        Map<String, String[]> parameterMap = request.getParameterMap();
        Set<String> keySet = parameterMap.keySet();
        for (String key : keySet) {
            String[] values = parameterMap.get(key);
            for (String value : values) {
                System.out.println(key+"----"+value);
            }
            System.out.println("========================");
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get 获取请求参数

        /*//根据参数名称获取参数值
        String username = request.getParameter("username");
        System.out.println("get");
        System.out.println(username);*/

        this.doPost(request,response);
    }
}

    中文乱码问题：

    1. get方式：tomcat 8 已经将get方式乱码问题解决了

    2. post方式：会乱码

      解决：在获取参数前，设置request的编码request.setCharacterEncoding(“utf-8”);

    package cn.web.request;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;
import java.util.Set;

@WebServlet("/RequestDemo7")
public class RequestDemo7 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.设置流编码格式
        request.setCharacterEncoding("utf-8");

        //获取请求参数username
        String username = request.getParameter("username");
        System.out.println(username);
    }

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

  2. 请求转发：一种在服务器内部的资源跳转方式

    步骤：

    1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
    2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

    特点：

    1. 浏览器地址栏路径不发生变化
    2. 只能转发到当前服务器内部资源中
    3. 转发是一次请求
    package cn.web.request;

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

@WebServlet("/RequestDemo8")
public class RequestDemo8 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo8被访问了.....");

//        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/RequestDemo9");
//        requestDispatcher.forward(request,response);
        request.getRequestDispatcher("/RequestDemo9").forward(request,response);
//        request.getRequestDispatcher("http://www.baidu.com").forward(request,response);//无法访问
    }

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

    package cn.web.request;

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

@WebServlet("/RequestDemo9")
public class RequestDemo9 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo9被访问了....");
    }

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

  3. 共享数据：

    域对象：一个有作用范围的对象，可以在范围内共享数据

    request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据

    方法：

    1. void setAttribute(String name,Object obj)：存储数据
    2. Object getAttribute(String name)：通过键获取值
    3. void removeAttribute(String name)：通过键移除键值对
    package cn.web.request;

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

@WebServlet("/RequestDemo8")
public class RequestDemo8 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo8被访问了.....");
        
        //存储数据到request域中
        request.setAttribute("msg","hello");

        request.getRequestDispatcher("/RequestDemo9").forward(request,response);
    }

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

    package cn.web.request;

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

@WebServlet("/RequestDemo9")
public class RequestDemo9 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo9被访问了....");

        //获取数据
        Object msg = request.getAttribute("msg");
        System.out.println(msg);
    }

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

  4. 获取ServletContext

    ServletContext getServletContext()

    package cn.web.request;

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

@WebServlet("/RequestDemo10")
public class RequestDemo10 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext servletContext = request.getServletContext();
        System.out.println(servletContext);
    }

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

6.5 案例：用户登录

用户登录案例需求：

  1. 编写login.html登录页面

    username & password两个输入框

  2. 使用Druid数据库连接池技术，操作MySQL，mysql_demo01数据库中的t_user表

  3. 使用JDBCTemplate技术封装JDBC

  4. 登录成功跳转到SuccessServlet展示：登录成功！用户名，欢迎您

  5. 登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

分析：

开发步骤：

  1. 创建项目，导入html页面，配置文件，jar包

  2. 创建数据库环境

    CREATE TABLE t_user (
    id bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘用户id’,
    username varchar(32) NOT NULL COMMENT ‘用户名’,
    password varchar(32) NOT NULL COMMENT ‘密码’,
    PRIMARY KEY (id)
    ) ENGINE=InnoDB AUTO_INCREMENT=26 DEFAULT CHARSET=utf8;

  3. 创建包cn.itcast.domain，创建一个类User

    package cn.itcast.domain;

/**
 * 用户实体类
 */
public class User {
    private int id;
    private String name;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

  4. 创建包cn.itcast.util，创建一个类JDBCUtil，提供getDatesource()方法和getConnection()方法

    package cn.itcast.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * JDBC工具类 使用Druid连接池
 */
public class JDBCUtil {
    private static DataSource ds;

    static {
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            //使用ClassLoader加载配置文件，获取字节输入流对象
            InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);

            //2.初始化连接池
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取连接池对象
     */
    public static DataSource getDatesource(){
        return ds;
    }

    /**
     * 获取连接对象
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
}

  5. 创建包cn.itcast.dao，创建一个类UserDao，提供login方法

    package cn.itcast.dao;

import cn.itcast.domain.User;
import cn.itcast.util.JDBCUtil;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * 操作数据库中t_user表的类
 */
public class UserDao {
    //声明JDBCTemplate对象共用
    private JdbcTemplate template = new JdbcTemplate(JDBCUtil.getDatesource());

    /**
     * 登录方法
     * @param loginUser 只有用户名和密码
     * @return user包含用户全部数据，没有查询到，返回null
     */
    public User login(User loginUser){
        try {
            //1.编写sql
            String sql = "select * from t_user where username = ? and password = ?";
            //2.调用query方法
            User user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class),
                    loginUser.getName(), loginUser.getPassword());
            return user;
        }catch (DataAccessException e){
            e.printStackTrace();//记录日志
            return null;
        }
    }
}

  6. 编写cn.itcast.web.servlet.LoginServlet类

    package cn.itcast.web.servlet;

import cn.itcast.dao.UserDao;
import cn.itcast.domain.User;

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

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.设置编码
        req.setCharacterEncoding("utf-8");
        //2.获取请求参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        //3.封装user对象
        User loginUser = new User();
        loginUser.setName(username);
        loginUser.setPassword(password);

        //4.调用UserDao的login方法
        UserDao dao = new UserDao();
        User user = dao.login(loginUser);

        //5.判断user
        if(user == null){
            //登录失败
            req.getRequestDispatcher("/failServlet").forward(req,resp);
        }else{
            //登录成功
            //存储数据
            req.setAttribute("user",user);
            //转发
            req.getRequestDispatcher("/successServlet").forward(req,resp);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}

  7. 编写cn.itcast.web.servlet包下FailServlet类和SuccessServlet类

    package cn.itcast.web.servlet;

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

@WebServlet("/failServlet")
public class FailServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //给页面写一句话
        //设置编码
        response.setContentType("text/html;charset=utf-8");
        //输出
        response.getWriter().write("登录失败，用户名或密码错误");
    }

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

    package cn.itcast.web.servlet;

import cn.itcast.domain.User;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/successServlet")
public class SuccessServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取request域中的共享数据user对象
        User user = (User) request.getAttribute("user");

        //给页面写一句话
        //设置编码
        response.setContentType("text/html;charset=utf-8");
        //输出
        response.getWriter().write("登录成功！"+user.getName()+"，欢迎您");
    }

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

  8. login.html中form表单的action路径写法：

    虚拟目录+servlet的资源路径

    <form action="/logindemo/loginServlet" method="post">

  9. BeanUtils工具类，简化数据的封装

    官网下载：commons-beanutils-1.9.4.jar、commons-collections-3.2.2.jar（注：beanutils-1.9.x以前包含了collections的jar包，只需下载一个beanutils的jar包即可）

    用于封装JavaBean的

    JavaBean：标准的Java类

    1. 要求：
      1. 类必须被public修饰
      2. 必须提供空参的构造器
      3. 成员变量必须使用private修饰
      4. 提供公共set和get方法
    2. 功能：封装数据

    概念：

    1. 成员变量：大多数情况下，成员变量和属性相同

    2. 属性：set和get方法截取后的产物

      例如：getName() --> Name --> name

    方法：

    1. setProperty()
    2. getProperty()
    3. populate(Object obj,Map map)：将Map中的键值对信息 封装到对应的JavaBean对象中
    package cn.itcast.test;

import cn.itcast.domain.User;
import org.apache.commons.beanutils.BeanUtils;
import org.junit.Test;
import java.lang.reflect.InvocationTargetException;

public class BeanUtilTest {
    @Test
    public void test(){
        User user = new User();
        try {
            BeanUtils.setProperty(user,"hehe","male");
            System.out.println(user);
            String sex = BeanUtils.getProperty(user, "hehe");
            System.out.println(sex);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}
qq_53529114
关注
专栏目录
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值