# order-strategy-demo

**Repository Path**: icehand/order-strategy-demo

## Basic Information

- **Project Name**: order-strategy-demo
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2019-09-16
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# order-strategy-demo

## 说明
	演示如何利用策略模式改写订单中多余的if else

## 传统写法
    OrderServiceImplV1
    利用 if else 来区分类型，处理不同的业务逻辑
```java
@Service("orderServiceV1")
public class OrderServiceImplV1 implements OrderService {
    @Override
    public String handle(OrderDTO dto) {
        if(1 == dto.getType()) {
            return "普通订单";
        } else if(2 == dto.getType()) {
            return "团购订单";
        } else if (3 == dto.getType()) {
            return "秒杀订单";
        }

        throw new BizException(1001,"订单类型暂不支持");
    }
}
```

## 策略模式
    定义基类 AbastractOrderHandler， 所有的订单处理都继承该基类
```java
public abstract class AbstractOrderHandler {
    public abstract String handle(OrderDTO dto);
}
```
    不同的订单类型，对应不同的处理类
```java
@Component
@OrderHandlerType(type = OrderTypeEnums.GROUP)
public class GroupOrderHandler extends AbstractOrderHandler {
    @Override
    public String handle(OrderDTO dto) {
        return "团购订单【策略模式】";
    }
}

@Component
@OrderHandlerType(type = OrderTypeEnums.NORMAL)
public class NormalOrderHandler extends AbstractOrderHandler {
    @Autowired
    private OrderProductServiceImpl orderProductService;

    @Override
    public String handle(OrderDTO dto) {
        return orderProductService.sayHello() + "普通订单【策略模式】";
    }
}

@Component
@OrderHandlerType(type = OrderTypeEnums.SEC_KILL)
public class SecKillOrderHandler extends AbstractOrderHandler {

    @Override
    public String handle(OrderDTO dto) {
        return "秒杀订单【策略模式】";
    }
}
```
    OrderHandlerType 注解便于在注册扫包时过滤，并注入到 Map 中
```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface OrderHandlerType {
    OrderTypeEnums type();
}
```
    利用 OrderHandlerContext 存储对应类型的处理方法
```java
@Service("orderServiceV2")
@AllArgsConstructor
public class OrderServiceImplV2 implements OrderService {
    private final OrderHandlerContext orderHandlerContext;

    @Override
    public String handle(OrderDTO dto) {
        AbstractOrderHandler orderHandler = orderHandlerContext.getInstance(dto.getType());
        return orderHandler.handle(dto);
    }
}
```
   OrderHandlerContext 中获取对应 type 的处理类
```java
@AllArgsConstructor
public class OrderHandlerContext {
    private Map<Integer, Class> orderHandlerMap;

    public AbstractOrderHandler getInstance(int type){
        Class clazz = orderHandlerMap.get(type);
        if(null == clazz) {
            throw new BizException(ResultCodeEnums.NOT_SUPPORT);
        }

        return (AbstractOrderHandler) SpringContextUtils.getBean(clazz);
    }
}
```
    而 OrderHandlerContext 注入到 Spring 容器中是在 OrderHandlerProcessor 中完成的
```java
@Component
public class OrderHandlerProcessor implements BeanFactoryPostProcessor {
    @Value("${order.handler.packaget}")
    private String OrderHandlerPackageName;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        Map<Integer, Class> handlerMap = Maps.newHashMapWithExpectedSize(3);
        ClassScaner.scanPackageByAnnotation(OrderHandlerPackageName, OrderHandlerType.class).forEach(c -> {
            int type = c.getAnnotation(OrderHandlerType.class).type().getType();
            handlerMap.put(type,c);
        });
        OrderHandlerContext orderHandlerContext = new OrderHandlerContext(handlerMap);
        configurableListableBeanFactory.registerSingleton(orderHandlerContext.getClass().getName(),orderHandlerContext);
    }
}
```

## 总结
    利用策略模式，把对应的功能划分到不同的类中，每个类专职做自己的事情，代码不会显得冗长，而且在后期的扩展，也是十分的便捷，只需要增加对应的
    处理类即可，同时也会增加不少的类，把功能细分开来
    
    在项目的开始，不需要做过多的设计，满足需求的同时追求简单的实现就可以，但随着业务的发展，代码越来越长，可读性越来越差，也是时候考虑使用设计模式重构代码
    
## 源码地址
    demo样例详情请见：https://gitee.com/icehand/order-strategy-demo.git