策略类Spring框架下开发优化

策略类Spring框架下开发实例

先列出策略模式下需要那些类:

策略接口 (Strategy),定义所有策略类必须遵循的行为。

具体策略类(如 ConcreteStrategyAConcreteStrategyB),实现不同的算法或行为。

上下文类 (Context),持有策略实例并根据条件动态选择和创建策略。

辅助类和注解(作为工具辅助构建类工厂,可忽略),为策略模式的实现提供额外的功能或配置。

具体实现

定义策略接口

采用策略模式的情况一般是封装多重if-else/switch下的不同处理逻辑,这些逻辑可以抽象为一个行为(比如封装参数,做前置校验等),将这个行为定义为接口方法

/**
 * 策略接口
 */
public interface ProductTypeHandler {
    //本例中根据不同产品类型执行不同的返回参数封装逻辑
    void assemble(ResponseBO resBO);
}

定义策略类及其处理逻辑

将上文提到的多重if-else/switch中不同情况及其处理逻辑抽象成具体策略类和其内部方法执行逻辑


/**
 * 记录器参数处理类
 */
@Component
//注解使用见3
@ProductTypeAssembleTag(TAG = EnumProductType.PROCESS_RECORDER)
public class RecorderHandler implements ProductTypeHandler {
    @Autowired
    private RecorderService service;
    @Override
    public void assemble(ResponseBO resBO) {
        //记录器的处理逻辑
        int bindDeviceNums = service.getNumByUserId(ContextUtil.getUserId());
        resBO.setValue(bindDeviceNums);
    }
}
@Component
@ProductTypeAssembleTag(TAG = EnumProductType.COMMANDER)
//继承见4
public class CommanderHandler  extends CommonHandler implements ProductTypeHandler {
    @Override
    public void assemble(ResponseBO resBO) {
       //控制器的处理逻辑
       ...
    }
}

这里用到的注解和继承可以先忽视,3,4中会做解释

Context上下文类

这个类的核心就是存储map所有的策略类,然后提供getHandler()方法,供外界匹配获取对应策略类执行相关逻辑

那么这个map是如何存储的呢?我在实践中遇到是通过Map<TypeEnum,Handler>也就是定义枚举类作为键,存储其对应枚举类

此处有一个可拓展的点就是这个map是如何封装的,我遇到的有这么两种:

  1. 在Context中将所有策略类定义为属性,然后@Resourse注入
  2. 通过注解的方式进行解耦

第一种自动注入+switch的方式

@Component
public class ProductTypeHandlerContext {
    @Resource
    private CommonHandler commonHandler;
    @Resource
    privateRecorderHandler recorderHandler;
    //...其他策略类

    public ProductTypeHandler getHandler(EnumProductType emumType) {
        ProductTypeHandler handler = null;
        switch (EnumProductType) {
            case COMMANDER:
                handler = commonHandler;
                break;
            case RECORDER:
                handler = recorderHandler;
                break;
            default:
                throw new BizException("未匹配到目标类型");
                break;
        }
        return handler;
    }
}

可以看到第一种方案比较轻量级,下面来着重举例看看第二种情况:

@Component
public class HandlerContext{
    private static final Map<EnumProductType, ProductTypeHandler> handlerMap = new HashMap<>();

    @Autowired
    private HandlerContext(List<ProductTypeHandler> handlers) {
        handlers.forEach(processor -> {
            //这一段是通过反射获取到策略类
            long count = new ArrayList<>(Arrays.asList(processor.getClass().getInterfaces())).stream().filter(m -> m.getName().equals("org.springframework.aop.framework.Advised")).count();
            try {
                Class<?> ifaceClass = (Class) (count > 0 ? processor.getClass().getMethod("getTargetClass").invoke(processor) : processor.getClass());
                this.handlerMap.put(ifaceClass.getAnnotation(ProductTypeAssembleTag.class).TAG(), processor);
            } catch (Exception e) {
                log.error("HandlerContext初始化失败",e);
                throw new BizException("HandlerContext初始化失败");
            }
        });
    }
    
    public ProductTypeHandler getHandler(EnumProductType emumType) {
        return handlerMap.get(emumType);
    }
}

可以看到Context主要分为三部分:

  1. map
  2. 构造函数-->初始化map
  3. getHandler()

这里的重点在2中的HandlerContext()构造方法,通过@Autowired注解,Spring会将所有继承了策略接口ProductTypeHandler的策略类注入为列表作为参数,那么在方法内部对列表中的策略类依次进行map.put就可以了

那如何将策略类对应到其所属的EnumType上呢?这里通过自定义一个注解,为其添加一个名为Tag的EnumType属性,在每个策略类上面加上这个注解,就大功告成了,这也是上面的策略类的注解来源

/**
 * 注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ProductTypeAssembleTag {
    EnumsLogin.EnumProductType TAG();
}

至于HandlerContext()中的try中所涉及的逻辑,是检查当前的 processor 类是否是一个 Spring AOP 代理类:

"org.springframework.aop.framework.Advised"接口是 Spring AOP 代理类的标志。如果 count > 0,说明 processor 是一个 AOP 代理类。

如果 processor 是 AOP 代理类,则调用 processor.getClass().getMethod("getTargetClass").invoke(processor) 获取目标类的 Class 对象,这样可以获取到代理类的实际目标类(即被代理的类)。如果 processor 不是代理类,则直接使用 processor.getClass()

getTargetClass() 方法是 AOP 代理类的一个方法,它返回代理对象的实际目标类(即未被代理的原始类)。

进一步思考

如果策略类a,b的执行逻辑是一样的,那么要写重复的代码吗?

这时候就可以回归到最基础的继承上,通过定义一个CommonHandler,在其中写一次默认逻辑,然后其他策略类进行继承这也是上面的策略类有继承的原因

public class CommonHandler {
    public void assemble(ResponseBO resBO) {
       log.info("默认处理--目前没有特殊处理逻辑");
    }
}

至此,一个通过注解和继承优化的策略类实现方案就得以使用,在调用类通过注入HandlerContext,调用getHandler(enumType).assemble就可以传入枚举类获取对应策略类执行对应逻辑

总结

针对Context中map的两种初始化方案:

方案 优点 缺点
自动注入+switch - 简单直观,易于理解和维护
- 性能较好,避免了反射开销
- 扩展性差,需要修改 switch 语句才能添加新策略
- 高耦合,修改策略类需要修改 Context
注解解耦 - 解耦性强,符合开闭原则
- 易于扩展,不需要修改现有代码
- 支持 AOP 代理
- 性能开销较高,使用了反射
-- 启动时的反射性能开销
全部评论

相关推荐

评论
点赞
收藏
分享

创作者周榜

更多
牛客网
牛客企业服务