如何优雅的使用设计模式 ？ 策略模式结合工厂模式与单例 SpringBean版

什么是设计模式？

• 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
• 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性

今天我们来说策略模式，何为策略模式？让我们先看看以下示例代码
这里我们拿支付方式来举例
工程结构如下：

这是我们的支付接口，定义了一个支付的方法 根据不同的支付类型给予不同的优惠

public interface Pay {
    /**
     * @param skuPrice 提交的金额
     * @return
     */
    BigDecimal payment(Integer,BigDecimal skuPrice);
}

我们来看看这个支付接口的实现类

public class PayService implements Pay {

    public BigDecimal payment(Integer type,BigDecimal skuPrice) {
        // 1. 支付宝 优惠0.7元
        if (1 == type) {
            return skuPrice.subtract(new BigDecimal(0.7));
        }
        // 2. 微信支付 优惠0.3
        if (2 == type) {
            return skuPrice.subtract(new BigDecimal(0.3));
        }
        return skuPrice;//否则银行卡支付原价
    }
}

这种方式看似没有什么问题，想要的功能也能为你实现，但一旦优惠条件的算法难度上升导致代码量剧增，大量的if else语句会使整个程序代码看起来又长又臭，而且对于产品的扩展性极其不友好

思考：如何避免使用if语句并能使程序根据不同的支付类型给予不同的优惠？

就是我们今天的主角 策略模式！

为什么需要策略模式？

• 指对象有某个行为,但是在不同的场景中,该行为有不同的实现算法
• 可以理解为见风使舵？根据不同的客户而选择不同服务 而这些,作为客户他们并不需要知晓
• 像现在我们说的这个例子，客户都需要支付 但支付的方式不同 所以不同的支付方式都需要一套不同规则对应的算法

切入正题！改造我们的代码
首先，使用不同的支付方式实现支付接口

• 微信支付

public class WeChatPay implements Pay {

    /**
     * 微信支付10元+ 优惠0.7
     * @param skuPrice 提交的金额
     * @return
     */
    public BigDecimal payment(BigDecimal skuPrice) {
        //大于10元就优惠
        if (skuPrice.compareTo(new BigDecimal(10)) >= 0)
            return skuPrice.subtract(new BigDecimal(0.7));//返回优惠价
        return skuPrice;//返回原价
    }
}

• 支付宝支付

public class AliPay implements Pay {

    public BigDecimal payment(BigDecimal skuPrice) {
        if (skuPrice.compareTo(new BigDecimal(10)) >= 0)
            return skuPrice.subtract(new BigDecimal(0.3));//返回优惠价
        return skuPrice;
    }
}

• 银行卡支付

public class BankPay implements Pay {

    /**
     * @param skuPrice 提交的金额
     * @return
     */
    public BigDecimal payment(BigDecimal skuPrice) {
        return skuPrice;//银行卡支付无优惠
    }
}

策略类

public class PayStrategy<T> {

    private Pay pay;

    public PayStrategy (Integer i) {
       if (i == 1) {
    		pay= new WeChatPay();
    	} else if (i == 2) {
    		pay = new AliPay();
    	} else {
			pay = new BankPay();
		}	 
    }

    public BigDecimal payment(BigDecimal skuPrice) {
        return pay.payment(skuPrice);
    }

}

来康康测试结果

	@Test
    public void test() {
        PayStrategy pay = new PayStrategy(1);//1=微信支付
        BigDecimal bigDecimal = pay.payment(new BigDecimal(20));
        logger.info("测试结果：支付金额 {}",bigDecimal);
    }

经测试我们的策略模式成功了，但是大家有没有发现个问题在我们的策略类中有一段这样的代码

这是啥玩意？ 如果按照这种写法 如果产品多增加一种支付类型那么就意味着你要再增加if else！ 然后不停的new哦~ 嘿嘿嘿. 这非常的龌龊！

作为俺们村的村草我是绝对不允许这种事情发生 咳咳~
我们可以把创建实例的工作交个Spring 大大简化开发，让我们看下面的代码

新建一个支付类型枚举

public enum PayEnum {

    WeChatPay,
    PayStrategy,
    AliPay;
}

在我们的支付接口实现类上标注@component注解 将对象加载进入Springbean中 起别名为类名 例如：

@Component("WeChatPay")
public class WeChatPay implements Pay {

@Component("BankPay")
public class BankPay implements Pay {

@Component("AliPay")
public class AliPay implements Pay {

改造策略类

@Component
public class PayStrategy {

    private Pay pay;

    private Map<String,Pay> map;

	
    public void setStrategy(PayEnum strategy) {
        pay = map.get(strategy.toString());
        System.out.println("pay == " + pay);
    }
	
	/**
	* 工厂初始化注入map
	*/
    public PayStrategy(Map<String,Pay> map) {
        this.map = map;
    }

    public BigDecimal payment(BigDecimal sku) {
        return pay.payment(sku);
    }
}

策略工厂，说明一下该方法的作用，可见下列方法的有一个map参数，它是如何注入的呢？

• 如果找到了 Pay的实现类spring就会以String == 类名(别名) Pay = 自动查找实现类对象

@Component
public class PayStrategyFactory {
		
    @Bean
    public PayStrategy payStrategy(Map<String,Pay> map) {
        return new PayStrategy(map);
    }
}

因为spring的默认机制，默认是单例模式 我们并不需要担心map是否会失效，在策略类中定义的map为我们实现了实现类的单例 让我们来测试一下

@ComponentScan
public class Application {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(Application.class);//初始化IOC容器

        try {
           PayStrategy payStrategy = ctx.getBean(PayStrategy.class);
            payStrategy.setStrategy(PayEnum.WeChatPay);
            System.out.println("支付价格为 == " + payStrategy.payment(new BigDecimal(20)).setScale(2,BigDecimal.ROUND_DOWN));

            payStrategy.setStrategy(PayEnum.AliPay);
            System.out.println("支付价格为 == " + payStrategy.payment(new BigDecimal(20)).setScale(2,BigDecimal.ROUND_DOWN));

            payStrategy.setStrategy(PayEnum.WeChatPay);
            System.out.println("支付价格为 == " + payStrategy.payment(new BigDecimal(20)).setScale(2,BigDecimal.ROUND_DOWN));

            payStrategy.setStrategy(PayEnum.BankPay);
            System.out.println("支付价格为 == " + payStrategy.payment(new BigDecimal(20)).setScale(2,BigDecimal.ROUND_DOWN));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

可以看到我们在使用相同枚举时候 拿到的都是同一个对象，这就完成了单例模式

同学，你学废了嘛，设计模式深撸起来会感觉非常奇妙，在上述代码中还有些许不完美，让我们一起进步吧，这片文章要是对你有帮助记得点个赞哟
每日进步一点点，Day Day Up