`

策略模式

设计模式 
阅读更多
本文探讨初学使用策略模式时遇到的一些疑惑，以及在工作中慢慢解决之前遇到的疑惑，借此与大家分享。比如说本文谈到策略模式中环境角色Context的用处，为什么一定要用，可不可以将此取消。这些都是在学习和工作的实践总结中慢慢体会到的。
首先，我们来看下策略模式的概念。一般的解释如下：　
策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。（原文：The Strategy Pattern defines a family of algorithms,encapsulates each one,and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.）

一般的，策略模式主要分为以下三个角色：
1． 环境角色（Context）:持有一个策略类引用
2． 抽象策略（Strategy）:定义了多个具体策略的公共接口，具体策略类中各种不同的算法以不同的方式实现这个接口；Context使用这些接口调用不同实现的算法。一般的，我们使用接口或抽象类实现。
3． 具体策略（ConcreteStrategy）:实现抽象策略类中的相关的算法或操作。

我们首先来写一个简单的策略模式，然后再结合实际应用进行扩展，进而思考其在实际开发中的使用方法。
（给大家推荐前辈写的一篇不错的博文，研磨设计模式之 策略模式http://www.uml.org.cn/sjms/201009092.asp）
我们这个简单的策略假设就是想让不同的策略来实现某个算法（algorithm），抽象类如下：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo.strategy;
  2. /**
  3. * 抽象策略
  4. * @author zhanche
  5. *
  6. */
  7. public abstract class AbstractStrategy {
  8. /**
  9. * 某个希望有不同策略实现的算法
  10. */
  11. public abstract void algorithm();
  12. }

算法algorithm的具体实现策略类ConcreteStrategy1和ConcreteStrategy2如下：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo.strategy.impl;
  3. import com.icecode.demo.strategy.AbstractStrategy;
  4. /**
  5. * 对算法的第一种具体实现策略
  6. * @author zhanche
  7. *
  8. */
  9. public class ConcreteStrategy1 extends AbstractStrategy {
  11. @Override
  12. public void algorithm() {
  13. System.out.println("----------------我是策略一算法----------------");
  14. }
  16. }
  18. package com.icecode.demo.strategy.impl;
  20. import com.icecode.demo.strategy.AbstractStrategy;
  21. /**
  22. * 对算法的第二种具体实现策略
  23. * @author zhanche
  24. *
  25. */
  26. public class ConcreteStrategy2 extends AbstractStrategy {
  28. @Override
  29. public void algorithm() {
  30. System.out.println("----------------我是策略二算法----------------");
  31. }
  33. }


环境角色的实现如下：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo.context;
  3. import com.icecode.demo.strategy.AbstractStrategy;
  4. /**
  5. * 环境角色，主要完成对特定策略的调用
  6. * @author zhanche
  7. *
  8. */
  9. public class Context {
  10. private AbstractStrategy strategy;
  12. public Context(AbstractStrategy strategy) {
  13. this.strategy = strategy;
  14. }
  15. public void algorithm() {
  16. this.strategy.algorithm();
  17. }
  18. }


下面简单写一个客户端测试的代码：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo;
  3. import com.icecode.demo.context.Context;
  4. import com.icecode.demo.strategy.impl.ConcreteStrategy1;
  5. import com.icecode.demo.strategy.impl.ConcreteStrategy2;
  6. /**
  7. * 策略模式测试类
  8. * @author zhanche
  9. *
  10. */
  11. public class Client {
  13. /**
  14. * @param args
  15. */
  16. public static void main(String[] args) {
  17. Context context = new Context(new ConcreteStrategy1());
  18. context.algorithm();
  20. context = new Context(new ConcreteStrategy2());
  21. context.algorithm();
  22. }
  24. }


输出结果如下：
----------------我是策略一算法----------------
----------------我是策略二算法----------------


好吧，到此为止，一个简单的策略模式就写完了。但是，大家肯定有所疑惑，Context完全可以没有嘛，既然抽象策略AbstractStrategy已经持有algorithm这个接口，我们完全可以如下去写代码，让系统根据不同的实现执行不同的策略不就完了。代码可以如下：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo;
  3. import com.icecode.demo.strategy.AbstractStrategy;
  4. import com.icecode.demo.strategy.impl.ConcreteStrategy1;
  5. import com.icecode.demo.strategy.impl.ConcreteStrategy2;
  6. /**
  7. * 策略模式测试类
  8. * @author zhanche
  9. *
  10. */
  11. public class Client {
  13. /**
  14. * @param args
  15. */
  16. public static void main(String[] args) {
  17. AbstractStrategy strategy = new ConcreteStrategy1();
  18. strategy.algorithm();
  20. strategy = new ConcreteStrategy2();
  21. strategy.algorithm();
  22. }
  24. }

输出结果如下：
----------------我是策略一算法----------------
----------------我是策略二算法----------------

可见，2种方案都实现了同一个引用根据不同的实现执行特定的算法。是的，分析发现，在上面简单的应用中，Context的确可以取消。那么，Context这个角色为什么还要存在呢？
让我们考虑以下几种情况：
1、如果我们需要对不同策略中相同算法的参数，执行相同的安全性检查，我们如果没有环境角色Context，则只能在每个实现的开始部分，调用安全性检查代码；而有了Context这个角色，我们可以在调用Context的构造器时，统一进行安全性检查。这在我们的实现策略比较多的时候，比如说7、8个的时候，特别有用，可以大量减少冗余的代码量。
2、如果我们需要改变原有算法时，需要引进新的参数，如果没有Context，我们怎么办？一种办法是重载该算法，增加新的函数接口；另外一种办法是完全废弃原有的函数接口，重新写新的函数接口。毋庸置疑，这2种办法的代价都很大，尤其是如果这个新的参数只有部分实现策略中的该算法实现用到的时候。而我们使用Context就可以完全解决这个问题。
下面我们改造下上面那个基本策略模式，我们让策略模式也持有对Context的引用，这样的优点是可以在策略类里回调的Context里的所有可用的变量或函数等信息。此外，我们也增加一个新的实现策略类ConcreteStrategy3，具体代码如下所示：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo.strategy;
  3. import com.icecode.demo.context.Context;
  5. /**
  6. * 抽象策略
  7. * @author zhanche
  8. *
  9. */
  10. public abstract class AbstractStrategy {
  11. /**
  12. * 某个希望有不同策略实现的算法
  13. */
  14. public abstract void algorithm(Context context);
  15. }
  18. package com.icecode.demo.strategy.impl;
  20. import com.icecode.demo.context.Context;
  21. import com.icecode.demo.strategy.AbstractStrategy;
  22. /**
  23. * 对算法的第一种具体实现策略
  24. * @author zhanche
  25. *
  26. */
  27. public class ConcreteStrategy1 extends AbstractStrategy {
  29. @Override
  30. public void algorithm(Context context) {
  31. System.out.println("----------------我是策略一算法----------------");
  32. }
  34. }
  37. package com.icecode.demo.strategy.impl;
  39. import com.icecode.demo.context.Context;
  40. import com.icecode.demo.strategy.AbstractStrategy;
  41. /**
  42. * 对算法的第二种具体实现策略
  43. * @author zhanche
  44. *
  45. */
  46. public class ConcreteStrategy2 extends AbstractStrategy {
  48. @Override
  49. public void algorithm(Context context) {
  50. System.out.println("----------------我是策略二算法----------------");
  51. }
  54. }
  57. package com.icecode.demo.strategy.impl;
  59. import com.icecode.demo.context.Context;
  60. import com.icecode.demo.strategy.AbstractStrategy;
  61. /**
  62. * 对算法的第三种具体实现策略
  63. * @author zhanche
  64. *
  65. */
  66. public class ConcreteStrategy3 extends AbstractStrategy {
  68. @Override
  69. public void algorithm(Context context) {
  70. System.out.println("----------------我是策略三算法----------------");
  71. }
  74. }
  76. package com.icecode.demo.context;
  78. import com.icecode.demo.strategy.AbstractStrategy;
  79. /**
  80. * 环境角色，主要完成对特定策略的调用
  81. * @author zhanche
  82. *
  83. */
  84. public class Context {
  85. /**
  86. * 持有对策略的引用
  87. */
  88. private AbstractStrategy strategy;
  90. /**
  91. * 算法入口
  92. */
  93. public void algorithm() {
  94. this.strategy.algorithm(this);
  95. }
  97. }


好了，现在我们想这样改变需求，ConcreteStrategy2和ConcreteStrategy3里对algorithm算法的实现，需要统计两个新的信息，分别用parameter1和parameter2来表示，同时要统计所有实现策略类里，对algorithm算法调用的次数。
如果没有Context这个角色，又需要做到客户端调用的时候代码改动尽量少，相信大家的做法只好是改抽象策略类和实现策略类里的algorithm算法。但是这样实现策略ConcreteStrategy1可能不愿意了，因为他并不需要新增加的参数；此外，对所有实现类里algorithm算法调用的统计也没有一个统一的入口，需要在每个algorithm实现中，插入一个计数代码。但是如果有了环境角色Context，一切就变得很简单了，我们不需要改动抽象策略类，和实现策略类ConcreteStrategy1，只需要改需求发生变化相关的类，且看下面的代码：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo.context;
  3. import com.icecode.demo.strategy.AbstractStrategy;
  4. /**
  5. * 环境角色，主要完成对特定策略的调用
  6. * @author zhanche
  7. *
  8. */
  9. public class Context {
  10. /**
  11. * 持有对策略的引用
  12. */
  13. private AbstractStrategy strategy;
  14. /**
  15. * parameter1、parameter2只是ConcreteStrategy2ConcreteStrategy3需要使用的参数，
  16. * 而ConcreteStrategy1不使用
  17. */
  18. private int parameter1;
  19. private int parameter2;
  20. //count用来统计所有策略的算法algorithm调用的总次数
  21. public static int count = 0;
  23. public Context(AbstractStrategy strategy) {
  24. this.strategy = strategy;
  25. }
  27. public Context(AbstractStrategy strategy, int parameter1, int parameter2) {
  28. super();
  29. this.strategy = strategy;
  30. this.parameter1 = parameter1;
  31. this.parameter2 = parameter2;
  32. }
  34. public int getParameter1() {
  35. return parameter1;
  36. }
  38. public int getParameter2() {
  39. return parameter2;
  40. }
  41. /**
  42. * 算法入口
  43. */
  44. public void algorithm() {
  45. count++;
  46. System.out.println("------------这是第"+count+"次调用algorithm算法--------");
  47. this.strategy.algorithm(this);
  48. }
  50. }
  52. package com.icecode.demo.strategy.impl;
  54. import com.icecode.demo.context.Context;
  55. import com.icecode.demo.strategy.AbstractStrategy;
  56. /**
  57. * 对算法的第一种具体实现策略
  58. * @author zhanche
  59. *
  60. */
  61. public class ConcreteStrategy1 extends AbstractStrategy {
  63. @Override
  64. public void algorithm(Context context) {
  65. System.out.println("----------------我是策略一算法----------------");
  66. }
  68. }
  71. package com.icecode.demo.strategy.impl;
  73. import com.icecode.demo.context.Context;
  74. import com.icecode.demo.strategy.AbstractStrategy;
  75. /**
  76. * 对算法的第二种具体实现策略
  77. * @author zhanche
  78. *
  79. */
  80. public class ConcreteStrategy2 extends AbstractStrategy {
  82. @Override
  83. public void algorithm(Context context) {
  84. System.out.println("----------------我是策略二算法----------------");
  85. System.out.println("------------------我需要的参数parameter1="+context.getParameter1());
  86. System.out.println("------------------我需要的参数parameter2="+context.getParameter2());
  88. }
  91. }
  94. package com.icecode.demo.strategy.impl;
  96. import com.icecode.demo.context.Context;
  97. import com.icecode.demo.strategy.AbstractStrategy;
  98. /**
  99. * 对算法的第三种具体实现策略
  100. * @author zhanche
  101. *
  102. */
  103. public class ConcreteStrategy3 extends AbstractStrategy {
  105. @Override
  106. public void algorithm(Context context) {
  107. System.out.println("----------------我是策略二算法----------------");
  108. System.out.println("------------------我需要的参数parameter1="+context.getParameter1());
  109. System.out.println("------------------我需要的参数parameter2="+context.getParameter2());
  111. }
  114. }


客户端测试的代码如下：
Java代码 复制代码 收藏代码
  1. package com.icecode.demo;
  3. import com.icecode.demo.context.Context;
  4. import com.icecode.demo.strategy.impl.ConcreteStrategy1;
  5. import com.icecode.demo.strategy.impl.ConcreteStrategy2;
  6. import com.icecode.demo.strategy.impl.ConcreteStrategy3;
  7. /**
  8. * 策略模式测试类
  9. * @author zhanche
  10. *
  11. */
  12. public class Client {
  14. /**
  15. * @param args
  16. */
  17. public static void main(String[] args) {
  18. Context context = new Context(new ConcreteStrategy1());
  19. context.algorithm();
  21. context = new Context(new ConcreteStrategy2(),100, 200);
  22. context.algorithm();
  24. context = new Context(new ConcreteStrategy3(), 100, 200);
  25. context.algorithm();
  26. }
  28. }

测试输出结果如下：
------------这是第1次调用algorithm算法--------
----------------我是策略一算法----------------
------------这是第2次调用algorithm算法--------
----------------我是策略二算法----------------
------------------我需要的参数parameter1=100
------------------我需要的参数parameter2=200
------------这是第3次调用algorithm算法--------
----------------我是策略三算法----------------
------------------我需要的参数parameter1=100
------------------我需要的参数parameter2=200

由以上分析可见，策略模式中，各个角色的功能都非常重要，虽然环境角色Context可以在某些简单的策略模式中不去使用，但是如果无法预测到各个实现策略功能和需求的变化，以及实现灵活性更好的策略模式，在使用策略模式进行架构时，一定要充分利用所有角色的功能。 
分享到：
| Eclipse快捷键大全(转载)
评论
发表评论

文章已被作者锁定，不允许评论。

相关推荐

    策略模式结合模板方法模式

    策略模式结合模板方法模式的设计思路 策略模式结合模板方法模式是策略模式的一种变形，目的是为了解决策略模式中的一些共性问题。在策略模式中，经常会出现这样一种情况，就是发现这一系列算法的实现上存在公共功能...

    详解SpringBoot结合策略模式实战套路

    SpringBoot结合策略模式实战套路 策略模式是一种常用的设计模式，它可以使我们的代码更加灵活、可维护和可扩展。在SpringBoot项目中，策略模式可以与依赖注入机制相结合，实现更加灵活的业务逻辑处理。在本文中，...

    设计模式之策略模式 鸭子问题

    设计模式之策略模式 鸭子问题 策略模式是一种经典的设计模式，通过鸭子问题，可以让学习者更好地了解设计模式的概念和实现。策略模式的主要思想是定义一系列的算法，并将每一个算法封装起来，使它们可以相互替换。...

    桥接模式和策略模式的区别，内含可运行代码和两者详细区别

    桥接模式和策略模式是软件设计模式中的两种重要模式，它们在实现上有着相似之处，但各自的应用场景和设计理念有所不同。下面将详细阐述这两种模式的特点、区别以及它们在实际编程中的应用。 首先，桥接模式（Bridge...

    策略模式在实际项目中的应用二

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通过定义一系列的算法，并将每一个算法封装起来，使它们可以相互替换，让算法独立于使用它的客户而变化。这种模式通常用于处理多种...

    Spring下使用策略模式

    在Spring框架中，策略模式是一种常见的设计模式，它允许我们定义一组可互换的策略，这些策略可以在运行时根据需求动态选择。这篇文章将深入探讨如何在Spring中运用策略模式，并结合源码分析其工作原理。 策略模式的...

    策略模式的实现，通过反射

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常用于将算法封装到不同的类中，使得可以根据需要动态选择并应用这些算法。本示例将详细介绍如何通过两种方法实现策略模式：一种...

    抽象工厂模式+工厂方法模式+策略模式+类图实现手机加工厂

    本文将探讨三个重要的设计模式：抽象工厂模式、工厂方法模式以及策略模式，并结合一个实际的场景——手机加工厂，来具体阐述它们的应用。 首先，我们来看**抽象工厂模式**。这个模式主要用于创建相关或依赖对象的...

    55-Java设计模式之策略模式与状态模式1

    Java 设计模式之策略模式与状态模式 策略模式是 Java 中的一种设计模式，它主要用于解决系统与第三方接口进行数据交互的问题。当系统需要与多种格式的数据进行交互时，使用策略模式可以很好地解决这个问题。例如，...

    策略模式封装的几个加密解密算法源码

    在"策略模式封装的几个加密解密算法源码"中，我们主要关注的是如何使用策略模式来封装常见的加密解密算法，如BASE64和MD5。 1. **BASE64编码**：BASE64是一种用于将二进制数据编码为ASCII字符的编码方式，以便在...

    策略模式的简单例子

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同条件或选择执行不同算法的情况。策略模式提供了一种将算法封装到独立可互换的策略对象中，使得算法的变化独立...

    设计模式之策略模式，商场收银，封装算法

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或场景来执行不同算法的情况。策略模式就是为了解决这类问题而提出的，它将每种算法封装到具有共同接口...

    js策略模式和代理模式

    策略模式和代理模式是设计模式中的两种常见模式，它们在软件开发中扮演着重要的角色，尤其是在JavaScript中，这两种模式提供了更加灵活和可维护的代码结构。 策略模式（Strategy Pattern）是一种行为设计模式，它...

    策略模式 template模式

    策略模式（Template模式） 策略模式是设计模式中的一种 객체行为型模式，它定义了一系列算法，封装每一个算法，并使它们可以互相替换。策略模式使得算法可以独立于使用它的客户而变化。 概述 在软件开发中，经常...

    Java 设计模式 策略模式

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户而变化。 首先，策略模式的...

    策略模式的示例代码和思想模式

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常涉及接口或抽象类的实现，允许程序在运行时选择并应用不同的算法或策略。这种模式的核心在于将算法封装到独立的可互换的策略中...

    Java策略模式+案例

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式允许我们定义一组算法或策略，并将每个策略封装为一个类，使得它们可以互换，而不会影响到客户端代码。这种模式的核心在于"策略"，...

    策略模式代码实现

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为模式。 策略模式定义了一系列的算法，并将每一个算法封装起来，使...

    设计模式——策略模式

    策略模式的设计与实现 策略模式是一种常用的设计模式，它定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。策略模式的主要优点是它可以使得算法的变化独立于使用算法...

    软件设计模式策略模式实例

    策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件工程中，当一个系统需要在不同时间执行不同的算法或者行为时，策略模式就显得尤为有用。这种模式将算法封装到独立的可相互替换的策略类中，使得...

Magicbox
Global site tag (gtag.js) - Google Analytics