Spring 学习笔记 04：JPA 关联映射与仓储测试

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    private Category category;

    // 构造器多一个「带分类」的版本，原来那个 (title, author) 保留
    public Book(String title, Category category) {
        this.title = title;
        this.category = category;
    }

    /** 关联只能从维护方这一侧改 */
    public void changeCategory(Category category) {
        this.category = category;
    }

    public Category getCategory() {
        return category;
    }

package com.example.library.domain;

import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;

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

@Entity
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "category", fetch = FetchType.LAZY)
    private List<Book> books = new ArrayList<>();

    protected Category() {
    }

    public Category(String name) {
        this.name = name;
    }

    /** 双向关联要两边都改，交给实体自己的方法保证一致性 */
    public void addBook(Book book) {
        books.add(book);
        book.changeCategory(this);
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public List<Book> getBooks() {
        return List.copyOf(books);
    }
}

package com.example.library.domain;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToMany;

import java.util.LinkedHashSet;
import java.util.Set;

@Entity
public class Tag {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    /** 反方：维护方在上面那侧，这里只读 */
    @ManyToMany(mappedBy = "tags")
    private Set<Book> books = new LinkedHashSet<>();

    protected Tag() {
    }

    public Tag(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public Set<Book> getBooks() {
        return Set.copyOf(books);
    }
}

@ManyToMany
@JoinTable(
        name = "book_tags",
        joinColumns = @JoinColumn(name = "book_id"),
        inverseJoinColumns = @JoinColumn(name = "tag_id"))
private Set<Tag> tags = new LinkedHashSet<>();

@ManyToMany(mappedBy = "tags")
private Set<Book> books = new LinkedHashSet<>();

@Entity
public class Book {
    // ...
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    private Category category;
}

List<Book> findByCategoryId(Long categoryId);

List<Book> books = bookRepository.findAll();        // 1 条 SQL
for (Book book : books) {
    System.out.println(book.getCategory().getName()); // 每条再补 1 条 SQL
}

package com.example.library.repository;

import com.example.library.domain.Book;
import com.example.library.domain.BookStatus;
import com.example.library.domain.Category;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

@DataJpaTest
class BookRepositoryTest {

    @Autowired
    private BookRepository bookRepository;

    @Autowired
    private CategoryRepository categoryRepository;

    @Test
    @DisplayName("按分类查书：只返回该分类下的书，并按书名排序")
    void findsBooksByCategoryOrderedByTitle() {
        // given
        Category novel = categoryRepository.save(new Category("小说"));
        Category tech = categoryRepository.save(new Category("技术"));

        bookRepository.save(new Book("活着", novel));
        bookRepository.save(new Book("许三观卖血记", novel));
        bookRepository.save(new Book("重构", tech));

        // when
        List<Book> books = bookRepository.findByCategoryIdOrderByTitleAsc(novel.getId());

        // then
        assertThat(books)
                .hasSize(2)
                .extracting(Book::getTitle)
                .containsExactlyInAnyOrder("活着", "许三观卖血记");
    }

    @Test
    @DisplayName("Containing 会自动补通配符，Like 不会")
    void containingVersusLike() {
        bookRepository.save(new Book("重构：改善既有代码的设计", "Martin Fowler"));

        assertThat(bookRepository.findByTitleContaining("重构")).hasSize(1);
        assertThat(bookRepository.findByTitleLike("重构%")).hasSize(1);
        assertThat(bookRepository.findByTitleLike("重构")).isEmpty();   // 没带通配符就等同于完全相等
    }

    @Test
    @DisplayName("@Modifying 更新之后，同一个事务里读到的是新值")
    void updatesStatusInPlace() {
        Book book = bookRepository.save(new Book("重构", "Martin Fowler"));

        int updated = bookRepository.markStatus(book.getId(), BookStatus.BORROWED);

        assertThat(updated).isEqualTo(1);
        assertThat(bookRepository.findById(book.getId()).orElseThrow().getStatus())
                .isEqualTo(BookStatus.BORROWED);
    }
}

assertThat(books).hasSize(2);
assertThat(book.getTitle()).isEqualTo("重构");
assertThat(book.getTitle()).startsWith("重");
assertThat(optional).isEmpty();
assertThat(books).extracting(Book::getAuthor).containsOnly("Martin Fowler");