springboot+责任链模式初体验

CSDN话题挑战赛第2期
参赛话题：学习笔记

*学习之路，长路漫漫，写学习笔记的过程就是把知识讲给自己听的过程。这个过程中，我们去记录思考的过程，便于日后复习，梳理自己的思路。学习之乐，独乐乐，不如众乐乐，把知识讲给更多的人听，何乐而不为呢?

责任链模式，是为发送者和接受者之间创建一条对象处理链路，避免请求的发送者与请求的接受者耦合在一起。
请求发送者 -》请求处理1 -》请求处理2 -》请求处理3 -》请求接受者
springboot应用中常用的过滤器链就是应用责任链模式，下面体验一下在springboot中引入责任链模式。
实例：以下单流程为例，将经过多个检查校验逻辑，处理流程类似如下：

1、新建springboot工程，pom依赖如下

	<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2、新建下单对象

@Data
public class Order {

    /**
     * 请求唯一序列ID
     */
    private String seqId;

    /**
     * 用户ID
     */
    private String userId;

    /**
     * 产品skuId
     */
    private Long skuId;

    /**
     * 下单数量
     */
    private Integer amount;

    /**
     * 用户收货地址ID
     */
    private String userAddressId;
}

3、新建数据处理的接口

public interface OrderHandle {

    /**
     * 指定执行顺序
     * @return
     */
    int sort();

    /**
     * 对参数进行处理
     * @param order
     * @return
     */
    Order handle(Order order);
}

4、新建3个不同的接口实现类，并指定执行顺序

@Slf4j
@Component
public class RepeatOrderHandleService implements OrderHandle {

    @Override
    public int sort() {
        //用于判断是否重复下单，在执行顺序为1
        return 1;
    }

    @Override
    public Order handle(Order order) {
        log.info("判断是否重复下单");
        return order;
    }
}

@Slf4j
@Component
public class ValidOrderHandleService implements OrderHandle {


    @Override
    public int sort() {
        //用于判断参数是否合法，执行顺序为2
        return 2;
    }

    @Override
    public Order handle(Order order) {
        log.info("判断参数是否合法");
        return order;
    }
}

@Slf4j
@Component
public class BankOrderHandleService implements OrderHandle {


    @Override
    public int sort() {
        //用于判断库存是否充足，在执行顺序为3
        return 3;
    }

    @Override
    public Order handle(Order order) {
        log.info("判断库存是否充足");
        return order;
    }
}

5、新建一个订单数据处理管理器，用于管理这些实现类

@Component
public class OrderHandleChainService implements ApplicationContextAware {

    private List<OrderHandle> handleList = new ArrayList<>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //获取指定的接口实现类，并按照sort进行排序，放入List中
        Map<String, OrderHandle> serviceMap = applicationContext.getBeansOfType(OrderHandle.class);
        handleList = serviceMap.values().stream()
                .sorted(Comparator.comparing(OrderHandle::sort))
                .collect(Collectors.toList());
    }

    /**
     * 执行处理
     * @param order
     * @return
     */
    public Order execute(Order order){
        for (OrderHandle handleIntercept : handleList) {
            order = handleIntercept.handle(order);
        }
        return order;
    }
}

6、单元测试

	@Autowired
    private OrderHandleChainService orderHandleChainService;

    @Test
    public void test(){
        orderHandleChainService.execute(new Order());
    }

7、测试结果如下

若是需要天津其他的处理流程，只需要重新实现一个就行，其他代码无需改动。
8、还可以对上面的OrderHandleChainService类通过手动add的方式排序，如下

@Component
public class OrderHandleChainService2 {

    private List<OrderHandle> handleList = new ArrayList<>();

    @Autowired
    private ValidOrderHandleService validOrderHandleService;

    @Autowired
    private RepeatOrderHandleService repeatOrderHandleService;

    @Autowired
    private BankOrderHandleService bankOrderHandleService;

    @PostConstruct
    public void init(){
        //依次手动add对象
        handleList.add(repeatOrderHandleService);
        handleList.add(validOrderHandleService);
        handleList.add(bankOrderHandleService);
    }

    /**
     * 执行处理
     * @param context
     * @return
     */
    public Order execute(Order context){
        for (OrderHandle orderHandle : handleList) {
            context = orderHandle.handle(context);
        }
        return context;
    }
}

9、还可以通过注解@Oder来指定排序，代替手动方法排序sort()，如下

@Slf4j
@org.springframework.core.annotation.Order(1)
@Component
public class RepeatOrderHandleService2 implements OrderHandle2 {

    @Override
    public Order handle(Order order) {
        log.info("判断是否重复下单");
        return order;
    }
}

@Slf4j
@org.springframework.core.annotation.Order(2)
@Component
public class ValidOrderHandleService2 implements OrderHandle2 {

    @Override
    public Order handle(Order order) {
        log.info("判断参数是否合法");
        return order;
    }
}

@Slf4j
@org.springframework.core.annotation.Order(3)
@Component
public class BankOrderHandleService2 implements OrderHandle2 {

    @Override
    public Order handle(Order order) {
        log.info("判断库存是否充足");
        return order;
    }
}

@Component
public class OrderHandleChainService3  {

    @Autowired
    private List<OrderHandle2> handleList;

    /**
     * 执行处理
     * @param order
     * @return
     */
    public Order execute(Order order){
        for (OrderHandle2 orderHandle2 : handleList) {
            order = orderHandle2.handle(order);
        }
        return order;
    }
}

测试结果同上