Best practices with interface projections for JPA Repository in Spring?

Question

I was wondering if anyone can give feedback on a pattern that I am currently playing around with? It involves having an entity implementing a DTO interface that is also used (as a projection) in a JpaRepository interface – for the same entity – to return query results with specific columns. The DTO interface also has default methods to allow any instances of the entity and the DTO proxies to have similar behaviours.

The questions I am looking to have answered are whether this pattern has any drawbacks such as performance that might prevent one from using it in production. I am also interested to hear how others are querying specific data fields using JpaRepositories. Below I have a code sample that illustrates the pattern that I am playing with.

public interface InstructorDTO {
    String getFirstName();
    String getLastName();

    default String getFullName() {
        return getFirstName() + ' ' + getLastName();
    }
}

@Entity
public class Instructor implements InstructorDTO {
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private int id;

    @Column(name="first_name")
    private String firstName;

    @Column(name="last_name")
    private String lastName;

    @Column(unique = true)
    private String email;

    @Override
    public String getFirstName() {
        return this.firstName;
    }

    @Override
    public String getLastName() {
        return this.lastName;
    }

    ...remaining getters and setters
}

@Repository
public interface InstructorRepository extends JpaRepository<Instructor, Integer> {

    <S> S findById(int id, Class<S> type);

    <T> Collection<T> findByEmail(String email, Class<T> type);
}


public class SomeClass {
    @Autowired
    InstructorRepository instructorRepository;

    public void someMethod {
        int id = 1;

        // Returns proxy
        InstructorDTO instructor1 = instructorRepository.findById(id, InstructorDTO.class);

        // Returns Instructor Object
        Instructor instructor2 = instructorRepository.findOne(id);

        System.out.println(instructor1.getFullName()); // returns John Doe
        System.out.println(instructor2.getFullName()); // returns John Doe
    }
}

Answer 1

There are no drawbacks with this solution in contrast. It's much better to use DTOs instead of Entities if you just need a few columns.

Because if you use DTOs only on SQL statement will be generated for selecting the data. Where as if you use Entities eager or lazy fetched relationships can be loaded and this may cause the n+1 select problem.

It's only questionable if you really want your Entities extend the DTO. That doesn't make sense in my opinion.

Two recommendations.

• Don't use @GeneratedValue(strategy= GenerationType.AUTO). Why you can find here https://vladmihalcea.com/why-should-not-use-the-auto-jpa-generationtype-with-mysql-and-hibernate/

• You can remove @Repository because your extending from JpaRepository