Replacing entire contents of spring-data Page, while maintaining paging info

Question

Using spring-data-jpa and working on getting data out of table where there are about a dozen columns which are used in queries to find particular rows, and then a payload column of clob type which contains the actual data that is marshalled into java objects to be returned.

Entity object very roughly would be something like

@Entity
@Table(name = "Person")

public class Person {
    @Column(name="PERSON_ID", length=45) @Id private String personId;
    @Column(name="NAME", length=45) private String name;
    @Column(name="ADDRESS", length=45) private String address;
    @Column(name="PAYLOAD") @Lob private String payload;

    //Bunch of other stuff
} 

(Whether this approach is sensible or not is a topic for a different discussion)

The clob column causes performance to suffer on large queries ...

In an attempt to improve things a bit, I've created a separate entity object ... sans payload ...

@Entity
@Table(name = "Person")

public class NotQuiteAWholePerson {
    @Column(name="PERSON_ID", length=45) @Id private String personId;
    @Column(name="NAME", length=45) private String name;
    @Column(name="ADDRESS", length=45) private String address;

    //Bunch of other stuff
} 

This gets me a page of NotQuiteAPerson ... I then query for the page of full person objects via the personIds.

The hope is that in not using the payload in the original query, which could filtering data over a good bit of the backing table, I only concern myself with the payload when I'm retrieving the current page of objects to be viewed ... a much smaller chunk.

So I'm at the point where I want to map the contents of the original returned Page of NotQuiteAWholePerson to my List of Person, while keeping all the Paging info intact, the map method however only takes a Converter which will iterate over the NotQuiteAWholePerson objects ... which doesn't quite fit what I'm trying to do.

Is there a sensible way to achieve this ?

---

Additional clarification for @itsallas as to why existing map() will not suffice..

PageImpl::map has

@Override
public <S> Page<S> map(Converter<? super T, ? extends S> converter) {
    return new PageImpl<S>(getConvertedContent(converter), pageable, total);
}

Chunk::getConvertedContent has

protected <S> List<S> getConvertedContent(Converter<? super T, ? extends S> converter) {

    Assert.notNull(converter, "Converter must not be null!");

    List<S> result = new ArrayList<S>(content.size());

    for (T element : this) {
        result.add(converter.convert(element));
    }

    return result;
}

So the original List of contents is iterated through ... and a supplied convert method applied, to build a new list of contents to be inserted into the existing Pageable.

However I cannot convert a NotQuiteAWholePerson to a Person individually, as I cannot simply construct the payload... well I could, if I called out to the DB for each Person by Id in the convert... but calling out individually is not ideal from a performance perspective ...

After getting my Page of NotQuiteAWholePerson I am querying for the entire List of Person ... by Id ... in one call ... and now I am looking for a way to substitute the entire content list ... not interively, as the existing map() does, but in a simple replacement.

This particular use case would also assist where the payload, which is json, is more appropriately persisted in a NoSql datastore like Mongo ... as opposed to the sql datastore clob ...

Hope that clarifies it a bit better.

Answer 1

You can avoid the problem entirely with Spring Data JPA features.

The most sensible way would be to use Spring Data JPA projections, which have good extensive documentation.

For example, you would first need to ensure lazy fetching for your attribute, which you can achieve with an annotation on the attribute itself.

i.e. :

@Basic(fetch = FetchType.LAZY)  @Column(name="PAYLOAD") @Lob private String payload;

or through Fetch/Load Graphs, which are neatly supported at repository-level.

You need to define this one way or another, because, as taken verbatim from the docs :

The query execution engine creates proxy instances of that interface at runtime for each element returned and forwards calls to the exposed methods to the target object.

You can then define a projection like so :

interface NotQuiteAWholePerson {
    String getPersonId();
    String getName();
    String getAddress();

    //Bunch of other stuff
}

And add a query method to your repository :

interface PersonRepository extends Repository<Person, String> {

    Page<NotQuiteAWholePerson> findAll(Pageable pageable);
    // or its dynamic equivalent
    <T> Page<T> findAll(Pageable pageable, Class<T>);
}

Given the same pageable, a page of projections would refer back to the same entities in the same session.

If you cannot use projections for whatever reason (namely if you're using JPA < 2.1 or a version of Spring Data JPA before projections), you could define an explicit JPQL query with the columns and relationships you want, or keep the 2-entity setup. You could then map Persons and NotQuiteAWholePersons to a PersonDTO class, either manually or (preferably) using your object mapping framework of choice.

NB. : There are a variety of ways to use and setup lazy/eager relations. This covers more in detail.