[Spring Boot Basics] Các tác vụ phổ biến trong Spring Boot: upload/download file, gửi email, @Scheduled và @Async

curl -s "https://start.spring.io/starter.zip?type=gradle-project&language=java&bootVersion=4.1.1&javaVersion=21&groupId=com.example&artifactId=demo&name=demo&packageName=com.example.demo&dependencies=web,validation,data-jpa,h2,mail" -o demo.zip

dependencies {
	implementation 'org.springframework.boot:spring-boot-h2console'
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-mail'
	implementation 'org.springframework.boot:spring-boot-starter-validation'
	implementation 'org.springframework.boot:spring-boot-starter-webmvc'
	runtimeOnly 'com.h2database:h2'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-jpa-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-mail-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-validation-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

@Entity
@Table(name = "products")
public class Product {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false, unique = true, length = 32)
    private String sku;
 
    @Column(nullable = false)
    private String name;
 
    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;
 
    @Column(nullable = false)
    private int stock;
 
    private String imageFile;
 
    private String imageName;
 
    protected Product() {
    }
 
    public Product(String sku, String name, BigDecimal price, int stock) {
        this.sku = sku;
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
 
    public void attachImage(String imageFile, String imageName) {
        this.imageFile = imageFile;
        this.imageName = imageName;
    }
 
    public void removeStock(int quantity) {
        this.stock -= quantity;
    }
 
    // getters for every field
}

spring.application.name=demo
server.port=8140
spring.datasource.url=jdbc:h2:mem:catalog
spring.jpa.open-in-view=false

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
 
    private final ProductService service;
 
    public ProductController(ProductService service) {
        this.service = service;
    }
 
    @PostMapping(path = "/{id}/image", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public ProductResponse uploadImage(@PathVariable long id, @RequestParam("file") MultipartFile file) {
        log.info("part={}, originalFilename={}, contentType={}, size={}",
                file.getName(), file.getOriginalFilename(), file.getContentType(), file.getSize());
        return service.attachImage(id, file);
    }
}

@Service
public class ProductService {
 
    private final ProductRepository products;
    private final FileStorage storage;
 
    public ProductService(ProductRepository products, FileStorage storage) {
        this.products = products;
        this.storage = storage;
    }
 
    @Transactional
    public ProductResponse attachImage(long id, MultipartFile file) {
        Product product = products.findById(id).orElseThrow(() -> new ProductNotFoundException(id));
        String storedName = storage.store(file);
        product.attachImage(storedName, StringUtils.getFilename(file.getOriginalFilename()));
        return ProductResponse.from(product);
    }
}

curl -i -F "file=@Bàn phím cơ.png" http://localhost:8140/api/products/1/image

HTTP/1.1 200 
Content-Type: application/json
Content-Length: 110

{"id":1,"sku":"KB-001","name":"Mechanical keyboard","price":89.90,"stock":12,"imageName":"Bàn phím cơ.png"}

15:54:44.485  INFO [nio-8140-exec-1] c.e.demo.product.ProductController       : part=file, originalFilename=Bàn phím cơ.png, contentType=image/png, size=316

    @PostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public ResponseEntity<ProductResponse> create(@RequestPart("product") @Valid CreateProductRequest request,
                                                  @RequestPart("image") MultipartFile image) {
        ProductResponse created = service.create(request, image);
        return ResponseEntity.created(URI.create("/api/products/" + created.id())).body(created);
    }

public record CreateProductRequest(
        @NotBlank String sku,
        @NotBlank String name,
        @NotNull @Positive BigDecimal price,
        @PositiveOrZero int stock) {
}

curl -i -F 'product={"sku":"HS-003","name":"Gaming headset","price":59.00,"stock":4};type=application/json' \
     -F "image=@keyboard.png" http://localhost:8140/api/products

HTTP/1.1 201 
Location: /api/products/3
Content-Type: application/json

{"id":3,"sku":"HS-003","name":"Gaming headset","price":59.00,"stock":4,"imageName":"keyboard.png"}

HTTP/1.1 415 
Accept: application/json, application/*+json
Content-Type: application/problem+json

{"detail":"Content-Type 'application/octet-stream' is not supported.","instance":"/api/products","status":415,"title":"Unsupported Media Type"}

{"detail":"Request has 2 invalid value(s).","instance":"/api/products","status":422,"title":"Unprocessable Content","errors":[{"field":"price","message":"must be greater than 0"},{"field":"sku","message":"must not be blank"}]}

@ConfigurationProperties("app.storage")
public record StorageProperties(Path location, Set<String> allowedContentTypes) {
}

app.storage.location=uploads/images
app.storage.allowed-content-types=image/png,image/jpeg

@Service
public class FileStorage {
 
    private static final Logger log = LoggerFactory.getLogger(FileStorage.class);
 
    private final Path root;
 
    public FileStorage(StorageProperties properties) throws IOException {
        this.root = properties.location().toAbsolutePath().normalize();
        Files.createDirectories(root);
    }
 
    public String store(MultipartFile file) {
        Path target = root.resolve(file.getOriginalFilename());
        log.info("Writing {}", target);
        try (InputStream in = file.getInputStream()) {
            Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
        return file.getOriginalFilename();
    }
 
    public Resource load(String storedName) {
        Path path = root.resolve(storedName);
        if (!Files.isReadable(path)) {
            throw new StoredFileNotFoundException("File " + storedName + " does not exist.");
        }
        return new FileSystemResource(path);
    }
}

curl -F "file=@notes.txt;filename=../../evil.txt" http://localhost:8140/api/products/2/image

15:54:44.543  INFO [nio-8140-exec-2] c.e.demo.product.ProductController       : part=file, originalFilename=../../evil.txt, contentType=text/plain, size=16
15:54:44.544  INFO [nio-8140-exec-2] com.example.demo.storage.FileStorage     : Writing /…/demo/uploads/images/../../evil.txt

    public String store(MultipartFile file) {
        Path target = root.resolve(file.getOriginalFilename()); 
        Path target = resolve(file.getOriginalFilename()); 
        log.info("Writing {}", target);
        // copy as before
    }
 
    public Resource load(String storedName) {
        Path path = root.resolve(storedName); 
        Path path = resolve(storedName); 
        // as before
    }
 
    private Path resolve(String name) { 
        Path target = root.resolve(name).normalize(); 
        if (!target.startsWith(root)) { 
            throw new InvalidFileException(HttpStatus.BAD_REQUEST, "Invalid file name: " + name); 
        } 
        return target; 
    } 

public class InvalidFileException extends ErrorResponseException {
 
    public InvalidFileException(HttpStatus status, String detail) {
        super(status, ProblemDetail.forStatusAndDetail(status, detail), null);
    }
}

{"detail":"Invalid file name: ../../evil.txt","instance":"/api/products/2/image","status":400,"title":"Bad Request"}

{"detail":"Invalid file name: /…/abs-evil.txt","instance":"/api/products/2/image","status":400,"title":"Bad Request"}

../../evil.txt         resolve=/srv/app/uploads/../../evil.txt  normalize=/srv/evil.txt              Path.startsWith=false String.startsWith=false
/etc/passwd            resolve=/etc/passwd                      normalize=/etc/passwd                Path.startsWith=false String.startsWith=false
../uploads-old/x.png   resolve=/srv/app/uploads/../uploads-old/x.png normalize=/srv/app/uploads-old/x.png Path.startsWith=false String.startsWith=true
a/../b.png             resolve=/srv/app/uploads/a/../b.png      normalize=/srv/app/uploads/b.png     Path.startsWith=true  String.startsWith=true

@Service
public class FileStorage {
 
    private static final Logger log = LoggerFactory.getLogger(FileStorage.class); 
 
    private final Path root;
    private final Set<String> allowedContentTypes; 
 
    public FileStorage(StorageProperties properties) throws IOException {
        this.root = properties.location().toAbsolutePath().normalize();
        this.allowedContentTypes = properties.allowedContentTypes(); 
        Files.createDirectories(root);
    }
 
    public String store(MultipartFile file) {
        if (file.isEmpty()) { 
            throw new InvalidFileException(HttpStatus.UNPROCESSABLE_CONTENT, "The file is empty."); 
        } 
        String contentType = file.getContentType(); 
        if (contentType == null || !allowedContentTypes.contains(contentType)) { 
            throw new InvalidFileException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, 
                    "Content type " + contentType + " is not accepted, use one of " + allowedContentTypes + "."); 
        } 
        String storedName = UUID.randomUUID() + "." + MediaType.parseMediaType(contentType).getSubtype(); 
        Path target = resolve(file.getOriginalFilename()); 
        log.info("Writing {}", target); 
        Path target = resolve(storedName); 
        try (InputStream in = file.getInputStream()) {
            Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING); 
            Files.copy(in, target); 
        } catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
        return file.getOriginalFilename(); 
        return storedName; 
    }
 
    // load(…) and resolve(…) unchanged
}

curl -i -F "file=@big-2mb.png" http://localhost:8140/api/products/1/image

HTTP/1.1 100 
 
HTTP/1.1 413 
Content-Length: 0
Date: Wed, 16 Sep 2026 08:55:21 GMT
Connection: close

15:55:35.513 DEBUG [nio-8140-exec-1] o.s.web.servlet.DispatcherServlet        : POST "/api/products/1/image", parameters={multipart}
15:55:35.530 DEBUG [nio-8140-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Exception [org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException: The field file exceeds its maximum permitted size of 1048576 bytes.] occurred parsing parts and will be thrown
15:55:35.532  WARN [nio-8140-exec-1] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.multipart.MaxUploadSizeExceededException: Maximum upload size exceeded]
15:55:35.532 DEBUG [nio-8140-exec-1] o.s.web.servlet.DispatcherServlet        : Completed 413 CONTENT_TOO_LARGE
15:55:35.534 DEBUG [nio-8140-exec-1] o.s.web.servlet.DispatcherServlet        : "ERROR" dispatch for GET "/error", parameters={multipart}
15:55:35.534 DEBUG [nio-8140-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Exception [org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException: The field file exceeds its maximum permitted size of 1048576 bytes.] occurred parsing parts and will be thrown
15:55:35.534  WARN [nio-8140-exec-1] .w.s.m.s.DefaultHandlerExceptionResolver : Resolved [org.springframework.web.multipart.MaxUploadSizeExceededException: Maximum upload size exceeded]
15:55:35.534 DEBUG [nio-8140-exec-1] o.s.web.servlet.DispatcherServlet        : Exiting from "ERROR" dispatch, status 413

HTTP/1.1 413 
Content-Type: application/problem+json
Connection: close

{"detail":"Maximum upload size exceeded","instance":"/api/products/1/image","status":413,"title":"Content Too Large"}

@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
    private final MultipartProperties multipart; 
 
    public GlobalExceptionHandler(MultipartProperties multipart) { 
        this.multipart = multipart; 
    } 
 
    @Override
    protected ResponseEntity<Object> handleMaxUploadSizeExceededException(MaxUploadSizeExceededException ex, 
            HttpHeaders headers, HttpStatusCode status, WebRequest request) { 
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.CONTENT_TOO_LARGE, 
                "A file may be at most " + multipart.getMaxFileSize().toMegabytes() + " MB and a request at most "
                        + multipart.getMaxRequestSize().toMegabytes() + " MB."); 
        problem.setTitle("Upload too large"); 
        return handleExceptionInternal(ex, problem, headers, HttpStatus.CONTENT_TOO_LARGE, request); 
    } 
 
    // handlers for ProductNotFoundException (404), StoredFileNotFoundException (404),
    // the 422 override and the catch-all, as in article 20
}

    @GetMapping("/{id}/image")
    public ResponseEntity<Resource> downloadImage(@PathVariable long id) {
        ProductImage image = service.loadImage(id);
        MediaType contentType = MediaTypeFactory.getMediaType(image.resource())
                .orElse(MediaType.APPLICATION_OCTET_STREAM);
        ContentDisposition disposition = ContentDisposition.attachment()
                .filename(image.fileName(), StandardCharsets.UTF_8)
                .build();
        return ResponseEntity.ok()
                .contentType(contentType)
                .header(HttpHeaders.CONTENT_DISPOSITION, disposition.toString())
                .body(image.resource());
    }

    @Transactional(readOnly = true)
    public ProductImage loadImage(long id) {
        Product product = products.findById(id).orElseThrow(() -> new ProductNotFoundException(id));
        if (product.getImageFile() == null) {
            throw new StoredFileNotFoundException("Product " + id + " has no image.");
        }
        return new ProductImage(storage.load(product.getImageFile()), product.getImageName());
    }

curl -s -D - -o /dev/null http://localhost:8140/api/products/1/image

HTTP/1.1 200 
Content-Disposition: attachment; filename="Ban phim co.png"; filename*=UTF-8''B%C3%A0n%20ph%C3%ADm%20c%C6%A1.png
Accept-Ranges: bytes
Content-Type: image/png
Content-Length: 316

    @ExceptionHandler(StoredFileNotFoundException.class)
    public ProblemDetail handleFileNotFound(StoredFileNotFoundException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
        problem.setTitle("File not found");
        return problem;
    }

HTTP/1.1 404 
Content-Type: application/problem+json

{"detail":"File 5680249c-bf06-4ada-a8d3-d7054abb31af.png does not exist.","instance":"/api/products/2/image","status":404,"title":"File not found"}

curl -s -D - -o part.bin -H "Range: bytes=0-9" http://localhost:8140/api/products/1/image

HTTP/1.1 206 
Content-Disposition: attachment; filename="Ban phim co.png"; filename*=UTF-8''B%C3%A0n%20ph%C3%ADm%20c%C6%A1.png
Accept-Ranges: bytes
Content-Range: bytes 0-9/316
Content-Type: image/png
Content-Length: 10

docker run -d --name mailpit -p 11025:1025 -p 18025:8025 axllent/mailpit:v1.31.1

@Component
public class LowStockJob {
 
    private static final Logger log = LoggerFactory.getLogger(LowStockJob.class);
 
    private final ProductRepository products;
    private final JavaMailSender mailSender;
 
    public LowStockJob(ProductRepository products, JavaMailSender mailSender) {
        this.products = products;
        this.mailSender = mailSender;
    }
 
    @Scheduled(cron = "${app.jobs.low-stock.cron}", zone = "Asia/Ho_Chi_Minh")
    public void reportLowStock() {
        List<Product> lowStock = products.findByStockLessThanOrderBySku(5);
        log.info("Low-stock check: {} product(s) below 5", lowStock.size());
        if (lowStock.isEmpty()) {
            return;
        }
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("catalogue@example.com");
        message.setTo("ops@example.com");
        message.setSubject("Low stock: " + lowStock.size() + " product(s)");
        message.setText(lowStock.stream()
                .map(p -> p.getSku() + " " + p.getName() + ": " + p.getStock() + " left")
                .collect(Collectors.joining("\n")));
        mailSender.send(message);
    }
}

curl -s http://localhost:18025/api/v1/messages
curl -s http://localhost:18025/api/v1/message/4kbQLSc06KEf7nNWVykDGR/raw

Return-Path: <catalogue@example.com>
Received: from localhost (unknown [192.168.65.1])
        by d7e2d646a04e (Mailpit) with SMTP
        for <ops@example.com>; Wed, 16 Sep 2026 08:59:00 +0000 (UTC)
Date: Wed, 16 Sep 2026 15:59:00 +0700 (ICT)
From: catalogue@example.com
To: ops@example.com
Message-ID: <380803817.1.1789549140036@localhost>
Subject: Low stock: 2 product(s)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 7bit
 
HS-003 Gaming headset: 4 left
MS-002 Wireless mouse: 3 left

@Service
public class OrderMailer {
 
    private static final Logger log = LoggerFactory.getLogger(OrderMailer.class);
 
    private final JavaMailSender mailSender;
 
    public OrderMailer(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }
 
    public void sendConfirmation(OrderConfirmation order) {
        log.info("Sending confirmation for order {}", order.orderId());
        mailSender.send(message -> {
            MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
            helper.setFrom("shop@example.com");
            helper.setTo(order.customerEmail());
            helper.setSubject("Xác nhận đơn hàng #" + order.orderId());
            helper.setText(plainText(order), html(order));
            String csv = "order,product,quantity,total\n" + order.orderId() + "," + order.productName()
                    + "," + order.quantity() + "," + order.total() + "\n";
            helper.addAttachment("Đơn hàng " + order.orderId() + ".csv",
                    new ByteArrayResource(csv.getBytes(StandardCharsets.UTF_8)), "text/csv");
        });
        log.info("Confirmation for order {} sent", order.orderId());
    }
 
    private static String plainText(OrderConfirmation order) {
        return "Cảm ơn bạn đã đặt hàng.\nĐơn hàng #%d: %d x %s\nTổng cộng: %s USD\n"
                .formatted(order.orderId(), order.quantity(), order.productName(), order.total());
    }
 
    private static String html(OrderConfirmation order) {
        return "<h1>Cảm ơn bạn đã đặt hàng</h1><p>Đơn hàng <b>#%d</b>: %d x %s</p><p>Tổng cộng: <b>%s USD</b></p>"
                .formatted(order.orderId(), order.quantity(), HtmlUtils.htmlEscape(order.productName()), order.total());
    }
}

    @Transactional
    public OrderResponse place(PlaceOrderRequest request) {
        Product product = products.findById(request.productId())
                .orElseThrow(() -> new ProductNotFoundException(request.productId()));
        product.removeStock(request.quantity());
        BigDecimal total = product.getPrice().multiply(BigDecimal.valueOf(request.quantity()));
        Order order = orders.save(new Order(request.customerEmail(), product, request.quantity(), total));
        mailer.sendConfirmation(new OrderConfirmation(order.getId(), order.getCustomerEmail(),
                product.getName(), order.getQuantity(), total));
        return OrderResponse.from(order);
    }

Date: Wed, 16 Sep 2026 15:59:28 +0700 (ICT)
From: shop@example.com
To: lan@example.com
Message-ID: <1610773479.5.1789549168187@localhost>
Subject: =?UTF-8?Q?X=C3=A1c_nh=E1=BA=ADn_=C4=91=C6=A1n_h=C3=A0ng_#1?=
MIME-Version: 1.0
Content-Type: multipart/mixed; 
	boundary="----=_Part_2_394136627.1789549168128"
 
------=_Part_2_394136627.1789549168128
Content-Type: multipart/related; 
	boundary="----=_Part_3_1015054981.1789549168129"
 
------=_Part_3_1015054981.1789549168129
Content-Type: multipart/alternative; 
	boundary="----=_Part_4_1919655689.1789549168136"
 
------=_Part_4_1919655689.1789549168136
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
 
C=E1=BA=A3m =C6=A1n b=E1=BA=A1n =C4=91=C3=A3 =C4=91=E1=BA=B7t h=C3=A0ng.
=C4=90=C6=A1n h=C3=A0ng #1: 2 x Mechanical keyboard
T=E1=BB=95ng c=E1=BB=99ng: 179.80 USD
 
------=_Part_4_1919655689.1789549168136
Content-Type: text/html;charset=UTF-8
Content-Transfer-Encoding: quoted-printable
 
<h1>C=E1=BA=A3m =C6=A1n b=E1=BA=A1n =C4=91=C3=A3 =C4=91=E1=BA=B7t h=C3=A0ng=
</h1><p>=C4=90=C6=A1n h=C3=A0ng <b>#1</b>: 2 x Mechanical keyboard</p><p>T=
=E1=BB=95ng c=E1=BB=99ng: <b>179.80 USD</b></p>
------=_Part_4_1919655689.1789549168136--
 
------=_Part_3_1015054981.1789549168129--
 
------=_Part_2_394136627.1789549168128
Content-Type: text/csv; charset=us-ascii; 
	name*=UTF-8''%C4%90%C6%A1n%20h%C3%A0ng%201.csv
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment; 
	filename*=UTF-8''%C4%90%C6%A1n%20h%C3%A0ng%201.csv
 
order,product,quantity,total
1,Mechanical keyboard,2,179.80
 
------=_Part_2_394136627.1789549168128--

{"detail":"An unexpected error occurred.","instance":"/api/orders","status":500,"title":"Internal Server Error"}

15:59:46.219 ERROR [io-8140-exec-10] c.e.demo.common.GlobalExceptionHandler   : Unhandled exception on POST /api/orders
 
org.springframework.mail.MailSendException: Mail server connection failed. Failed messages: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: localhost, 11025; timeout -1;
  nested exception is:
	java.net.ConnectException: Connection refused; message exceptions (1) are:
Failed message 1: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: localhost, 11025; timeout -1;
  nested exception is:
	java.net.ConnectException: Connection refused

curl -s --max-time 30 -H "Content-Type: application/json" \
     -d '{"customerEmail":"lan@example.com","productId":2,"quantity":1}' http://localhost:8140/api/orders

"http-nio-8140-exec-7" #46 [37635] daemon prio=5 os_prio=31 cpu=91.80ms elapsed=139.42s tid=0x0000000813d21c00 nid=37635 runnable  [0x0000000172e3b000]
   java.lang.Thread.State: RUNNABLE
	…
	at org.eclipse.angus.mail.smtp.SMTPTransport.readServerResponse(SMTPTransport.java:2500)
	at org.eclipse.angus.mail.smtp.SMTPTransport.openServer(SMTPTransport.java:2205)
	at org.eclipse.angus.mail.smtp.SMTPTransport.protocolConnect(SMTPTransport.java:729)
	…
	at org.springframework.mail.javamail.JavaMailSenderImpl.connectTransport(JavaMailSenderImpl.java:467)
	at org.springframework.mail.javamail.JavaMailSenderImpl.doSend(JavaMailSenderImpl.java:386)
	…
	at com.example.demo.order.OrderMailer.sendConfirmation(OrderMailer.java:26)

org.springframework.mail.MailSendException: Mail server connection failed. Failed messages: jakarta.mail.MessagingException: Exception reading response;
  nested exception is:
	java.net.SocketTimeoutException: Read timed out; message exceptions (1) are:

@Configuration
@EnableScheduling
public class TaskConfig {
}

@Component
@Profile("schedule-lab")
public class ScheduleLab {
 
    private static final Logger log = LoggerFactory.getLogger(ScheduleLab.class);
 
    @Scheduled(fixedRate = 5, timeUnit = TimeUnit.SECONDS)
    public void publishStats() {
        log.info("publishStats (fixedRate 5 s)");
    }
 
    @Scheduled(fixedDelay = 5000, initialDelay = 2000)
    public void cleanUpOrphanImages() {
        log.info("cleanUpOrphanImages (fixedDelay 5 s, initialDelay 2 s)");
    }
 
    @Scheduled(cron = "*/10 * * * * *", zone = "Asia/Ho_Chi_Minh")
    public void everyTenSeconds() {
        log.info("everyTenSeconds (cron */10)");
    }
}

16:07:24.219  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : publishStats (fixedRate 5 s)
16:07:24.224  INFO [           main] com.example.demo.DemoApplication         : Started DemoApplication in 2.08 seconds (process running for 2.382)
16:07:26.222  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : cleanUpOrphanImages (fixedDelay 5 s, initialDelay 2 s)
16:07:29.219  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : publishStats (fixedRate 5 s)
16:07:30.006  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : everyTenSeconds (cron */10)
16:07:31.222  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : cleanUpOrphanImages (fixedDelay 5 s, initialDelay 2 s)
16:07:34.222  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : publishStats (fixedRate 5 s)
16:07:36.223  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : cleanUpOrphanImages (fixedDelay 5 s, initialDelay 2 s)
16:07:39.220  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : publishStats (fixedRate 5 s)
16:07:40.004  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : everyTenSeconds (cron */10)
16:07:41.228  INFO [   scheduling-1] com.example.demo.lab.ScheduleLab         : cleanUpOrphanImages (fixedDelay 5 s, initialDelay 2 s)

app.jobs.low-stock.cron=0 0 7 * * *

@Component
@Profile("slow-lab")
public class SlowLab {
 
    private static final Logger log = LoggerFactory.getLogger(SlowLab.class);
 
    @Scheduled(fixedRate = 2000)
    public void heartbeat() {
        log.info("heartbeat");
    }
 
    @Scheduled(fixedDelay = 60000, initialDelay = 3000)
    public void rebuildSearchIndex() throws InterruptedException {
        log.info("rebuildSearchIndex started");
        Thread.sleep(7000);
        log.info("rebuildSearchIndex finished");
    }
}

16:07:51.025  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:07:53.028  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:07:54.025  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : rebuildSearchIndex started
16:08:01.026  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : rebuildSearchIndex finished
16:08:01.026  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:01.026  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:01.026  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:01.026  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:03.024  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat

16:08:14.071  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:15.069  INFO [   scheduling-2] com.example.demo.lab.SlowLab             : rebuildSearchIndex started
16:08:16.071  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:18.072  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:20.071  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:22.072  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat
16:08:22.074  INFO [   scheduling-2] com.example.demo.lab.SlowLab             : rebuildSearchIndex finished
16:08:24.073  INFO [   scheduling-1] com.example.demo.lab.SlowLab             : heartbeat

@Component
@Profile("overrun-lab")
public class OverrunLab {
 
    private static final Logger log = LoggerFactory.getLogger(OverrunLab.class);
 
    private int run;
 
    @Scheduled(fixedRate = 1000)
    public void syncPrices() throws InterruptedException {
        int current = ++run;
        log.info("syncPrices run {} started", current);
        Thread.sleep(2500);
        log.info("syncPrices run {} finished", current);
    }
}

16:08:32.343  INFO [   scheduling-1] com.example.demo.lab.OverrunLab          : syncPrices run 1 started
16:08:34.848  INFO [   scheduling-1] com.example.demo.lab.OverrunLab          : syncPrices run 1 finished
16:08:34.849  INFO [   scheduling-2] com.example.demo.lab.OverrunLab          : syncPrices run 2 started
16:08:37.352  INFO [   scheduling-2] com.example.demo.lab.OverrunLab          : syncPrices run 2 finished
16:08:37.353  INFO [   scheduling-2] com.example.demo.lab.OverrunLab          : syncPrices run 3 started
16:08:39.857  INFO [   scheduling-2] com.example.demo.lab.OverrunLab          : syncPrices run 3 finished
16:08:39.858  INFO [   scheduling-2] com.example.demo.lab.OverrunLab          : syncPrices run 4 started

@Component
@Profile("error-lab")
public class ErrorLab {
 
    private static final Logger log = LoggerFactory.getLogger(ErrorLab.class);
 
    private int run;
 
    @Scheduled(fixedRate = 3000)
    public void importSupplierFeed() {
        run++;
        log.info("importSupplierFeed run {}", run);
        if (run == 2) {
            throw new IllegalStateException("Supplier feed returned 503");
        }
    }
}

16:07:24.219  INFO [   scheduling-1] com.example.demo.lab.ErrorLab            : importSupplierFeed run 1
16:07:27.219  INFO [   scheduling-1] com.example.demo.lab.ErrorLab            : importSupplierFeed run 2
16:07:27.219 ERROR [   scheduling-1] o.s.s.s.TaskUtils$LoggingErrorHandler    : Unexpected error occurred in scheduled task
 
java.lang.IllegalStateException: Supplier feed returned 503
	at com.example.demo.lab.ErrorLab.importSupplierFeed(ErrorLab.java:22) ~[!/:0.0.1-SNAPSHOT]
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103) ~[na:na]
	at java.base/java.lang.reflect.Method.invoke(Method.java:580) ~[na:na]
	at org.springframework.scheduling.support.ScheduledMethodRunnable.runInternal(ScheduledMethodRunnable.java:128) ~[spring-context-7.0.9.jar!/:7.0.9]
16:07:30.219  INFO [   scheduling-1] com.example.demo.lab.ErrorLab            : importSupplierFeed run 3
16:07:33.217  INFO [   scheduling-1] com.example.demo.lab.ErrorLab            : importSupplierFeed run 4

@Configuration
@EnableScheduling
@EnableAsync
public class TaskConfig {
}

>>> applicationTaskExecutor: org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor, aliases [bootstrapExecutor], TaskExecutor beans [applicationTaskExecutor, taskScheduler]
>>> core=8 max=2147483647 queueCapacity=2147483647 keepAlive=60s prefix=task- queue=LinkedBlockingQueue

@Service
public class CatalogueExporter {
 
    private static final Logger log = LoggerFactory.getLogger(CatalogueExporter.class);
 
    private final ProductRepository products;
 
    public CatalogueExporter(ProductRepository products) {
        this.products = products;
    }
 
    @Async
    public void exportCatalogue() {
        log.info("Exporting {} products", products.count());
    }
 
    @Async
    public CompletableFuture<BigDecimal> stockValue() {
        BigDecimal value = products.findAll().stream()
                .map(p -> p.getPrice().multiply(BigDecimal.valueOf(p.getStock())))
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        log.info("Stock value computed");
        return CompletableFuture.completedFuture(value);
    }
}

        log.info("calling exportCatalogue()");
        exporter.exportCatalogue();
        log.info("exportCatalogue() returned");
 
        CompletableFuture<BigDecimal> value = exporter.stockValue();
        log.info("stockValue() returned {}", value);
        log.info("stock value = {}", value.join());

16:10:05.031  INFO [           main] com.example.demo.lab.AsyncLab            : calling exportCatalogue()
16:10:05.031  INFO [           main] com.example.demo.lab.AsyncLab            : exportCatalogue() returned
16:10:05.032  INFO [           main] com.example.demo.lab.AsyncLab            : stockValue() returned java.util.concurrent.CompletableFuture@758e6acd[Not completed]
16:10:05.091  INFO [         task-2] c.e.demo.product.CatalogueExporter       : Stock value computed
16:10:05.091  INFO [           main] com.example.demo.lab.AsyncLab            : stock value = 1152.30
16:10:05.146  INFO [         task-1] c.e.demo.product.CatalogueExporter       : Exporting 2 products

    public void nightlyExport() {
        log.info("nightlyExport calls exportCatalogue()");
        exportCatalogue();
    }

16:10:05.397  INFO [           main] c.e.demo.product.CatalogueExporter       : nightlyExport calls exportCatalogue()
16:10:05.401  INFO [           main] c.e.demo.product.CatalogueExporter       : Exporting 2 products

    @Async
    public void exportToFtp() {
        log.info("Uploading the export to FTP");
        throw new IllegalStateException("FTP server refused the upload");
    }
 
    @Async
    public CompletableFuture<BigDecimal> stockValueFromWarehouse() {
        log.info("Asking the warehouse for the stock value");
        throw new IllegalStateException("Warehouse API timed out");
    }

        exporter.exportToFtp();
        Thread.sleep(300);
 
        BigDecimal fallback = exporter.stockValueFromWarehouse()
                .exceptionally(ex -> {
                    log.warn("exceptionally received {}", ex.toString());
                    return BigDecimal.ZERO;
                })
                .join();
        log.info("fallback = {}", fallback);
        try {
            exporter.stockValueFromWarehouse().join();
        } catch (CompletionException ex) {
            log.warn("join() threw {}", ex.toString());
        }

16:10:05.707  INFO [         task-3] c.e.demo.product.CatalogueExporter       : Uploading the export to FTP
16:10:05.709 ERROR [         task-3] .a.i.SimpleAsyncUncaughtExceptionHandler : Unexpected exception occurred invoking async method: public void com.example.demo.product.CatalogueExporter.exportToFtp()
 
java.lang.IllegalStateException: FTP server refused the upload
	at com.example.demo.product.CatalogueExporter.exportToFtp(CatalogueExporter.java:44) ~[!/:0.0.1-SNAPSHOT]
16:10:06.010  INFO [         task-4] c.e.demo.product.CatalogueExporter       : Asking the warehouse for the stock value
16:10:06.011  WARN [           main] com.example.demo.lab.AsyncLab            : exceptionally received java.util.concurrent.CompletionException: java.lang.IllegalStateException: Warehouse API timed out
16:10:06.011  INFO [           main] com.example.demo.lab.AsyncLab            : fallback = 0
16:10:06.011  INFO [         task-5] c.e.demo.product.CatalogueExporter       : Asking the warehouse for the stock value
16:10:06.012  WARN [           main] com.example.demo.lab.AsyncLab            : join() threw java.util.concurrent.CompletionException: java.lang.IllegalStateException: Warehouse API timed out

    @Async
    public void sendConfirmation(OrderConfirmation order) {
        log.info("Sending confirmation for order {}", order.orderId());

15:59:28.119  INFO [nio-8140-exec-4] com.example.demo.order.OrderMailer       : Sending confirmation for order 1
16:10:45.549  INFO [         task-7] com.example.demo.order.OrderMailer       : Sending confirmation for order 9

16:10:45.549  INFO [         task-7] com.example.demo.order.OrderMailer       : Sending confirmation for order 9
16:10:50.553 ERROR [         task-7] .a.i.SimpleAsyncUncaughtExceptionHandler : Unexpected exception occurred invoking async method: public void com.example.demo.order.OrderMailer.sendConfirmation(com.example.demo.order.OrderConfirmation)
 
org.springframework.mail.MailSendException: Mail server connection failed. Failed messages: jakarta.mail.MessagingException: Exception reading response;
  nested exception is:
	java.net.SocketTimeoutException: Read timed out; message exceptions (1) are: