Simplify Spring Service Calls with ServiceManager: No @Autowired, Unified Logging & Error Handling

Background

When building Spring applications, developers often write repetitive code: injecting a service in each controller, adding logging statements, and wrapping every call in try‑catch blocks. This boilerplate makes the code noisy and error‑prone.

Solution – ServiceManager Component

The author introduces a reusable component called ServiceManager that accepts a Lambda expression representing a service method, automatically resolves the target Spring bean, caches the service metadata, and executes the method with unified logging and exception handling. This removes the need for explicit @Autowired fields and duplicated error handling.

Core Classes

SerResult

– a generic wrapper for API responses (code, message, data). LambdaUtil – extracts a SerializedLambda from a Lambda to obtain the implementing class and method name. SpringUtil – provides ApplicationContext access to retrieve beans programmatically. InstBuilder – a generic builder that creates objects and allows fluent set calls. ServiceManager – static call method, a cache of LambdaMeta objects, and an inner LambdaMeta class that stores the service class, instance, and method name. ServiceExecutor – performs the actual method invocation, logs start/end, measures execution time, and returns a SerResult.

Key Code Snippets

public static <U, R> SerResult call(SerialBiFunction<?, U, R> fn, U param) {
    if (fn == null) {
        return SerResult.fail("服务函数不能为空！");
    }
    LambdaMeta lambdaMeta = (LambdaMeta) CACHE_LAMBDA.computeIfAbsent(fn, k -> {
        LambdaMeta meta = parseSerialFunction(fn);
        log.debug("缓存Service信息：{}", meta.getServiceName());
        return meta;
    });
    ServiceExecutor executor = InstBuilder.of(ServiceExecutor.class)
        .set(ServiceExecutor::setServiceFn, fn)
        .set(ServiceExecutor::setParam, param)
        .set(ServiceExecutor::setLambdaMeta, lambdaMeta)
        .build();
    return executor.callService();
}

// Example usage in a controller
@GetMapping("/{userId}")
public SerResult getUser(@PathVariable Long userId) {
    return ServiceManager.call(UserService::queryUser, userId);
}

@PutMapping("/{userId}")
public SerResult updateUser(@PathVariable Long userId,
                           @RequestBody UserUpdateDTO updateDTO) {
    return ServiceManager.call(
        (UserService service, UserUpdateDTO dto) -> service.updateUser(userId, dto),
        updateDTO);
}

Benefits

No need to declare @Autowired fields in controllers; the service is obtained automatically.

Logging format and exception handling are centralized in ServiceExecutor, so changes affect all endpoints.

Parsed service metadata is cached, making subsequent calls faster.

Compile‑time safety: the Lambda’s method reference guarantees that a non‑existent method causes a compilation error.

Gotchas / Caveats

Requires JDK 8 or higher because the solution relies on Lambda expressions.

The target service must be a Spring bean (annotated with @Service); otherwise SpringUtil.getBean will fail.

If an interface has multiple implementations, you need a bean‑by‑name lookup in SpringUtil to avoid ambiguity.