做的一个比较老的系统，不要吐槽别人的代码烂 发现不足并改变就是进步
代码中有很多if else的代码 可读性很差 在想怎么能进行优化在，找到并学习了策略模式的使用

if (msgType = "文本") {
    // dosomething
} else if(msgType = "图片") {
    // doshomething
} else if(msgType = "视频") {
    // doshomething
} else {
    // doshomething
}

如图以下的代码 如果条件很多就会变得很夸张很难读 现在将以下的代码进行优化
1、定义枚举类

public enum MSG_TYPE {

    TEXT(1, "文本"),
    IMAGE(2, "图片"),
    VIDEO(3, "视频");

    public final int code;
    public final String name;

    MSG_TYPE(int code, String name) {
        this.code = code;
        this.name = name;
    }
}

2、定义一个注解

@Documented
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MsgTypeHandler {

    MSG_TYPE value();
}

3、策略处理的接口

public interface MessageService {

    void handleMessage(MessageInfo messageInfo);
}

4、接口的实现类

@Service
@MsgTypeHandler(value = MSG_TYPE.TEXT)
public class TextMessageService implements MessageService {

    @Override
    public void handleMessage(MessageInfo messageInfo) {
        System.out.println("处理文本消息 " + messageInfo.getContent());
    }
}

@Service
@MsgTypeHandler(value = MSG_TYPE.IMAGE)
public class ImageMessageService implements MessageService {

    @Override
    public void handleMessage(MessageInfo messageInfo) {
        System.out.println("处理图片消息 " + messageInfo.getContent());
    }
}

在spring启动的时候将类型和service实现以map的形式储存到Context中

@Component
public class MessageServiceContext {

    private final Map<Integer, MessageService> handlerMap = new HashMap<>();

    public MessageService getMessageService(Integer type) {
        return handlerMap.get(type);
    }

    public void putMessageService(Integer code, MessageService messageService) {
        handlerMap.put(code, messageService);
    }

}

@Component
public class MessageServiceListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        Map<String, Object> beans = event.getApplicationContext().getBeansWithAnnotation(MsgTypeHandler.class);
        MessageServiceContext messageServiceContext = event.getApplicationContext().getBean(MessageServiceContext.class);
        beans.forEach((name, bean) -> {
            MsgTypeHandler typeHandler = bean.getClass().getAnnotation(MsgTypeHandler.class);
            messageServiceContext.putMessageService(typeHandler.value().code, (MessageService) bean);
        });
    }
}

现在说一下什么是策略模式
策略模式（Strategy），定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换。UML结构图如下：

image

其中，Context是上下文，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用；Strategy是策略类，用于定义所有支持算法的公共接口；ConcreteStrategy是具体策略类，封装了具体的算法或行为，继承于Strategy。

以及网上的一个栗子

1. 上下文类

首先声明一个CashSuper对象，通过构造方法，传入具体的收费策略，getResult()方法的功能为根据收费策略的不同获得计算结果。

public class CashContext {
    
    private CashSuper cashSuper;
    
    public CashContext(CashSuper cashSuper) {
        this.cashSuper = cashSuper;
    }
    
    public double getResult(double money) {
        return cashSuper.acceptCash(money);
    }

}

2. 现金收费抽象类

策略类，为抽象类，抽象出收费的方法供子类实现。

public abstract class CashSuper {
     
     public abstract double acceptCash(double money);
 
 }

3. 正常收费子类

没有任何活动的情况，正常收费，返回原价。

public class CashNormal extends CashSuper {

    @Override
    public double acceptCash(double money) {
        return money;
    }

}

4. 打折收费子类

打折活动，根据折扣返回打折后的价格。

public class CashRebate extends CashSuper {
    
    private double moneyRebate = 1;    //折扣
    
    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }

}

5. 返利收费子类

public class CashReturn extends CashSuper {

    private double moneyConditation = 0.0;    //返利条件
    private double moneyReturn = 0.0d;    //返利值
    
    public CashReturn(double moneyConditation, double moneyReturn) {
        this.moneyConditation = moneyConditation;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double acceptCash(double money) {
        double result = money;
        
        if (money >= moneyConditation) {
            result = money - Math.floor(money / moneyConditation) * moneyReturn;
        }
        
        return result;
    }

}

6. Client客户端

public class Client {
    
    public static void main(String[] args) {
        CashContext cashContext = null;
        
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入打折方式（1/2/3）：");
        int in = scanner.nextInt();
        String type = "";
        
        switch (in) {
            case 1:
                cashContext = new CashContext(new CashNormal());
                type += "正常收费";
                break;
                
            case 2:
                cashContext = new CashContext(new CashReturn(300, 100));
                type += "满300返100";
                break;
                
            case 3:
                cashContext = new CashContext(new CashRebate(0.8));
                type += "打8折";
                break;
    
            default:
                System.out.println("请输入1/2/3");
                break;
        }
        
        double totalPrices = 0;
        
        System.out.print("请输入单价：");
        double price = scanner.nextDouble();
        System.out.print("请输入数量：");
        double num = scanner.nextDouble();
        totalPrices = cashContext.getResult(price * num);
        
        System.out.println("单价：" + price + "，数量：" + num + "，类型：" + type + "，合计：" + totalPrices);
        
        scanner.close();
    }

}

正常收费结果如下：

image

返利收费结果如下：

image

打折收费结果如下：

image