如何抽象逻辑避免重复实现？JSF与REST场景代码复用咨询

针对JSF有状态类（SpecificHandler）和REST无状态类（SpecificOnCreate）的重复逻辑复用问题，以下是几种实用的实现思路：

方案1：提取独立的无状态业务服务类（最推荐） #

把SpecificHandler中需要复用的核心逻辑抽离到一个无状态的业务服务类中，这个类既可以被JSF的@ViewScoped类注入调用，也能适配REST无状态环境的需求。

代码示例： #

1. 新建无状态业务服务类

// 无状态的业务服务，可被任何组件依赖注入
@ApplicationScoped // 或@RequestScoped，根据实际需求选择，核心是无状态
public class ComponentCreationService {
    // 提取原SpecificHandler中的共用逻辑
    public Container createComponents(Object arg1, Object arg2, Object arg3) {
        // 这里放原来SpecificHandler里的核心业务逻辑
        return new Container();
    }

    // 适配REST接口的参数转换方法
    public Container createComponentsFromDto(Dto inputDto) {
        // 把Dto转换为createComponents需要的参数
        Object arg1 = extractArg1FromDto(inputDto);
        Object arg2 = extractArg2FromDto(inputDto);
        Object arg3 = extractArg3FromDto(inputDto);
        return createComponents(arg1, arg2, arg3);
    }

    // 辅助转换方法
    private Object extractArg1FromDto(Dto inputDto) { /* 实现转换逻辑 */ }
    private Object extractArg2FromDto(Dto inputDto) { /* 实现转换逻辑 */ }
    private Object extractArg3FromDto(Dto inputDto) { /* 实现转换逻辑 */ }
}

2. 修改JSF的SpecificHandler

@ViewScoped
public class SpecificHandler extends DefaultHandler {
    @Inject
    private ComponentCreationService creationService;

    @Override
    public Container createComponents(Object arg1, Object arg2, Object arg3) {
        // 直接调用业务服务复用逻辑
        return creationService.createComponents(arg1, arg2, arg3);
    }
}

3. 修改REST的SpecificOnCreate

public class SpecificOnCreate extends OnCreateBase {
    @Inject
    private ComponentCreationService creationService;

    @Override
    public Dto onCreate(Dto arg1) {
        // 调用适配方法复用核心逻辑
        Container container = creationService.createComponentsFromDto(arg1);
        // 后续把Container转换为返回Dto的逻辑
        return convertContainerToDto(container);
    }

    private Dto convertContainerToDto(Container container) { /* 实现转换逻辑 */ }
}

优点： #

• 符合分层架构原则，业务逻辑与框架耦合解耦
• 无状态服务天然适配REST环境，JSF有状态类也能安全注入使用
• 便于单元测试，业务逻辑可单独测试验证

方案2：提取静态工具类（适合无依赖的简单逻辑） #

如果共用逻辑没有外部依赖，可直接抽成静态工具类，让两个类直接调用静态方法。

代码示例： #

public class ComponentUtils {
    // 静态方法存放共用逻辑
    public static Container createComponents(Object arg1, Object arg2, Object arg3) {
        // 原共用逻辑
        return new Container();
    }

    // 适配Dto的静态方法
    public static Container createComponentsFromDto(Dto inputDto) {
        Object arg1 = extractArg1FromDto(inputDto);
        Object arg2 = extractArg2FromDto(inputDto);
        Object arg3 = extractArg3FromDto(inputDto);
        return createComponents(arg1, arg2, arg3);
    }

    private static Object extractArg1FromDto(Dto inputDto) { /* 实现转换逻辑 */ }
    // ... 其他辅助方法
}

修改两个业务类：

// SpecificHandler修改后
@ViewScoped
public class SpecificHandler extends DefaultHandler {
    @Override
    public Container createComponents(Object arg1, Object arg2, Object arg3) {
        return ComponentUtils.createComponents(arg1, arg2, arg3);
    }
}

// SpecificOnCreate修改后
public class SpecificOnCreate extends OnCreateBase {
    @Override
    public Dto onCreate(Dto arg1) {
        Container container = ComponentUtils.createComponentsFromDto(arg1);
        return convertContainerToDto(container);
    }
}

注意： #

• 静态类无法依赖注入其他服务，只适合纯逻辑、无外部依赖的场景
• 后续扩展或修改逻辑时，维护成本较高

方案3：使用组合模式替代继承（灵活适配不同接口） #

如果需要同时适配Handler和OnCreate两个不同接口，可以把共用逻辑封装成独立组件，让两个类通过组合的方式复用组件，而非依赖继承。

代码示例： #

1. 定义核心逻辑组件

public class ComponentCreator {
    public Container createComponents(Object arg1, Object arg2, Object arg3) {
        // 共用核心逻辑
        return new Container();
    }
}

2. 修改SpecificHandler（组合核心组件）

@ViewScoped
public class SpecificHandler extends DefaultHandler {
    private final ComponentCreator creator = new ComponentCreator(); // 或通过注入获取

    @Override
    public Container createComponents(Object arg1, Object arg2, Object arg3) {
        return creator.createComponents(arg1, arg2, arg3);
    }
}

3. 修改SpecificOnCreate（组合核心组件）

public class SpecificOnCreate extends OnCreateBase {
    private final ComponentCreator creator = new ComponentCreator(); // 或通过注入获取

    @Override
    public Dto onCreate(Dto arg1) {
        // 参数转换
        Object handlerArg1 = extractArg1FromDto(arg1);
        Object handlerArg2 = extractArg2FromDto(arg1);
        Object handlerArg3 = extractArg3FromDto(arg1);
        Container container = creator.createComponents(handlerArg1, handlerArg2, handlerArg3);
        // 转换为返回Dto
        return convertContainerToDto(container);
    }
}

优点： #

• 遵循"组合优于继承"的设计原则，避免继承带来的耦合
• 核心逻辑组件可独立维护，两个接口实现类仅负责参数和返回值的适配

内容的提问来源于stack exchange，提问作者Jan Kück