Android 架構師之路15 設計模式之策略模式

Android 架構師之路 目錄

1、策略模式概念

1.1 介紹

在策略模式（Strategy Pattern）中，一個類的行為或其算法可以在運行時更改。這種類型的設計模式屬于行為型模式。
在策略模式中，我們創(chuàng)建表示各種策略的對象和一個行為隨著策略對象改變而改變的 context 對象。策略對象改變 context 對象的執(zhí)行算法。

1.2 定義

也叫作政策模式，定義一組算法，將每個算法都封裝起來，并且使他們之間可以互換!

1.3 使用場景
  • 如果在一個系統(tǒng)里面有許多類，它們之間的區(qū)別僅在于它們的行為，那么使用策略模式可以動態(tài)地讓一個對象在許多行為中選擇一種行為。
  • 一個系統(tǒng)需要動態(tài)地在幾種算法中選擇一種。
  • 如果一個對象有很多的行為，如果不用恰當?shù)哪Ｊ剑@些行為就只好使用多重的條件選擇語句來實現(xiàn)。

2、策略模式UML類圖

策略模式UML類圖

角色如下：

  • 策略接口（Strategy）：策略是一個接口，該接口定義若干個算法標識，即定義了若干個抽象方法。

  • 具體策略（ConcreteStrategy）：具體策略是實現(xiàn)策略接口的類。具體策略實現(xiàn)策略接口所定義的抽象方法，即給出算法標識的具體算法。

  • 上下文（Context）：上下文是依賴于策略接口的類，即上下文包含有策略聲明的變量。上下文中提供了一個方法，該方法委托策略變量調(diào)用具體策略所實現(xiàn)的策略接口中的方法。

3、策略模式實現(xiàn)

案例：不同公司理財產(chǎn)品政策
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("親您好，沒有你要的理財產(chǎn)品！");
        }
    }

}

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("您輸入的月份，沒有對應的理財產(chǎn)品！");
        }
    }

}


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("您輸入的月份，沒有對應的理財產(chǎn)品！");
        }
    }

}
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的系統(tǒng)源碼中,策略模式也是應用的相當廣泛的.最典型的就是屬性動畫中的應用.

我們知道,在屬性動畫中,有一個東西叫做插值器,它的作用就是根據(jù)時間流逝的百分比來來計算出當前屬性值改變的百分比.

我們使用屬性動畫的時候,可以通過set方法對插值器進行設置.可以看到內(nèi)部維持了一個時間插值器的引用，并設置了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插值器實現(xiàn)了Interpolator接口，并且是一個抽象類

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

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

平時我們使用的時候，通過設置不同的插值器，實現(xiàn)不同的動畫速率變換效果，比如線性變換，回彈，自由落體等等。這些都是插值器接口的具體實現(xiàn)，也就是具體的插值器策略。我們略微來看幾個策略。

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();
    }
}

內(nèi)部使用的時候直接調(diào)用getInterpolation方法就可以返回對應的值了，也就是屬性值改變的百分比。

屬性動畫中另外一個應用策略模式的地方就是估值器，它的作用是根據(jù)當前屬性改變的百分比來計算改變后的屬性值。該屬性和插值器是類似的，有幾個默認的實現(xiàn)。其中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.網(wǎng)絡框架中的緩存策略（內(nèi)存緩存和硬盤緩存）
2.文件、圖片命名策略
3.文件、網(wǎng)絡請求加密算法策略

以文件、圖片命名策略為例
 FileNameGenerator --->  類似于策略接口
 Md5FileNameGenerator、HashCodeFileNameGenerator--->  類似于策略實現(xiàn)類

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 優(yōu)點
  • 算法可以自由切換。
  • 避免使用多重條件判斷。
  • 擴展性良好。
5.2 缺點
  • 策略類會增多。
  • 所有策略類都需要對外暴露。
特別感謝：

Dream

最后編輯于 ：
?著作權歸作者所有,轉載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容