Android设计模式之策略模式

今天介绍下策略模式，直接先上UML图

策略模式的概念

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、需要使用ConcreteStrategy提供的算法。
2、 内部维护一个Strategy的实例。
3、 负责动态设置运行时Strategy具体的实现算法。
4、负责跟Strategy之间的交互和数据传递。

策略模式的组成

— Strategy（抽象策略类）： 通常由一个接口或者抽象类实现。
— ConcreteStrategy（具体策略角色）：包装了相关的算法和行为。一般有多个
— Context（环境角色）：持有一个策略类的引用，最终给客户端调用。

策略模式的应用场景

定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。策略模式使得算法可独立于使用它的客户而变化。实际开发中用途，比如google开源的android网络框架volley，volley的超时重发重发机制就使用到了典型策略模式，看源码
RetryPolicy.java 请求重试策略类，定义了三个接口

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

package com.android.volley; /** * 请求重试策略类 * 此类属于抽象策略类对应Strategy */ public interface RetryPolicy { /** * 超时时间 */ public int getCurrentTimeout(); /** * 重试次数 */ public int getCurrentRetryCount(); /** * 针对错误异常的处理 */ public void retry(VolleyError error) throws VolleyError; }

DefaultRetryPolicy.java 默认重试策略，继承了RetryPolicy ，具体实现了接口,我截取了部分代码

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

public class DefaultRetryPolicy implements RetryPolicy { ... public static final int DEFAULT_TIMEOUT_MS = 2500; private int mCurrentTimeoutMs; /** The default number of retries */ public static final int DEFAULT_MAX_RETRIES = 0; /** The default backoff multiplier */ public static final float DEFAULT_BACKOFF_MULT = 1f; ...//代表省略掉的代码 @Override public int getCurrentTimeout() { return mCurrentTimeoutMs; } @Override public int getCurrentRetryCount() { return mCurrentRetryCount; } @Override public void retry(VolleyError error) throws VolleyError { mCurrentRetryCount++; mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier); if (!hasAttemptRemaining()) { throw error; } } }

Request.java 请求类，持有一个抽象策略类RetryPolicy 的引用，最终给客户端调用。截取部分代码

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

public abstract class Request<T> implements Comparable<Request<T>> { private RetryPolicy mRetryPolicy; //持有策略类的引用 ... public Request(int method, String url, Response.ErrorListener listener) { mMethod = method; mUrl = url; mIdentifier = createIdentifier(method, url); mErrorListener = listener; setRetryPolicy(new DefaultRetryPolicy()); //设置策略类 mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url); } ... public Request<?> setRetryPolicy(RetryPolicy retryPolicy) { mRetryPolicy = retryPolicy; return this; } ... public final int getTimeoutMs() { return mRetryPolicy.getCurrentTimeout(); } }

BasicNetwork.java 网络处理类，处理Request，使用到了对应的重试策略，截取部分代码

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

/** *遇到异常请求使用到了策略类的getTimeoutMs()方法 */ private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError { RetryPolicy retryPolicy = request.getRetryPolicy(); int oldTimeout = request.getTimeoutMs(); try { retryPolicy.retry(exception); } catch (VolleyError e) { request.addMarker( String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout)); throw e; } request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout)); } ... /** * 网速慢，获取重试策略的重试次数getCurrentRetryCount */ private void logSlowRequests(long requestLifetime, Request<?> request, byte[] responseContents, StatusLine statusLine) { if (DEBUG || requestLifetime > SLOW_REQUEST_THRESHOLD_MS) { VolleyLog.d("HTTP response for request=<%s> [lifetime=%d], [size=%s], " + "[rc=%d], [retryCount=%s]", request, requestLifetime, responseContents != null ? responseContents.length : "null", statusLine.getStatusCode(), request.getRetryPolicy().getCurrentRetryCount()); } } ... private static void attemptRetryOnException(String logPrefix, Request<?> request, VolleyError exception) throws VolleyError { RetryPolicy retryPolicy = request.getRetryPolicy(); int oldTimeout = request.getTimeoutMs(); try { retryPolicy.retry(exception); } catch (VolleyError e) { request.addMarker( String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout)); throw e; } request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout)); }

实际使用中，我们可以自定义自己的策略继承RetryPolicy，这样就可以按照我们自己请求策略执行。

下面介绍一个比较简单的实例

自定义简单的策略模式实例

商品实现针对不同等级会员显示对应的会员价，比如一本书原价100元，一级会员打97折，三级会员打8折

PriceStrategy.java，策略类，可以使抽象类或接口，定义算法的公共接口，

1 2 3 4 5 6 7 8

/** * 定义一个计算价格的接口 * 它属于抽象策略类 * @author su */ public interface PriceStrategy { double priceStrategyInterface(double price); }

SuperVipStrategy.java，超级会员算法，打八折，继承PriceStrategy

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

/** * 超级会员类 * 它属于具体策略类，继承了计算价格接口 * @author su * */ public class SuperVipStrategy implements PriceStrategy { @Override public double priceStrategyInterface(double price) { return price * 0.8; //打八折 } }

OneVipStrategy.java，一级会员算法，打九七折，继承PriceStrategy

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

/** * 一级会员类 * 它属于具体策略类 * @author su * */ public class OneVipStrategy implements PriceStrategy { @Override public double priceStrategyInterface(double price) { return 0.97 * price; //打九七折 } }

ThreeVipStrategy.java，三级会员算法，打九五折，继承PriceStrategy

1 2 3 4 5 6 7 8 9 10 11

/** * 三级会员商品类 * 它属于具体策略类 * @author su */ public class ThreeVipStrategy implements PriceStrategy { @Override public double priceStrategyInterface(double price) { return 0.95 * price; //九五折 } }

Price.java 上下文环境，持有PriceStrategy 的引用。

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

/** * 环境角色 * @author su * */ public class Price { private PriceStrategy priceStrategy; public Price(PriceStrategy priceStrategy){ this.priceStrategy = priceStrategy; } public double getVipPrice(double price){ return priceStrategy.priceStrategyInterface(price); } }

测试实例

1 2 3 4 5 6 7 8 9 10 11

public class Test { public static void main(String[] args){ SuperVipStrategy supVipSrategy = new SuperVipStrategy(); OneVipStrategy onVipStrategy = new OneVipStrategy(); System.out.print("超级会员价="+new Price(supVipSrategy).getVipPrice(100)); System.out.print("一级员价="+new Price(onVipStrategy).getVipPrice(100)); } } -----输出结果--- 超级会员价=80.0一级员价=97.0

实例的uml图

总结

优点

1、 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)，还比继承更灵活(算法独立，可以任意扩展)；
2、 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展；
3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合；
4、 易于进行单元测试，各个算法区分开，可以针对每个算法进行单元测试；

缺点

1、 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量；
2、 选择何种算法需要客户端来创建对象，增加了耦合，这里可以通过与工厂模式结合解决该问题；
3、 程序复杂化。