Spring Data JPA Derived Query Methods Explained

//Book.java
package com.javabrahman.data.derived;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import java.math.BigDecimal;

@Entity
public class Book {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String title;
  private String author;
  private int publishedYear;
  private BigDecimal price;

  protected Book() {
  }

  public Book(String title, String author, int publishedYear, BigDecimal price) {
    this.title = title;
    this.author = author;
    this.publishedYear = publishedYear;
    this.price = price;
  }

  public Long getId() { return id; }
  public String getTitle() { return title; }
  public String getAuthor() { return author; }
  public int getPublishedYear() { return publishedYear; }
  public BigDecimal getPrice() { return price; }

  @Override
  public String toString() {
    return title + " (" + author + ", " + publishedYear + ", $" + price + ")";
  }
}

//BookRepository.java
package com.javabrahman.data.derived;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.springframework.data.domain.Limit;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.transaction.annotation.Transactional;

public interface BookRepository extends JpaRepository<Book, Long> {

  // equality
  List<Book> findByAuthor(String author);
  Optional<Book> findByTitle(String title);
  List<Book> findByAuthorAndPublishedYear(String author, int publishedYear);
  List<Book> findByAuthorOrPublishedYear(String author, int publishedYear);

  // case, text matching, collections
  List<Book> findByAuthorIgnoreCase(String author);
  List<Book> findByTitleContaining(String text);
  List<Book> findByTitleStartingWithIgnoreCase(String prefix);
  List<Book> findByAuthorIn(Collection<String> authors);

  // comparisons and ranges
  List<Book> findByPublishedYearBetween(int from, int to);
  List<Book> findByPriceLessThan(BigDecimal price);
  List<Book> findByPublishedYearGreaterThanEqual(int year);
  List<Book> findByAuthorNot(String author);

  // sorting and limiting
  List<Book> findByPublishedYearGreaterThanEqualOrderByPriceDesc(int year);
  List<Book> findByAuthorOrderByPublishedYearAsc(String author);
  List<Book> findByPublishedYearGreaterThan(int year, Sort sort);
  Book findFirstByOrderByPriceAsc();
  List<Book> findTop3ByOrderByPublishedYearDesc();
  List<Book> findByPublishedYearGreaterThan(int year, Sort sort, Limit limit);

  // distinct, count, exists, delete
  List<String> findDistinctAuthorBy();   // looks like "the distinct authors" - see the output and explanation
  long countByAuthor(String author);
  boolean existsByTitle(String title);

  @Transactional
  long deleteByPublishedYearLessThan(int year);
}

//DerivedQueriesApp.java
package com.javabrahman.data.derived;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.domain.Limit;
import org.springframework.data.domain.Sort;

@SpringBootApplication
public class DerivedQueriesApp {

  @Bean
  CommandLineRunner demo(BookRepository r) {
    return args -> {
      r.saveAll(List.of(
          new Book("Effective Java", "Joshua Bloch", 2018, new BigDecimal("45.99")),
          new Book("Java Puzzlers", "Joshua Bloch", 2005, new BigDecimal("29.99")),
          new Book("Java Concurrency in Practice", "Brian Goetz", 2006, new BigDecimal("49.99")),
          new Book("Clean Code", "Robert C. Martin", 2008, new BigDecimal("37.49")),
          new Book("Clean Architecture", "Robert C. Martin", 2017, new BigDecimal("34.99")),
          new Book("Refactoring", "Martin Fowler", 2018, new BigDecimal("47.99")),
          new Book("Spring in Action", "Craig Walls", 2022, new BigDecimal("49.99")),
          new Book("Domain-Driven Design", "Eric Evans", 2003, new BigDecimal("59.99"))));

      show("findByAuthor(\"Joshua Bloch\")", r.findByAuthor("Joshua Bloch"));
      System.out.println("findByTitle(\"Clean Code\"): " + r.findByTitle("Clean Code").map(Book::getAuthor).orElse("-"));
      System.out.println("findByTitle(\"Unknown\"): " + r.findByTitle("Unknown"));
      show("findByAuthorAndPublishedYear(\"Joshua Bloch\", 2018)", r.findByAuthorAndPublishedYear("Joshua Bloch", 2018));
      show("findByAuthorOrPublishedYear(\"Brian Goetz\", 2018)", r.findByAuthorOrPublishedYear("Brian Goetz", 2018));
      System.out.println();
      show("findByAuthorIgnoreCase(\"joshua BLOCH\")", r.findByAuthorIgnoreCase("joshua BLOCH"));
      show("findByTitleContaining(\"Clean\")", r.findByTitleContaining("Clean"));
      show("findByTitleStartingWithIgnoreCase(\"java\")", r.findByTitleStartingWithIgnoreCase("java"));
      show("findByAuthorIn([Brian Goetz, Eric Evans])", r.findByAuthorIn(List.of("Brian Goetz", "Eric Evans")));
      System.out.println();
      show("findByPublishedYearBetween(2005, 2008)", r.findByPublishedYearBetween(2005, 2008));
      show("findByPriceLessThan(35)", r.findByPriceLessThan(new BigDecimal("35")));
      show("findByPublishedYearGreaterThanEqual(2018)", r.findByPublishedYearGreaterThanEqual(2018));
      show("findByAuthorNot(\"Robert C. Martin\") - first 3 shown", r.findByAuthorNot("Robert C. Martin").subList(0, 3));
      System.out.println();
      show("findByPublishedYearGreaterThanEqualOrderByPriceDesc(2017)", r.findByPublishedYearGreaterThanEqualOrderByPriceDesc(2017));
      show("findByAuthorOrderByPublishedYearAsc(\"Robert C. Martin\")", r.findByAuthorOrderByPublishedYearAsc("Robert C. Martin"));
      show("findByPublishedYearGreaterThan(2005, Sort.by(\"title\"))", r.findByPublishedYearGreaterThan(2005, Sort.by("title")));
      System.out.println("findFirstByOrderByPriceAsc(): " + r.findFirstByOrderByPriceAsc());
      show("findTop3ByOrderByPublishedYearDesc()", r.findTop3ByOrderByPublishedYearDesc());
      show("findByPublishedYearGreaterThan(2005, Sort.by(\"price\").descending(), Limit.of(2))",
          r.findByPublishedYearGreaterThan(2005, Sort.by("price").descending(), Limit.of(2)));
      System.out.println();
      try {
        System.out.println("findDistinctAuthorBy(): " + r.findDistinctAuthorBy());
      } catch (Exception e) {
        String message = e.getMessage();
        System.out.println("findDistinctAuthorBy() failed: " + e.getClass().getSimpleName() + " - " + message.substring(0, message.indexOf(" for value")));
      }
      System.out.println("countByAuthor(\"Joshua Bloch\"): " + r.countByAuthor("Joshua Bloch"));
      System.out.println("existsByTitle(\"Refactoring\"): " + r.existsByTitle("Refactoring"));
      System.out.println("deleteByPublishedYearLessThan(2006) deleted " + r.deleteByPublishedYearLessThan(2006) + " books, "
          + r.count() + " left");
    };
  }

  private static void show(String call, Collection<Book> books) {
    System.out.println(call + ":");
    books.forEach(b -> System.out.println("    " + b));
  }

  public static void main(String[] args) {
    SpringApplication.run(DerivedQueriesApp.class, args);
  }
}

//BrokenRepository.java
package com.javabrahman.data.brokenrepo;

import com.javabrahman.data.derived.Book;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;

public interface BrokenRepository extends JpaRepository<Book, Long> {
  List<Book> findByAuthors(String author);   // the entity has "author", not "authors"
}

//BrokenApp.java
package com.javabrahman.data.brokenrepo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.persistence.autoconfigure.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
@EntityScan("com.javabrahman.data.derived")
@EnableJpaRepositories(basePackageClasses = BrokenRepository.class)
public class BrokenApp {
  public static void main(String[] args) {
    try (var context = SpringApplication.run(BrokenApp.class, args)) {
      System.out.println("Started");
    } catch (Exception e) {
      Throwable cause = e;
      while (cause.getCause() != null && !cause.getClass().getSimpleName().equals("PropertyReferenceException")) {
        cause = cause.getCause();
      }
      System.out.println(cause.getClass().getSimpleName() + ": " + cause.getMessage());
    }
  }
}