What mechanisms exist for handling complex queries…

The following mechanisms are used in Java to handle complex requests with multiple parameters:

POJO (Plain Old Java Object) as a parameter container: A class is created with fields corresponding to the expected request parameters. Frameworks like Spring can automatically bind HTTP request parameters to the fields of this object.
@RequestParam with Required = false: Allows specifying that a certain parameter is not mandatory.
@ModelAttribute: Used in Spring MVC to bind request parameters to a model object. Convenient for populating complex objects from form data.
@RequestBody in conjunction with JSON/XML: When using RESTful services, complex parameters can be transmitted in the request body in JSON or XML format. Frameworks (such as Spring Boot with Jackson or JAX-B) deserialize the data into Java objects.
PathVariableMap: In Spring MVC, allows obtaining all path parameters as a Map.
HttpServletRequest: Low-level access to the request object for manual parameter processing. Usually avoided in modern frameworks in favor of higher-level mechanisms.
Custom validator classes or specifications (e.g., Bean Validation): For validating parameter values after binding.
Builder or factory methods: Useful for programmatically creating complex parameter objects before passing them to the request handling method.

Example of using POJO in Spring MVC:

// Class representing request parameters
public class SearchCriteria {
    private String keyword;
    private Double minPrice;
    private Double maxPrice;
    // getters and setters
}

// Controller method accepting POJO
@GetMapping("/search")
public String performSearch(SearchCriteria criteria, Model model) {
    // Processing parameters from criteria object
    System.out.println("Searching for: " + criteria.getKeyword());
    // ...
    return "searchResults";
}

Example of using @RequestBody with JSON:

// Class representing request data from the body
public class ProductRequest {
    private String productName;
    private int quantity;
    // getters and setters
}

// Controller method accepting POJO from request body
@PostMapping(value = "/products", consumes = MediaType.APPLICATION_JSON_VALUE)
@ResponseBody
public String createProduct(@RequestBody ProductRequest request) {
    // Loading data from request object
    System.out.println("Creating product: " + request.getProductName());
    // ...
    return "Product created successfully";
}

What mechanisms exist for handling complex queries with multiple parameters?