JavaWeb之Servlet

1、什么是JavaWeb？

  1. Servlet 是 JavaEE 规范之一。规范就是接口
  2. Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
  3. Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端。

2、第一个Servlet程序

2.1 实现步骤

实现一个简单的Servlet程序的步骤：

  1. 编写一个类去实现 Servlet 接口或者Servlet接口的子类
  2. 实现 service 方法，处理请求，并响应数据
  3. 到 web.xml 中去配置 servlet 程序的访问地址

2.2 继承Servlet接口并实现service方法

public class HelloServlet implements Servlet {
/**
* service 方法是专门用来处理请求和响应的
* @param servletRequest 客户端的请求
* @param servletResponse 服务器的响应
*/
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws
ServletException, IOException {
System.out.println("Hello Servlet");
}
}

2.3 配置web.xml 

<?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_4_0.xsd"
version="4.0">
<!-- servlet 标签给 Tomcat 配置 Servlet 程序 -->
<servlet>
<!--servlet-name 标签 Servlet 程序起一个别名（一般是类名） -->
<servlet-name>HelloServlet</servlet-name>
<!--servlet-class 是 Servlet 程序的全类名-->
<servlet-class>com.lyh.servlet.HelloServlet</servlet-class>
</servlet>
<!--servlet-mapping 标签给 servlet 程序配置访问地址-->
<servlet-mapping>
<!--servlet-name 标签的作用是告诉服务器，我当前配置的地址给哪个 Servlet 程序使用-->
<servlet-name>HelloServlet</servlet-name>
<!--url-pattern 标签配置访问地址 <br/>
/ 斜杠在服务器解析的时候，表示地址为：http://ip:port/工程路径 <br/>
/hello 表示地址为：http://ip:port/工程路径/hello <br/>
-->
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>

3、Servlet的生命周期

  1. 执行 Servlet 构造器方法（只调用一次）
  2. 执行 init 初始化方法（只调用一次）
  3. 执行 service 方法 （每次访问Servlet对应的网页都会调用）
  4. 执行 destroy 销毁方法  （在 web 工程停止的时候调用）
public class HelloServlet implements Servlet {

    public HelloServlet(){

        System.out.println("1. 构造器方法被调用");

    }

    //这里使用了 ServletConfig这个类
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

        System.out.println("2. 初始化方法被调用");
        
    }

  

    /**
     * service是专门用来处理请求和响应的
     * 当需要查询服务器并且不包含敏感数据时，可以使用GET方法。而当需要向服务器发送大量数据或包含敏感数据时，则应使用POST方法。
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {

        System.out.println("3 service()方法被调用 Hello Servlet");

    }

    

    @Override
    public void destroy() {
        System.out.println("4. destroy()方法被调用");
    }
}

4、GET 和 POST

4.1概述

        因为 service方法是专门用来处理客户端请求和返回响应的，所以使用该方法需要我们用户根据自己的需求来实现相关的方法完成对不同类型请求（GET/POST）的处理。

4.2GET/POST的选择


        当需要查询服务器并且不包含敏感数据时，可以使用GET方法。而当需要向服务器发送大量数据或包含敏感数据时，则应使用POST方法。

4.3实现对不同请求的处理

        由于我们继承的是Servlet接口，它没有直接对GET和POST这两种请求类型的区分，所以需要我们自己来实现区分并做不同的处理。

public class HelloServlet implements Servlet {
/**
* service 方法是专门用来处理请求和响应的
*/
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws
ServletException, IOException {
        System.out.println("3 service === Hello Servlet 被访问了");
        // 类型转换（因为它有 getMethod()方法）
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        // 获取请求的方式
        String method = httpServletRequest.getMethod();
        if ("GET".equals(method)) {
            doGet();
        } else if ("POST".equals(method)) {
            doPost();
        }
    }
        /**
        * 做 get 请求的操作
        */
        public void doGet(){
            System.out.println("get 请求");
        }
        /**
        * 做 post 请求的操作
        */
        public void doPost(){
            System.out.println("post 请求");
        }
}

5、继承HttpServlet

        通过上面的案例我们可以看到，直接继承Servlet接口很不方便，因为它毕竟只是一个接口，只对方法进行了规范并没有实现，我们看看Servlet接口的源码：

5.1 Servlet接口源码

public interface Servlet {
    void init(ServletConfig var1) throws ServletException;

    ServletConfig getServletConfig();

    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    String getServletInfo();

    void destroy();
}

        实际开发中我们很少直接继承Servlet接口去实现servlet程序 而是继承它的子类HttpServlet，因为HttpServlet这个抽象子类对Servlet的方法都进行了实现而且对GET/POST请求也添加了专门的方法去实现。

5.2 doGet/doPost

        HttpServlet为GET/POST这两种客户端请求封装了两个方法，使得我们实现自己的业务逻辑更加简单明了。

public class HelloServlet2 extends HttpServlet {
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet2 的 doGet 方法");
    }

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

每一个Servlet类都需要配置web.xml： 

<servlet>
<servlet-name>HelloServlet2</servlet-name>
<servlet-class>com.lyh.servlet.HelloServlet2</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet2</servlet-name>
<url-pattern>/hello2</url-pattern>
</servlet-mapping>

 5.3 HttpServlet继承体系

6、ServletConfig

6.1 概述及源码

  • ServletConfig 是 Servlet 程序的配置信息类。
  • Servlet 程序和 ServletConfig 对象都是由 Tomcat 负责创建，我们负责使用。
  • Servlet 程序默认是第一次访问的时候创建，ServletConfig 是每个 Servlet 程序创建时，就创建一个对应的 ServletConfig 对象。
public interface ServletConfig {
    String getServletName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration<String> getInitParameterNames();
}

 通过源码，我们可以了解到它的三大作用：

6.2 ServletConfig 类的三大作用

  1. 可以获取 Servlet 程序的别名 servlet-name 的值
  2. 获取初始化参数 init-param
    1. 获取初始化参数可以帮助我们在运行时配置 Servlet 的行为，例如设置数据库连接信息、数据源名称等参数。
  3. 获取 ServletContext 对象（Servlet的上下文对象）

 6.3、ServletConfig 的使用

6.3.1、初始化参数<init-param>

需要在我们的Servlet程序的配置信息中添加

<servlet>
        <!--servlet-name 标签 Servlet 程序起一个别名（一般是类名） -->
        <servlet-name>HelloServlet</servlet-name>
        <!--servlet-class 是 Servlet 程序的全类名-->
        <servlet-class>com.lyh.servlet.HelloServlet</servlet-class>

        <!--   初始化参数 可以是多个参数  -->
        <init-param>
            <!--  参数名-->
            <param-name>url</param-name>
            <!--  参数值-->
            <param-value>jdbc:mysql://localhost:3306/test</param-value>
        </init-param>
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>

    </servlet>

 

public class HelloServlet implements Servlet {


    //继承了HttpServlet的类在重写init时 一定要调用父类的初始化方法
    super.init(config);
   
    //这里使用了 ServletConfig这个类
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

        // 1、可以获取 Servlet 程序的别名 servlet-name 的值
        System.out.println("HelloServlet 程序的别名是:" + servletConfig.getServletName());
        // 2、获取初始化参数 init-param
        System.out.println("初始化参数 username 的值是;" + servletConfig.getInitParameter("username"));
        System.out.println("初始化参数 url 的值是;" + servletConfig.getInitParameter("url"));
        // 3、获取 ServletContext 对象 
        ServletContext context = servletConfig.getServletContext();
    }
}

注意：

继承了HttpServlet的类在重写init时 一定要调用父类的初始化方法
super.init(config); 

7、ServletContext

7.1 概述

  1. ServletContext 是一个接口，它表示 Servlet 上下文对象。
  2. 一个 web 工程，只有一个 ServletContext 对象实例。
  3. ServletContext 对象是一个域对象，我们可以通过它来获取整个web工程中在web.xml中配置的所有被<context-param>标记的参数（不管web工程中有多少个Servlet程序）。
  4. ServletContext 是在 web 工程部署启动的时候创建。在 web 工程停止的时候销毁。

7.2 ServletContext的四大作用 

  1. 获取 web.xml 中配置的上下文参数 context-param
  2. 获取当前的工程路径，格式: /工程路径
  3. 获取工程部署后在服务器硬盘上的绝对路径
  4. 像 Map 一样存取数据

7.3 ServletContext的使用

7.3.1 配置web.xml

<!--context-param 是上下文参数(它属于整个 web 工程)-->
<context-param>
<param-name>username</param-name>
<param-value>context</param-value>
</context-param>
<!--context-param 是上下文参数(它属于整个 web 工程)-->
<context-param>
<param-name>password</param-name>
<param-value>root</param-value>
</context-param>

7.3.2 读取工程文件的配置参数以及工程路径

读取配置工程文件web.xml参数用 getInitParameter() 方法。

/**
 * <init-param>不同于ServletConfig的标签<context-param>
 * <init-param>的作用域是它自己对应的Servlet程序
 * <context-param>的作用域是每个Servlet程序
 */
public class ContextServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //1.获取配置文件中的<context-param>参数
        ServletContext context = getServletContext();
        String username = context.getInitParameter("username");
        System.out.println("context-param 参数 username 的值是:" + username);

        //2.获取当前工程路径 /JavaWebStudy_war_exploded
        System.out.println("当前工程路径 ="+context.getContextPath());
        //获取工程部署在服务器上的绝对路径 D:\IdeaProjects\JavaWebStudy\target\JavaWebStudy-1.0-SNAPSHOT\
        //斜杠 / 被服务器解析为 http://127.0.0.1:8080/JavaWebStudy/ 映射到idea的web目录
        System.out.println("工程部署的绝对路径是 ="+context.getRealPath("/"));

        System.out.println("工程下 css 目录的绝对路径是:" + context.getRealPath("/css"));
    }
}

7.3.3 多个Servle程序之间的存取数据

读取数据用 getAttribute() 方法 。

        因为ServletContext的作用域是整个web工程，所以不同Servlet程序之间也可以共享参数以及自己配置参数供其他Servlet读取。

例：写两个Servlet类，Servlet1负责设置参数数据，Servlet2负责读取参数数据。

public class ContextServlet1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext context = getServletContext();
        context.setAttribute("username","root");
        context.setAttribute("password","123456");
    }

   
}
public class ContextServlet2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(getServletContext().getAttribute("username"));
        System.out.println(getServletContext().getAttribute("password"));
    }

}

注意：

这两个不一样

  1. 读取配置工程文件web.xml参数用 getInitParameter() 方法
  2. 读取数据用 getAttribute() 方法 

8、HttpServletRequest 

8.1 概述

我们可以看到service（）方法里有两个参数，分别对应客户端的请求以及我们服务端的响应。

@Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws
ServletException, IOException {
    //用户业务逻辑代码。。。
}
        每次只要有请求进入 Tomcat 服务器， Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。 然后传递到 service 方法（doGet 和 doPost ）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息。

8.2 常用方法

  • getRequestURI()         获取请求的资源路径
  • getRequestURL()       获取请求的统一资源定位符（绝对路径）
  • getRemoteHost()         获取客户端的 ip 地址
  • getHeader()                 获取请求头
  • getParameter()                 获取请求的参数
  • getParameterValues()         获取请求的参数（多个值的时候使用）
  • getMethod()                         获取请求的方式 GET 或 POST
  • setAttribute(key, value);         设置域数据
  • getAttribute(key);                 获取域数据
  • getRequestDispatcher()         获取请求转发对象

8.3、实例

通过html中的表单提交数据，通过Servlet程序读取表单中的数据。

8.3.1、html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="http://localhost:8080/JavaWebStudy_war_exploded/request1" method="get">
  用户名:<input type="text" name="username"><br/>
  密码:<input type="text" name="password"><br/>
  爱好:<input type="checkbox" name="hobby" value="Java">Java
        <input type="checkbox" name="hobby" value="JS">JavaScript
        <input type="checkbox" name="hobby" value="Scala">Scala<br/>
    <input type="submit">
</form>

</body>
</html>

8.3.2、Servlet类

Servlet只需要实现doGet方法即可。

注意：

  1. 当参数不只一个的时候（比如多选框），我们需要用的是getParameterValues方法，它会返回一个数组对象。使用getParameter来读取多选框的话，最终只会返回一个值（用户最后选的值，先选的值会被覆盖）。
  2. 中文乱码问题：我们需要设置请求体的字符集编码格式，设置编码格式的代码只有放到doGet/doPost方法下的第一行才有效。

 @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
        //设置请求体的字符集为 UTF-8 解决post的请求乱码问题
        //必须放在获取请求参数getParameter()方法之前调用才有效果
        req.setCharacterEncoding("UTF-8");
        System.out.println("URI => "+req.getRequestURI());
        System.out.println("URL => "+req.getRequestURL());
        System.out.println("客户端Host的ip => "+req.getRemoteHost());
//        我的真实ip 10.49.xx.xxx 可通过网络管理查看ipv4地址 就是本地真实地址
        System.out.println("请求头 => "+req.getHeader("User-Agent"));
        System.out.println("请求的方法 => "+req.getMethod());

//        参数名称就是 <input>标签中的 name属性
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby");
        System.out.println("请求的参数 username => "+username);
        System.out.println("请求的参数 password => "+password);
        System.out.print("请求的参数 hobby => ");
        //打印数组的两种方式 1. Arrays.toString  Arrays.asList(数组名)
        System.out.println(Arrays.toString(hobby));
//        System.out.println(Arrays.asList(hobby));

    }

8.4、请求转发

8.4.1 特点：

  1. 浏览器地址没有变化
  2. 是一次请求
  3. 共享request域的数据
  4. 可以转发到WEB-INF目录下的资源
  5. 不可以访问外部资源（比如www.baidu.com）

核心代码：

req.getRequestDispatcher("转发路径").forward(req,resp);

实例：客户端请求 /forwardc的资源， 由ForwardC这个Servlet程序转发到http://localhost:8080/JavaWebStudy_war_exploded/a/b/c.html。

需要再我们上面的html中添加超链接（我们的ForwardC对应的工程url为"/forwardc"）。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <a href="a/b/c.html">跳转到c.html</a></br>

    <a href="http://localhost:8080/JavaWebStudy_war_exploded/forwardC">通过请求转发跳转到c.html</a></br>

    <a href="http://localhost:8080/JavaWebStudy_war_exploded/redirect">请求重定向到c.html</a>
</body>
</html>
public class ForwardC extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("经过了ForwardC请求转发到了 c.html");
        //转发到http://localhost:8080/JavaWebStudy_war_exploded + /a/b/c.html
        //这里的斜杠 / 是协议//ip:端口号/工程路径的意思
        req.getRequestDispatcher("/a/b/c.html").forward(req,resp);
    }
}

c.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>c页面</title>
<!--  有了base标签 浏览器就不会根据当前的浏览器地址的路径去判断 ../../后的路径了  -->
  <base href="http://localhost:8080/JavaWebStudy_war_exploded/a/b/">
</head>
<body>
C页面
<a href="../../index.html">回到首页</a></br>
</body>
</html>

 9、HttpServletResponse

9.1 HttpServletResponse 类的作用

HttpServletResponse 类和 HttpServletRequest 类一样。每次请求进来， Tomcat 服务器都会创建一个 Response 对象传 递给 Servlet 程序去使用。 HttpServletRequest 表示请求过来的信息， HttpServletResponse 表示所有响应的信息， 我们如果需要设置返回给客户端的信息，都可以通过 HttpServletResponse 对象来进行设置。

9.1.1 两个输出流的说明。

  • 字节流   getOutputStream()  常用于下载（传递二进制数据）
  • 字符流  getWriter();  常用于回传字符串（常用）
两个流同时只能使用一个。
使用了字节流，就不能再使用字符流，反之亦然，否则就会报错。 
public class ResponseIOServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //回传中文字符串同样会乱码,需要设置编码格式
        //1.1这里设置的是我们服务器的编码格式 如果客户的浏览器不是UTF-8仍然是乱码
//        resp.setCharacterEncoding("UTF-8");
        //1.2通过响应头来设置浏览器编码
//        resp.setHeader("Content-Type","text/html; charset=UTF-8");

        //2.设置相应内容的格式 这种方法可以同时设置服务器和浏览器的编码格式
        resp.setContentType("text/html; charset=UTF-8");

        /**
         * 字符流和字节流只能用一个
         */
        //字符流 回传字符串 展示到html上
        PrintWriter writer = resp.getWriter();
        writer.write("Hello Response");
    }
}



9.2 请求重定向

9.2.1 特点：

  1. 浏览器地址会发生变化
  2. 两次请求
  3. 不共享request域中的数据
  4. 不能访问WEB-INF目录下的资源
  5. 可以访问外部资源（比如www.baidu.com）

9.2.2 实现

/**
 * 请求重定向
 */
public class RedirectServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet程序接收到用户请求");


        //设置重定向的两种方法
        //设置响应状态码 302 ，表示重定向，（已搬迁）
        resp.setStatus(302);
        //1. 设置响应头，说明 新的地址在哪里 不推荐
       // resp.setHeader("Location", "http://localhost:8080");

        //2.第二种方法 推荐使用
        resp.sendRedirect("http://localhost:8080/JavaWebStudy_war_exploded/a/b/c.html");
    }
}