servlet测试

在Java Web应用中，Servlet是处理HTTP请求的核心组件之一。为了确保Servlet的正确性和稳定性，通常需要进行单元测试和集成测试。

单元测试

单元测试主要关注于Servlet类本身的逻辑，例如请求参数的解析、业务逻辑的执行等。对于Servlet来说，单元测试通常需要模拟HttpServletRequest和HttpServletResponse对象，以验证Servlet的行为是否符合预期。

1. 使用Mock框架：

   • Mockito 和 PowerMock 是常用的Mock框架，可以用来创建HttpServletRequest和HttpServletResponse的模拟对象。

2. 创建测试用例：

   • 使用JUnit或其他测试框架编写测试用例。
   • 模拟请求数据，比如设置请求方法（GET, POST等）、请求路径、请求参数等。
   • 检查Servlet的响应状态码、输出流中的内容等。

示例代码（使用JUnit和Mockito）：

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyServletTest {

    @Test
    public void testDoGet() throws ServletException, IOException {
        HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

        // 设置请求参数
        Mockito.when(request.getParameter("paramName")).thenReturn("paramValue");

        // 创建并调用Servlet实例
        MyServlet servlet = new MyServlet();
        servlet.doGet(request, response);

        // 验证响应
        Mockito.verify(response).setStatus(HttpServletResponse.SC_OK);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

集成测试

集成测试则更侧重于验证Servlet与数据库、其他服务或系统的交互。它通常需要启动一个完整的运行环境来测试Servlet的功能。

1. 使用内嵌容器：

   • Jetty 或 Tomcat 提供了内嵌容器模式，可以在测试时启动一个小型的Web服务器。
   • 通过发送实际的HTTP请求到这个服务器来测试Servlet的行为。

2. 使用REST客户端工具：

   • 使用RestTemplate或第三方库如OkHttp、HttpClient来发送HTTP请求，并检查响应结果。

示例代码（使用Jetty和JUnit）：

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyServletIntegrationTest {

    private Server server;

    @BeforeEach
    public void setUp() throws Exception {
        server = new Server(8080);
        server.setHandler(new AbstractHandler() {
            @Override
            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
                if (target.equals("/test")) {
                    new MyServlet().doGet(request, response);
                    baseRequest.setHandled(true);
                }
            }
        });
        server.start();
    }

    @AfterEach
    public void tearDown() throws Exception {
        server.stop();
    }

    @Test
    public void testIntegration() throws Exception {
        String url = "http://localhost:8080/test?paramName=paramValue";
        // 使用 HttpClient 或 RestTemplate 发送请求并验证结果
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

以上是基本的测试方法，具体实现可能还需要根据你的项目结构和技术栈来调整。

为了使用HttpClient进行集成测试，我们可以结合Jetty内嵌服务器和JUnit来构建一个完整的测试案例。下面是一个具体的示例，展示了如何使用Apache HttpClient进行集成测试。

首先，确保你已经添加了Jetty和HttpClient相关的依赖到你的项目中。如果你使用Maven，可以在文件中添加以下依赖：

<dependencies>
    <!-- Jetty for embedded server -->
    <dependency>
        <groupId></groupId>
        <artifactId>jetty-server</artifactId>
        <version>9.4.35.v20201120</version>
        <scope>test</scope>
    </dependency>

    <!-- Apache HttpClient for making HTTP requests -->
    <dependency>
        <groupId></groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.13</version>
        <scope>test</scope>
    </dependency>

    <!-- JUnit 5 for testing -->
    <dependency>
        <groupId></groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId></groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31

接下来，我们将创建一个集成测试类，该类将启动一个Jetty服务器并在其中部署我们的Servlet。然后我们使用Apache HttpClient向这个服务器发送HTTP请求，并验证返回的结果。

以下是具体的实现示例：

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

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

public class MyServletIntegrationTest {

    private Server server;
    private CloseableHttpClient httpClient;

    @BeforeEach
    public void setUp() throws Exception {
        server = new Server(8080);
        server.setHandler(new AbstractHandler() {
            @Override
            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
                if (target.equals("/test")) {
                    new MyServlet().doGet(request, response);
                    baseRequest.setHandled(true);
                }
            }
        });

        server.start();

        httpClient = HttpClients.createDefault();
    }

    @AfterEach
    public void tearDown() throws Exception {
        server.stop();
        httpClient.close();
    }

    @Test
    public void testIntegration() throws Exception {
        String url = "http://localhost:8080/test?paramName=paramValue";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        // 根据实际情况验证状态码和返回内容
        assert statusCode == 200 : "Expected status code 200 but got " + statusCode;
        assert content.contains("expectedContent") : "Expected 'expectedContent' in the response body.";
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61

在这个例子中，我们首先启动了一个Jetty服务器，该服务器监听8080端口，并且在/test路径上处理HTTP GET请求。当请求被处理后，我们使用Apache HttpClient发送一个GET请求到服务器，并验证返回的状态码和内容是否符合预期。

请注意，在实际的应用场景中，你需要替换MyServlet为你的实际Servlet类，并根据实际需求修改测试用例中的断言条件。此外，确保你的Servlet实现了期望的行为，以便在测试中可以正确地验证其功能。

增加异常测试用例可以帮助你确保Servlet能够正确地处理各种异常情况。这包括但不限于请求参数错误、业务逻辑中的异常以及任何可能发生的运行时异常。

下面是如何在现有的集成测试基础上增加异常测试用例的例子：

1. 模拟异常请求：创建一个请求，其中包含一些不正确的参数或者格式，以触发异常。
2. 验证异常处理：验证Servlet是否能够正确地处理这些异常，并返回合适的HTTP状态码或错误消息。

假设我们的Servlet在接收到无效参数时会抛出异常，我们可以编写如下测试用例：

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

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

public class MyServletIntegrationTest {

    private Server server;
    private CloseableHttpClient httpClient;

    @BeforeEach
    public void setUp() throws Exception {
        server = new Server(8080);
        server.setHandler(new AbstractHandler() {
            @Override
            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
                if (target.equals("/test")) {
                    new MyServlet().doGet(request, response);
                    baseRequest.setHandled(true);
                }
            }
        });

        server.start();

        httpClient = HttpClients.createDefault();
    }

    @AfterEach
    public void tearDown() throws Exception {
        server.stop();
        httpClient.close();
    }

    @Test
    public void testIntegration() throws Exception {
        String url = "http://localhost:8080/test?paramName=paramValue";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        // 根据实际情况验证状态码和返回内容
        assert statusCode == 200 : "Expected status code 200 but got " + statusCode;
        assert content.contains("expectedContent") : "Expected 'expectedContent' in the response body.";
    }

    @Test
    public void testExceptionHandling() throws Exception {
        // 模拟一个无效的请求参数
        String url = "http://localhost:8080/test?invalidParam=badValue";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        // 验证异常处理后的状态码
        assert statusCode == 400 : "Expected status code 400 but got " + statusCode;
        assert content.contains("Bad Request") : "Expected 'Bad Request' in the response body.";
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77

在这个例子中，我们新增了一个名为testExceptionHandling的方法，用于测试当Servlet接收到无效参数时的情况。我们构造了一个包含无效参数的请求，并期望Servlet返回一个HTTP状态码400（Bad Request），并且响应体中包含“Bad Request”的信息。

注意事项

• 在实际的应用程序中，你可能需要自定义异常处理逻辑，例如使用过滤器或者Servlet容器提供的默认异常处理机制。
• 如果你的Servlet内部抛出了异常，你可能需要捕获这些异常并在适当的范围内返回合适的HTTP状态码。
• 确保在Servlet中处理异常时记录详细的错误日志，以便于调试和维护。

请根据你的具体需求调整上述代码中的细节，例如更改状态码和错误消息等。

接下来，我们举一个更加真实的例子，假设我们的Servlet需要处理一些特定的请求参数，并且需要对这些参数进行验证。如果参数不符合要求，Servlet应该返回一个错误状态码和相应的错误信息。

这里我们将创建一个简单的Servlet，它接受一个名为age的查询参数，并检查这个参数是否为有效的整数。如果不是有效的整数，Servlet将返回一个HTTP状态码400（Bad Request）和一个错误消息。

Servlet 实现

首先，我们需要实现一个简单的Servlet，用于处理HTTP GET请求，并验证age参数的有效性。

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.io.PrintWriter;

@WebServlet("/validateAge")
public class AgeValidationServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String ageString = request.getParameter("age");
        if (ageString == null || !isNumeric(ageString)) {
            // 参数不是有效的整数
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            response.setContentType("text/plain");
            PrintWriter writer = response.getWriter();
            writer.println("Invalid age parameter.");
            return;
        }

        // 这里可以添加更多的业务逻辑
        int age = Integer.parseInt(ageString);
        if (age < 0) {
            // 年龄不能是负数
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            response.setContentType("text/plain");
            PrintWriter writer = response.getWriter();
            writer.println("Age cannot be negative.");
            return;
        }

        // 成功的情况
        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType("text/plain");
        PrintWriter writer = response.getWriter();
        writer.println("Valid age: " + age);
    }

    private boolean isNumeric(String strNum) {
        if (strNum == null) {
            return false;
        }
        try {
            Integer.parseInt(strNum);
        } catch (NumberFormatException nfe) {
            return false;
        }
        return true;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53

测试用例

现在我们将编写集成测试用例，以验证Servlet是否能正确处理异常情况。

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

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

public class AgeValidationServletIntegrationTest {

    private Server server;
    private CloseableHttpClient httpClient;

    @BeforeEach
    public void setUp() throws Exception {
        server = new Server(8080);
        server.setHandler(new AbstractHandler() {
            @Override
            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
                if (target.equals("/validateAge")) {
                    new AgeValidationServlet().doGet(request, response);
                    baseRequest.setHandled(true);
                }
            }
        });

        server.start();

        httpClient = HttpClients.createDefault();
    }

    @AfterEach
    public void tearDown() throws Exception {
        server.stop();
        httpClient.close();
    }

    @Test
    public void testValidAge() throws Exception {
        String url = "http://localhost:8080/validateAge?age=25";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        assert statusCode == 200 : "Expected status code 200 but got " + statusCode;
        assert content.contains("Valid age: 25") : "Expected 'Valid age: 25' in the response body.";
    }

    @Test
    public void testInvalidAge() throws Exception {
        String url = "http://localhost:8080/validateAge?age=abc";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        assert statusCode == 400 : "Expected status code 400 but got " + statusCode;
        assert content.contains("Invalid age parameter.") : "Expected 'Invalid age parameter.' in the response body.";
    }

    @Test
    public void testNegativeAge() throws Exception {
        String url = "http://localhost:8080/validateAge?age=-10";

        HttpGet httpGet = new HttpGet(url);
        HttpResponse httpResponse = httpClient.execute(httpGet);

        int statusCode = httpResponse.getStatusLine().getStatusCode();
        String content = EntityUtils.toString(httpResponse.getEntity());

        assert statusCode == 400 : "Expected status code 400 but got " + statusCode;
        assert content.contains("Age cannot be negative.") : "Expected 'Age cannot be negative.' in the response body.";
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88

在这个例子中，我们编写了三个测试用例：

1. testValidAge：验证当年龄参数有效时，Servlet能够正确返回200状态码和正确的响应体。
2. testInvalidAge：验证当年龄参数无效时，Servlet能够返回400状态码和错误消息。
3. testNegativeAge：验证当年龄参数为负数时，Servlet能够返回400状态码和错误消息。

这些测试用例覆盖了正常情况和异常情况，确保Servlet能够正确处理各种输入。你可以根据你的具体需求调整这些测试用例。

在实际项目中，测试Servlet的跳转逻辑可以通过模拟HTTP请求和响应来实现。Servlet中的跳转通常涉及到重定向（redirect）或转发（forward）。下面我将分别介绍这两种情况下的测试方法。

1. 重定向测试

当Servlet执行完某些操作后，可能会重定向到另一个资源（如另一个Servlet或JSP页面）。在这种情况下，我们需要验证Servlet是否正确地设置了HTTP状态码302（Found）和重定向URL。

示例代码

假设我们有一个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("/redirect")
public class RedirectServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 执行一些业务逻辑...

        // 重定向到另一个资源
        response.sendRedirect("/");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

测试用例

为了测试重定向，我们需要使用Mockito或其他Mock框架来模拟HttpServletResponse对象，并验证是否正确设置了重定向。

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RedirectServletTest {

    @Test
    public void testRedirect() throws ServletException, IOException {
        HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

        RedirectServlet servlet = new RedirectServlet();
        servlet.doGet(request, response);

        // 验证重定向URL
        Mockito.verify(response).sendRedirect("/");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

2. 转发测试

当Servlet需要将控制权交给另一个Servlet或JSP页面时，它会使用转发。转发不会改变浏览器地址栏中的URL，但会将请求传递给另一个资源处理。

示例代码

假设我们有一个Servlet，它在处理完请求后将控制权转发给另一个Servlet或JSP页面。

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 javax.servlet.RequestDispatcher;

@WebServlet("/forward")
public class ForwardServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 执行一些业务逻辑...

        // 获取RequestDispatcher对象
        RequestDispatcher dispatcher = request.getRequestDispatcher("/");

        // 转发请求
        dispatcher.forward(request, response);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

测试用例

为了测试转发，我们同样需要使用Mockito或其他Mock框架来模拟HttpServletRequest和HttpServletResponse对象，并验证是否正确进行了转发。

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.RequestDispatcher;

public class ForwardServletTest {

    @Test
    public void testForward() throws ServletException, IOException {
        HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse response = Mockito.mock(HttpServletResponse.class);

        ForwardServlet servlet = new ForwardServlet();
        servlet.doGet(request, response);

        // 验证转发
        Mockito.verify(request).getRequestDispatcher("/");
        Mockito.verify(request).setAttribute(Mockito.anyString(), Mockito.any());
        Mockito.verify(request).getServletContext();
        Mockito.verify((RequestDispatcher)Mockito.any()).forward(request, response);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

注意事项

• 在实际项目中，你可能需要使用更复杂的测试框架，如Spring Test或Arquillian，它们提供了更高级的测试支持，包括自动配置容器和注入依赖等。
• 当使用转发时，通常需要在测试中模拟RequestDispatcher对象，并验证是否正确调用了forward方法。
• 对于重定向测试，重要的是验证是否设置了正确的HTTP状态码（通常是302）和重定向URL。

希望这些示例能帮助你理解如何在实际项目中测试Servlet的跳转逻辑。