如何优化Java类的委托架构，减少繁琐重复工作？

问题背景 #

我有一个使用Guice依赖注入的Java项目，出于可读性考虑，将一个过于庞大的类拆分为多个更小的类，实现方式如下：

public interface FooDataService { Foo getFoo(); }
public class FooDataServiceImpl implements FooDataService { @Override public Foo getFoo() { /* 实现 */ } }
// 还有BarDataService、BazDataService等类似的服务接口与实现类

public interface DataService extends FooDataService, BarDataService {}
public class DataServiceImpl implements DataService {
    private final FooDataService fooDataService;
    private final BarDataService barDataService;
    // ... 更多服务依赖

    @Inject
    public DataServiceImpl(FooDataService fooDataService, BarDataService barDataService) {
        this.fooDataService = fooDataService;
        this.barDataService = barDataService;
        // ... 初始化更多依赖
    }
    
    @Override public Foo getFoo(){ return fooDataService.getFoo(); }
    @Override public Bar getBar(){ return barDataService.getBar(); }
    // 后续还有大量类似的转发方法
}

// 使用场景
public class ApiService {
    // 原本的想法是只注入一个dataService，避免注入多个XDataService
    // 除了单元测试外，几乎没有单独使用FooDataService而不用BarDataService的场景
    @Inject
    private final DataService dataService;

    public void doThing() {
      dataService.getFoo();
      dataService.getBar();
    }
}

这种拆分虽然让各个XDataService保持精简，也把原本2000+行的大类拆分掉，但带来了三个繁琐问题：

• 随着方法增加，DataServiceImpl已经达到600行，方法查找困难，多开发者协作时频繁出现合并冲突
• 若需在FooDataService中新增方法或修改方法签名，需要在4处修改（接口、实现类、聚合接口、聚合实现类的转发方法），十分繁琐
• 偶尔FooDataService需要调用BarDataService的方法，破坏了类之间原本清晰的职责分离

优化方案 #

1. 移除聚合类DataService，直接注入具体的XDataService #

放弃通过聚合类统一注入的方式，直接在需要的地方注入多个XDataService：

public class ApiService {
    private final FooDataService fooDataService;
    private final BarDataService barDataService;

    @Inject
    public ApiService(FooDataService fooDataService, BarDataService barDataService) {
        this.fooDataService = fooDataService;
        this.barDataService = barDataService;
    }

    public void doThing() {
      fooDataService.getFoo();
      barDataService.getBar();
    }
}

好处：

• 彻底消除DataServiceImpl的转发代码，避免合并冲突和方法查找困难
• 新增或修改XDataService的方法时，只需要修改对应的接口和实现类，无需改动其他地方
• 符合依赖注入的单一职责原则，依赖关系更清晰

2. 通过Guice直接处理XDataService之间的依赖 #

如果某个XDataService需要调用另一个服务，直接在其实现类中注入依赖，Guice会自动处理依赖链：

public class FooDataServiceImpl implements FooDataService {
    private final BarDataService barDataService;

    @Inject
    public FooDataServiceImpl(BarDataService barDataService) {
        this.barDataService = barDataService;
    }

    @Override
    public Foo getFoo() {
        // 可以直接调用barDataService的方法
        Bar bar = barDataService.getBar();
        return new Foo(bar);
    }
}

好处：

• 保持各个XDataService的职责清晰：FooDataService专注于Foo相关逻辑，需要Bar数据时直接依赖BarDataService，而非通过聚合类中转
• Guice会自动完成依赖注入，无需手动管理实例创建

3. 可选：批量注入服务（针对大量服务的场景） #

如果确实有很多XDataService需要统一管理，可以利用Guice的MapBinder批量注入：

首先在Guice模块中配置：

public class DataServiceModule extends AbstractModule {
    @Override
    protected void configure() {
        MapBinder<Class<?>, DataService> dataServiceBinder = MapBinder.newMapBinder(binder(), Class.class, DataService.class);
        dataServiceBinder.addBinding(FooDataService.class).to(FooDataServiceImpl.class);
        dataServiceBinder.addBinding(BarDataService.class).to(BarDataServiceImpl.class);
        // 绑定更多服务
    }
}

然后在使用类中注入Map：

public class ApiService {
    private final Map<Class<?>, DataService> dataServiceMap;

    @Inject
    public ApiService(Map<Class<?>, DataService> dataServiceMap) {
        this.dataServiceMap = dataServiceMap;
    }

    public void doThing() {
        FooDataService fooService = (FooDataService) dataServiceMap.get(FooDataService.class);
        BarDataService barService = (BarDataService) dataServiceMap.get(BarDataService.class);
        fooService.getFoo();
        barService.getBar();
    }
}

注意：这种方式仅适合需要动态获取服务的场景，否则直接注入具体服务的可读性更高。

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