Java设计模式(十二) 策略模式

原创文章,转载请务必将下面这段话置于文章开头处(保留超链接)。
本文转发自Jason’s Blog原文链接 http://www.jasongj.com/design_pattern/strategy/

策略模式介绍

策略模式定义

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

策略模式类图

策略模式类图如下
Strategy Pattern Class Diagram

策略模式角色划分

  • 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设计模式系列

郭俊 Jason wechat
欢迎关注作者微信公众号【大数据架构】
您的赞赏将支持作者继续原创分享