前言

在软件开发中，装饰者模式和策略模式是两种常用的设计模式，它们在特定的业务场景下能够发挥巨大的作用。本文将通过一个实际的埋点系统案例，探讨如何在 Java 中运用装饰者模式和策略模式，以及如何结合工厂方法模式来优化代码结构。

业务场景分析

随着互联网的发展，用户行为分析变得越来越重要，而埋点技术是实现用户行为分析的关键手段之一。埋点系统需要记录用户在应用中的各种操作行为，如点击、浏览、提交等，以便后续进行数据分析和业务决策。

假设我们正在开发一个在线教育平台，需要实现以下埋点功能：

1. 点击埋点：记录用户点击的位置。

2. 课程埋点：记录用户点击的课程信息。

3. 任务埋点：记录用户点击的任务信息。

这些埋点功能需要根据不同的业务场景进行动态组合，例如在课程页面的点击操作需要记录点击位置和课程信息，而在任务页面的点击操作需要记录点击位置和任务信息。

装饰者模式的应用

装饰者模式允许我们在不修改原有代码的基础上，动态地给对象添加职责。它由以下几部分组成：

• Component：定义对象的接口。

• Concrete Component：实现 Component 接口的具体对象。

• Decorator：维护一个对 Component 对象的引用，并定义与 Component 接口相同的接口。

• Concrete Decorator：实现 Decorator 接口，负责给 Component 对象添加特定的职责。
  

实现埋点功能

// Component 接口
public interface SaveMessage {
    void saveMessage(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest);
}

// Concrete Component：基础点击埋点
public class CommonClickPoint implements SaveMessage {
    @Override
    public void saveMessage(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        pointSaveBean.setClickLocation(pointSaveRequest.getClickLocation());
    }
}

// Decorator 抽象类
public abstract class AddPointMessageService implements SaveMessage {
    protected SaveMessage saveMessage;

    public AddPointMessageService(SaveMessage saveMessage) {
        this.saveMessage = saveMessage;
    }

    @Override
    public void saveMessage(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        saveMessage.saveMessage(pointSaveBean, pointSaveRequest);
    }
}

// Concrete Decorator：课程埋点
public class CourseClickPoint extends AddPointMessageService {
    public CourseClickPoint(SaveMessage saveMessage) {
        super(saveMessage);
    }

    @Override
    public void saveMessage(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        super.saveMessage(pointSaveBean, pointSaveRequest);
        pointSaveBean.setCourseId(pointSaveRequest.getCourseId());
    }
}

// Concrete Decorator：任务埋点
public class TaskClickPoint extends AddPointMessageService {
    public TaskClickPoint(SaveMessage saveMessage) {
        super(saveMessage);
    }

    @Override
    public void saveMessage(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        super.saveMessage(pointSaveBean, pointSaveRequest);
        pointSaveBean.setTaskId(pointSaveRequest.getTaskId());
    }
}

客户端代码

public class CommonMain {
    public static void main(String[] args) {
        // 初始化埋点类型列表
        List<PointSaveType> types = Arrays.asList(PointSaveType.TASK, PointSaveType.COURSE);

        // 初始化埋点保存对象
        PointSaveBean pointSaveBean = new PointSaveBean();

        // 初始化埋点请求对象
        PointSaveRequest pointSaveRequest = PointSaveRequest.builder()
                .pointSaveTypeList(types)
                .clickLocation("右上角落")
                .courseId("英语")
                .taskId("任务1")
                .build();

        // 初始化基础保存逻辑
        SaveMessage saveMessage = new CommonClickPoint();
        saveMessage.saveMessage(pointSaveBean, pointSaveRequest);
        System.out.println("基础埋点保存数据: " + pointSaveBean);

        // 根据埋点类型动态添加保存逻辑
        for (PointSaveType type : types) {
            if (type == PointSaveType.COURSE) {
                saveMessage = new CourseClickPoint(saveMessage);
            } else if (type == PointSaveType.TASK) {
                saveMessage = new TaskClickPoint(saveMessage);
            }
            saveMessage.saveMessage(pointSaveBean, pointSaveRequest);
        }

        // 打印最终埋点数据
        System.out.println("最终埋点保存数据: " + pointSaveBean);
    }
}

策略模式的应用

策略模式定义了一系列算法，并将每个算法封装到具有共同接口的独立类中，使它们可以互相替换。当埋点逻辑之间存在复杂的组合关系时，结合策略模式可以更好地管理这些组合逻辑。

实现埋点功能

// 策略接口
public interface PointSaveStrategy {
    void save(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest);
}

// 具体策略：点击埋点
public class ClickPointSaveStrategy implements PointSaveStrategy {
    @Override
    public void save(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        pointSaveBean.setClickLocation(pointSaveRequest.getClickLocation());
    }
}

// 具体策略：课程埋点
public class CoursePointSaveStrategy implements PointSaveStrategy {
    @Override
    public void save(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        pointSaveBean.setCourseId(pointSaveRequest.getCourseId());
    }
}

// 具体策略：任务埋点
public class TaskPointSaveStrategy implements PointSaveStrategy {
    @Override
    public void save(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        pointSaveBean.setTaskId(pointSaveRequest.getTaskId());
    }
}

// 策略上下文
public class PointSaveStrategyContext {
    private List<PointSaveStrategy> strategies = new ArrayList<>();

    public void addStrategy(PointSaveStrategy strategy) {
        strategies.add(strategy);
    }

    public void execute(PointSaveBean pointSaveBean, PointSaveRequest pointSaveRequest) {
        for (PointSaveStrategy strategy : strategies) {
            strategy.save(pointSaveBean, pointSaveRequest);
        }
    }
}

// 策略配置
public class PointSaveStrategyConfig {
    private static final Map<PointSaveType, PointSaveStrategy> STRATEGY_MAP = new HashMap<>();

    static {
        STRATEGY_MAP.put(PointSaveType.CLICK, new ClickPointSaveStrategy());
        STRATEGY_MAP.put(PointSaveType.COURSE, new CoursePointSaveStrategy());
        STRATEGY_MAP.put(PointSaveType.TASK, new TaskPointSaveStrategy());
    }

    public static PointSaveStrategy getStrategy(PointSaveType type) {
        return STRATEGY_MAP.getOrDefault(type, null);
    }
}

客户端代码

public class CommonMain {
    public static void main(String[] args) {
        // 初始化埋点类型列表
        List<PointSaveType> types = Arrays.asList(PointSaveType.TASK, PointSaveType.COURSE);

        // 初始化埋点保存对象
        PointSaveBean pointSaveBean = new PointSaveBean();

        // 初始化埋点请求对象
        PointSaveRequest pointSaveRequest = PointSaveRequest.builder()
                .pointSaveTypeList(types)
                .clickLocation("右上角落")
                .courseId("英语")
                .taskId("任务1")
                .build();

        // 创建策略上下文
        PointSaveStrategyContext context = new PointSaveStrategyContext();

        // 添加基础策略
        context.addStrategy(new ClickPointSaveStrategy());

        // 根据埋点类型动态添加策略
        for (PointSaveType type : types) {
            PointSaveStrategy strategy = PointSaveStrategyConfig.getStrategy(type);
            if (strategy != null) {
                context.addStrategy(strategy);
            }
        }

        // 执行所有策略
        context.execute(pointSaveBean, pointSaveRequest);

        // 打印最终埋点数据
        System.out.println("最终埋点保存数据: " + pointSaveBean);
    }
}

工厂方法模式的结合

为了进一步简化客户端代码，我们可以引入工厂方法模式来创建装饰者对象。

// 工厂类
public class PointSaveDecoratorFactory {
    public static SaveMessage getDecorator(PointSaveType type, SaveMessage saveMessage) {
        switch (type) {
            case COURSE:
                return new CourseClickPoint(saveMessage);
            case TASK:
                return new TaskClickPoint(saveMessage);
            default:
                System.out.println("未知的埋点类型: " + type);
                return saveMessage;
        }
    }
}

客户端代码优化

public class CommonMain {
    public static void main(String[] args) {
        // 初始化埋点类型列表
        List<PointSaveType> types = Arrays.asList(PointSaveType.TASK, PointSaveType.COURSE);

        // 初始化埋点保存对象
        PointSaveBean pointSaveBean = new PointSaveBean();

        // 初始化埋点请求对象
        PointSaveRequest pointSaveRequest = PointSaveRequest.builder()
                .pointSaveTypeList(types)
                .clickLocation("右上角落")
                .courseId("英语")
                .taskId("任务1")
                .build();

        // 初始化基础保存逻辑
        SaveMessage saveMessage = new CommonClickPoint();
        saveMessage.saveMessage(pointSaveBean, pointSaveRequest);
        System.out.println("基础埋点保存数据: " + pointSaveBean);

        // 根据埋点类型动态添加保存逻辑
        for (PointSaveType type : types) {
            saveMessage = PointSaveDecoratorFactory.getDecorator(type, saveMessage);
            saveMessage.saveMessage(pointSaveBean, pointSaveRequest);
        }

        // 打印最终埋点数据
        System.out.println("最终埋点保存数据: " + pointSaveBean);
    }
}

总结

在实际的开发过程中，合理地运用设计模式能够使我们的代码更加灵活、可维护和可扩展。装饰者模式适合用于在运行时动态地给对象添加职责，而策略模式则适合用于管理多种算法或行为的组合。通过结合工厂方法模式，我们可以进一步简化客户端代码，使系统更加模块化和易于使用。

通过本文的示例，我们看到了装饰者模式和策略模式在埋点系统中的有效应用。这些设计模式不仅解决了实际的业务问题，还为我们提供了应对复杂需求变化的优雅解决方案。在未来的开发中，我们可以根据具体的需求场景，灵活地选择和结合不同的设计模式，以构建高质量的软件系统。