Java后端哀求想接收多个对象入参的数据方法

吴旭华  论坛元老 | 2024-11-9 07:03:15 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1770|帖子 1770|积分 5310

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
在Java后端开辟中，假如我们盼望接收多个对象作为HTTP哀求的入参，可以利用Spring Boot框架来简化这一过程。Spring Boot提供了强大的RESTful API支持，可以大概方便地处理各种HTTP哀求。
1.示例：利用Spring Boot接收包含多个对象的HTTP哀求

以下是一个详细的示例，展示了如何利用Spring Boot接收包含多个对象的HTTP哀求。
1.1创建Spring Boot项目

首先，确保我们已经安装了Spring Boot和Maven（或Gradle）。我们可以利用Spring Initializr来快速天生一个Spring Boot项目。
1.2 界说数据模型

假设我们有两个对象：User和Address。
  1. // User.java
  2. public class User {
  3.    private Long id;
  4.    private String name;
  6.    // Getters and Setters
  7.    public Long getId() {
  8.        return id;
  9.    }
  11.    public void setId(Long id) {
  12.        this.id = id;
  13.    }
  15.    public String getName() {
  16.        return name;
  17.    }
  19.    public void setName(String name) {
  20.        this.name = name;
  21.    }
  22. }
  24. // Address.java
  25. public class Address {
  26.    private String street;
  27.    private String city;
  28.    private String state;
  30.    // Getters and Setters
  31.    public String getStreet() {
  32.        return street;
  33.    }
  35.    public void setStreet(String street) {
  36.        this.street = street;
  37.    }
  39.    public String getCity() {
  40.        return city;
  41.    }
  43.    public void setCity(String city) {
  44.        this.city = city;
  45.    }
  47.    public String getState() {
  48.        return state;
  49.    }
  51.    public void setState(String state) {
  52.        this.state = state;
  53.    }
  54. }
复制代码
1.3 创建DTO类

创建一个DTO类来封装多个对象。
  1. // UserAddressDTO.java
  2. public class UserAddressDTO {
  3.    private User user;
  4.    private Address address;
  6.    // Getters and Setters
  7.    public User getUser() {
  8.        return user;
  9.    }
  11.    public void setUser(User user) {
  12.        this.user = user;
  13.    }
  15.    public Address getAddress() {
  16.        return address;
  17.    }
  19.    public void setAddress(Address address) {
  20.        this.address = address;
  21.    }
  22. }
复制代码
1.4 创建Controller

在Controller中编写一个端点来接收包含多个对象的哀求。
  1. // UserAddressController.java
  2. import org.springframework.web.bind.annotation.*;
  4. @RestController
  5. @RequestMapping("/api")
  6. public class UserAddressController {
  8.    @PostMapping("/user-address")
  9.    public String receiveUserAddress(@RequestBody UserAddressDTO userAddressDTO) {
  10.        User user = userAddressDTO.getUser();
  11.        Address address = userAddressDTO.getAddress();
  13.        // 处理接收到的数据，例如保存到数据库
  14.        System.out.println("User ID: " + user.getId());
  15.        System.out.println("User Name: " + user.getName());
  16.        System.out.println("Address Street: " + address.getStreet());
  17.        System.out.println("Address City: " + address.getCity());
  18.        System.out.println("Address State: " + address.getState());
  20.        return "User and Address received successfully!";
  21.    }
  22. }
复制代码
1.5 设置Spring Boot应用

确保我们的Spring Boot应用有一个主类来启动应用。
  1. // DemoApplication.java
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. @SpringBootApplication
  6. public class DemoApplication {
  8.    public static void main(String[] args) {
  9.        SpringApplication.run(DemoApplication.class, args);
  10.    }
  11. }
复制代码
1.6 编写测试哀求

我们可以利用Postman或curl来测试这个API。
（1）利用Postman


  • 打开Postman。
  • 创建一个新的POST哀求。
  • 设置URL为http://localhost:8080/api/user-address。
  • 切换到Body选项卡，选择raw和JSON。
  • 输入以下JSON数据：
  1. {
  2.    "user": {
  3.        "id": 1,
  4.        "name": "John Doe"
  5.    },
  6.    "address": {
  7.        "street": "123 Main St",
  8.        "city": "Springfield",
  9.        "state": "IL"
  10.    }
  11. }
复制代码
6.点击Send按钮。
（2）利用curl

  1. curl -X POST http://localhost:8080/api/user-address -H "Content-Type: application/json" -d '{
  2.    "user": {
  3.        "id": 1,
  4.        "name": "John Doe"
  5.    },
  6.    "address": {
  7.        "street": "123 Main St",
  8.        "city": "Springfield",
  9.        "state": "IL"
  10.    }
  11. }'
复制代码
1.7 运行应用

运行我们的Spring Boot应用，并发送测试哀求。我们应该会看到控制台输出接收到的用户和地址信息，而且API返回"User and Address received successfully!"。
1.8总结

以上示例展示了如何利用Spring Boot接收包含多个对象的HTTP哀求。通过界说数据模型、DTO类和Controller，我们可以轻松地处理复杂的哀求数据。这个示例不仅可以直接运行，还具有一定的参考价值和现实意义，可以资助我们理解如何在Java后端开辟中处理类似的需求。
2.在Spring Boot项目中创建和利用RESTful API

在Spring Boot中，利用RESTful API黑白常直观和高效的，这得益于Spring框架提供的强大支持。以下是一个渐渐指南，教我们如何在Spring Boot项目中创建和利用RESTful API。
2.1搭建Spring Boot项目

首先，我们需要一个Spring Boot项目。我们可以通过以下方式之一来创建：


  • 利用Spring Initializr网站天生项目，并下载为Maven或Gradle项目。
  • 在IDE（如IntelliJ IDEA、Eclipse或STS）中利用内置的Spring Initializr工具。
  • 手动创建一个Maven或Gradle项目，并添加必要的Spring Boot依赖。
2.2 添加依赖

对于RESTful API，我们通常需要以下依赖（假如我们利用的是Maven）：
  1. <dependencies>
  2.    <!-- Spring Boot Starter Web: 包含创建RESTful Web服务所需的所有内容 -->
  3.    <dependency>
  4.        <groupId>org.springframework.boot</groupId>
  5.        <artifactId>spring-boot-starter-web</artifactId>
  6.    </dependency>
  7.    
  8.    <!-- 其他依赖，如Spring Data JPA（用于数据库交互）、Spring Boot DevTools（用于开发时自动重启等） -->
  9.    <!-- ... -->
  10. </dependencies>
复制代码
2.3 创建Controller

Controller是处理HTTP哀求的核心组件。我们可以利用@RestController注解来创建一个RESTful Controller。
  1. import org.springframework.web.bind.annotation.*;
  3. @RestController
  4. @RequestMapping("/api/items") // 基础URL路径
  5. public class ItemController {
  7.    // 模拟的数据源
  8.    private Map<Long, Item> items = new HashMap<>();
  10.    // 创建一个新的Item（POST请求）
  11.    @PostMapping
  12.    public ResponseEntity<Item> createItem(@RequestBody Item item) {
  13.        items.put(item.getId(), item);
  14.        return ResponseEntity.ok(item);
  15.    }
  17.    // 获取所有Item（GET请求）
  18.    @GetMapping
  19.    public ResponseEntity<List<Item>> getAllItems() {
  20.        return ResponseEntity.ok(new ArrayList<>(items.values()));
  21.    }
  23.    // 根据ID获取单个Item（GET请求）
  24.    @GetMapping("/{id}")
  25.    public ResponseEntity<Item> getItemById(@PathVariable Long id) {
  26.        Item item = items.get(id);
  27.        if (item == null) {
  28.            return ResponseEntity.notFound().build();
  29.        }
  30.        return ResponseEntity.ok(item);
  31.    }
  33.    // 更新一个Item（PUT请求）
  34.    @PutMapping("/{id}")
  35.    public ResponseEntity<Item> updateItem(@PathVariable Long id, @RequestBody Item item) {
  36.        Item existingItem = items.get(id);
  37.        if (existingItem == null) {
  38.            return ResponseEntity.notFound().build();
  39.        }
  40.        existingItem.setName(item.getName());
  41.        existingItem.setDescription(item.getDescription());
  42.        return ResponseEntity.ok(existingItem);
  43.    }
  45.    // 删除一个Item（DELETE请求）
  46.    @DeleteMapping("/{id}")
  47.    public ResponseEntity<Void> deleteItem(@PathVariable Long id) {
  48.        Item item = items.remove(id);
  49.        if (item == null) {
  50.            return ResponseEntity.notFound().build();
  51.        }
  52.        return ResponseEntity.noContent().build();
  53.    }
  54. }
复制代码
2.4 创建数据模型

数据模型（也称为实体或DTO）是表现业务数据的类。
  1. public class Item {
  2.    private Long id;
  3.    private String name;
  4.    private String description;
  6.    // Getters and Setters
  7.    public Long getId() {
  8.        return id;
  9.    }
  11.    public void setId(Long id) {
  12.        this.id = id;
  13.    }
  15.    public String getName() {
  16.        return name;
  17.    }
  19.    public void setName(String name) {
  20.        this.name = name;
  21.    }
  23.    public String getDescription() {
  24.        return description;
  25.    }
  27.    public void setDescription(String description) {
  28.        this.description = description;
  29.    }
  30. }
复制代码
2.5 启动应用

确保我们的Spring Boot应用有一个包含@SpringBootApplication注解的主类。
  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class DemoApplication {
  7.    public static void main(String[] args) {
  8.        SpringApplication.run(DemoApplication.class, args);
  9.    }
  10. }
复制代码
2.6 测试API

我们可以利用Postman、curl、或其他HTTP客户端来测试我们的RESTful API。
（1）利用Postman


  • 创建一个新的哀求。
  • 选择哀求类型（GET、POST、PUT、DELETE）。
  • 输入URL（比方，http://localhost:8080/api/items）。
  • 根据需要添加哀求头、参数或正文。
  • 发送哀求并查看相应。
（2）利用curl

  1. # 创建一个新的Item
  2. curl -X POST http://localhost:8080/api/items -H "Content-Type: application/json" -d '{
  3.    "id": 1,
  4.    "name": "Item Name",
  5.    "description": "Item Description"
  6. }'
  8. # 获取所有Item
  9. curl http://localhost:8080/api/items
  11. # 根据ID获取单个Item
  12. curl http://localhost:8080/api/items/1
  14. # 更新一个Item
  15. curl -X PUT http://localhost:8080/api/items/1 -H "Content-Type: application/json" -d '{
  16.    "name": "Updated Item Name",
  17.    "description": "Updated Item Description"
  18. }'
  20. # 删除一个Item
  21. curl -X DELETE http://localhost:8080/api/items/1
复制代码
通过以上步骤，我们就可以在Spring Boot中创建和利用RESTful API了。这些API可以用于与前端应用、移动应用或其他微服务举行交互。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

吴旭华

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

集成商 AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表