Android图片加载框架基本用法

介绍一下Android图片加载的4种框架的基本使用方法

定义了Constants类来存储一些图片网址

之后就一步一步来就可以了(注释很详细~~~)

一，Glide:

public class GlideActivity extends AppCompatActivity {
    private ListView listView;
    private String[] imageUrl;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_list);
        listView = (ListView) findViewById(R.id.listview_my);
        imageUrl = Constants.imagesGif;
        listView.setAdapter(new GlideAdapter());

    }
    class GlideAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            return imageUrl.length;
        }

        @Override
        public Object getItem(int position) {
            return imageUrl[position];
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder = null;
            if (convertView == null) {
                convertView = getLayoutInflater().inflate(R.layout.list_item_gif, parent, false);
                holder = new ViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }
            initGlide(holder,position);


            return convertView;
        }

        class ViewHolder {
            private ImageView imageView;

            public ViewHolder(View view) {
                super();
                imageView = (ImageView) view.findViewById(R.id.iv_gif);
            }
        }
    }
    public void initGlide(GlideAdapter.ViewHolder holder, int pos) {
        //这也是最基本的写法
      // Glide.with(this).load(imageUrl[pos]).into(holder.imageView);


        ViewPropertyAnimation.Animator animationObject = new ViewPropertyAnimation.Animator() {
            @Override
            public void animate(View view) {
                view.setAlpha( 0f );

                ObjectAnimator fadeAnim = ObjectAnimator.ofFloat(view, "alpha", 0f, 1f );
                fadeAnim.setDuration( 2500 );
                fadeAnim.start();
            }
        };
        //
        Glide.with(this).load(imageUrl[pos])
                .placeholder(R.mipmap.ic_launcher)
                .error(R.mipmap.ic_launcher)
                .animate(animationObject)    //渐变动画

               // .dontAnimate()//移除动画

                //.skipMemoryCache(true)   //禁止内存缓存
                //.diskCacheStrategy(DiskCacheStrategy.NONE) //禁止磁盘缓存
                //DiskCacheStrategy.SOURCE：缓存原始数据，
                // DiskCacheStrategy.RESULT：缓存变换(如缩放、裁剪等)后的资源数据，
                // DiskCacheStrategy.NONE：什么都不缓存，
                // DiskCacheStrategy.ALL：缓存SOURC和RESULT。
                // 默认采用DiskCacheStrategy.RESULT策略，
                // 对于download only操作要使用DiskCacheStrategy.SOURCE。


                .priority(Priority.HIGH)   //优先加载
                //指定加载的优先级，优先级越高越优先加载，但不保证所有图片都按序加载
                //Priority.IMMEDIATE，Priority.HIGH，Priority.NORMAL，Priority.LOW。默认为Priority.NORMAL。


                .thumbnail(0.5f) //利用原图的一半作为缩略图
                //请求给定系数的缩略图。如果缩略图比全尺寸图先加载完，就显示缩略图，否则就不显示。
                // 系数sizeMultiplier必须在(0,1)之间，可以递归调用该方法。
                //.override(100,100)//重新设置宽高 单为 px

                //先添加依赖  compile 'jp.wasabeef:glide-transformations:2.0.0'


                .bitmapTransform(new CropCircleTransformation(this))//圆形处理
//                .bitmapTransform(new RoundedCornersTransformation
//                        (this,30,0, RoundedCornersTransformation.CornerType.ALL))//圆角处理
                .into(holder.imageView);



    }
}

二，Picasso:

public class PicassoActivity extends AppCompatActivity {
    private ListView listView;
    private String[] imageUrl;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_list);
        listView = (ListView) findViewById(R.id.listview_my);
        imageUrl = Constants.images;
        listView.setAdapter(new PicassoAdapter());

    }

    class PicassoAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            return imageUrl.length;
        }

        @Override
        public Object getItem(int position) {
            return imageUrl[position];
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder = null;
            if (convertView == null) {
                convertView = getLayoutInflater().inflate(R.layout.list_item, parent, false);
                holder = new ViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();

            }
            initPicasso(holder,position);

            return convertView;
        }

        class ViewHolder {
            private ImageView imageView;

            public ViewHolder(View view) {
                super();
                imageView = (ImageView) view.findViewById(R.id.iv_item);
            }
        }
    }

    public void initPicasso(PicassoAdapter.ViewHolder holder, int pos) {
        //最最基本的写法
        //Picasso.with(this).load(imageUrl[pos]).into(holder.imageView);
        Picasso.with(this).load(imageUrl[pos])
                .placeholder(R.mipmap.ic_launcher)//加载时的图片
                .error(R.mipmap.ic_launcher) //失败时的图片
               // .resize(50, 50).centerCrop()//剪裁图片
                .transform(new CircleTransform())//自定义转换圆形图片
               // .memoryPolicy(MemoryPolicy.NO_CACHE,MemoryPolicy.NO_STORE)//不使用内存缓存
               // .networkPolicy(NetworkPolicy.NO_CACHE,NetworkPolicy.NO_STORE)//不使用磁盘缓存
                .into(holder.imageView);


    }
    
    public class CircleTransform implements Transformation {
        @Override
        public Bitmap transform(Bitmap source) {
            int size = Math.min(source.getWidth(), source.getHeight());

            int x = (source.getWidth() - size) / 2;
            int y = (source.getHeight() - size) / 2;

            Bitmap squaredBitmap = Bitmap.createBitmap(source, x, y, size, size);
            if (squaredBitmap != source) {
                source.recycle();
            }

            Bitmap bitmap = Bitmap.createBitmap(size, size, source.getConfig());

            Canvas canvas = new Canvas(bitmap);
            Paint paint = new Paint();
            BitmapShader shader = new BitmapShader(squaredBitmap,
                    BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
            paint.setShader(shader);
            paint.setAntiAlias(true);

            float r = size / 2f;
            canvas.drawCircle(r, r, r, paint);

            squaredBitmap.recycle();
            return bitmap;
        }

        @Override
        public String key() {
            return "circle";
        }
    }
}

三，Fresco:

public class FrescoActivity extends AppCompatActivity {
    private String[] imageUrl;
    private ListView listView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Fresco.initialize(this);//一定要在setContentView之前写
        setContentView(R.layout.activity_list);
        listView = (ListView) findViewById(R.id.listview_my);
        imageUrl = Constants.images;
        listView.setAdapter(new FrescoAdapter());

    }

    class FrescoAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            return imageUrl.length;
        }

        @Override
        public Object getItem(int position) {
            return imageUrl[position];
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder = null;
            if (convertView == null) {
                convertView = getLayoutInflater().inflate(R.layout.list_item_fresco, null);
                holder = new ViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }


            Uri uri = Uri.parse(imageUrl[position]);
            initDraweeView(holder.simpleDraweeView, uri);


            return convertView;
        }

        class ViewHolder {
            private SimpleDraweeView simpleDraweeView;

            public ViewHolder(View view) {
                super();
                simpleDraweeView = (SimpleDraweeView) view.findViewById(R.id.draw);


            }
        }
    }

    public void initDraweeView(SimpleDraweeView simpleDraweeView, Uri uri) {
        DraweeController draweeController =
                Fresco.newDraweeControllerBuilder()
                        .setUri(uri)
                        .setAutoPlayAnimations(true)
                        .build();
        simpleDraweeView.setController(draweeController);
    }

}

四，Android Universal Image Loader:

part1：

public class UILApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        initMyImageLoader(this);
    }

    /**
     * 4这个方法是对ImageLoaderConfiguration各属性解释
     * 切记不要瞎用
     */
    public static void initImageLoader(Context context) {
        //这里的路径可以自定义
        File cacheDir = StorageUtils.getCacheDirectory(context);
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
                // 默认等于你的屏幕尺寸，设备屏幕宽高
                .memoryCacheExtraOptions(480, 800)
                // 在将下载的图片保存到你的sd卡之前会重新计算，压缩。
                // 这个属性不要滥用，只有你在对应的需求时再用，因为他会使你的ImageLoader变的很慢。
                .diskCacheExtraOptions(480, 800, null)
                //用于执行从源获取图片任务的 Executor，为configuration中的 taskExecutor，
                // 如果为null，则会调用DefaultConfigurationFactory.createExecutor(…)根据配置返回一个默认的线程池。
                .taskExecutor(null)
                //用于执行从缓存获取图片任务的 Executor，为configuration中的 taskExecutorForCachedImages，
                // 如果为null，则会调用DefaultConfigurationFactory.createExecutor(…)根据配置返回一个默认的线程池。
                .taskExecutorForCachedImages(null)
                // 表示核心池大小(最大并发数) 默认为3
                .threadPoolSize(3)
                // 线程优先级，默认Thread.NORM_PRIORITY - 2
                .threadPriority(Thread.NORM_PRIORITY - 2)
                // 任务进程的顺序，默认为：FIFO 先进先出
                .tasksProcessingOrder(QueueProcessingType.FIFO)
                //设置内存缓存不允许缓存一张图片的多个尺寸，默认允许。
                .denyCacheImageMultipleSizesInMemory()
                //图片内存缓存
                .memoryCache(new LruMemoryCache(2 * 1024 * 1024))
                //memoryCacheSize 为 0，则设置该内存缓存的最大字节数为 App 最大可用内存的 1/8。
                .memoryCacheSize(2 * 1024 * 1024)
                // 创建最大的内存缓存百分比，默认为 13%
                .memoryCacheSizePercentage(13)
                // 硬盘缓存路径，默认为StorageUtils.getCacheDirectory(context)
                .diskCache(new UnlimitedDiskCache(cacheDir))
                //硬盘缓存大小
                .diskCacheSize(50 * 1024 * 1024)
                //缓存文件数量
                .diskCacheFileCount(100)
                // 硬盘缓存文件名生成器，默认为哈希文件名生成器
                .diskCacheFileNameGenerator(new HashCodeFileNameGenerator())
                // 创建图片下载器，默认是BaseImageDownloader
                .imageDownloader(new BaseImageDownloader(context))
                // 图片解码器，负责将图片输入流InputStream转换为Bitmap对象
                .imageDecoder(new BaseImageDecoder(true))
                // 图片显示的配置项。比如加载前、加载中、加载失败应该显示的占位图片，图片是否需要在磁盘缓存，是否需要在内存缓存等。
                .defaultDisplayImageOptions(DisplayImageOptions.createSimple())
                //是否显示调试log信息
                .writeDebugLogs()
                .build();
        ImageLoader.getInstance().init(config);
    }

    /**
     * 这个是推荐的写法
     */
    public static void initMyImageLoader(Context context) {
        //缓存文件的目录
        File cacheDir = StorageUtils.getOwnCacheDirectory(context, "imageloader/Cache");
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
                .memoryCacheExtraOptions(480, 800) // max width, max height，即保存的每个缓存文件的最大长宽
                .threadPoolSize(3) //线程池内加载的数量
                .threadPriority(Thread.NORM_PRIORITY - 2)
                .denyCacheImageMultipleSizesInMemory()
                .diskCacheFileNameGenerator(new Md5FileNameGenerator()) //将保存的时候的URI名称用MD5 加密
                .memoryCache(new UsingFreqLimitedMemoryCache(2 * 1024 * 1024)) //你可以通过自己的内存缓存实现
                .memoryCacheSize(2 * 1024 * 1024) // 内存缓存的最大值
                .diskCacheSize(50 * 1024 * 1024)  // 50 Mb sd卡(本地)缓存的最大值
                .tasksProcessingOrder(QueueProcessingType.LIFO)
                .diskCache(new UnlimitedDiskCache(cacheDir))//自定义缓存路径
                .imageDownloader(new BaseImageDownloader(context, 5 * 1000, 30 * 1000)) // connectTimeout (5 s), readTimeout (30 s)超时时间
                .writeDebugLogs()
                .build();
        //全局初始化此配置
        ImageLoader.getInstance().init(config);
    }
}

part2:

public class UILActivity extends AppCompatActivity implements View.OnClickListener {
    private ListView listView;
    private String[] imageUrl;
    private DisplayImageOptions options;
    private ImageLoader imageLoader;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_list_uil);
        imageLoader = ImageLoader.getInstance();
        listView = (ListView) findViewById(R.id.listview_uil);
        findViewById(R.id.btn_clear_disk).setOnClickListener(this);
        findViewById(R.id.btn_clear_memory).setOnClickListener(this);
        imageUrl = Constants.images;
        initMyOptions();
        listView.setAdapter(new UILAdapter());
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_clear_disk:
                imageLoader.clearDiskCache();
                Toast.makeText(UILActivity.this, "已清除本地缓存", Toast.LENGTH_SHORT).show();
                break;
            case R.id.btn_clear_memory:
                imageLoader.clearMemoryCache();
                Toast.makeText(UILActivity.this, "已清除内存缓存", Toast.LENGTH_SHORT).show();
                break;
        }
    }


    class UILAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            return imageUrl.length;
        }

        @Override
        public Object getItem(int position) {
            return imageUrl[position];
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder = null;
            if (convertView == null) {
                convertView = getLayoutInflater().inflate(R.layout.list_item, parent, false);
                holder = new ViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();

            }
            imageLoader.displayImage(imageUrl[position], holder.imageView, options);

            return convertView;
        }

        class ViewHolder {
            private ImageView imageView;

            public ViewHolder(View view) {
                super();
                imageView = (ImageView) view.findViewById(R.id.iv_item);
            }
        }
    }

    /**
     * 这里是对options所有属性的解释
     */
    public void initOptions() {
        options = new DisplayImageOptions.Builder()
                // 正在加载时显示的占位图
                .showImageOnLoading(R.mipmap.ic_launcher)
                // URL为空时显示的占位图
                .showImageForEmptyUri(R.mipmap.ic_launcher)
                // 加载失败时显示的占位图
                .showImageOnFail(R.mipmap.ic_launcher)
                // 在加载前是否重置 view，默认为false
                .resetViewBeforeLoading(false)
                //设置在开始加载前的延迟时间，单位为毫秒，通过 Builder 构建的对象默认为 0
                .delayBeforeLoading(1000)
                // 是否缓存在内存中，通过 Builder 构建的对象默认为 false
                .cacheInMemory(false)
                // 是否缓存在磁盘中，通过 Builder 构建的对象默认为 false。
                .cacheOnDisk(false)
                //缓存在内存之前的处理程序，默认为 null
                .preProcessor(null)
                //缓存在内存之后的处理程序，默认为 null。
                .postProcessor(null)
                //下载器需要的辅助信息。下载时传入ImageDownloader.getStream(String, Object)的对象，方便用户自己扩展，默认为 null。
                .extraForDownloader(null)
                // 是否考虑图片的 EXIF 信息，通过 Builder 构建的对象默认为 false。
                .considerExifParams(false)
                // 图片的缩放类型，通过 Builder 构建的对象默认为IN_SAMPLE_POWER_OF_2
                .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)
                // bitmap的质量，默认为ARGB_8888
                .bitmapConfig(Bitmap.Config.ARGB_8888)
                //为 BitmapFactory.Options，用于BitmapFactory.decodeStream(imageStream, null, decodingOptions)得到图片尺寸等信息。
                .decodingOptions(null)
                // 在ImageAware中显示 bitmap 对象的接口。可在实现中对 bitmap 做一些额外处理，比如加圆角、动画效果。
                .displayer(new SimpleBitmapDisplayer())
                // handler 对象，默认为 null
                .handler(new Handler())
                .build();
    }

    /**
     * 这是我要使用的options
     */
    public void initMyOptions() {
        // 使用DisplayImageOptions.Builder()创建DisplayImageOptions
        options = new DisplayImageOptions.Builder()
                .showImageOnLoading(R.mipmap.ic_launcher) // 设置图片下载期间显示的图片
                .showImageForEmptyUri(R.mipmap.ic_launcher) // 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.mipmap.ic_launcher) // 设置图片加载或解码过程中发生错误显示的图片
                .cacheInMemory(true) // 设置下载的图片是否缓存在内存中
                .cacheOnDisk(true) // 设置下载的图片是否缓存在SD卡中
                .displayer(new RoundedBitmapDisplayer(20)) // 设置成圆角图片
                .build(); // 构建完成
    }

}

ok,以上就是Android图片加载的几种框架的基本用法~~~

最后感谢硕哥提供的分享代码！！！