策略模式介绍

策略模式定义

策略模式（Strategy Pattern），将各种算法封装到具体的类中，作为一个抽象策略类的子类，使得它们可以互换。客户端可以自行决定使用哪种算法。

策略模式类图

策略模式类图如下

策略模式角色划分

  • Strategy 策略接口或者（抽象策略类），定义策略执行接口
  • ConcreteStrategy 具体策略类
  • Context 上下文类，持有具体策略类的实例，并负责调用相关的算法

策略模式实例解析

本文代码可从作者Github下载

典型策略模式实现

策略接口，定义策略执行接口

1
2
3
4
5
6
7
package com.jasongj.strategy;
public interface Strategy {
void strategy(String input);
}

具体策略类，实现策略接口，提供具体算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.jasongj.strategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@com.jasongj.annotation.Strategy(name="StrategyA")
public class ConcreteStrategyA implements Strategy {
private static final Logger LOG = LoggerFactory.getLogger(ConcreteStrategyB.class);
@Override
public void strategy(String input) {
LOG.info("Strategy A for input : {}", input);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.jasongj.strategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@com.jasongj.annotation.Strategy(name="StrategyB")
public class ConcreteStrategyB implements Strategy {
private static final Logger LOG = LoggerFactory.getLogger(ConcreteStrategyB.class);
@Override
public void strategy(String input) {
LOG.info("Strategy B for input : {}", input);
}
}

Context类，持有具体策略类的实例，负责调用具体算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.jasongj.context;
import com.jasongj.strategy.Strategy;
public class SimpleContext {
private Strategy strategy;
public SimpleContext(Strategy strategy) {
this.strategy = strategy;
}
public void action(String input) {
strategy.strategy(input);
}
}

客户端可以实例化具体策略类，并传给Context类，通过Context统一调用具体算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.jasongj.client;
import com.jasongj.context.SimpleContext;
import com.jasongj.strategy.ConcreteStrategyA;
import com.jasongj.strategy.Strategy;
public class SimpleClient {
public static void main(String[] args) {
Strategy strategy = new ConcreteStrategyA();
SimpleContext context = new SimpleContext(strategy);
context.action("Hellow, world");
}
}

使用Annotation和简单工厂模式增强策略模式

上面的实现中，客户端需要显示决定具体使用何种策略，并且一旦需要换用其它策略，需要修改客户端的代码。解决这个问题，一个比较好的方式是使用简单工厂，使得客户端都不需要知道策略类的实例化过程，甚至都不需要具体哪种策略被使用。

如《Java设计模式（一） 简单工厂模式不简单》所述，简单工厂的实现方式比较多，可以结合《Java系列（一）Annotation（注解）》中介绍的Annotation方法。

使用Annotation和简单工厂模式的Context类如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.jasongj.context;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.reflections.Reflections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jasongj.strategy.Strategy;
public class SimpleFactoryContext {
private static final Logger LOG = LoggerFactory.getLogger(SimpleFactoryContext.class);
private static Map<String, Class> allStrategies;
static {
Reflections reflections = new Reflections("com.jasongj.strategy");
Set<Class<?>> annotatedClasses =
reflections.getTypesAnnotatedWith(com.jasongj.annotation.Strategy.class);
allStrategies = new ConcurrentHashMap<String, Class>();
for (Class<?> classObject : annotatedClasses) {
com.jasongj.annotation.Strategy strategy = (com.jasongj.annotation.Strategy) classObject
.getAnnotation(com.jasongj.annotation.Strategy.class);
allStrategies.put(strategy.name(), classObject);
}
allStrategies = Collections.unmodifiableMap(allStrategies);
}
private Strategy strategy;
public SimpleFactoryContext() {
String name = null;
try {
XMLConfiguration config = new XMLConfiguration("strategy.xml");
name = config.getString("strategy.name");
LOG.info("strategy name is {}", name);
} catch (ConfigurationException ex) {
LOG.error("Parsing xml configuration file failed", ex);
}
if (allStrategies.containsKey(name)) {
LOG.info("Created strategy name is {}", name);
try {
strategy = (Strategy) allStrategies.get(name).newInstance();
} catch (InstantiationException | IllegalAccessException ex) {
LOG.error("Instantiate Strategy failed", ex);
}
} else {
LOG.error("Specified Strategy name {} does not exist", name);
}
}
public void action(String input) {
strategy.strategy(input);
}
}

从上面的实现可以看出，虽然并没有单独创建一个简单工厂类，但它已经融入了简单工厂模式的设计思想和实现方法。

客户端调用方式如下

1
2
3
4
5
6
7
8
9
10
11
12
package com.jasongj.client;
import com.jasongj.context.SimpleFactoryContext;
public class SimpleFactoryClient {
public static void main(String[] args) {
SimpleFactoryContext context = new SimpleFactoryContext();
context.action("Hellow, world");
}
}

从上面代码可以看出，引入简单工厂模式后，客户端不再需要直接实例化具体的策略类，也不需要判断应该使用何种策略，可以方便应对策略的切换。

策略模式分析

策略模式优点

  • 策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法（策略），并且可以灵活地增加新的算法（策略）。
  • 策略模式通过Context类提供了管理具体策略类（算法族）的办法。
  • 结合简单工厂模式和Annotation，策略模式可以方便的在不修改客户端代码的前提下切换算法（策略）。

策略模式缺点

  • 传统的策略模式实现方式中，客户端必须知道所有的具体策略类，并须自行显示决定使用哪一个策略类。但通过本文介绍的通过和Annotation和简单工厂模式结合，可以有效避免该问题
  • 如果使用不当，策略模式可能创建很多具体策略类的实例，但可以通过使用上文《Java设计模式（十一） 享元模式》介绍的享元模式有效减少对象的数量。

策略模式已（未）遵循的OOP原则

已遵循的OOP原则

  • 依赖倒置原则
  • 迪米特法则
  • 里氏替换原则
  • 接口隔离原则
  • 单一职责原则
  • 开闭原则

未遵循的OOP原则

  • NA

Java设计模式系列

  • Java设计模式（一） 简单工厂模式不简单
  • Java设计模式（二） 工厂方法模式
  • Java设计模式（三） 抽象工厂模式
  • Java设计模式（四） 观察者模式
  • Java设计模式（五） 组合模式
  • Java设计模式（六） 代理模式 VS. 装饰模式
  • Java设计模式（七） Spring AOP JDK动态代理 vs. cglib
  • Java设计模式（八） 适配器模式
  • Java设计模式（九） 桥接模式
  • Java设计模式（十） 你真的用对单例模式了吗？
  • Java设计模式（十一） 享元模式
  • Java设计模式（十二） 策略模式

from: http://www.jasongj.com/design_pattern/strategy/

Java设计模式（十二） 策略模式相关推荐

  1. 设计模式 ( 十八 ) 策略模式Strategy（对象行为型）

    设计模式 ( 十八 ) 策略模式Strategy(对象行为型) 1.概述 在软件开发中也经常遇到类似的情况,实现某一个功能有多种算法或者策略,我们能够依据环境或者条件的不同选择不同的算法或者策略来完毕 ...

  2. Java设计模式之十一 ---- 策略模式和模板方法模式

    前言 在上一篇中我们学习了行为型模式的访问者模式(Visitor Pattern)和中介者模式(Mediator Pattern).本篇则来学习下行为型模式的两个模式,策略模式(Strategy Pa ...

  3. Java设计模式6：策略模式

    策略模式 策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立类中,从而使得它们可以相互替换.策略模式使得算法可以在不影响到客户端的情况下发生变化. 策略模式的结构 策略模式是对算法的包 ...

  4. [设计模式](十)：策略模式(Strategy)与模板模式(Template)详解及二者间区别介绍（两种父子类行为模式）

    这次要说的两个模式,都是行为模式,指的是在程序运行过程中,经过经验总结的行为开发模式. 其次,行为模式再按照类与类间关系的划分,可以划分为四个类型:父子关系(2种).独立类间关系(4种).类自身状态( ...

  5. java设计模式之【策略模式】

    策略模式 策略模式定义了算法族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化独立于使用算法的客户. 开启策略模式 我们的的代码中有各种鸭子 突然有一天,我们的需求变了.... 但是这也带来 ...

  6. Java 设计模式情景分析——策略模式

    当实现某功能需要根据实际情况选择不同的算法或者策略时,可以选择通过硬编码的方式(if-else 或者 switch-case)来实现,但是这样会使这个类变得臃肿,维护成本上升,出错率也变大了.基于这样 ...

  7. Java设计模式(十二)：状态设计模式

    1.应用场景 在软件开发过程中,应用程序可能会根据不同的情况作出不同的处理.最直接的解决方案是将这些所有可能发生的情况全都考虑到.然后使用if- ellse语句来做状态判断来进行不同情况的处理.但是对 ...

  8. 重学 Java 设计模式：实战策略模式「模拟多种营销类型优惠券，折扣金额计算策略场景」

    作者:小傅哥 博客:https://bugstack.cn - 原创系列专题文章 沉淀.分享.成长,让自己和他人都能有所收获!

  9. 【每天一个java设计模式（二十三）】 - 访问者模式

    在访问者模式中,我们使用了一个访问者类,它改变了元素类的执行算法.通过这种方式,元素的执行算法可以随着访问者改变而改变.这种类型的设计模式属于行为型模式.根据模式,元素对象已接受访问者对象,这样访问者 ...

  10. 设计模式十二之组合模式

    设计模式十二之组合模式 1. 模式的定义与特点 1.1 模式的定义 1.2 模式的特点 1.3 模式的使用场景 2. 模式的结构与实现 2.1 模式的结构 2.2 模式的实现 3. 模式在开源软件中的 ...

最新文章

  1. 五层架构（MVC+biz+lib）
  2. Java——集合带All的功能演示
  3. SortedDictionaryTKey,TValue正序与反序排序及Dicttionary相关
  4. MyBatis的三个基本要素
  5. ACM 国际大学生程序设计竞赛简介
  6. M个苹果放在N个盘子里，有多少种不同的放法
  7. gc算法 java_Java的GC机制及算法
  8. 如何在MacBook Pro上使用原彩显示功能？
  9. selenium 远程调用浏览器
  10. 申请邓白氏编码的流程
  11. 超星高级语言程序设计实验作业 （实验04 数组及其在程序设计中的应用）（二）
  12. dongle 工具 蓝牙_bluetooth USB Dongle（蓝牙适配器）怎么用？
  13. 电力窃漏电用户自动识别的实验报告
  14. 技术选型系列 -- Redis VS Memcached
  15. 画图函数title 和 axis 的用法
  16. CCNA实验三十八 ZFW(区域防火墙)
  17. GNSS观测方程及线性组合(全)
  18. 人工智能基础复习1——人工智能概述
  19. Screen安装+命令使用教程
  20. 详解URI、URN、URL

热门文章

  1. Catch Me If You ... Can't Do Otherwise--转载
  2. 分隔单词和标点符号示例
  3. CatBoost讲解
  4. 机器学习Sklearn实战——极限森林、梯度提升树算法
  5. 基于Python的开源人脸识别库：离线识别率高达99.38%
  6. Gartner的2019战略性技术趋势：量子计算、区块链、AI
  7. 求解LambdaMART的疑惑？
  8. Slack：日活跃用户50万人、6周增幅35%造就奇迹
  9. Linux-编写Shell的几个技巧_02
  10. MySQL-主从复制监控