Android 架构师之路15 设计模式之策略模式

Android 架构师之路 目录

1、策略模式概念

1.1 介绍

在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

1.2 定义

也叫作政策模式,定义一组算法,将每个算法都封装起来,并且使他们之间可以互换!

1.3 使用场景
  • 如果在一个系统里面有许多类,它们之间的区别仅在于它们的行为,那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
  • 一个系统需要动态地在几种算法中选择一种。
  • 如果一个对象有很多的行为,如果不用恰当的模式,这些行为就只好使用多重的条件选择语句来实现。

2、策略模式UML类图

策略模式UML类图

角色如下:

  • 策略接口(Strategy):策略是一个接口,该接口定义若干个算法标识,即定义了若干个抽象方法。

  • 具体策略(ConcreteStrategy):具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法,即给出算法标识的具体算法。

  • 上下文(Context):上下文是依赖于策略接口的类,即上下文包含有策略声明的变量。上下文中提供了一个方法,该方法委托策略变量调用具体策略所实现的策略接口中的方法。

3、策略模式实现

案例:不同公司理财产品政策

Strategy:
public interface IManageFinancy {
    /**
     * 理财算法
     * @param month
     * @param money
     * @return
     */
    public float manageFinancy(int month, float money);
}

ConcreteStrategy:
public class PingAnManageFinanacy implements IManageFinancy {

    @Override
    public float manageFinancy(int month, float money) {
        if (month == 6) {
            return money + money * 0.08f / 12 * 6;
        } else if (month == 12) {
            return money + money * 0.09f / 12 * 12;
        } else {
            throw new IllegalArgumentException("亲您好,没有你要的理财产品!");
        }
    }

}
public class YouLiWangManageFinancy implements IManageFinancy {

    @Override
    public float manageFinancy(int month, float money) {
        if (month == 3) {
            return money + money * 0.07f / 12 * 3;
        } else if (month == 6) {
            return money + money * 0.08f / 12 * 6;
        } else if (month == 12) {
            return money + money * 0.095f / 12 * 12;
        } else if (month == 24) {
            return money + money * 0.105f / 12 * 24;
        } else {
            throw new IllegalArgumentException("您输入的月份,没有对应的理财产品!");
        }
    }

}

public class ZhiFuBaoManageFinancy implements IManageFinancy {

    @Override
    public float manageFinancy(int month, float money) {
        if (month == 6) {
            return money + money * 0.03f / 12 * 6;
        } else if (month == 12) {
            return money + money * 0.04f / 12 * 12;
        } else if (month == 24) {
            return money + money * 0.045f / 12 * 24;
        } else {
            throw new IllegalArgumentException("您输入的月份,没有对应的理财产品!");
        }
    }

}

Context:
public class ManangeFinancyContext {
    
    private IManageFinancy manageFinancy;
    
    public ManangeFinancyContext(IManageFinancy manageFinancy) {
        this.manageFinancy = manageFinancy;
    }
    
    public float manageFinancy(int month,float money){
        return this.manageFinancy.manageFinancy(month, money);
    }
    
}

Client:
public class Client {
    public static void main(String[] args) {
        IManageFinancy manageFinancy = new ZhiFuBaoManageFinancy();
        ManangeFinancyContext financyContext = new ManangeFinancyContext(
                manageFinancy);
        float money = financyContext.manageFinancy(12, 10000);
        System.out.println("理财之后的金额:" + money);
    }
}

结果输出:

理财之后的金额:10400.0

4、策略模式Android场景分析

而在Android的系统源码中,策略模式也是应用的相当广泛的.最典型的就是属性动画中的应用.

我们知道,在属性动画中,有一个东西叫做插值器,它的作用就是根据时间流逝的百分比来来计算出当前属性值改变的百分比.

我们使用属性动画的时候,可以通过set方法对插值器进行设置.可以看到内部维持了一个时间插值器的引用,并设置了getter和setter方法,默认情况下是先加速后减速的插值器,set方法如果传入的是null,则是线性插值器。而时间插值器TimeInterpolator是个接口,有一个接口继承了该接口,就是Interpolator这个接口,其作用是为了保持兼容

private static final TimeInterpolator sDefaultInterpolator =
        new AccelerateDecelerateInterpolator();  
private TimeInterpolator mInterpolator = sDefaultInterpolator; 
@Override
public void setInterpolator(TimeInterpolator value) {
    if (value != null) {
        mInterpolator = value;
    } else {
        mInterpolator = new LinearInterpolator();
    }
}

@Override
public TimeInterpolator getInterpolator() {
    return mInterpolator;
}
public interface Interpolator extends TimeInterpolator {
    // A new interface, TimeInterpolator, was introduced for the new android.animation
    // package. This older Interpolator interface extends TimeInterpolator so that users of
    // the new Animator-based animations can use either the old Interpolator implementations or
    // new classes that implement TimeInterpolator directly.
}

此外还有一个BaseInterpolator插值器实现了Interpolator接口,并且是一个抽象类

abstract public class BaseInterpolator implements Interpolator {
    private int mChangingConfiguration;
    /**
     * @hide
     */
    public int getChangingConfiguration() {
        return mChangingConfiguration;
    }

    /**
     * @hide
     */
    void setChangingConfiguration(int changingConfiguration) {
        mChangingConfiguration = changingConfiguration;
    }
}

平时我们使用的时候,通过设置不同的插值器,实现不同的动画速率变换效果,比如线性变换,回弹,自由落体等等。这些都是插值器接口的具体实现,也就是具体的插值器策略。我们略微来看几个策略。

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();
    }
}
public class AccelerateDecelerateInterpolator extends BaseInterpolator
        implements NativeInterpolatorFactory {
    public AccelerateDecelerateInterpolator() {
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
    }

    public float getInterpolation(float input) {
        return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
    }

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

内部使用的时候直接调用getInterpolation方法就可以返回对应的值了,也就是属性值改变的百分比。

属性动画中另外一个应用策略模式的地方就是估值器,它的作用是根据当前属性改变的百分比来计算改变后的属性值。该属性和插值器是类似的,有几个默认的实现。其中TypeEvaluator是一个接口。

public interface TypeEvaluator<T> {

    public T evaluate(float fraction, T startValue, T endValue);

}
public class IntEvaluator implements TypeEvaluator<Integer> {

    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        int startInt = startValue;
        return (int)(startInt + fraction * (endValue - startInt));
    }
}
public class FloatEvaluator implements TypeEvaluator<Number> {

    public Float evaluate(float fraction, Number startValue, Number endValue) {
        float startFloat = startValue.floatValue();
        return startFloat + fraction * (endValue.floatValue() - startFloat);
    }
}
public class PointFEvaluator implements TypeEvaluator<PointF> {

    private PointF mPoint;


    public PointFEvaluator() {
    }

    public PointFEvaluator(PointF reuse) {
        mPoint = reuse;
    }

    @Override
    public PointF evaluate(float fraction, PointF startValue, PointF endValue) {
        float x = startValue.x + (fraction * (endValue.x - startValue.x));
        float y = startValue.y + (fraction * (endValue.y - startValue.y));

        if (mPoint != null) {
            mPoint.set(x, y);
            return mPoint;
        } else {
            return new PointF(x, y);
        }
    }
}
public class ArgbEvaluator implements TypeEvaluator {
    private static final ArgbEvaluator sInstance = new ArgbEvaluator();

    public static ArgbEvaluator getInstance() {
        return sInstance;
    }

    public Object evaluate(float fraction, Object startValue, Object endValue) {
        int startInt = (Integer) startValue;
        int startA = (startInt >> 24) & 0xff;
        int startR = (startInt >> 16) & 0xff;
        int startG = (startInt >> 8) & 0xff;
        int startB = startInt & 0xff;

        int endInt = (Integer) endValue;
        int endA = (endInt >> 24) & 0xff;
        int endR = (endInt >> 16) & 0xff;
        int endG = (endInt >> 8) & 0xff;
        int endB = endInt & 0xff;

        return (int)((startA + (int)(fraction * (endA - startA))) << 24) |
                (int)((startR + (int)(fraction * (endR - startR))) << 16) |
                (int)((startG + (int)(fraction * (endG - startG))) << 8) |
                (int)((startB + (int)(fraction * (endB - startB))));
    }
}
其它案例

1.网络框架中的缓存策略(内存缓存和硬盘缓存)
2.文件、图片命名策略
3.文件、网络请求加密算法策略

以文件、图片命名策略为例
 FileNameGenerator --->  类似于策略接口
 Md5FileNameGenerator、HashCodeFileNameGenerator--->  类似于策略实现类
public interface FileNameGenerator {

    /** Generates unique file name for image defined by URI */
    String generate(String imageUri);
}
public class HashCodeFileNameGenerator implements FileNameGenerator {
    @Override
    public String generate(String imageUri) {
        return String.valueOf(imageUri.hashCode());
    }
}

public class Md5FileNameGenerator implements FileNameGenerator {

    private static final String HASH_ALGORITHM = "MD5";
    private static final int RADIX = 10 + 26; // 10 digits + 26 letters

    @Override
    public String generate(String imageUri) {
        byte[] md5 = getMD5(imageUri.getBytes());
        BigInteger bi = new BigInteger(md5).abs();
        return bi.toString(RADIX);
    }

    private byte[] getMD5(byte[] data) {
        byte[] hash = null;
        try {
            MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM);
            digest.update(data);
            hash = digest.digest();
        } catch (NoSuchAlgorithmException e) {
        }
        return hash;
    }
}

5、模式总结

5.1 优点
  • 算法可以自由切换。
  • 避免使用多重条件判断。
  • 扩展性良好。
5.2 缺点
  • 策略类会增多。
  • 所有策略类都需要对外暴露。
特别感谢:

Dream

推荐阅读更多精彩内容