设计模式之策略设计模式

1. 策略设计模式介绍

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

2. 策略设计模式使用场景

针对同一类型的问题的多种处理方式，仅仅是具体行为有差别时。
需要安全地封装多种同一类型的操作时。
出现同一抽象类有多个子类，而又需要使用if-else 或者switch-case来选择具体子类时。

3. 策略设计模式的UML类图

4. 策略设计模式的简单实现

情景描述：现在有一个计算的案例，如果满足了大于0的条件，那么就采用method1()的算法，如果满足了小于0的情况，就采用method2的算法。一般情况下我们会采用如下形式：

public class Calculator {
public static void main(String[] args) {
Calculator calculator = new Calculator();

int result1 = calculator.method1(1);
int result2 = calculator.method2(-1);

System.out.println("result1:" + result1);
System.out.println("result2:" + result2);
}

/**
* 计算
* 采用if-else 的方式
*
* @return
*/
public int calculate(int param) {
int result;
if (param > 0) {
result = method1(param);
} else {
result = method2(param);
}
return result;
}

/**
* 方案1
*
* @return
*/
private int method1(int param) {
return 1;
}

/**
* 方案2
*
* @return
*/
private int method2(int param) {
return -1;
}
}

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

如上述代码所示，加入现在又出现了一种情况，等于0时，采用method3算法，那么我们就必须修改if-else，同时加入method3()的具体实现。

假如我们采用策略设计模式，代码如下所示：
首先定义一个接口：CalculateStrategy

public interface CalculateStrategy {
int method();
}

1
2
3
接着所有的method1、method2方法将实现此接口，同时给出具体的实现算法。

public class Method1Stategy implements CalculateStrategy {
@Override
public int method() {
return 1;
}
}

public class Method2Stategy implements CalculateStrategy {
@Override
public int method() {
return -1;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
在Calculator类中，有两个方法setStrategy(CalculateStrategy strategy) 、calculate() ，用户首先设置策略，设置完成后，调用calculate()方法，calculate()方法调用具体策略的具体算法。

public class Calculator {
CalculateStrategy calculateStrategy;

/**
* 设置策略
*
* @param strategy
*/
public void setStrategy(CalculateStrategy strategy) {
this.calculateStrategy = strategy;
}

public int calculate() {
return calculateStrategy.method();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
测试类：Client

public class Client {
public static void main(String[] args) {
Calculator calculator = new Calculator();
//设置策略1
calculator.setStrategy(new Method1Stategy());
int result1 = calculator.calculate();
System.out.println("result1:" + result1);

calculator.setStrategy(new Method2Stategy());
int result2 = calculator.calculate();
System.out.println("result2:" + result2);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

现在如果我们想加入新的算法，只需要实现CalculateStrategy这个接口，同时通过calculator.setStrategy()即可切换算法，不必修改if-else等等。

通过上述代码我们可以看到两者的区别，前者采用了if-else的方式，简单、单一，但是代码臃肿，难以升级维护；后者建立了抽象，将不同的策略构成各自的具体的策略实现，通过设置不同的策略实现算法的替换，增强了系统的可读性、维护性、可拓展性。

5. 策略设计模式在Android源码中

其实我们平时使用的属性动画，内部的实现原理采用时插值器（TimeInterpolator）实现的，也叫时间插值器。 

当我们通过如下代码设置插值器时：

animation.setInterpolator();

1

我们来看看，它内部做了什么?

public abstract class Animation implements Cloneable {
public void setInterpolator(Interpolator i) {
mInterpolator = i;
}

public Interpolator getInterpolator() {
return mInterpolator;
}

/**
* Gets the transformation to apply at a specified point in time. Implementations of this
* method should always replace the specified Transformation or document they are doing
* otherwise.
*
*/
public boolean getTransformation(long currentTime, Transformation outTransformation) {
//省略
final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);
//省略
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在内部保留了插值器的引用。 

此外这里面有一个重要的方法getTransformation()。

在这个方法里面，会调用插值器的 getInterpolation(normalizedTime), 它的作用就是根据时间的流逝的计算出当前属性改变的百分比。

这个相当于策略设计模式中的接口的方法。 

它的代码如下，实际上确实也是一个接口，相当于我们上面例子的CalculateStrategy这个接口。

TimeInterpolator代码如下

public interface TimeInterpolator {

float getInterpolation(float input);
}

1
2
3
4
5

Interpolator代码如下：

public interface Interpolator extends TimeInterpolator {

}

1
2
3

BaseInterpolator代码如下：

abstract public class BaseInterpolator implements Interpolator {

}

1
2
3

所以我们小结一下： 

BaeInterpolator 继承自Interpolator,Interpolator继承自TimeInterpolator。

TimeInterpolator接口里面有 

float getInterpolation(float input);

所以，三个具体的插值器直接继承自BaseInterpolator，并实现各自的getInterpolation方法即可。

然后我们可以看看其他三个插值器的具体实现： 

* LinearInterpolator如下:

public class LinearInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {

public LinearInterpolator() {
}

public LinearInterpolator(Context context, AttributeSet attrs) {
}

public float getInterpolation(float input) {
return input;
}

/** @hide */
@Override
public long createNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createLinearInterpolator();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
AccelerateInterpolator如下：

@HasNativeInterpolator
public class AccelerateInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {
private final float mFactor;
private final double mDoubleFactor;

//省略不相关代码

public float getInterpolation(float input) {
if (mFactor == 1.0f) {
return input * input;
} else {
return (float)Math.pow(input, mDoubleFactor);
}
}

/** @hide */
@Override
public long createNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createAccelerateInterpolator(mFactor);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
DecelerateInterpolator 代码如下：

public class DecelerateInterpolator extends BaseInterpolator implements NativeInterpolatorFactory {

public float getInterpolation(float input) {
float result;
if (mFactor == 1.0f) {
result = (float)(1.0f - (1.0f - input) * (1.0f - input));
} else {
result = (float)(1.0f - Math.pow((1.0f - input), 2 * mFactor));
}
return result;
}

private float mFactor = 1.0f;

/** @hide */
@Override
public long createNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createDecelerateInterpolator(mFactor);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

我们发现上述的三个插值器都实现了BaseInterpolator这个接口。三个类里面getInterpolation()的具体实现又各不相同。通过设置不同的插值器，实现不同的效果。

所以我们的属性动画采用的就是策略设计模式。

6. 策略设计模式在Android开发中

google的网络请求框架volley，里面设置请求超时策略，用到的就是策略设计模式。

RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
StringRequest stringRequest = new StringRequest(Request.Method.GET, "http://www.baidu.com", new Response.Listener<String>() {
@Override
public void onResponse(String response) {

}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {

}
});
//给请求设置超时重连策略
stringRequest.setRetryPolicy(new DefaultRetryPolicy());
requestQueue.add(stringRequest);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DefaultRetryPolicy是默认请求超时策略，我们可以根据不同的需求，定制不同的策略。只需要设置相关参数即可。

//定制请求超时重连策略
stringRequest.setRetryPolicy(new DefaultRetryPolicy(STRING_TIMEOUT_MS, STRING_MAX_RETRIES, STRING_BACKOFF_MULT)))

DefaultRetryPolicy 继承自接口：RetryPolicy

public interface RetryPolicy {

public int getCurrentTimeout();

public int getCurrentRetryCount();

public void retry(VolleyError error) throws VolleyError;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在setRetryPolicy()方法中，保留了我们之前设置的超时重连策略。并且在getTimeoutMs()方法中，返回了超时重连策略的超时时间。

public abstract class Request<T> implements Comparable<Request<T>> {
/** The retry policy for this request. */
private RetryPolicy mRetryPolicy;

public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {
mRetryPolicy = retryPolicy;
return this;
}

public final int getTimeoutMs() {
return mRetryPolicy.getCurrentTimeout();
}

public RetryPolicy getRetryPolicy() {
return mRetryPolicy;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

所以，当通过setRetryPolicy()方法设置不同的超时重连策略，就会返回不同的参数，达到不同的效果。
此外，Adapter也是一个策略模式，我们平时在开发中，一般情况下会继承自BaseAdapter,然后实现不同的View返回，当我们的数据源不同时，getView返回不同的View时，可以通过切换不同的adapter，达到切换View视图的效果。具体代码就不做分析了。

7. 总结

策略设计模式主要用来分离算法，在相同的行为抽象下有不同的具体实现策。这个模式很好地演示了开闭原则，也就是定义抽象，注入不同的实现，从而达到很好的扩展性。
优点： 
结构清晰明了，使用简单直观
耦合度相对而言较低，扩展方便。
操作封装业更为彻底，数据更为安全

缺点： 
随着策略的增加，子类会变得繁多。