Angular表单传参至Spring后，如何实现JPA Repository动态字段查询？

一、后端Spring Boot实现 #

1. 定义参数接收DTO #

创建DTO类接收前端传递的查询参数，允许字段为空：

public class QueryParamsDTO {
    private String symbol;
    private String currency;

    // Getter & Setter
    public String getSymbol() { return symbol; }
    public void setSymbol(String symbol) { this.symbol = symbol; }
    public String getCurrency() { return currency; }
    public void setCurrency(String currency) { this.currency = currency; }
}

2. 声明JPA Repository查询方法 #

在Repository接口中定义对应查询方法，JPA会自动生成实现：

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {
    // 按symbol查询
    List<YourEntity> findAllBySymbol(String symbol);
    // 按symbol+currency联合查询
    List<YourEntity> findAllBySymbolAndCurrency(String symbol, String currency);
}

3. Service层实现动态逻辑判断 #

根据参数非空情况，调用对应Repository方法：

import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class YourEntityService {
    private final YourEntityRepository repository;

    // 构造注入
    public YourEntityService(YourEntityRepository repository) {
        this.repository = repository;
    }

    public List<YourEntity> queryByParams(QueryParamsDTO params) {
        String symbol = params.getSymbol();
        String currency = params.getCurrency();

        if (symbol != null && currency != null) {
            return repository.findAllBySymbolAndCurrency(symbol, currency);
        } else if (symbol != null) {
            return repository.findAllBySymbol(symbol);
        } else {
            // 按需处理无有效参数的情况，比如抛异常或返回空列表
            throw new IllegalArgumentException("至少需输入symbol参数");
        }
    }
}

4. Controller层接收请求 #

编写RestController处理前端POST请求：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
public class YourEntityController {
    private final YourEntityService service;

    public YourEntityController(YourEntityService service) {
        this.service = service;
    }

    @PostMapping("/api/entities/query")
    public List<YourEntity> queryEntities(@RequestBody QueryParamsDTO params) {
        return service.queryByParams(params);
    }
}

二、前端Angular实现 #

构造请求体并发送POST请求，可移除空字符串避免无效参数：

import { HttpClient } from '@angular/common/http';
import { Component } from '@angular/core';

@Component({
  selector: 'app-query-form',
  templateUrl: './query-form.component.html'
})
export class QueryFormComponent {
  queryParams = { symbol: '', currency: '' };

  constructor(private http: HttpClient) {}

  onSubmit() {
    // 过滤空值参数
    const requestBody = Object.fromEntries(
      Object.entries(this.queryParams).filter(([_, value]) => value.trim() !== '')
    );

    this.http.post('/api/entities/query', requestBody)
      .subscribe(response => {
        // 处理查询结果
        console.log(response);
      });
  }
}

进阶方案：JPA Specification（多字段场景更优雅） #

如果后续字段增多，手动判断逻辑会繁琐，推荐用Specification动态构建查询：

1. 编写Specification构建类 #

import org.springframework.data.jpa.domain.Specification;
import jakarta.persistence.criteria.Predicate;
import java.util.ArrayList;
import java.util.List;

public class YourEntitySpecifications {
    public static Specification<YourEntity> withParams(QueryParamsDTO params) {
        return (root, query, criteriaBuilder) => {
            List<Predicate> predicates = new ArrayList<>();

            if (params.getSymbol() != null && !params.getSymbol().isEmpty()) {
                predicates.add(criteriaBuilder.equal(root.get("symbol"), params.getSymbol()));
            }
            if (params.getCurrency() != null && !params.getCurrency().isEmpty()) {
                predicates.add(criteriaBuilder.equal(root.get("currency"), params.getCurrency()));
            }

            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }
}

2. 修改Repository和Service #

Repository继承JpaSpecificationExecutor：

public interface YourEntityRepository extends JpaRepository<YourEntity, Long>, JpaSpecificationExecutor<YourEntity> {
}

Service中调用Specification查询：

public List<YourEntity> queryByParams(QueryParamsDTO params) {
    Specification<YourEntity> spec = YourEntitySpecifications.withParams(params);
    return repository.findAll(spec);
}

该方式会自动根据非空参数生成对应WHERE条件，无需手动判断调用方法，扩展性更强。

内容的提问来源于stack exchange，提问作者matel