Spring 学习笔记 10：Service 层与事务

public interface LoanService {

    Loan borrow(Long bookId, Long memberId);

    List<Loan> findByMember(Long memberId);
}

package com.example.library.service;

import com.example.library.domain.Book;
import com.example.library.domain.BookStatus;
import com.example.library.domain.Loan;
import com.example.library.domain.Member;
import com.example.library.repository.BookRepository;
import com.example.library.repository.LoanRepository;
import com.example.library.repository.MemberRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.util.List;
import java.util.NoSuchElementException;

@Service
@Transactional(readOnly = true)        // 整个类的默认：查询型方法
public class LoanServiceImpl implements LoanService {

    private final BookRepository bookRepository;
    private final MemberRepository memberRepository;
    private final LoanRepository loanRepository;

    public LoanServiceImpl(BookRepository bookRepository,
                           MemberRepository memberRepository,
                           LoanRepository loanRepository) {
        this.bookRepository = bookRepository;
        this.memberRepository = memberRepository;
        this.loanRepository = loanRepository;
    }

    @Override
    @Transactional                    // 写方法单独覆盖：方法级注解优先于类级
    public Loan borrow(Long bookId, Long memberId) {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new NoSuchElementException("图书不存在：" + bookId));
        if (book.getStatus() != BookStatus.AVAILABLE) {
            throw new IllegalStateException("这本书当前不可借");
        }

        Member member = memberRepository.findById(memberId)
                .orElseThrow(() -> new NoSuchElementException("会员不存在：" + memberId));

        book.markBorrowed();
        member.increaseActiveLoans();

        return loanRepository.save(new Loan(book, member, LocalDate.now()));
    }

    @Override
    public List<Loan> findByMember(Long memberId) {
        return loanRepository.findByMemberId(memberId);   // 用类级 readOnly=true
    }
}

@Transactional
public void doSomething() {
    try {
        riskyOperation();
    } catch (Exception e) {
        log.warn("出错了", e);       // 吞掉异常
    }
    // 事务照样提交，前面的写操作留下了
}

@Transactional(isolation = Isolation.REPEATABLE_READ)
public ReportSummary buildSummary(Long memberId) { ... }

@Transactional(rollbackFor = Exception.class)
public Loan borrow(Long bookId, Long memberId) throws BusinessException { ... }

@Transactional(noRollbackFor = NotificationFailedException.class)

@Transactional(readOnly = true, timeout = 5)
public List<BookTitleDto> search(String keyword) { ... }

public interface BookRepository extends JpaRepository<Book, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select b from Book b where b.id = :id")
    Optional<Book> findByIdForUpdate(@Param("id") Long id);
}

@Transactional
public Loan borrow(Long bookId, Long memberId) {
    Book book = bookRepository.findByIdForUpdate(bookId).orElseThrow();
    // 期间别人拿不到这行的写锁，只能等
}

@Entity
public class Book {

    @Version
    private Long version;

    // ...
}

@Service
public class BookImportService {

    private static final Logger log = LoggerFactory.getLogger(BookImportService.class);

    private final BookRepository bookRepository;
    private final TransactionTemplate transactionTemplate;

    public BookImportService(BookRepository bookRepository,
                             PlatformTransactionManager transactionManager) {
        this.bookRepository = bookRepository;
        // 也可以把 TransactionTemplate 声明成 @Bean 注入，这里为了看清依赖关系直接 new
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    /** 每本书一个独立事务：某一本 ISBN 重复时只跳过这一本，其余照常导入 */
    public int importBooks(List<BookForm> forms) {
        int imported = 0;
        for (BookForm form : forms) {
            Integer result = transactionTemplate.execute(status -> {
                try {
                    Book book = new Book(form.getTitle(), form.getAuthor());
                    book.setIsbn(form.getIsbn());
                    bookRepository.saveAndFlush(book);   // 立刻 flush，唯一约束冲突在这里就暴露
                    return 1;
                } catch (DataIntegrityViolationException e) {
                    status.setRollbackOnly();
                    log.warn("跳过 ISBN 重复的《{}》", form.getTitle());
                    return 0;
                }
            });
            imported += result == null ? 0 : result;
        }
        return imported;
    }
}