Spring Data JPA map the native query result to Non-Entity POJO

I think the easiest way to do that is to use so called projection. It can map query results to interfaces. Using SqlResultSetMapping is inconvienient and makes your code ugly :).

An example right from spring data JPA source code:

public interface UserRepository extends JpaRepository<User, Integer> { @Query(value = "SELECT firstname, lastname FROM SD_User WHERE id = ?1", nativeQuery = true) NameOnly findByNativeQuery(Integer id); public static interface NameOnly { String getFirstname(); String getLastname(); } } 

You can also use this method to get a list of projections.

Check out this spring data JPA docs entry for more info about projections.

Note 1:

Remember to have your User entity defined as normal - the fields from projected interface must match fields in this entity. Otherwise field mapping might be broken (getFirstname() might return value of last name et cetera).

Note 2:

If you use SELECT table.column ... notation always define aliases matching names from entity. For example this code won't work properly (projection will return nulls for each getter):

@Query(value = "SELECT user.firstname, user.lastname FROM SD_User user WHERE id = ?1", nativeQuery = true) NameOnly findByNativeQuery(Integer id); 

But this works fine:

@Query(value = "SELECT user.firstname AS firstname, user.lastname AS lastname FROM SD_User user WHERE id = ?1", nativeQuery = true) NameOnly findByNativeQuery(Integer id); 

In case of more complex queries I'd rather use JdbcTemplate with custom repository instead.

I think Michal's approach is better. But, there is one more way to get the result out of the native query.

@Query(value = "SELECT g.*, gm.* FROM group g LEFT JOIN group_members gm ON g.group_id = gm.group_id and gm.user_id = :userId WHERE g.group_id = :groupId", nativeQuery = true) String[][] getGroupDetails(@Param("userId") Integer userId, @Param("groupId") Integer groupId); 

Now, you can convert this 2D string array into your desired entity.

You can write your native or non-native query the way you want, and you can wrap JPQL query results with instances of custom result classes. Create a DTO with the same names of columns returned in query and create an all argument constructor with same sequence and names as returned by the query. Then use following way to query the database.

@Query("SELECT NEW example.CountryAndCapital(c.name, c.capital.name) FROM Country AS c") 

Create DTO:

package example; public class CountryAndCapital { public String countryName; public String capitalName; public CountryAndCapital(String countryName, String capitalName) { this.countryName = countryName; this.capitalName = capitalName; } } 

This is my solution for converting to Map and then to custom Object

private ObjectMapper objectMapper; public static List<Map<String, Object>> convertTuplesToMap(List<?> tuples) { List<Map<String, Object>> result = new ArrayList<>(); tuples.forEach(object->{ if(object instanceof Tuple single) { Map<String, Object> tempMap = new HashMap<>(); for (TupleElement<?> key : single.getElements()) { tempMap.put(key.getAlias(), single.get(key)); } result.add(tempMap); }else{ throw new RuntimeException("Query should return instance of Tuple"); } }); return result; } public <T> List<T> parseResult(List<?> list, Class<T> clz){ List<T> result = new ArrayList<>(); convertTuplesToMap(list).forEach(map->{ result.add(objectMapper.convertValue(map, clz)); }); return result; } public static class CustomDTO{ private String param1; private Integer param2; private OffsetDateTime param3; } public List<CustomDTO> doSomeQuery(){ Query query = entityManager.createNativeQuery("SELECT param1, param2 param3 ... ", Tuple.class); return parseResult(query.getResultList(), CustomDTO.class); } 

USE JPA PROJECTIONS In your case it may be desirable to retrieve data as objects of customized types. These types reflect partial views of the root class, containing only properties we care about. This is where projections come in handy. first declare Entity as @immutable

@Entity @Immutable 

public class Address {

@Id private Long id; 

set your Repository

public interface AddressView { String getZipCode(); } 

Then use it in a repository interface:

public interface AddressRepository extends Repository<Address, Long> { @Query("EXEC SP_GETCODE ?1") List<AddressView> getAddressByState(String state); } 

Use the default method in the interface and get the EntityManager to get the opportunity to set the ResultTransformer, then you can return the pure POJO, like this:

final String sql = "SELECT g.*, gm.* FROM group g LEFT JOIN group_members gm ON g.group_id = gm.group_id and gm.user_id = ? WHERE g.group_id = ?"; default GroupDetails getGroupDetails(Integer userId, Integer groupId) { return BaseRepository.getInstance().uniqueResult(sql, GroupDetails.class, userId, groupId); } 

And the BaseRepository.java is like this:

@PersistenceContext public EntityManager em; public <T> T uniqueResult(String sql, Class<T> dto, Object... params) { Session session = em.unwrap(Session.class); NativeQuery q = session.createSQLQuery(sql); if(params!=null){ for(int i=0,len=params.length;i<len;i++){ Object param=params[i]; q.setParameter(i+1, param); } } q.setResultTransformer(Transformers.aliasToBean(dto)); return (T) q.uniqueResult(); } 

This solution does not impact any other methods in repository interface file.

If you are looking for running a custom SQL query in spring boot with @repository and @service structures. Please have a look.

https://stackoverflow.com/a/71501509/4735043