学习和使用ImageLoader、 Picasso、Fresco 图像加载

最新推荐文章于 2024-05-11 09:33:37 发布
最新推荐文章于 2024-05-11 09:33:37 发布
阅读量1.3k 收藏
点赞数
分类专栏： Android 文章标签： android 图片加载第三方sdk的学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Boom_Jia/article/details/52299665
版权

我们在Android开发难免会碰到图片加载问题，比如最常见的内存溢出OOM，在开发中，现在比较流行的第三方框架比如有以下几个：

1.ImageLoader

2.Picasso

3.Fresco

框架一：ImageLoader

那我们如何使用ImageLoader来加载图片?

1.下载相关jar包   jar包下载地址：http://pan.baidu.com/s/1kUTBe9h（为了方便我放在自己的百度网盘）


2.对jar进行依赖

3.在自定义application中进行配置

先自定义个方法

    public static void initImageLoader(Context context) {
                personOptions = new DisplayImageOptions.Builder()
                .showImageOnFail(R.mipmap.ic_launcher)
                .showImageForEmptyUri(R.mipmap.ic_launcher)
                .resetViewBeforeLoading(false)  // default
                .delayBeforeLoading(0)
                .cacheInMemory(true) // default
                .cacheOnDisk(true) // default
                .considerExifParams(true) // default
                .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default
                .bitmapConfig(Bitmap.Config.ARGB_8888) // default
                .displayer(new SimpleBitmapDisplayer()) // default
                .handler(new Handler()) // default
                .build();

        DisplayImageOptions options = new DisplayImageOptions.Builder()
                .showImageOnLoading(R.mipmap.ic_launcher)
//                .showImageOnFail(R.drawable.img_fail)
                .resetViewBeforeLoading(false)  // default
                .delayBeforeLoading(0)
                .cacheInMemory(true) // default
                .cacheOnDisk(true) // default
                .considerExifParams(true) // default
                .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default
                .bitmapConfig(Bitmap.Config.ARGB_8888) // default
                .displayer(new SimpleBitmapDisplayer()) // default
                .handler(new Handler()) // default
                .build();

        // This configuration tuning is custom. You can tune every option, you may tune some of them,
        // or you can create default configuration by
        // ImageLoaderConfiguration.createDefault(this);
        // method.
//        File cacheDir = StorageUtils.getCacheDirectory(context);
        File picPath=new File(Environment.getExternalStorageDirectory().getPath()+ File.separator+"app_pic"+File.separator+"photos");
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
                .memoryCacheExtraOptions(480, 800) // default = device screen dimensions
                .diskCacheExtraOptions(480, 800, null)
                .threadPoolSize(3) // default
                .threadPriority(Thread.NORM_PRIORITY - 1) // default
                .tasksProcessingOrder(QueueProcessingType.FIFO) // default
                .denyCacheImageMultipleSizesInMemory()
                .memoryCache(new LruMemoryCache(2 * 1024 * 1024))
                .memoryCacheSize(2 * 1024 * 1024)
                .memoryCacheSizePercentage(13) // default
                .diskCache(new UnlimitedDiskCache(picPath)) // default
                .diskCacheSize(50 * 1024 * 1024)
                .diskCacheFileCount(1000)
                .diskCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default
                .imageDownloader(new BaseImageDownloader(context)) // default
                .imageDecoder(new BaseImageDecoder(true)) // default
                .defaultDisplayImageOptions(options) // default
                .writeDebugLogs()
                .build();
        // Initialize ImageLoader with configuration.
        ImageLoader.getInstance().init(config);
    }
然后在application中进行调用 

    //加载图片设置
        initImageLoader(getApplicationContext());

4.加载图片方法

我们可以查看源码中的Imageloader类

其中提供了几种加载图片方式：

1.displayImage（）

2.loadImage（）

  3.loadImageSync（）

下面我们查看一下源码：

displayImage的方法：

    public void displayImage(String uri, ImageAware imageAware) {
        this.displayImage(uri, (ImageAware)imageAware, (DisplayImageOptions)null, (ImageLoadingListener)null, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageAware imageAware, ImageLoadingListener listener) {
        this.displayImage(uri, (ImageAware)imageAware, (DisplayImageOptions)null, listener, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options) {
        this.displayImage(uri, (ImageAware)imageAware, options, (ImageLoadingListener)null, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options, ImageLoadingListener listener) {
        this.displayImage(uri, (ImageAware)imageAware, options, listener, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        this.displayImage(uri, imageAware, options, (ImageSize)null, listener, progressListener);
    }

    public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options, ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        this.checkConfiguration();
        if(imageAware == null) {
            throw new IllegalArgumentException("Wrong arguments were passed to displayImage() method (ImageView reference must not be null)");
        } else {
            if(listener == null) {
                listener = this.defaultListener;
            }

            if(options == null) {
                options = this.configuration.defaultDisplayImageOptions;
            }

            if(TextUtils.isEmpty(uri)) {
                this.engine.cancelDisplayTaskFor(imageAware);
                listener.onLoadingStarted(uri, imageAware.getWrappedView());
                if(options.shouldShowImageForEmptyUri()) {
                    imageAware.setImageDrawable(options.getImageForEmptyUri(this.configuration.resources));
                } else {
                    imageAware.setImageDrawable((Drawable)null);
                }

                listener.onLoadingComplete(uri, imageAware.getWrappedView(), (Bitmap)null);
            } else {
                if(targetSize == null) {
                    targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, this.configuration.getMaxImageSize());
                }

                String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
                this.engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);
                listener.onLoadingStarted(uri, imageAware.getWrappedView());
                Bitmap bmp = this.configuration.memoryCache.get(memoryCacheKey);
                ImageLoadingInfo imageLoadingInfo;
                if(bmp != null && !bmp.isRecycled()) {
                    L.d("Load image from memory cache [%s]", new Object[]{memoryCacheKey});
                    if(options.shouldPostProcess()) {
                        imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey, options, listener, progressListener, this.engine.getLockForUri(uri));
                        ProcessAndDisplayImageTask displayTask1 = new ProcessAndDisplayImageTask(this.engine, bmp, imageLoadingInfo, defineHandler(options));
                        if(options.isSyncLoading()) {
                            displayTask1.run();
                        } else {
                            this.engine.submit(displayTask1);
                        }
                    } else {
                        options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
                        listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
                    }
                } else {
                    if(options.shouldShowImageOnLoading()) {
                        imageAware.setImageDrawable(options.getImageOnLoading(this.configuration.resources));
                    } else if(options.isResetViewBeforeLoading()) {
                        imageAware.setImageDrawable((Drawable)null);
                    }

                    imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey, options, listener, progressListener, this.engine.getLockForUri(uri));
                    LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(this.engine, imageLoadingInfo, defineHandler(options));
                    if(options.isSyncLoading()) {
                        displayTask.run();
                    } else {
                        this.engine.submit(displayTask);
                    }
                }

            }
        }
    }

    public void displayImage(String uri, ImageView imageView) {
        this.displayImage(uri, (ImageAware)(new ImageViewAware(imageView)), (DisplayImageOptions)null, (ImageLoadingListener)null, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageView imageView, ImageSize targetImageSize) {
        this.displayImage(uri, new ImageViewAware(imageView), (DisplayImageOptions)null, targetImageSize, (ImageLoadingListener)null, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageView imageView, DisplayImageOptions options) {
        this.displayImage(uri, (ImageAware)(new ImageViewAware(imageView)), options, (ImageLoadingListener)null, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageView imageView, ImageLoadingListener listener) {
        this.displayImage(uri, (ImageAware)(new ImageViewAware(imageView)), (DisplayImageOptions)null, listener, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageView imageView, DisplayImageOptions options, ImageLoadingListener listener) {
        this.displayImage(uri, (ImageView)imageView, options, listener, (ImageLoadingProgressListener)null);
    }

    public void displayImage(String uri, ImageView imageView, DisplayImageOptions options, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        this.displayImage(uri, (ImageAware)(new ImageViewAware(imageView)), options, listener, progressListener);
    }


loadImage的方法：

 public void loadImage(String uri, ImageLoadingListener listener) {
        this.loadImage(uri, (ImageSize)null, (DisplayImageOptions)null, listener, (ImageLoadingProgressListener)null);
    }

    public void loadImage(String uri, ImageSize targetImageSize, ImageLoadingListener listener) {
        this.loadImage(uri, targetImageSize, (DisplayImageOptions)null, listener, (ImageLoadingProgressListener)null);
    }

    public void loadImage(String uri, DisplayImageOptions options, ImageLoadingListener listener) {
        this.loadImage(uri, (ImageSize)null, options, listener, (ImageLoadingProgressListener)null);
    }

    public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options, ImageLoadingListener listener) {
        this.loadImage(uri, targetImageSize, options, listener, (ImageLoadingProgressListener)null);
    }

    public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        this.checkConfiguration();
        if(targetImageSize == null) {
            targetImageSize = this.configuration.getMaxImageSize();
        }

        if(options == null) {
            options = this.configuration.defaultDisplayImageOptions;
        }

        NonViewAware imageAware = new NonViewAware(uri, targetImageSize, ViewScaleType.CROP);
        this.displayImage(uri, (ImageAware)imageAware, options, listener, progressListener);
    }


 

loadImageSync的方法：
 

  public Bitmap loadImageSync(String uri) {
        return this.loadImageSync(uri, (ImageSize)null, (DisplayImageOptions)null);
    }

    public Bitmap loadImageSync(String uri, DisplayImageOptions options) {
        return this.loadImageSync(uri, (ImageSize)null, options);
    }

    public Bitmap loadImageSync(String uri, ImageSize targetImageSize) {
        return this.loadImageSync(uri, targetImageSize, (DisplayImageOptions)null);
    }

    public Bitmap loadImageSync(String uri, ImageSize targetImageSize, DisplayImageOptions options) {
        if(options == null) {
            options = this.configuration.defaultDisplayImageOptions;
        }

        options = (new Builder()).cloneFrom(options).syncLoading(true).build();
        ImageLoader.SyncImageLoadingListener listener = new ImageLoader.SyncImageLoadingListener();
        this.loadImage(uri, targetImageSize, options, listener);
        return listener.getLoadedBitmap();
    }
   我们可以根据自己的需求去封装类，然后调用，方便后期程序的开发，减少代码的冗余。 

 

关键类：
 

 

ImageLoader
 

DisplayImageOptions
 

ImageLoaderConfiguration
 

 

框架二：Picasso
 

我们如何使用Picasso加载图片？
 

1.在app中的grade中进行依赖 
 

 

    compile 'com.squareup.picasso:picasso:2.5.2'
 
 2.简单的使用 

 

 

   Picasso.with(getBaseContext()).load(R.mipmap.a).resize(100,100).centerCrop().into(img);
 
 3.自定义类处理图片加载，然后在其他类中进行调用    起到控制的作用 

 

 

<span style="font-size:18px;">package com.example.boom.picproject.core;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.net.Uri;
import android.os.Environment;
import android.widget.ImageView;

import com.squareup.picasso.Callback;
import com.squareup.picasso.Picasso;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;


public class PicassoHelper {
    public static void LoadImage(Context _context,String url,String fileName,final ImageView target) {
        LoadImage(_context,url,fileName,target,null);
    }

    public static void LoadImage(Context _context, String url, final String fileName , final ImageView target, final Callback callback) {
        url = url.replaceAll(" ", "%20");

        if(fileName != null && !fileName.equals(""))
        {
            File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),fileName);
            if (file.exists()) {
                Bitmap bm = BitmapFactory.decodeFile(file.getPath());
                target.setImageBitmap(bm);
                if(callback != null) callback.onSuccess();
                return ;
            }
        }

        final ArrayList<String> urlList = new ArrayList<>();
        final Callback localCallback = new Callback() {
            @Override
            public void onSuccess() {
                if(callback != null) callback.onSuccess();
                else {
                    if (fileName != null && !fileName.equals("")) {
                        File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), fileName);
                        if (!file.exists()) {
                            FileOutputStream out = null;
                            try {
                                Bitmap bitmap = ((BitmapDrawable) target.getDrawable()).getBitmap();
                                out = new FileOutputStream(file);
                                bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();
                            } finally {
                                if (out != null) {
                                    try {
                                        out.close();
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        }
                    }
                }
            }

            @Override
            public void onError() {
                if(callback != null) callback.onError();
            }
        };
        urlList.add(url);
        Picasso picasso = new Picasso.Builder(_context).listener(new Picasso.Listener() {
            @Override
            public void onImageLoadFailed(Picasso picasso, Uri uri, Exception exception) {
                boolean needLoadLocalFile = true;
                String message = exception.getMessage();
                if (message != null && message.contains("302")) {
                    String tempUrl = uri.toString();
                    if(tempUrl.startsWith("http://"))
                    {
                        tempUrl = tempUrl.replace("http://","https://");
                    }else{
                        tempUrl = tempUrl.replace("https://","http://");
                    }

                    if(!urlList.contains(tempUrl))
                    {
                        urlList.add(tempUrl);
                        needLoadLocalFile = false;
                        picasso.load(tempUrl).into(target,localCallback);
                    }

                }
                if(needLoadLocalFile){
                    if(fileName != null && !fileName.equals(""))
                    {
                        File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),fileName);
                        if (file.exists()) {
                            Bitmap bm = BitmapFactory.decodeFile(file.getPath());
                            target.setImageBitmap(bm);
                        }
                    }
                }
            }
        }).build();
        picasso.load(url).into(target,localCallback);
    }

    public static void LoadImage(Context _context,String url,final ImageView target) {
        LoadImage(_context,url,"",target,null);
    }

    public static void LoadImage(Context _context,String url,final ImageView target,final Callback callback) {
        LoadImage(_context,url,"",target,callback);
    }
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">		</span></span>
 

 

查看源码加载图片的方法：
 

 

Picasso类中的方法（普通）
 

 

 

  /**
   * Start an image request using the specified URI.
   * <p>
   * Passing {@code null} as a {@code uri} will not trigger any request but will set a placeholder,
   * if one is specified.
   *
   * @see #load(File)
   * @see #load(String)
   * @see #load(int)
   */
  public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
  }

  /**
   * Start an image request using the specified path. This is a convenience method for calling
   * {@link #load(Uri)}.
   * <p>
   * This path may be a remote URL, file resource (prefixed with {@code file:}), content resource
   * (prefixed with {@code content:}), or android resource (prefixed with {@code
   * android.resource:}.
   * <p>
   * Passing {@code null} as a {@code path} will not trigger any request but will set a
   * placeholder, if one is specified.
   *
   * @see #load(Uri)
   * @see #load(File)
   * @see #load(int)
   * @throws IllegalArgumentException if {@code path} is empty or blank string.
   */
  public RequestCreator load(String path) {
    if (path == null) {
      return new RequestCreator(this, null, 0);
    }
    if (path.trim().length() == 0) {
      throw new IllegalArgumentException("Path must not be empty.");
    }
    return load(Uri.parse(path));
  }

  /**
   * Start an image request using the specified image file. This is a convenience method for
   * calling {@link #load(Uri)}.
   * <p>
   * Passing {@code null} as a {@code file} will not trigger any request but will set a
   * placeholder, if one is specified.
   * <p>
   * Equivalent to calling {@link #load(Uri) load(Uri.fromFile(file))}.
   *
   * @see #load(Uri)
   * @see #load(String)
   * @see #load(int)
   */
  public RequestCreator load(File file) {
    if (file == null) {
      return new RequestCreator(this, null, 0);
    }
    return load(Uri.fromFile(file));
  }

  /**
   * Start an image request using the specified drawable resource ID.
   *
   * @see #load(Uri)
   * @see #load(String)
   * @see #load(File)
   */
  public RequestCreator load(int resourceId) {
    if (resourceId == 0) {
      throw new IllegalArgumentException("Resource ID must not be zero.");
    }
    return new RequestCreator(this, null, resourceId);
  }
用建造者模式 

 

 

    /** Start building a new {@link Picasso} instance. */
    public Builder(Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.context = context.getApplicationContext();
    }

    /**
     * Specify the default {@link Bitmap.Config} used when decoding images. This can be overridden
     * on a per-request basis using {@link RequestCreator#config(Bitmap.Config) config(..)}.
     */
    public Builder defaultBitmapConfig(Bitmap.Config bitmapConfig) {
      if (bitmapConfig == null) {
        throw new IllegalArgumentException("Bitmap config must not be null.");
      }
      this.defaultBitmapConfig = bitmapConfig;
      return this;
    }
 

 

 

 

 

框架三：Fresco
 

这是我最近在看的一个第三方sdk,感觉很好，并且很强大，这里就简单的说说使用，主要还是参考他的网址介绍：http://www.fresco-cn.org/docs/using-drawees-code.html，上面介绍如何使用还是很详细的。
 

1.app中grade如何配置
 

 

<span style="font-size:18px;">  compile 'com.facebook.fresco:fresco:0.12.0'</span>
 

 

  
 

<span style="font-size:18px;"> // 在 API < 14 上的机器支持 WebP 时，需要添加
  compile 'com.facebook.fresco:animated-base-support:0.12.0'

  // 支持 GIF 动图，需要添加
  compile 'com.facebook.fresco:animated-gif:0.12.0'

  // 支持 WebP （静态图+动图），需要添加
  compile 'com.facebook.fresco:animated-webp:0.12.0'
  compile 'com.facebook.fresco:webpsupport:0.12.0'

  // 仅支持 WebP 静态图，需要添加
  compile 'com.facebook.fresco:webpsupport:0.12.0'</span>
 

  

 

在自定义application中初始化
 

 

<span style="font-size:18px;">Fresco.initialize(this);</span>
 

 主要控件 

 

 

<span style="font-size:18px;"><com.facebook.drawee.view.SimpleDraweeView
    android:id="@+id/my_image_view"
    android:layout_width="130dp"
    android:layout_height="130dp"
    fresco:placeholderImage="@drawable/my_drawable"
  /></span>
 

 代码实现： 

 

 

<span style="font-size:18px;">Uri uri = Uri.parse("https://raw.githubusercontent.com/facebook/fresco/gh-pages/static/logo.png");
SimpleDraweeView draweeView = (SimpleDraweeView) findViewById(R.id.my_image_view);
draweeView.setImageURI(uri);</span>
 

 我们在利用第三方sdk的时候，这是其中解决OOM问题之一，我们也可以自己通过对图片的大小进行压缩或对图片的格式进行更改，比如把png图片转换成jpg图片。对处理离线缓存有很大的用处。 

 

 最后我们记得还要加上User权限
 

 

   <uses-permission android:name="android.permission.INTERNET"/>
 

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 

 

 

 


 
 


 
 


 

                

        

        

    




    

      

        

            

              
                
                  心宽何处不桃源
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
ImageLoading图片加载

				
			

			

				

					zhangyuke01的博客
				

				

					09-20
					
					1740
					
				

			

		

		

			
				
//创建Application类在配置文件中写name属性、要有写的权限
 
package com.bwie.imageloaer;
import android.app.Application;
import android.os.Environment;
import
com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDis

			
		

	



                

              
                



	

		

			

				
					
ImageLoader:壁画，glidev3，v4的包装器，用于图像加载和大图像预览的解决方案，并提供用于imageview的调试工具

				
			

			

				

					04-14
				

			

		

		

			
				
目前底层依赖fresco和glide,picasso,直接gradle改一下就切换了 能够以同样api获取bitmap,所设置的宽高,高斯模糊,圆角或圆形效果均生效. 解决了fresco最新版中,获取到的bitmap是recycled,不能用的问题 基于...

			
		

	



                


  
              

                


	

		

			

				
					
ImageLoader和Picasso

				
			

			

				

					bianshaopeng的博客
				

				

					07-06
					
					292
					
				

			

		

		

			
				
下载资源jarhttps://github.com/nostra13/Android-Universal-Image-Loader 
将jar导入libspublic class MyAppilication extends Application{
    @Override
    public void onCreate() {
        // TODO Auto-generated m

			
		

	





	

		

			

				
					
Image loading with Imaging API

				
			

			

				

					就是要去飞翔……
				

				

					09-13
					
					2458
					
				

			

		

		

			
				
Image loading with Imaging API IntroductionThere is a number of different ways for image loading exists on Windows Mobile. The oldest one is to use not officially documented in SDK imgdecmp.dl

			
		

	



		

			
		



	

		

			

				
					
推荐：Image Loading System - 优雅的图像加载库

					
最新发布

				
			

			

				

					gitblog_00082的博客
				

				

					05-11
					
					916
					
				

			

		

		

			
				
推荐：Image Loading System - 优雅的图像加载库
项目地址:https://gitcode.com/kean/Nuke

在软件开发中，高效的图像处理和加载是提升用户体验的关键因素之一。Image Loading System 是一个专为 iOS、macOS、watchOS、tvOS 和 visionOS 平台设计的强大图像加载框架。它提供简洁且灵活的 API，让图片加载变得简...

			
		

	





	

		

			

				
					
Imageloading单一模式

				
			

			

				

					zhangyuke01的博客
				

				

					09-20
					
					261
					
				

			

		

		

			
				
package com.bwie.imageloaderdemo1;

import android.graphics.Bitmap;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView

			
		

	





	

		

			

				
					
Android常用的图片加载库

				
			

			

				

					01-04
				

			

		

		

			
				
四种常用的图片加载框架，分别是Fresco、ImageLoader、 Picasso、 Glide。 Universal Image Loader：ImageLoader是比较老的框架，一个强大的图片加载库，包含各种各样的配置，最老牌，使用也最广泛。 ImageLoader...

			
		

	





	

		

			

				
					
ImageLoader.zip

				
			

			

				

					05-15
				

			

		

		

			
				
在Android开发中，高效地加载和管理图片资源是至关重要的，因为这直接影响到应用的性能和用户体验。"ImageLoader.zip" 提供了一个解决方案，通过结合`LruCache`和`DiskLruCache`来实现一个简单的`ImageLoader`。下面...

			
		

	





	

		

			

				
					
加载图片的demo

				
			

			

				

					09-12
				

			

		

		

			
				
它可能包含了初始化imageLoader对象、设置加载和错误占位图、指定加载策略以及处理加载过程中的异常的代码。通过阅读和分析这段代码，开发者可以更好地理解和掌握图片加载的最佳实践。  总的来说，加载图片不仅仅是...

			
		

	





	

		

			

				
					
Android 常见的图片加载框架详细介绍

				
			

			

				

					01-20
				

			

		

		

			
				
 - Picasso的亮点在于其简洁的API，开发者只需一行代码即可实现图片的加载和显示。  - 它支持内存和LruCache的缓存策略，但不直接支持GIF或WebP格式。  4. **Glide**  - Glide是谷歌推荐的图片加载库，以其高效、...

			
		

	





	

		

			

				
					
Android Image Loading 库如何解决加载缓慢的问题？

				
			

			

				

					yihanss的博客
				

				

					09-22
					
					365
					
				

			

		

		

			
				
加载缓慢的主要原因之一是，即使视图不在窗口或不再需要该任务，我们也不会取消下载或解码位图之类的任务，因此甚至有许多任务正在完成虽然我们不需要它们，所以加载刚刚出现在窗口中的实际图像需要时间。这就是他们通过在适当的时间取消不再需要的任务来解决图像加载缓慢问题的方法。在这篇博客中，我们将学习 Android Image Loading 库如何解决图像加载缓慢的问题。这些库在内部为我们做了很多事情，这样我们就可以使用它们并轻松完成我们的任务。我们将在即将发布的博文中了解这些库所做的更多事情。

			
		

	





	

		

			

				
					
HTML ＜img＞ loading属性

				
			

			

				

					qq_43115434的博客
				

				

					08-06
					
					2288
					
				

			

		

		

			
				
        在页面中是大量存在的，对于这些图片，加载也是需要消耗时间。了解 loading 可以优化页面，我们可以选择 eager 和 lazy。下面就是对 loading 属性的详细介绍。
loading
        指示浏览器应当如何加载该图像。允许的值：
eager

     &nbs

			
		

	





	

		

			

				
					
【开源项目1】使用ImageLoader实现图片异步加载

				
			

			

				

					weixin_30299709的博客
				

				

					05-28
					
					127
					
				

			

		

		

			
				
我们经常会从网上加载大量的图片，处理不好，经常会出现内存溢出，导致app崩溃，还有下载速度慢登问题。ImageLoader基本避免了这些问题，下载速度快，基本不会出现内存泄漏，还有很好的缓存管理机制，自己感觉很好用的，下面，简单介绍其使用方法：
官方网址：https://github.com/nostra13/Android-Universal-Image-Loader
1.到官方网站下载最新...

			
		

	





	

		

			

				
					
facebook强大的图片加载工具Fresco，比imageload加载速度快

				
			

			

				

					Mr_ladeng的博客
				

				

					12-16
					
					1848
					
				

			

		

		

			
				
关于 Fresco
Fresco 是一个强大的图片加载组件。
Fresco 中设计有一个叫做 image pipeline 的模块。它负责从网络，从本地文件系统，本地资源加载图片。为了最大限度节省空间和CPU时间，它含有3级缓存设计（2级内存，1级文件）。
Fresco 中设计有一个叫做 Drawees 模块，方便地显示loading图，当图片不再显示在屏幕上时，及时地释放内存和空间占用。

			
		

	





	

		

			

				
					
使用ImageLoader实现图片异步加载

					
热门推荐

				
			

			

				

					
				

				

					05-08
					
					2万+
					
				

			

		

		

			
				
使用ImageLoader实现异步加载图片，很简单实用
我们经常会从网上加载大量的图片，处理不好，经常会出现内存溢出，导致app崩溃，还有下载速度慢登问题。ImageLoader基本避免了这些问题，下载速度快，基本不会出现内存泄漏，还有很好的缓存管理机制，自己感觉很好用的，下面，简单介绍其使用方法：
官方网址：https://github.com/nostra13/Android-Universal-Image-Loader
1.到官方网站下载最新

			
		

	





	

		

			

				
					
android图片加载工具栏,Android开发中ImageLoder进行图片加载和缓存

				
			

			

				

					weixin_28965739的博客
				

				

					05-27
					
					140
					
				

			

		

		

			
				
package com.longfei.admin.imageloder_text;import android.app.Application;import android.graphics.Bitmap;import android.os.Environment;import com.nostra13.universalimageloader.cache.disc.impl.Unlimited...

			
		

	





	

		

			

				
					
关于ImageLoadingProgressListener不执行的囧事儿。

				
			

			

				

					Drink_Spring的专栏
				

				

					07-14
					
					1672
					
				

			

		

		

			
				
ImageLoader使用过程中，遭遇ImageLoadingProgressListener不执行的问题，其实原因是，已经加载过这张图片，有缓存了，就不会再加载了，就不执行这个方法了。
赶紧打自己脸吧。

			
		

	





	

		

			

				
					
解决Android ImageView用setImageDrawable方法图片缩小的问题

				
			

			

				

					抢财猫股票课堂
				

				

					01-23
					
					2万+
					
				

			

		

		

			
				
今天使用assert目录存了几张图片，然后想通过imageview显示出来，结果在一个低分辨率的手机上显示正常，但是到了一个高分辨率手机上显示图片变得非常小，看了一下api   public void setAdjustViewBounds (boolean adjustViewBounds)当你需要在 ImageView 调整边框时保持可绘制对象的比例时，将该值设为真。参数adjustViewB

			
		

	





	

		

			

				
					
Android开发笔记(成长轨迹)

				
			

			

				

					dawuafang
				

				

					06-21
					
					962
					
				

			

		

		

			
				

1.控制台输出：called unimplemented OpenGL ES API
调用了未实现的OpenGL ES API函数，一般由于导入的第三方库如地图库，里面有用到OpenGL，但是模拟器的硬件默认是没有这个的，所以需要我们编辑模拟器Emulation Options选项勾选 Use Host GPU 然后重启模拟器再尝试，如果还是这个错误，那么我们只好用真机测试了。

2.控...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值