要实现new Response对象延时发送，可以采用以下几种方法

要实现new Response对象延时发送，可以采用以下几种方法：

如下springboot+vue3图片上传由于热部署需要延时发送响应：

package com.smapi.smserver_api.Upload.Controller;

import com.smapi.smserver_api.Upload.bean.Response;
import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.beans.factory.annotation.Value;

import java.io.File;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

@RestController
@RequestMapping("/upload")
/**
 * 文件控制器类，负责处理文件上传的请求。
 */
public class FileController {
   

//    private static final Logger logger = LoggerFactory.getLogger(FileController.class);

    // 从application.properties配置文件中读取上传目录
//    @Value("${file.upload-dir:classpath:/static/uploads}")
    @Value("${file.upload-dir:F:/SpringBootVue/IdeProject/SMserver_API/src/main/resources/static/uploads/}")
    private String uploadDir; // 从application.yml配置文件中读取上传目录

    /**
     * 上传头像的方法。
     * @param file 用户上传的文件
     * @return 返回文件上传后的路径
     */
    @PostMapping("/avatar")
    public Response uploadAvatar(MultipartFile file) {
   
//        logger.info("Received file for upload: {}", file.getOriginalFilename());
        try {
   
            // 生成日期格式的文件夹名，用于分类存储
            String dateFolder = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
            String basePath = uploadDir +"/" + dateFolder;
            // 确保基础文件夹存在
            File directory = new File(basePath);
            if (!directory.exists()) {
   
                directory.mkdirs();
            }
            // 定义文件命名规则，避免重复
            String originalFilename = file.getOriginalFilename();
            String extension = originalFilename.substring(originalFilename.lastIndexOf('.'));
            String fileName = System.currentTimeMillis() + extension; // 使用当前时间戳作为文件名
            // 存储文件
            File dest = new File(basePath + "/" + fileName);
            file.transferTo(dest);
            // 返回文件路径
            String baseUrl = ServletUriComponentsBuilder.fromCurrentContextPath().build().toUriString();
            String filePath = baseUrl + "/uploads" + "/" + dateFolder + "/" + fileName;
            System.out.println("返回路径：：："+filePath);
//            logger.info("File stored successfully at: {}", dest.getAbsolutePath());

            return new Response(filePath); // 返回包含文件路径的响应对象
        } catch (Exception e) {
   
            // 文件上传异常处理
//            logger.error("Error occurred while uploading file: {}", e.getMessage());
            return new Response("Upload failed: " + e.getMessage()); // 返回上传失败的响应对象
        }
    }

}

1. 使用异步框架： Spring WebFlux：

如果您正在使用Spring Boot，并希望保持非阻塞和异步响应，可以利用Spring WebFlux框架提供的Mono或Flux来延迟发送响应。将Response对象包装成Mono，并通过.delayElement(Duration.ofSeconds(15))方法使其延时发送。

   import reactor.core.publisher.Mono;
   import java.time.Duration;

   ...

   @GetMapping("/delayed-response")
   public Mono<Response> delayedResponse() {
   
       Response response = new Response(...);
       return Mono.just(response).delayElement(Duration.ofSeconds(15));
   }

Reactor/RxJava：如果您在项目中使用了Reactor或RxJava这类响应式编程库，可以类似地使用它们提供的延时操作符（如delay或delaySubscription）来实现。

2. 使用CompletableFuture：

创建一个CompletableFuture，异步执行延时任务，然后在其完成时返回Response对象。可以结合supplyAsync和thenApply方法实现。

   import java.util.concurrent.CompletableFuture;
   import java.util.concurrent.TimeUnit;

   ...

   public CompletableFuture<Response> delayedResponse() {
   
       return CompletableFuture.supplyAsync(() -> {
   
           try {
   
               TimeUnit.SECONDS.sleep(15);
           } catch (InterruptedException e) {
   
               Thread.currentThread().interrupt();
           }
           return new Response(...);
       });
   }
   

客户端需要处理返回的CompletableFuture，等待其完成以获取Response。

3. 使用ScheduledExecutorService：

创建一个ScheduledExecutorService实例，提交一个延时任务，该任务在指定时间后创建并返回Response对象。

   import java.util.concurrent.Callable;
   import java.util.concurrent.ScheduledExecutorService;
   import java.util.