🏛️⏱️ EJB ASYNC — RUN WORK IN THE BACKGROUND (SAFELY)

// 1) You write a session bean (business service)
//    The container will manage lifecycle, pooling, security, and transactions.
import jakarta.ejb.Stateless;
import jakarta.annotation.security.RolesAllowed;
import jakarta.transaction.Transactional;

@Stateless
@RolesAllowed("USER")          // security handled by container
@Transactional                 // transaction boundary handled by container
public class BillingService {

  public String charge(String customerId, int amountCents) {
    // business logic here (DB calls, etc.)
    return "Charged " + amountCents + " cents to " + customerId;
  }
}

// 2) Your web layer (Servlet here) calls the bean
//    The container injects the EJB automatically.
import jakarta.ejb.EJB;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public class BillingServlet extends HttpServlet {

  @EJB
  private BillingService billingService; // injected by container

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
    String customerId = req.getParameter("customerId");
    int amount = Integer.parseInt(req.getParameter("amountCents"));

    String result = billingService.charge(customerId, amount);

    resp.setContentType("text/plain");
    try {
      resp.getWriter().println(result);
    } catch (Exception ignored) { }
  }
}

// (Optional) CDI-style injection instead of @EJB
import jakarta.inject.Inject;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;

@Path("/billing")
public class BillingResource {

  @Inject
  BillingService billingService;

  @POST
  public String charge() {
    return billingService.charge("cust-42", 1999);
  }
}

import jakarta.ejb.Asynchronous;
import jakarta.ejb.Stateless;
import jakarta.ejb.AsyncResult;
import jakarta.enterprise.concurrent.ManagedExecutorService;
import jakarta.annotation.Resource;

import java.util.concurrent.Future;
import java.util.concurrent.CompletableFuture;

// EJB async: container-managed threads (no new Thread())
@Stateless
public class ReportService {

  // 1) Fire-and-forget ✅
  @Asynchronous
  public void generateReport(String reportId) {
    // long-running work (IO, DB, remote calls...)
    // container manages the execution thread
    System.out.println("Generating report " + reportId);
  }

  // 2) Future-based result ✅
  @Asynchronous
  public Future<String> generateReportWithStatus(String reportId) {
    // do work...
    return new AsyncResult<>("DONE:" + reportId);
  }

  // 3) CompletionStage style (common alternative in modern code) ✅
  // If your stack prefers CompletionStage, you can adapt (example).
  @Resource
  ManagedExecutorService executor;

  public CompletableFuture<String> generateReportAsync(String reportId) {
    return CompletableFuture.supplyAsync(() -> "DONE:" + reportId, executor);
  }
}

import jakarta.ejb.EJB;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.QueryParam;

import java.util.concurrent.Future;

@Path("/reports")
public class ReportResource {

  @EJB
  ReportService reportService;

  // Doesn't block: returns immediately, work continues in background
  @POST
  @Path("/fire")
  public String fireAndForget(@QueryParam("id") String id) {
    reportService.generateReport(id);
    return "Accepted: " + id;
  }

  // Optionally wait for result (not always recommended in HTTP handlers)
  @POST
  @Path("/status")
  public String withFuture(@QueryParam("id") String id) throws Exception {
    Future<String> status = reportService.generateReportWithStatus(id);
    return status.get(); // blocks until done
  }
}