两个例子学会策略模式

我不是女神ヾ 2024-04-19 09:57 4阅读 0赞

## 策略模式 ##

> 意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。  
> 主要解决：在有多种算法相似的情况下，使用 `if...else` 所带来的复杂和难以维护。  
> 何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。  
> 如何解决：将这些算法封装成一个一个的类，任意地替换。  
> 关键代码：实现同一个接口。  
> 应用实例：  
> 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。  
> 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。  
> 3、`JAVA AWT` 中的 `LayoutManager`。  
> 优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。  
> 缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。  
> 使用场景：  
> 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。  
> 2、一个系统需要动态地在几种算法中选择一种。  
> 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。  
> 注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

ps:以下代码来源与网络，忘记出处了，侵立删。

### 图片加载库 ###

1.  定义接口

public interface IimageListener {
        void display(Context context, ImageView imageView, String url, int progressId, int errorId,
                     Object tag);
    
        void display(Context context, ImageView imageView, String url, int progressId, int errorId);
    
        void display(Context context, ImageView imageView, String url, int progressId);
    
        void display(Context context, ImageView imageView, String url);
    
        void display(Context context, ImageView imageView, Uri uri);
    }

1.  实现接口

public class GlideRequest implements IimageListener {
    
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId, int
                errorId, Object tag) {
            DrawableTypeRequest<String> load = Glide.with(context).load(url);
            if (progressId != -1) {
                load.placeholder(progressId).centerCrop();
            } else {
                load.placeholder(new ColorDrawable(Color.GRAY));
            }
            if (errorId != -1) {
                load.error(errorId);
            }else{
                load.error(R.drawable.ic_error);
            }
    
            load.into(imageView);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId, int
                errorId) {
            display(context, imageView, url, progressId, errorId, null);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId) {
            display(context, imageView, url, progressId, -1, null);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url) {
            display(context, imageView, url, -1, -1, null);
        }
    
        @Override
        public void display(Context context, ImageView imageView, Uri uri) {
            DrawableTypeRequest<Uri> load = Glide.with(context).load(uri);
            load.into(imageView);
        }
    }
    
    
    public class PicassoRequest implements IimageListener {
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId, int
                errorId, Object tag) {
            Picasso.with(context).load(url).placeholder(progressId).error(errorId).tag(tag).into(imageView);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId, int
                errorId) {
            Picasso.with(context).load(url).placeholder(progressId).error(errorId).into(imageView);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url, int progressId) {
           Picasso.with(context).load(url).placeholder(progressId).into(imageView);
        }
    
        @Override
        public void display(Context context, ImageView imageView, String url) {
            Picasso.with(context).load(url).into(imageView);
        }
    
        @Override
        public void display(Context context, ImageView imageView, Uri uri) {
               Picasso.with(context).load(uri).into(imageView);
        }
    }

1.  实现类

public class ImageRequestManager {
    
        public static final String type_Glide="Glide";
        public static final String type_Picasso="Picasso";
        public static final String type_default =type_Glide;
    
       private ImageRequestManager(){
    
       }
    
        public static IimageListener getRequest(){
          return getRequest(type_default);
    
        }
    
        public static IimageListener getRequest(String type){
            switch (type){
                case type_Glide:
                    return new GlideRequest();
    
                case type_Picasso:
                    return new PicassoRequest();
    
                default:
                    return new GlideRequest();
            }
    
        }
    }

1.  使用

ImageRequestManager.getRequest(ImageRequestManager.type_default).display(mContext, imageView, imageUrl);

### 网络库封装 ###

1.  定义配置项

public class NetworkOption {
    
        /**
         * 网络请求的 TAG
         */
        public String mBaseUrl;
        public String mTag;
        public Map<String,String> mHeaders;
    
        public NetworkOption(String tag) {
            this.mTag = tag;
        }
    
        public static final  class Builder{
            public String tag;
            public Map<String,String> mHeaders;
            public String mBaseUrl;
    
            public Builder setTag(String tag){
                this.tag=tag;
                return this;
            }
    
            public Builder setHeaders(Map<String,String> headers){
                mHeaders=headers;
                return this;
    
            }
    
            public Builder setBaseUrl(String baseUrl) {
                mBaseUrl = baseUrl;
                return this;
            }
    
            public NetworkOption build(){
                NetworkOption networkOption = new NetworkOption(tag);
                networkOption.mHeaders=mHeaders;
                networkOption.mBaseUrl=mBaseUrl;
                return networkOption;
            }
        }
    }

1.  定义接口

public interface NetRequest {
    
        void init(Context context);
    
         void doGet(String url, final Map<String, String> paramsMap, final IResponseListener iResponseListener);
    
         void doGet(String url, final Map<String, String> paramsMap, NetworkOption networkOption, final IResponseListener iResponseListener);
    
    
         void doPost(String url, final Map<String, String> paramsMap, final IResponseListener iResponseListener);
    
         void doPost(String url, final Map<String, String> paramsMap, NetworkOption networkOption,
                     final IResponseListener iResponseListener);
        
    
         void cancel(Object tag);
    
    }

1.  定义具体的网络请求

public class OKHttpRequest implements NetRequest {
    
        static int cacheSize = 10 * 1024 * 1024; // 10 MiB
    
        private static  OkHttpClient client ;
        private Context mContext;
    
        public static Handler mHandler=new Handler();
    
        public static Handler getHandler(){
            if(mHandler==null){
                mHandler=new Handler();
            }
            return mHandler;
        }
    
        @Override
        public void init(Context context) {
            mContext = context.getApplicationContext();
            client=getCilent();
        }
    
        private volatile static OKHttpRequest instance = null;
    
        private OKHttpRequest(){
        }
    
        public static OKHttpRequest getInstance() {
            if (instance == null) {
                synchronized (OKHttpRequest.class) {
                    if (instance == null) {
                        instance = new OKHttpRequest();
                    }
                }
            }
    
    
            return instance;
        }
    
        private OkHttpClient getCilent() {
            if(client==null){
                OkHttpClient.Builder mBuilder= new OkHttpClient.Builder().
                        connectTimeout(10, TimeUnit.SECONDS).writeTimeout(10, TimeUnit.SECONDS)
                        .readTimeout(30, TimeUnit.SECONDS)
                        .addInterceptor(new LoggingInterceptor())
                        .cache(new Cache(mContext.getExternalFilesDir("okhttp"),cacheSize));
                client=mBuilder.build();
            }
            return client;
    
        }
    
        @Override
        public void doGet(String url, Map<String, String> paramsMap, final IResponseListener iResponseListener) {
            doGet(url,paramsMap,null,iResponseListener);
        }
    
        @Override
        public void doGet(String url, Map<String, String> paramsMap, NetworkOption networkOption,
                       final   IResponseListener iResponseListener) {
            url= NetUtils.checkUrl(url);
            url=NetUtils.appendUrl(url,paramsMap);
            final NetworkOption option=NetUtils.checkNetworkOption(networkOption,url);
            Request.Builder builder = new Request.Builder().url(url).tag(option.mTag);
            builder=configHeaders(builder,option);
    
            Request build = builder.build();
    
            getCilent().newCall(build).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    handleError(e, iResponseListener);
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    handleResult(response, iResponseListener);
                }
            });
        }
    
     
    
        private Request.Builder configHeaders(Request.Builder builder, NetworkOption option) {
            Map<String, String> headers = option.mHeaders;
            if(headers==null || headers.size()==0){
                return builder;
            }
            Set<Map.Entry<String, String>> entries = headers.entrySet();
            for(Map.Entry<String, String> entry: entries){
                String key = entry.getKey();
                String value = entry.getValue();
                // 添加请求头
                builder.addHeader(key,value);
            }
            return builder;
    
        }
    
        @Override
        public void doPost(String url, Map<String, String> paramsMap, final IResponseListener iResponseListener) {
            doPost(url,paramsMap,null,iResponseListener);
    
        }
    
        private FormBody.Builder configPushParam(FormBody.Builder builder, Map<String, String> paramsMap) {
            if(paramsMap!=null){
                Set<Map.Entry<String, String>> entries = paramsMap.entrySet();
                for(Map.Entry<String,String> entry:entries ){
                    String key = entry.getKey();
                    String value = entry.getValue();
                    builder.add(key,value);
                }
            }
            return builder;
        }
    
        @Override
        public void doPost(String url, Map<String, String> paramsMap, NetworkOption networkOption,
                           final IResponseListener iResponseListener) {
            url= NetUtils.checkUrl(url);
            final NetworkOption option=NetUtils.checkNetworkOption(networkOption,url);
            // 以表单的形式提交
            FormBody.Builder builder = new FormBody.Builder();
            builder=configPushParam(builder,paramsMap);
            FormBody formBody = builder.build();
    
            Request.Builder requestBuilder = new Request.Builder().url(url).post(formBody).tag(option.mTag);
            requestBuilder=configHeaders(requestBuilder,option);
            Request request = requestBuilder.build();
            getCilent().newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    handleError(e,iResponseListener);
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                   handleResult(response,iResponseListener);
                }
            });
        }
    
        @Override
        public void cancel(Object tag) {
            if(client!=null){
                if(client != null) {
                // 在等待队列中查找是否有相应的请求
                    for(Call call : client.dispatcher().queuedCalls()) {
                        if(call.request().tag().equals(tag))
                            call.cancel();
                    }
                // 在正在请求的请求队列中查找是否有相应的请求
                    for(Call call : client.dispatcher().runningCalls()) {
                        if(call.request().tag().equals(tag))
                            call.cancel();
                    }
                }
            }
        }
    
    
    }

1.  管理类

public class NetManger {
    
        private static NetRequest instance;
        private static Context mContext;
    
        public static NetRequest getRequest(){
            return instance;
        }
    
        static HashMap<String,NetRequest> mMap=new HashMap<>();
    
        public static void  init(Context context){
            instance = OKHttpRequest.getInstance();
            mContext = context.getApplicationContext();
            instance.init(NetManger.mContext);
        }
    
    
    // 采用反射的形式实现，这样有一个好处是，以后增加新的实现类的话，我们只需要传递相应 的 Class，
    //而不需要更改 NetManger 的代码
        public static <T extends NetRequest> NetRequest getRequest(Class<T> clz){
            String simpleName = clz.getSimpleName();
            NetRequest request = mMap.get(simpleName);
            if(request ==null){
                try {
                    Constructor<T> constructor = clz.getDeclaredConstructor();
                    constructor.setAccessible(true);
                    request = constructor.newInstance();
                    request.init(mContext);
                    mMap.put(simpleName,request);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
            instance=request;
            return request;
    
        }
    
    }

1.  使用

在 application 中 初始化
    NetManger.init(application);
    
    
    发起具体请求
    NetManger.getRequest(OKHttpRequest.classs).doGet(url, mMap, new IResponseListener() {
        @Override
        public void onResponse(String response) {
            LogUtil.i(TAG,"onResponse:  response ="+response);
        }
    
        @Override
        public void onFail(HttpException httpException) {
            Log.i(TAG, "onFail: httpException=" +httpException.toString());
        }
    });