Servlet

JavaEE规范之一

是运行在服务端上的一个java小程序，它可以接收客户端发过来的数据请求，并且响应数据给客户端

部署tomcat的时候记得部署工程

Servlet的生命周期

1.浏览器根据地址来发起调用，tomcat容器在接收到请求之后会根据地址栏上的地址进行一个数据的解析

会找到具体的工程，然后再定位到工程下面具体的资源

2.定位到资源以后，首先会创建当前servlet类的实例，所以调用的是无参构造方法

3.会执行初始化init方法，初始化servlet上下文配置对象ServletConfig

4.会去执行service方法，service方法以后我们会用来执行请求的分发处理

5.当容器关闭的时候，会执行销毁方法destroy

使用浏览器去访问项目资源时候，记得在xml文件下注册资源路径，例如将HelloServlet注册路径设置为/hello


xxxxxxxxxx
11
1
  <!--资源注册-->
2
    <servlet>
3
        <servlet-name>hello</servlet-name>
4
        <servlet-class>com.os467.servlet.HelloServlet</servlet-class>
5
    </servlet>
6

7
    <!--资源路径的配置-->
8
    <servlet-mapping>
9
        <servlet-name>hello</servlet-name>
10
        <url-pattern>/hello</url-pattern>
11
    </servlet-mapping>

servlet的实例是由容器所创建的


xxxxxxxxxx
51
1
package com.os467.servlet;
2

3
import javax.servlet.*;
4
import java.io.IOException;
5

6
public class HelloServlet implements Servlet {
7

8
    public HelloServlet(){
9

10
        System.out.println("无参构造方法执行了!");
11

12
    }
13

14

15
    /**
16
     * 初始化的方法
17
     * @param servletConfig
18
     * @throws ServletException
19
     */
20
    @Override
21
    public void init(ServletConfig servletConfig) throws ServletException {
22

23
        System.out.println("init初始化方法执行了！");
24

25
    }
26

27
    @Override
28
    public ServletConfig getServletConfig() {
29
        return null;
30
    }
31

32
    @Override
33
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
34

35
        System.out.println("service方法执行了！");
36

37
    }
38

39
    @Override
40
    public String getServletInfo() {
41
        return null;
42
    }
43

44
    @Override
45
    public void destroy() {
46

47
        System.out.println("destroy方法执行了！");
48

49
    }
50
}
51

HttpServlet

HttpServlet中的service方法为我们提供了请求分发的处理

创建一个HelloServlet类，继承HttpServlet

先由service方法接收到request对象，与response对象

再根据客户端提交的方式调用不同的方法


xxxxxxxxxx
55
1
package com.os467.servlet;
2

3
import javax.servlet.ServletException;
4
import javax.servlet.http.HttpServlet;
5
import javax.servlet.http.HttpServletRequest;
6
import javax.servlet.http.HttpServletResponse;
7
import java.io.IOException;
8

9
public class HelloServlet extends HttpServlet {
10

11
    /**
12
     * servlet中的service方法实际上就是完成请求的分发处理，会根据客户端不同提交的方式来执行不同的方法
13
     * @param request 请求对象 一般用于请求客户端传递过来的数据或者用于获取浏览器的一些信息
14
     * @param response 响应对象 响应数据给前端
15
     * @throws ServletException
16
     * @throws IOException
17
     */
18

19
    @Override
20
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
21

22
        //获取客户端的提交方式
23
        String method = request.getMethod();
24

25
        //客户端的提交方式
26
        System.out.println("客户端的提交方式为："+method);
27

28
        if (method.equals("GET")){
29

30
            doGet(request,response);
31

32
        }else if (method.equals("POST")){
33

34
            doPost(request,response);
35

36
        }
37

38

39

40
    }
41

42
    public void doGet(HttpServletRequest request,HttpServletResponse response){
43

44
        System.out.println("执行了doGet方法!!!");
45

46
    }
47

48
    public void doPost(HttpServletRequest request,HttpServletResponse response){
49

50
        System.out.println("执行了doPost方法!!!");
51

52
    }
53

54
}
55

//前端资源


xxxxxxxxxx
15
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Title</title>
6
</head>
7
<body>
8

9
    <form action="http://localhost:8080/servlet/hello" method="post">
10

11
        <input type="submit" value="提交">
12

13
    </form>
14
</body>
15
</html>

ServletConfig

通过ServletConfig的对象来获取上下文配置信息（即xml文件内配置的信息）


xxxxxxxxxx
13
1
  /**
2
     * ServletConfig用于获取上下文配置信息
3
     * @param config
4
     * @throws ServletException
5
     */
6
    @Override
7
    public void init(ServletConfig config) throws ServletException {
8

9
        //获取初始化的数据
10
        String mysql_url = config.getInitParameter("mysql_url");
11

12
        System.out.println(mysql_url);
13
    }

配置文件


xxxxxxxxxx
21
1
 <servlet>
2
        <servlet-name>hello</servlet-name>
3
        <servlet-class>com.os467.servlet.HelloServlet</servlet-class>
4

5
      <!--配置初始化时的数据-->
6
        <init-param>
7
            <param-name>mysql_url</param-name>
8
            <param-value>jdbc:mysql://localhost:3306</param-value>
9
        </init-param>
10

11
        <init-param>
12
            <param-name>username</param-name>
13
            <param-value>root</param-value>
14
        </init-param>
15

16
        <init-param>
17
            <param-name>driver</param-name>
18
            <param-value>com.mysql.jdbc.Driver</param-value>
19
        </init-param>
20

21
    </servlet>

servlet配置对象和servlet域对象都是单例的(从工程启动时，这两个实例就创建成功了，使用的都是同一个对象)

单例模式（提高了系统资源，提高了程序的执行效率）


xxxxxxxxxx
17
1
public void doGet(HttpServletRequest request,HttpServletResponse response){
2

3
        //获取servlet核心配置对象，打印结果为true
4
        ServletConfig servletConfig01 = getServletConfig();
5
        ServletConfig servletConfig02 = getServletConfig();
6

7
        System.out.println(servletConfig01 == servletConfig02);
8

9
        //获取servlet域对象,打印结果为true
10
        //1.
11
        ServletContext servletContext = getServletConfig().getServletContext();
12

13
        //2.
14
        ServletContext servletContext1 = getServletContext();
15

16
        System.out.println(servletContext == servletContext1);
17
    }

servlet域对象

ServletConfig 是servlet核心配置对象，而且该对象的生命周期是随着容器的创建而创建，容器的销毁而销毁,在工程的任意位置去获取该实例的时候，指向的都是同一份内存地址作用：在servlet实例加载的时候去获取局部的初始化信息

servletContext 是servlet中的一个上下文本对象，而且该对象的生命周期是随着容器的创建而创建，容器的销毁而销毁，在工程的任意位置去获取该实例的时候，指向的都是同一份内存地址作用：可以像map一样存放数据，取出数据，而且是在工程的任意位置取出数据，范围是整个web工程，可以去读取全局的初始化信息，可以在工程的任何位置读取

后面会接触到的域对象：

request（也是一个域对象，也可以去存放数据，只不过该对象的取值范围比较小），session（会话对象，会对客户端和服务端进行一个绑定）


xxxxxxxxxx
17
1
public void doGet(HttpServletRequest request,HttpServletResponse response){
2

3
        //获取servlet核心配置对象
4
        ServletConfig servletConfig0 = getServletConfig();
5

6
        //获取servlet域对象
7
        ServletContext servletContext = getServletConfig().getServletContext();
8

9
        //往域中存放数据
10
        servletContext.setAttribute("username","root");
11
        servletContext.setAttribute("password","123456");
12

13
        //取出域中的数据
14
        System.out.println("username的值为："+servletContext.getAttribute("username")+
15
        "  password的值为："+servletContext.getAttribute("password"));
16

17
    }

取出全局的初始化数据


xxxxxxxxxx
6
1
 //取出全局的初始化数据
2
        String name = servletContext.getInitParameter("name");
3
        String age = servletContext.getInitParameter("age");
4
        String sex = servletContext.getInitParameter("sex");
5

6
        System.out.println(name+" "+age+" "+sex);

配置文件（需要写在根标签web-app内部）


xxxxxxxxxx
20
1
 </servlet-mapping>
2

3
    <!--配置全局的初始化数据-->
4
    <context-param>
5
        <param-name>name</param-name>
6
        <param-value>jack</param-value>
7
    </context-param>
8

9
    <context-param>
10
        <param-name>age</param-name>
11
        <param-value>20</param-value>
12
    </context-param>
13

14
    <context-param>
15
        <param-name>sex</param-name>
16
        <param-value>男</param-value>
17
    </context-param>
18

19

20
</web-app>

标签内的数据用servletConfig对象取出

标签内的数据用servletContext对象取出

HTTP协议

所谓HTTP协议，客户端和服务器之间通信时，发送的数据，需要遵循的规则，叫HTTP协议

请求分为GET和POST两种

响应HTTP协议格式

1.响应行

响应的协议和版本号
响应状态码
响应状态描述符

2.响应头key ：value不同的请求头，有不同的含义

3.响应体 ===>>>就是回传给客户端的数据

常用响应码说明

200表示请求成功
302表示请求重定向
404表示请求服务器已经收到了，但是你要的数据不存在（请求地址错误）
500表示服务器已经收到请求，但是服务器内部错误（代码错误）

GET请求

请求行

1.请求的方式GET

2.请求的资源路径[+?+请求参数]

3.请求的协议的版本号HTTP/1.1

请求头

key : value 组成不同的键值对，表示不同的含义

无论客户端给服务器传数据，还是服务端给客户端传数据，都是基于http协议来完成数据的互传

客户端

客户端如何访问服务端，如何给服务区发送数据?

1.要知道访问服务端具体的地址

http://localhost:8080/servlet/hello

格式：http://本地IP地址:端口号/工程路径/资源路径

2.如何去传递数据

看一下浏览器端的提交方式是什么，如果是get，则把数据封装在地址后面：资源路径?key1=value1&key2=value2

如果是post提交方式，则数据是被封装在请求体中的

服务端

服务端给客户端响应数据，直接是在当前页面上完成，没有地址的跳转，响应的数据则直接被封装在响应体中

以后在前端框架中，我们会根据后端的响应数据，来完成前端逻辑的判断（比如AJA异步技术）

HttpServletRequest类

每次只要有请求进入Tomcat服务器，Tomcat服务器就会把请求过来的HTTP协议信息解析好封装到Request对象中。然后传递到service方法（doGet和doPost）中给我们使用。我们可以通过HttpServletRequest对象，获取到所有请求的信息

HttpServletRequest类的常用方法

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

配置资源路径的方式(基于注解)

在类名上注释@WebServlet("/hello05")

GET方法处理：


xxxxxxxxxx
51
1
package com.os467.servlet;
2

3
import javax.servlet.annotation.WebServlet;
4
import javax.servlet.http.HttpServlet;
5

6
@WebServlet("/hello05")
7
public class HelloServlet04 extends HttpServlet {
8
    
9
     @Override
10
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
11

12
        doGet(request,response);
13

14
    }
15

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

19
        //获取请求的资源路径
20
        String requestURI = request.getRequestURI();
21

22
        System.out.println("请求的资源路径为:"+requestURI);
23

24
        //基于浏览器的全路径
25
        StringBuffer requestURL = request.getRequestURL();
26

27
        //http://localhost:8080/servlet/hello04
28
        System.out.println(requestURL);
29

30
        //获取客户端的ip
31
        String remoteHost = request.getRemoteHost();
32

33
        //0:0:0:0:0:0:0:1
34
        System.out.println(remoteHost);
35

36
        String header = request.getHeader("User-Agent");
37

38
        System.out.println(header);
39

40
        //获取请求的参数，获取客户端传递过来的数据
41
        String key1 = request.getParameter("key1");
42
        String key2 = request.getParameter("key2");
43
        String key3 = request.getParameter("key3");
44
        String name = request.getParameter("name");
45

46
        System.out.println(key1+" "+key2+" "+key3+" "+name);
47

48

49
    }
50

51
}

Post方法处理：

接收数据的方法:

request.getParameter("key的值")

处理中文乱码的方法:


xxxxxxxxxx
2
1
//处理中文乱码
2
request.setCharacterEncoding("utf-8");


xxxxxxxxxx
48
1
package com.os467.servlet;
2

3
import javax.servlet.ServletException;
4
import javax.servlet.annotation.WebServlet;
5
import javax.servlet.http.HttpServlet;
6
import javax.servlet.http.HttpServletRequest;
7
import javax.servlet.http.HttpServletResponse;
8
import java.io.IOException;
9

10
@WebServlet("/hello04")
11
public class HelloServlet04 extends HttpServlet {
12

13
    @Override
14
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
15

16
        //处理中文乱码
17
        request.setCharacterEncoding("utf-8");
18

19
        if (request.getMethod().equals("GET")){
20

21
            doGet(request,response);
22

23
        }else if (request.getMethod().equals("POST")){
24

25
            doPost(request,response);
26

27
        }
28

29
    }
30

31

32
    @Override
33
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
34
        
35
        //获取客户端传递来的数据
36
        String username = request.getParameter("username");
37
        String password = request.getParameter("password");
38
        String sex = request.getParameter("sex");
39
        String country = request.getParameter("country");
40

41
        System.out.println(username);
42
        System.out.println(password);
43
        System.out.println(sex);
44
        System.out.println(country);
45

46
    }
47
}
48

前端布局：


xxxxxxxxxx
28
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Title</title>
6
</head>
7
<body>
8

9
    <form action="http://localhost:8080/servlet/hello04" method="post">
10
        username:<input type="text" name="username"><br>
11

12
        password:<input type="text" name="password"><br>
13

14
        男:<input type="radio" name="sex" value="男"> 女:<input type="radio" name="sex" value="女"><br>
15
        
16
        国籍:<select name="country">
17
            <option value="1">----请选择----</option>
18
            <option value="中国">中国</option>
19
            <option value="美国">美国</option>
20
            <option value="日本">日本</option>
21
            <option value="德国">德国</option>
22
            </select><br>
23

24
        <input type="submit" value="提交">
25

26
    </form>
27
</body>
28
</html>

接收具有多个value值的key的方法


xxxxxxxxxx
9
1
//通过请求对象来接收value有多个的key
2
        String[] hobbies = request.getParameterValues("hobby");
3
        
4
        //遍历value
5
        for (String hobby : hobbies) {
6

7
            System.out.println(hobby);
8

9
        }

HttpServletResponse类

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

往客户端回传数据

字节流getOutputStream()

效率高

常用于下载（传递二进制数据）

字符流getWriter()

效率低

常用于回传字符串（常用）

响应中文乱码解决方法，以及设置浏览器可读取文本类型

setContentType("text/html;charset=UTF-8")


xxxxxxxxxx
30
1
package com.os467.servlet;
2

3
import javax.servlet.ServletException;
4
import javax.servlet.annotation.WebServlet;
5
import javax.servlet.http.HttpServlet;
6
import javax.servlet.http.HttpServletRequest;
7
import javax.servlet.http.HttpServletResponse;
8
import java.io.IOException;
9

10
@WebServlet("/hello06")
11
public class HelloServlet06 extends HttpServlet {
12

13
    @Override
14
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
15

16
        //让前后端字符集统一的方法
17
        response.setContentType("text/html;charset=UTF-8");
18

19
        //向tomcat服务器请求字符流对象
20
        response.getWriter().print("hello servlet");
21
        response.getWriter().print("<br/>");
22
        response.getWriter().print("响应成功！");
23
        response.getWriter().print("<br/>");
24
        response.getWriter().print("<input type='text'>");
25
        
26

27

28
    }
29
}
30

案例：（通过前端访问，后端响应数据库数据给前端）

User用户类

JdbcUtils工具类


xxxxxxxxxx
99
1
package com.os467.servlet;
2

3
import com.os467.beans.User;
4
import com.os467.utils.JdbcUtils;
5

6
import javax.servlet.ServletException;
7
import javax.servlet.http.HttpServlet;
8
import javax.servlet.http.HttpServletRequest;
9
import javax.servlet.http.HttpServletResponse;
10
import java.io.IOException;
11
import java.sql.Connection;
12
import java.sql.PreparedStatement;
13
import java.sql.ResultSet;
14
import java.sql.SQLException;
15
import java.util.ArrayList;
16

17
public class UserServlet extends HttpServlet {
18

19
    @Override
20
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
21

22
        //处理中文乱码
23
        request.setCharacterEncoding("utf-8");
24
        response.setContentType("text/html;charset=utf-8");
25

26
        //获取提交类型
27
        String method = request.getMethod();
28

29
        if (method.equals("GET")){
30

31
            doGet(request,response);
32

33
        }else if (method.equals("POST")){
34

35
            doPost(request,response);
36

37
        }
38

39
    }
40

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

44
        Connection connection = null;
45

46
        PreparedStatement preparedStatement = null;
47

48
        ResultSet resultSet = null;
49

50
        //创建集合对象
51
        ArrayList<User> users = new ArrayList<>();
52

53
        //获取数据库对象
54
        try {
55
             connection = JdbcUtils.getConnection();
56

57
             //获取数据库操作对象并且预编译sql
58
             preparedStatement = connection.prepareStatement("select * from tb_user");
59

60
             //执行sql
61
             resultSet = preparedStatement.executeQuery();
62

63
             //遍历结果集
64
             while (resultSet.next()){
65

66
                 //取出数据
67
                 int uid = resultSet.getInt("uid");
68

69
                 String username = resultSet.getString("username");
70

71
                 String password = resultSet.getString("password");
72

73
                 //创建用户对象
74
                 User user = new User(uid, username, password);
75

76
                 //将用户对象添加到集合
77
                 users.add(user);
78

79

80
             }
81

82
           //将集合对象响应到前端
83
            response.getWriter().print(users);
84

85
        } catch (Exception throwables) {
86
            throwables.printStackTrace();
87
        }finally {
88

89
            //关闭资源
90
            JdbcUtils.getClose(resultSet,preparedStatement,connection);
91

92
        }
93

94

95

96

97
    }
98
}
99

请求的转发

请求转发是指，服务器收到请求后，从一次资源跳转到另一个资源的操作叫做请求转发。（地址不会改变，即浏览器路径不会跳转）

getRequestDispatcher() 获取请求转发对象


xxxxxxxxxx
28
1
package com.os467.servlet;
2

3
import javax.servlet.RequestDispatcher;
4
import javax.servlet.ServletException;
5
import javax.servlet.annotation.WebServlet;
6
import javax.servlet.http.HttpServlet;
7
import javax.servlet.http.HttpServletRequest;
8
import javax.servlet.http.HttpServletResponse;
9
import java.io.IOException;
10

11
@WebServlet("/hello01")
12
public class HelloServlet extends HttpServlet {
13

14
    @Override
15
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
16

17
        //往域中去存放数据
18
        request.setAttribute("username","jack");
19
        request.setAttribute("password","123456");
20

21
        //获取转发对象  相对路径
22
        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/hello02");
23

24
        //走向具体的资源
25
        requestDispatcher.forward(request,response);
26
    }
27
}
28

request除了可以作为请求对象之外，还可以作为域对象，但是该域对象的取值范围，是一次请求范围之内

request通过setAttribute(key,value)方法存放数据

通过getAttribute(key)方法获取数据

请求转发：内部资源的跳转，通过浏览器发起访问，工程中的资源会从一个地址跳转到另外一个地址，浏览器的地址不会发生改变

请求转发集合对象 (使用request域存放数据，要使用请求转发)


xxxxxxxxxx
45
1
package com.os467.servlet;
2

3
import com.os467.beans.User;
4

5
import javax.servlet.ServletException;
6
import javax.servlet.annotation.WebServlet;
7
import javax.servlet.http.HttpServlet;
8
import javax.servlet.http.HttpServletRequest;
9
import javax.servlet.http.HttpServletResponse;
10
import java.io.IOException;
11
import java.util.ArrayList;
12

13
@WebServlet("/hello06")
14
public class HelloServlet06 extends HttpServlet {
15

16

17
    @Override
18
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
19

20
        //创建集合对象
21
        ArrayList<User> users = new ArrayList<>();
22

23
        //创建用户对象
24
        User user1 = new User(100,"jack001","123");
25
        User user2 = new User(100,"jack002","123");
26
        User user3 = new User(100,"jack003","123");
27
        User user4 = new User(100,"jack004","123");
28
        User user5 = new User(100,"jack005","123");
29

30
        //将数据添加到集合中去
31
        users.add(user1);
32
        users.add(user2);
33
        users.add(user3);
34
        users.add(user4);
35
        users.add(user5);
36

37
        //将集合存放到域中
38
        request.setAttribute("users",users);
39

40
        //执行请求转发
41
        request.getRequestDispatcher("/jsp/test.jsp").forward(request,response);
42

43
    }
44
}
45

渲染后端数据（使用jsp）

jsp的底层是java

不使用html，html作为一个静态文件，是不能读取动态数据的，需要用jsp去操作

el表达式：

用于替换jsp中的取值脚本

作用：取出后端域中的数据，完成数据的校验和判断 ${后端域中的key}


xxxxxxxxxx
23
1
<%--
2
  Created by IntelliJ IDEA.
3
  User: tly20
4
  Date: 2022/7/3
5
  Time: 19:54
6
  To change this template use File | Settings | File Templates.
7
--%>
8
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
9
<html>
10
<head>
11
    <title>test</title>
12
</head>
13
<body>
14
    <%--
15
        el表达式：
16
        取出后端域中的数据
17
        ${后端域中的key}
18
    --%>
19
        ${users}
20

21

22
</body>
23
</html>

使用servletContext域存放数据（可以使用请求重定向）


xxxxxxxxxx
5
1
//获取域对象
2
ServletContext servletContext = getServletContext();
3

4
servletContext.setAttribute("users",users);
5
response.sendRedirect("http://localhost:8080/servlet/jsp/test.jsp");

请求重定向

请求重定向，是指客户端给服务器发请求，然后服务器告诉客户端去新地址访问，叫做请求重定向

请求重定向：也可以完成内部资源的跳转，而且浏览器的地址是会发生改变的，这种情况下是不能取到request域中的数据的


xxxxxxxxxx
24
1
package com.os467.servlet;
2

3
import javax.servlet.ServletException;
4
import javax.servlet.annotation.WebServlet;
5
import javax.servlet.http.HttpServlet;
6
import javax.servlet.http.HttpServletRequest;
7
import javax.servlet.http.HttpServletResponse;
8
import java.io.IOException;
9

10
@WebServlet("/hello03")
11
public class HelloServlet03 extends HttpServlet {
12

13
    @Override
14
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
15

16
        //存数据
17
        request.setAttribute("key","value");
18

19
        //请求重定向  绝对路径
20
        response.sendRedirect("http://localhost:8080/servlet/hello04");
21

22

23
    }
24
}


xxxxxxxxxx
23
1
package com.os467.servlet;
2

3
import javax.servlet.ServletException;
4
import javax.servlet.annotation.WebServlet;
5
import javax.servlet.http.HttpServlet;
6
import javax.servlet.http.HttpServletRequest;
7
import javax.servlet.http.HttpServletResponse;
8
import java.io.IOException;
9

10
@WebServlet("/hello04")
11
public class HelloServlet04 extends HttpServlet {
12

13
    @Override
14
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
15

16
        Object key = request.getAttribute("key");
17
        
18
        //打印key的值应该为null，因为request域中的数据的作用范围只在一次请求范围内
19
        System.out.println(key);
20

21

22
    }
23
}

注意的点：

重定向和转发使用的域对象有哪些

采用重定向的时候: servletContext session
采用转发的时候: servletContext request session

JSP

什么是jsp？

JSP（全称Java Server Pages）是由Sun公司专门为了解决动态生成HTML文档的技术
jsp的主要作用是代替Servlet程序回传html页面的数据，因为Servlet程序回传html页面数据是一件非常繁琐的事情，开发成本和维护成本都极高

jsp九大内置对象

request
response
pageContext
exception
application
out输出
page
session
servletConfig

jsp四大域对象

pageContext：取值范围：在当前的jsp页面才能取到
request：取值范围：一次请求范围内
session：取值范围：浏览器的开启到关闭
application：本质是servletContext 取值范围：整个web工程

它们从小到大的顺序分别是:pageContext 、Request、Session 、application

jsp的运行原理

jsp的本质，其实是一个Servlet程序

可以在<%...%>内写java代码

<%!...%>jsp声明脚本，只能声明变量，不能写业务逻辑

通过脚本表达式<%=...%>取到值

也可以通过el表达式${...}取到域对象中的值

el表达式可以取到后端中的数据，而且取值的方式比较简单${域的key}

jsp脚本表达式<%=request.getAttribute("key")%>

el表达式其实在底层封装的就是对应的jsp脚本表达式，它出现目的就是为了替换脚本表达式，使得我们在开发的时候更高效

el表达式的用法：相关的逻辑判断，判断一个容器是否为空，el表达式取到的数据只能是域中的数据

在前端进行请求转发


xxxxxxxxxx
2
1
<%--在前端的请求转发--%>
2
<jsp:forward page="test4.jsp"></jsp:forward>


xxxxxxxxxx
54
1
<%--
2
  Created by IntelliJ IDEA.
3
  User: tly20
4
  Date: 2022/7/4
5
  Time: 9:53
6
  To change this template use File | Settings | File Templates.
7
--%>
8
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
9
<html>
10
<head>
11
    <title>study</title>
12
</head>
13

14
<%
15
    String username = "123456";
16
    request.setAttribute("key1","value1");
17
    
18
     ArrayList<String> strings = new ArrayList<>();
19

20
    strings.add("hello");
21
    strings.add("world");
22
    strings.add("java");
23
    strings.add("c++");
24

25
    request.setAttribute("strings",strings);
26
    
27
    HashMap<String, String> hashMap = new HashMap<>();
28

29
    hashMap.put("key1","value1");
30
    hashMap.put("key2","value2");
31
    hashMap.put("key3","value3");
32
    hashMap.put("key4","value4");
33

34
    session.setAttribute("hashMap",hashMap);
35
%>
36
<body>
37
    
38
    <%=request.getAttribute("key1")%>
39
    <%=username%>
40
    ${key1}
41
    
42
    <%=strings%><br>
43
    集合中的一个对象:${strings[0]}<br>
44
    集合中的一个对象:${strings[1]}<br>
45
    集合中的一个对象:${strings[2]}<br>
46
    集合中的一个对象:${strings[3]}<br>
47
    map集合对象:${hashMap}<br>
48
    根据下表取到某一个元素:${hashMap.get("key1")}<br>
49

50

51

52
</body>
53
</html>
54

判断一个对象是否为空（指的是对象是否存在，不是说容器长度为0）


xxxxxxxxxx
2
1
${empty strings}   判断是否为空
2
${not empty strings}  判断是否不为空

引入jstl标签库


xxxxxxxxxx
1
1
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

ForEach标签

items表示遍历集合， var表示遍历集合中每一个对象


xxxxxxxxxx
15
1
<c:forEach items="${empList}" var="emp">
2

3
    <tr>
4
        <td>${emp.empName}</td>
5
        <td>${emp.age}</td>
6
        <td>${emp.sex == 1? '男' : '女'}</td>
7
        <td>${emp.salary}</td>
8
        <td>${emp.birthday}</td>
9
        <td>
10
            <a href="http://localhost:8080/servlet/emp?flag=showEmpByID&eid=${emp.eid}">修改</a>
11
            <a href="http://localhost:8080/servlet/emp?flag=deleteEmpByID&eid=${emp.eid}">删除</a>
12
        </td>
13
    </tr>
14

15
</c:forEach>

If标签


xxxxxxxxxx
3
1
<c:if test="${not empty user}">
2
代码执行
3
</c:if>

Servlet

Servlet

HttpServlet

ServletConfig

servlet域对象

HTTP协议

GET请求

客户端

服务端

HttpServletRequest类

HttpServletRequest类的常用方法

配置资源路径的方式(基于注解)

GET方法处理：

Post方法处理：

HttpServletResponse类

往客户端回传数据

请求的转发

渲染后端数据 （使用jsp）

el表达式：

请求重定向

JSP

引入jstl标签库

渲染后端数据（使用jsp）