Android设计模式——单一职责原则

单一职责原则

单一职责：Single Responsibility Principle SRP

• 定义：就一个类而言，应该仅有一个引起它变化的原因。一个类中应该是一组相关性很高的函数、数据的封装
• 解释：就是说一个类的功能应该封装的功能是单一的，一个类仅仅处理一个问题，或者是仅仅做一组相近的工作。高内聚低耦合

示例程序

需求：编写Android图片加载器，根据url下载图片并缓存加载到imageview中，要求体现单一设计模式

• 需求分析：对于图片加载类 应当将图片的下载和图片的缓存与图片的显示加载分开，对于一种功能单独进行封装

ImageCache 图片缓存封装

package com.probuing.designpatterns.srpdemo.imageloader;

import android.annotation.TargetApi;
import android.graphics.Bitmap;
import android.os.Build;
import android.util.LruCache;

/**
 * 用于处理图片缓存的类
 * Created by Administrator on 2016/12/5.
 */
public class ImageCache {
    // TODO: 2016/12/5 LRU图片集合
    LruCache<String, Bitmap> mImageCache;

    public ImageCache() {
        initImageCache();
    }

    /**
     * 初始化图片缓存类
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
    private void initImageCache() {
        //计算可以使用的最大内存
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取最大可用内存的1/4为缓存
        int cacheSize = maxMemory / 4;
        //实例化图片缓存集合
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public void put(String url, Bitmap bitmap) {
        mImageCache.put(url, bitmap);
    }

    public Bitmap get(String url) {
        return mImageCache.get(url);
    }
}

• ImageLoader 图片加载类封装，其中 分别封装图片下载与图片加载的功能

package com.probuing.designpatterns.srpdemo.imageloader;


import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;

import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 单一职责 设计模式
 */
public class ImageLoader {
    ImageCache mImageCache = new ImageCache();
    //线程池 可用cpu数量
    ExecutorService executors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    /**
     * 图片加载
     *
     * @param url       加载图片的地址
     * @param imageView view
     */
    public void displayImage(final String url, final ImageView imageView) {
        // TODO: 从缓存中加载图片
        Bitmap bitmap = mImageCache.get(url);
        //缓存中存在的情况
        if (bitmap != null) {
            //设置给view
            imageView.setImageBitmap(bitmap);
            return;
        }
        imageView.setTag(url);
        // TODO: 执行线程池的异步任务下载图片
        executors.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                // TODO: 下载失败
                if (bitmap == null) {
                    return;
                }
                // TODO: bitmap不为空的情况，取出控件 imageview 判断是否是对应的url的图片
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                // TODO: 放入缓存中
                mImageCache.put(url, bitmap);
            }
        });

    }

    /**
     * 图片下载方法
     *
     * @param imageUrl 图片地址
     * @return 下载好的图片
     */
    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        // TODO: url 构造
        try {
            URL url = new URL(imageUrl);
            // TODO: 开启连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            // TODO: 获取下载码
            if (conn.getResponseCode() == 200) {
                // TODO: 获取输入流
                bitmap = BitmapFactory.decodeStream(conn.getInputStream());

            }
            // TODO: 连接关闭
            conn.disconnect();
        } catch (java.io.IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

总结

• 单一职责设计模式很好的对类功能的低耦合进行了处理，采用单一设计模式的实现，对于代码的扩展与维护都是比较遍历的
• 单一职责的基本思路就是，将一类功能只定义在一个类或者方法中，避免重复的定义和过多的定义
• 个人感觉 单一职责的边界划分不是非常的清晰，对于一些的功能需求，很难确定单一的职责模式，需要大量的经验来判定