# spring-boot-ifelse

**Repository Path**: hweiyu/spring-boot-ifelse

## Basic Information

- **Project Name**: spring-boot-ifelse
- **Description**: SpringBoot项目，用策略模式，简化if-else操作
- **Primary Language**: Java
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 6
- **Forks**: 2
- **Created**: 2021-03-19
- **Last Updated**: 2024-05-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 概述
* SpringBoot项目，用策略模式，简化if-else操作   
* 有时候，因为业务逻辑的关系，我们的代码中会使用到很多的if-else，这会使代码看起来很臃肿，说得难听点就是代码又长又臭，那怎么才能让代码香起来呢？策略模式是个不错的选择。

### 策略模式
* 策略模式指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。比如下订单功能，包含基础的下单时间和总金额，但是酒店订单还有额外的选择住宿时间范围，而门票订单仅仅有使用时间等等，所以处理起来的逻辑就会不一样。

### 编码实战 [以订单处理为例]
* 1.定义订单类型枚举
```java
public enum OrderTypeEnum {
    /**
     * 食品
     */
    FOOD,
    /**
     * 酒店
     */
    HOTEL,
    /**
     * 门票
     */
    TICKET,
    /**
     * 默认
     */
    DEFAULT_TYPE;

    public static OrderTypeEnum of(String name) {
        for (OrderTypeEnum cur : OrderTypeEnum.values()) {
            if (cur.name().equalsIgnoreCase(name)) {
                return cur;
            }
        }
        //如果找不到，则使用默认处理
        return DEFAULT_TYPE;
    }
}
```
* 2.定义处理接口
```java
public interface OrderService {
    /**
     * 统一下单
     */
    void createOrder(OrderReqDTO reqDTO);
    /**
     * 获取订单类型
     * @return
     */
    OrderTypeEnum getType();
}

/**
* 订单传参对象
*/
@Data
@Accessors(chain = true)
public class OrderReqDTO implements Serializable {
    private static final long serialVersionUID = 1019466745376831818L;
    /**
     * 订单类型
     * @see com.yubest.demo.enums.OrderTypeEnum
     */
    private String orderType;
    /**
     * 订单金额
     */
    private BigDecimal money;
}
```
* 3.各种订单处理实现类
```java
/**
* 默认订单处理类
*/
@Service
@Slf4j
public class DefaultOrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderReqDTO reqDTO) {
        log.info("开始处理，[默认订单]");
    }
    @Override
    public OrderTypeEnum getType() {
        return OrderTypeEnum.DEFAULT_TYPE;
    }
}

/**
 * 食品订单处理类
 */
@Service
@Slf4j
public class FoodOrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderReqDTO reqDTO) {
        log.info("开始处理，[食品订单]");
    }
    @Override
    public OrderTypeEnum getType() {
        return OrderTypeEnum.FOOD;
    }
}

/**
 * 酒店订单处理类
 */
@Service
@Slf4j
public class HotelOrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderReqDTO reqDTO) {
        log.info("开始处理，[酒店订单]");
    }
    @Override
    public OrderTypeEnum getType() {
        return OrderTypeEnum.HOTEL;
    }
}

/**
 * 门票订单处理类
 */
@Service
@Slf4j
public class TicketOrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderReqDTO reqDTO) {
        log.info("开始处理，[门票订单]");
    }
    @Override
    public OrderTypeEnum getType() {
        return OrderTypeEnum.TICKET;
    }
}
```
* 4.实现策略选择器
```java
public class OrderStrategy {
    private static Map<OrderTypeEnum, OrderService> SERVICE_MAP = new HashMap<>(16);
    //初始化，将service缓存到内存中
    static {
        Map<String, OrderService> map = SpringUtil.getBeansOfType(OrderService.class);
        for (Map.Entry<String, OrderService> entry : map.entrySet()) {
            SERVICE_MAP.put(entry.getValue().getType(), entry.getValue());
        }
    }
    /**
     * 根据订单类型选择对应的处理service
     * @param orderType
     * @return
     */
    public static OrderService choose(String orderType) {
        OrderTypeEnum type = OrderTypeEnum.of(orderType);
        return SERVICE_MAP.get(type);
    }
}
```

* 使用
```java
@RestController
public class DemoController {
    @PostMapping(value = "/createOrder")
    public Object createOrder(@RequestBody OrderReqDTO reqDTO) {
        OrderStrategy.choose(reqDTO.getOrderType()).createOrder(reqDTO);
        return "{}";
    }
}
```
```curl
curl -X POST \
  http://localhost:8080/createOrder \
  -H 'Content-Type: application/json' \
  -d '{
  "orderType": "FOOD",
  "money": 100
}'
```