无法构造 `` 的实例（尽管至少存在一个 Creator）：没有可从 Number 值反序列化的 Int 参数构造函数/工厂方法 (10)

Question

通过邮递员申请邮寄请求时：

我收到这样的错误/响应：

有任何想法吗？

2022-12-11 15:43:43.355 警告 20344 --- [nio-8080-exec-2] .w.s.m.s.DefaultHandlerExceptionResolver：已解决 [org.springframework.http.converter.HttpMessageNotReadableException: JSON 解析错误：无法构造实例 HogeschoolLeiden.IPRWCApp.product.ProductDto（虽然至少有一个 创建者存在）：没有 int/Int-argument 构造函数/工厂方法 从数字值 (10) 反序列化；嵌套异常是 com.fasterxml.jackson.databind.exc.MismatchedInputException: 不能 构造HogeschoolLeiden.IPRWCApp.product.ProductDto的实例 （虽然至少有一个 Creator 存在）：没有 int/Int-argument 从数字值反序列化的构造函数/工厂方法 (10) 在[来源： (org.springframework.util.StreamUtils$NonClosingInputStream);行：2， 列：16]（通过参考链： HogeschoolLeiden.IPRWCApp.orderItem.OrderItemDto["产品"])]

产品：

@Entity
@Table(name = "product")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(name = "product_name", columnDefinition = "TEXT", nullable = false, unique = true)
    private String productName;

    @Column(name = "product_photo", columnDefinition = "TEXT")
    private String productPhoto;

    @Column(name = "product_prise", columnDefinition = "INT", nullable = false)
    private int productPrise;

    @Column(name = "product_description", columnDefinition = "TEXT")
    private String productDescription;
}

产品Dto：

    @Getter
    @Setter
    public class ProductDto {
    
        private Long productId;
        private String productName;
        private String productPhoto;
        private int productPrise;
        private String productDescription;
    }

OrderItem:

@Entity
@Table(name = "ORDER_ITEM")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderItem {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(targetEntity = Product.class, fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "product", referencedColumnName = "id", updatable = false, nullable = false)
    private Product product;

    @Column(name = "quantity", nullable = false)
    private int quantity;

    @CreationTimestamp
    @Column(name = "created_at", nullable = false, updatable = false)
    private Date createdAt;

    @UpdateTimestamp
    @Column(name = "updated_at")
    private Date updatedAt;
    @ManyToOne
    @JoinColumn(name = "order_id", nullable = false)
    private Order orderCart;
}

OrderItemDto:

@Getter
@Setter
public class OrderItemDto {
    private Long id;
    private ProductDto product;
    private int quantity;
    private Date createdAt;
    private Date updatedAt;
    private Order orderCart;
}

订单（购物车）：

@Entity
@Table(name = "shopping_order")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @CreationTimestamp
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "created_at", nullable = false, updatable = false)
    private Date createdAt;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "updated_at")
    private Date updatedAt;

    @OneToMany(mappedBy = "orderCart", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @Column(name = "orderItems")
    private List<OrderItem> orderItems;
}

订购服务：

@Service
@Transactional
@RequiredArgsConstructor
@AllArgsConstructor
@Slf4j
@JsonIgnoreProperties
public class OrderService {
    @Autowired
    private OrderRepo orderRepo;

    @Autowired
    private OrderItemRepo orderItemRepo;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;

    public List<OrderItemDto> addItemToOrder(OrderItemDto orderItemDto) {
        Order order = new Order();
        log.info("Saving new order Item: {} to the database.", orderItemDto.getId());
        OrderItem orderItem = orderItemMapper.toOrderItem(orderItemDto);
        if (!order.getOrderItems().contains(orderItem)) {
            orderItem.setOrderCart(order);
            order.getOrderItems().add(orderItem);
            orderRepo.save(order);
            return orderItemMapper.toDTOs(order.getOrderItems());
        } else {
            incrementExistingItemQuantity(order, orderItem);
        }
        return orderItemMapper.toDTOs(order.getOrderItems());
    }

    private static void incrementExistingItemQuantity(Order order, OrderItem orderItem) {
        for (OrderItem existingItem: order.getOrderItems()) {
            if (orderItem.getProduct().getId().equals(existingItem.getProduct().getId())) {
                existingItem.setQuantity(
                        existingItem.getQuantity() + orderItem.getQuantity()
                );
            }
        }
    }

    public float getTotal(Order order) {
        float total = 0.0f;
        for (OrderItem orderItem:order.getOrderItems()){
            int totalProduct = orderItem.getProduct().getProductPrise() * orderItem.getQuantity();
            total += totalProduct;
        }
        return total;
    }

    public List<OrderDto> getAllOrdersDto() {
        List<Order> orderList = orderRepo.findAll();
        log.info(orderList.toString());
        return orderMapper.toDTOs(orderList);
    }

    public OrderDto getOrderDto(Long id) {
        Order order = getOrder(id);
        return orderMapper.toDTO(order);
    }

    public Order getOrder(Long id) {
        return orderRepo.findById(id).orElseThrow(()-> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    public void deleteOrder(Long id) {
        if (!orderRepo.existsById(id)) {
            throw new ResponseStatusException(
                    HttpStatus.BAD_REQUEST, "No order found with id: " + id);
        }
        orderRepo.deleteById(id);
    }
}

订单控制器：

@RestController
@RequiredArgsConstructor
@CrossOrigin
@Slf4j
@RequestMapping("/order_baskets")
public class OrderController {
    @Autowired
    public OrderService orderService;

    @GetMapping("")
    public ResponseEntity<List<OrderDto>> getAllOrders() {
        return ResponseEntity.ok().body(orderService.getAllOrdersDto());
    }

    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable long orderId) {
        return ResponseEntity.ok().body(orderService.getOrderDto(orderId));
    }

    @PostMapping("/add")
    public ResponseEntity<List<OrderItemDto>> AddOrder(@RequestBody OrderItemDto orderItemDto) {
        URI uri = URI.create(ServletUriComponentsBuilder.fromCurrentContextPath().path("/order_baskets/add").toUriString());
        return ResponseEntity.created(uri).body(orderService.addItemToOrder(orderItemDto));
    }

    @DeleteMapping("/{orderId}")
    public ResponseEntity<Void> deleteOrder(@PathVariable long orderId) {
        orderService.deleteOrder(orderId);
        return ResponseEntity.ok().build();
    }
}

Answer 1

抛出异常是因为数字 10 无法反序列化为 ProductDto 对象。

将请求正文更改为：

{
  "product": {
    "productId": 10
  },
  "quantity": 3
}