Vòng đời của Servlet

02-vong-doi-servlet/
  pom.xml
  src/main/webapp/WEB-INF/web.xml       deployment descriptor tối thiểu (Servlet 6.1)
  src/main/java/dev/canhdominich/servlet/lifecycle/
    EmbeddedServer.java       dựng Tomcat nhúng, quét lớp trong target/classes
    ServerMain.java           chạy server ở cổng 8080 (đổi bằng biến PORT)
    EventLog.java             ghi và in các sự kiện vòng đời
    EventsServlet.java        trả danh sách sự kiện qua HTTP (/events)
    LifecycleServlets.java    EagerServlet (loadOnStartup=1) và LazyServlet
    CounterServlet.java       ba bộ đếm: không an toàn luồng, synchronized, AtomicInteger
    FailingInitServlet.java   hai servlet có init() ném lỗi
    MethodsServlet.java       servlet chỉ có doGet và doPost, để xem OPTIONS và HEAD
    LifecycleProbes.java      chạy toàn bộ thí nghiệm và in kết quả

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>servlet-vong-doi</artifactId>
    <version>1.0.0</version>
    <name>Servlet - Vong doi Servlet</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.servlet.lifecycle.ServerMain</main.class>
        <main.arg>none</main.arg>
        <tomcat.version>11.0.27</tomcat.version>
        <junit.version>6.0.3</junit.version>
        <assertj.version>3.27.7</assertj.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>${assertj.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.6.3</version>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                        <argument>${main.arg}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_1.xsd" version="6.1">
    <display-name>servlet-vong-doi</display-name>
</web-app>

package dev.canhdominich.servlet.lifecycle;

import java.io.File;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.webresources.DirResourceSet;
import org.apache.catalina.webresources.StandardRoot;

public final class EmbeddedServer implements AutoCloseable {

    private final Tomcat tomcat;

    private EmbeddedServer(Tomcat tomcat) {
        this.tomcat = tomcat;
    }

    public static EmbeddedServer start(int port) throws LifecycleException {
        Logger root = Logger.getLogger("");
        root.setLevel(Level.WARNING);
        for (Handler handler : root.getHandlers()) {
            handler.setLevel(Level.WARNING);
        }
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        tomcat.setPort(port);
        Connector connector = tomcat.getConnector();
        connector.setProperty("address", "127.0.0.1");
        if (System.getProperty("lab.hardenErrors") != null) {
            org.apache.catalina.valves.ErrorReportValve valve = new org.apache.catalina.valves.ErrorReportValve();
            valve.setShowReport(false);
            valve.setShowServerInfo(false);
            tomcat.getHost().getPipeline().addValve(valve);
        }
        Context context = tomcat.addWebapp("", new File("src/main/webapp").getAbsolutePath());
        if (context instanceof org.apache.catalina.core.StandardContext standard) {
            standard.setClearReferencesRmiTargets(false);
            standard.setClearReferencesThreadLocals(false);
        }
        WebResourceRoot resources = new StandardRoot(context);
        resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes", new File("target/classes").getAbsolutePath(), "/"));
        context.setResources(resources);
        tomcat.start();
        return new EmbeddedServer(tomcat);
    }

    public int port() {
        return tomcat.getConnector().getLocalPort();
    }

    public Tomcat tomcat() {
        return tomcat;
    }

    @Override
    public void close() throws LifecycleException {
        tomcat.stop();
        tomcat.destroy();
    }
}

package dev.canhdominich.servlet.lifecycle;

import org.apache.catalina.LifecycleException;

public final class ServerMain {

    private ServerMain() {
    }

    public static void main(String[] args) throws LifecycleException {
        int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
        EmbeddedServer server = EmbeddedServer.start(port);
        System.out.println("Listening on http://localhost:" + server.port() + "/life/eager");
        server.tomcat().getServer().await();
    }
}

package dev.canhdominich.servlet.lifecycle;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class EventLog {

    private static final List<String> EVENTS = Collections.synchronizedList(new ArrayList<>());

    private EventLog() {
    }

    public static void record(String event) {
        EVENTS.add(event);
        System.out.println("  event: " + event);
    }

    public static List<String> snapshot() {
        synchronized (EVENTS) {
            return new ArrayList<>(EVENTS);
        }
    }

    public static void clear() {
        EVENTS.clear();
    }
}

package dev.canhdominich.servlet.lifecycle;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

public final class LifecycleServlets {

    private LifecycleServlets() {
    }

    abstract static class Recording extends HttpServlet {

        @Override
        public void init() {
            EventLog.record(getClass().getSimpleName() + ".init() on " + Thread.currentThread().getName().replaceAll("\\d+$", "N"));
        }

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
            EventLog.record(getClass().getSimpleName() + ".doGet()");
            response.setContentType("text/plain;charset=UTF-8");
            response.getWriter().println(getClass().getSimpleName() + " served");
        }

        @Override
        public void destroy() {
            EventLog.record(getClass().getSimpleName() + ".destroy()");
        }
    }

    @WebServlet(urlPatterns = "/life/eager", loadOnStartup = 1)
    public static class EagerServlet extends Recording {
    }

    @WebServlet(urlPatterns = "/life/lazy")
    public static class LazyServlet extends Recording {
    }
}

package dev.canhdominich.servlet.lifecycle;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public final class LifecycleProbes {

    static final int INCREMENTS = 2000;

    private LifecycleProbes() {
    }

    public static void main(String[] args) throws Exception {
        System.out.println("-- starting the server");
        EmbeddedServer server = EmbeddedServer.start(0);
        HttpClient client = HttpClient.newHttpClient();
        String base = "http://127.0.0.1:" + server.port();
        System.out.println("-- server started; requests to the lazy servlet twice, then the eager servlet once");
        get(client, base + "/life/lazy");
        get(client, base + "/life/lazy");
        get(client, base + "/life/eager");
        System.out.println("-- failing init");
        System.out.println("  ordinary exception, request 1: " + status(get(client, base + "/bad-init/ordinary")));
        System.out.println("  ordinary exception, request 2: " + status(get(client, base + "/bad-init/ordinary")) + " " + get(client, base + "/bad-init/ordinary").body().trim());
        System.out.println("  UnavailableException, request 1: " + status(get(client, base + "/bad-init/unavailable")));
        System.out.println("  UnavailableException, request 2: " + status(get(client, base + "/bad-init/unavailable")));
        System.out.println("-- methods the container adds");
        HttpResponse<String> options = client.send(HttpRequest.newBuilder(URI.create(base + "/methods")).method("OPTIONS", HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.ofString());
        System.out.println("  OPTIONS /methods -> " + options.statusCode() + " Allow=" + options.headers().firstValue("Allow").orElse("none"));
        HttpResponse<String> head = client.send(HttpRequest.newBuilder(URI.create(base + "/methods")).method("HEAD", HttpRequest.BodyPublishers.noBody()).build(), HttpResponse.BodyHandlers.ofString());
        System.out.println("  HEAD /methods    -> " + head.statusCode() + " Content-Length=" + head.headers().firstValue("Content-Length").orElse("none") + " body length=" + head.body().length());
        System.out.println("-- " + INCREMENTS + " increments from 16 client threads");
        for (String kind : new String[]{"unsafe", "synchronized", "atomic"}) {
            System.out.printf("  %-12s final value %s%n", kind, hammer(client, base, kind));
        }
        System.out.println("-- stopping the server");
        server.close();
    }

    static String hammer(HttpClient client, String base, String kind) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(16);
        List<Future<?>> futures = new ArrayList<>();
        for (int i = 0; i < INCREMENTS; i++) {
            futures.add(pool.submit(() -> get(client, base + "/count/" + kind)));
        }
        for (Future<?> future : futures) {
            future.get();
        }
        pool.shutdown();
        return get(client, base + "/count/" + kind + "?peek=1").body().trim();
    }

    private static String status(HttpResponse<String> response) {
        return String.valueOf(response.statusCode());
    }

    private static HttpResponse<String> get(HttpClient client, String url) throws Exception {
        return client.send(HttpRequest.newBuilder(URI.create(url)).build(), HttpResponse.BodyHandlers.ofString());
    }
}

-- starting the server
  event: EagerServlet.init() on main
-- server started; requests to the lazy servlet twice, then the eager servlet once
  event: LazyServlet.init() on http-nio-127.0.0.1-auto-1-exec-N
  event: LazyServlet.doGet()
  event: LazyServlet.doGet()
  event: EagerServlet.doGet()
...
-- stopping the server
  event: LazyServlet.destroy()
  event: EagerServlet.destroy()

package dev.canhdominich.servlet.lifecycle;

import jakarta.servlet.ServletException;
import jakarta.servlet.UnavailableException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;

public final class FailingInitServlet {

    private static final AtomicInteger TEMPORARY_ATTEMPTS = new AtomicInteger();

    private FailingInitServlet() {
    }

    @WebServlet("/bad-init/ordinary")
    public static class Ordinary extends HttpServlet {

        @Override
        public void init() throws ServletException {
            if (TEMPORARY_ATTEMPTS.incrementAndGet() == 1) {
                throw new ServletException("database not ready yet");
            }
        }

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
            response.setContentType("text/plain;charset=UTF-8");
            response.getWriter().println("ready after " + TEMPORARY_ATTEMPTS.get() + " init attempts");
        }
    }

    @WebServlet("/bad-init/unavailable")
    public static class Unavailable extends HttpServlet {

        @Override
        public void init() throws ServletException {
            throw new UnavailableException("configuration missing");
        }

        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
            response.getWriter().println("never reached");
        }
    }
}

ordinary exception, request 1: 500
ordinary exception, request 2: 200 ready after 2 init attempts
UnavailableException, request 1: 404
UnavailableException, request 2: 404

package dev.canhdominich.servlet.lifecycle;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/methods")
public class MethodsServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/plain;charset=UTF-8");
        response.getWriter().println("hello from doGet");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/plain;charset=UTF-8");
        response.getWriter().println("hello from doPost");
    }
}

OPTIONS /methods -> 200 Allow=GET, HEAD, POST, OPTIONS
HEAD /methods    -> 200 Content-Length=17 body length=0

package dev.canhdominich.servlet.lifecycle;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;

@WebServlet({"/count/unsafe", "/count/atomic", "/count/synchronized"})
public class CounterServlet extends HttpServlet {

    private int unsafeCount;
    private int synchronizedCount;
    private final AtomicInteger atomicCount = new AtomicInteger();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String kind = request.getServletPath().substring("/count/".length());
        boolean peek = request.getParameter("peek") != null;
        int value = switch (kind) {
            case "unsafe" -> peek ? unsafeCount : incrementUnsafe();
            case "atomic" -> peek ? atomicCount.get() : atomicCount.incrementAndGet();
            default -> peek ? synchronizedCount : incrementSynchronized();
        };
        response.setContentType("text/plain;charset=UTF-8");
        response.getWriter().print(value);
    }

    private int incrementUnsafe() {
        int current = unsafeCount;
        Thread.yield();
        unsafeCount = current + 1;
        return unsafeCount;
    }

    private synchronized int incrementSynchronized() {
        int current = synchronizedCount;
        Thread.yield();
        synchronizedCount = current + 1;
        return synchronizedCount;
    }
}

-- 2000 increments from 16 client threads
  unsafe       final value 912
  synchronized final value 2000
  atomic       final value 2000

package dev.canhdominich.servlet.lifecycle;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/events")
public class EventsServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/plain;charset=UTF-8");
        for (String event : EventLog.snapshot()) {
            response.getWriter().println(event);
        }
    }
}

@Test
void webappClassesAreIsolatedFromTheLauncherClasspath() throws Exception {
    get("/life/eager");
    assertThat(get("/events").body()).contains("EagerServlet.doGet()");
    assertThat(EventLog.snapshot()).isEmpty();
}