{"id":61270,"date":"2024-04-18T11:39:43","date_gmt":"2024-04-18T06:09:43","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=61270"},"modified":"2024-04-18T11:39:43","modified_gmt":"2024-04-18T06:09:43","slug":"understanding-data-projection-in-spring-boot-with-hibernate","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/understanding-data-projection-in-spring-boot-with-hibernate\/","title":{"rendered":"Understanding Data Projection in Spring Boot with Hibernate"},"content":{"rendered":"

This article will delve into data projection in the context of Spring Boot and Hibernate. This blog will examine the significance of data projection, its advantages, and disadvantages. Furthermore, I will provide a comprehensive explanation of how to implement it in your Spring Boot applications efficiently.<\/p>\n

What is data Projection?<\/strong><\/h2>\n

Data projection in database querying involves selecting specific attributes from one or multiple entities or tables and retrieving only those attributes in the result set. This technique is useful when you do not require the complete entity object and aims to enhance performance by fetching only the necessary data.<\/p>\n

Why use data projection?<\/strong><\/h2>\n

Using data projection in Spring Boot offers several benefits:<\/p>\n

    \n
  1. Performance Optimization:<\/strong>\u00a0Data projection enables the retrieval of specific fields from database queries, rather than fetching complete objects. This leads to a notable decrease in data transfer between the application and the database, ultimately improving response times and enhancing overall performance.<\/li>\n
  2. Bandwidth Efficiency:<\/strong>\u00a0Opting for essential fields helps reduce the network bandwidth usage of your application, which is crucial when dealing with extensive datasets. This is especially significant for applications operating in settings with restricted network resources or when data transfer expenses need to be considered.<\/li>\n
  3. Reduced Memory Usage:<\/strong>\u00a0By fetching only the necessary fields from the database, it reduces the amount of memory required to store the data. This optimization can significantly enhance memory usage efficiency, particularly when dealing with extensive datasets.<\/li>\n
  4. Improved Security:<\/strong>\u00a0Data projection can enhance security by restricting the disclosure of sensitive or redundant data fields in the responses of your application.<\/li>\n<\/ol>\n

    Data Projection Techniques :<\/strong><\/h2>\n
      \n
    • JPQL (Java Persistence Query Language) Queries<\/strong>: JPQL allows developers to write SQL-like queries to retrieve specific fields from entities. By selecting only the required fields in the SELECT clause, you can achieve data projection.<\/li>\n<\/ul>\n
           @Query(\"SELECT NEW com.ttn.dataProjection.dto.UserDetailsProjectionDTO(u.name, u.email, a.city, a.pincode) FROM UserDetails u JOIN u.address a\")<\/span>\r\n     List<UserDetailsProjectionDTO> findAllByActiveTrueOrderByNameDesc<\/span>()<\/span>;<\/pre>\n
        \n
      • Spring Data JPA Projections:<\/strong>\u00a0Spring Data JPA provides a powerful feature called projections, which allows defining interfaces to represent the desired subset of data. These projections can be used directly in repository methods.<\/li>\n<\/ul>\n
        @Data<\/span>\r\npublic<\/span> class<\/span> UserDetailsProjectionDTO<\/span> {\r\nprivate<\/span> String name;\r\nprivate<\/span> String email;\r\nprivate<\/span> String city;\r\nprivate<\/span> String pincode;\r\n\r\npublic<\/span> UserDetailsProjectionDTO<\/span>(String name, String email, String city, String pincode)<\/span> {\r\nthis<\/span>.name = name;\r\nthis<\/span>.email = email;\r\nthis<\/span>.city = city;\r\nthis<\/span>.pincode = pincode;\r\n}\r\n}\r\n\r\npublic<\/span> interface<\/span> RolesProjection<\/span> {\r\n\r\nString getName<\/span>()<\/span>;\r\n}\r\n\r\n\r\npublic<\/span> interface<\/span> AddressProjection<\/span> {\r\nString getCity<\/span>()<\/span>;\r\nString getPincode<\/span>()<\/span>;\r\n}<\/pre>\n
          \n
        • DTO (Data Transfer Object) Projection:<\/strong> Another common approach is to use DTOs to represent the projected data. DTOs are plain Java objects that contain only the fields needed for a particular use case.<\/li>\n<\/ul>\n
          \/\/create a class with name UserDetailsDto,AddressDto and RolesDto and add below code.<\/span>\r\n@Data<\/span>\r\n@JsonPropertyOrder({\"name\",\"email\",\"mobile\",\"address\",\"roles\"})<\/span>\r\npublic<\/span> class<\/span> UserDetailsDto<\/span> {\r\nprivate<\/span> String name;\r\nprivate<\/span> String email;\r\nprivate<\/span> String mobile;\r\nprivate<\/span> List<AddressDto> address;\r\nprivate<\/span> List<RolesDto> roles;\r\n}\r\n\r\n@Data<\/span>\r\npublic<\/span> class<\/span> AddressDto<\/span> {\r\nprivate<\/span> String city;\r\nprivate<\/span> String pincode;\r\n}\r\n\r\n@Data<\/span>\r\npublic<\/span> class<\/span> RolesDto<\/span> {\r\nprivate<\/span> String name;\r\n}\r\n\r\n public<\/span> List<UserDetailsDto> getAllByDto<\/span>()<\/span> {\r\nList<UserDetails> userDetailsList= userDetailsRepository.findAll();\r\nList<UserDetailsDto> userDetailsDtoList=new<\/span> ArrayList<\/span><>();\r\nuserDetailsList.forEach(userDetails -> {\r\nUserDetailsDto userDetailsDto=new<\/span> UserDetailsDto<\/span>();\r\nBeanUtils.copyProperties(userDetails,userDetailsDto);\r\nList<AddressDto> addressDtoList=new<\/span> ArrayList<\/span><>();\r\nuserDetails.getAddress().forEach(address -> {\r\nAddressDto addressDto=new<\/span> AddressDto<\/span>();\r\nBeanUtils.copyProperties(address,addressDto);\r\naddressDtoList.add(addressDto);\r\n});\r\nuserDetailsDto.setAddress(addressDtoList);\r\nList<RolesDto> rolesDtoList=new<\/span> ArrayList<\/span><>();\r\nuserDetails.getRoles().forEach(roles -> {\r\nRolesDto rolesDto=new<\/span> RolesDto<\/span>();\r\nBeanUtils.copyProperties(roles,rolesDto);\r\nrolesDtoList.add(rolesDto);\r\n});\r\nuserDetailsDto.setRoles(rolesDtoList);\r\nuserDetailsDtoList.add(userDetailsDto);\r\n});\r\nreturn<\/span> userDetailsDtoList;\r\n}<\/pre>\n
          Project Details :<\/strong><\/h2>\n
          In the context of a User Management System, let\u2019s consider three entities: UserDetails, Roles, and Address. Within this project, I have developed a set of five APIs to facilitate various functionalities.<\/p>\n
            \n
          1. Create API for the user.<\/li>\n
          2. Fetching All Users with Entity.<\/li>\n
          3. Retrieving user details, including specific fields of an entity, can be accomplished by utilizing the\u00a0\u201cSpring Data JPA Projections\u201d<\/strong>\u00a0technique.<\/li>\n
          4. Retrieving user details, including specific fields of an entity, can be accomplished by utilizing the\u00a0\u201cDTO (Data Transfer Object) Projection\u201d<\/strong>\u00a0technique.<\/li>\n
          5. Retrieving user details, including specific fields of an entity, can be accomplished by utilizing the\u00a0\u201cJPQL (Java Persistence Query Language) Queries\u201d<\/strong>\u00a0technique.<\/li>\n<\/ol>\n
            @RequestMapping(value = \"\/user\")<\/span>\r\n@RestController<\/span>\r\npublic<\/span> class<\/span> UserController<\/span> {\r\n\r\nprivate<\/span> final<\/span> UserService userService;\r\n\r\n@Autowired<\/span>\r\npublic<\/span> UserController<\/span>(UserService userService)<\/span> {\r\nthis<\/span>.userService = userService;\r\n}\r\n\r\n@PostMapping(value = \"\/create\")<\/span>\r\npublic<\/span> UserDetails createUser<\/span>(@RequestBody<\/span> UserDetails userDetails)<\/span> {\r\nreturn<\/span> userService.createUser(userDetails);\r\n}\r\n\r\n@GetMapping(value = \"\/getAll\")<\/span>\r\npublic<\/span> List<UserDetails> getAllUsers<\/span>()<\/span>{\r\nreturn<\/span> userService.getAllUsers();\r\n}\r\n\r\n@GetMapping(value = \"\/getAllByProjection\")<\/span>\r\npublic<\/span> List<UserDetailsProjection> getAllByProjection<\/span>()<\/span>{\r\nreturn<\/span> userService.getAllUsersByProjection();\r\n}\r\n@GetMapping(value = \"\/getAllByDto\")<\/span>\r\npublic<\/span> List<UserDetailsDto> getAllByDto<\/span>()<\/span>{\r\nreturn<\/span> userService.getAllByDto();\r\n}\r\n\r\n@GetMapping(value = \"\/getAllByJPQL\")<\/span>\r\npublic<\/span> List<UserDetailsProjectionDTO> getAllByJPQL<\/span>()<\/span>{\r\nreturn<\/span> userService.getAllByJPQL();\r\n}\r\n}<\/pre>\n
            Below are some PROS and CONS of spring data projection techniques through which you can find out which technique you can use according to your situation.<\/p>\n
            JPQL Queries:<\/strong>
            \nPros:<\/h3>\n
              \n
            1. Fine-grained Control:<\/strong>\u00a0JPQL queries offer precise control over the fields to be selected, allowing developers to fetch exactly what they need.<\/li>\n
            2. Flexibility:<\/strong>\u00a0Developers can leverage the full power of JPQL, including joins, aggregates, and complex filtering conditions.<\/li>\n
            3. Performance Optimization:<\/strong>\u00a0By selecting only necessary fields, JPQL queries can optimize database performance by reducing the amount of data transferred.<\/li>\n<\/ol>\n
              Cons :<\/strong><\/h3>\n
                \n
              1. Syntax Complexity:<\/strong>\u00a0Writing JPQL queries can be more complex and verbose compared to other projection techniques, especially for developers less familiar with SQL-like syntax.<\/li>\n
              2. Potential for Typos and Errors:\u00a0<\/strong>Due to the dynamic nature of JPQL queries, there\u2019s a higher likelihood of typos or errors in query construction, leading to runtime issues.<\/li>\n<\/ol>\n
                Spring Data JPA Projections:<\/strong><\/h2>\n
                Pros :<\/strong><\/h3>\n
                  \n
                1. Type Safety:\u00a0<\/strong>Spring Data JPA projections provide type-safe interfaces or classes for representing projected data, reducing the risk of runtime errors.<\/li>\n
                2. Simplicity:\u00a0<\/strong>Projections can be defined as interfaces or classes with getter methods, making them easy to understand and maintain.<\/li>\n
                3. Integrated with Repository:<\/strong>\u00a0Projections can be seamlessly integrated into repository methods, allowing for clean and concise query definitions.<\/li>\n
                4. Reduced Boilerplate Code:<\/strong>\u00a0Projections eliminate the need for manually mapping query results to DTOs or other data structures, reducing boilerplate code.<\/li>\n<\/ol>\n
                  Cons:<\/strong><\/h3>\n
                    \n
                  1. Limited Expressiveness:\u00a0<\/strong>When it comes to complex query constructs, JPQL queries have broader support in comparison to projections, which could limit their usefulness in certain situations.<\/li>\n
                  2. Static Definition:<\/strong>\u00a0To create projections, it is necessary to have pre-defined interfaces. However, this approach might not be very flexible for dynamic projections.<\/li>\n<\/ol>\n
                    DTO Projection:<\/strong><\/h2>\n
                    Pros:<\/strong><\/h3>\n
                      \n
                    1. Flexibility:<\/strong>\u00a0DTO projection allows developers to define custom data transfer objects tailored to specific use cases, providing maximum flexibility.<\/li>\n
                    2. Serialization Control:\u00a0<\/strong>DTOs enable fine-grained control over the data to be serialized and transmitted over the network, improving performance and reducing bandwidth usage.<\/li>\n
                    3. Encapsulation:<\/strong>\u00a0DTOs encapsulate projected data, promoting better encapsulation and separation of concerns within the application architecture.<\/li>\n
                    4. Reusability:\u00a0<\/strong>DTOs can be reused across multiple queries or use cases, promoting code reuse and maintainability.<\/li>\n<\/ol>\n
                      Cons:<\/strong><\/h3>\n
                        \n
                      1. Additional Mapping Overhead:<\/strong>\u00a0DTO projection requires additional mapping code to transform entity objects into DTOs, potentially introducing overhead, especially for complex mappings.<\/li>\n
                      2. Manual Synchronization:<\/strong>\u00a0Developers must ensure synchronization between entity attributes and DTO fields, which can be cumbersome and error-prone, especially in large projects.<\/li>\n
                      3. Boilerplate Code:\u00a0<\/strong>DTOs often require writing additional boilerplate code for defining classes, constructors, getters, and setters, increasing development effort and verbosity.<\/li>\n<\/ol>\n
                        Project Souce Code :<\/strong><\/h2>\n
                        https:\/\/github.com\/ankit25496kumar\/data-projection<\/p>\n
                        Reference :<\/h2>\n
                        https:\/\/medium.com\/@ankit25496kumar\/understanding-data-projection-in-spring-boot-with-hibernate-23a581a13781<\/p>\n
                        <\/div>","protected":false},"excerpt":{"rendered":"
                        This article will delve into data projection in the context of Spring Boot and Hibernate. This blog will examine the significance of data projection, its advantages, and disadvantages. Furthermore, I will provide a comprehensive explanation of how to implement it in your Spring Boot applications efficiently. What is data Projection? Data projection in database querying […]<\/p>\n","protected":false},"author":1765,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":191},"categories":[446,1994],"tags":[5831,5830,2072],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/61270"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1765"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=61270"}],"version-history":[{"count":3,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/61270\/revisions"}],"predecessor-version":[{"id":61359,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/61270\/revisions\/61359"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=61270"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=61270"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=61270"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}