使用@RequestParams时，Spring Boot中的Query by Example可以用来替代条件逻辑吗？

Question

I have the following code for a Spring Boot application:

Entity:

@Proxy(lazy = false)
public class Vehicle {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String type;
  private String make;
  private String model;
  private Integer year;

Controller:

@RequestMapping("/vehicles")
public class VehicleController {

  @Autowired
  private VehicleService vehicleService;

  //GET method to get all vehicles, or specify a parameter
  @GetMapping
  @ResponseStatus(HttpStatus.OK)
  public List<Vehicle> getAllVehicles(
      @RequestParam(required = false) Map<String, String> allParams) {
    return vehicleService.getVehicles(allParams);
  }

Service:

  private VehicleRepository vehicleRepository;

  /**
   * Gets the full list of vehicles based on the provided parameters. If no parameters are
   * presented, then returns the entire list of vehicles
   *
   * @param allParams A map of all possible parameters that can be passed through
   * @return list of vehicles
   */
  @Override
  public List<Vehicle> getVehicles(Map<String, String> allParams) {
    //gather all of the possible parameters that can be passed through
    String type = allParams.get("type");
    String make = allParams.get("make");
    String model = allParams.get("model");
    Integer year;
    try {
      year = Integer.parseInt(allParams.get("year"));
    } catch (NumberFormatException n) {
      year = 0;
    }

    if (type != null && make != null && model != null && year != 0) {
      return vehicleRepository.findByTypeAndMakeAndModelAndYear(type, make, model, year);
    }
    if (make != null && type == null && model != null && year != 0) {
      return vehicleRepository.findByMakeAndModelAndYear(make, model, year);
    }
    if (type != null && make == null && model != null && year != 0) {
      return vehicleRepository.findByTypeAndModelAndYear(type, model, year);
    }
    if (type != null && make != null && model == null && year != 0) {
      return vehicleRepository.findByTypeAndMakeAndYear(type, make, year);
    }
    if (model != null && type == null && make == null && year != 0) {
      return vehicleRepository.findByModelAndYear(model, year);
    }
    if (make != null && type == null && model == null && year != 0) {
      return vehicleRepository.findByMakeAndYear(make, year);
    }
    if (type != null && make == null && model == null && year != 0) {
      return vehicleRepository.findByTypeAndYear(type, year);
    }
    if (type != null && make != null && model != null) {
      return vehicleRepository.findByTypeAndMakeAndModel(type, make, model);
    }
    if (make != null && type == null && model != null) {
      return vehicleRepository.findByMakeAndModel(make, model);
    }
    if (type != null && make == null && model != null) {
      return vehicleRepository.findByTypeAndModel(type, model);
    }
    if (type != null && make != null) {
      return vehicleRepository.findByTypeAndMake(type, make);
    }
    if (type != null) {
      return vehicleRepository.findByType(type);
    }
    if (make != null) {
      return vehicleRepository.findByMake(make);
    }
    if (model != null) {
      return vehicleRepository.findByModel(model);
    }
    if (year != 0) {
      return vehicleRepository.findByYear(year);
    }

    return vehicleRepository.findAll();
  }

Repository:

public interface VehicleRepository extends JpaRepository<Vehicle, Long> {

  List<Vehicle> findByTypeAndMakeAndModelAndYear(String type, String make, String model,
      Integer year);

  List<Vehicle> findByMakeAndModelAndYear(String make, String model, Integer year);

  List<Vehicle> findByTypeAndModelAndYear(String type, String model, Integer year);

  List<Vehicle> findByTypeAndMakeAndYear(String type, String make, Integer year);

  List<Vehicle> findByModelAndYear(String model, Integer year);

  List<Vehicle> findByMakeAndYear(String make, Integer year);

  List<Vehicle> findByTypeAndYear(String type, Integer year);

  List<Vehicle> findByTypeAndMakeAndModel(String type, String make, String model);

  List<Vehicle> findByMakeAndModel(String make, String model);

  List<Vehicle> findByTypeAndModel(String type, String model);

  List<Vehicle> findByTypeAndMake(String type, String make);

  List<Vehicle> findByType(String type);

  List<Vehicle> findByMake(String make);

  List<Vehicle> findByModel(String model);

  List<Vehicle> findByYear(Integer year);

}

Obviously, the service layer has a lot of conditional logic to cover multiple combinations of the passed parameters. While it achieves my goal of accounting for any queries being passed through (ie http://localhost:8080/vehicles?make=&model=&year=&type= ), I want to figure out if there's a way to refactor the code to make it more efficient. Would a query-by-example from Spring be a sufficient way to solve this, or is there a better way? (or is this code about as good as I can make it?)

Answer 1

I recommend that Spring JPA ExampleMatcher . It is one of the easiest JPA query methods. You create a probe variable that defines searching on the database. Only non-null values are included in queries, for more information, Spring Data JPA Query by Example . Also, I have used Lombok library for @Data annotation. You can discard it if you don't prefer.

Vehicle.java

@Data
@Entity
@Table
public class Vehicle {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String type;
    private String make;
    private String model;
    private Integer year;
}

VehicleController.java

@RequestMapping("/vehicles")
@RestController
public class VehicleController{

    @Autowired
    private VehicleService vehicleService;

    //GET method to get all vehicles, or specify a parameter
    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    public List<Vehicle> getAllVehicles(
            @RequestParam(required = false) Map<String, String> allParams) {
        return vehicleService.getVehicles(allParams);
    }
}

VehicleRepository.java

public interface VehicleRepository extends JpaRepository<Vehicle, Long> {
}

VehicleService.java

@Service
public class VehicleService {
    @Autowired
    private VehicleRepository vehicleRepository;

    public List<Vehicle> getVehicles(Map<String, String> allParams) {
        if (allParams.isEmpty()) {
            return vehicleRepository.findAll();
        }
        Vehicle probe = new Vehicle();
        if (allParams.containsKey("type")) {
            probe.setType(allParams.get("type"));
        }
        if (allParams.containsKey("make")) {
            probe.setMake(allParams.get("make"));
        }
        if (allParams.containsKey("year")) {
            probe.setYear(Integer.parseInt(allParams.get("year")));
        }
        if (allParams.containsKey("model")) {
            probe.setModel(allParams.get("model"));
        }
        Example<Vehicle> example = Example.of(probe,
                ExampleMatcher.matchingAll()
                        .withIgnoreCase());
        return vehicleRepository.findAll(example);
    }
}