springboot项目实现策略模式，我愿称之为最优雅！！！

1. 众所周知，项目中的业务处理可能一条线会有多种实现，例如一个下单就可能根据商品类型有多种处理的逻辑，此时，如果使用策略模式那么对该功能的拓展性、可读性都有明显的增强。
2. 虽然说 if-else也可以实现策略模式，一人一个想法，策略模式也有无数的实现方式，本人自开发以来也写了很多套策略模式的实现，这次又写了一套自认优雅与拓展都很全面的方式去实现，各位看官请往下看。
3. 首先定义自定义策略注解，再定义一个策略接口的（将需要实现的策略抽象在接口里），利用spring提供的IOC，将策略都注册到容器中，再首次调用策略时将所有的策略按照自定义注解的值存到对应的Map容器中，在业务方根据策略key获取实际的策略实现类调用方法。
4. 以下是代码，首先定义一个策略模式处理handler，通用的，将所有策略模式需要用到的方法封装，减少调用方的编码。
5. 核心base handler代码：使用了模板模式，直接调用抽象方法把具体实现交给子类，因为实际调用方是子类。

package com.central.common.handler;import cn.hutool.core.map.MapUtil;
import com.central.common.utils.Assert;
import org.springframework.context.ApplicationContext;import java.lang.annotation.Annotation;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;/*** 处理策略的 处理工具的基本类** @Date 2023/3/8 17:59*/
public abstract class BaseStrategyHandler<T, R extends Annotation> {protected ApplicationContext applicationContext;public BaseStrategyHandler(ApplicationContext applicationContext) {this.applicationContext = applicationContext;}/*** 容器*/protected ConcurrentHashMap<String, Class<T>> container = new ConcurrentHashMap();/*** 返回指定的策略枚举*/protected abstract Class<R> getStrategyAnnotationClass();/*** 返回指定的策略 接口类*/protected abstract Class<T> getStrategyInterface();/*** 获取 注解的值* 为了处理可能枚举值是数组的情况，因此需要包装成集合* 为了避免多个策略键用的同一个策略实现的情况* @date 17:41 2023/7/6* @param strategyAnnotationEntity 注解实体* @return java.util.List**/protected abstract List<String> getStrategyAnnotationValue(R strategyAnnotationEntity);/*** 根据class 获取Bean** @param clazz* @return T* @date 17:06 2023/3/9**/protected T getBean(Class<T> clazz) {return applicationContext.getBean(clazz);}/*** 获取类上的 枚举实体* @date 17:44 2023/7/6* @param service 策略类实体* @return R 枚举实体**/protected R getStrategyAnnotationEntity(Class<T> service) {Class<R> strategyAnnotationClass = this.getStrategyAnnotationClass();boolean annotationPresent = service.isAnnotationPresent(strategyAnnotationClass);Assert.isTrue(!annotationPresent, "策略实现存在未加注解的异常");return service.getAnnotation(strategyAnnotationClass);}/*** 懒加载的方式 初始化容器* @date 17:50 2023/7/6* @param* @return void**/protected void lazyInitContainer(){ConcurrentHashMap<String, Class<T>> container = this.container;// 获取策略接口Class<T> strategyInterface = this.getStrategyInterface();// 获取所有 实现类的spring beanapplicationContext.getBeansOfType(strategyInterface).forEach((k, v) -> {Class<T> service = (Class<T>) v.getClass();// 获取策略实体上的枚举实体R strategyAnnotationEntity = this.getStrategyAnnotationEntity(service);// 获取枚举上的值List<String> strategyAnnotationValue = this.getStrategyAnnotationValue(strategyAnnotationEntity);// 置入策略容器strategyAnnotationValue.stream().forEach(value -> container.putIfAbsent(value, service));});}/*** 获取策略实体 供外部调用的* @date 17:44 2023/7/6* @param strategyKey* @return java.lang.Class**/public T getStrategyEntity(String strategyKey) {// 获取容器ConcurrentHashMap<String, Class<T>> container = this.container;if (MapUtil.isEmpty(container)) {this.lazyInitContainer();}return this.getBean(container.get(strategyKey));}
}

6. 子类handler代码：

package com.central.keep.strategy.orderRegRelation;import com.central.common.dto.saveDto.OrderRegRelationSaveDto;
import com.central.common.enums.CommonEnum;
import com.central.common.handler.BaseStrategyHandler;
import com.central.common.utils.Assert;
import com.central.keep.annotation.OrderRegRelationAnnotation;
import com.central.keep.model.OrderRegRelation;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;import java.util.Collections;
import java.util.List;/*** OrderRegRelationStrategyHandler* @Date 2023/7/12 17:07 * @Description */ 
@Component
public class OrderRegRelationStrategyHandler extends BaseStrategyHandler<OrderRegRelationStrategy, OrderRegRelationAnnotation> {/*** 初始化，提供spring的ApplicationContext  spring在初始化bean时会将ApplicationContext **/public OrderRegRelationStrategyHandler(ApplicationContext applicationContext) {super(applicationContext);}// 提供自定义注解类@Overrideprotected Class<OrderRegRelationAnnotation> getStrategyAnnotationClass() {return OrderRegRelationAnnotation.class;}// 提供 策略接口类@Overrideprotected Class<OrderRegRelationStrategy> getStrategyInterface() {return OrderRegRelationStrategy.class;}@Overrideprotected List<String> getStrategyAnnotationValue(OrderRegRelationAnnotation strategyAnnotationEntity) {return Collections.singletonList(strategyAnnotationEntity.value().getCode());}/*** 策略 handler 提供整体的逻辑处理，也可以写在 对应的 service层中* @date 17:44 2023/7/12* @param orderRegRelationSaveDto* @return com.central.keep.model.OrderRegRelation**/public OrderRegRelation buildOrderRegRelation(OrderRegRelationSaveDto orderRegRelationSaveDto){// 获取策略类OrderRegRelationStrategy strategyEntity = this.getStrategyEntity(orderRegRelationSaveDto.getBizType());Assert.isObjEmpty(strategyEntity, CommonEnum.ExceptionDesc.参数异常);// 策略实现类调用 实现的策略方法OrderRegRelation orderRegRelation = strategyEntity.setEntityAttributes(orderRegRelationSaveDto);return orderRegRelation;}
}

7. 自定义注解代码：

package com.central.keep.annotation;import com.central.common.enums.BizEnum;import java.lang.annotation.*;/*** OrderRegRelationAnnotation* keep 订单reg 的枚举** @author chenkaimin* @Date 2023/7/12 17:05* @Description* @see com.central.common.enums.BizEnum.BizTypeEnum*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OrderRegRelationAnnotation {BizEnum.BizTypeEnum value();
}

public class BizEnum {/*** BizTypeEnum* 业务商品表类型 枚举** @author chenkaimin* @Date 2023/7/3 14:59* @Description*/@Getter@AllArgsConstructorpublic enum BizTypeEnum {Keep_Curriculum("keep_curriculum", "keep 课程"),Keep_Activity("keep_activity", "keep 活动"),;String code;String desc;}
}

8. 策略接口类：

package com.central.keep.strategy.orderRegRelation;import com.central.common.dto.saveDto.OrderRegRelationSaveDto;
import com.central.keep.model.OrderRegRelation;/*** OrderRegRelationStrategy* 订单reg 策略** @Date 2023/7/12 17:19* @Description*/
public interface OrderRegRelationStrategy {/*** 订单reg 实体需要的业务的实体的字段置入* @date 17:43 2023/7/12* @param orderRegRelationSaveDto* @return com.central.keep.model.OrderRegRelation**/OrderRegRelation setEntityAttributes(OrderRegRelationSaveDto orderRegRelationSaveDto);
}

9. 调用方代码例子：

public Boolean saveOrderRegRelation(OrderRegRelationSaveDto orderRegRelationSaveDto){OrderRegRelation orderRegRelation = orderRegRelationStrategyHandler.buildOrderRegRelation(orderRegRelationSaveDto);return this.save(orderRegRelation);}

10. 核心是BaseStrategyHandler ，分为容器（Map<策略值，策略实现>）、枚举（策略键定义）、接口（策略抽象与实现） ，配合spring的IOC就构成了这套策略模式的实现。拓展只需要多一个策略接口的实现即可。如果有多套策略需要实现，每套策略需要编写一个类似OrderRegRelationStrategyHandler 的子类。个人感觉整体逻辑会更清晰，可以作为一个项目的全局策略实现的底层来使用。
11. 结尾附上完整的流程图，更容易理解一点，感谢网友给出意见。
    
12. 这个说白了核心思想就是在注解里定义key值，然后按照key，value的结构把key值和对应的策略实现类放到ConcurrentHashMap里面。然后调用策略的时候根据你的不同的key值使用子类调用 BaseStrategyHandler#getStrategyEntity()的方法获取策略，然后直接用具体的策略实现类去调用你的不同的策略。

留言：码字不易，大佬们觉得文章有帮助，动动小手点个赞支持一下，蟹蟹！

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！