rongwei84n

62. ImageLoader源代码-流程分析

一. ImageLoader简介

Android library #1 on GitHub. UIL aims to provide a powerful, flexible and highly customizable instrument for image loading, caching and displaying. It provides a lot of configuration options and good control over the image loading and caching process.

根据Github上面的注释，ImageLoader是一个强大的，灵活的，高度可定制化的图片加载，缓存已经展示的框架。它提供了大量的可配置选项，可以很好的控制图片的加载和缓存进度。

1.1 Github源代码地址

https://github.com/nostra13/Android-Universal-Image-Loader

1.2 主要类及其功能介绍

类名	意义
ImageLoader	ImageLoader的主要操作入口类，比如初始化，请求加载图片。
ImageLoaderEngine	ImageLoader的发动机，包含几个Executor线程池，可以执行各种任务，有些Executor可以在configuration中配置。
ImageViewAware	传入图片控件ImageView的包装，对ImageView弱引用(防止内存泄漏)，封装了一些方法，可以更加方便的操作ImageView，比如获取宽高，设置图片显示等。
DisplayImageOptions	请求显示图片时的参数，比如默认图片，失败图片，是否使用内存缓存等等
ImageLoadingListener	图片加载的监听器，比如onLoadingStarted，onLoadingComplete
MemoryCache	MemoryCache是图片内存缓存的一个接口，包括多种实现机制，比如Lru, FIFO, LargestLimited等
DiskCache	图片磁盘缓存接口，包括多种缓存命名算法，比如md5,hashcode等
ImageLoadingInfo	内存中没有找到图片，准备去其他地方找图片的时候，为了便于操作封装的对象，比如图片uri,memorykey, imageLoadinglistener,progressListener, loadFromUriLock
LoadedFrom	枚举类型，表明图片从哪里获取，包括3种类型 NETWORK(网络), DISC_CACHE(磁盘,sd卡), MEMORY_CACHE(内存)
ImageLoaderConfiguration	非常重要的对象，在Application中初始化，包含了MemoryCache,DiskCache，ImageDownloader，ImageDecoder等
ImageDownloader	图片下载接口，有些实现子类，比如BaseImageDownloader，SlowNetworkImageDownloader，NetworkDeniedImageDownloader
BaseImageDownloader	基本的图片下载类，支持网络，assets, content, drawable等图片获取
SlowNetworkImageDownloader	底网速下图片获取
BitmapDisplayer	图片显示抽象类，包括各种图片显示效果，比如最普通的显示图片，圆角图片显示等

1.3 代码包及其含义

包名	作用
com.nostra13.universalimageloader.cache.disc	磁盘缓存命名和存储的算法实现，比如md5和hashcode名称，限制使用时间存储等
com.nostra13.universalimageloader.cache.memory	内存缓存算法的实现类，包括先进先出，Lru等算法
com.nostra13.universalimageloader.core	ImageLoader的核心代码和主要工作流程类，比如ImageLoader,ImageLoaderConfiguration,ImageLoaderEngine等。
com.nostra13.universalimageloader.core.assist	辅助类，
com.nostra13.universalimageloader.core.decode	解码，比如从磁盘文件解码成Bitmap
com.nostra13.universalimageloader.core.display	图片显示效果类，比如圆角，淡入效果等
com.nostra13.universalimageloader.core.download	图片下载类，支持网络下载图片，文件读取图片，assets图片，drawable,已经contentProvider读取图片
com.nostra13.universalimageloader.core.imageaware	ImageView的封装，提供了对ImageView的便捷操作，比如获取ImageView高度宽度，是否被回收等
com.nostra13.universalimageloader.core.listener	监听器，包括图片加载监听，加载进度监听，列表滑动监听
com.nostra13.universalimageloader.core.process	外放给调用者处理图片的能力，获取到图片之后，在显示之前，调用者可以设置此监听器，处理图片，比如切割图片。
com.nostra13.universalimageloader.utils	工具类

4 图片加载序列图

二. 简单使用

https://www.cnblogs.com/yimi-yangguang/p/5715350.html

2.1 Application

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(this)
                .memoryCacheExtraOptions(480, 800) // default = device screen ，默认为屏幕宽高 dimensions，内存缓存的最大宽高
                .diskCacheExtraOptions(480, 800, null)//磁盘缓存最大宽高,默认不限制
                .threadPriority(Thread.NORM_PRIORITY - 2) // default //线程优先级
                .denyCacheImageMultipleSizesInMemory() //阻止内存中多尺寸缓存
                .memoryCacheSize(2 * 1024 * 1024) //配置缓存大小
                .memoryCacheSizePercentage(13) // default //缓存百分比
                .diskCacheSize(50 * 1024 * 1024) //磁盘缓存大小，只在使用默认缓存有效
                .diskCacheFileCount(100)  //磁盘缓存文件数，只在使用默认缓存有效
                .writeDebugLogs() //打印调试日志
                .build();
       ImageLoader.getInstance().init(config);//初始化         
   }
}

2.2 加载图片

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ImageView imageView = findViewById(R.id.img_test);

        ImageLoader imageLoader = ImageLoader.getInstance();

        DisplayImageOptions options = new DisplayImageOptions.Builder()
                .showImageOnLoading(R.drawable.ic_launcher_background) // resource or drawable
                .showImageForEmptyUri(R.drawable.ic_launcher_background) // resource or drawable
                .showImageOnFail(R.drawable.ic_launcher_background) // resource or drawable
                .resetViewBeforeLoading(false)  // default
                .delayBeforeLoading(1000)
                .postProcessor(new BitmapProcessor() {
                    @Override
                    public Bitmap process(Bitmap bitmap) {
                        Log.d("sandy", "process bitmap...");
                        return bitmap;
                    }
                })
                .showImageOnLoading(R.drawable.ic_launcher_foreground)
                .cacheInMemory(false) // default
                .cacheOnDisk(false) // default
                .considerExifParams(false) // default
                .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default
                .bitmapConfig(Bitmap.Config.ARGB_8888) // default
                .build();

        imageLoader.displayImage("http://img3.imgtn.bdimg.com/it/u=2200166214,500725521&fm=27&gp=0.jpg",
                imageView, options, new ImageLoadingListener() {
                    @Override
                    public void onLoadingStarted(String imageUri, View view) {
                        Log.d("sandy", "onLoadingStarted imageUri: " + imageUri);
                    }

                    @Override
                    public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
                        Log.d("sandy", "onLoadingFailed imageUri: " + imageUri
                        + " failReason: " + failReason);
                    }

                    @Override
                    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                        Log.d("sandy", "onLoadingComplete imageUri: " + imageUri);
                    }

                    @Override
                    public void onLoadingCancelled(String imageUri, View view) {
                        Log.d("sandy", "onLoadingCancelled imageUri: " + imageUri);
                    }
                }, new ImageLoadingProgressListener(){
                    @Override
                    public void onProgressUpdate(String imageUri, View view, int current, int total) {
                        Log.d("sandy", "onProgressUpdate current: " + current + " total: " + total);
                    }
                });
    }
}

三. 流程分析-初始化

按照上面的使用方法，进行ImageLoader的源代码分析，首先看Application的onCreate里面ImageLoader的代码。

3.1 初始化ImageLoaderConfiguration

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(this)
                .memoryCacheExtraOptions(480, 800) // default = device screen ，默认为屏幕宽高 dimensions，内存缓存的最大宽高
                .diskCacheExtraOptions(480, 800, null)//磁盘缓存最大宽高,默认不限制
                .threadPriority(Thread.NORM_PRIORITY - 2) // default //线程优先级
                .denyCacheImageMultipleSizesInMemory() //阻止内存中多尺寸缓存
                .memoryCacheSize(2 * 1024 * 1024) //配置缓存大小
                .memoryCacheSizePercentage(13) // default //缓存百分比
                .diskCacheSize(50 * 1024 * 1024) //磁盘缓存大小，只在使用默认缓存有效
                .diskCacheFileCount(100)  //磁盘缓存文件数，只在使用默认缓存有效
                .writeDebugLogs() //打印调试日志
                .build();

这是一个典型的构造者模式，构造者模式一般适用于属性比较多的场景。

在设置完各种属性后，最后来看看build方法。

3.1.1 build

/** Builds configured {@link ImageLoaderConfiguration} object */
public ImageLoaderConfiguration build() {
   initEmptyFieldsWithDefaultValues();
   return new ImageLoaderConfiguration(this);
}

首先会调用initEmptyFieldsWithDefaultValues，如果用户没有设置一些属性，那么就会为他们初始化默认值。

private void initEmptyFieldsWithDefaultValues() {
            if (taskExecutor == null) {
                taskExecutor = DefaultConfigurationFactory
                        .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);
            } else {
                customExecutor = true;
            }
            if (taskExecutorForCachedImages == null) {
                taskExecutorForCachedImages = DefaultConfigurationFactory
                        .createExecutor(threadPoolSize, threadPriority, tasksProcessingType);
            } else {
                customExecutorForCachedImages = true;
            }
            if (diskCache == null) {
                if (diskCacheFileNameGenerator == null) {
                    diskCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();
                }
                diskCache = DefaultConfigurationFactory
                        .createDiskCache(context, diskCacheFileNameGenerator, diskCacheSize, diskCacheFileCount);
            }
            if (memoryCache == null) {
                memoryCache = DefaultConfigurationFactory.createMemoryCache(context, memoryCacheSize);
            }
            if (denyCacheImageMultipleSizesInMemory) {
                memoryCache = new FuzzyKeyMemoryCache(memoryCache, MemoryCacheUtils.createFuzzyKeyComparator());
            }
            if (downloader == null) {
                downloader = DefaultConfigurationFactory.createImageDownloader(context);
            }
            if (decoder == null) {
                decoder = DefaultConfigurationFactory.createImageDecoder(writeLogs);
            }
            if (defaultDisplayImageOptions == null) {
                defaultDisplayImageOptions = DisplayImageOptions.createSimple();
            }
        }

最后build方法可以产生出一个ImageLoaderConfiguration对象

return new ImageLoaderConfiguration(this);

得到ImageLoaderConfiguration这个配置对象后，接下来就会利用它来初始化ImageLoader

ImageLoader.getInstance().init(config);//初始化

继续往下分析，首先看ImageLoader.getInstance()

3.2 ImageLoader.getInstance()

ImageLoader imageLoader = ImageLoader.getInstance();

继续看ImageLoader.getInstance()方法

3.2.1 ImageLoader.getInstance

/** Returns singleton class instance */
    public static ImageLoader getInstance() {
        if (instance == null) {
            synchronized (ImageLoader.class) {
                if (instance == null) {
                    instance = new ImageLoader();
                }
            }
        }
        return instance;
    }

getInstance可以看出是一个单例模式，而且是做了效率优化(两层if判断，第一层可以过滤大部分访问，从而减少进入synchronized锁的次数)。

3.3 ImageLoader.init(config)

/**
     * Initializes ImageLoader instance with configuration.

     * If configurations was set before ( {@link #isInited()} == true) then this method does nothing.

     * To force initialization with new configuration you should {@linkplain #destroy() destroy ImageLoader} at first.
     *
     * @param configuration {@linkplain ImageLoaderConfiguration ImageLoader configuration}
     * @throws IllegalArgumentException if configuration parameter is null
     */
    public synchronized void init(ImageLoaderConfiguration configuration) {
        if (configuration == null) {
            throw new IllegalArgumentException(ERROR_INIT_CONFIG_WITH_NULL);
        }
        if (this.configuration == null) {
            L.d(LOG_INIT_CONFIG);
            engine = new ImageLoaderEngine(configuration);
            this.configuration = configuration;
        } else {
            L.w(WARNING_RE_INIT_CONFIG);
        }
    }

根据注释，我们利用传入的configuration对象初始化ImageLoader，如果这个configuration之前已经被设置过(isInit=true)，那么就不会发生什么。

如果想用现在的configuration替换之前的configuration对象，那么需要先调用ImageLoader.destory()方法进行销毁。

如果一些正常的话，就出产生一个ImageLoaderEngine对象，

3.3.1 ImageLoaderEngine

private Executor taskExecutor;
private Executor taskExecutorForCachedImages;
private Executor taskDistributor;

ImageLoaderEngine(ImageLoaderConfiguration configuration) {
        this.configuration = configuration;

        taskExecutor = configuration.taskExecutor;
        taskExecutorForCachedImages = configuration.taskExecutorForCachedImages;

        taskDistributor = DefaultConfigurationFactory.createTaskDistributor();
    }

ImageLoaderEngine把传入的configuration保存起来，然后包含了几个Executor，用来执行各种异步任务，所以叫做Engine，发动机。

其中taskExecutor和taskExecutorForCachedImages是从configuration里面传进来的，那换句话就是说，是可以我们在configuration中配置的，然后自己也创建了一个taskDistributor 这个Executor。

这样Application里面初始化流程久分析完成了，接下来看Activity里面怎么使用ImageLoader

四. 流程分析-加载图片

先继续贴一段请求加载图片的代码，在Activity的onCreate里面。

首先

首先设置布局文件
findViewById找到想要展示图片的ImageView控件
初始化展示的配置，当然也可以不用，ImageLoader可以使用默认的。
调用imageLoader.displayImage方法请求加载图片，其中可以有图片地址，图片控件，展示配置参数，加载图片的监听器，加载进度监听器。

protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            ImageView imageView = findViewById(R.id.img_test);
            ImageLoader imageLoader = ImageLoader.getInstance();
            DisplayImageOptions options = new DisplayImageOptions.Builder()
                    .showImageOnLoading(R.drawable.ic_launcher_background) // resource or drawable
                    .showImageForEmptyUri(R.drawable.ic_launcher_background) // resource or drawable
                    .showImageOnFail(R.drawable.ic_launcher_background) // resource or drawable
                    .resetViewBeforeLoading(false)  // default
                    .delayBeforeLoading(1000)
                    .postProcessor(new BitmapProcessor() {
                        @Override
                        public Bitmap process(Bitmap bitmap) {
                            Log.d("sandy", "process bitmap...");
                            return bitmap;
                        }
                    })
                    .showImageOnLoading(R.drawable.ic_launcher_foreground)
    //                .displayer(new RoundedBitmapDisplayer(5))
                    .cacheInMemory(false) // default
                    .cacheOnDisk(false) // default
                    .considerExifParams(false) // default
                    .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default
                    .bitmapConfig(Bitmap.Config.ARGB_8888) // default
                    .build();

            imageLoader.displayImage("http://img3.imgtn.bdimg.com/it/u=2200166214,500725521&fm=27&gp=0.jpg",
                    imageView, options, new ImageLoadingListener() {
                        @Override
                        public void onLoadingStarted(String imageUri, View view) {
                            Log.d("sandy", "onLoadingStarted imageUri: " + imageUri);
                        }

                        @Override
                        public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
                            Log.d("sandy", "onLoadingFailed imageUri: " + imageUri
                            + " failReason: " + failReason);
                        }

                        @Override
                        public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                            Log.d("sandy", "onLoadingComplete imageUri: " + imageUri);
                        }

                        @Override
                        public void onLoadingCancelled(String imageUri, View view) {
                            Log.d("sandy", "onLoadingCancelled imageUri: " + imageUri);
                        }
                    }, new ImageLoadingProgressListener(){
                        @Override
                        public void onProgressUpdate(String imageUri, View view, int current, int total) {
                            Log.d("sandy", "onProgressUpdate current: " + current + " total: " + total);
                        }
                    });
        }

DisplayImageOptions图片展示参数，你可以不指定，也可以指定，表示一些展示的参数，比如默认图片(在网络图片还没有加载出来之前显示)，加载失败图片，是否从内存加载，这些后面再分析，不涉及流程的分析。

所以继续看ImageLoader.displayImage(xxx)方法

4.1 ImageLoader.displayImage

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

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

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
            ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        checkConfiguration();
        if (imageAware == null) {
            throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);
        }
        if (listener == null) {
            listener = defaultListener;
        }
        if (options == null) {
            options = configuration.defaultDisplayImageOptions;
        }

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

        if (targetSize == null) {
            targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
        }
        String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
        engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

        listener.onLoadingStarted(uri, imageAware.getWrappedView());

        Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);
        if (bmp != null && !bmp.isRecycled()) {
            L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);

            if (options.shouldPostProcess()) {
                ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                        options, listener, progressListener, engine.getLockForUri(uri));
                ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
                        defineHandler(options));
                if (options.isSyncLoading()) {
                    displayTask.run();
                } else {
                    engine.submit(displayTask);
                }
            } else {
                options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
                listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
            }
        } else {
            if (options.shouldShowImageOnLoading()) {
                imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
            } else if (options.isResetViewBeforeLoading()) {
                imageAware.setImageDrawable(null);
            }

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

4.2 ImageViewAware

在displayImage的时候，会使用ImageView对象，初始化一个ImageViewAware对象。

new ImageViewAware(imageView)

ImageViewAware的继承关系如下:

里面主要是做了一个View的弱引用，可以访问传入的ImageView的一些属性，比如高度宽度，设置显示图片等等。

protected Reference viewRef;

之所以搞出一个ImageViewAware，是因为ImageLoader想方便操作传入的ImageView对象。

下面来看displayImage(xx)里面具体的内容

4.3 displayImage条件判断

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
      ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
   checkConfiguration();
   if (imageAware == null) {
      throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);
   }
   if (listener == null) {
      listener = defaultListener;
   }
   if (options == null) {
      options = configuration.defaultDisplayImageOptions;
   }

   ...
}

private void checkConfiguration() {
   if (configuration == null) {
      throw new IllegalStateException(ERROR_NOT_INIT);
   }
}

首先会检查configuration，checkConfiguration，如果configuration==null，那么就会报错。也就是说如果没有调用之前我们说的ImageLoader.init()，初始化如下.

public synchronized void init(ImageLoaderConfiguration configuration) {
        if (configuration == null) {
            throw new IllegalArgumentException(ERROR_INIT_CONFIG_WITH_NULL);
        }
        if (this.configuration == null) {
            L.d(LOG_INIT_CONFIG);
            engine = new ImageLoaderEngine(configuration);
            this.configuration = configuration;
        } else {
            L.w(WARNING_RE_INIT_CONFIG);
        }
    }

然后imageAware是否null，如果null，那么就报错

接着检查，listener， options是否为null，如果是null，那么设置为default值。

继续往下面看代码

4.4 加载空图片地址

如果传入的图片地址是null，那么将走下面的的分支

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

上面这段代码做了下面几件事

清空engine里面取消对这个ImageAware的缓存
调用listener.onLoadingStarted，如果你传入了listener，那么这个时候就会回调。
判断options里面是否有为空时候的图片，如果有，那么就把ImageView设置这张图片
如果没有设置为空时候的图片，那么ImageView设置图片为null.
然后调用listener.onLoadingComplete方法

4.5 初始化ImageSize

if (targetSize == null) {
            targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
        }

public static ImageSize defineTargetSizeForView(ImageAware imageAware, ImageSize maxImageSize) {
        int width = imageAware.getWidth();
        if (width <= 0) width = maxImageSize.getWidth();

        int height = imageAware.getHeight();
        if (height <= 0) height = maxImageSize.getHeight();

        return new ImageSize(width, height);
    }

根据传入的ImageView获取高度和宽度，如果没有宽度和高度，就用最大的宽度和高度。

4.6 获取Image Memory key

private static final String URI_AND_SIZE_SEPARATOR = "_";
private static final String WIDTH_AND_HEIGHT_SEPARATOR = "x";

String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);

public static String generateKey(String imageUri, ImageSize targetSize) {
        return new StringBuilder(imageUri).append(URI_AND_SIZE_SEPARATOR).append(targetSize.getWidth()).append(WIDTH_AND_HEIGHT_SEPARATOR).append(targetSize.getHeight()).toString();
    }

产生Image Key的方式是: 图片URL_图片宽度x图片高度

4.7 缓存ImageAware和Image Memory Key

engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

void prepareDisplayTaskFor(ImageAware imageAware, String memoryCacheKey) {
        cacheKeysForImageAwares.put(imageAware.getId(), memoryCacheKey);
    }

4.8 通知Listener回调onLoadingStarted

listener.onLoadingStarted(uri, imageAware.getWrappedView());

4.9 根据Memory Key从缓存里面获取图片

Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);

final MemoryCache memoryCache;

public interface MemoryCache {
    /**
     * Puts value into cache by key
     *
     * @return true - if value was put into cache successfully, false - if value was not put into
     * cache
     */
    boolean put(String key, Bitmap value);

    /** Returns value by key. If there is no value for key then null will be returned. */
    Bitmap get(String key);

    /** Removes item by key */
    Bitmap remove(String key);

    /** Returns all keys of cache */
    Collection keys();

    /** Remove all items from cache */
    void clear();
}

MemoryCache是图片内存缓存的一个接口，包括多种实现机制，比如Lru, FIFO, LargestLimited等，如下图:

具体缓存算法可以后续分析

4.10 从内存中获取到图片

if (bmp != null && !bmp.isRecycled()) {
            L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);

            if (options.shouldPostProcess()) {
                ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                        options, listener, progressListener, engine.getLockForUri(uri));
                ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
                        defineHandler(options));
                if (options.isSyncLoading()) {
                    displayTask.run();
                } else {
                    engine.submit(displayTask);
                }
            } else {
                options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
                listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
            }
        }

如果从内存里面获取到了图片，那么就准备显示，又分成两种情况，看业务需不需要重新处理图片，如果图片显示选项设置了shouldPostProcess，就像

DisplayImageOptions options = new DisplayImageOptions.Builder()
                .postProcessor(new BitmapProcessor() {
                    @Override
                    public Bitmap process(Bitmap bitmap) {
                        Log.d("sandy", "process bitmap...");
                        return bitmap;
                    }
                })

那么就产生一个ProcessAndDisplayImageTask

final class ProcessAndDisplayImageTask implements Runnable {
    ...
    @Override
    public void run() {
        L.d(LOG_POSTPROCESS_IMAGE, imageLoadingInfo.memoryCacheKey);

        //获取图片显示选项中的processor对象
        BitmapProcessor processor = imageLoadingInfo.options.getPostProcessor();
        //回调processor.process来处理图片
        Bitmap processedBitmap = processor.process(bitmap);
        DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(processedBitmap, imageLoadingInfo, engine,
                LoadedFrom.MEMORY_CACHE);
        LoadAndDisplayImageTask.runTask(displayBitmapTask, imageLoadingInfo.options.isSyncLoading(), handler, engine);
    }
}

在ProcessAndDisplayImageTask里面首先获取到BitmapProcessor

BitmapProcessor processor = imageLoadingInfo.options.getPostProcessor();

然后回调processor.process方法()

Bitmap processedBitmap = processor.process(bitmap);

然后新建一个DisplayBitmapTask对象，用来显示图片和回调listener的回调方法，如下:

final class DisplayBitmapTask implements Runnable {
    @Override
    public void run() {
        if (imageAware.isCollected()) {
            L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
            listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
        } else if (isViewWasReused()) {
            L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
            listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
        } else {
            L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
            displayer.display(bitmap, imageAware, loadedFrom);
            engine.cancelDisplayTaskFor(imageAware);
            listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
        }
    }
}

那如果使用者不需要自己另外处理图片，那么就直接显示好了。

if (options.shouldPostProcess()) {
    ...
} else {
    options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
    listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
}

4.11 内存中没有图片

如果内存中没有获取到图片，比如第一次加载图片，那该怎么办呢？

if (bmp != null && !bmp.isRecycled()) {
            ...
        } else {
            if (options.shouldShowImageOnLoading()) {
                imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
            } else if (options.isResetViewBeforeLoading()) {
                imageAware.setImageDrawable(null);
            }

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

先判断是否需要在加载图片的过程中，显示loading图片，如果是，那么先显示loading图片。
如果需要在加载前先清空图片，那么就把ImageView显示图片设置成null。
然后封装出一个ImageLoadingInfo对象，因为要操作的属性是在有点多。
然后封装出一个LoadAndDisplayImageTask对象，接下来所有的逻辑就封装在LoadAndDisplayImageTask对象里面，我们重点看LoadAndDisplayImageTask的实现。

4.12 LoadAndDisplayImageTask加载和显示图片

final class LoadAndDisplayImageTask implements Runnable, IoUtils.CopyListener {
    @Override
    public void run() {
        if (waitIfPaused()) return;
        if (delayIfNeed()) return;

        ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
        L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);
        if (loadFromUriLock.isLocked()) {
            L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);
        }

        loadFromUriLock.lock();
        Bitmap bmp;
        try {
            checkTaskNotActual();

            bmp = configuration.memoryCache.get(memoryCacheKey);
            if (bmp == null || bmp.isRecycled()) {
                bmp = tryLoadBitmap();
                if (bmp == null) return; // listener callback already was fired

                checkTaskNotActual();
                checkTaskInterrupted();

                if (options.shouldPreProcess()) {
                    L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);
                    bmp = options.getPreProcessor().process(bmp);
                    if (bmp == null) {
                        L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);
                    }
                }

                if (bmp != null && options.isCacheInMemory()) {
                    L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);
                    configuration.memoryCache.put(memoryCacheKey, bmp);
                }
            } else {
                loadedFrom = LoadedFrom.MEMORY_CACHE;
                L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);
            }

            if (bmp != null && options.shouldPostProcess()) {
                L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);
                bmp = options.getPostProcessor().process(bmp);
                if (bmp == null) {
                    L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);
                }
            }
            checkTaskNotActual();
            checkTaskInterrupted();
        } catch (TaskCancelledException e) {
            fireCancelEvent();
            return;
        } finally {
            loadFromUriLock.unlock();
        }

        DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
        runTask(displayBitmapTask, syncLoading, handler, engine);
    }
}

4.12.1 首先判断waitIfPaused，engine是否在暂停状态，如果是，那么就直接return了。

if (waitIfPaused()) return;

4.12.2 然后根据图片显示参数里面判断这次请求是否需要延迟，如果是，那么就延迟指定的时间。

if (delayIfNeed()) return;

private boolean delayIfNeed() {
   if (options.shouldDelayBeforeLoading()) {
      L.d(LOG_DELAY_BEFORE_LOADING, options.getDelayBeforeLoading(), memoryCacheKey);
      try {
         Thread.sleep(options.getDelayBeforeLoading());
      } catch (InterruptedException e) {
         L.e(LOG_TASK_INTERRUPTED, memoryCacheKey);
         return true;
      }
      return isTaskNotActual();
   }
   return false;
}

4.12.3 根据Uri进行锁操作

loadFromUriLock.lock();

loadFromUriLock是ImageLoader里面和uri关联的，所以这里锁的话意味着同一个uri,一个时间只能有一个请求。

ReentrantLock getLockForUri(String uri) {
        ReentrantLock lock = uriLocks.get(uri);
        if (lock == null) {
            lock = new ReentrantLock();
            uriLocks.put(uri, lock);
        }
        return lock;
    }

4.12.4 检查ImageView是否被回收

try {
    checkTaskNotActual();
    ...
} catch (TaskCancelledException e) {
    fireCancelEvent();
    return;
} finally {
    loadFromUriLock.unlock();
}

private void checkTaskNotActual() throws TaskCancelledException {
   checkViewCollected();
   checkViewReused();
}

如果ImageView已经被回收，那就没必要去请求图片加载了，直接抛异常，然后catch住，结束task任务

private void checkViewCollected() throws TaskCancelledException {
   if (isViewCollected()) {
      throw new TaskCancelledException();//会被上面的catch捕获
   }
}

4.12.5 再次从内存里面读取图片

bmp = configuration.memoryCache.get(memoryCacheKey);

那为什么需要再次从内存里面读取图片呢，还记得上面这个锁吗？如果是同一个url，发起两个请求，那么就会锁住一个，第二个请求形成等待，在等待完成后，那么正常的话就会从内存里面读取到图片，不要从网络上再次请求。

4.12.6 从内存中成功获取到图片

if (bmp == null || bmp.isRecycled()) {
   ...
} else {
   loadedFrom = LoadedFrom.MEMORY_CACHE;
   L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);
}

我们先不分析if分支，if分支是从内存中没有获取到图片，先看else

else里面没有做什么事情，只是简单的打印了一下日志(经过等待从内存中获取图片成功)，然后把获取的类型设置成LoadedFrom.MEMORY_CACHE。

LoadedFrom包括3种类型，网络，磁盘，内存。可以参考文章最开始的概念介绍。

4.12.7 如果从内存中没有获取图片

如果从内存里面没有获取到图片，那就走if分支，也就是bmp == null || bmp.isRecycled()

if (bmp == null || bmp.isRecycled()) {
   bmp = tryLoadBitmap();
   if (bmp == null) return; // listener callback already was fired

   checkTaskNotActual();
   checkTaskInterrupted();

   if (options.shouldPreProcess()) {
      L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);
      bmp = options.getPreProcessor().process(bmp);
      if (bmp == null) {
         L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);
      }
   }

   if (bmp != null && options.isCacheInMemory()) {
      L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);
      configuration.memoryCache.put(memoryCacheKey, bmp);
   }
} else {
   ...
}

首先就会看到 bmp = tryLoadBitmap(); 尝试获取Bitmap，这个方法包含的东西很多，我们可以待会再讲。我们先看if分支后面的逻辑。

如果没有获取到bmp，比如指定的Uri是错误，那么就直接返回。

接下来继续判断ImageView是否被回收以及线程是否被中断，如果都通过之后，那么就判断是否需要处理图片，如果需要，那么就回调processor.process(bmp)来处理图片。

bmp = options.getPreProcessor().process(bmp);

最后，判断bmp != null以及是否需要存入内存(调用的地方可以设置是否需要存入内存)，如果需要的话(一般都需要)，那么就会存入内存缓存。

存入内存缓存后，那么下次就可以从内存中获取了图片了。

那接下来分析tryLoadBitmap()

4.12.8 tryLoadBitmap

先来大概说下思路，首先会去磁盘上获取图片，如果没有则从网络获取，获取完毕后，会存入磁盘，下面来看代码。

private Bitmap tryLoadBitmap() throws TaskCancelledException {
   Bitmap bitmap = null;
   try {
      File imageFile = configuration.diskCache.get(uri);
      if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
         L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);
         loadedFrom = LoadedFrom.DISC_CACHE;

         checkTaskNotActual();
         bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));
      }
      if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
         L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);
         loadedFrom = LoadedFrom.NETWORK;

         String imageUriForDecoding = uri;
         if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {
            imageFile = configuration.diskCache.get(uri);
            if (imageFile != null) {
               imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());
            }
         }

         checkTaskNotActual();
         bitmap = decodeImage(imageUriForDecoding);

         if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
            fireFailEvent(FailType.DECODING_ERROR, null);
         }
      }
   } catch (IllegalStateException e) {
      fireFailEvent(FailType.NETWORK_DENIED, null);
   } catch (TaskCancelledException e) {
      throw e;
   } catch (IOException e) {
      L.e(e);
      fireFailEvent(FailType.IO_ERROR, e);
   } catch (OutOfMemoryError e) {
      L.e(e);
      fireFailEvent(FailType.OUT_OF_MEMORY, e);
   } catch (Throwable e) {
      L.e(e);
      fireFailEvent(FailType.UNKNOWN, e);
   }
   return bitmap;
}

首先是尝试从磁盘获取

File imageFile = configuration.diskCache.get(uri);

如果获取到了，那么读取这个文件，读出Bitmap，同时把类型标记成从磁盘读取。

if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
   L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);
   loadedFrom = LoadedFrom.DISC_CACHE;

   checkTaskNotActual();
   bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));
}

如果从磁盘上面获取是失败，获取磁盘上面没有这个文件，那么bitmap == null

于是，就会从网络上尝试获取图片，如下：

if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
   L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);
   loadedFrom = LoadedFrom.NETWORK;

   String imageUriForDecoding = uri;
   if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {
      imageFile = configuration.diskCache.get(uri);
      if (imageFile != null) {
         imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());
      }
   }

   checkTaskNotActual();
   bitmap = decodeImage(imageUriForDecoding);

   if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
      fireFailEvent(FailType.DECODING_ERROR, null);
   }
}

先把类型设置成网络获取 loadedFrom = LoadedFrom.NETWORK;
然后尝试从网络获取图片并缓存图片到磁盘上-tryCacheImageOnDisk，对于这个方法的名称持保守态度，怪怪的。
然后解析出bitmap
bitmap = decodeImage(imageUriForDecoding);

4.12.9 tryCacheImageOnDisk下载图片并存入磁盘

/** @return true - if image was downloaded successfully; false - otherwise */
private boolean tryCacheImageOnDisk() throws TaskCancelledException {
   L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);

   boolean loaded;
   try {
      loaded = downloadImage();
      if (loaded) {
         int width = configuration.maxImageWidthForDiskCache;
         int height = configuration.maxImageHeightForDiskCache;
         if (width > 0 || height > 0) {
            L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);
            resizeAndSaveImage(width, height); // TODO : process boolean result
         }
      }
   } catch (IOException e) {
      L.e(e);
      loaded = false;
   }
   return loaded;
}

private boolean downloadImage() throws IOException {
   InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader());
   if (is == null) {
      L.e(ERROR_NO_IMAGE_STREAM, memoryCacheKey);
      return false;
   } else {
      try {
         return configuration.diskCache.save(uri, is, this);
      } finally {
         IoUtils.closeSilently(is);
      }
   }
}

首先从网络下载图片downloadImage
把图片存入磁盘resizeAndSaveImage(width, height);

那从网络下载图片并存入磁盘和内存的代码就分析完了，最后回到上面LoadAndDisplayImageTask.run方法，看看后面的代码。

4.13 给调用者处理图片

if (bmp != null && options.shouldPostProcess()) {
   L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);
   bmp = options.getPostProcessor().process(bmp);
   if (bmp == null) {
      L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);
   }
}

图片已经拿到了，所以如果需要回调处理图片的话，现在回调一次。

4.14 显示图片

DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
runTask(displayBitmapTask, syncLoading, handler, engine);

创建了一个 DisplayBitmapTask来显示图片

final class DisplayBitmapTask implements Runnable {
    private final BitmapDisplayer displayer;
    ...

   @Override
   public void run() {
      if (imageAware.isCollected()) {
         L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
         listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
      } else if (isViewWasReused()) {
         L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
         listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
      } else {
         L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
         displayer.display(bitmap, imageAware, loadedFrom);
         engine.cancelDisplayTaskFor(imageAware);
         listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
      }
   }
}

显示图片的时候又封装了一个displayer, displayer封装了图片显示的效果，比如圆角之类的。

你可能感兴趣的:(Image,Loader,源代码,Android应用开发)

webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
vue3中el-table中点击图片放大时，被表格覆盖叫我小鹏呀 vue.js javascript 前端
问题：vue3中el-table中点击图片放大时，被表格覆盖。解决方法：el-image添加preview-teleported
python tif转png Python与遥感 python 开发语言
importosfromosgeoimportgdalimportnumpyasnpfromPILimportImage#提取432三波段fromspectralimport*#输入文件夹路径defget_img(dataset_img):width=dataset_img.RasterXSize#获取行列数height=dataset_img.RasterYSizebands=dataset_i
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
详解：如何设计出健壮的秒杀系统？夜空_2cd3
作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
2020年学习什么知识比较好？互联网行业依然是发展较佳编程仔
2019年余额已不足，不少职场人心里也在盘点这一年的工作得失，琢磨新一年的奋斗策略，是继续冲刺还是换个跑道？今年跳槽更难吗？image互联网行业一直以相对较丰厚的薪酬和广阔的发展前景吸引着各界人才。但最近，互联网行业寒冬、互联网企业裁员等话题再次引起热议。正在从前些年的高速发展期转向发展调整期的互联网行业真的步入了“寒冬”？该行业依旧具有吸引力吗？什么职位又最热门呢？image互联网行业仍保持较高
uniapp使用内置地图选择插件，实现地址选择并在地图上标点神夜大侠 Uniapp vue.js uniapp
uniapp使用内置地图选择插件，实现地址选择并在地图上标点代码如下：page{background:#F4F5F6;}::-webkit-scrollbar{width:0;height:0;color:transparent;}page{height:100%;width:100%;font-size:24rpx;}image,view,input,textarea,label,text,na
KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
idea使用自定义checkstyle.xml配置文件 Gemkey
1.下载插件image.png2.插件安装完后,找到设置中的checkstyle,点击"+",新增自定义规则image.png3.输入描述信息,点击Browse找到对应的文件image.pngimage.png4.可以把active勾上,则使用默认校验规则,点击OK,则可以开始使用自定义规则检测单个文件了image.png
Scanpy源码浅析之pp.normalize_total 何物昂
版本导入Scanpy,其版本为'1.9.1'，如果你看到的源码和下文有差异，其可能是由于版本差异。importscanpyasscsc.__version__#'1.9.1'例子函数pp.normalize_total用于Normalizecountspercell，其源代码在scanpy/preprocessing/_normalization.py我们通过一个简单例子来了解该函数主要功能:将一
使用input[type=file]遇上的一些问题刘圣凯
项目遇到一个需要，如下image.png功能大致就是添加图片，展示出来，然后在用户点击提交的时候把图片传给后台，在和后台交涉之后，决定在用户选择图片之后转成formdata传给后台，后台返回一个url，提交的时候将url返回给后台/**转formdata*/varformdata=newFormData();formdata.append("file1",$("#pic")[0].files[0]
爬虫技术抓取网站数据 Bearjumpingcandy 爬虫
爬虫技术是指通过程序自动访问网页并提取数据的技术。一般来说，爬虫技术包含以下几个步骤：确定目标网站：确定需要抓取的网站，并了解其页面结构和数据特点。分析页面结构：分析网页的结构和源代码，找到需要抓取的数据在页面中的位置和标识。编写爬虫程序：使用编程语言（如Python）编写爬虫程序，实现对目标网站的自动访问和数据提取。处理抓取数据：对抓取到的数据进行清洗、去重、整合等处理，以便后续的分析和利用。爬
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
SPI机制我们仍未知道那天所看见的猫的名
1、SPI机制：ServiceProviderInterface：服务提供发现机制，类型IOCJavaSPI实现：ServiceLoader定义接口A；实现接口A的实现类，B和C；在/META-INF/services/下创建文件，文件名为A类的全名称，内容为B和C的类全名调用：ServiceLoaderload=ServiceLoader.load(A.class);Interatori=loa
小米嵌入式面试题目RTOS面试题目嵌入式面试题目好家伙VCC 面试杂谈杂谈面试职场和发展
第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转 kVfINoSzdrt fpga开发程序人生
fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
好看的vue登录页面(附源代码背景图) 小小薛定谔 vue.js javascript css 前端
一、效果展示二、代码你好!欢迎回来登录忘记密码?注册exportdefault{name:"MedLogin",data(){return{confirm_disabled:false,loginForm:{no:'',password:''},rules:{no:[{required:true,message:'请输入账号',trigger:'blur'},{min:3,max:6,messag
MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码捕鲸叉 QT macos c++QT
安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
【代码模板】可视化 xuanyu22 SOP opencv 计算机视觉人工智能
PillowDocumentdataformat-(H,W,C),RGBdatadtype-np.uint8valuerange-(0,255)fromPILimportImage#Readimagesimg=Image.open("img.png").convert('RGB')#读取RGB图像img=Image.open("img.png").convert('L')#读取灰度图像(H,W)u
uniapp实现IM即时通讯仿微信聊天功能即构开发者
本文介绍如何基于UNIAPP使用即时通讯SDKZIMSDK快速实现基本的消息收发功能。1uniappim即时通讯功能方案介绍即时通讯SDKZIMSDK提供了如下接入方案：image.png在此方案中，您需要通过您自己的业务系统实现以下业务逻辑：搭建客户端的用户管理逻辑，并下发用户ID用于客户端登录。鉴权Token，建议由您的业务后台自行实现，保证鉴权数据安全。uni-appSDK是一个基于原生iO
利用Python+OpenCV实现截图匹配图像，支持自适应缩放、灰度匹配、区域匹配、匹配多个结果 xu-jssy Python自动化脚本 python opencv 开发语言图像处理自动化
可以直接通过pip获取，无需手动安装其他依赖pipinstallxug示例：importxugxug.find_image_on_screen(,,,)=========================================================================一、依赖安装pipinstallopencv-pythonpipinstallpyautogui二、获
Linux命令行基础——软件包管理 HHwxtx linux 运维服务器
1.软件包管理的发展初始阶段最早的软件包管理可以追溯到Unix系统的早期版本。在那时，软件通常以源代码的形式分发，并由系统管理员手动编译和安装。这种方式的管理比较原始和繁琐，因为每次安装都需要手动解决依赖关系和编译问题。软件包的引入为了简化安装过程，软件包被引入Linux，它将软件及其所有文件和资源打包在一起的集合，通常包括可执行文件、库文件、配置文件、文档和元数据（如软件名称、版本号、依赖关系等
外卖分销分佣小程序外卖cps小程序返利系统源码分享 m0_56957302 java 小程序 linux python docker
外卖返利小程序源码;轻松部署搭建，小程序服务号数据互通；对接美团官方;佣金比例自定义分配;三级分佣，所有资金数据一目了然；拉新立减最低4.9元购月卡；签到20天免费领取会员卡；提现秒到账！外卖cps带分销返利源码源代码地址美团/饿了么外卖CPS联盟返利公众号小程序裂变核心源码截图步骤下载以上源代码到本地http://y.mybei.cn/修改为你自己的微信小程序，打开/dist/pages/ele
Axure移动端原型模板实例100+，APP原型设计模版，高保真高交互含大组件库默林工作室 AxureRP原型模板 axure 原型模板
作品概况页面数量：共100+页（长期更新中…）源文件格式：rp格式，兼容AxureRP9/10，非程序软件无源代码适用领域：APP、小程序、H5作品特色本品为「移动端原型模板实例100+」，属于APP+H5+小程序的页面实例原型模板，主要运用了中继器＋动态面板，栏目丰富样式多多，高保真高交互高复用（带仿真交互），可以快速组装成美观大方的原型图。该原型模板的页面尺寸为375×812像素，推荐演示设备
测试平台系列(24) 编写成员管理功能米洛丶
回顾上一节我们编写了项目设置相关功能，还剩下2个tab没有编写，分别是:用例列表和成员管理.编写成员列表及部分接口添加成员搜索成员编辑成员删除成员今天因为时间关系就不展示删除成员了，只编写编辑/新增成员接口和页面。编写新增/编辑角色的方法由于之前我们已经编辑过新增角色的方法了，但是需要修改一点:image这里角色的筛选条件不能加上，为什么呢？因为加上的话，我可以创建同一个user_id的不同角色，
ResNet的半监督和半弱监督模型 Valar_Morghulis
Billion-scalesemi-supervisedlearningforimageclassificationhttps://arxiv.org/pdf/1905.00546.pdfhttps://github.com/facebookresearch/semi-supervised-ImageNet1K-models/权重在timm中也有：https://hub.fastgit.org/r
Github官方桌面客户端 zwb_jianshu
GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名gitHub。如果你是一名程序员，那么一定会听过或用过现在最流行的版本控制工具GIT！而GitHub.com则是目前全球最热门的公共代码仓库网站，多到数不清的知名开源项目源代码都是托管在它上面。GitHubDesktop免费的Github官方桌面客户端首先，我先对GitHub来一个简单的介绍，Gi
Swift4.0: 利用图形上下文画基础图? Dayu大鱼
步骤:开启图片上下文获取上下文配置上下文3.1填充颜色cgColor3.2填充尺寸从图形上下文中获取图片关闭上下文返回图片importFoundationimportUIKitextensionUIImage{///画一个白色背景的图片classfuncimageWithWhiteBackGroundColor()->UIImage{//开始图形上下文UIGraphicsBeginImageCon
PCL 怎样可视化深度图像 LeonDL168 PCL 计算机视觉人工智能视觉检测图像处理算法
本小节讲解如何可视化深度图像的两种方法，在3D视窗中以点云形式进行可视化（深度图像来源于点云），另一种是，将深度值映射为颜色，从而以彩色图像方式可视化深度图像。代码首先，在PCL（PointCloudLearning）中国协助发行的书提供光盘的第7章例2文件夹中，打开名为range_image_visualization.cpp的代码文件，同文件夹下可以找到相关的测试点云文件room_scan1.
python-opencv cv2.findContours()函数 fjswcjswzy opencv python笔记 python opencv
示例代码：image,contours,hierarchy=cv2.findContours(contour,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)输入：contour：带有轮廓信息的图像；cv2.RETR_TREE：提取轮廓后，输出轮廓信息的组织形式，除了cv2.RETR_TREE还有以下几种选项：cv2.RETR_EXTERNAL：输出轮廓中只有外侧轮廓信
java杨辉三角 3213213333332132 java基础
package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
《大话重构》之大布局的辛酸历史白糖_ 重构
《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。背景公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频 ed2k
本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
Javascript中函数的toString()方法周凡杨 JavaScript js toString function object
简述 The toString() method returns a string representing the source code of the function. 简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。句法 function.
struts处理自定义异常 g21121 struts
很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
Linux中find常见用法示例 510888780 linux
Linux中find常见用法示例 ·find path -option [ -print ] [ -exec -ok command ] {} \; find命令的参数；
SpringMVC的各种参数绑定方式 Harry642 springMVC 绑定表单
1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
Java 获取Oracle ROWID aijuans java oracle
A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
java获取方法的参数名 antlove java jdk parameter method reflect
reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
JAVA正则表达式匹配查找替换提取操作百合不是茶 java 正则表达式替换提取查找
正则表达式的查找;主要是用到String类中的split(); String str; str.split();方法中传入按照什么规则截取,返回一个String数组常见的截取规则: str.split("\\.")按照.来截取 str.
Java中equals()与hashCode()方法详解 bijian1013 java set equals()hashCode()
一.equals()方法详解 equals()方法在object类中定义如下： public boolean equals(Object obj) { return (this == obj); } 很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle 数据库 plsql
--工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
Nginx作为静态文件HTTP服务器在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片在主配置文件中添加http指令 http { server { listen 80; server_name
kafka获得最新partition offset blackproof kafka partition offset 最新
kafka获得partition下标，需要用到kafka的simpleconsumer import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
centos 7安装docker两种方式 ronin47
第一种是采用yum 方式 yum install -y docker
java-60-在O(1)时间删除链表结点 bylijinnan java
public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
nginx利用proxy_cache来缓存文件 cfyme cache
user zhangy users; worker_processes 10; error_log /var/vlogs/nginx_error.log crit; pid /var/vlogs/nginx.pid; #Specifies the value for ma
[JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做： string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))" 定义一个0整数c,然后用这个整数c去
如何集成支付宝官方文档 dai_lm android
官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成调试的时候估计会真的扣款，请注意
应该在什么时候使用Hadoop datamachine hadoop
原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
在GridView中使用关联模型进行搜索和排序首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
使用NSString 的格式化大全 dcj3sjt126com Objective-C
格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
使用activeX插件对象object滚动有重影蕃薯耀 activeX插件滚动有重影
使用activeX插件对象object滚动有重影 <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
SpringMVC4零配置 hanqunfeng springmvc4
基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
问题引入上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
AngularJS浅析 kvhur JavaScript
概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
1.前言. jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
本文链接: http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。说一下，
C语言算法之水仙花数 qiufeihu c 算法
/** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
JSP指令 wyzuomumu jsp
jsp指令的一般语法格式： <%@ 指令名属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include