叮咚象JC
叮咚象JC

Glide V4 源码浅析（上）-- 主流程分析

1. Glide的作用

图片加载基本是每个APP都需要的基础功能，而在使用的过程中我们需要考虑到图片的加载方式、缓存、多媒体等问题，而Glide帮我们完成这一类的工作，并且提供了一套易用的API。

Glide的官方介绍如下：

Glide是一个快速高效的Android图片加载库，注重于平滑的滚动。Glide提供了易用的API，高性能、可扩展的图片解码管道（decode pipeline），以及自动的资源池技术。

总结起来它的优势如下：

  1. 可加载多媒体格式多样化，如Gif、Webp、Video等
  2. 加载过程绑定生命周期，通过生命周期管理实现更好的实现资源利用
  3. 高效缓存策略，拥有2层内存缓存和磁盘缓存。

2. Glide的使用方法

由于Glide的API十分灵活，开发者可以通过各种设置来达到不同加载效果，因此这里仅就最基础的使用方式进行分析，至于glide下载与安装可以直接参考官方项目地址下载安装最新版。

Glide项目地址：github

加载一张圆形图片

//初始化一个RequestOptions，并在其中通过circleCropTransform()设置圆形
RequestOptions mRequestOptions = new RequestOptions().circleCropTransform();
//通过Glide将图片地址为myUrl的图片以圆形的裁剪方式加载到imageView中
Glide.with(fragment)
    .load(myUrl)
    .apply(mRequestOptions)
    .into(imageView);

3. Glide的工作原理

根据上面的例子，Glide主要的流程如下图


Glide主要流程

短短几行代码就实现了将图片加载到我们指定地方，其中Glide框架帮我们完成了资源的不同类型（PNG、JPG、WEBP、GIF）和不同来源（网络、本地）的加载，以及对应的缓存策略。

3.1 Glide.with()

Glide.with()一共有个6重载方法，其中一个已经被标记为Deprecated了，分别对应在不同的情景下使用，每种重载方法的调用逻辑是一致的，都是先调用getRetriever()，之后再调用get()方法获取RequestManager，这里我们以比较常用的Activity作为例子

  public static RequestManager with(@NonNull Activity activity) {
    return getRetriever(activity).get(activity);
  }
3.1.1 如上文写的一样先调用getRetriever获取RequestManagerRetriever
  private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    //对传入的Context进行判空
    Preconditions.checkNotNull(
        context,
        "You cannot start a load on a not yet attached View or a Fragment where getActivity() "
            + "returns null (which usually occurs when getActivity() is called before the Fragment "
            + "is attached or after the Fragment is destroyed).");
    return Glide.get(context).getRequestManagerRetriever();
  }

其中在Glide.get(context)中，完成了对Glide单例的初始化

  //双重验证单例
  public static Glide get(@NonNull Context context) {
    if (glide == null) {
      synchronized (Glide.class) {
        if (glide == null) {
          checkAndInitializeGlide(context);
        }
      }
    }

    return glide;
  }

初始化Glide会在gilde.build()时创建RequestManagerRetriever

  @NonNull
  Glide build(@NonNull Context context) {
    //创建默认参数
    ......

    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);

    //创建将参数传入Glide的构造函数完成初始化
    ......
  }

RequestManagerRetriever根据官方注解的描述是一个用于创建或者获取现有的RequestManager的集合，此时我们在with()方法中通过getRetriever(activity)获取到生成的requestManagerRetriever.

3.1.2 再通过RequestManagerRetriever获取RequestManager.

RequestManagerRetriever的get()方法和with()方法一样拥有许多重载方法，我们还是继续以Activity为例

  public RequestManager get(@NonNull Activity activity) {
    if (Util.isOnBackgroundThread()) {
      //如果当前不在主线程，通过调用get(@NonNull Context context)调用getApplicationManager
      return get(activity.getApplicationContext());
    } else {
      assertNotDestroyed(activity);
      android.app.FragmentManager fm = activity.getFragmentManager();
      return fragmentGet(
          activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
  }
  
  
  private RequestManager fragmentGet(@NonNull Context context,
      @NonNull android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint,
      boolean isParentVisible) {
    RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      Glide glide = Glide.get(context);
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }

可见在调用Activity的get时实际是通过fragmentGet方法中的factory.build()产生返回的requestManager的。

 //RequestManagerRetriever的构造函数中创建了factory
 public RequestManagerRetriever(@Nullable RequestManagerFactory factory) {
    //若创建RequestManagerRetriever未传入RequestManagerFactory，则使用DEFAULT_FACTORY作为factory
    this.factory = factory != null ? factory : DEFAULT_FACTORY;
    handler = new Handler(Looper.getMainLooper(), this /* Callback */);
  }
  
 private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() {
    @NonNull
    @Override
    public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
        @NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) {
      //创建对应的RequestManager
      return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
    }
  };

在factory中通过new RequestManager()创建所需的RequestManager。至此Glide.with()分析完成

3.2 load()

在load方法中我们一般传入我们所需的资源文件，Glide提供了很多种重载方法用于兼容不同类型的加载方式，如Bitmap，Drawable，Uri等。
在RequestManager中对于load方法一般直接通过asDrawable().load(xxx)方法继续调用。当然除了asDrawable()，Glide还提供asFile()、asGif()、asBitmap()等方法。而他们最终都会调用到as(xxx)方法用于返回一个RequestBuilder

  public RequestBuilder asDrawable() {
    return as(Drawable.class);
  }
  
  public  RequestBuilder as(
      @NonNull Class resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
  }

因此上文中asDrawable().load(xxx)方法最终会调用到RequestBuilder中的load(xxx)方法,而这些方法无一例外会调用到loadGeneric()方法

  private RequestBuilder loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
  }

在loadGeneric仅对model进行了赋值，因此整个load()操作总结下主要作用如下：1.生成RequestBuilder，2.对传入model进行赋值保存。

3.3 apply()

我们使用 apply() 方法将我们自定义的requestOptions传入

  public RequestBuilder apply(@NonNull RequestOptions requestOptions) {
    Preconditions.checkNotNull(requestOptions);
    this.requestOptions = getMutableOptions().apply(requestOptions);
    return this;
  }
  
  //获取现有的RequestOptions
  protected RequestOptions getMutableOptions() {
    //如果目前的requestOptions与defaultRequestOptions一致则表明未进行修改，为了保证源文件不被修改，使用clone方法创建一个新的requestOptions回传回去
    return defaultRequestOptions == this.requestOptions
        ? this.requestOptions.clone() : this.requestOptions;
  }

由此可知最终会调用到RequestBuilder中RequestOptions的apply()方法

  public RequestOptions apply(@NonNull RequestOptions other) {
    if (isAutoCloneEnabled) {
      return clone().apply(other);
    }

    if (isSet(other.fields, SIZE_MULTIPLIER)) {
      sizeMultiplier = other.sizeMultiplier;
    }
    if (isSet(other.fields, USE_UNLIMITED_SOURCE_GENERATORS_POOL)) {
      useUnlimitedSourceGeneratorsPool = other.useUnlimitedSourceGeneratorsPool;
    }
    if (isSet(other.fields, USE_ANIMATION_POOL)) {
      useAnimationPool = other.useAnimationPool;
    }
    if (isSet(other.fields, DISK_CACHE_STRATEGY)) {
      diskCacheStrategy = other.diskCacheStrategy;
    }
    if (isSet(other.fields, PRIORITY)) {
      priority = other.priority;
    }
    if (isSet(other.fields, ERROR_PLACEHOLDER)) {
      errorPlaceholder = other.errorPlaceholder;
    }
    if (isSet(other.fields, ERROR_ID)) {
      errorId = other.errorId;
    }
    if (isSet(other.fields, PLACEHOLDER)) {
      placeholderDrawable = other.placeholderDrawable;
    }
    if (isSet(other.fields, PLACEHOLDER_ID)) {
      placeholderId = other.placeholderId;
    }
    if (isSet(other.fields, IS_CACHEABLE)) {
      isCacheable = other.isCacheable;
    }
    if (isSet(other.fields, OVERRIDE)) {
      overrideWidth = other.overrideWidth;
      overrideHeight = other.overrideHeight;
    }
    if (isSet(other.fields, SIGNATURE)) {
      signature = other.signature;
    }
    if (isSet(other.fields, RESOURCE_CLASS)) {
      resourceClass = other.resourceClass;
    }
    if (isSet(other.fields, FALLBACK)) {
      fallbackDrawable = other.fallbackDrawable;
    }
    if (isSet(other.fields, FALLBACK_ID)) {
      fallbackId = other.fallbackId;
    }
    if (isSet(other.fields, THEME)) {
      theme = other.theme;
    }
    if (isSet(other.fields, TRANSFORMATION_ALLOWED)) {
      isTransformationAllowed = other.isTransformationAllowed;
    }
    if (isSet(other.fields, TRANSFORMATION_REQUIRED)) {
      isTransformationRequired = other.isTransformationRequired;
    }
    if (isSet(other.fields, TRANSFORMATION)) {
      transformations.putAll(other.transformations);
      isScaleOnlyOrNoTransform = other.isScaleOnlyOrNoTransform;
    }
    if (isSet(other.fields, ONLY_RETRIEVE_FROM_CACHE)) {
      onlyRetrieveFromCache = other.onlyRetrieveFromCache;
    }

    // Applying options with dontTransform() is expected to clear our transformations.
    if (!isTransformationAllowed) {
      transformations.clear();
      fields &= ~TRANSFORMATION;
      isTransformationRequired = false;
      fields &= ~TRANSFORMATION_REQUIRED;
      isScaleOnlyOrNoTransform = true;
    }

    fields |= other.fields;
    options.putAll(other.options);

    return selfOrThrowIfLocked();
  }

在apply()方法中通过isSet方法比较对应的标志位的值从而对相应属性进行修改。此时apply()逻辑完成，主要用于对用户的设置进行配置。

3.4 into()

into()方法是我们此次分析流程中的最后一步，可以看到前文提到的with()、load()、apply()这些方法中均未涉及到图片的加载和显示过程，更多是做一些初始化和参数的配置。因此可以猜测缓存加载的相关操作应该是房子into()中

  public ViewTarget into(@NonNull ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);

    //省略部分代码，根据imageView的ScaleType设置相应的RequestOptions
    ......

    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions);
  }
  
  
  private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      @NonNull RequestOptions options) {
    Util.assertMainThread();
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    options = options.autoClone();
    //初始化Request
    Request request = buildRequest(target, targetListener, options);

    Request previous = target.getRequest();
    //将此次Request与之前的Request相比较看能否复用
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    //将当前生成的request赋值给target
    target.setRequest(request);
    //通过requestManager追踪target和request
    requestManager.track(target, request);

    return target;
  }
3.4.1 生成对应的ViewTarget

根据传入的view和上文提到资源类型(asDrawable()所传入的类型)生成一个对应的ViewTarget，通过glideContext.buildImageViewTarget的层层调用最终会调用到ImageViewTargetFactory中的buildTarget方法中

  public  ViewTarget buildTarget(@NonNull ImageView view,
      @NonNull Class clazz) {
    if (Bitmap.class.equals(clazz)) {
      return (ViewTarget) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
      return (ViewTarget) new DrawableImageViewTarget(view);
    } else {
      throw new IllegalArgumentException(
          "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
  }

这里会传入资源类型生成对应的ViewTarget

3.4.2 生成对应的request

通过buildRequest最终会调用buildRequestRecursive()方法

private Request buildRequestRecursive(
      Target target,
      @Nullable RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {

    // 根据使用glide加载图片时是否传入了errorBuilder(通过error()方法传入)来确定是否会生成errorRequestCoordinator
    ErrorRequestCoordinator errorRequestCoordinator = null;
    if (errorBuilder != null) {
      errorRequestCoordinator = new ErrorRequestCoordinator(parentCoordinator);
      parentCoordinator = errorRequestCoordinator;
    }

    //初始化mainRequest
    Request mainRequest =
        buildThumbnailRequestRecursive(
            target,
            targetListener,
            parentCoordinator,
            transitionOptions,
            priority,
            overrideWidth,
            overrideHeight,
            requestOptions);

    //如果未生成errorRequestCoordinator则直接返回mainRequest
    if (errorRequestCoordinator == null) {
      return mainRequest;
    }

    int errorOverrideWidth = errorBuilder.requestOptions.getOverrideWidth();
    int errorOverrideHeight = errorBuilder.requestOptions.getOverrideHeight();
    if (Util.isValidDimensions(overrideWidth, overrideHeight)
        && !errorBuilder.requestOptions.isValidOverride()) {
      errorOverrideWidth = requestOptions.getOverrideWidth();
      errorOverrideHeight = requestOptions.getOverrideHeight();
    }

    //如果errorRequestCoordinator存在则生成errorRequest并返回
    Request errorRequest = errorBuilder.buildRequestRecursive(
        target,
        targetListener,
        errorRequestCoordinator,
        errorBuilder.transitionOptions,
        errorBuilder.requestOptions.getPriority(),
        errorOverrideWidth,
        errorOverrideHeight,
        errorBuilder.requestOptions);
    errorRequestCoordinator.setRequests(mainRequest, errorRequest);
    return errorRequestCoordinator;
  }

这里我们可以看到生成request时会先通过errorBuilder存在与否分别返回不同的request，但无论返回哪个request，其中都需要mainRequest。

private Request buildThumbnailRequestRecursive(
      Target target,
      RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {
    //判断是否存在thumbnailBuilder，由此决定是否创建thumbRequest
    if (thumbnailBuilder != null) {
      //省略部分代码
      ......
      //创建thumbRequest
      Request thumbnailRequest =
          obtainRequest(
              target,
              targetListener,
              thumbnailOptions,
              coordinator,
              transitionOptions,
              getThumbnailPriority(priority),
              overrideWidth,
              overrideHeight);
      //将fullRequest和thumbnailRequest放入coordinator中
      coordinator.setRequests(fullRequest, thumbnailRequest);
      return coordinator;
    //若未传入对应的thumbnailBuilder判断是否传入对应的thumbSizeMultiplier(float类型的缩放比例)，与上方逻辑类似创建对应的thumbnailRequest并和fullRequest放入coordinator中，并返回。
    } else if (thumbSizeMultiplier != null) {
      //省略部分代码
    } else {
      // 若无thumbnail相关参数，则直接调用obtainRequest返回
      return obtainRequest(
          target,
          targetListener,
          requestOptions,
          parentCoordinator,
          transitionOptions,
          priority,
          overrideWidth,
          overrideHeight);
    }
  }

可见buildThumbnailRequestRecursive()逻辑与buildRequestRecursive逻辑类似，用于根据thumbnail生成对应的coordinator，但是对应的request的生成均是由obtainRequest()方法实现

private Request obtainRequest(
      Target target,
      RequestListener targetListener,
      RequestOptions requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight) {
    //调用了SingleRequest的obtain
    return SingleRequest.obtain(
        context,
        glideContext,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListener,
        requestCoordinator,
        glideContext.getEngine(),
        transitionOptions.getTransitionFactory());
  }
  
  
  //该方法最终会调用到SingleRequest的init()方法，该方法也仅仅是用于初始化赋值，并将request的状态改为PENDING
  private void init(
      Context context,
      GlideContext glideContext,
      Object model,
      Class transcodeClass,
      RequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target target,
      RequestListener targetListener,
      RequestListener requestListener,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory animationFactory) {
    this.context = context;
    this.glideContext = glideContext;
    this.model = model;
    this.transcodeClass = transcodeClass;
    this.requestOptions = requestOptions;
    this.overrideWidth = overrideWidth;
    this.overrideHeight = overrideHeight;
    this.priority = priority;
    this.target = target;
    this.targetListener = targetListener;
    this.requestListener = requestListener;
    this.requestCoordinator = requestCoordinator;
    this.engine = engine;
    this.animationFactory = animationFactory;
    status = Status.PENDING;
  }

经过多层嵌套，request的生成终于完成了，虽然代码量不少，但是整体逻辑还是比较清晰的，先根据是否有errorBuilder确定最外层的errorRequestCoordinator是否存在，再在buildThumbnailRequestRecursive()中是否有thumbnail相关参数来确定内部的coordinator是否存在。
如果两者均存在，则生成的request为ErrorRequestCoordinator(ThumbnailRequestCoordinator(fullRequest,thumbRequest),errorRequest)。

3.4.3 通过requestManager追踪target和request
  void track(@NonNull Target target, @NonNull Request request) {
    //分别用targetTracker 追踪 target，requestTracker 调用request
    targetTracker.track(target);
    requestTracker.runRequest(request);
  }

targetTracker在官方注释中表示这个类的作用是用于对target进行相应生命周期的管理，而它的track方法也十分简单，仅仅是将target加入到它的一个内部集合类targets中

  public void track(@NonNull Target target) {
    targets.add(target);
  }

而requestTrack与targetTracker类似，也是将传入的request保存到内部集合类中，用于对其进行相应生命周期管理，而且该方法还会调用request的begin方法

  public void runRequest(@NonNull Request request) {
    requests.add(request);
    //当前非paused状态时，调用request的begin，否则加入pendingRequests队列中
    if (!isPaused) {
      request.begin();
    } else {
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Paused, delaying request");
      }
      pendingRequests.add(request);
    }
  }

在上文关于request的创建中我们知道了，这里的request指的是singleRequest，因此会调用它的begin方法

  @Override
  public void begin() {
    //省略部分异常判断的代码
    ......

    //判断当前status是否是已完成（即完成相应资源的加载）。
    if (status == Status.COMPLETE) {
      onResourceReady(resource, DataSource.MEMORY_CACHE);
      return;
    }
    
    //将状态更变为WAITING_FOR_SIZE
    status = Status.WAITING_FOR_SIZE;
    //判断用户是否通过requestOptions指定合法的宽高
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
      //如果指定了合法的宽高则直接调用onSizeReady()
      onSizeReady(overrideWidth, overrideHeight);
    } else {
      //如果未指定，则由上文生成的viewTarget获取对应的size
      target.getSize(this);
    }

    if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
        && canNotifyStatusChanged()) {
      target.onLoadStarted(getPlaceholderDrawable());
    }
    if (IS_VERBOSE_LOGGABLE) {
      logV("finished run method in " + LogTime.getElapsedMillis(startTime));
    }
  }

target.getSize(this)方法，将singleRequest本身作为一个callback传递了进去，当target获取到了所需尺寸后则会通过传入的callback调用onSizeReady()方法，所以之后的流程还是会进入到onSizeReady()方法

  @Override
  public void onSizeReady(int width, int height) {
    //省略部分异常判断代码
    ......
    
    //将目前的状态变更为RUNNING
    status = Status.RUNNING;

    float sizeMultiplier = requestOptions.getSizeMultiplier();
    this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
    this.height = maybeApplySizeMultiplier(height, sizeMultiplier);

    if (IS_VERBOSE_LOGGABLE) {
      logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
    }
    
    //通过engine.load()进行加载，并返回loadStatus
    loadStatus = engine.load(
        glideContext,
        model,
        requestOptions.getSignature(),
        this.width,
        this.height,
        requestOptions.getResourceClass(),
        transcodeClass,
        priority,
        requestOptions.getDiskCacheStrategy(),
        requestOptions.getTransformations(),
        requestOptions.isTransformationRequired(),
        requestOptions.isScaleOnlyOrNoTransform(),
        requestOptions.getOptions(),
        requestOptions.isMemoryCacheable(),
        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
        requestOptions.getUseAnimationPool(),
        requestOptions.getOnlyRetrieveFromCache(),
        this);

    // This is a hack that's only useful for testing right now where loads complete synchronously
    // even though under any executor running on any thread but the main thread, the load would
    // have completed asynchronously.
    if (status != Status.RUNNING) {
      loadStatus = null;
    }
    if (IS_VERBOSE_LOGGABLE) {
      logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
  }

engine是在Glide在初始化build时创建的，官方注释描述该类用于启动加载和管理对应的活动资源和缓存资源。

    public  LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class resourceClass,
      Class transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map, Transformation> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb) {
    Util.assertMainThread();
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;

    //创建本次加载的资源对应的key
    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);
    
    //从活动资源查找对应资源是否存在
    EngineResource active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return null;
    }
    
    //如未找到，从缓存资源中查找对应资源是否存在
    EngineResource cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }
    
    //如果内存缓存未找到则查找目前正在运行的加载任务中是否存在相同的任务
    EngineJob current = jobs.get(key, onlyRetrieveFromCache);
    if (current != null) {
      current.addCallback(cb);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Added to existing load", startTime, key);
      }
      return new LoadStatus(cb, current);
    }

    //全部未命中后创建engineJob和decodeJob
    EngineJob engineJob =
        engineJobFactory.build(
            key,
            isMemoryCacheable,
            useUnlimitedSourceExecutorPool,
            useAnimationPool,
            onlyRetrieveFromCache);

    DecodeJob decodeJob =
        decodeJobFactory.build(
            glideContext,
            model,
            key,
            signature,
            width,
            height,
            resourceClass,
            transcodeClass,
            priority,
            diskCacheStrategy,
            transformations,
            isTransformationRequired,
            isScaleOnlyOrNoTransform,
            onlyRetrieveFromCache,
            options,
            engineJob);

    //将创建的engineJob与key绑定存入jobs中，让后续任务可以查找
    jobs.put(key, engineJob);

    //将cb(即上文中的SingleRequest)加入callback，继续向下传递
    engineJob.addCallback(cb);
    //由engineJob启动decodeJob
    engineJob.start(decodeJob);

    if (VERBOSE_IS_LOGGABLE) {
      logWithTimeAndKey("Started new load", startTime, key);
    }
    return new LoadStatus(cb, engineJob);
  }

在此方法中涉及到了两级的内存缓存的查找，后续再详细讨论。我们继续关注加载的主流程，在内存缓存未命中的时候我们创建分别创建了EngineJob和DecodeJob。根据官方注释，EngineJob是用来管理添加和删除加载时callback的类，并会在完成时通知对应callback。而DecodeJob正如它的名字是一个解码任务负责从缓存数据或者原始数据解码的类。engineJob.start(decodeJob)则会开启decodeJob的运行

  public void start(DecodeJob decodeJob) {
    this.decodeJob = decodeJob;
    GlideExecutor executor = decodeJob.willDecodeFromCache()
        ? diskCacheExecutor
        : getActiveSourceExecutor();
    executor.execute(decodeJob);
  }

在线程池中运行decodeJob。

  @Override
  public void run() {
    GlideTrace.beginSectionFormat("DecodeJob#run(model=%s)", model);
    DataFetcher localFetcher = currentFetcher;
    try {
      //判断该任务是否取消
      if (isCancelled) {
        notifyFailed();
        return;
      }
      //运行任务
      runWrapped();
    } catch (Throwable t) {
      //异常情况处理
      if (Log.isLoggable(TAG, Log.DEBUG)) {
        Log.d(TAG, "DecodeJob threw unexpectedly"
            + ", isCancelled: " + isCancelled
            + ", stage: " + stage, t);
      }
      if (stage != Stage.ENCODE) {
        throwables.add(t);
        notifyFailed();
      }
      if (!isCancelled) {
        throw t;
      }
    } finally {
      if (localFetcher != null) {
        localFetcher.cleanup();
      }
      GlideTrace.endSection();
    }
  }
  
  private void runWrapped() {
    //根据runReason状态调用不同处理逻辑，runReason在DecodeJob初始化时会被赋值为INITIALIZE
    switch (runReason) {
      case INITIALIZE:
        //获取下个stage和generator
        stage = getNextStage(Stage.INITIALIZE);
        currentGenerator = getNextGenerator();
        //状态更新后调用的runGenerators
        runGenerators();
        break;
      case SWITCH_TO_SOURCE_SERVICE:
        runGenerators();
        break;
      case DECODE_DATA:
        decodeFromRetrievedData();
        break;
      default:
        throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
  }

这里stage更新会根据当前的缓存状态来改变，如果缓存未命中且未限制仅能从缓存中读取，则状态会变为SOURCE。getNextGenerator()方法则会根据当前的stage状态生成不同的currentGenerator。

  private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    //判断任务是否被取消，违背取消则去调用currentGenerator的startNext()方法用于查找对应缓存，而while循环会不断的更新stage和currentGenerator的状态。
    while (!isCancelled && currentGenerator != null
        && !(isStarted = currentGenerator.startNext())) {
      stage = getNextStage(stage);
      currentGenerator = getNextGenerator();

      //如果stage为SOURCE，则会调用reschedule
      if (stage == Stage.SOURCE) {
        //reschedule会将runReason变为SWITCH_TO_SOURCE_SERVICE，并通过callback的reschedule方法重新调用runWrapped从而达到状态更新目的
        reschedule();
        return;
      }
    }
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
      notifyFailed();
    }
  }

关于文件缓存暂时略过，后续再详细讨论。因此我们目前以SourceGenerator为例，进行接下来流程的讨论

  @Override
  public boolean startNext() {
    //判断dataToCache状态来确定是否需要生成对应的sourceCacheGenerator。
    if (dataToCache != null) {
      Object data = dataToCache;
      dataToCache = null;
      cacheData(data);
    }

    //如果生成了对应的sourceCacheGenerator，则调用其startNext方法，并返回true
    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
      return true;
    }
    sourceCacheGenerator = null;

    loadData = null;
    boolean started = false;
    //循环查找ModelLoader中是否存在加载对应数据的ModelLoader
    while (!started && hasNextModelLoader()) {
      loadData = helper.getLoadData().get(loadDataListIndex++);
      if (loadData != null
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
          || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
        //找到能处理的loadData后，调用loadData方法进行加载
        started = true;
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }
    return started;
  }

loadData加载对应资源成功后，会通过传入的第二个参数this回调onDataReady方法。

  @Override
  public void onDataReady(Object data) {
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
    //判断数据是否可以缓存
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
      //若允许缓存，则进行赋值，且调用cb的reschedule()方法
      dataToCache = data;
      cb.reschedule();
    } else {
      //否则直接调用cb的onDataFetcherReady()方法
      cb.onDataFetcherReady(loadData.sourceKey, data, loadData.fetcher,
          loadData.fetcher.getDataSource(), originalKey);
    }
  }

如上文所述reschedule方法会重新调用DecodeJob的runWrapped()方法，最终会回到startNext()方法中，但此时dataToCache已被赋值，因此会调用cacheData()方法

  private void cacheData(Object dataToCache) {
    long startTime = LogTime.getLogTime();
    try {
      Encoder encoder = helper.getSourceEncoder(dataToCache);
      DataCacheWriter writer =
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
      originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
      helper.getDiskCache().put(originalKey, writer);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Finished encoding source to cache"
            + ", key: " + originalKey
            + ", data: " + dataToCache
            + ", encoder: " + encoder
            + ", duration: " + LogTime.getElapsedMillis(startTime));
      }
    } finally {
      loadData.fetcher.cleanup();
    }

    sourceCacheGenerator =
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
  }


该方法主要用于对source数据进行缓存，以及生成对应的sourceCacheGenerator。之后通过sourceCacheGenerator来通加载缓存数据，加载完成后最终还是会调用cb.onDataFetcherReady()方法，也就是DecodeJob的onDataFetcherReady()方法。


  @Override
  public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher fetcher,
      DataSource dataSource, Key attemptedKey) {
    this.currentSourceKey = sourceKey;
    this.currentData = data;
    this.currentFetcher = fetcher;
    this.currentDataSource = dataSource;
    this.currentAttemptingKey = attemptedKey;
    //判断当前线程是否一致，不一致则修改runReason为DECODE_DATA，再通过reschedule方法重新调用run()
    if (Thread.currentThread() != currentThread) {
      runReason = RunReason.DECODE_DATA;
      callback.reschedule(this);
    } else {
      GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
      try {
        decodeFromRetrievedData();
      } finally {
        GlideTrace.endSection();
      }
    }
  }



在onDataFetcherReady方法中会在赋值操作后通过decodeFromRetrievedData()方法对数据进行解析。decodeFromRetrievedData()方法最终通过层层调用会获取到对应的LoadPath对象并调用其load()方法进行解析。并在最后通过notifyEncodeAndRelease()方法进行回调通知。


  public Resource load(DataRewinder rewinder, @NonNull Options options, int width,
      int height, DecodePath.DecodeCallback decodeCallback) throws GlideException {
    List throwables = Preconditions.checkNotNull(listPool.acquire());
    try {
      return loadWithExceptionList(rewinder, options, width, height, decodeCallback, throwables);
    } finally {
      listPool.release(throwables);
    }
  }
  
  private Resource loadWithExceptionList(DataRewinder rewinder,
      @NonNull Options options,
      int width, int height, DecodePath.DecodeCallback decodeCallback,
      List exceptions) throws GlideException {
    Resource result = null;
    //循环调用decodePaths中的DecodePath的decode进行解析
    for (int i = 0, size = decodePaths.size(); i < size; i++) {
      DecodePath path = decodePaths.get(i);
      try {
        result = path.decode(rewinder, width, height, options, decodeCallback);
      } catch (GlideException e) {
        exceptions.add(e);
      }
      if (result != null) {
        break;
      }
    }

    if (result == null) {
      throw new GlideException(failureMessage, new ArrayList<>(exceptions));
    }

    return result;
  }



可见LoadPath的load()方法最终会调用到loadWithExceptionList()方法，并在此方法中循环调用decodePaths中DecodePath的decode进行解析，获取result。


  public Resource decode(DataRewinder rewinder, int width, int height,
      @NonNull Options options, DecodeCallback callback) throws GlideException {
    Resource decoded = decodeResource(rewinder, width, height, options);
    Resource transformed = callback.onResourceDecoded(decoded);
    return transcoder.transcode(transformed, options);
  }

  @NonNull
  private Resource decodeResource(DataRewinder rewinder, int width,
      int height, @NonNull Options options) throws GlideException {
    List exceptions = Preconditions.checkNotNull(listPool.acquire());
    try {
      return decodeResourceWithList(rewinder, width, height, options, exceptions);
    } finally {
      listPool.release(exceptions);
    }
  }



DecodePath的decode方法首先与LoadPath的load()方法类似，通过decodeResourceWithList循环调用ResourceDecoder进行解析。之后通过callback.onResourceDecoded()回调方法将对应的结果传入。


  @Synthetic
  @NonNull
   Resource onResourceDecoded(DataSource dataSource,
      @NonNull Resource decoded) {
    @SuppressWarnings("unchecked")
    Class resourceSubClass = (Class) decoded.get().getClass();
    Transformation appliedTransformation = null;
    Resource transformed = decoded;
    if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
      appliedTransformation = decodeHelper.getTransformation(resourceSubClass);
      transformed = appliedTransformation.transform(glideContext, decoded, width, height);
    }
    if (!decoded.equals(transformed)) {
      decoded.recycle();
    }

    final EncodeStrategy encodeStrategy;
    final ResourceEncoder encoder;
    if (decodeHelper.isResourceEncoderAvailable(transformed)) {
      encoder = decodeHelper.getResultEncoder(transformed);
      encodeStrategy = encoder.getEncodeStrategy(options);
    } else {
      encoder = null;
      encodeStrategy = EncodeStrategy.NONE;
    }

    Resource result = transformed;
    //省略部分代码
    ....
    return result;
  }
  
  
  @SuppressWarnings("unchecked")
   Transformation getTransformation(Class resourceClass) {
    Transformation result = (Transformation) transformations.get(resourceClass);
    if (result == null) {
      for (Entry, Transformation> entry : transformations.entrySet()) {
        if (entry.getKey().isAssignableFrom(resourceClass)) {
          result = (Transformation) entry.getValue();
          break;
        }
      }
    }

    if (result == null) {
      if (transformations.isEmpty() && isTransformationRequired) {
        throw new IllegalArgumentException(
            "Missing transformation for " + resourceClass + ". If you wish to"
                + " ignore unknown resource types, use the optional transformation methods.");
      } else {
        return UnitTransformation.get();
      }
    }
    return result;
  }



在Engine.load()的时候会将Glide初始化时创建的transformations进行遍历，寻找key对应的Transformation。之后将结果返回到onDataFetcherReady方法中，继续调用notifyEncodeAndRelease()方法，进行回调通知。


  private void notifyEncodeAndRelease(Resource resource, DataSource dataSource) {
    if (resource instanceof Initializable) {
      ((Initializable) resource).initialize();
    }

    Resource result = resource;
    LockedResource lockedResource = null;
    if (deferredEncodeManager.hasResourceToEncode()) {
      lockedResource = LockedResource.obtain(resource);
      result = lockedResource;
    }

    notifyComplete(result, dataSource);

    stage = Stage.ENCODE;
    try {
      if (deferredEncodeManager.hasResourceToEncode()) {
        deferredEncodeManager.encode(diskCacheProvider, options);
      }
    } finally {
      if (lockedResource != null) {
        lockedResource.unlock();
      }
    }
    onEncodeComplete();
  }
  
  private void notifyComplete(Resource resource, DataSource dataSource) {
    setNotifiedOrThrow();
    callback.onResourceReady(resource, dataSource);
  }



由上文可见会在此时调用callback(即EngineJob)的onResourceReady方法。


  @Override
  public void onResourceReady(Resource resource, DataSource dataSource) {
    //对回传的数据进行赋值
    this.resource = resource;
    this.dataSource = dataSource;
    //通过Handle回传调用handleResultOnMainThread，确保该方法运行在UI线程中
    MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
  }
  
  @Synthetic
  void handleResultOnMainThread() {
    //省略部分异常判断的代码
    ......
    
    engineResource = engineResourceFactory.build(resource, isCacheable);
    hasResource = true;

    engineResource.acquire();
    listener.onEngineJobComplete(this, key, engineResource);

    //循环触发回调的onResourceReady方法
    for (int i = 0, size = cbs.size(); i < size; i++) {
      ResourceCallback cb = cbs.get(i);
      if (!isInIgnoredCallbacks(cb)) {
        engineResource.acquire();
        cb.onResourceReady(engineResource, dataSource);
      }
    }
    //完成后释放engineResource资源
    engineResource.release();

    release(false /*isRemovedFromQueue*/);
  }



这样就会触发在Engine.load()时传入callback(即SingleRequest)的onResourceReady方法


  @Override
  public void onResourceReady(Resource resource, DataSource dataSource) {
    //省略部分代码
    ......
    onResourceReady((Resource) resource, (R) received, dataSource);
  }
  
  private void onResourceReady(Resource resource, R result, DataSource dataSource) {
    //省略部分代码
    ......
    
    try {
      if ((requestListener == null
          || !requestListener.onResourceReady(result, model, target, dataSource, isFirstResource))
          && (targetListener == null
          || !targetListener.onResourceReady(result, model, target, dataSource, isFirstResource))) {
        Transition animation =
            animationFactory.build(dataSource, isFirstResource);
        //调用target的onResourceReady
        target.onResourceReady(result, animation);
      }
    } finally {
      isCallingCallbacks = false;
    }
    
    //调用requestCoordinator的onRequestSuccess方法
    notifyLoadSuccess();
  }



这里的target我们以上文中的DrawableImageViewTarget为例，先调用它的父类ImageViewTarget的onResourceReady()方法，最终会调用到的DrawableImageViewTarget的setResource()方法中完成资源文件的加载。


  @Override
  protected void setResource(@Nullable Drawable resource) {
    view.setImageDrawable(resource);
  }



总结收获


至此，整个Glide加载图片的主流程分析完成。按照Glide提供的API来划分，整个加载过程分为四步
 with()-load()-apply()-into()
 这四步的作用分别如下：


    

  1. with()主要用于初始化Glide，并将对应context进行处理，完成对生命周期的绑定管理。
    2. 

  2. load()用于对所需加载的资源的model进行识别保存，并且创建RequestBuilder
    3. 

  3. apply()方法用于对用户设定的RequestOptions通过位运算进行传入赋值。
    4. 

  4. into()方法才是整个加载过程的核心，实现了缓存加载，解析，转换等过程，最终通过回调将解析处理完成的资源设置到对应的view中
    5. 

























你可能感兴趣的:(Glide V4 源码浅析（上）-- 主流程分析)






    

  • 极狐GitLab 论坛 2.0 全新上线，可以在论坛上查找与 GitLab 相关的问题了～
极小狐
gitlab极狐GitLabdevopsGitLabci/cddevsecopsSCM

    安装出现依赖错误？版本升级搞不定？遇到422、500就懵逼了？不知道某个功能是免费or付费？……使用GitLab这种全球顶级的DevOps平台进行软件研发时，总会遇到一些困惑，想跟专业的技术人员快速交流以便获得答案，同时又想把这些问题沉淀下来以帮助他人？有这种赠人玫瑰，手有余香的解决方案吗？答案肯定有：论坛！！！论坛——一个各路大神聚集的地方，一个可以解惑答疑问道的地方。解惑：搜索与自己问题相同或
    

    • 

  • LeetCode1047：删除字符串中的所有相邻重复项
一个小猴子｀
LeetCode算法数据结构c++leetcode

    题目描述给出由小写字母组成的字符串S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在S上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。示例：输入：“abbaca”输出：“ca”解释：例如，在“abbaca”中，我们可以删除“bb”由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串“aaca”，其中又只有“a
    

    • 

  • 易经第六十一卦风泽中孚
徐徐微风正好

    易经第六十一卦风泽中孚，巽上兑下。中孚：豚鱼吉，利涉大川，利贞。中孚卦象征着中心诚信，甚至诚信到了能够感动小猪小鱼，可获吉祥，对渡过大河巨流有利，对坚守正道有利。诚信是立人之本，立身处世心怀诚信广施仁义才会走的长远。但是诚信也要合理合时，君子从中得到启示，要以诚信的德行慎重审议案件并宽缓死刑。诚信可以使人信服，有利于坚守中正，内在谦逊柔顺外在坚守行动诚信，连最顽固的老百姓都被感化，天何言哉，四时行
    

    • 

  • 下载Android源码
赛非斯

    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
    

    • 

  • SpringMVC设置全局异常处理器
水岸齐天
javaspring

    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
    

    • 

  • 细水长流的日子之二百五十二（一点一点慢慢长大）
独一无二的小茶叶

    2021-10-22今天小妹妹刚来，见到放在桌篓子里晾着的薰青豆，想要吃，给她拿个小碗装了点，我正在厨房收拾，嘱咐她自己去坐在小椅子上吃，她却一屁股坐在厨房门口的地板上吃起来不小心打翻了，就直接趴在地板上一粒一粒地捡拾。口渴了，自己去把奶瓶里剩下的奶喝掉，然后到厨房门口将奶瓶提给我让我洗干净，把手伸的很长，边小嘴巴里说哇哇，我不让她的小脚跨进厨房半步，怕自己有时没看好出现意外，她牢牢记着，脚绝对不
    

    • 

  • 【算法分析与设计】去除重复字母
五敷有你
算法分析与设计javajavascript开发语言算法数据结构

    个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
    

    • 

  • 第一章 山洞传来牛铃声
满眼荷花

    春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
    

    • 

  • 数据分析：低代码平台助力大数据时代的飞跃发展
快乐非自愿
数据分析低代码大数据

    随着信息技术的突飞猛进，我们身处于一个数据量空前增长的时代——大数据时代。在这个时代背景下，数据分析已经成为企业决策、政策制定、科学研究等众多领域不可或缺的重要工具。然而，面对海量的数据和日益复杂多变的分析需求，传统的数据分析方法往往捉襟见肘，难以应对。幸运的是，低代码平台的兴起为大数据分析注入了新的活力，成为推动大数据时代发展的重要力量。低代码平台，顾名思义，是一种通过少量甚至无需编写代码，就能
    

    • 

  • 以前开发MFC界面如何快速转成QT界面
广州视觉芯软件有限公司
mfcqtc++

    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
    

    • 

  • 数据挖掘|数据预处理|基于Python的数据标准化方法
皖山文武
数据挖掘数据建模与分析python数据挖掘开发语言

    基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
    

    • 

  • yarn的安装和使用全网最详细教程
zxj19880502
yarnnpm

    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
    

    • 

  • 我到人间走一趟
常清净

    我到人间走一趟爱恨情仇尝一尝看着你多情的目光无情的我心头也有些迷茫看着你如此惆怅不屑一顾的我不忍再让你忧伤既然已经来到了凡尘之上又怎能一尘不染地度春光扯一段霓虹遮挡住那道灵光撒一把红尘模糊那个真相我是人，不是神是人就会恋红尘都说人生就是一场戏转身我拿起了一个面具准备和你好好地演上一场戏哪怕最终没有了记忆阿赖耶识里却都会留下印记只要还在轮回里我们就会三生三世十里桃花再相遇桃花开时来相聚
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 00后的我和你们
三七_f4f4

    大部分人认为，这个社会压力最大的莫过于90后。可能上有老下有小，可以正在被催婚。工作压力大。可是也有大部分00后也步入了社会，比起90后，他们更是迷茫，不知所措。虽没有来自家庭的压力，没有来自催婚的烦劳。可迷茫真的很可怕，不知道一会该干嘛，该想那些方面发展。觉得自己以后就这样碌碌无为了吗？就这样过一辈子吗？又不甘。图片发自App前几天在抖音上看见一个视频，他说姚明在苦练篮球。谁谁在苦练什么。问，你
    

    • 

  • 读书笔记《穿越寒冬》
如雪般飞舞

    各位好，我们今天来讲一本书，名字叫作《穿越寒冬》。看起来特别应景，大家觉得现在创业的状况不景气，大家都在忍受着寒冬的煎熬。但实际上，这本书的英文名字并不是这个意思，它的英文名叫作“如何创立一家新公司，并且能够活下来”。我在整个读完了以后，我发现这本书真正要翻译得好，它的名字应该叫作《创业生存手册》。这个书的作者，来自硅谷的霍夫曼船长。霍夫曼船长写过一本让创业者觉得特别贴心的书，叫作《让大象飞》它和
    

    • 

  • 如何呵护孩子的兴趣
婉叶老师

    “老师你教国画吗？”又一个微友这样问我。“怎么啦？”我很想听她后面的言外之意。“我觉得我家孩子很喜欢画画的，可是感觉她画得一般，没什么天赋啊……”感觉这位妈妈有些小焦虑。“传些作品给我看看呢。”那位妈妈传了三张。我先不看画怎样，只看孩子的状态。因为一个孩子是否对参加的课外班真有兴趣这是关键。我看孩子笑得很开心，手里的画也已经有了一些浓淡变化。按专业的眼光看，虽说从造型上、笔法上有待进一步提升，但是
    

    • 

  • OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出
愚梦者
深度学习人工智能计算机视觉c++opencv

    返回：OpenCV系列文章目录（持续更新中......）上一篇：如何利用OpenCV4.9离散傅里叶变换下一篇:目标本文内容主要介绍：如何使用YAML或XML文件打印和读取文件和OpenCV的文本条目？如何对OpenCV数据结构做同样的事情？如何为您的数据结构执行此操作？使用OpenCV数据结构，例如cv::FileStorage,cv::FileNodeorcv::FileNodeIterato
    

    • 

  • docker基础（一）
运维搬运工
容器-dockerdocker容器运维

    相关概念介绍Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖到一个可移植的容器中，然后发布到任何流行的linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，互相之间不会有任何接口。Docker有几个重要概念：dockerfile，配置文件，用来生成dockerimagedockerimage，交付部署的最小单元docker命令与API，定义命令与接口，支持第三方系统集
    

    • 

  • el-dialog宽度自适应
STATICHIT静砸
JavaScriptvue.jselementuijavascript自适应

    最近在自适应上做了很多功夫其中有一个是，在使用element-plus的el-dialog时，在pc端和在手机端打开，由于屏幕宽度的不同，我希望el-dialog的宽度是不一样的。而el-dialog设置宽度是通过width属性，直接用%来相对窗口设置宽度。我先后尝试了媒体查询，监听屏幕宽度和监听视口宽度来自适应。1️⃣首先，直接给el-dialog设置自定义class结合媒体查询是无效的，直接设
    

    • 

  • Ai插件脚本合集安装包，免费教程视频网盘分享
全网优惠分享君

    随着人工智能技术的不断发展，越来越多的插件脚本涌现出来，为我们的生活和工作带来了便利。然而，如何快速、方便地获取和使用这些插件脚本呢？今天，我将为大家分享一个非常实用的资源——AI插件脚本合集安装包，以及免费教程视频网盘分享。首先，让我们来了解一下这个AI插件脚本合集安装包。它是一个集合了众多AI插件脚本的资源包，涵盖了各种领域，如数据分析、自动化办公、智能客服等等。通过这个安装包，用户可以轻松地
    

    • 

  • “播下种子，亲近梦想”北京研学营日记Day2
贝壳Bella

    到目前为止，没有收到同学们想家的反馈，应该没有孩子哭，从门外听到的也是一片安静，估计一个个都进入了梦想。从6:30至9:00回到酒店，的确有些辛苦。有些孩子坚持得很好，有些在下午五点离开科技馆时已经疲惫不堪，嚷嚷着回酒店。于是，餐后在车上立了一个规矩，明天在长城上喊累不能超过三次，因为这也是会传染的。图片发自App从科技馆步行至鸟巢，在等红绿灯时居然就有同学蹲下了。有些孩子一上车睡觉，养好精神，路
    

    • 

  • 如何把大象装进冰箱的思考 210624
大丁_初心生活

    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
    

    • 

  • python转码
Desamond
python开发语言

    转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
    

    • 

  • 生活中的很多事是既令人生气又令人伤感，但却还无可奈何
城中隐士

    今天一打开手机，就看到姨娘家的姐姐兰兰在抖音上发了一则信息，信息内容如下：“我绝对不是我爸妈亲生的，不知他们是从哪儿把我捡回来的”。图源网络，侵则必删今天一大早，天刚蒙蒙亮，姨父就着急莫慌给姨妈家姐姐来一电话，说是家里今天有急事，喊她赶紧回去。还没等姐姐反应过来，姨父就草草地挂断了电话。吓得姐姐立马清醒，以为家里不知出了多大的事？她赶紧从床上爬起来以最快速度第一时间从温江赶到中江。等她顶着烈日，风
    

    • 

  • 排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现）
宇宙之一粟
不归路之Python#IT面试题收集与总结数据结构与算法算法数据结构排序算法pythonjava

    文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
    

    • 

  • 『阅读•思考•灵性新苑‖第九辑/358/1001』《冥想》2作者：[印]斯瓦米·拉玛（Swami Rama） 译者：刘海凝
景熙惟

    部分节选当我们仔细审视生活，就会意识到：从幼年开始，我们接受的教育就仅仅止于观察和了解外部世界。从来没人教导过我们，应当如何向内看、发现和了解内在。因此我们在渴望了解别人的同时，对自己而言却依然是一个陌生人。由于缺乏自我了解，我们的人际关系并不那么称心如意，生活中也常常充满了困惑与失望。事实上，常规教育体系只开发了我们大脑的一小部分。而另外负责做梦、睡眠以及用于存储所有经历的无意识领域，仍不为人知
    

    • 

  • 信马由缰
悦久悦迷人

    那是表面的安静随和乖巧懂事，事实上我也真的安于生活的祥和宁静，唯有自己明白，我接受现实不代表我表里如一！哈哈行走在风里，梦见自己随风而起，遇见战马，和英雄一起仗剑走天涯，穿过黑夜，披着风霜，内心的满足就是在路上，不要安居，有臂膀就足够美满！幸好没生个女儿
    

    • 

  • [高精度加法和乘法] 阶乘之和
StudyingPanda
算法

    题目描述用高精度计算出S=1!+2!+3!+⋯+n!（n≤50）。其中!表示阶乘，定义为n!=n×(n−1)×(n−2)×⋯×1。例如，5!=5×4×3×2×1=120。输入格式一个正整数n。输出格式一个正整数S，表示计算结果。输入输出样例输入#13输出#19解题分析思路很简单，求出阶乘之后再累次求和即可，但是关键在于这个数据量实在是太大了，所以必须封装高精度运算，这里我们创建一个BigInt类，
    

    • 

  • 2022-07-09
双髻山府正堂

    【解析】法律解释是指一定的人或组织对法律规定意义的说明与阐述。法律解释由于解释主体和解释效力的不同可以分为正式解释与非正式解释。所谓正式解释，通常也叫法定解释，是指由特定的国家机关、官员或其他有解释权的人对法律作出的具有法律上约束力的解释。由于王某老伴与子女对该条的解释不具有法律上的约束力，故为非正式解释，A项说法错误。主观目的解释是指根据参与立法的人的意志或立法资料揭示某个法律规定的含义，或者说
    

    • 

  • 强大的销售团队背后 竟然是大数据分析的身影
蓝儿唯美
数据分析

    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。
大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。
Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析 
    

    • 

  • Haproxy+Keepalived高可用双机单活
bylijinnan
负载均衡keepalivedhaproxy高可用

    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）：
1.正常情况下，只有master启动MyApp并提供服务
2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变
F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过
服务器资源
10.7
    

    • 

  • eclipse编辑器中文乱码问题解决
0624chenhong
eclipse乱码

    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File
本文以Eclipse 3.3（英文）为例加以说明：
1. 设置Workspace的编码格式：
Windows-&g
    

    • 

  • 基础篇--resources资源
不懂事的小屁孩
android

    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。
String.xml    字符串资源   涉及国际化问题 
http://www.2cto.com/kf/201302/190394.html  
string-array
    

    • 

  • 接上篇补上window平台自动上传证书文件的批处理问卷
酷的飞上天空
window

    
@echo off
: host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称
set host=localhost
set ou=localhost
set o=localhost
set password=123456
set validity=3650
set salias=s
    

    • 

  • 企业物联网大潮涌动：如何做好准备？
蓝儿唯美
企业

    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。
尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。
Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
    

    • 

  • spring学习——数据库（mybatis持久化框架配置）
a-john
mybatis

    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。
mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置：
1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
    

    • 

  • Java静态代理、动态代理实例
aijuans
Java静态代理

    
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。
按照代理类的创建时期，可以分为：静态代理和动态代理。
所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。
所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。
 
一、静态代理类实例：
1、Serivce.ja
    

    • 

  • Struts1与Struts2的12点区别
asia007
Struts1与Struts2

    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
    

    • 

  • 初学者要多看看帮助文档 不要用js来写Jquery的代码
百合不是茶
jqueryjs

    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;
 
1, JQuery的赋值  有问题
   代码如下: data.username 表示的是:  网易
 
         $("#use
    

    • 

  • 经理怎么和员工搞好关系和信任
bijian1013
团队项目管理管理

            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
    

    • 

  • 如何为rich:tree不同类型节点设置右键菜单
sunjing
contextMenutreeRichfaces

    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}"
selectionChangeListener=&qu
    

    • 

  • 【Redis二】Redis2.8.17搭建主从复制环境
bit1129
redis

    开始使用Redis2.8.17
Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
    

    • 

  • JSONObject转换JSON--将Date转换为指定格式
白糖_
JSONObject

    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：
 
{"nanos":0,"time":-27076233600000,
    

    • 

  • JavaScript语言精粹读书笔记
braveCS
JavaScript

    【经典用法】：
 
//①定义新方法
Function .prototype.method=function(name, func){
this.prototype[name]=func;
return this;
}
//②给Object增加一个create方法，这个方法创建一个使用原对
    

    • 

  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出
bylijinnan
编程之美

    
import java.util.LinkedList;
public class FindInteger {
/**
* 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出
* 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0
*
* 假设当前正在搜索由0，1组成的K位十进制数
    

    • 

  • 读书笔记
chengxuyuancsdn
读书笔记

    1、Struts访问资源
2、把静态参数传递给一个动作
3、<result>type属性
4、s:iterator、s:if c:forEach
5、StringBuilder和StringBuffer
6、spring配置拦截器
1、访问资源
(1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
    

    • 

  • [通讯与电力]光网城市建设的一些问题
comsci
问题

    
      信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系
      我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
    
    

    • 

  • oracle 空间RESUMABLE
daizj
oracle空间不足RESUMABLE错误挂起

    空间RESUMABLE操作  转
Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。
这一篇简单介绍空间RESUMABLE的例子。
第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
    

    • 

  • 重构第一次写的线程池
dieslrae
线程池 python

    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类.
1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法
#!/usr/bin/env python
# -*- coding:utf8 -*-

    

    • 

  • C语言学习六指针
dcj3sjt126com
c

    初识指针，简单示例程序：
/*
指针就是地址，地址就是指针
地址就是内存单元的编号
指针变量是存放地址的变量
指针和指针变量是两个不同的概念
但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
*/
# include <stdio.h>
int main(void)
{
int * p; // p是变量的名字， int * 
    

    • 

  • yii2 beforeSave afterSave beforeDelete
dcj3sjt126com
delete

    public function afterSave($insert, $changedAttributes)
{
parent::afterSave($insert, $changedAttributes);
if($insert) {
//这里是新增数据
} else {
//这里是更新数据
}
}
 
    

    • 

  • timertask
shuizhaosi888
timertask

    java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。
TimerTask task = new
    

    • 

  • Spring Security（13）——session管理
234390216
sessionSpring Security攻击保护超时

    session管理
目录
 
1.1     检测session超时
1.2     concurrency-control
1.3     session 固定攻击保护
 
      
    

    • 

  • 公司项目NODEJS实践0.3[ mongo / session ...]
逐行分析JS源代码
mongodbsessionnodejs

       
http://www.upopen.cn
 
一、前言
        书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
    

    • 

  • pojo.vo.po.domain区别
LiaoJuncai
javaVOPOJOjavabeandomain

    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。
　　
　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
    

    • 

  • Windows Error Code
OhMyCC
windows

    0 操作成功完成.
1 功能错误.
2 系统找不到指定的文件.
3 系统找不到指定的路径.
4 系统无法打开文件.
5 拒绝访问.
6 句柄无效.
7 存储控制块被损坏.
8 存储空间不足, 无法处理此命令.
9 存储控制块地址无效.
10 环境错误.
11 试图加载格式错误的程序.
12 访问码无效.
13 数据无效.
14 存储器不足, 无法完成此操作.
15 系
    

    • 

  • 在storm集群环境下发布Topology
roadrunners
集群stormtopologyspoutbolt

    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。
 
1、打包
打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。
<plugin>
<groupId>org.apache.maven.
    

    • 

  • 为什么不允许代码里出现“魔数”
tomcat_oracle
java

    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
    

    • 

  • zoj 3511 Cake Robbery(线段树)
阿尔萨斯
线段树

     题目链接：zoj 3511 Cake Robbery
题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。
解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。
#include <cstdio>
#include <cstring>
#include <vector&
    

    •