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

单一职责原则实践

最新推荐文章于 2024-05-29 20:30:39 发布

原创最新推荐文章于 2024-05-29 20:30:39 发布 · 380 阅读

0 ·

CC 4.0 BY-SA版权

Android(Java)设计模式专栏收录该内容

9 篇文章

订阅专栏

本文介绍单一职责原则的应用，通过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;
    }
}