使用方法名称中的 spring-data 查询重写 JPQL 查询

Question

I have two entities with many-to-many relationship:

@Entity
@Table(name = "author")
public class Author {

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

    @Column(name = "author_name", unique = true)
    private String authorName;

    @ManyToMany // default FetchType.LAZY
    @JoinTable(name = "author_book",
            joinColumns = @JoinColumn(name = "author_id"),
            inverseJoinColumns = @JoinColumn(name = "book_id"))
    private Set<Book> books;

    // other fields, getters, setters
}

and

@Entity
@Table(name = "book")
public class Book {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(name = "title", unique = true)
    private String title;
  
    // other fields, getters, setters
}

Let's say, that we have in the database 1 author with author_name ' Stephen King ' with related 3 books with titles ' book-title-1 ', ' book-title-2 ', ' book-title-3 '.

I need to get author by name with his books with a certain titles, eg:

find an author named 'Stephen King' with books named 'book-title-1' or 'book-title-2'

With following query as below, it works, namely I'm getting an author with a set of two Book-elements.

public interface AuthorRepository extends JpaRepository<Author, Long> {

    @Query("select a from Author a join fetch a.books b " +
            "where a.authorName=:authorName and b.title in :titles")
    Optional<Author> findByNameAndBookTitles(String authorName, Set<String> titles);
}

Hibernate query for method above (simplified):

 select author.id, book.id, author.author_name, book.title, author_book.author_id, author_book.book_id
    from public.author
    inner join public.author_book on author.id= author_book.author_id 
    inner join public.book on author_book.book_id=book.id 
    where author.author_name=? and (book.title in (? , ?))

Question: Is there a way to rewrite it with query from method names?

I tried smth like this:

Optional<Author> findByAuthorNameAndBooks_titleIn(String authorName, Set<String> titles);

but it returns author and all related books instead of two books, so hibernate makes two following queries (second hibernate query is made when the Set<Book> books is accessed for the first time):

Hibernate:
select author.id , author.author_name
from public.author
left outer join public.author_book on author.id = author_book.author_id 
left outer join public.book on author_book.book_id= book.id 
where author_name=? and (book.title in (? , ?))

Hibernate: 
select author_book.author_id, author_book.book_id, book.id, book.title 
from public.author_book
inner join public.book on author_book.book_id=book.id 
where author_book.author_id=?

I suggested that probably it would work with @ManyToMany(fetch = FetchType.EAGER) , but hibernate again made two queries like above, with the only difference that the second query is made before the first call to the set of books.

If you need any clarification, let me know and thanks in advance.

Answer 1

I wouldn't recommend you to use the method name convention as that is only a tool for quick prototyping AFAIU. As soon as the requirements change you might have to switch back to a query and then you will have fun to decipher what this method name convention really means.

But even your JPQL/HQL query isn't really safe as you are returning managed entities with filtered collections. A simple change to the collection could lead to deletion of all filtered out books. I would recommend you use DTOs instead to avoid all of the issues.

I think this is a perfect use case forBlaze-Persistence Entity Views .

I created the library to allow easy mapping between JPA models and custom interface or abstract class defined models, something like Spring Data Projections on steroids. The idea is that you define your target structure(domain model) the way you like and map attributes(getters) via JPQL expressions to the entity model.

A DTO model for your use case could look like the following with Blaze-Persistence Entity-Views:

@EntityView(Author.class)
public interface AuthorDto {
    @IdMapping
    Long getId();
    String getAuthorName();
    Set<BookDto> getBooks();

    @EntityView(Book.class)
    interface BookDto {
        @IdMapping
        Long getId();
        String getTitle();
    }
}

Querying is a matter of applying the entity view to a query, the simplest being just a query by id.

AuthorDto a = entityViewManager.find(entityManager, AuthorDto.class, id);

The Spring Data integration allows you to use it almost like Spring Data Projections: https://persistence.blazebit.com/documentation/entity-view/manual/en_US/index.html#spring-data-features

Page<AuthorDto> findAll(Pageable pageable);

The best part is, it will only fetch the state that is actually necessary!

In your particular case, you could use this:

Optional<AuthorDto> findByAuthorNameAndBooks_titleIn(String authorName, Set<String> titles) {
    return findOne((root, query, cb) -> {
        return cb.and(
            cb.equal(root.get("name"), authorName),
            root.get("books").get("title").in(titles)
         );
    });
}