一醉南柯
一醉南柯

图片加载框架 --Picasso 的基本使用

下面是我在学习Picasso过程中做的笔记,思路可能有些凌乱,如果阅读过程中有发现不准确或者错误的地方欢迎交流

内容主要分三部分，第一部分是picasso的基本使用，第二部分是picasso的源码阅读，最后一部分是关于源码中一些细节的梳理.

关于图片加载库的思考

我们为什么要用图片库呢? 
图片库通常会对图片加载逻辑进行封装、优化，比如多级缓存/异步线程调度/图片压缩变换,有了这些特性，开发者不再需要关注内存占用、 
OOM、网络请求等问题，而只需关注业务本身的逻辑，这对提高生产效率有很大帮助。

我工作半年以来也研究了一些主流的图片库,发现虽然每个图片的架构和实现细节不太一样，但是通常都会有以下模块:

  1. 请求分发模块。负责封装请求,对请求进行优先级排序,并按照类型进行分发。
  2. 缓存模块。通常包括一个二级的缓存，内存缓存、磁盘缓存。并预置多种缓存策略。
  3. 下载模块。负责下载网络图片。
  4. 监控模块。负责监控缓存命中率、内存占用、加载图片平均耗时等。
  5. 图片处理模块。负责对图片进行压缩、变换等处理。
  6. 本地资源加载模块。负责加载本地资源，如assert、drawable、sdcard等。
  7. 显示模块。负责将图片输出显示。

图片加载库

Android平台图片加载库现状

目前社区主流的图片加载库有Universal Image Loader,Picasso,Volley,Fresco,Glide.

Picasso简介

A powerful image downloading and caching library for Android,developed by Square

wiki:http://square.github.io/picasso/


Picasso的特性

  1. 绝对是最轻量的图片加载库,120kb.
  2. 自带监控功能，可以检测cache hit/内存大小等等数据
  3. 图片预加载
  4. 线程并发数依网络状态变化而变化、优先级调度
  5. 图片变换
  6. 图片压缩、自适应
  7. 易扩展

Picasso的使用

  • 加载一张网络图片到ImageView上
Picasso.with(context)
    .load(url)
    .placeholder(R.drawable.user_placeholder)
    .error(R.drawable.user_placeholder_error)
    .into(imageView);//此种策略并不会压缩图片
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    •
  • 预加载一张图片
Picasso.with(this).load(URL).fetch();
Picasso.with(this).load(URL).fetch(Callback);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    •

注意哦，如果你以以下面这种方式加上图形变换preload的话:

Picasso.with(this).load(URL).rotate(20).fetch();
   
   
   
   
    
    
    
    
    
  • 1
    •

再下面这种方式是取不到preload的图片的，因为预缓存的是经过变换后的图片，它的cachekey会有rotation标识

Picasso.with(this).load(URL).into(imageView);
   
   
   
   
    
    
    
    
    
  • 1
    •

当然我说的是preload到内存中的那份经过旋转的图片，http会缓存旋转前的图片到磁盘（支持缓存的情况下），所以最终还是可以从磁盘缓存 
拿到图片的。

  • 替换默认的Picasso
Picasso p = new Picasso.Builder(this).executor().downloader(downloader).memoryCache(cache).build();
Picasso.setSingletonInstance(p);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    •
  • 同步call
 new AsyncTask(){
        @Override
        protected Bitmap doInBackground(Void... params) {
            try {
                return Picasso.with(PicassoTestActivity.this).load(URL).get();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if(bitmap != null){
                imageView.setImageBitmap(bitmap);
            }
        }
    }.execute();
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    •

注意，必须在异步线程调用，否则crash,另外，这个结果并不会缓存到内存里面，所以慎用。

  • 自适应
Picasso.with(TestImageActivity.this).load(url).fit().into(imageview);
   
   
   
   
    
    
    
    
    
  • 1
    •

fit方法的意思是，让图片的宽高恰好等于imageView的宽高.前提是你的imageView控件不能设置成wrap_content,也就是必须 
有大小才行。另外，如果使用了fit方法，那么就不能调用resize.

  • 压缩到指定尺寸
Picasso.with(TestImageActivity.this).load(url).resize(widthPixel,heightPixel).centerInside().into(imageView);
Picasso.with(TestImageActivity.this).load(URL).resizeDimen(R.dimen.width,R.dimen.height).centerCrop().into(iv);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    •

resize后面通常接centerInside或者centerCrop。注意这跟ImageView的scaleTyoe没有关系，仅仅指的是图片的缩放方式。 
比如如下代码,iv不压缩，iv_2宽高压缩到40dp并且指定为centerInside.

"@+id/iv"
        android:background="#000"
        android:layout_width="100dp"
        android:layout_height="100dp"/>
"@id/iv"
    android:id="@+id/iv_2"
    android:background="#000"
    android:layout_width="100dp"
    android:layout_height="100dp"/>

Picasso.with(TestImageActivity.this).load(URL).into(iv);
Picasso.with(TestImageActivity.this).load(URL).resizeDimen(R.dimen.width/*40dp*/, R.dimen.height/*40dp*/).centerInside().into(iv_2);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    •

最终显示结果如下:

demo

可以很明显看到下面的图模糊许多，这是因为图片被压缩了，但是显示的时候又被ImageView拉伸了(默认scaleType是fitCenter)， 
要想不显示拉伸的图,可以给iv_2增加scaleType="centerInside",效果如下:

demo

  • 图形变换
Picasso.with(TestImageActivity.this).load(URL).rotate(20).into(iv);
//自定义变换
 Picasso.with(TestImageActivity.this).load(URL).transform(new Transformation() {
                    @Override
                    public Bitmap transform(Bitmap source) {//从原图中间裁剪一个正方形
                        int size = Math.min(source.getWidth(), source.getHeight());
                        int x = (source.getWidth() - size) / 2;
                        int y = (source.getHeight() - size) / 2;
                        Bitmap result = Bitmap.createBitmap(source, x, y, size, size);
                        if (result != source) {
                            source.recycle();
                        }
                        return result;
                    }

                    @Override
                    public String key() {
                        return "square()";
                    }
                }).into(iv);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    •

各种图形变换:https://github.com/wasabeef/picasso-transformations

  • 暂停/重启请求任务

通常在滑动列表的时候需要暂停请求


Picasso.with(context).load(URL).tag(context);


public class SampleScrollListener implements AbsListView.OnScrollListener {
  private final Context context;


  public SampleScrollListener(Context context) {
    this.context = context;
  } 


  @Override 
  public void onScrollStateChanged(AbsListView view, int scrollState) {
    final Picasso picasso = Picasso.with(context);
    if (scrollState == SCROLL_STATE_IDLE || scrollState == SCROLL_STATE_TOUCH_SCROLL) {
      picasso.resumeTag(context);
    } else { 
      picasso.pauseTag(context);
    } 
  } 


  @Override 
  public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
                       int totalItemCount) {
    // Do nothing. 
  } 
}

   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    •

Picasso源码分析

其实看源码分析什么的最无聊了，最好的方式是自己跟一遍源码,picasso里面有很多设计很优雅的地方，只有自己看了才会真正有收获.

整体架构

盗用下Trinea的图:

整体架构

Picasso中的核心类包括Picasso、Dispatcher、BitmapHunter、RequestHandler、Request、Action、Cache 
等.Picasso类是一个负责图片下载、变换、缓存的管理器,当它收到一个图片下载请求的时候，它会创建Request并提交给Dispatcher, 
Dispatcher会寻找对应的处理器RequestHandler,并将请求与该处理器一起提交给线程池执行,图片获取成功后，最终会交给 
PicassoDrawable显示到Target上。

它将一张图片的加载过程分为八步，依次为:

创建->入队->执行->解码->变换->批处理->完成->分发->显示(可选)

也可以从日志中看到这个过程:

11-05 10:39:00.942 2952-2952/com.taobao.paimainews D/Picasso: Main        created      [R0] Request{http://ww3.sinaimg.cn/mw600/006g34NHgw1exj5c4hmfvj30hs0qoqff.jpg resize(90,300) centerInside rotation(30.0) ARGB_8888}
11-05 10:39:00.981 2952-3109/com.taobao.paimainews D/Picasso: Dispatcher  enqueued     [R0]+40ms
11-05 10:39:00.993 2952-3193/com.taobao.paimainews D/Picasso: Hunter      executing    [R0]+50ms
11-05 10:39:01.038 2952-3193/com.taobao.paimainews D/Picasso: Hunter      decoded      [R0]+97ms
11-05 10:39:01.041 2952-3193/com.taobao.paimainews D/Picasso: Hunter      transformed  [R0]+100ms
11-05 10:39:01.042 2952-3109/com.taobao.paimainews D/Picasso: Dispatcher  batched      [R0]+101ms for completion
11-05 10:39:01.279 2952-2952/com.taobao.paimainews D/Picasso: Main        completed    [R0]+338ms from DISK
11-05 10:39:01.280 2952-3109/com.taobao.paimainews D/Picasso: Dispatcher  delivered    [R0]+338ms
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    •

下面是Picasso的类图:

类图

代码分析

版本:2.5.2

Picasso类是整个图片加载器的入口，负责初始化各个模块，配置相关参数等等。 
Picasso.with()方法用于创建全局唯一的Picasso实例,为了确保唯一，使用了单例模式。

Picasso#with()

 static volatile Picasso singleton = null;

 public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    •

with方法内部通过Builder模式创建Picasso实例，这样做的好处是简洁清晰，通常在构造器参数很多的时候使用。 
build方法会最终创建Picasso实例:

Picasso#Builder#build()

 public Picasso build() {
      Context context = this.context;

      if (downloader == null) {
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {
        cache = new LruCache(context);
      }
      if (service == null) {
        service = new PicassoExecutorService();
      }
      if (transformer == null) {
        transformer = RequestTransformer.IDENTITY;
      }

      Stats stats = new Stats(cache);

      Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
    }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    •

此方法做了如下基本配置:

  1. 使用默认的缓存策略，内存缓存基于LruCache,磁盘缓存基于http缓存,HttpResponseCache
  2. 创建默认的下载器
  3. 创建默认的线程池(3个worker线程)
  4. 创建默认的Transformer,这个Transformer什么事情也不干，只负责转发请求
  5. 创建默认的监控器(Stats),用于统计缓存命中率、下载时长等等
  6. 创建默认的处理器集合,即RequestHandlers.它们分别会处理不同的加载请求

处理器集合的初始化在Picasso的构造器中: 
Picasso构造器

    allRequestHandlers.add(new ResourceRequestHandler(context));
    if (extraRequestHandlers != null) {
      allRequestHandlers.addAll(extraRequestHandlers);
    }
    allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
    allRequestHandlers.add(new MediaStoreRequestHandler(context));
    allRequestHandlers.add(new ContentStreamRequestHandler(context));
    allRequestHandlers.add(new AssetRequestHandler(context));
    allRequestHandlers.add(new FileRequestHandler(context));
    allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
    requestHandlers = Collections.unmodifiableList(allRequestHandlers);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    •

从命名就可以看出来，可以从网络、file、assert、contactsphoto等地方加载图片.

另,Picasso支持增加自己的处理器.

load()方法用于从不同地方加载图片，比如网络、resource、File等，该方法内部逻辑很简单，只是创建了一个RequestCreator

Picasso#load()

 public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    •

RequestCreator从名字就可以知道这是一个封装请求的类,请求在Picasso中被抽象成Request。RequestCreator类提供了 
诸如placeholder、tag、error、memoryPolicy、networkPolicy等方法. 
由于可配置项太多，所以Request也使用了Builder模式: 
RequestCreator构造器

  RequestCreator(Picasso picasso, Uri uri, int resourceId) {
    if (picasso.shutdown) {
      throw new IllegalStateException(
          "Picasso instance already shut down. Cannot submit new requests.");
    }
    this.picasso = picasso;
    this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    •

那么可想而知into方法一定会去将Request创建，并丢到线程池或者分发器中执行。into方法有多种重载，因为Picasso不仅仅可以 
将图片加载到ImageView上，还可以加载到Target或者RemoteView上. 
这里选取imageView作为分析对象,该方法代码如下：

RequestCreator#into()

public void into(ImageView target, Callback callback) {
    long started = System.nanoTime();
    checkMain();//检查是否在主线程中执行

    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }

    if (!data.hasImage()) {//检查是否设置uri或者resID
      //如果没有设置当然取消请求
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }

    if (deferred) {//是否调用了fit(),如果是，代表需要将image调整为ImageView的大小
      if (data.hasSize()) {//不能与resize一起用
        throw new IllegalStateException("Fit cannot be used with resize.");
      }
      //既然要适应ImageView，肯定需要拿到ImageView大小
      int width = target.getWidth();
      int height = target.getHeight();
      if (width == 0 || height == 0) {
        if (setPlaceholder) {
          setPlaceholder(target, getPlaceholderDrawable());
        }
        picasso.defer(target, new DeferredRequestCreator(this, target, callback));
        return;
      }
      data.resize(width, height);
    }

    //创建request
    Request request = createRequest(started);
    String requestKey = createKey(request);

    if (shouldReadFromMemoryCache(memoryPolicy)) {//是否需要在缓存里面先查找
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      if (bitmap != null) {//cache hit
        picasso.cancelRequest(target);
        setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
        if (picasso.loggingEnabled) {
          log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
        }
        if (callback != null) {
          callback.onSuccess();
        }
        return;
      }
    }

    //缓存未命中，那就创建Action，将任务交给dispatcher
    if (setPlaceholder) {
      setPlaceholder(target, getPlaceholderDrawable());
    }

    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    picasso.enqueueAndSubmit(action);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    • 
    
    
    
    
  • 32
    • 
    
    
    
    
  • 33
    • 
    
    
    
    
  • 34
    • 
    
    
    
    
  • 35
    • 
    
    
    
    
  • 36
    • 
    
    
    
    
  • 37
    • 
    
    
    
    
  • 38
    • 
    
    
    
    
  • 39
    • 
    
    
    
    
  • 40
    • 
    
    
    
    
  • 41
    • 
    
    
    
    
  • 42
    • 
    
    
    
    
  • 43
    • 
    
    
    
    
  • 44
    • 
    
    
    
    
  • 45
    • 
    
    
    
    
  • 46
    • 
    
    
    
    
  • 47
    • 
    
    
    
    
  • 48
    • 
    
    
    
    
  • 49
    • 
    
    
    
    
  • 50
    • 
    
    
    
    
  • 51
    • 
    
    
    
    
  • 52
    • 
    
    
    
    
  • 53
    • 
    
    
    
    
  • 54
    • 
    
    
    
    
  • 55
    • 
    
    
    
    
  • 56
    • 
    
    
    
    
  • 57
    • 
    
    
    
    
  • 58
    • 
    
    
    
    
  • 59
    • 
    
    
    
    
  • 60
    • 
    
    
    
    
  • 61
    • 
    
    
    
    
  • 62
    • 
    
    
    
    
  • 63
    • 
    
    
    
    
  • 64
    •

逻辑注释写的很清楚了，into方法会先从缓存里面查找图片，如果找不到的话，则会创建Action即一个加载任务，交给Dispatcher执行。 
那我们就来看看picasso.enqueueAndSubmit方法做了什么. 
在这之前，先来看下Action是什么鬼，为什么有了Request还要Action.

先看Request有哪些属性:

  int id;
  long started;
  int networkPolicy;
  public final Uri uri;
  public final int resourceId;
  public final String stableKey;
  public final List transformations;
  public final int targetWidth;
  public final int targetHeight;
  public final boolean centerCrop;
  public final boolean centerInside;
  public final boolean onlyScaleDown;
  public final float rotationDegrees;
  public final float rotationPivotX;
  public final float rotationPivotY;
  public final boolean hasRotationPivot;
  public final Bitmap.Config config;
  public final Priority priority;
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    •

再看Action的属性:

  final Picasso picasso;
  final Request request;
  final WeakReference target;
  final boolean noFade;
  final int memoryPolicy;
  final int networkPolicy;
  final int errorResId;
  final Drawable errorDrawable;
  final String key;
  final Object tag;
  boolean willReplay;
  boolean cancelled;
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    •

Request关注的是请求本身，比如请求的源、id、开始时间、图片变换配置、优先级等等，而Action则代表的是一个加载任务，所以不仅需要 
Request对象的引用，还需要Picasso实例，是否重试加载等等

Action有个需要关注的点，那就是WeakReference target,它持有的是Target(比如ImageView..)的弱引用，这样可以保证加载时间很长的情况下 
也不会影响到Target的回收了.

好的，那回到刚才的思路，我们开始分析picasso.enqueueAndSubmit方法:

picasso#enqueueAndSubmit()

  final Map targetToAction;
   ...
  this.targetToAction = new WeakHashMap();
   ...
  void enqueueAndSubmit(Action action) {
    Object target = action.getTarget();
    if (target != null && targetToAction.get(target) != action) {
      // This will also check we are on the main thread.
      cancelExistingRequest(target);
      targetToAction.put(target, action);
    }
    submit(action);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    •

它会先从action任务上拿到对应target，也就是imageView，然后从weakHashMap中通过这个imageView索引到对应的action，如果 
发现这个action跟传进来的action不一样的话，那就取消掉之前的加载任务。最后将当前加载任务提交.

跟进submit发现最终调用的是Dispatcher的dispatchSubmit(action)方法.这个Dispatcher即任务分发器，它是在 
Picasso实例创建的时候初始化的.。

那我们在看dispatchSubmit方法之前，必然得了解下Dispatcher.

Picasso.Builder.build()

  Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);
   
   
   
   
    
    
    
    
    
  • 1
    •

每一个Dispatcher都需要关联线程池(service)、下载器(downloader)、主线程的Handler(HANDLER)、缓存(cache)、 
监控器(stats).

这里先看线程池,Picasso默认的线程池叫PicassoExecutorService,它继承自ThreadPoolExecutor,默认线程数量为 
3.但是PicassoExecutorService的特性是可以根据网络情况调整线程数量，wifi下是4个线程，而2g网只有一个线程。具体是 
通过在Dispatcher中注册了监听网络变化的广播接收者。

另外，PicassoExecutorService中还有一个很重要的方法叫submit,它会去执行一个runnable.

好的，我们回到Dispatcher,这里还需要关注的是Dispatcher中有个内部类叫DispatcherHandler,注意哦， 
这个handler是Dispatcher自己的，而不是构造器传进来的。而且，这个handler绑定的是子线程的Looper，为什么？请看:

Dispatcher#构造器

    this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
   
   
   
   
    
    
    
    
    
  • 1
    •

而dispatcherThread则是一个HandlerThread:

Dispatcher内部类

 static class DispatcherThread extends HandlerThread {
    DispatcherThread() {
      super(Utils.THREAD_PREFIX + DISPATCHER_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
    }
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    •

也就是说，这个handler的消息处理是在子线程进行的!这样就可以避免阻塞主线程的消息队列啦!

好的，再回到刚才的问题，来看下dispatchSubmit方法（不知道大家有没有看晕。。。。）:

Dispatcher#dispatchSubmit

 void dispatchSubmit(Action action) {
    handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    •

不用看都知道会发消息给handler。而handler收到这个消息之后调用了这个方法:

 dispatcher.performSubmit(action);
   
   
   
   
    
    
    
    
    
  • 1
    •

果断跟进去:

Dispatcher#performSubmit

 void performSubmit(Action action, boolean dismissFailed) {//注意哦，这里已经不在主线程了，而是在dispatcher线程(HandlerThread)
    if (pausedTags.contains(action.getTag())) {//此任务是否被暂停
      pausedActions.put(action.getTarget(), action);
      if (action.getPicasso().loggingEnabled) {
        log(OWNER_DISPATCHER, VERB_PAUSED, action.request.logId(),
            "because tag '" + action.getTag() + "' is paused");
      }
      return;
    }

    BitmapHunter hunter = hunterMap.get(action.getKey());
    if (hunter != null) {
      hunter.attach(action);
      return;
    }

    if (service.isShutdown()) {//线程池是否关闭
      if (action.getPicasso().loggingEnabled) {
        log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), "because shut down");
      }
      return;
    }

    //创建hunter
    hunter = forRequest(action.getPicasso(), this, cache, stats, action);
    hunter.future = service.submit(hunter);
    hunterMap.put(action.getKey(), hunter);
    if (dismissFailed) {
      failedActions.remove(action.getTarget());
    }

    if (action.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId());
    }
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    • 
    
    
    
    
  • 32
    • 
    
    
    
    
  • 33
    • 
    
    
    
    
  • 34
    • 
    
    
    
    
  • 35
    •

首先创建了一个BitmapHunter,它继承自Runnable,可以被线程池调用。然后判断线程池有没有关闭，如果没有的话， 
就会将这个bitmapHunter丢到线程池里面，即调用刚才说的submit方法。

我们先看下forRequest方法里面干了什么:

BitmapHunter#forRequest

 static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,
      Action action) {
    Request request = action.getRequest();
    List requestHandlers = picasso.getRequestHandlers();

    // Index-based loop to avoid allocating an iterator.
    //noinspection ForLoopReplaceableByForEach
    for (int i = 0, count = requestHandlers.size(); i < count; i++) {
      RequestHandler requestHandler = requestHandlers.get(i);
      if (requestHandler.canHandleRequest(request)) {
        return new BitmapHunter(picasso, dispatcher, cache, stats, action, requestHandler);
      }
    }
    //没有人能处理这个请求，那么交给ERRORING_HANDLER,它会直接抛异常
    return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    •

还记得大明湖畔的Picasso么?在它的构造器中创建了若干RequestHandler,用于处理不同的加载请求，在这里，它会遍历 
这些requestHandler，看谁可以处理当前请求，如果发现了，那就创建BitmapHandler,并把这个requestHandler传进去，

线程池在收到BitmapHunter之后，会调用其run方法，那么我们就来看下:

BitmapHunter#run

@Override public void run() {
    try {
      updateThreadName(data);

      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
      }

      result = hunt();

      if (result == null) {
        dispatcher.dispatchFailed(this);
      } else {
        dispatcher.dispatchComplete(this);
      }
    } catch (Downloader.ResponseException e) {
      if (!e.localCacheOnly || e.responseCode != 504) {
        exception = e;
      }
      dispatcher.dispatchFailed(this);
    } catch (NetworkRequestHandler.ContentLengthException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (IOException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (OutOfMemoryError e) {
      StringWriter writer = new StringWriter();
      stats.createSnapshot().dump(new PrintWriter(writer));
      exception = new RuntimeException(writer.toString(), e);
      dispatcher.dispatchFailed(this);
    } catch (Exception e) {
      exception = e;
      dispatcher.dispatchFailed(this);
    } finally {
      Thread.currentThread().setName(Utils.THREAD_IDLE_NAME);
    }
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    • 
    
    
    
    
  • 32
    • 
    
    
    
    
  • 33
    • 
    
    
    
    
  • 34
    • 
    
    
    
    
  • 35
    • 
    
    
    
    
  • 36
    • 
    
    
    
    
  • 37
    • 
    
    
    
    
  • 38
    •

核心逻辑是由hunt方法完成的，下面一堆catch语句分别捕捉不同的异常然后上报给dispatcher进行处理。 
而hunt方法里面肯定会调用RequestHandler的load方法:

BitmapHunter#hunt

Bitmap hunt() throws IOException {
    Bitmap bitmap = null;

    //依然先从缓存拿
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      bitmap = cache.get(key);
      if (bitmap != null) {
        stats.dispatchCacheHit();
        loadedFrom = MEMORY;
        if (picasso.loggingEnabled) {
          log(OWNER_HUNTER, VERB_DECODED, data.logId(), "from cache");
        }
        return bitmap;
      }
    }

    //缓存没有命中的话，再调用requestHandler.load
    data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
    RequestHandler.Result result = requestHandler.load(data, networkPolicy);
    //拿到结果
    if (result != null) {
      loadedFrom = result.getLoadedFrom();
      exifRotation = result.getExifOrientation();
       //从结果中拿bitmap
      bitmap = result.getBitmap();

      // If there was no Bitmap then we need to decode it from the stream.
      if (bitmap == null) {
        InputStream is = result.getStream();
        try {
        //压缩
          bitmap = decodeStream(is, data);
        } finally {
          Utils.closeQuietly(is);
        }
      }
    }

    if (bitmap != null) {
      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_DECODED, data.logId());
      }
      stats.dispatchBitmapDecoded(bitmap);
      //图片变换
      if (data.needsTransformation() || exifRotation != 0) {
        synchronized (DECODE_LOCK) {
          if (data.needsMatrixTransform() || exifRotation != 0) {
            bitmap = transformResult(data, bitmap, exifRotation);
            if (picasso.loggingEnabled) {
              log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
            }
          }
          if (data.hasCustomTransformations()) {
            bitmap = applyCustomTransformations(data.transformations, bitmap);
            if (picasso.loggingEnabled) {
              log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
            }
          }
        }
        if (bitmap != null) {
          stats.dispatchBitmapTransformed(bitmap);
        }
      }
    }

    return bitmap;
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    • 
    
    
    
    
  • 32
    • 
    
    
    
    
  • 33
    • 
    
    
    
    
  • 34
    • 
    
    
    
    
  • 35
    • 
    
    
    
    
  • 36
    • 
    
    
    
    
  • 37
    • 
    
    
    
    
  • 38
    • 
    
    
    
    
  • 39
    • 
    
    
    
    
  • 40
    • 
    
    
    
    
  • 41
    • 
    
    
    
    
  • 42
    • 
    
    
    
    
  • 43
    • 
    
    
    
    
  • 44
    • 
    
    
    
    
  • 45
    • 
    
    
    
    
  • 46
    • 
    
    
    
    
  • 47
    • 
    
    
    
    
  • 48
    • 
    
    
    
    
  • 49
    • 
    
    
    
    
  • 50
    • 
    
    
    
    
  • 51
    • 
    
    
    
    
  • 52
    • 
    
    
    
    
  • 53
    • 
    
    
    
    
  • 54
    • 
    
    
    
    
  • 55
    • 
    
    
    
    
  • 56
    • 
    
    
    
    
  • 57
    • 
    
    
    
    
  • 58
    • 
    
    
    
    
  • 59
    • 
    
    
    
    
  • 60
    • 
    
    
    
    
  • 61
    • 
    
    
    
    
  • 62
    • 
    
    
    
    
  • 63
    • 
    
    
    
    
  • 64
    • 
    
    
    
    
  • 65
    • 
    
    
    
    
  • 66
    • 
    
    
    
    
  • 67
    •

这里假设是一个网络请求，那么最终NetworkRequestHandler会处理请求：

NetworkRequestHandler#load

@Override public Result load(Request request, int networkPolicy) throws IOException {

    //这个downloader也是Dispatcher创建的时候传进来的
    Response response = downloader.load(request.uri, request.networkPolicy);
    if (response == null) {
      return null;
    }
    //判断是从缓存还是网络拿的
    Picasso.LoadedFrom loadedFrom = response.cached ? DISK : NETWORK;
    //从响应中拿到bitmap
    Bitmap bitmap = response.getBitmap();
    if (bitmap != null) {
      return new Result(bitmap, loadedFrom);
    }
    //如果是从网络返回的，那么拿到的是流对象
    InputStream is = response.getInputStream();
    if (is == null) {
      return null;
    }
    // Sometimes response content length is zero when requests are being replayed. Haven't found
    // root cause to this but retrying the request seems safe to do so.
    if (loadedFrom == DISK && response.getContentLength() == 0) {
      Utils.closeQuietly(is);
      throw new ContentLengthException("Received response with 0 content-length header.");
    }
    if (loadedFrom == NETWORK && response.getContentLength() > 0) {
      stats.dispatchDownloadFinished(response.getContentLength());
    }
    //将结果封装返回
    return new Result(is, loadedFrom);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    •

现在我们关注下这个downloader的前世今生,如果用户没有自定义的话，那将使用默认downloader:

Picasso#Builder#build()

 downloader = Utils.createDefaultDownloader(context);
   
   
   
   
    
    
    
    
    
  • 1
    •

Utils#createDefaultDownloader

static Downloader createDefaultDownloader(Context context) {
    try {
      Class.forName("com.squareup.okhttp.OkHttpClient");
      return OkHttpLoaderCreator.create(context);
    } catch (ClassNotFoundException ignored) {
    }
    return new UrlConnectionDownloader(context);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    •

首先反射下，看有没有依赖okhttp，如果依赖的话，那就使用OkHttpClient喽，否则就使用默认的HttpUrlConnection了。 
注:其实从4.4开始，okhttp已经作为HttpUrlConnection的实现引擎了。

可以从picasso的pom文件里面看到，okhttp是optional的:

 <dependency>
      <groupId>com.squareup.okhttpgroupId>
      <artifactId>okhttpartifactId>
      <optional>trueoptional>
    dependency>
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    •

以UrlConnectionDownloader为例，看下它的load方法:

  @Override public Response load(Uri uri, int networkPolicy) throws IOException {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
      installCacheIfNeeded(context);
    }

    HttpURLConnection connection = openConnection(uri);
    connection.setUseCaches(true);

    if (networkPolicy != 0) {
      String headerValue;

      if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
        headerValue = FORCE_CACHE;
      } else {
        StringBuilder builder = CACHE_HEADER_BUILDER.get();
        builder.setLength(0);

        if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
          builder.append("no-cache");
        }
        if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
          if (builder.length() > 0) {
            builder.append(',');
          }
          builder.append("no-store");
        }

        headerValue = builder.toString();
      }

      connection.setRequestProperty("Cache-Control", headerValue);
    }

    int responseCode = connection.getResponseCode();
    if (responseCode >= 300) {
      connection.disconnect();
      throw new ResponseException(responseCode + " " + connection.getResponseMessage(),
          networkPolicy, responseCode);
    }

    long contentLength = connection.getHeaderFieldInt("Content-Length", -1);
    boolean fromCache = parseResponseSourceHeader(connection.getHeaderField(RESPONSE_SOURCE));

    return new Response(connection.getInputStream(), fromCache, contentLength);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    • 
    
    
    
    
  • 20
    • 
    
    
    
    
  • 21
    • 
    
    
    
    
  • 22
    • 
    
    
    
    
  • 23
    • 
    
    
    
    
  • 24
    • 
    
    
    
    
  • 25
    • 
    
    
    
    
  • 26
    • 
    
    
    
    
  • 27
    • 
    
    
    
    
  • 28
    • 
    
    
    
    
  • 29
    • 
    
    
    
    
  • 30
    • 
    
    
    
    
  • 31
    • 
    
    
    
    
  • 32
    • 
    
    
    
    
  • 33
    • 
    
    
    
    
  • 34
    • 
    
    
    
    
  • 35
    • 
    
    
    
    
  • 36
    • 
    
    
    
    
  • 37
    • 
    
    
    
    
  • 38
    • 
    
    
    
    
  • 39
    • 
    
    
    
    
  • 40
    • 
    
    
    
    
  • 41
    • 
    
    
    
    
  • 42
    • 
    
    
    
    
  • 43
    • 
    
    
    
    
  • 44
    • 
    
    
    
    
  • 45
    •

注意哦，Disk Cache功能是在这里做掉的，它基于Http语义来判断是否缓存. 
另，返回的是inputStream流，而不是Bitmap对象.

好的，现在我们回到BitmapHunter#run(),它在拿到结果后会将结果交给dispatcher

BitmapHunter#run()

 if (result == null) {
        dispatcher.dispatchFailed(this);
      } else {
        dispatcher.dispatchComplete(this);
      }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    •

我们看dispatcher.dispatchComplete(this),它会把消息发给自己内部的handler，也就是刚才说的Looper在子线程 
的handler,handler将做如下处理:

  BitmapHunter hunter = (BitmapHunter) msg.obj;
  dispatcher.performComplete(hunter);
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    •

注意哦，BitmapHunter会持有网络请求回来的Bitmap引用.来看下performComplete:

Dispatcher#performComplete

void performComplete(BitmapHunter hunter) {
    if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }
    hunterMap.remove(hunter.getKey());
    batch(hunter);
    if (hunter.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion");
    }
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    •

首先会根据事先设置的缓存策略决定是否将结果加到内存缓存。然后调用batch方法，从名字就可以知道，这个方法会把结果暂存， 
然后批量处理(等待200ms)，这样做也是为了防止短时间大量任务阻塞消息队列。到时间后，就会执行performBatchComplete, 
此方法会将这个批次的所有结果一次性发给主线程的Handler，也就是Picasso中定义的Handler:

Dispatcher#performBatchComplete

  void performBatchComplete() {
    List copy = new ArrayList(batch);
    batch.clear();
    mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
    logBatch(copy);
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    •

主线程收到消息后会进行处理:

case HUNTER_BATCH_COMPLETE: {
          @SuppressWarnings("unchecked") List batch = (List) msg.obj;
          //noinspection ForLoopReplaceableByForEach
          for (int i = 0, n = batch.size(); i < n; i++) {
            BitmapHunter hunter = batch.get(i);
            hunter.picasso.complete(hunter);
          }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    •

对batch中每个BitmapHunter调用complete方法,而complete方法会调用deliverAction方法,最终其实调用的是具体 
action的complete方法，如果是ImageView的话，那就是ImageViewAction的complete方法:

ImageViewAction#complete

 @Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
    if (result == null) {
      throw new AssertionError(
          String.format("Attempted to complete action with no result!\n%s", this));
    }

    ImageView target = this.target.get();
    if (target == null) {
      return;
    }

    Context context = picasso.context;
    boolean indicatorsEnabled = picasso.indicatorsEnabled;
    PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

    if (callback != null) {
      callback.onSuccess();
    }
  }
   
   
   
   
    
    
    
    
    
  • 1
    • 
    
    
    
    
  • 2
    • 
    
    
    
    
  • 3
    • 
    
    
    
    
  • 4
    • 
    
    
    
    
  • 5
    • 
    
    
    
    
  • 6
    • 
    
    
    
    
  • 7
    • 
    
    
    
    
  • 8
    • 
    
    
    
    
  • 9
    • 
    
    
    
    
  • 10
    • 
    
    
    
    
  • 11
    • 
    
    
    
    
  • 12
    • 
    
    
    
    
  • 13
    • 
    
    
    
    
  • 14
    • 
    
    
    
    
  • 15
    • 
    
    
    
    
  • 16
    • 
    
    
    
    
  • 17
    • 
    
    
    
    
  • 18
    • 
    
    
    
    
  • 19
    •

注意看这一句，ImageView target = this.target.get(),因为target是ImageView的弱引用，在下载过程中， 
ImageView可能已经被销毁了，所以这里要做下判断。

如果没有被回收，那么图片最终通过PicassoDrawable.setBitmap()方法被设置到ImageView上. 
这个PicassoDrawable提供了fade动画.

好了，分析基本完毕,下面是整个流程的时序图.

时序图

简单总结下，当我们执行Picasso.with(context).load(url).into(imageview)时，首先会构造Picasso实例，然后会 
根据url创建请求，然后请求会被交给Dispatcher,Dispatcher将在子线程对请求任务进行调度，将请求任务交给线程池 
执行，执行完毕后，将结果传给主线程的handler，最后在主线程中将图片设置到ImageView上.

其他需要关注的点

  • 关于缓存策略

    Picasso的缓存是内存缓存+磁盘缓存，内存缓存基于LruCache类，可配置替换。磁盘缓存依赖于http缓存，不可配置。 
    先看内存缓存.内存缓存比较简单，是通过LinkedHashMap实现. 
    读缓存时机:生成了请求Request对象，准备创建Action加载任务之前，会先去缓存里面查找下.

    RequestCreator#into

    if (shouldReadFromMemoryCache(memoryPolicy)) {
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      if (bitmap != null) {
        picasso.cancelRequest(target);
        setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
        if (picasso.loggingEnabled) {
          log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
        }
        if (callback != null) {
          callback.onSuccess();
        }
        return;
      }
    }

     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
      
      
      
      
    • 3
      • 
      
      
      
      
    • 4
      • 
      
      
      
      
    • 5
      • 
      
      
      
      
    • 6
      • 
      
      
      
      
    • 7
      • 
      
      
      
      
    • 8
      • 
      
      
      
      
    • 9
      • 
      
      
      
      
    • 10
      • 
      
      
      
      
    • 11
      • 
      
      
      
      
    • 12
      • 
      
      
      
      
    • 13
      • 
      
      
      
      
    • 14
      • 
      
      
      
      
    • 15
      •

    写缓存时机:图片从网络或者其他地方加载成功后，即在BitmapHunter的run方法执行结束的时候. 
    Dispatcher#performComplete

    
 if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }

     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
      
      
      
      
    • 3
      • 
      
      
      
      
    • 4
      • 
      
      
      
      
    • 5
      •

    注意哦，缓存的是经过压缩之后的图片（如果你使用了fit或者resize方法的话）， 
    再看磁盘缓存。 
    如果你是使用UrlConnectionDownloader的话,那很不幸，缓存只在Api>14上生效，因为缓存依赖于HttpResponseCache. 
    如果你依赖了okhttp，那么缓存策略始终是有效的。另外需要说明的是，既然是http缓存，那么缓存的可用性依赖于http响应是 
    否允许缓存，也就是说得看响应中是否携带Cache-Control、Expires等字段.对于这块不了解的话，可以参考我的这篇文章: 
    HttpCache in android 
    还有一点，缓存的路径是 应用cache目录/picasso-cache 文件夹.具体代码参考Utils.createDefaultCacheDir方法

  • 关于预加载

    首先要注意的是Callback是一个强引用，如果你使用带Callback的重载形式的话，只有当Request结束的时候才会释放 
    引用，在此期间你的Activity/Fragment等组件引用不会被释放.因此你需要注意内存泄露的情形.

    怎么实现?很简单拉，调fetch的时候创建了FetchAction,然后其他流程上面描述的一样,最终在Dispatcher.performComplete 
    的时候将结果写入内存缓存，结果回传到主线程的时候，调用了FetchAction的complete方法，这里面不对Bitmap做 
    任何处理就行拉:

    FetchAction#complete

    ```
 @Override void complete(Bitmap result, Picasso.LoadedFrom from) {
       if (callback != null) {
         callback.onSuccess();
       }
     }
```

  • 关于图形变换

    图形变换在Picasso中被抽象成Transformation接口，具体的变换操作由transform方法实现.Request维护一个 
    图形变换的列表List,当图片加载成功后，BitmapHunter中将会遍历这个变换集合，依次进行变换， 
    最后返回变换后的bitmap.恩，其实是一个回调的思想，将操作封装到接口中交给系统，系统在某个特定时机调用你的接口。

    具体代码:

    BitmapHunter#applyCustomTransformations

       ```
   static Bitmap applyCustomTransformations(List transformations, Bitmap result) {
             for (int i = 0, count = transformations.size(); i < count; i++) {
               final Transformation transformation = transformations.get(i);
               Bitmap newResult;
               try {
                 newResult = transformation.transform(result);
               } catch (final RuntimeException e) {
                 Picasso.HANDLER.post(new Runnable() {
                   @Override public void run() {
                     throw new RuntimeException(
                         "Transformation " + transformation.key() + " crashed with exception.", e);
                   }
                 });
                 return null;
               }
               ....
               result = newResult;
             }
             return result;
           } 

   ```

  • 关于CleanupThread

    Picasso类中有一个内部线程叫CleanupThread,这是一个daemon线程,它的工作是找到那些Target(比如说ImageView)已经被回收 
    但是所对应的Request请求还在继续的任务(Action),找到之后,会取消对应的请求,避免资源浪费.

    看下代码:

    Picasso#CleanupThread

     private static class CleanupThread extends Thread {
    private final ReferenceQueue referenceQueue;
    private final Handler handler;

    CleanupThread(ReferenceQueue referenceQueue, Handler handler) {//关联主线程的handler,refreenceQueue
      this.referenceQueue = referenceQueue;
      this.handler = handler;
      setDaemon(true);
      setName(THREAD_PREFIX + "refQueue");
    }

    @Override public void run() {
      Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);
      while (true) {
        try {
          // Prior to Android 5.0, even when there is no local variable, the result from
          // remove() & obtainMessage() is kept as a stack local variable.
          // We're forcing this reference to be cleared and replaced by looping every second
          // when there is nothing to do.
          // This behavior has been tested and reproduced with heap dumps.
          RequestWeakReference remove =
              (RequestWeakReference) referenceQueue.remove(THREAD_LEAK_CLEANING_MS);
          Message message = handler.obtainMessage();
          if (remove != null) {
            message.what = REQUEST_GCED;
            message.obj = remove.action;
            handler.sendMessage(message);
          } else {
            message.recycle();
          }
        } catch (InterruptedException e) {
          break;
        } catch (final Exception e) {
          handler.post(new Runnable() {
            @Override public void run() {
              throw new RuntimeException(e);
            }
          });
          break;
        }
      }
    }

    void shutdown() {
      interrupt();
    }
  }
     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
      
      
      
      
    • 3
      • 
      
      
      
      
    • 4
      • 
      
      
      
      
    • 5
      • 
      
      
      
      
    • 6
      • 
      
      
      
      
    • 7
      • 
      
      
      
      
    • 8
      • 
      
      
      
      
    • 9
      • 
      
      
      
      
    • 10
      • 
      
      
      
      
    • 11
      • 
      
      
      
      
    • 12
      • 
      
      
      
      
    • 13
      • 
      
      
      
      
    • 14
      • 
      
      
      
      
    • 15
      • 
      
      
      
      
    • 16
      • 
      
      
      
      
    • 17
      • 
      
      
      
      
    • 18
      • 
      
      
      
      
    • 19
      • 
      
      
      
      
    • 20
      • 
      
      
      
      
    • 21
      • 
      
      
      
      
    • 22
      • 
      
      
      
      
    • 23
      • 
      
      
      
      
    • 24
      • 
      
      
      
      
    • 25
      • 
      
      
      
      
    • 26
      • 
      
      
      
      
    • 27
      • 
      
      
      
      
    • 28
      • 
      
      
      
      
    • 29
      • 
      
      
      
      
    • 30
      • 
      
      
      
      
    • 31
      • 
      
      
      
      
    • 32
      • 
      
      
      
      
    • 33
      • 
      
      
      
      
    • 34
      • 
      
      
      
      
    • 35
      • 
      
      
      
      
    • 36
      • 
      
      
      
      
    • 37
      • 
      
      
      
      
    • 38
      • 
      
      
      
      
    • 39
      • 
      
      
      
      
    • 40
      • 
      
      
      
      
    • 41
      • 
      
      
      
      
    • 42
      • 
      
      
      
      
    • 43
      • 
      
      
      
      
    • 44
      • 
      
      
      
      
    • 45
      • 
      
      
      
      
    • 46
      • 
      
      
      
      
    • 47
      • 
     
     
     
     
     
     可以看到它会不断轮询ReferenceQueue,找到这样的reference,就交给handler,handler会从reference中拿到action, 
     并取消请求.
     
     case REQUEST_GCED: {
          Action action = (Action) msg.obj;
          if (action.getPicasso().loggingEnabled) {
            log(OWNER_MAIN, VERB_CANCELED, action.request.logId(), "target got garbage collected");
          }
          action.picasso.cancelExistingRequest(action.getTarget());
          break;
        }
     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
      
      
      
      
    • 3
      • 
      
      
      
      
    • 4
      • 
      
      
      
      
    • 5
      • 
      
      
      
      
    • 6
      • 
      
      
      
      
    • 7
      • 
      
      
      
      
    • 8
      • 
     
     
     
     
     
     那么这个ReferenceQueue又是如何关联Action的呢？这个可以从Action的构造器中拿到答案:
     
     this.target =//RequestWeakReference是WeakReference的子类
        target == null ? null : new RequestWeakReference(this/*即Action本身*/, target, picasso.referenceQueue);
     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
     
     
     
     
     
     可以看到两点:
     
    
       
     
    1. 每个Action都会关联Picasso中唯一的referenceQueue实例;
      2.  
     
    2. 每个RequestWeakReference都会同时关联Target和Action.
      3.  
    
      
   
  •  
     resume/pause
     
    
       
     
    1.  
       pause
       
       流程如下。
       
      2.  
    
     
     pause
     
     可能会有疑问的地方在于Dispatcher#performPauseTag中遍历所有的hunter，都会调一次cancel,这似乎会取消所有 
     的请求。但其实不是这样的,可以看下BitmapHunter#cancel方法的代码:
     
       boolean cancel() {
     return action == null
         && (actions == null || actions.isEmpty())
         && future != null
         && future.cancel(false);
   }
     
     
     
     
      
      
      
      
      
    • 1
      • 
      
      
      
      
    • 2
      • 
      
      
      
      
    • 3
      • 
      
      
      
      
    • 4
      • 
      
      
      
      
    • 5
      • 
      
      
      
      
    • 6
      • 
     
     
     
     
     
     注意到它会判断action是否为空，如果不为空就不会取消了。而在Dispatcher#performPauseTag中会把tag匹配的 
     action与对应的BitmapHunter解绑(detach),让BitmapHunter的action为空.所以这并不影响其他任务的执行。
     
    
       
     
    1.  
       resume
       
       流程如下。
       
      2.  
    
     
     resume
     
     其实就是遍历pausedActions，挨个重新交给dispatcher分发。
     
     作者的提交记录: https://github.com/square/picasso/pull/665/files#diff-f11286bbae6959a7a5dd74bf99276f1aR229
     
    •  
   
  •  
     图片压缩
     
     图片压缩的原理通常都是利用BitmapFactory#Options类，先将injustDecodeBounds设置为true,对Bitmap进行一次 
     解码，拿到outWidth/outHeight，即实际宽高,然后根据期望压缩到的宽和高算出inSampleSize,最后将injustDecodeBounds设置为false， 
     再对Bitmap进行一次解码即可。另一种压缩的方法是设置图片的显示效果,比如ARGB_8888等等.Picasso综合了利用这两种方案.
     
     图片压缩
     
     详细代码参考BitmapHunter#decodeStream、RequestHandler#createBitmapOptions、RequestHandler#calculateInSampleSize 
     这三个方法，有个需要注意的地方，只有当设置图片的宽高时(调用了fit或者resize)才会计算smpleSize进行压缩。
     
    •  
   
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Android,Native)
    
        
    
            
    
                
      
                    
    • 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
      
                    
      • 
                    
    • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
      本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
      
                    
      • 
                    
    • python多线程程序设计 之一
                        IT_Beijing_BIT
#Python程序设计语言python
                        
      python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
      
                    
      • 
                    
    • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
      在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
      
                    
      • 
                    
    • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
      最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
      
                    
      • 
                    
    • Android应用性能优化
                        轻口味
Android
                        
      Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
      
                    
      • 
                    
    • Android实现监听事件的方法
                        Amy木婉清

                        
      1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
      
                    
      • 
                    
    • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
      （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
      
                    
      • 
                    
    • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
      0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
      
                    
      • 
                    
    • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
      Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
      
                    
      • 
                    
    • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
      目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
      
                    
      • 
                    
    • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
      总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
      
                    
      • 
                    
    • linux简单安装gcc和gdb
                        chn-zgq
Linuxlinuxubuntu
                        
      linux安装gcc以及环境配置和gdb安装gcc-10.0添加源:sudoadd-apt-repositoryppa:ubuntu-toolchain-r/ppa更新源:sudoaptupdate下载gcc:sudoaptinstallgcc-10g++-10默认GCC版本设置为gcc-10.0:sudoupdate-alternatives--install/usr/bin/gccgcc/us
      
                    
      • 
                    
    • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
      作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
      
                    
      • 
                    
    • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
                        weixin_34302561
数据库devops大数据
                        
      1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
      
                    
      • 
                    
    • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
      一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
      
                    
      • 
                    
    • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
      1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
      
                    
      • 
                    
    • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
      一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
      
                    
      • 
                    
    • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
      为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
      
                    
      • 
                    
    • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
      Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
      
                    
      • 
                    
    • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
      写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
      
                    
      • 
                    
    • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
      文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
      
                    
      • 
                    
    • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
      文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
      
                    
      • 
                    
    • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
      今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
      
                    
      • 
                    
    • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
      前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
      
                    
      • 
                    
    • Superset二次开发之源码DependencyList.tsx 分析
                        aimmon
Superset二次开发SupersetBI二次开发typescript前端
                        
      功能点路径superset-frontend\src\dashboard\components\nativeFilters\FiltersConfigModal\FiltersConfigForm\DependencyList.tsx/***LicensedtotheApacheSoftwareFoundation(ASF)underone*ormorecontributorlicenseagre
      
                    
      • 
                    
    • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
      //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
      
                    
      • 
                    
    • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
      关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
      
                    
      • 
                    
    • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
      Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
      
                    
      • 
                    
    • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
      关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
      
                    
      • 
                                
    • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
      Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
      
                                
      • 
                                
    • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
      (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
      
                                
      • 
                                
    • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
      Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
      
                                
      • 
                                
    • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
         有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
      
                                
      • 
                                
    • 重绘之画图板
                                    朱辉辉33
画图板
                                    
             上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
      
                                
      • 
                                
    • Java的IO流
                                    西蜀石兰
java
                                    
      刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
      
                                
      • 
                                
    • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
      java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
      
                                
      • 
                                
    • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
      原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
      
                                
      • 
                                
    • JS 格式化时间
                                    alxw4616
JavaScript
                                    
      /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
      
                                
      • 
                                
    • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
        
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
      
                                
      • 
                                
    • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
      Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
      
                                
      • 
                                
    • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
      扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
      
                                
      • 
                                
    • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
      浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
      
                                
      • 
                                
    • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
       1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
      
                                
      • 
                                
    • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
      在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
      
                                
      • 
                                
    • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
      
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
      
                                
      • 
                                
    • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
      以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
      
                                
      • 
                                
    • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
       
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
      
                                
      • 
                                
    • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
      方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
      
                                
      • 
                                
    • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
      终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
      
                                
      • 
                                
    • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
      1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
      
                                
      • 
                                
    • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
      MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
      
                                
      • 
                                
    • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
      MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
      
                                
      • 
                                
    • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
      重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
      
                                
      • 
                                
    • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
        
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
      
                                
      • 
                                
    • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
      前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
      
                                
      • 
                                
    • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
      在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
      
                                
      • 
                                
    • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
      // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


      
                                
      • 
                                
    • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
        
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
      
                                
      • 
                                
    • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
      Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
      
                                
      •