MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java使用Spring进行网络请求处理

2022-08-213.9k 阅读

Spring 框架简介

Spring 是一个开源的 Java 应用程序框架，旨在提供一种简化企业级应用开发的方式。它具有轻量级、模块化的特点，涵盖了多个领域，如依赖注入（Dependency Injection, DI）、面向切面编程（Aspect - Oriented Programming, AOP）等。Spring 为 Java 开发者提供了一系列工具和机制，使得开发过程更加高效、可维护和可扩展。

在网络请求处理方面，Spring 提供了强大的支持。它能够帮助开发者轻松地构建 RESTful 服务，处理各种类型的 HTTP 请求，包括 GET、POST、PUT、DELETE 等，并且可以很好地与前端技术进行交互。

Spring 中的网络请求处理模块

Spring Web MVC

Spring Web MVC 是 Spring 框架中用于构建 Web 应用的模块，它基于模型 - 视图 - 控制器（MVC）设计模式。在处理网络请求时，Spring Web MVC 扮演着核心的角色。

DispatcherServlet：它是 Spring Web MVC 的前端控制器。所有的 HTTP 请求都会首先到达 DispatcherServlet。DispatcherServlet 负责接收请求，然后将请求分发给合适的控制器（Controller）进行处理。

Controller：控制器是处理业务逻辑的地方。开发者通过定义控制器类，并在类中编写方法来处理不同的请求。这些方法通常被称为请求处理方法，它们会根据请求的 URL、HTTP 方法等条件进行匹配和调用。

ModelAndView：控制器处理完请求后，通常会返回一个 ModelAndView 对象。其中，Model 包含了要传递给视图的数据，而 View 则指定了要渲染的视图资源，比如 JSP、Thymeleaf 模板等。

Spring Boot Web

Spring Boot 是基于 Spring 框架的快速开发框架，它极大地简化了 Spring 应用的搭建和配置。Spring Boot Web 为构建 Web 应用提供了更加便捷的方式。

自动配置：Spring Boot 会根据项目的依赖自动配置 Web 相关的组件，如嵌入式的 Servlet 容器（如 Tomcat、Jetty 等）、Spring Web MVC 等。开发者只需要专注于业务逻辑的实现，而无需手动进行大量的配置。

Starter 依赖：Spring Boot 通过 Starter 依赖来管理项目的依赖。例如，spring - boot - starter - web 依赖包含了构建 Web 应用所需的所有核心依赖，包括 Spring Web MVC、Tomcat 等。

处理 GET 请求

简单的 GET 请求处理

在 Spring 中处理 GET 请求非常简单。首先，需要创建一个 Spring Boot 项目，并添加 spring - boot - starter - web 依赖。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring GET Request!";
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在上述代码中：

  1. @SpringBootApplication 注解标记这是一个 Spring Boot 应用，它包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 等多个注解的功能，能够自动配置 Spring 应用并扫描组件。
  2. @RestController 注解表示这个类是一个 RESTful 风格的控制器，它会将方法的返回值直接以 JSON 或 XML 等格式返回给客户端，而不是渲染视图。
  3. @GetMapping("/hello") 注解表示该方法处理以 /hello 为路径的 GET 请求。当客户端发送一个 GET 请求到 /hello 时，hello 方法会被调用，并返回字符串 Hello, Spring GET Request!。

GET 请求带参数

如果 GET 请求需要携带参数，可以在请求处理方法中定义参数。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        return "Hello, " + name + "! Welcome to Spring GET Request with Parameter.";
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

这里使用 @RequestParam 注解来绑定请求参数。当客户端发送请求 http://localhost:8080/greet?name=John 时，name 参数的值会被传递给 greet 方法中的 name 变量，方法返回 Hello, John! Welcome to Spring GET Request with Parameter.。

处理 POST 请求

处理表单数据的 POST 请求

处理 POST 请求中表单数据的提交也是常见的需求。假设我们有一个简单的用户注册功能，需要接收用户名和密码。

首先，创建一个 HTML 表单：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF - 8">
    <title>User Registration</title>
</head>

<body>
    <form action="/register" method="post">
        <label for="username">Username:</label><br>
        <input type="text" id="username" name="username"><br>
        <label for="password">Password:</label><br>
        <input type="password" id="password" name="password"><br><br>
        <input type="submit" value="Register">
    </form>
</body>

</html>

然后，在 Spring 中创建对应的控制器方法来处理这个 POST 请求：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @PostMapping("/register")
    public String register(@RequestParam String username, @RequestParam String password) {
        return "User " + username + " registered successfully with password " + password;
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在上述代码中，@PostMapping("/register") 表示该方法处理以 /register 为路径的 POST 请求。@RequestParam 用于获取表单中的 username 和 password 参数，并在方法中进行相应的处理。

处理 JSON 数据的 POST 请求

在现代的 Web 开发中，处理 JSON 格式的数据非常普遍。Spring 可以很方便地处理 JSON 数据的 POST 请求。

首先，创建一个 Java 类来表示要接收的 JSON 数据：

public class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

然后，在控制器中处理 JSON 数据的 POST 请求：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @PostMapping(value = "/registerJson", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<String> registerJson(@RequestBody User user) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String json = objectMapper.writeValueAsString(user);
            return new ResponseEntity<>("User registered successfully: " + json, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>("Error registering user", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在这段代码中：

  1. @PostMapping 的 consumes 属性指定了该方法接收 application/json 类型的数据。
  2. @RequestBody 注解用于将请求体中的 JSON 数据绑定到 User 对象上。Spring 会自动使用 Jackson 库进行 JSON 到 Java 对象的转换。
  3. 方法返回一个 ResponseEntity，它包含了响应体和响应状态码。如果处理成功，返回成功信息和 HttpStatus.OK；如果出现异常，返回错误信息和 HttpStatus.INTERNAL_SERVER_ERROR。

处理 PUT 和 DELETE 请求

PUT 请求

PUT 请求通常用于更新资源。假设我们有一个简单的用户信息更新功能。

首先，定义一个更新用户信息的方法：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @PutMapping("/updateUser")
    public ResponseEntity<String> updateUser(@RequestBody User user) {
        // 这里可以添加实际的更新逻辑，例如更新数据库中的用户信息
        return new ResponseEntity<>("User " + user.getUsername() + " updated successfully", HttpStatus.OK);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在这个例子中，@PutMapping("/updateUser") 表示该方法处理以 /updateUser 为路径的 PUT 请求。@RequestBody 同样用于将请求体中的 JSON 数据绑定到 User 对象，然后可以在方法中进行实际的更新操作（这里只是简单返回更新成功的信息）。

DELETE 请求

DELETE 请求用于删除资源。以下是一个删除用户的示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @DeleteMapping("/deleteUser")
    public ResponseEntity<String> deleteUser(@RequestParam String username) {
        // 这里可以添加实际的删除逻辑，例如从数据库中删除用户
        return new ResponseEntity<>("User " + username + " deleted successfully", HttpStatus.OK);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在上述代码中，@DeleteMapping("/deleteUser") 表示该方法处理以 /deleteUser 为路径的 DELETE 请求。@RequestParam 用于获取请求中的 username 参数，然后可以在方法中进行实际的删除操作（这里同样只是简单返回删除成功的信息）。

处理复杂的请求场景

路径变量

在一些情况下，我们可能需要在 URL 中包含变量，这就是路径变量的作用。例如，我们想要获取特定用户的信息，URL 可以设计为 /user/{id}。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @GetMapping("/user/{id}")
    public ResponseEntity<String> getUser(@PathVariable String id) {
        // 这里可以添加根据 id 获取用户信息的逻辑
        return new ResponseEntity<>("User with id " + id + " retrieved successfully", HttpStatus.OK);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在这个例子中，@PathVariable 注解用于将 URL 中的 {id} 部分绑定到方法的 id 参数上。当客户端发送请求 http://localhost:8080/user/123 时，id 的值为 123，方法会返回相应的信息。

多个请求方法处理

有时候，一个资源可能需要支持多种请求方法。例如，我们有一个 /product 资源，既可以通过 GET 请求获取所有产品列表，也可以通过 POST 请求添加新产品。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @GetMapping("/product")
    public ResponseEntity<String> getProducts() {
        // 返回所有产品列表的逻辑
        return new ResponseEntity<>("List of products", HttpStatus.OK);
    }

    @PostMapping("/product")
    public ResponseEntity<String> addProduct(@RequestBody Product product) {
        // 添加新产品的逻辑
        return new ResponseEntity<>("Product added successfully", HttpStatus.CREATED);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

class Product {
    private String name;
    private double price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

在上述代码中，/product 路径同时支持 GET 和 POST 请求，通过不同的请求处理方法来实现不同的功能。

异常处理

在处理网络请求过程中，难免会出现各种异常，如参数校验失败、资源未找到等。Spring 提供了强大的异常处理机制。

全局异常处理

通过创建一个全局异常处理器，可以统一处理应用中抛出的异常。

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException e) {
        return new ResponseEntity<>("Invalid argument: " + e.getMessage(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException e) {
        return new ResponseEntity<>("Resource not found: " + e.getMessage(), HttpStatus.NOT_FOUND);
    }
}

在上述代码中：

  1. @ControllerAdvice 注解表示这是一个全局的异常处理器，它会对所有控制器中抛出的异常进行处理。
  2. @ExceptionHandler 注解指定了要处理的异常类型。例如，当控制器中抛出 IllegalArgumentException 时，handleIllegalArgumentException 方法会被调用，返回一个包含错误信息和 HttpStatus.BAD_REQUEST 状态码的响应。

自定义异常处理

除了处理内置的异常，开发者还可以自定义异常并进行处理。

首先，定义一个自定义异常类：

public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

然后，在控制器中抛出这个自定义异常，并在全局异常处理器中处理它：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @GetMapping("/user/{id}")
    public ResponseEntity<String> getUser(@PathVariable String id) {
        // 假设这里根据 id 查找用户，如果未找到则抛出异常
        if (!"123".equals(id)) {
            throw new UserNotFoundException("User with id " + id + " not found");
        }
        return new ResponseEntity<>("User with id " + id + " retrieved successfully", HttpStatus.OK);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException e) {
        return new ResponseEntity<>("User not found: " + e.getMessage(), HttpStatus.NOT_FOUND);
    }
}

这样，当用户请求不存在的用户时，会抛出 UserNotFoundException，全局异常处理器会捕获并处理这个异常，返回合适的错误响应。

性能优化与最佳实践

缓存

在处理网络请求时，缓存可以显著提高性能。Spring 提供了对缓存的支持。

首先，在 pom.xml 文件中添加缓存相关的依赖，例如使用 Caffeine 缓存：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

然后，在 Spring Boot 应用的配置文件 application.properties 中配置缓存：

spring.cache.type=CAFFEINE
spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=600s

接下来，在控制器方法上使用缓存注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @Cacheable("userCache")
    @GetMapping("/user/{id}")
    public ResponseEntity<String> getUser(@PathVariable String id) {
        // 模拟从数据库或其他数据源获取用户信息
        String userInfo = "User with id " + id;
        return new ResponseEntity<>(userInfo, HttpStatus.OK);
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在上述代码中，@Cacheable("userCache") 注解表示该方法的返回值会被缓存到名为 userCache 的缓存中。当相同的请求再次到达时，如果缓存中存在对应的值，就直接从缓存中返回，而不需要再次执行方法体中的逻辑，从而提高了性能。

异步处理

对于一些耗时较长的网络请求处理，可以采用异步处理的方式，避免阻塞主线程。Spring 支持异步方法调用。

首先，在 Spring Boot 应用的启动类上添加 @EnableAsync 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class WebRequestApp {
    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

然后，在控制器方法中定义异步方法：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@SpringBootApplication
@RestController
public class WebRequestApp {

    @Async
    @GetMapping("/asyncTask")
    public CompletableFuture<String> asyncTask() {
        // 模拟一个耗时操作
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return CompletableFuture.completedFuture("Async task completed");
    }

    public static void main(String[] args) {
        SpringApplication.run(WebRequestApp.class, args);
    }
}

在这个例子中，@Async 注解表示该方法是一个异步方法。方法返回一个 CompletableFuture，主线程不会阻塞等待这个方法执行完毕，而是继续处理其他请求。当异步任务完成后，CompletableFuture 会包含任务的结果。

最佳实践总结

  1. 代码结构清晰：按照功能模块划分控制器、服务层和数据访问层，使代码易于维护和扩展。
  2. 参数校验：在控制器方法中对输入参数进行严格校验，避免非法数据进入业务逻辑层。可以使用 Spring 提供的 @Valid 注解和自定义的校验器。
  3. 日志记录：合理使用日志框架（如 Logback、Log4j 等）记录请求处理过程中的关键信息和异常，方便调试和排查问题。
  4. 安全考虑：对网络请求进行安全防护，如防止 SQL 注入、XSS 攻击等。可以使用 Spring Security 框架来实现身份验证、授权和安全过滤等功能。

通过以上对 Spring 进行网络请求处理的详细介绍，开发者可以更好地利用 Spring 的强大功能，构建高效、可靠和安全的 Web 应用。无论是简单的 RESTful 服务还是复杂的企业级应用，Spring 都能提供良好的支持。