Spring 学习笔记 06：表单绑定与服务端校验

package com.example.library.dto;

import com.example.library.validation.PastOrCurrentYear;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;

public class BookForm {

    @NotBlank(message = "书名不能为空")
    @Size(max = 200, message = "书名不能超过 200 个字符")
    private String title;

    @NotBlank(message = "作者不能为空")
    private String author;

    @PastOrCurrentYear
    @Min(value = 1000, message = "出版年份看起来不对")
    @Max(value = 2100, message = "出版年份看起来不对")
    private Integer publishedYear;

    @Pattern(regexp = "\\d{13}", message = "ISBN 必须是 13 位数字")
    private String isbn;

    @NotNull(message = "请选择分类")
    private Long categoryId;

    // 下面这些 getter / setter 一个都不能少：
    // 绑定靠 setter，回填靠 getter，缺任何一个都会「绑定不上」或「值显示不出来」

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Integer getPublishedYear() {
        return publishedYear;
    }

    public void setPublishedYear(Integer publishedYear) {
        this.publishedYear = publishedYear;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public Long getCategoryId() {
        return categoryId;
    }

    public void setCategoryId(Long categoryId) {
        this.categoryId = categoryId;
    }
}

    private final CategoryService categoryService;

    public BookViewController(BookService bookService, CategoryService categoryService) {
        this.bookService = bookService;
        this.categoryService = categoryService;
    }

    @GetMapping("/new")
    public String form(Model model) {
        model.addAttribute("form", new BookForm());        // 空对象，th:object 靠它
        model.addAttribute("categories", categoryService.findAll());
        return "books/form";
    }

    @PostMapping
    public String create(@Valid @ModelAttribute("form") BookForm form,
                         BindingResult bindingResult,
                         Model model,
                         RedirectAttributes redirectAttributes) {
        if (bindingResult.hasErrors()) {
            model.addAttribute("categories", categoryService.findAll());  // 下拉框数据要重新准备
            return "books/form";
        }
        bookService.create(form);
        redirectAttributes.addFlashAttribute("message", "新增成功");
        return "redirect:/books";
    }

package com.example.library.service;

import com.example.library.domain.Category;

import java.util.List;

public interface CategoryService {

    List<Category> findAll();

    Category findByName(String name);
}

package com.example.library.service;

import com.example.library.domain.Category;
import com.example.library.repository.CategoryRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.NoSuchElementException;

@Service
@Transactional(readOnly = true)
public class CategoryServiceImpl implements CategoryService {

    private final CategoryRepository categoryRepository;

    public CategoryServiceImpl(CategoryRepository categoryRepository) {
        this.categoryRepository = categoryRepository;
    }

    @Override
    public List<Category> findAll() {
        return categoryRepository.findAll();
    }

    @Override
    public Category findByName(String name) {
        return categoryRepository.findByName(name)
                .orElseThrow(() -> new NoSuchElementException("分类不存在：" + name));
    }
}

package com.example.library.repository;

import com.example.library.domain.Category;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface CategoryRepository extends JpaRepository<Category, Long> {

    Optional<Category> findByName(String name);
}

    private final BookRepository bookRepository;
    private final CategoryRepository categoryRepository;

    public BookServiceImpl(BookRepository bookRepository, CategoryRepository categoryRepository) {
        this.bookRepository = bookRepository;
        this.categoryRepository = categoryRepository;
    }

    @Override
    @Transactional
    public Book create(BookForm form) {
        Category category = categoryRepository.findById(form.getCategoryId())
                .orElseThrow(() -> new NoSuchElementException("分类不存在：" + form.getCategoryId()));

        Book book = new Book(form.getTitle(), category);   // 02 / 04 篇那个「带分类」的构造器
        book.setAuthor(form.getAuthor());
        book.setIsbn(form.getIsbn());
        book.setPublishedYear(form.getPublishedYear());
        return bookRepository.save(book);
    }

<form th:action="@{/books}" th:object="${form}" method="post">

    <label for="title">书名</label>
    <input type="text" id="title" th:field="*{title}" th:errorclass="is-invalid">
    <span class="error" th:if="${#fields.hasErrors('title')}" th:errors="*{title}">书名不能为空</span>

    <label for="author">作者</label>
    <input type="text" id="author" th:field="*{author}">
    <span class="error" th:if="${#fields.hasErrors('author')}" th:errors="*{author}">作者不能为空</span>

    <label for="publishedYear">出版年份</label>
    <input type="number" id="publishedYear" th:field="*{publishedYear}">

    <label for="isbn">ISBN</label>
    <input type="text" id="isbn" th:field="*{isbn}">

    <label for="categoryId">分类</label>
    <select id="categoryId" th:field="*{categoryId}">
        <option value="">请选择</option>
        <option th:each="category : ${categories}"
                th:value="${category.id}"
                th:text="${category.name}">小说</option>
    </select>
    <span class="error" th:if="${#fields.hasErrors('categoryId')}" th:errors="*{categoryId}">请选择分类</span>

    <button type="submit">保存</button>
</form>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

// 对：BindingResult 紧接着 form
public String create(@Valid @ModelAttribute("form") BookForm form, BindingResult bindingResult, Model model)

// 错：中间隔了 Model，框架会直接抛 MethodArgumentNotValidException
public String create(@Valid @ModelAttribute("form") BookForm form, Model model, BindingResult bindingResult)

<ul th:if="${#fields.hasGlobalErrors()}">
    <li th:each="err : ${#fields.globalErrors()}" th:text="${err}">两次输入不一致</li>
</ul>

package com.example.library.validation;

import jakarta.validation.Constraint;
import jakarta.validation.Payload;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Constraint(validatedBy = PastOrCurrentYearValidator.class)
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface PastOrCurrentYear {

    String message() default "年份不能晚于当前年份";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

package com.example.library.validation;

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

import java.time.Year;

public class PastOrCurrentYearValidator implements ConstraintValidator<PastOrCurrentYear, Integer> {

    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext context) {
        return value == null || value <= Year.now().getValue();
    }
}

@PastOrCurrentYear
private Integer publishedYear;

package com.example.library.web;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.NoSuchElementException;

/** 页面型控制器的统一异常处理 */
@ControllerAdvice(assignableTypes = { BookViewController.class, BookWizardController.class })
public class GlobalExceptionHandler {

    @ExceptionHandler(NoSuchElementException.class)
    public String handleNotFound(NoSuchElementException ex, Model model) {
        model.addAttribute("message", ex.getMessage());
        return "error/not-found";
    }
}

package com.example.library.web;

import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class ApiExceptionHandler {

    @ExceptionHandler(NoSuchElementException.class)
    public ProblemDetail handleNotFound(NoSuchElementException ex) {
        ProblemDetail detail = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
        detail.setTitle("资源不存在");
        return detail;
    }
}

@ModelAttribute("currentYear")
public int currentYear() {
    return Year.now().getValue();
}