Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects

This article summarizes several reusable programming patterns adopted in the high‑frequency, rapid‑iteration development of the Taobao "静心守护" (Calm Guard) innovation project. The goal is to keep the technology fast and stable while supporting frequent feature changes.

Strategy Pattern based on Spring container and reflection

The classic Strategy pattern is implemented by registering each strategy as a Spring bean. During container startup, reflection is used to collect all beans that implement a given strategy interface and store them in a map (key = unique identifier, value = bean). A custom routing logic can then retrieve the appropriate bean from the map.

public interface Handler<T> { T type(); }

@Slf4j
public abstract class HandlerFactory<T, H extends Handler<T>> implements InitializingBean, ApplicationContextAware {
    private Map<T, H> handlerMap;
    private ApplicationContext appContext;
    // ... getHandler, getHandlerOrDefault, afterPropertiesSet, setApplicationContext ...
}

The main advantages are automatic strategy identifier maintenance, scene‑level isolation to avoid name clashes, and flexible interface definitions per scene.

Practical case: title‑unlock module

The title‑unlock feature uses the above strategy framework. Each title type (gameplay, sign‑in, etc.) implements Handler and provides its own business logic.

@Component
public class TitleUnlockHandlerFactory extends HandlerFactory<String, BaseTitleUnlockHandler<BaseTitleUnlockParams>> {}

public abstract class BaseTitleUnlockHandler<T extends BaseTitleUnlockParams> implements Handler<String> {
    // injected managers
    public @CheckForNull TitleUnlockResult unlockTitles(T params) { /* common flow */ }
    protected abstract TitleUnlockResult doUnlock(T param);
    public abstract String type();
}

Fatigue‑control system

To limit user actions (e.g., daily sign‑in, limited‑times tasks), a hierarchy of interfaces and abstract classes is introduced:

FatigueLimiter – top‑level interface defining query, reset, increment, and limit‑check methods.

BaseFatigueLdbLimiter – abstract class handling LDB storage, leaving scene‑specific key generation and expiration to subclasses.

Concrete implementations such as BaseFatigueDailyLimiter , BaseFatigueNoCycleLimiter , and custom limiters like DailyWishSignLimiter or HomeEnterGuideLimiter combine daily and total‑count limits.

@Component
public class DailyWishSignLimiter extends BaseFatigueLdbDailyLimiter {
    @Override
    protected String scene() { return LimiterScene.dailyWish; }
}

Functional behavior parameterization

Repeated cache‑upsert logic for unread achievements is refactored by extracting a generic upsertCache method that receives an Supplier for initialization and a Function for update, allowing callers to pass lambda expressions.

private boolean upsertCache(long uid, Supplier<UserUnreadAchievementsCache> initCacheSupplier,
                            Function<UserUnreadAchievementsCache, UserUnreadAchievementsCache> updater) { /* ... */ }

Both writeUnreadAchievements and clearUnreadAchievements now delegate to this method, reducing duplication.

AOP practices

Service‑layer exception handling and monitoring are extracted into an aspect. The pointcut targets all public methods in classes ending with *Impl under the mtop package.

@Aspect
@Component
@Slf4j
public class MtopServiceAspect {
    @Pointcut("execution(public com.taobao.mtop.common.MtopResult com.taobao.gaia.veyron.bless.service.mtop.*Impl.*(..))")
    public void mtopService() {}

    @Around("com.taobao.gaia.veyron.bless.aspect.MtopServiceAspect.mtopService()")
    public Object enhanceService(ProceedingJoinPoint pjp) throws Throwable { /* logging, error handling */ }
}

Similar pointcuts are defined for DAO layers, Tair access, and custom‑annotated methods, illustrating how to choose precise join points based on naming conventions, package structure, or custom annotations.

Conclusion

By extracting stable patterns (strategy, fatigue control, functional parameterization, AOP) from changing business requirements, the team achieves faster development cycles, better code reuse, and easier maintenance.