In Spring Boot applications, efficient data filtering mechanisms are indispensable for providing users with tailored experiences. Whether it’s searching for items by name, quantity, or status, implementing robust filtering functionalities ensures a seamless user interaction. In this blog post, we’ll delve into the utilization of Specification<Item> in a Spring Boot service, allowing for flexible and precise data retrieval. We’ll cover everything from the Data Transfer Object (DTO) to the Controller, Service, Entity, Repository, and even provide sample curl requests for testing.

Defining the Data Transfer Object (DTO)

A Data Transfer Object (DTO) is a plain Java object used to transfer data between the client and the server. In our case, the ItemFilterDTO encapsulates the filtering criteria that users can specify when querying items. This DTO includes fields such as partialName, quantity, and outOfStock, allowing users to filter items based on name, quantity, and availability status.

public class ItemFilterDTO {
    private String partialName;
    private Integer quantity;
    private Boolean outOfStock;
    // Other fields, getters, and setters
}

Creating the Entity Class (Item)

The Entity class represents the structure of the items stored in the database. It typically corresponds to a table in the database and includes fields that map to columns in that table. Here, our Item entity contains attributes such as name, quantity, soldQuantity, listingDate, and enabled, which define the properties of each item.

@Entity
public class Item {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int quantity;
    private int soldQuantity;
    private LocalDateTime listingDate;
    private boolean enabled;
    // Constructors, getters, and setters
}

Implementing the Repository Interface (ItemRepository)

The Repository interface provides methods for performing CRUD operations (Create, Read, Update, Delete) on items in the database. In addition to basic CRUD methods, the ItemRepository interface extends JpaSpecificationExecutor<Item>, allowing us to execute dynamic queries using Specifications.

public interface ItemRepository extends JpaRepository<Item, Long>, JpaSpecificationExecutor<Item> {
    // Custom query methods if needed
}

Building the Service (ItemService)

The Service layer contains the business logic of our application. In the ItemService class, we define a method filterItems(ItemFilterDTO filterDTO) that accepts a filterDTO containing user-defined filtering criteria. Inside this method, we construct a Specification<Item> based on the provided criteria and use it to filter items from the database.

@Service
public class ItemService {
    @Autowired
    private ItemRepository itemRepository;

    public List<Item> filterItems(ItemFilterDTO filterDTO) {
        Specification<Item> spec = Specification.where(null);

        if (filterDTO.getPartialName() != null) {
            spec = spec.and((root, query, criteriaBuilder) ->
                    criteriaBuilder.like(root.get("name"), "%" + filterDTO.getPartialName() + "%"));
        }

        // Other filtering criteria...

        return itemRepository.findAll(spec);
    }
}

Setting up the Controller (ItemController)

The Controller layer handles incoming HTTP requests and delegates them to the appropriate methods in the Service layer. In the ItemController class, we define a GET endpoint /items/filter that accepts a JSON payload containing filter criteria. This endpoint invokes the filterItems() method of the ItemService to retrieve filtered items from the database.

@RestController
@RequestMapping("/items")
public class ItemController {
    @Autowired
    private ItemService itemService;

    @GetMapping("/filter")
    public ResponseEntity<List<Item>> filterItems(@RequestBody ItemFilterDTO filterDTO) {
        List<Item> filteredItems = itemService.filterItems(filterDTO);
        return ResponseEntity.ok(filteredItems);
    }
}

Sample Curl Requests for Testing

Filtering by partial name match

curl -X GET -H "Content-Type: application/json" -d '{"partialName":"keyword"}' http://localhost:8080/items/filter

Filtering by quantity

curl -X GET -H "Content-Type: application/json" -d '{"quantity":10}' http://localhost:8080/items/filter

Filtering by out of stock items

curl -X GET -H "Content-Type: application/json" -d '{"outOfStock":true}' http://localhost:8080/items/filter

Combining multiple filters

curl -X GET -H "Content-Type: application/json" -d '{"partialName":"keyword", "quantity":10, "outOfStock":true}' http://localhost:8080/items/filter

By incorporating Specification<Item> in our Spring Boot service, we’ve empowered our application with advanced filtering capabilities. This not only enhances user experience but also improves the overall efficiency and usability of the system. Feel free to customize and expand upon these concepts to suit the specific requirements of your project. Happy coding!