Spring环境下实现抽象类方法如何避免代码重复？

以下是几种可行的重构方案，可彻底解决子类代码重复的问题：

方案一：将默认实现移至抽象父类 #

既然所有子类的抽象方法实现完全一致，直接在抽象类中提供这两个方法的具体实现，移除abstract修饰符即可。子类无需重写，直接继承父类的实现逻辑。

修改后的抽象类代码：

@Slf4j
public abstract class PublishMappingService {
    @Autowired
    private ErpPackageRepository erpPackageRepository;

    @Autowired
    private PubSubClient pubSubClient;

    @Autowired
    private RequestInfo requestInfo;

    // 移除abstract，提供默认实现
    public void publishMappingUpdateEvent(MappingsEntity mappingsEntity) {
        if (mappingsEntity != null) {
            String companyId = mappingsEntity.getCompanyId();
            publishEvent(companyId);
        }
    }

    // 移除abstract，提供默认实现
    public void publishMappingUpdateEvent(List<MappingsEntity> mappingsEntityList) {
        if (mappingsEntityList != null && !mappingsEntityList.isEmpty()) {
            String companyId = mappingsEntityList.get(0).getCompanyId();
            publishEvent(companyId);
        }
    }

    public void publishEvent(String companyId) {
        ErpPackage erpPackage;

        try {
            erpPackage = erpPackageRepository.getSelectedErpPackageForCompanyId(companyId);
            pubSubClient.publishEventAsync(
                    new MappingUpdatedEvent(
                            erpPackage.getPartnerId(), erpPackage.getCompanyId(),
                            erpPackage.getErpId(), this.requestInfo.getCorrelationId(),
                            null
                    )
            );
        } catch (NotFoundException e) {
            log.error("MappingsRepository::publishEvent: This entity is not registered with ECP - companyId: {}", companyId, e);
        } catch (Exception e) {
            log.error("MappingsRepository::publishEvent: Failed to publish MappingUpdatedEvent for {}", companyId, e);
        }
    }
}

简化后的子类代码：

public class A extends PublishMappingService {
    // 无需重写任何方法，直接继承父类实现
}

public class B extends PublishMappingService {
    // 无需重写任何方法，直接继承父类实现
}

适用场景：所有子类的抽象方法实现逻辑一致，后续若有特殊子类需要自定义逻辑，可单独重写对应方法。

方案二：创建中间基类隔离通用实现 #

若原抽象类需要保留abstract方法约束其他子类（比如部分子类需要自定义实现），可创建一个中间基类，继承原抽象类并实现通用逻辑，再让A、B类继承该中间类。

创建中间基类：

public abstract class AbstractBasePublishMappingService extends PublishMappingService {
    @Override
    public void publishMappingUpdateEvent(MappingsEntity mappingsEntity) {
        if (mappingsEntity != null) {
            String companyId = mappingsEntity.getCompanyId();
            publishEvent(companyId);
        }
    }

    @Override
    public void publishMappingUpdateEvent(List<MappingsEntity> mappingsEntityList) {
        if (mappingsEntityList != null && !mappingsEntityList.isEmpty()) {
            String companyId = mappingsEntityList.get(0).getCompanyId();
            publishEvent(companyId);
        }
    }
}

子类继承中间基类：

public class A extends AbstractBasePublishMappingService {
    // 无需重写方法
}

public class B extends AbstractBasePublishMappingService {
    // 无需重写方法
}

适用场景：原抽象类需要维持抽象方法的约束，仅部分子类使用通用实现。

方案三：组合模式提取通用逻辑 #

将重复的事件发布逻辑提取到独立的服务类中，子类通过注入该服务类来实现抽象方法，避免代码重复。

创建通用事件发布服务：

@Component
public class MappingEventPublisher {
    @Autowired
    private PublishMappingService publishMappingService;

    public void publishSingleMappingUpdate(MappingsEntity mappingsEntity) {
        if (mappingsEntity != null) {
            String companyId = mappingsEntity.getCompanyId();
            publishMappingService.publishEvent(companyId);
        }
    }

    public void publishBatchMappingUpdate(List<MappingsEntity> mappingsEntityList) {
        if (mappingsEntityList != null && !mappingsEntityList.isEmpty()) {
            String companyId = mappingsEntityList.get(0).getCompanyId();
            publishMappingService.publishEvent(companyId);
        }
    }
}

修改子类实现：

public class A extends PublishMappingService {
    @Autowired
    private MappingEventPublisher mappingEventPublisher;

    @Override
    public void publishMappingUpdateEvent(MappingsEntity mappingsEntity) {
        mappingEventPublisher.publishSingleMappingUpdate(mappingsEntity);
    }

    @Override
    public void publishMappingUpdateEvent(List<MappingsEntity> mappingsEntityList) {
        mappingEventPublisher.publishBatchMappingUpdate(mappingsEntityList);
    }
}

public class B extends PublishMappingService {
    @Autowired
    private MappingEventPublisher mappingEventPublisher;

    @Override
    public void publishMappingUpdateEvent(MappingsEntity mappingsEntity) {
        mappingEventPublisher.publishSingleMappingUpdate(mappingsEntity);
    }

    @Override
    public void publishMappingUpdateEvent(List<MappingsEntity> mappingsEntityList) {
        mappingEventPublisher.publishBatchMappingUpdate(mappingsEntityList);
    }
}

适用场景：需要解耦通用逻辑与子类，后续修改通用逻辑只需调整MappingEventPublisher，所有子类同步受益。

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