酱爆大头菜
酱爆大头菜

对着那Glide最新版本就是一顿暴讲 1（框架流程篇）

一直想写一个篇 Glide原理讲解，可一直没能动笔。
不是因为没时间，是 Glide 涉及太过广泛，内部逻辑太过犀利。一直没能找到一个合适的制高点来俯览全身。

之前对 Glide 一直停留在使用层面，只晓得使用方便，链式调用，节约内存，无所顾及内部原理，更没能学习其架构设计。

glide_logo.png

经过数天的翻阅资料学习，我也是粗略的过了一遍Glide源码。接下来我将通过以下几个问题来引伸分析Glide的内部逻辑，尽量做到 由使用到原理，从架构到逻辑，深入浅出。

    1. Glide是干啥的？
    1. 为什么用Glide？
    1. Glide怎么用？
    1. Glide包含哪些模块？都干什么用的？
    1. Glide调用某一个方法后具体干了什么事？

本文基于Glide的最新版本 4.10.0 进行分析，如有错误欢迎指出。

1. 请用一脸懵逼的姿势了解，Glide到底是干啥的？

Glide is a fast and efficient open source media management and image loading framework for Android that wraps media decoding, memory and disk caching, and resource pooling into a simple and easy to use interface.

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

2. 那你为什么要用Glide？

  • 有个不知道哪的人，不知道叫什么名的人曾经说过，当你开始问 为什么 的时候，那么你可能要变身了。

  • 这个问题非常简洁，但分析透彻实属不易，甚至该问题是伴随使用的需求，场景变化而变化的。既然不好直观的分析说明，我们就罗列对应优势，方便需要的时候对号入座

  • 2.1 优雅的调用姿 Glide.with(fragment).load(url).into(imageView);

  • 2.2 多维度的图片格式（png，jpg，gif，webp，video等...）

  • 2.3 健壮的身体素质 性能极好，能防止频繁主线程I/O,垃圾回收而导致的页面闪烁卡顿等。

  • 2.4 灵活的加载请求 可根据页面的生命周期动态管理图片的加载请求。

  • 2.5 风骚的缓存策略 支持按控件大小缓存对应大小的图片，且默认的图片格式为RGB_565，相对占用空间更小。速度也因此更快。

嗯~~~ 就看这几个，你说你要不要选Glide.....

3. Glide怎么用？

可算是到我闭着眼都能写的环节了，来来来，咱们撸代码。

  • 3.1. 首先增加如下引用。 
    implementation 'com.github.bumptech.glide:glide:4.10.0'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.10.0'
  • 3.2. 使用方式，我们罗列5种常用的使用方式。 
//********************************** 直接使用 **********************************
Glide.with(Context).load("").into(mImageView)

//使用Generated API， 作用范围Application 模块内使用
//创建MyAppGlideModule类加上@GlideModule注解，buid后既能使用 GlideApp
@GlideModule
public final class MyAppGlideModule extends AppGlideModule {}

//Generated API加载图片
GlideApp.with(Context).load("").into(mImageView);


 
//**********************************  添加占位图 **********************************
RequestOptions requestOptions = new RequestOptions()
         .placeholder(R.drawable.a)
         .error(R.drawable.e)
         .diskCacheStrategy(DiskCacheStrategy.NONE);//设置缓存了参数
Glide.with(Context).load("").apply(requestOptions).into(mImageView);

//Generated API 方式(和Glide3 一样)
GlideApp.with(Context).load("")
         .placeholder(R.drawable.a)
         .error(R.drawable.e)
         .diskCacheStrategy(DiskCacheStrategy.NONE)
         .into(mImageView);

// 后备回调符(Fallback) Generated API 方式才有
//在设置图片的场景中，如果用户不设置，也就是为null的情况，可使用后备回调符显示默认图
private static final String NULL_URL=null;
GlideApp.with(Context).load(NULL_URL)
         .fallback(R.drawable.a)
         .into(mImageView);




//**********************************  指定加载图片的大小（override） **********************************
RequestOptions requestOptions = new RequestOptions().override(200,100);
Glide.with(Context).load("").apply(requestOptions).into(mImageView);

//Generated API 方式
GlideApp.with(Context).load("")
             .override(200,100)
             .into(mImageView);





//**********************************  通过thumbnail加载缩略图 **********************************
//与placeholder类似，但是thumbnail可加载网络图，placeholder只能加载本地图。
RequestOptions requestOptions = new RequestOptions()
                .override(200,100)
                .diskCacheStrategy(DiskCacheStrategy.NONE);
Glide.with(MainActivity.this)
                .load(url)
                .thumbnail( Glide.with(this)
                .load(url)
                .apply(requestOptions))
                .into(iv);
 
//Generated API 方式
 GlideApp.with(Context)
            .load(url)
            .thumbnail( GlideApp.with(this)
            .load(IMAGE_URL).override(200,100)          
            .diskCacheStrategy(DiskCacheStrategy.NONE))
            .into(mImageView);


//**********************************  设置图片的变化操作 **********************************
//可通过
//CenterCrop（图片原图的中心区域进行裁剪显示）
//FitCenter（图片原始长宽铺满）
//CircleCrop（圆形裁剪）
//设置图片的变化操作
Glide.with(Context)
            .load(IMAGE_URL)
            .apply(RequestOptions.circleCropTransform())
            .into(mImageView);

//Generated API 方式
GlideApp.with(Context).load(IMAGE_URL)
            .circleCrop()
            .diskCacheStrategy(DiskCacheStrategy.NONE)
            .into(mImageView);
4. Glide包含哪些模块？都干什么用的？

接下来的环节将是本篇文章的高地，至于有多高。我可以负责任的告诉你们有这么高...


有这么高.jpg

我们可以先简单思考下，如果你是Glide的作者，你要怎么设计一个优秀的图片加载框架，需要兼顾哪些环节，需要包含哪些模块？
简单来说，图片加载需要以下几种模块。

    1. 参数封装
    1. 加载请求
    1. 执行引擎
    1. 数据加载器
    1. 解码器
    1. 编码器
    1. 缓存

那实际Glide是这样设计的么？

    1. 参数封装（获得请求的参数，配置加载图的属性）
    1. 网络请求（下载图片）
    1. 缓存逻辑（资源重用）
    1. 加解码（处理图片）
    1. 数据加载（判断加载方式/请求网络/IO读取/内存读取）
    1. 线程池/线程队列（或者叫任务队列，用于处理每次的加载任务）
    1. 防止OOM的处理机制（软引用，缓存，压缩，存储等..）
    1. 生命周期管理（防止内存泄露）
      ...

说了这么多，那加载一张图片，到底是怎样一个流程呢？换句话说，这些模块具体是怎样协同工作的，调用顺序又是怎样的呢？
给大家画了一个简单的图，兄弟们，这个图来之不易啊，你不从头捋一遍你真是不知道咋画啊...


image.png

好多小伙伴可能看到这个图，又懵逼了， 你这都啥跟啥啊，一个Glide你画这么几个块就over了？
那网络咋加载的？那缓存怎么处理的，那线程咋切换的？那生命周期咋控制的。啥也没说啊..

各位，各位，先别着急。咱们力争的是先 整体再局部，先总览再细分。接下来咱们针对代码进行跟进。

兄台准备好面对疾风了么？

5. Glide调用某一个方法后具体干了什么事？

首先我们拿一个简单的使用进行跟进

Glide.with(context).load("").into(mImageView)

链式调用，我们分解为以下三个方法进行分析。
Glide.with(context)
Glide.with(context).load("")
Glide.with(context).load("").into(mImageView)

  • 5.1. Glide.with(context)具体干了啥？

死亡如风，常伴吾身。我会给你个痛快的！

/**
   * 简单来说该方法进行了以下几步操作
   * 1. Glide 初始化
   * 2. 各种线程池初始化，各种缓存对象初始化
   * 3. Engine初始化，至于Engine是啥，后续我们慢慢介绍
   * 4. RequestManager 初始化
   * 5. 创建透明的fragment，动态监听生命周期
   */
  @NonNull
  public static RequestManager with(@NonNull FragmentActivity activity) {
    return getRetriever(activity).get(activity);
  }

 private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    // 检测传入的context是否合规
    Preconditions.checkNotNull(context, "You cannot start .....");
    return Glide.get(context).getRequestManagerRetriever();
  }

  public static Glide get(@NonNull Context context) {
    if (glide == null) {
      GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules(context.getApplicationContext());
      synchronized (Glide.class) {
        if (glide == null) {
          //如果glide为null则启动检测初始化逻辑
          checkAndInitializeGlide(context, annotationGeneratedModule);
        }
      }
    }
    return glide;
  }

  private static void checkAndInitializeGlide(@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
    // 如果已经在初始化中了，则抛异常。
    if (isInitializing) {
      throw new IllegalStateException( "You cannot call Glide.get() in registerComponents(), use the provided Glide instance instead");
    }
    //设置初始化状态
    isInitializing = true;
    initializeGlide(context, generatedAppGlideModule);
    isInitializing = false;
  }

  private static void initializeGlide(
      @NonNull Context context,
      @NonNull GlideBuilder builder,
      @Nullable GeneratedAppGlideModule annotationGeneratedModule) {
    Context applicationContext = context.getApplicationContext();
...
    //调用GlideBuilder.build()方法进行Glide初始化
    Glide glide = builder.build(applicationContext);
...
   //注册回调
    applicationContext.registerComponentCallbacks(glide);
    Glide.glide = glide;
  }

 //GlideBuilder.build()方法，用于初始化各种线程池，以及缓存对象，初始化Glide
  Glide build(@NonNull Context context) {
    //创建资源池
    if (sourceExecutor == null) {
      sourceExecutor = GlideExecutor.newSourceExecutor();
    }
    //硬盘缓存池
    if (diskCacheExecutor == null) {
      diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
    }

    if (animationExecutor == null) {
      animationExecutor = GlideExecutor.newAnimationExecutor();
    }
    
    if (memorySizeCalculator == null) {
      memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();
    }

    if (connectivityMonitorFactory == null) {
      connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();
    }

    if (bitmapPool == null) {
      int size = memorySizeCalculator.getBitmapPoolSize();
      if (size > 0) {
        bitmapPool = new LruBitmapPool(size);
      } else {
        bitmapPool = new BitmapPoolAdapter();
      }
    }

    if (arrayPool == null) {
      arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
    }

    if (memoryCache == null) {
      memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
    }

    if (diskCacheFactory == null) {
      diskCacheFactory = new InternalCacheDiskCacheFactory(context);
    }

    if (engine == null) {
  //初始化Engine
      engine = new Engine(
              memoryCache,
              diskCacheFactory,
              diskCacheExecutor,
              sourceExecutor,
              GlideExecutor.newUnlimitedSourceExecutor(),
              animationExecutor,
              isActiveResourceRetentionAllowed);
    }

    if (defaultRequestListeners == null) {
      defaultRequestListeners = Collections.emptyList();
    } else {
      defaultRequestListeners = Collections.unmodifiableList(defaultRequestListeners);
    }

    RequestManagerRetriever requestManagerRetriever = new RequestManagerRetriever(requestManagerFactory);
   //初始化Glide
    return new Glide(
        context,
        engine,
        memoryCache,
        bitmapPool,
        arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
        logLevel,
        defaultRequestOptionsFactory,
        defaultTransitionOptions,
        defaultRequestListeners,
        isLoggingRequestOriginsEnabled,
        isImageDecoderEnabledForBitmaps,
        hardwareBitmapFdLimit,
        minHardwareDimension);
  }

 //RequestManagerRetriever.get()通过Glide.with(Context)入参获取FragmentManager 
  public RequestManager get(@NonNull FragmentActivity activity) {
    if (Util.isOnBackgroundThread()) {
      return get(activity.getApplicationContext());
    } else {
      //通过Android版本>17，并且页面已经isDestroyed则抛出异常
      assertNotDestroyed(activity);
      //通过入参获取FragmentManager 
      FragmentManager fm = activity.getSupportFragmentManager();
      return supportFragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
  }
//RequestManagerRetriever.supportFragmentGet（）
 private RequestManager supportFragmentGet(
      @NonNull Context context,
      @NonNull FragmentManager fm,
      @Nullable Fragment parentHint,
      boolean isParentVisible) {
//获取请求fragment
    SupportRequestManagerFragment current =getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
    //获取fragment中RequestManager 对象，如果fragment是刚刚创建的requestManager 为null
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      // TODO(b/27524013): Factor out this Glide.get() call.
      Glide glide = Glide.get(context);
  //创建requestManager 并设置给fragment
      requestManager =
          factory.build( glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }

  private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, @Nullable Fragment parentHint, boolean isParentVisible) {
//先查找这个tag的fragment有没有被创建
    SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
      //从pendingSupportRequestManagerFragments中在查找一次
      current = pendingSupportRequestManagerFragments.get(fm);
      if (current == null) {
        //如果都为null则new创建
        current = new SupportRequestManagerFragment();
        current.setParentFragmentHint(parentHint);
        if (isParentVisible) {
          current.getGlideLifecycle().onStart();
        }
        //存储
        pendingSupportRequestManagerFragments.put(fm, current);
         //添加到FragmentManager 中
        fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
        //发送通知
        handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
      }
    }
    return current;
  }

兄弟们，咱回回神，经过这一通暴讲，我们终于把 with() 这个方法分析完成了。是不是贼拉牛逼。现在对with()方法的流程以及生命周期的控制管理是不是稍稍有那么一些印象了。无法复述没有关系。先能顺下来，当你第二遍看到时候就会事半功倍了。

写了这么一堆，我们回顾下这个with()干了啥？

    1. 调用getRetriever(activity).get(activity)
    1. 调用checkAndInitializeGlide(context, annotationGeneratedModule)检测并启动初始化
    1. 调用initializeGlide(context, generatedAppGlideModule);连带调用GlideBuilder.build(applicationContext)进行Glide初始化
    1. Glide初始化过程中会创建各种线程池，各种缓存对象，并初始化Engine对象。
    1. 调用RequestManagerRetriever.get(activity)返回RequestManager对象，同时通过入参的activity.getSupportFragmentManager()获取FragmentManager对象。
    1. 调用supportFragmentGet(activity, fm, null, isActivityVisible(activity))创建RequestManager和SupportRequestManagerFragment并做关联。
    • 6.1. 这个地方需要注意下，可能调用的是fragmentGet()或getApplicationManager(),最终目的都是 创建RequestManager。
    • 6.2. 主线程 下调用各个对象之间的对应关系为
      1个Activity<-->1个FragmentManager<-->1个RequestManagerFragment<--> 1个RequestManager。
    • 6.3. 子线程 调用会传入ApplicationContext，此时使用的是全局的单例RequestManager，生命周期和App一致。

扩展个知识点，具体Glide是怎么依赖生命周期动态控制加载图片的呢?

SupportRequestManagerFragment对象中有个属性为ActivityFragmentLifecycle对象，并且在SupportRequestManagerFragment的生命周期方法中均调用了ActivityFragmentLifecycle的对应方法。

 @Override
  public void onStart() {
    super.onStart();
    lifecycle.onStart();
  }

  @Override
  public void onStop() {
    super.onStop();
    lifecycle.onStop();
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    lifecycle.onDestroy();
    unregisterFragmentWithRoot();
  }

然后通过LifecycleListener调用对应的方法

void onStart() {
    isStarted = true;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStart();
    }
  }

  void onStop() {
    isStarted = false;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStop();
    }
  }

  void onDestroy() {
    isDestroyed = true;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onDestroy();
    }
  }

我们再看都哪些类实现了LifecycleListener接口呢？其中有RequestManager，TargetTracker和Target（继承）实现了该接口，我们抽出RequestManager单独看下。

查看哪个类实现了该接口.png

RequestManager 

 @Override
  public synchronized void onStart() {
    resumeRequests();
    targetTracker.onStart();
  }

  /**
   * Lifecycle callback that unregisters for connectivity events (if the
   * android.permission.ACCESS_NETWORK_STATE permission is present) and pauses in progress loads.
   */
  @Override
  public synchronized void onStop() {
    pauseRequests();
    targetTracker.onStop();
  }

  /**
   * Lifecycle callback that cancels all in progress requests and clears and recycles resources for
   * all completed requests.
   */
  @Override
  public synchronized void onDestroy() {
    targetTracker.onDestroy();
    for (Target target : targetTracker.getAll()) {
      clear(target);
    }
    targetTracker.clear();
    requestTracker.clearRequests();
    lifecycle.removeListener(this);
    lifecycle.removeListener(connectivityMonitor);
    mainHandler.removeCallbacks(addSelfToLifecycle);
    glide.unregisterRequestManager(this);
  }

 public synchronized void resumeRequests() {
    requestTracker.resumeRequests();
  }

  public void pauseRequests() {
    isPaused = true;
    for (Request request : Util.getSnapshot(requests)) {
      //如果正在执行过程中
      if (request.isRunning()) {
        // Avoid clearing parts of requests that may have completed (thumbnails) to avoid blinking
        // in the UI, while still making sure that any in progress parts of requests are immediately
        // stopped.
        //调用暂停
        request.pause();
        //添加到挂起的请求中。
        pendingRequests.add(request);
      }
    }
  }
  public void clear(@Nullable final Target target) {
    if (target == null) {
      return;
    }

    untrackOrDelegate(target);
  }

private void untrackOrDelegate(@NonNull Target target) {
    boolean isOwnedByUs = untrack(target);
    // We'll end up here if the Target was cleared after the RequestManager that started the request
    // is destroyed. That can happen for at least two reasons:
    // 1. We call clear() on a background thread using something other than Application Context
    // RequestManager.
    // 2. The caller retains a reference to the RequestManager after the corresponding Activity or
    // Fragment is destroyed, starts a load with it, and then clears that load with a different
    // RequestManager. Callers seem especially likely to do this in retained Fragments (#2262).
    //
    // #1 is always an error. At best the caller is leaking memory briefly in something like an
    // AsyncTask. At worst the caller is leaking an Activity or Fragment for a sustained period of
    // time if they do something like reference the Activity RequestManager in a long lived
    // background thread or task.
    //
    // #2 is always an error. Callers shouldn't be starting new loads using RequestManagers after
    // the corresponding Activity or Fragment is destroyed because retaining any reference to the
    // RequestManager leaks memory. It's possible that there's some brief period of time during or
    // immediately after onDestroy where this is reasonable, but I can't think of why.
    Request request = target.getRequest();
    if (!isOwnedByUs && !glide.removeFromManagers(target) && request != null) {
      //移除请求调用清理。
      target.setRequest(null);
      request.clear();
    }
  }

看到以上及其简短的注释，估计你是明白咋回事了。

本质原理就是 SupportRequestManagerFragment是通过传入的Context创建的。可以感知onStart(), onStop(), onDestroy() 等方法。

在这些方法中调用 ActivityFragmentLifecycle 中对应的方法，然后 循环 找到 ActivityFragmentLifecycle中与之对应的RequestManager对象，再调用 对应生命周期 的方法。

最后通过requestTracker循环找到对应的Request对象，然后调用对应的处理方法从而达到了根据生命周期动态控制图片加载的目的。

好了，我就不多赘述了。我还得抓紧赶路，争取一气呵成。

  • 5.2. Glide.with(context).load("")具体干了啥？

长路漫漫 惟剑做伴 吾之荣耀 离别已久 宁日安在 无人能云 且随疾风前行

Glide.with(context)已经返回了RequestManager,因此Glide.with(context).load("")相当于RequestManager.load("");

public RequestBuilder load(@Nullable String string) {
    return asDrawable().load(string);
  }

  //注意返回值为RequestBuilder
  public RequestBuilder asDrawable() {
    return as(Drawable.class);
  }

  public  RequestBuilder as(
      @NonNull Class resourceClass) {
    //初始化RequestBuilder对象
    return new RequestBuilder<>(glide, this, resourceClass, context);
  }
  //RequestBuilder的构造方法
  protected RequestBuilder(
      @NonNull Glide glide,
      RequestManager requestManager,
      Class transcodeClass,
      Context context) {
    this.glide = glide;
    this.requestManager = requestManager;
    this.transcodeClass = transcodeClass;
    this.context = context;
    this.transitionOptions = requestManager.getDefaultTransitionOptions(transcodeClass);
    this.glideContext = glide.getGlideContext();
    //初始化RequestListeners
    initRequestListeners(requestManager.getDefaultRequestListeners());
    apply(requestManager.getDefaultRequestOptions());
  }

 private void initRequestListeners(List> requestListeners) {
    for (RequestListener listener : requestListeners) {
      addListener((RequestListener) listener);
    }
  }

  public RequestBuilder apply(@NonNull BaseRequestOptions requestOptions) {
    Preconditions.checkNotNull(requestOptions);
    return super.apply(requestOptions);
  }

 
 
上文中的源码我们只是分析load()方法的第一步，首先分析了load()中asDrawable()方法以及一系列的连带方法。
 逻辑非常简单，相对比较有代表性的是初始化了RequestBuilder对象。
 我们继续分析RequestBuilder.load()
 
 
public RequestBuilder load(@Nullable String string) {
    return loadGeneric(string);
  }

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

 
 
诶？这就完了？咋稍稍有点不适应呢？就只设置了下model和isModelSet属性就完事了？
 看来是的，load()就是这么简单，需要注意的一点是model通过Object接收的。
 
 
     
  
  • 5.3. Glide.with(context).load("").into(mImageView)具体干了啥？ 
    •  
 
 
 
回首往昔 更进一步 吾虽浪迹天涯 却从未迷失本心。最后一个方法了，黎明就在眼前
 Glide.with(context).load("")的返回值为RequestBuilder，因此无亚于RequestBuilder.into(mImageView);
 
 
//  注意返回值为ViewTarget
public ViewTarget into(@NonNull ImageView view) {
    //判断是否为主线程，不是主线程则抛异常
    Util.assertMainThread();
    //判空逻辑
    Preconditions.checkNotNull(view);
    //这个requestOptions 是啥现在还看不出来，好像是存放图片展示的相关属性的。
    BaseRequestOptions requestOptions = this;
    if (!requestOptions.isTransformationSet()
        && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
      // 在此方法中克隆，以便如果使用此RequestBuilder加载到视图中，然后加载到其他目标中，
      //则不会保留基于上一个视图的缩放类型应用的转换。
      //该switch 主要用于控制调用Glide时设置的各种样式，没设置则为默认的
      switch (view.getScaleType()) {
        case CENTER_CROP:
          requestOptions = requestOptions.clone().optionalCenterCrop();
          break;
        case CENTER_INSIDE:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case FIT_CENTER:
        case FIT_START:
        case FIT_END:
          requestOptions = requestOptions.clone().optionalFitCenter();
          break;
        case FIT_XY:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case CENTER:
        case MATRIX:
        default:
          // Do nothing.
      }
    }

    return into(
        //注意这个transcodeClass在上述4.2中得知transcodeClass为Drawable.class
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions,
        Executors.mainThreadExecutor());
  }
//
public  ViewTarget buildImageViewTarget(
      @NonNull ImageView imageView, @NonNull Class transcodeClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
  }
//由于为Drawable.class因此本方法将返回DrawableImageViewTarget对象。
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)");
    }
  }

 
 
简单来说上述的的一串逻辑可以理解为
 a. 调用into()后首先判断是否为主线程
 b. 通过view.getScaleType()判断使用哪个requestOptions对象，如果没设置则使用默认的。
 c. 调用glideContext.buildImageViewTarget(view, transcodeClass)返回DrawableImageViewTarget对象。
 
 
ok，我们继续看into方法，现在的into可以理解为
 
 
into(DrawableImageViewTarget，null，requestOptions，Executors.mainThreadExecutor());

 
 
  private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      BaseRequestOptions options,
      Executor callbackExecutor) {
    //还是检查逻辑
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }
    //创建Request对象，看面相 这个应该还是用于请求的对象，我们得看看咋创建的
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
    //此处的target为DrawableImageViewTarget
    Request previous = target.getRequest();
    if (request.isEquivalentTo(previous) && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      //如果请求完成，重新开始将确保重新传递结果，
      //触发请求侦听器和目标。如果请求失败，则重新开始
      // 重新启动请求，还会有一次完成的机会。如果请求已经开始我们可以让它继续运行而不中断
      if (!Preconditions.checkNotNull(previous).isRunning()) {
      //使用上一个请求而不是新请求，如跳过设置占位符、跟踪和取消跟踪目标以及获取视图维度这些事在个人请求中完成的。
        previous.begin();
      }
      return target;
    }
    //这三个方法我们后续分析，不是一句话能说明白的。
    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }


private Request buildRequest(
      Target target,
      @Nullable RequestListener targetListener,
      BaseRequestOptions requestOptions,
      Executor callbackExecutor) {
    return buildRequestRecursive(
        /*requestLock=*/ new Object(),
        target,
        targetListener,
        /*parentCoordinator=*/ null,
        transitionOptions,
        requestOptions.getPriority(),
        requestOptions.getOverrideWidth(),
        requestOptions.getOverrideHeight(),
        requestOptions,
        callbackExecutor);
  }
//此时的target为DrawableImageViewTarget，targetListener为null
private Request buildRequestRecursive(
      Object requestLock,
      Target target,
      @Nullable RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      BaseRequestOptions requestOptions,
      Executor callbackExecutor) {

    // 如果需要，请先构建ErrorRequestCoordinator，以便我们可以更新parentCoordinator。
    //但是因为我们没有设置error，因此errorBuilder 为null
    ErrorRequestCoordinator errorRequestCoordinator = null;
    if (errorBuilder != null) {
      errorRequestCoordinator = new ErrorRequestCoordinator(requestLock, parentCoordinator);
      parentCoordinator = errorRequestCoordinator;
    }
    //我们后续详细看下这个mainRequest创建逻辑
    Request mainRequest = buildThumbnailRequestRecursive(
                                            requestLock,
                                            target,
                                            targetListener,
                                            parentCoordinator,
                                            transitionOptions,
                                            priority,
                                            overrideWidth,
                                            overrideHeight,
                                            requestOptions,
                                            callbackExecutor);
    //因为errorBuilder 为null因此上述的errorRequestCoordinator也为null，此处直接返回mainRequest了
    if (errorRequestCoordinator == null) {
      return mainRequest;
    }

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

    Request errorRequest = errorBuilder.buildRequestRecursive(
                                            requestLock,
                                            target,
                                            targetListener,
                                            errorRequestCoordinator,
                                            errorBuilder.transitionOptions,
                                            errorBuilder.getPriority(),
                                            errorOverrideWidth,
                                            errorOverrideHeight,
                                            errorBuilder,
                                            callbackExecutor);
    errorRequestCoordinator.setRequests(mainRequest, errorRequest);
    return errorRequestCoordinator;
  }

 
 
buildThumbnailRequestRecursive()方法的逻辑比较长，我们单独拿出来去分析,但是其实我们并没有设置thumbnail()，所以thumbnailBuilder和thumbSizeMultiplier 是都null，只会走最后一个else。
 我贴下整体的逻辑代码，不要惊慌，这一大片代码，只为最后创建个SingleRequest。
 
 

private Request buildThumbnailRequestRecursive(
      Object requestLock,
      Target target,
      RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      BaseRequestOptions requestOptions,
      Executor callbackExecutor) {
    if (thumbnailBuilder != null) { 
      ....
     return coordinator;
    } else if (thumbSizeMultiplier != null) {
      ....
      return coordinator;
    } else {
      // 没有设置thumbnail走
      return obtainRequest(
          requestLock,
          target,
          targetListener,
          requestOptions,
          parentCoordinator,
          transitionOptions,
          priority,
          overrideWidth,
          overrideHeight,
          callbackExecutor);
    }
  }

 private Request obtainRequest(
      Object requestLock,
      Target target,
      RequestListener targetListener,
      BaseRequestOptions requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      Executor callbackExecutor) {
    return SingleRequest.obtain(
        context,
        glideContext,
        requestLock,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListeners,
        requestCoordinator,
        glideContext.getEngine(),
        transitionOptions.getTransitionFactory(),
        callbackExecutor);
  }

public static  SingleRequest obtain(
      Context context,
      GlideContext glideContext,
      Object requestLock,
      Object model,
      Class transcodeClass,
      BaseRequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target target,
      RequestListener targetListener,
      @Nullable List> requestListeners,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory animationFactory,
      Executor callbackExecutor) {
    return new SingleRequest<>(
        context,
        glideContext,
        requestLock,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListeners,
        requestCoordinator,
        engine,
        animationFactory,
        callbackExecutor);
  }

  private SingleRequest(
      Context context,
      GlideContext glideContext,
      @NonNull Object requestLock,
      @Nullable Object model,
      Class transcodeClass,
      BaseRequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target target,
      @Nullable RequestListener targetListener,
      @Nullable List> requestListeners,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory animationFactory,
      Executor callbackExecutor) {
    this.requestLock = requestLock;
    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.requestListeners = requestListeners;
    this.requestCoordinator = requestCoordinator;
    this.engine = engine;
    this.animationFactory = animationFactory;
    this.callbackExecutor = callbackExecutor;
    status = Status.PENDING;

    if (requestOrigin == null && glideContext.isLoggingRequestOriginsEnabled()) {
      requestOrigin = new RuntimeException("Glide request origin trace");
    }
  }

 
 
生成完SingleRequest了，看到头了，是不是突然不知道从哪再次开始了？
 还记得RequestBuilder.into()方法的最后那三个方法么？这就是重新开始的地方....
 
 
 private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      BaseRequestOptions options,
      Executor callbackExecutor) {
    //还是检查逻辑
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }
    //创建Request对象，看面相 这个应该还是用于请求的对象，我们得看看咋创建的
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
    //此处的target为DrawableImageViewTarget
    Request previous = target.getRequest();
    if (request.isEquivalentTo(previous) && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      //如果请求完成，重新开始将确保重新传递结果，
      //触发请求侦听器和目标。如果请求失败，则重新开始
      // 重新启动请求，还会有一次完成的机会。如果请求已经开始我们可以让它继续运行而不中断
      if (!Preconditions.checkNotNull(previous).isRunning()) {
      //使用上一个请求而不是新请求，如跳过设置占位符、跟踪和取消跟踪目标以及获取视图维度这些事在个人请求中完成的。
        previous.begin();
      }
      return target;
    }
    //对对对 就是这三个方法。
    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }

 
 
我们一个一个跟进,先看下clear()
 
 
  public void clear(@Nullable final Target target) {
    if (target == null) {
      return;
    }

    untrackOrDelegate(target);
  }

  private void untrackOrDelegate(@NonNull Target target) {
    boolean isOwnedByUs = untrack(target);
    // 如果在启动请求的请求管理器之后清除了目标，我们将在这里结束
    // 被摧毁了。至少有两个原因：
    // 1. 我们在后台线程上调用clear（），使用的不是应用程序上下文请求管理器。
    // 2. 调用方在相应的活动或片段被破坏，用它开始加载，然后用另一个请求管理器。调用者似乎特别有可能在保留的片段中这样做（#2262）。 
    //
    // #1 总是一个错误。充其量，调用者只是在像异步任务。最坏情况下，调用者在持续的
    // 如果他们做了类似引用活动请求管理器的长时间操作后台线程或任务。
    //
    // #2 总是一个错误。调用方不应该在由于保留对请求管理器泄漏内存。可能有一段很短的时间
    // 紧接着onDestroy这是合理的。
    Request request = target.getRequest();
    if (!isOwnedByUs && !glide.removeFromManagers(target) && request != null) {
      target.setRequest(null);
      request.clear();
    }
  }

 
 
clear() 相对比较简单，判断当前target上面是否有请求，进行一些逻辑判断是否需要取消。
 然后DrawableImageViewTarget的Request对象置空。
 target.setRequest(request);没啥好说的只是将Request设置到DrawableImageViewTarget对象中。
 我们看下最后的 requestManager.track(target, request);
 
 
//track()内部又调用两个方法。
synchronized void track(@NonNull Target target, @NonNull Request request) {
    targetTracker.track(target);
    requestTracker.runRequest(request);
  }

//TargetTracker.track()比较简单，将DrawableImageViewTarget添加到targets 的Set>对象中。
private final Set> targets = Collections.newSetFromMap(new WeakHashMap, Boolean>());
public void track(@NonNull Target target) {
    targets.add(target);
  }

private final Set requests = Collections.newSetFromMap(new WeakHashMap());
//RequestTracker.runRequest()
public void runRequest(@NonNull Request request) {
    //首先将request对象添加到Set对象中统一管理
    requests.add(request); 
    if (!isPaused) {
      //如果界面未处于onStop状态，代表页面可见
      request.begin();
    } else {
      //如果界面处于onStop状态，页面不可见
      request.clear();
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Paused, delaying request");
      }
     //添加到pendingRequests对象中
     //pendingRequests的注释有写到，pendingRequests用于存未完成的请求，方便下次请求，该列表用于维护强引用，确保再次运行前不被GC，
      pendingRequests.add(request);
    }
  }

 
 
我们继续看下以上代码中的 request.begin() 方法，此处的requests为SingleRequest对象，因此只需看SingleReques.begin();
 
 
public void begin() {
    synchronized (requestLock) {
      assertNotCallingCallbacks();
      stateVerifier.throwIfRecycled();
      startTime = LogTime.getLogTime();
      //首先对model 判断，model 为load传入的那个url。
      if (model == null) {
         //如果为null则直接失败。
        if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
          width = overrideWidth;
          height = overrideHeight;
        }
       //当用户设置了fallback drawable，输入详细日志，因为fallback drawable偶尔需要空models 
        int logLevel = getFallbackDrawable() == null ? Log.WARN : Log.DEBUG;
        onLoadFailed(new GlideException("Received null model"), logLevel);
        return;
      }
      //如果当前状态已经为运行状态了，则抛异常
      if (status == Status.RUNNING) {
        throw new IllegalArgumentException("Cannot restart a running request");
      }

      //如果完成后重新再加载，（一般通过notifyDataSetChanged这样的方法，在同一个Target或View中启动 相同的请求）
      //我们可以简单地使用上次检索到的资源和大小，跳过获取新大小，启动新加载等环节。
      //由于视图大小可能已更改，此时希望重新启动加载的用户需要在启动加载之前手动清除View或Target。
      if (status == Status.COMPLETE) {
        onResourceReady(resource, DataSource.MEMORY_CACHE);
        return;
      }

      //对于既没完成也不正在运行的请求，可以将其重新启动视为新请求。
      status = Status.WAITING_FOR_SIZE;  
      //判断宽高是狗有效。
      if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
      } else {
        //宽高无效，需要等待有效
        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));
      }
    }
  }

 
 
2个方法了
 onSizeReady(overrideWidth, overrideHeight);
 target.onLoadStarted(getPlaceholderDrawable());
 兄弟们，快了，这次真快了...再坚持一下子。
 
 
诶呀妈呀，可算是看到胜利的曙光了，我太难了。。。。
 
 
  public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();
    if (IS_VERBOSE_LOGGABLE) {
      logV("Got onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
    //检测下当前是否为等待状态。
    if (status != Status.WAITING_FOR_SIZE) {
      return;
    }
    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));
    }
    //说的天花乱坠的，这里才是加载的核心，缓存请求，都在这里，我单独开一篇去讲解，要不然我怕你们坚持不住了。
    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));
    }
  }

  //ImageViewTarget.onLoadStarted()加载完成
  public void onLoadStarted(@Nullable Drawable placeholder) {
    super.onLoadStarted(placeholder);
    setResourceInternal(null);
    setDrawable(placeholder);
  }

  public void setDrawable(Drawable drawable) {
    view.setImageDrawable(drawable);
  }

 
 
这头皮发麻的逻辑总算是喷....嗯..不对，总算是讲完了。你能看到这我敬你是条汉子，能有幸学习这么优秀的框架真的是荣幸至极。一次不懂没有关系。重要的是那颗学习的心。
 
 
多了也不说了，最后一句。
 
 
纵然前路迷茫，纵然天隔一方，纵然我手中的刀刃已然破碎，也无法阻挡我寻找你的道路。吾之初心 永世不忘 这个故事还没有完结。
 
 
飞机直达数据加载部分..
 对着那Glide最新版本就是一顿暴讲 2（数据加载篇）
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(对着那Glide最新版本就是一顿暴讲 1（框架流程篇）)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动
                        李蕾1229

                        
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                                
  • redis学习笔记——不仅仅是存取数据
                                    Everyday都不同
returnSourceexpire/delincr/lpush数据库分区redis
                                    
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷） 
  
1、关于JedisPool.returnSource(Jedis jeids) 
  
这个方法是从red
    
                                
    • 
                                
  • SQL性能优化-持续更新中。。。。。。
                                    atongyeye
oraclesql
                                    
    1 通过ROWID访问表--索引 
你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 
 
2 共享SQL语句--相同的sql放入缓存 
 
3 选择最有效率的表
    
                                
    • 
                                
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善
                                    comsci
JAVA虚拟机
                                    
     
     如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ 
 
&n
    
                                
    • 
                                
  • lvs- real
                                    男人50
LVS
                                    
    #!/bin/bash 
# 
# Script to start LVS DR real server. 
# description: LVS DR real server 
# 
#.  /etc/rc.d/init.d/functions 
 
VIP=10.10.6.252 
host='/bin/hostname' 
 
case "$1" in 
sta
    
                                
    • 
                                
  • 生成公钥和私钥
                                    oloz
DSA安全加密
                                    
    package com.msserver.core.util;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;

public class SecurityUtil {

    
                                
    • 
                                
  • UIView 中加入的cocos2d，背景透明
                                    374016526
cocos2dglClearColor
                                    
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
    
                                
    • 
                                
  • mysql常用命令
                                    香水浓
mysql
                                    
    连接数据库 
mysql -u troy -ptroy 
 
备份表 
mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 
 
恢复表（与恢复数据库命令相同） 
mysql -u troy -ptroy mm_database < user.sql 
 
备份数据库 
mysqldump -u troy -ptroy
    
                                
    • 
                                
  • 我的架构经验系列文章 - 后端架构 - 系统层面
                                    agevs
JavaScriptjquerycsshtml5
                                    
    系统层面：
高可用性

所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
    
                                
    • 
                                
  • 利用ant进行远程tomcat部署
                                    aijuans
tomcat
                                    
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 
1.配置tomcat的用户角色
    
                                
    • 
                                
  • 获取复利总收入
                                    baalwolf
获取
                                    
           public static void main(String args[]){ 
        int money=200; 
        int year=1; 
        double rate=0.1; 
&
    
                                
    • 
                                
  • eclipse.ini解释
                                    BigBird2012
eclipse
                                    
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 
Overview 
1、Eclipse.ini的作用 
Eclipse startup is controlled by th
    
                                
    • 
                                
  • AngularJS实现分页功能
                                    bijian1013
JavaScriptAngularJS分页
                                    
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。 
  &nbs
    
                                
    • 
                                
  • [Maven学习笔记三]Maven archetype
                                    bit1129
ArcheType
                                    
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等. 
  
mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式， 
  
mvn archetype 
  
1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
    
                                
    • 
                                
  • 【Java命令三】jps
                                    bit1129
Java命令
                                    
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看 
  
[hadoop@hadoop bin]$ jps -help
usage: jps [-help]
       jps [-q] [-mlvV] [<hostid>]

Definitions:
    <hostid>:      <hostname>[:
    
                                
    • 
                                
  • ZABBIX2.2 2.4 等各版本之间的兼容性
                                    ronin47

                                    
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 
zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
    
                                
    • 
                                
  • unity 3d还是cocos2dx哪个适合游戏？
                                    brotherlamp
unity自学unity教程unity视频unity资料unity
                                    
    unity 3d还是cocos2dx哪个适合游戏？ 
问：unity 3d还是cocos2dx哪个适合游戏？ 
答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2， 

    
                                
    • 
                                
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序
                                    bylijinnan
java算法面试百度招聘
                                    
    

import java.util.Arrays;

/**
 * 最早是在陈利人老师的微博看到这道题：
 * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K
 * 设计一个排序算法。It should be faster than O(n*lgn)。
    
                                
    • 
                                
  • 获取checkbox复选框的值
                                    chiangfai
checkbox
                                    
    <title>CheckBox</title>
  <script type = "text/javascript">
	doGetVal: function  doGetVal()
	{
		//var fruitName = document.getElementById("apple").value;//根据
    
                                
    • 
                                
  • MySQLdb用户指南
                                    chenchao051
mysqldb
                                    
    原网页被墙，放这里备用。  MySQLdb User's Guide  
Contents 
 
 Introduction 
 Installation 
  _mysql 
   
   MySQL C API translation 
   MySQL C API function mapping 
   Some _mysql examples 
    
  MySQLdb 
   
 
    
                                
    • 
                                
  • HIVE 窗口及分析函数
                                    daizj
hive窗口函数分析函数
                                    
    窗口函数应用场景： 
（1）用于分区排序 
（2）动态Group By 
（3）Top N 
（4）累计计算 
（5）层次查询 
 
一、分析函数 
用于等级、百分点、n分片等。 
函数             说明 
RANK()     &nbs
    
                                
    • 
                                
  • PHP ZipArchive 实现压缩解压Zip文件
                                    dcj3sjt126com
PHPzip
                                    
      
PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 
一、解压缩zip文件        01   02   03   04   05   06   07   08   09   10   11   
    
                                
    • 
                                
  • 精彩英语贺词
                                    dcj3sjt126com
英语
                                    
    I'm always here  
            我会一直在这里支持你  
              &nb
    
                                
    • 
                                
  • 基于Java注解的Spring的IoC功能
                                    e200702084
javaspringbeanIOCOffice
                                    
                                    
  
    
                                
    • 
                                
  • java模拟post请求
                                    geeksun
java
                                    
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。  此处用HttpComponents的httpclient来完成使命。   
import org.apache.http.HttpEntity ;
import org.apache.http.HttpRespon
    
                                
    • 
                                
  • Swift语法之 ---- ?和!区别
                                    hongtoushizi
?swift!
                                    
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html 
  
Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错：  
var stringValue : String 
//
    
                                
    • 
                                
  • centos7安装jdk1.7
                                    jisonami
jdkcentos
                                    
    安装JDK1.7 
步骤1、解压tar包在当前目录 
[root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 
步骤2：配置环境变量 
在etc/profile文件下添加 
export JAVA_HOME=/usr/java/jdk1.7.0_75 
export CLASSPATH=/usr/java/jdk1.7.0_75/lib 

    
                                
    • 
                                
  • 数据源架构模式之数据映射器
                                    home198979
PHP架构数据映射器datamapper
                                    
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。 
  
一、概念 
数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 
&nb
    
                                
    • 
                                
  • 在Python中使用MYSQL
                                    pda158
mysqlpython
                                    
    缘由   　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 
数据库中。   　　了解到 
Python在这方面有优势，便选用之。   　　由于我有台 
server上面安装有 
mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 
记录一下，大家共勉。   　　 
python中mysql的调用   　　 
百度之后能够通过MySQLdb进行数据库操作。
    
                                
    • 
                                
  • 单例模式
                                    hxl1988_0311
java单例设计模式单件
                                    
    package com.sosop.designpattern.singleton;

/*
 * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点
 * 
 * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件
 * 
 * 必须考虑到并发情况下创建了多个实例对象
 * */

/**
 * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
    
                                
    • 
                                
  • 27种迹象显示你应该辞掉程序员的工作
                                    vipshichg
工作
                                    
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。
    
                                
    •