从零实现ImageLoader（二）—— 基本实现

目录

从零实现ImageLoader（一）—— 架构
从零实现ImageLoader（二）—— 基本实现
从零实现ImageLoader（三）—— 线程池详解
从零实现ImageLoader（四）—— Handler的内心独白
从零实现ImageLoader（五）—— 内存缓存LruCache
从零实现ImageLoader（六）—— 磁盘缓存DiskLruCache

ImageLoader类

我们今天先从ImageLoader类入手，由于是链式的调用方式，ImageLoader以单例的方式实现，下面是代码：

public class ImageLoader {
    private static volatile ImageLoader mSingleton;
    private final Context mContext;

    private ImageLoader(Context context) {
        mContext = context;
    }

    public static ImageLoader with(Context context) {
        if(mSingleton == null) {
            synchronized (ImageLoader.class) {
                if(mSingleton == null) {
                    mSingleton = new ImageLoader(context);
                }
            }
        }
        return mSingleton;
    }
}

至于单例为什么要这么实现，不清楚的同学可以看一下这篇文章：如何正确地写出单例模式 | Jark's Blog。单例如何实现，为什么要这么实现，在这篇文章中都有详细的介绍，这里就不再赘述了。

内存泄露！

不过，上面的代码看似没有问题，但细心的同学可能已经发现了，ImageLoader类持有了Context对象，而ImageLoader作为一个单例持有Context对象是很有可能造成内存泄露的。

我们可以用LeakCanary检测一下，使用起来也很简单， 在build.gradle中加入以下代码：

 dependencies {
   debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.2'
   releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.2'
 }

接着创建自己的Application类：

public class App extends Application {
  @Override public void onCreate() {
    super.onCreate();
    if (LeakCanary.isInAnalyzerProcess(this)) {
      // This process is dedicated to LeakCanary for heap analysis.
      // You should not init your app in this process.
      return;
    }
    LeakCanary.install(this);
    // Normal app init code...
  }
}

然后随便在MainActivity的什么地方调用ImageLoader：

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ImageLoader.with(this);
    }
}

现在只需要打开应用、退出、再打开就会看到下面的画面：

LeakCanary提示

这是LeakCanary在导出内存信息，过一会等待LeakCanary分析完成就会出现一条通知：

LeakCanary通知

可以看到LeakCanary提示MainActivity产生内存泄露了，点进去有更详细的情况：

MainActivity内存泄露详情

可以很明显看到MainActivity的引用被ImageLoader的单例持有，由于单例的生命周期是伴随整个应用的，当Activity调用onDestory()方法时，依然被ImageLoader引用而无法释放，这就造成了内存泄露。

这给了我们一个很重要的警示：不要在单例中持有Activity对象的Context。

可这就产生了一个问题，我们必须要用Context，这可怎么办呢？其实解决方法也很简单，既然ImageLoader的生命周期是整个应用，那我们使用生命周期同样是整个应用的ApplicationContext不就可以了吗？于是代码变成了这样：

public class ImageLoader {
    private static volatile ImageLoader mSingleton;
    private final Context mContext;

    private ImageLoader(Context context) {
        //防止单例持有Activity的Context导致内存泄露
        mContext = context.getApplicationContext();
    }

    public static ImageLoader with(Context context) {
        if(mSingleton == null) {
            synchronized (ImageLoader.class) {
                if(mSingleton == null) {
                    mSingleton = new ImageLoader(context);
                }
            }
        }
        return mSingleton;
    }
}

再打开应用，已经没有内存泄露了。

同步实现

解决了内存泄露问题，接着实现其他功能。我们使用load(String url)传入需要加载的图片路径：

public class ImageLoader {
    ...

    public Dispatcher load(String url) {
        return new Dispatcher(url);
    }
}

由于是链式调用，所以返回了Dispatcher类：

public class Dispatcher {
    private final String mUrl;
    public Bitmap get() throws IOException {
        URL realUrl = new URL(mUrl);
        HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
        try(InputStream in = connection.getInputStream()) {
            return BitmapFactory.decodeStream(in);
        } finally {
            connection.disconnect();
        }
    }
}

这里只做一个简单的同步加载实现，也就是get()方法，其他功能等之后再慢慢添加。

到这里，ImageLoader就已经有了加载图片的功能了，先测试一下：

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ImageView imageView = findViewById(R.id.image);
        new Thread(() -> {
            Bitmap bitmap;
            try {
                bitmap = ImageLoader.with(this)
                        .load("https://i.redd.it/20mplvimm8ez.jpg")
                        .get();
                MainActivity.this.runOnUiThread(() -> {
                    imageView.setImageBitmap(bitmap);
                });
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

效果图

代码优化

上面的get()方法实现现在看起来好像没什么问题，不过Dispatcher类是用来进行线程切换以及缓存加载的，如果再将网络下载放在这里，Dispatcher类就会显得过于臃肿，为了保持Dispatcher类功能的单一性，这里选择将网络下载功能抽出来单独做一个类：

public class NetworkUtil {
    private NetworkUtil() {}

    public static Bitmap getBitmap(String url) throws IOException {
        URL realUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
        try(InputStream in = connection.getInputStream()) {
            return BitmapFactory.decodeStream(in);
        } finally {
            connection.disconnect();
        }
    }
}

这样做还有一个好处，那就是以后想要使用其他的网络下载框架比如OkHttp或者Volley，只需要在NetworkUtil中修改而不影响其他类了。

现在，Dispatcher的get()方法也变得非常简洁：

public class Dispatcher {
    private final String mUrl;
    public Bitmap get() throws IOException {
        return NetworkUtil.getBitmap(mUrl);
    }
}

总结

在这篇文章里我们实现了基本的同步加载，同时解决了Context的内存泄露问题，下一篇，我们将要实现的是异步图片加载。