Mastering the Strategy Pattern in Spring: Dynamic Message Processing Explained

Concept

The Strategy pattern (also called Policy Pattern) defines a family of algorithms, encapsulates each one, and makes them interchangeable so that the client using the algorithm is not affected by changes.

Practical Application

Business scenario: the system needs to listen to multiple message types, enrich each with different data, and update a single Elasticsearch index for merchant search and statistics. Different message types are processed by different strategies.

Implementation combines the Spring framework, a simple factory, and the Strategy pattern.

Strategy Interface

public interface GatherExecuteService {
    /**
     * Process the message body
     * @param gatherDataVo
     */
    boolean execute(GatherDataVo gatherDataVo);
}

Concrete Strategy Implementations

// Price strategy implementation
@Service
public class PriceExecuteServiceImpl implements GatherExecuteService {
    @Override
    public boolean execute(GatherDataVo gatherDataVo) {
        // ... implementation omitted
    }
}

// Product strategy implementation
@Service
public class ProductExecuteServiceImpl implements GatherExecuteService {
    @Override
    public boolean execute(GatherDataVo gatherDataVo) {
        // ... implementation omitted
    }
}

// Stock strategy implementation
@Service
public class StockExecuteServiceImpl implements GatherExecuteService {
    @Override
    public boolean execute(GatherDataVo gatherDataVo) {
        // ... implementation omitted
    }
}

Enum for Strategy Bean Lookup

@Getter
@AllArgsConstructor
public enum MessageTypeEnum {
    PRODUCT(0, "productExecuteServiceImpl", "Product basic info message"),
    PRICE(1, "priceExecuteServiceImpl", "Price message"),
    STOCK(2, "stockExecuteServiceImpl", "Stock message");

    private int type;
    private String service;
    private String description;

    public static String getServiceName(int type) {
        for (MessageTypeEnum enumType : MessageTypeEnum.values()) {
            if (enumType.getType() == type) {
                return enumType.getService();
            }
        }
        return null;
    }
}

Using the Strategy

// Retrieve the appropriate strategy bean based on message type
String serviceName = MessageTypeEnum.getServiceName(gatherDataVo.getMessageType());
if (StringUtils.isNotBlank(serviceName)) {
    GatherExecuteService gatherExecuteService = (GatherExecuteService) SpringContextUtil.getBean(
        serviceName, GatherExecuteService.class);
}

The Strategy pattern is a simple design pattern that is often combined with other patterns in real projects; this article shares a concise example.