策略模式（学习笔记）

时间  2021-07-29
标签 java 算法 编程 数据结构 app 框架 编程语言 ide 函数 栏目 Java 繁體版
原文   原文链接

　　1. 意图

　　定义一系列算法，把它们一个个封装起来，而且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化java

　　2. 动机 　　

　　假设打算为游客们建立一款导游程序。该程序的核心功能是提供美观的地图，以帮助用户在任何城市中快速定位。用户期待的程序新功能是自动路线规划：他们但愿输入地址后就能在地图上看到前往目的地的最快路线。程序的首个版本只能规划公路路线。驾车旅行的人们对此很是满意。但很显然，并不是全部人都会在度假时开车。所以在下次更新时添加了规划步行路线的功能。此后，又添加了规划公共交通路线的功能。而这只是个开始。不久后，又要为骑行者规划路线。又过了一段时间，又要为游览城市中的全部景点规划路线。尽管从商业角度来看，这款应用很是成功，但其技术部分却让你很是头疼：每次添加新的路线规划算法后，导游应用中主要类的体积就会增长一倍。随着需求的不断增长，你以为本身无法继续维护这堆代码了算法

　　策略模式经过定义一些类来封装不一样功能背后的算法，从而避免了一个类不断膨胀以致于难以维护的问题。名为上下文的原始类必须包含一个成员变量来存储对于每种策略的引用。上下文并不执行任务，而是将工做委派给已链接的策略对象。上下文不负责选择符合任务须要的算法——客户端会将所需策略传递给上下文。实际上，上下文并不十分了解策略，它会经过一样的通用接口与全部策略进行交互，而该接口只需暴露一个方法来触发所选策略中封装的算法便可。所以，上下文可独立于具体策略。这样你就可在不修改上下文代码或其余策略的状况下添加新算法或修改已有算法了。在导游应用中，每一个路线规划算法均可被抽取到 buildRoute 方法的独立类中。 该方法接收起点和终点做为参数，并返回路线中途点的集合。编程

          

　　3. 适用性

  • 许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法
  • 须要使用一个算法的不一样变体
  • 算法使用客户不该该知道的数据。可以使用策略模式以免暴露复杂的、与算法相关的数据结构
  • 一个类定义了多种行为，而且这些行为在这个类的操做中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句

　　4. 结构

           

　　5. 效果

　　1. 能够在运行时切换对象内的算法数据结构

　　2. 一个替代继承的方法       若是直接生成一个Context类的子类，从而给它以不一样的行为。这会将行为硬性编制到Context中，将算法的实现与Context的实现混合起来，从而使Context难以理解、维护和扩展，并且还不能动态的改变算法app

　　3. 消除了一些条件语句   框架

　　4. Strategy能够提供相同行为的不一样实现编程语言

　　5. 客户必须了解不一样的Strategy以选择合适的算法ide

　　6. 许多现代编程语言支持函数类型功能，容许你在一组匿名函数中实现不一样版本的算法。使用这些函数的方式就和使用策略对象时彻底相同，无需借助额外的类和接口来保持代码简洁函数

　　7. 增长了对象的数目ui

　　8. Strategy和Context之间的通讯开销      不管各个ConcreteStrategy实现的算法是简单仍是复杂，它们都共享Strategy定义的接口。所以极可能某些ConcreteStrategy不会用到全部经过这个接口传递给它们的信息，简单的ConcreteStrategy可能不使用其中的任何信息！这就意味着有时Context会建立和初始化一些永远不会用到的参数。若是存在这个问题，须要在Strategy和Context之间进行更紧密的耦合

　　6. 代码实现　　

　　在本例中，策略模式被用于在电子商务应用中实现各类支付方法。客户选中但愿购买的商品后须要选择一种支付方式：Paypal 或者信用卡。具体策略不只会完成实际的支付工做，还会改变支付表单的行为，并在表单中提供相应的字段来记录支付信息

　　strategies/PayStrategy.java: 通用的支付方法接口

package strategy.strategies;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:57
 * Common interface for all strategies.
 */
public interface PayStrategy {
    boolean pay(int paymentAmount);
    void collectPaymentDetails();
}

　　strategies/PayByPayPal.java: 使用 PayPal 支付

package strategy.strategies;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:57
 */
public class PayByPayPal implements PayStrategy{
    private static final Map<String, String> DATA_BASE = new HashMap<>();
    private final BufferedReader READER = new BufferedReader(new InputStreamReader(System.in));
    private String email;
    private String password;
    private boolean signedIn;

    static {
        DATA_BASE.put("amanda1985", "amanda@ya.com");
        DATA_BASE.put("qwerty", "john@amazon.eu");
    }

    /**
     * Collect customer's data.
     */
    @Override
    public void collectPaymentDetails() {
        try {
            while (!signedIn) {
                System.out.print("Enter the user's email: ");
                email = READER.readLine();
                System.out.print("Enter the password: ");
                password = READER.readLine();
                if (verify()) {
                    System.out.println("Data verification has been successful.");
                } else {
                    System.out.println("Wrong email or password!");
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    private boolean verify() {
        setSignedIn(email.equals(DATA_BASE.get(password)));
        return signedIn;
    }

    /**
     * Save customer data for future shopping attempts.
     */
    @Override
    public boolean pay(int paymentAmount) {
        if (signedIn) {
            System.out.println("Paying " + paymentAmount + " using PayPal.");
            return true;
        } else {
            return false;
        }
    }

    private void setSignedIn(boolean signedIn) {
        this.signedIn = signedIn;
    }
}

　　strategies/PayByCreditCard.java: 使用信用卡支付

package strategy.strategies;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:58
 */
public class PayByCreditCard implements PayStrategy{
    private final BufferedReader READER = new BufferedReader(new InputStreamReader(System.in));
    private CreditCard card;

    /**
     * Collect credit card data.
     */
    @Override
    public void collectPaymentDetails() {
        try {
            System.out.print("Enter the card number: ");
            String number = READER.readLine();
            System.out.print("Enter the card expiration date 'mm/yy': ");
            String date = READER.readLine();
            System.out.print("Enter the CVV code: ");
            String cvv = READER.readLine();
            card = new CreditCard(number, date, cvv);

            // Validate credit card number...

        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * After card validation we can charge customer's credit card.
     */
    @Override
    public boolean pay(int paymentAmount) {
        if (cardIsPresent()) {
            System.out.println("Paying " + paymentAmount + " using Credit Card.");
            card.setAmount(card.getAmount() - paymentAmount);
            return true;
        } else {
            return false;
        }
    }

    private boolean cardIsPresent() {
        return card != null;
    }

}

　　strategies/CreditCard.java: 信用卡类

package strategy.strategies;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:58
 */
public class CreditCard {
    private int amount;
    private String number;
    private String date;
    private String cvv;

    CreditCard(String number, String date, String cvv) {
        this.amount = 100_000;
        this.number = number;
        this.date = date;
        this.cvv = cvv;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    public int getAmount() {
        return amount;
    }
}

　　context/Order.java: 订单类

package strategy.context;

import strategy.strategies.PayStrategy;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:59
 * Order class. Doesn't know the concrete payment method (strategy) user has
 * picked. It uses common strategy interface to delegate collecting payment data
 * to strategy object. It can be used to save order to database.
 *
 */
public class Order {
    private int totalCost = 0;
    private boolean isClosed = false;

    public void processOrder(PayStrategy strategy) {
        strategy.collectPaymentDetails();
        // Here we could collect and store payment data from the strategy.
    }

    public void setTotalCost(int cost) {
        this.totalCost += cost;
    }

    public int getTotalCost() {
        return totalCost;
    }

    public boolean isClosed() {
        return isClosed;
    }

    public void setClosed() {
        isClosed = true;
    }
}

　　Demo.java: 客户端代码

package strategy;

import strategy.context.Order;
import strategy.strategies.PayByCreditCard;
import strategy.strategies.PayByPayPal;
import strategy.strategies.PayStrategy;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

/**
 * @author GaoMing
 * @date 2021/7/26 - 20:56
 */
public class Demo {
    private static Map<Integer, Integer> priceOnProducts = new HashMap<>();
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private static Order order = new Order();
    private static PayStrategy strategy;

    static {
        priceOnProducts.put(1, 2200);
        priceOnProducts.put(2, 1850);
        priceOnProducts.put(3, 1100);
        priceOnProducts.put(4, 890);
    }

    public static void main(String[] args) throws IOException {
        while (!order.isClosed()) {
            int cost;

            String continueChoice;
            do {
                System.out.print("Please, select a product:" + "\n" +
                        "1 - Mother board" + "\n" +
                        "2 - CPU" + "\n" +
                        "3 - HDD" + "\n" +
                        "4 - Memory" + "\n");
                int choice = Integer.parseInt(reader.readLine());
                cost = priceOnProducts.get(choice);
                System.out.print("Count: ");
                int count = Integer.parseInt(reader.readLine());
                order.setTotalCost(cost * count);
                System.out.print("Do you wish to continue selecting products? Y/N: ");
                continueChoice = reader.readLine();
            } while (continueChoice.equalsIgnoreCase("Y"));

            if (strategy == null) {
                System.out.println("Please, select a payment method:" + "\n" +
                        "1 - PalPay" + "\n" +
                        "2 - Credit Card");
                String paymentMethod = reader.readLine();

                // Client creates different strategies based on input from user,
                // application configuration, etc.
                if (paymentMethod.equals("1")) {
                    strategy = new PayByPayPal();
                } else {
                    strategy = new PayByCreditCard();
                }
            }

            // Order object delegates gathering payment data to strategy object,
            // since only strategies know what data they need to process a
            // payment.
            order.processOrder(strategy);

            System.out.print("Pay " + order.getTotalCost() + " units or Continue shopping? P/C: ");
            String proceed = reader.readLine();
            if (proceed.equalsIgnoreCase("P")) {
                // Finally, strategy handles the payment.
                if (strategy.pay(order.getTotalCost())) {
                    System.out.println("Payment has been successful.");
                } else {
                    System.out.println("FAIL! Please, check your data.");
                }
                order.setClosed();
            }
        }
    }
}

　　运行结果

Please, select a product:
1 - Mother board
2 - CPU
3 - HDD
4 - Memory
1
Count: 2
Do you wish to continue selecting products? Y/N: y
Please, select a product:
1 - Mother board
2 - CPU
3 - HDD
4 - Memory
2
Count: 1
Do you wish to continue selecting products? Y/N: n
Please, select a payment method:
1 - PalPay
2 - Credit Card
1
Enter the user's email: user@example.com
Enter the password: qwerty
Wrong email or password!
Enter user email: amanda@ya.com
Enter password: amanda1985
Data verification has been successful.
Pay 6250 units or Continue shopping?  P/C: p
Paying 6250 using PayPal.
Payment has been successful.   

　　7. 与其余模式的关系

  • 桥接模式、状态模式和策略模式（在某种程度上包括适配器模式）模式的接口很是类似。实际上，它们都基于组合模式——即将工做委派给其余对象，不过也各自解决了不一样的问题。模式并不仅是以特定方式组织代码的配方，你还可使用它们来和其余开发者讨论模式所解决的问题 

  • 命令模式和策略看上去很像，由于二者都能经过某些行为来参数化对象。可是，它们的意图有很是大的不一样：
    - 命令模式将任何操做转换为对象。 操做的参数将成为对象的成员变量。能够经过转换来延迟操做的执行、将操做放入队列、保存历史命令或者向远程服务发送命令等
    - 策略模式一般用于描述完成某件事的不一样方式，让你可以在同一个上下文类中切换算法

  • 装饰模式可以让你更改对象的外表，策略则让你可以改变其本质
  • 模板方法模式基于继承机制：它容许你经过扩展子类中的部份内容来改变部分算法。策略基于组合机制：你能够经过对相应行为提供不一样的策略来改变对象的部分行为。模板方法在类层次上运做，所以它是静态的。策略在对象层次上运做，所以容许在运行时切换行为
  • 状态可被视为策略的扩展。二者都基于组合机制：它们都经过将部分工做委派给“帮手”对象来改变其在不一样情景下的行为。策略使得这些对象相互之间彻底独立，它们不知道其余对象的存在。但状态模式没有限制具体状态之间的依赖，且容许它们自行改变在不一样情景下的状态

　　8. 已知应用

　　策略模式在Java代码中很常见。它常常在各类框架中使用，能在不扩展类的状况下向用户提供改变其行为的方式　　Java 8 开始支持 lambda 方法，它可做为一种替代策略模式的简单方式　　一些核心 Java 程序库中策略模式的示例：　　对 java.util.Comparator#compare() 的调用来自 Collections#sort()　　javax.servlet.http.HttpServlet：service­()方法，还有全部接受 Http­Servlet­Request和 Http­Servlet­Response对象做为参数的 do­XXX()方法　　javax.servlet.Filter#doFilter()　　识别方法：策略模式能够经过容许嵌套对象完成实际工做的方法以及容许将该对象替换为不一样对象的设置器来识别。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程