Dynamic Feign Client: Building a Generic Service Invocation Layer in Spring Cloud

Feign simplifies inter‑service communication in a microservice architecture by allowing developers to declare HTTP calls as Java interfaces, eliminating the need to write low‑level Http client code.

In the traditional approach, a separate Feign client interface and corresponding controller method must be created for each microservice and each endpoint, which quickly becomes verbose and hard to maintain.

The article proposes a dynamic Feign solution: a generic interface that defines common GET and POST methods, accepting the target URL and request parameters, and a factory that creates a Feign client for any service name at runtime.

public interface DynamicService {
    @PostMapping("{url}")
    Object executePostApi(@PathVariable("url") String url, @RequestBody Object params);

    @GetMapping("{url}")
    Object executeGetApi(@PathVariable("url") String url, @SpringQueryMap Object params);
}

The executePostApi method requires the endpoint url (matching the target controller’s mapping) and a params object that will be sent as the request body; the executeGetApi method works similarly for GET requests.

@Component
public class DynamicClient {
    @Autowired
    private DynamicFeignClientFactory<DynamicService> dynamicFeignClientFactory;

    public Object executePostApi(String feignName, String url, Object params) {
        DynamicService dynamicService = dynamicFeignClientFactory.getFeignClient(DynamicService.class, feignName);
        return dynamicService.executePostApi(url, params);
    }

    public Object executeGetApi(String feignName, String url, Object params) {
        DynamicService dynamicService = dynamicFeignClientFactory.getFeignClient(DynamicService.class, feignName);
        return dynamicService.executeGetApi(url, params);
    }
}

Parameters: feignName – the name of the target microservice, usually the value of spring.application.name (e.g., system). url – the endpoint path defined in the target service’s controller. params – the request payload; for POST it is annotated with @RequestBody, and the receiving controller must also use this annotation.

@Component
public class DynamicFeignClientFactory<T> {
    private FeignClientBuilder feignClientBuilder;

    public DynamicFeignClientFactory(ApplicationContext appContext) {
        this.feignClientBuilder = new FeignClientBuilder(appContext);
    }

    public T getFeignClient(final Class<T> type, String serviceId) {
        return this.feignClientBuilder.forType(type, serviceId).build();
    }
}

The factory builds a Feign client instance for the specified service ID, enabling the dynamic client to delegate calls without pre‑defining interfaces for each service.

Usage example:

DynamicClient dynamicClient = SpringUtil.getBean(DynamicClient.class);
Object result = dynamicClient.executePostApi("system", "/system/test", new HashMap<>());
System.out.println("==========>" + JSONObject.toJSONString(result));

By obtaining the DynamicClient bean and invoking executePostApi (or executeGetApi) with the desired service name, URL, and parameters, developers can call any microservice endpoint with a single, reusable Feign client, greatly reducing boilerplate code.