Refactoring Overburdened Classes in C++ Using the Sprout Class Technique

We have covered several approaches that focus on method-level refactoring techniques. But what about scenarios when entire classes need intervention? In this and several following lessons, we will focus on just that.

This lesson will explain the sprout class technique, which is particularly useful when dealing with classes that have taken on too many responsibilities. This technique helps in breaking down complex classes into more manageable and focused components, improving both readability and maintainability.

In software development, it's common to encounter classes that have grown too large and complex over time. These overburdened classes often handle multiple responsibilities, making them difficult to understand and maintain. Signs of such classes include long methods, numerous dependencies, and a mix of unrelated functionalities. For instance, a class that manages both order processing and metrics collection is doing too much.

The sprout class technique is a powerful refactoring strategy that involves extracting cohesive responsibilities from an overburdened class into a new class. This approach aligns with the single responsibility principle, which states that a class should have only one reason to change. By creating a new class to handle specific tasks, we can simplify the original class and make the codebase more modular. This not only enhances readability but also makes the code easier to test and maintain.

Let's walk through the process of applying the sprout class technique using a practical example. Back to the OrderProcessor!

Here's a simplified version of the OrderProcessor class before refactoring:

#include <vector>
#include <numeric>

class IDatabase {
public:
    virtual std::vector<Order> GetOrdersCreatedToday() = 0;
    virtual void SaveMetric(const std::string& name, int value) = 0;
};

class OrderProcessor {
private:
    IDatabase& database;

public:
    OrderProcessor(IDatabase& db) : database(db) {}

    bool ProcessOrder(const Order& order) {
        // ... some order processing logic ...

        auto todayOrders = database.GetOrdersCreatedToday();
        int totalRevenue = std::accumulate(todayOrders.begin(), todayOrders.end(), 0, 
            [](int sum, const Order& o) { return sum + o.TotalAmount; });

        database.SaveMetric("daily_orders", todayOrders.size());
        database.SaveMetric("daily_revenue", totalRevenue);
        // ... other metrics storage processes ...
    }
};

We can start by identifying the distinct responsibilities within the class. In this version, order processing and metrics collection are two separate concerns. We can extract the metrics collection logic into a new class called OrderMetricsCollector.

After applying the sprout class technique, the OrderProcessor class becomes more focused:

class OrderMetricsCollector {
private:
    IDatabase& database;

public:
    OrderMetricsCollector(IDatabase& db) : database(db) {}

    void CollectMetricsForOrder(const Order& order) {
        auto todayOrders = database.GetOrdersCreatedToday();
        int totalRevenue = std::accumulate(todayOrders.begin(), todayOrders.end(), 0, 
            [](int sum, const Order& o) { return sum + o.TotalAmount; });

        database.SaveMetric("daily_orders", todayOrders.size());
        database.SaveMetric("daily_revenue", totalRevenue);
    }
};

class OrderProcessor {
private:
    IDatabase& database;
    OrderMetricsCollector metricsCollector;

public:
    OrderProcessor(IDatabase& db) : database(db), metricsCollector(db) {}

    bool ProcessOrder(const Order& order) {
        // ... some order processing logic ...
        metricsCollector.CollectMetricsForOrder(order);
    }
};

The OrderMetricsCollector class now handles the metrics collection.