（三）设计模式之PHP项目应用（策略模式：商场收银系统）

浏览数：31 / 时间：2015年06月09日

1 策略模式简介

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

2 模式组成

1）抽象策略角色（Strategy）：
策略类，通常由一个接口或者抽象类实现。

2）具体策略角色（ConcreteStrategy）：
包装了相关的算法和行为。

3）环境角色(Context)：
持有一个策略类的引用，最终给客户端调用。

3 模式核心思想

策略模式是一种定义一些列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类的耦合。命令模式的算法是相互独立的，每个命令做的工作是不同的。而策略模式却是在做同一种工作。

4 模式架构图

5 程序架构

1) 抽象策略（Strategy）

// 定义接口，定义了要实现的策略算法
interface IStrategy{
    // 算法方法
    public function doFunction();
}

2) 具体策略（ConcreteStrategy）

// 具体A策略
class ConcreteStrategyA implements IStrategy{

    public function doFunction(){
        echo '算法A实现';
    }
}

// 具体B策略
class ConcreteStrategyB implements IStrategy{

    public function doFunction(){
        echo '算法B实现';
    }
}

// 具体C策略
class ConcreteStrategyC implements IStrategy{

    public function doFunction(){
        echo '算法C实现';
    }
}

3）环境类（Context）

// 环境类，维护一个Strategy应用
class Context{
    // 策略
    private $_strategy = null;

    public function __construct(IStrategy $strategy){
        $this->_strategy = $strategy;
    }

    public function doWork(){
        return $this->_strategy->doFunction();
    }
}

4）客户端(Client)

// 客户端类
class Client{

    public function main($data){
        // A策略
        $context = new Context(new ConcreteStrategyA());
        $context->doWork();
        
        // B策略
        $context = new Context(new ConcreteStrategyB());
        $context->doWork();
        
        // C策略
        $context = new Context(new ConcreteStrategyC());
        $context->doWork();
    }
}

6 项目应用

6.1 需求说明

实现一个商场收银系统，商品可以有正常收费，打折收费，返利收费等模式（来之《大话设计模式》）

6.2 需求分析

按照需求，可以将收费操作设计成为一个接口算法，正常收费，打折收费，返利收费都继承这个接口，实现不同的策略算法。然后设计一个环境类，去维护策略的实例。

6.3 设计架构图

6.4 程序源码下载

http://download.csdn.net/detail/clevercode/8700009

6.5 程序说明

1）strategy.php

<?php
/**
 * strategy.php
 *
 * 策略类：定义了一系列的算法，这些算法都是完成的相同工作，但是实现不同。
 *  
 * 特别声明：本源代码是根据《大话设计模式》一书中的C#案例改成成PHP代码，和书中的
 * 代码会有改变和优化。
 *
 * Copyright (c) 2015 http://blog.csdn.net/CleverCode
 *
 * modification history:
 * --------------------
 * 2015/5/5, by CleverCode, Create
 *
 */

// 定义接口现金策略，每种策略都是具体实现acceptCash，但都是实现收取现金功能
interface ICashStrategy{
    // 收取现金
    public function acceptCash($money);
}

// 正常收取策略
class NormalStrategy implements ICashStrategy{

    /**
     * 返回正常金额
     *
     * @param double $money 金额
     * @return double 金额
     */
    public function acceptCash($money){
        return $money;
    }
}

// 打折策略
class RebateStrategy implements ICashStrategy{
    // 打折比例
    private $_moneyRebate = 1;

    /**
     * 构造函数
     *
     * @param double $rebate 比例
     * @return void
     */
    public function __construct($rebate){
        $this->_moneyRebate = $rebate;
    }

    /**
     * 返回正常金额
     *
     * @param double $money 金额
     * @return double 金额
     */
    public function acceptCash($money){
        return $this->_moneyRebate * $money;
    }
}

// 返利策略
class ReturnStrategy implements ICashStrategy{
    // 返利条件
    private $_moneyCondition = null;
    
    // 返利多少
    private $_moneyReturn = null;

    /**
     * 构造函数
     *
     * @param double $moneyCondition 返利条件
     * @return double $moneyReturn 返利多少
     * @return void
     */
    public function __construct($moneyCondition, $moneyReturn){
        $this->_moneyCondition = $moneyCondition;
        $this->_moneyReturn = $moneyReturn;
    }

    /**
     * 返回正常金额
     *
     * @param double $money 金额
     * @return double 金额
     */
    public function acceptCash($money){
        if (!isset($this->_moneyCondition) || !isset($this->_moneyReturn) || $this->_moneyCondition == 0) {
            return $money;
        }
        
        return $money - floor($money / $this->_moneyCondition) * $this->_moneyReturn;
    }
}

2） strategyPattern.php

<?php
/**
 * strategyPattern.php
 *
 * 设计模式：策略模式
 * 
 * 模式简介：
 *     它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，
 * 不会影响到使用算法的客户。
 *     策略模式是一种定义一些列算法的方法，从概念上来看，所有这些算法完成的都是
 * 相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类
 * 与使用算法类的耦合。
 *     本源码中的各种结账方式，其实都是在结账，但是具体的实现确实不同的。策略模式与
 * 命令模式不同的是，命令模式的算法是相互独立的，每个命令做的工作是不同的。而策略模式
 * 却是在做通一种工作。          
 * 
 * 特别声明：本源代码是根据《大话设计模式》一书中的C#案例改成成PHP代码，和书中的
 * 代码会有改变和优化。
 *
 * Copyright (c) 2015 http://blog.csdn.net/CleverCode
 *
 * modification history:
 * --------------------
 * 2015/5/14, by CleverCode, Create
 *
 */

// 加载所有的策略
include_once ('strategy.php');

// 创建一个环境类，根据不同的需求调用不同策略
class CashContext{
    
    // 策略
    private $_strategy = null;

    /**
     * 构造函数
     *
     * @param string $type 类型
     * @return void
     */
    public function __construct($type = null){
        if (!isset($type)) {
            return;
        }
        $this->setCashStrategy($type);
    }

    /**
     * 设置策略（简单工厂与策略模式混合使用）
     *
     * @param string $type 类型
     * @return void
     */
    public function setCashStrategy($type){
        $cs = null;
        switch ($type) {
            
            // 正常策略
            case 'normal' :
                $cs = new NormalStrategy();
                break;
            
            // 打折策略
            case 'rebate8' :
                $cs = new RebateStrategy(0.8);
                break;
            
            // 返利策略
            case 'return300to100' :
                $cs = new ReturnStrategy(300, 100);
                break;
        }
        $this->_strategy = $cs;
    }

    /**
     * 获取结果
     *
     * @param double $money 金额
     * @return double
     */
    public function getResult($money){
        return $this->_strategy->acceptCash($money);
    }

    /**
     * 获取结果
     *
     * @param string $type 类型
     * @param int $num 数量
     * @param double $price 单价
     * @return double
     */
    public function getResultAll($type, $num, $price){
        $this->setCashStrategy($type);
        return $this->getResult($num * $price);
    }
}

/*
 * 客户端类
 * 让客户端和业务逻辑尽可能的分离，降低客户端和业务逻辑算法的耦合，
 * 使业务逻辑的算法更具有可移植性
 */
class Client{

    public function main(){
        $total = 0;
        
        $cashContext = new CashContext();
        
        // 购买数量
        $numA = 10;
        // 单价
        $priceA = 100;
        // 策略模式获取结果
        $totalA = $cashContext->getResultAll('normal', $numA, $priceA);
        $this->display('A', 'normal', $numA, $priceA, $totalA);
        
        // 购买数量
        $numB = 5;
        // 单价
        $priceB = 100;
        // 打折策略获取结果
        $totalB = $cashContext->getResultAll('rebate8', $numB, $priceB);
        $this->display('B', 'rebate8', $numB, $priceB, $totalB);
        
        // 购买数量
        $numC = 10;
        // 单价
        $priceC = 100;
        // 返利策略获取结果
        $totalC = $cashContext->getResultAll('return300to100', $numC, $priceC);
        $this->display('C', 'return300to100', $numC, $priceC, $totalC);
    }

    /**
     * 打印
     *
     * @param string $name 商品名
     * @param string $type 类型
     * @param int $num 数量
     * @param double $price 单价
     * @return double
     */
    public function display($name, $type, $num, $price, $total){
        echo date('Y-m-d H:i:s') . ",$name,[$type],num:$num,price:$price,total:$total\r\n";
    }
}

/**
 * 程序入口
 */
function start(){
    $client = new Client();
    $client->main();
}

start();

?>

3）在strategy.php与strategyPattern.php中。如果需要扩展多的策略，只需要继承收费接口实现更多的类，这里与简单工厂模式结合使用。是程序更清晰。

7 总结

7.1 优点：

1、策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类里面，从而避免重复的代码。
2、策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。
3、使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。