我的设计模式之路：策略模式

最新推荐文章于 2024-08-01 22:06:16 发布
最新推荐文章于 2024-08-01 22:06:16 发布
阅读量374 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ha_cjy/article/details/81207364
版权

设计模式是老生常谈了，在网络上千篇一律，看的越多越容易混淆，所以最好的办法是自己实现一下，用自己的话总结，这样子我们对它的理解才会深刻，才会将其灵活的运用到项目中。我们以一个场景来展开对策略模式的概念理解。

场景
公司有个老项目，里面涉及到一块关于直播推拉流线路切换的功能。以前的同事呢，估计是赶进度，把所有的cdn厂商的地址都写在一个类里面管理。
这里写图片描述
功能是完整实现了，但是对于其他没有接触该模块的同事初次接触来说，实在是有点乱，代码的可读性不好，如果再要加几个厂商的话，只能够在这个类里面去修改，也很繁琐。所以，我就想，能不能重构下，让代码读起来很清晰，后期去扩展的话也容易。
我们来分析下这个场景：
（1）有很多厂商可以让我们选择，那么最好是一个厂商就是一个类，它自己干自己的事，不跟其他的厂商搅和在一起，这样子看起来一目了然，代码读起来也清晰；
（2）既然是推拉流切换的问题，不管有多少个厂商，它们要实现的功能都是相同的。换句话说，就是都需要提供拉流，推流地址等功能；
（3）程序调用的话，总不能每次自己去判断厂商，然后调用对应厂商提供的功能，这样子的话，只要我们增加一个厂商，代码调用处就需要再次进行修改，违反了开闭原则，最好是提供一个管理给外部调用，外部不用管到底要使用什么策略，只要提供功能给它就好了。

我们来总结下：一个厂商就是一个策略，要实现的功能就是这个策略的抽象，提供一个管理给外部调用就是给外部一个引用，可以去执行策略。所以策略模式就是定义了一系列相同功能的策略集合。它有3个要素：策略要实现的功能（定义成接口）、具体的策略（实现接口）、管理策略的（给外部调用的引用类）。当然，这是我自己的理解，仅供大家参考。

运用
分析完了，我们动手实践下吧。首先，我们来看下结构：
这里写图片描述
1-策略模式接口：定义一系列方法；
2、3-具体的策略
4、给外部调用的策略管理类

1、策略接口

/**
 * cdn策略接口
 * Created by cjy on 2018/7/25.
 */

public interface ICDNStrategry {
    /**
     * 加载数据
     */
    void load();

    /**
     * 获取拉流host地址
     * @return
     */
    String getPullHost();

    /**
     * 获取推流host地址
     * @return
     */
    String getPushHost();

    /**
     * 获取拉流url地址
     * @return
     */
    String getPullUrl(CDNPushInfo info);

    /**
     * 获取推流url地址
     * @return
     */
    String getPushUrl(CDNPushInfo info);

    /**
     * ping推流地址
     * @param info
     */
    void pushPing(CDNPushInfo info);

    /**
     * 获取策略的类型
     * @return
     */
    int getType();

2、具体策略的实现

package com.kaopu.xylive.tools.cdn;

import com.cyjh.util.StringUtil;
import com.kaopu.xylive.bean.cdn.CDNNewAddressInfo;
import com.kaopu.xylive.bean.cdn.CDNNewInfo;
import com.kaopu.xylive.bean.cdn.CDNPushInfo;
import com.kaopu.xylive.menum.ECDNType;
import com.kaopu.xylive.tools.http.HttpUtil;
import com.kaopu.xylive.tools.preset.PresetManager;
import com.kaopu.xylive.tools.utils.CLog;
import com.kaopu.xylive.tools.utils.Util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import rx.Subscriber;

/**
 * 网宿CDN策略
 * Created by cjy on 2018/7/25.
 */

public class WSStrategry implements ICDNStrategry{
    private final String TAG = WSStrategry.class.getSimpleName();

    /**
     * 网宿拉流ip地址集合
     */
    private List<String> mWSPullIpList;
    /**
     * 当前网宿拉流ip下标
     */
    private int mCurrWSPullIpIndex;
    /**
     * 网宿推流ip地址集合
     */
    private List<String> mWSPushIpList;
    /**
     * 当前网宿推流ip下标
     */
    private int mCurrWSPushIpIndex;

    public static WSStrategry create(){
        return new WSStrategry();
    }

    @Override
    public void load() {
        List<CDNNewInfo> infos = PresetManager.getInstance().getNewCDNAddressInfo();
        CDNNewInfo info = CDNUtil.getMainNewCDNAddressInfo(infos);
        if (info == null) {
            return;
        }
        loadPull(info.RtmpPullFlowAddress);
        loadPush(info.PushFlowAddress);
    }

    /**
     * 请求拉流ip
     * @param infos
     */
    public void loadPull(List<CDNNewAddressInfo> infos ){
        if (!Util.isCollectionEmpty(infos)) {
            for (CDNNewAddressInfo info :
                    infos) {
                HttpUtil.loadWSPull(new WSPullSubscriber(), "rtmp://" + info.Address.toString().trim() + "/", 1, 1, PresetManager.getInstance().getIP());
            }
        }
    }

    /**
     * 请求推流ip
     * @param info
     */
    public void loadPush(CDNNewAddressInfo info ){
        try {
            if (info == null || StringUtil.isEmpty(info.Address)) {
                return;
            }
            HttpUtil.loadWSPull(new WSPushSubscriber(), "rtmp://" + info.Address.toString().trim() + "/", 5, 1, PresetManager.getInstance().getIP());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取拉流的host地址
     * @return
     */
    @Override
    public String getPullHost() {
        if (Util.isCollectionEmpty(mWSPullIpList)) {
            return "";
        }
        mCurrWSPullIpIndex = mCurrWSPullIpIndex % mWSPullIpList.size();
        return mWSPullIpList.get(mCurrWSPullIpIndex);
    }

    /**
     * 获取推流的host地址
     * @return
     */
    @Override
    public String getPushHost() {
        if (Util.isCollectionEmpty(mWSPushIpList)) {
            return "";
        }
        mCurrWSPushIpIndex = mCurrWSPushIpIndex % mWSPushIpList.size();
        return mWSPushIpList.get(mCurrWSPushIpIndex);
    }

    /**
     * 获取拉流地址
     * @param info
     * @return
     */
    @Override
    public String getPullUrl(CDNPushInfo info) {
        String url = "";
        String newHost = getPullHost();
        url = getWSNewUrl(info.Address, newHost);
        return url;
    }

    /**
     * 获取推流地址
     * @param info
     * @return
     */
    @Override
    public String getPushUrl(CDNPushInfo info) {
        String url = info.Address;
        String newHost = getPushHost();
        url = getWSNewUrl(info.Address, newHost);
        return url;
    }

    /**
     * ping推流地址
     * @param info
     */
    @Override
    public void pushPing(CDNPushInfo info) {
        if (!Util.isCollectionEmpty(mWSPullIpList)) {
            CDNUtil.minConnHostTask(mWSPushIpList).subscribe(new Subscriber<Integer>() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                }

                @Override
                public void onNext(Integer o) {
                    mCurrWSPushIpIndex = o;
                }
            });
        }
    }

    @Override
    public int getType() {
        return ECDNType.E_WS.getIntValue();
    }

    /**
     * 获取拉流ip的回调
     */
    private class WSPullSubscriber extends Subscriber {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
        }

        @Override
        public void onNext(Object o) {
            try {
                mWSPullIpList = getNodeWSList((String) o);
                CLog.e(TAG, "网宿ip=" + o.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取推流ip的回调
     */
    private class WSPushSubscriber extends Subscriber {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
        }

        @Override
        public void onNext(Object o) {
            try {
                mWSPushIpList = getNodeWSList((String) o);
                CLog.e(TAG, "网宿推流ip=" + o.toString());
                CDNUtil.minConnHostTask(mWSPushIpList).subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        e.printStackTrace();
                    }

                    @Override
                    public void onNext(Integer o) {
                        mCurrWSPushIpIndex = o;
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获得网宿组装节点列表
     */
    private List<String> getNodeWSList(String str) {
        List<String> pullList = new ArrayList<>();
        String hosts = str;
        String[] hsotArr = hosts.split("\n");
        pullList = Arrays.asList(hsotArr);
        return pullList;
    }

    /**
     * 网宿地址加上ip
     */

    public String getWSNewUrl(String oldurl, String newHost) {
        if (!StringUtil.isEmpty(newHost)) {
            try {
                String ourl1 = oldurl.substring("rtmp://".length(), oldurl.length());
                String[] ourl2 = ourl1.split("/");
                String[] url3 =  ourl2[2].split("\\?");
                StringBuilder sb = new StringBuilder();
                sb.append("rtmp://");
                sb.append(newHost);
                sb.append("/");
                sb.append(ourl2[1]);
                sb.append("/");
                sb.append(url3[0]);
                sb.append("?wsHost=");
                sb.append(ourl2[0]);
                if(url3.length>=2){
                    sb.append("&");
                    sb.append(url3[1]);
                }
//                sb.append("&wsiphost=");
//                sb.append(PresetManager.getInstance().getIP());
                String newUrl = sb.toString();
                CLog.e(TAG, "newUrl=" + newUrl);
                return newUrl;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return oldurl;
    }

}

3、策略管理（给外部的引用类）

package com.kaopu.xylive.tools.cdn;

import com.kaopu.xylive.bean.cdn.CDNPushInfo;

import java.util.ArrayList;
import java.util.List;

/**
 * CDN策略管理
 * Created by cjy on 2018/7/25.
 */

public class CDNStrategryManager implements ICDNStrategry {
    /**
     * 单例对象
     */
    private static volatile CDNStrategryManager mInstance = null;

    /**
     * 策略列表，主要是为了支持多策略
     */
    private List<ICDNStrategry> mCdnStrategryList = new ArrayList<>();
    /**
     * 当前地址
     */
    private String mCurrPath;

    private CDNStrategryManager() {
    }

    public static CDNStrategryManager getInstance(){
        if (mInstance == null){
            synchronized (CDNStrategryManager.class){
                if (mInstance == null)
                    mInstance = new CDNStrategryManager();
            }
        }
        return mInstance;
    }

    /**
     * 添加策略
     * @param strategry
     */
    public void addStrategry(ICDNStrategry strategry){
        boolean isAdded = false;
        //遍历策略，如果已经添加过了，就不再添加了
        for (ICDNStrategry temp : mCdnStrategryList){
            if (temp.getClass().getSimpleName().equals(strategry.getClass().getSimpleName())){
                isAdded = true;
                break;
            }
        }
        if (!isAdded) {
            mCdnStrategryList.add(strategry);
        }
    }

    /**
     * 移除所有策略
     */
    public void removeAll(){
        mCdnStrategryList.clear();
    }

    /**
     * 获取拉流地址
     * @param info
     * @return
     */
    @Override
    public String getPullUrl(CDNPushInfo info) {
        int index = findStrategry(info);
        String url = info.Address;
        String newHost = mCdnStrategryList.get(index).getPullHost();
        if (index != -1) {
            url = mCdnStrategryList.get(index).getPullUrl(info);
        } else {
            url = CDNUtil.getNewUrl(info.Address, newHost);
        }
        mCurrPath = url;
        return url;
    }

    /**
     * 获取推流地址
     * @param info
     * @return
     */
    @Override
    public String getPushUrl(CDNPushInfo info) {
        int index = findStrategry(info);
        String url = info.Address;
        String newHost = mCdnStrategryList.get(index).getPushHost();
        if (index != -1) {
            url = mCdnStrategryList.get(index).getPushUrl(info);
        } else {
            url = CDNUtil.getNewUrl(info.Address, newHost);
        }
        mCurrPath = url;
        return url;
    }

    /**
     * ping 推流地址
     * @param info
     */
    @Override
    public void pushPing(CDNPushInfo info) {
        int index = findStrategry(info);
        if (index != -1) {
            mCdnStrategryList.get(index).pushPing(info);
        }
    }

    /**
     * 查找对应的策略
     * @param info
     * @return
     */
    private int findStrategry(CDNPushInfo info){
        int index = -1;
        int size = mCdnStrategryList.size();
        //遍历策略，查找对应的策略
        for (int i = 0 ; i < size && size > 0; i++){
            ICDNStrategry strategry = mCdnStrategryList.get(i);
            if (strategry.getType() == info.ManufacturerType){
                index = i;
                break;
            }
        }
        return index;
    }

    /**
     * 获取当前地址
     * @return
     */
    public String getCurrPath(){
        return mCurrPath;
    }

    /**
     * 加载数据，初始化推流、拉流地址
     */
    @Override
    public void load() {
        int size = mCdnStrategryList.size();
        for (int i = 0 ; i < size && size > 0; i++){
            ICDNStrategry strategry = mCdnStrategryList.get(i);
            strategry.load();
        }
    }

    @Override
    public String getPullHost() {
        return null;
    }

    @Override
    public String getPushHost() {
        return null;
    }

    @Override
    public int getType() {
        return 0;
    }
}

一般程序使用策略的话，可以在具体使用的地方调用，也可以在应用初始化中就定义策略，统一管理。
我使用的就是第2种方法：在Application的onCreate中初始化下策略：

 CDNStrategryManager.getInstance().addStrategry(WSStrategry.create());
 CDNStrategryManager.getInstance().addStrategry(BYSStrategry.create());

总结
相信大家看完之后，就会明白策略模式一点也不复杂，只要掌握好三要素，就能在项目中灵活使用了。如果还有什么问题的话，欢迎大家在评论下留言。

hacjy
关注
专栏目录
设计模式学习之策略模式
一个码农的博客
04-11 7万+
写代码时总会出很多的if…else，或者case。如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿，维护的成本也会加大，而策略模式就能较好的解决这个问题，本篇博客就带你详细了解策略模式。策略模式的定义和使用场景定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替
策略模式
weixin_52450674的博客
04-10 469
策略模式 原文链接：策略模式（策略设计模式）详解 文章目录策略模式前言一、策略模式的结构与实现二、实列（烤冷面价格计算策略）1.创建一个抽象策略类2.具体策略3、 环境（Context）类总结 前言 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。 策略模式的主要优点如下。 多重条件语句不易维
策略模式及用例
最新发布
weixin_46140858的博客
08-01 951
策略模式用于算法的自由切换和扩展，对应于解决某一问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便地更换算法和增加新的算法。策略模式实现了算法定义和算法使用的分离，它通过继承和多态的机制实现对算法族的使用和管理，是一个简单，实用的设计模式。策略模式的定义如下：策略模式又称为政策(Policy)模式，它是一种对象行为型模式。
策略模式.
木仕的博客
07-23 145
定义 完成一个流程有多种策略，择优； 定义一系列规则，并将每个规则封装起来，使它们可以相互替换，并且规则的变化不会影响执行规则的对象，通过对规则的封装把规则的条件和规则的结果分割开。 架构 抽象策略：各种不同的规则以不同的方式实现这个接口，环境角色使用这个接口调用不同的规则； 具体策略：实现了抽象策略定义的接口，提供具体的规则实现； 环境类：持有一个策略类的引用，最终给客户端调用。 应用场景 1、一个系统需要动态地在几种规则中选择一种时，可将每个规则封装到策略类中； 2、 一个类定义了多种行为，并且这些行为
C++设计模式之策略模式
12-26
这就要说到今天我这里总结的策略设计模式了。 策略模式 在GOF的《设计模式:可复用面向对象软件的基础》一书中对策略模式是这样说的：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。该模式使得算法...
设计模式之策略和模板方法模式
03-01
TemplateMethod：(1)、意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。(2)、适用性：A、一次性实现一个算法的不变...
轻松掌握python设计模式之策略模式
09-21
### 知识点详解：Python设计模式之策略模式 #### 一、策略模式概述 **策略模式**（Strategy Pattern）是一种行为设计模式，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其算法可以在运行时更改...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值