策略+工厂设计模式的应用

问题

比如有下面一段业务，一个自动售货机，根据用户选择不同的饮料，出对应的货

public class NoDesignDemo {
    public void ifElse(String parameter) {
        if ("Pepsi".equalsIgnoreCase(parameter)) {
            System.out.println("百事可乐-初始无设计");
        }else if ("Coca".equalsIgnoreCase(parameter)){
            System.out.println("可口可乐-初始无设计");
            if("618".equalsIgnoreCase(parameter))
            {
                //需要配合618积分平台大促活动，涉及复杂业务。
            }
            if("1111".equals(parameter))
            {
                //需要配合双11优惠卷平台大促活动，涉及复杂业务。
                //1 MQ同步消息给其它下游系统
                //2 xxl-job做好定时任务扫描，当晚下单下单顾客，没1分钟统计一次送给QTL系统
                //3 。。。。。。
            }
        }else if ("Wahaha".equalsIgnoreCase(parameter)){
            System.out.println("娃哈哈-初始无设计");
        }
    }

    public static void main(String[] args)
    {
        new NoDesignDemo().ifElse("wahaha");
    }
}

这段代码有什么问题？大家想想。。。
很明显，这代码太耦合，太多if…else现在只写了3个，实际情况可能几十个几百个if…else，每次添加一个新的品类，又需要修改原来代码添加一个if…else

使用策略+工厂模式优化

1、先定义一个策略接口

public interface HandlerStrategyFactory extends InitializingBean
{
    void getDrink(String parameter);

    //继承InitializingBean方法后，Spring容器将在bean属性设置完成后自动调用这个方法
    // void afterPropertiesSet() throws Exception;
}

2、再定义一个饮料工厂

public class DrinkFactory {
    private static Map<String, HandlerStrategyFactory> strategyMap = new ConcurrentHashMap<>();

    public static HandlerStrategyFactory getInvokeStrategy(String str)
    {
        return strategyMap.get(str);
    }

    public static void register(String str ,HandlerStrategyFactory handler)
    {
        System.out.println("str: "+str+"\t handler: "+handler);
        if (null == str || null == handler)
        {
            return;
        }
        strategyMap.put(str,handler);
    }
}

3、定义各种饮料的处理方式类

@Component
public class CocaHandler implements HandlerStrategyFactory
{
    @Override
    public void getDrink(String parameter)
    {
        System.out.println("我是可口可乐-策略+工厂 "+parameter);
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
                               //K          //V
        DrinkFactory.register("Coca",this);
    }
}

@Component
public class PepsiHandler implements HandlerStrategyFactory
{
    @Override
    public void getDrink(String parameter)
    {
        System.out.println("我是百事可乐-策略+工厂 "+parameter);
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        DrinkFactory.register("Pepsi",this);
    }
}

@Component
public class WahahaHandler implements HandlerStrategyFactory
{
    @Override
    public void getDrink(String parameter)
    {
        System.out.println("我是娃哈哈可乐-策略+工厂 "+parameter);
    }

    @Override
    public void afterPropertiesSet() throws Exception
    {
        DrinkFactory.register("Wahaha",this);
    }
}

测试

    @Test
    public void invokeStrategyFactory()
    {
        String parameter = "Coca";  //Pepsi //Coca

        HandlerStrategyFactory invokeStrategy = DrinkFactory.getInvokeStrategy(parameter);

        invokeStrategy.getDrink(parameter);
    }

这样优化有什么好处？现在新来一个品类，只需要加一个xxxHandler对应的处理方式，其他代码不用修改，代码完全解耦，条理清晰，易于扩展

下课！

原文地址：https://blog.csdn.net/ZHUSHANGLIN/article/details/140627743

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！