Controller, Mapping và tham số request

02-controller-va-tham-so/
  pom.xml
  src/main/java/dev/canhdominich/spring/mvc/
    Trace.java, EmbeddedServer.java, ServerMain.java   như bài trước (không còn filter)
    Registration.java           đối tượng nhận dữ liệu form
    StudentDto.java             record dùng cho JSON
    PageController.java         @Controller: đường dẫn, tham số, form, header, view
    ApiController.java          @RestController: JSON, ResponseEntity, consumes và produces
    ExceptionSpy.java           ghi tên ngoại lệ mà Spring ném ra, không xử lý nó
    WebConfig.java              @EnableWebMvc, view resolver, gắn ExceptionSpy
    ParamsDemo.java             gửi mười chín yêu cầu và in kết quả
  src/main/webapp/WEB-INF/views/
    students.jsp                view của /pages/view

<?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>spring-mvc-controller-params</artifactId>
    <version>1.0.0</version>
    <name>Spring MVC - Controller va tham so</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <maven.compiler.parameters>true</maven.compiler.parameters>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.spring.mvc.ServerMain</main.class>
        <spring.version>7.0.9</spring.version>
        <tomcat.version>11.0.27</tomcat.version>
        <jackson.version>3.2.3</jackson.version>
        <jstl.api.version>3.0.2</jstl.api.version>
        <jstl.impl.version>3.0.1</jstl.impl.version>
        <junit.version>6.0.3</junit.version>
        <assertj.version>3.27.7</assertj.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>tools.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <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>jakarta.servlet.jsp.jstl</groupId>
            <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
            <version>${jstl.api.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>jakarta.servlet.jsp.jstl</artifactId>
            <version>${jstl.impl.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>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.spring.mvc;

public class Registration {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package dev.canhdominich.spring.mvc;

public record StudentDto(Integer id, String name) {
}

package dev.canhdominich.spring.mvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/pages")
public class PageController {

    @GetMapping("/students/new")
    @ResponseBody
    public String form() {
        return "form for a new student";
    }

    @GetMapping("/students/{id}")
    @ResponseBody
    public String student(@PathVariable int id) {
        return "student " + id;
    }

    @GetMapping("/products/{sku}/reviews/{id}")
    @ResponseBody
    public String review(@PathVariable String sku, @PathVariable int id) {
        return "review " + id + " of " + sku;
    }

    @GetMapping("/search")
    @ResponseBody
    public String search(@RequestParam String q, @RequestParam(defaultValue = "1") int page) {
        return "q=" + q + " page=" + page;
    }

    @PostMapping("/register")
    @ResponseBody
    public String register(@ModelAttribute Registration registration) {
        return "registered " + registration.getName() + " aged " + registration.getAge();
    }

    @GetMapping("/trace")
    @ResponseBody
    public String trace(@RequestHeader(value = "X-Trace", defaultValue = "none") String trace) {
        return "trace=" + trace;
    }

    @GetMapping("/view")
    public String view(Model model) {
        model.addAttribute("title", "Danh sach sinh vien");
        return "students";
    }
}

package dev.canhdominich.spring.mvc;

import java.net.URI;
import java.util.List;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/students")
public class ApiController {

    @GetMapping
    public List<StudentDto> all() {
        return List.of(new StudentDto(1, "An"), new StudentDto(2, "Binh"));
    }

    @GetMapping("/{id}")
    public ResponseEntity<StudentDto> one(@PathVariable int id) {
        if (id > 2) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(new StudentDto(id, id == 1 ? "An" : "Binh"));
    }

    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<StudentDto> create(@RequestBody StudentDto student) {
        StudentDto saved = new StudentDto(3, student.name());
        return ResponseEntity.created(URI.create("/api/students/3")).body(saved);
    }
}

package dev.canhdominich.spring.mvc;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

public class ExceptionSpy implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        Trace.record(ex.getClass().getSimpleName());
        return null;
    }
}

package dev.canhdominich.spring.mvc;

import java.util.List;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@EnableWebMvc
@ComponentScan(basePackageClasses = WebConfig.class)
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views/", ".jsp");
    }

    @Override
    public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        resolvers.add(0, new ExceptionSpy());
    }
}

package dev.canhdominich.spring.mvc;

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

public final class Trace {

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

    private Trace() {
    }

    public static void record(String event) {
        EVENTS.add(event);
    }

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

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

package dev.canhdominich.spring.mvc;

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.Wrapper;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

public final class EmbeddedServer implements AutoCloseable {

    private final Tomcat tomcat;
    private final AnnotationConfigWebApplicationContext springContext;

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

    public static EmbeddedServer start(int port, Class<?>... configurations) 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");
        Context context = tomcat.addContext("", new File("src/main/webapp").getAbsolutePath());
        if (context instanceof org.apache.catalina.core.StandardContext standard) {
            standard.setClearReferencesRmiTargets(false);
            standard.setClearReferencesThreadLocals(false);
        }
        context.addLifecycleListener(new Tomcat.FixContextListener());
        context.addServletContainerInitializer(new org.apache.jasper.servlet.JasperInitializer(), null);
        Wrapper jsp = Tomcat.addServlet(context, "jsp", "org.apache.jasper.servlet.JspServlet");
        jsp.setLoadOnStartup(3);
        context.addServletMappingDecoded("*.jsp", "jsp");

        AnnotationConfigWebApplicationContext springContext = new AnnotationConfigWebApplicationContext();
        springContext.register(configurations);
        Wrapper dispatcher = Tomcat.addServlet(context, "dispatcher", new DispatcherServlet(springContext));
        dispatcher.setLoadOnStartup(1);
        context.addServletMappingDecoded("/", "dispatcher");

        tomcat.start();
        return new EmbeddedServer(tomcat, springContext);
    }

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

    public AnnotationConfigWebApplicationContext springContext() {
        return springContext;
    }

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

package dev.canhdominich.spring.mvc;

public class ServerMain {

    public static void main(String[] args) throws Exception {
        int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
        EmbeddedServer server = EmbeddedServer.start(port, WebConfig.class);
        System.out.println("listening on http://127.0.0.1:" + server.port() + "/hello");
        Thread.currentThread().join();
    }
}

<%@ page contentType="text/html;charset=UTF-8" %>
<html><body><h1>${title}</h1></body></html>

package dev.canhdominich.spring.mvc;

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;

public class ParamsDemo {

    public static void main(String[] args) throws Exception {
        run();
    }

    public static List<String> run() throws Exception {
        List<String> lines = new ArrayList<>();
        try (EmbeddedServer server = EmbeddedServer.start(0, WebConfig.class)) {
            Client client = new Client(server.port(), lines);
            client.get("/pages/students/5");
            client.get("/pages/students/new");
            client.get("/pages/products/J-77/reviews/3");
            client.get("/pages/search?q=java&page=2");
            client.get("/pages/search?q=java");
            client.get("/pages/search");
            client.get("/pages/search?q=java&page=abc");
            client.get("/pages/students/abc");
            client.get("/pages/trace");
            client.get("/pages/trace", "X-Trace", "abc-123");
            client.post("/pages/register", "application/x-www-form-urlencoded", "name=An&age=20");
            client.post("/pages/register", "application/x-www-form-urlencoded", "name=An&age=abc");
            client.get("/pages/view");
            client.get("/api/students");
            client.get("/api/students/1");
            client.get("/api/students/9");
            client.post("/api/students", "application/json", "{\"name\":\"Chi\"}");
            client.post("/api/students", "text/plain", "Chi");
            client.get("/api/students/1", "Accept", "text/plain");
        }
        return lines;
    }

    static final class Client {

        private final int port;
        private final List<String> lines;
        private final HttpClient http = HttpClient.newHttpClient();

        Client(int port, List<String> lines) {
            this.port = port;
            this.lines = lines;
        }

        void get(String path, String... headers) throws Exception {
            HttpRequest.Builder builder = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + port + path)).GET();
            for (int i = 0; i < headers.length; i += 2) {
                builder.header(headers[i], headers[i + 1]);
            }
            send("GET " + path + (headers.length > 0 ? " [" + headers[0] + ": " + headers[1] + "]" : ""), builder.build());
        }

        void post(String path, String contentType, String body) throws Exception {
            HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + port + path))
                    .header("Content-Type", contentType)
                    .POST(HttpRequest.BodyPublishers.ofString(body))
                    .build();
            send("POST " + path + " [" + contentType + "] " + body, request);
        }

        private void send(String label, HttpRequest request) throws Exception {
            Trace.clear();
            HttpResponse<String> response = http.send(request, HttpResponse.BodyHandlers.ofString());
            StringBuilder out = new StringBuilder(label + " -> " + response.statusCode());
            response.headers().firstValue("Content-Type").ifPresent(type -> out.append(" ").append(type.split(";")[0]));
            response.headers().firstValue("Location").ifPresent(location -> out.append(" Location: ").append(location));
            String body = response.body().replaceAll("\\s+", " ").trim();
            if (response.statusCode() < 400 && !body.isEmpty()) {
                out.append(" | ").append(body);
            }
            if (!Trace.all().isEmpty()) {
                out.append(" | spring raised ").append(Trace.all().get(0));
            }
            System.out.println(out);
            lines.add(out.toString());
        }
    }
}

GET /pages/students/5 -> 200 text/plain | student 5
GET /pages/students/new -> 200 text/plain | form for a new student
GET /pages/products/J-77/reviews/3 -> 200 text/plain | review 3 of J-77
GET /pages/search?q=java&page=2 -> 200 text/plain | q=java page=2
GET /pages/search?q=java -> 200 text/plain | q=java page=1
GET /pages/search -> 400 text/html | spring raised MissingServletRequestParameterException
GET /pages/search?q=java&page=abc -> 400 text/html | spring raised MethodArgumentTypeMismatchException
GET /pages/students/abc -> 400 text/html | spring raised MethodArgumentTypeMismatchException
GET /pages/trace -> 200 text/plain | trace=none
GET /pages/trace [X-Trace: abc-123] -> 200 text/plain | trace=abc-123
POST /pages/register [application/x-www-form-urlencoded] name=An&age=20 -> 200 text/plain | registered An aged 20
POST /pages/register [application/x-www-form-urlencoded] name=An&age=abc -> 400 text/html | spring raised MethodArgumentNotValidException
GET /pages/view -> 200 text/html | <html><body><h1>Danh sach sinh vien</h1></body></html>
GET /api/students -> 200 application/json | [{"id":1,"name":"An"},{"id":2,"name":"Binh"}]
GET /api/students/1 -> 200 application/json | {"id":1,"name":"An"}
GET /api/students/9 -> 404
POST /api/students [application/json] {"name":"Chi"} -> 201 application/json Location: /api/students/3 | {"id":3,"name":"Chi"}
POST /api/students [text/plain] Chi -> 415 text/html | spring raised HttpMediaTypeNotSupportedException
GET /api/students/1 [Accept: text/plain] -> 406 text/html | spring raised HttpMediaTypeNotAcceptableException

IllegalArgumentException: Name for argument of type [int] not specified, and parameter name information not available via reflection. Ensure that the compiler uses the '-parameters' flag.