https://juejin.im/post/5a4a454f518825258b745c42

Http 方面的知识平常也会遇到，但是一般了解的也不深，今天记录几个常遇到的知识点。

Http 报文

http 报文可以分为请求报文和响应报文，格式大同小异，主要分为三个部分：

1. 起始行
2. 首部
3. 主体

请求报文格式：

1
2
3
4

<method> <request-url> <version>
<headers>

<entity-body>

响应报文格式：

1
2
3
4

<version> <status> <reason-phrase>
<headers>

<entity-body>

各个标签的解释：

1
2
3
4
5
6
7
8
9

<method> 指请求方法，常用的主要是Get、 Post、Head 还有其他一些我们这里就不说了，有兴趣的可以自己查阅一下

<version> 指协议版本，现在通常都是Http/1.1了

<request-url> 请求地址

<status> 指响应状态码， 我们熟悉的200、404等等

<reason-phrase> 原因短语，200 OK 、404 Not Found 这种后面的描述就是原因短语，通常不必太关注。

method

状态码

常见的状态码主要有
200 OK 请求成功，实体包含请求的资源
301 Moved Permanent 请求的URL被移除了，通常会在Location首部中包含新的URL用于重定向。
304 Not Modified 条件请求进行再验证，资源未改变。
404 Not Found 资源不存在
206 Partial Content 成功执行一个部分请求。这个在用于断点续传时会涉及到。

header

在请求报文和响应报文中都可以携带一些信息，通过与其他部分配合，能够实现各种强大的功能。这些信息位于起始行之下与请求实体之间，以键值对的形式，称之为首部。每条首部以回车换行符结尾，最后一个首部额外多一个换行，与实体分隔开。

这里我们重点关注一下
Date
Cache-Control
Last-Modified
Etag
Expires
If-Modified-Since
If-None-Match
If-Unmodified-Since
If-Range
If-Match

实体

Http 缓存

当我们发起一个http请求后，服务器返回所请求的资源，这时我们可以将该资源的副本存储在本地，这样当再次对该url资源发起请求时，我们能快速的从本地存储设备中获取到该url资源，这就是所谓的缓存。缓存既可以节约不必要的网络带宽，又能迅速对http请求做出响应。

先摆出几个概念：

1. 新鲜度检测
2. 再验证
3. 再验证命中

1. 新鲜度检测
   我们需要通过检测资源是否超过一定的时间，来判断缓存资源是否新鲜可用。那么这个一定的时间怎么决定呢？其实是由服务器通过在响应报文中增加 Cache-Control:max-age，或是 Expire 这两个首部来实现的。值得注意的是 Cache-Control 是 http1.1 的协议规范，通常是接相对的时间，即多少秒以后，需要结合 last-modified 这个首部计算出绝对时间。而 Expire 是 http1.0 的规范，后面接一个绝对时间。
2. 再验证
   如果通过新鲜度检测发现需要请求服务器进行再验证，那么我们至少需要告诉服务器，我们已经缓存了一个什么样的资源了，然后服务器来判断这个缓存资源到底是不是与当前的资源一致。逻辑是这样没错。那怎么告诉服务器我当前已经有一个备用的缓存资源了呢？我们可以采用一种称之为条件请求的方式实现再验证。
3. Http定义了5个首部用于条件请求:
   If-Modified-Since
   If-None-Match
   If-Unmodified-Since
   If-Range
   If-Match

Https

简单的说 Http + 加密 + 认证 + 完整性保护 = Https

传统的 Http 协议是一种应用层的传输协议，Http 直接与 TCP 协议通信，其本身存在一些缺点：

1. Http协议使用明文传输，容易遭到窃听。
2. Http 对于通信双方都没有进行身份验证，通信双方无法确认对方是否是伪装的客户端或者服务端。
3. Http 对于传输内容的完整性没有确认的办法，往往容易在传输的过程中遭到劫持篡改。

因此，在一些需要保证安全性的场景下，Http 无法抵御这些攻击。

Https 则可以听过增加的 SSL\TLS，支持对于通信内容的加密，以及通信双飞的身份验证。

Https 加密

近代密码学中加密的方式主要有两类：

1. 对称秘钥加密
2. 非对称秘钥加密

对称秘钥加密是指加密与解密过程使用同一把秘钥。这种方式的优点是处理速度快，但是如何安全的从一方将秘钥传递到通信的另一方是一个问题。

非对称秘钥加密是指加密与解密使用两把不同的秘钥。这两把秘钥，一把叫公开秘钥，可以随意对外公开。一把叫私有秘钥，只用于本身持有。得到公开秘钥的客户端可以使用公开秘钥对传输内容进行加密，而只有私有秘钥持有者本身可以对公开秘钥加密的内容进行解密。这种方式克服了秘钥交换的问题，但是相对于对称秘钥加密的方式，处理速度较慢。

SSL\TLS的加密方式则是结合了两种加密方式的优点。首先采用非对称秘钥加密，将一个对称秘钥使用公开秘钥加密后传输到对方。对方使用私有秘钥解密，得到传输的对称秘钥。之后双方再使用对称秘钥进行通信。这样即解决了对称秘钥加密的秘钥传输问题，又利用了对称秘钥的高效率来进行通信内容的加密与解密。

Https 的认证

SSL\TLS采用的混合加密的方式还是存在一个问题，即怎么样确保用于加密的公开秘钥确实是所期望的服务器所分发的呢？也许在收到公开秘钥时，这个公开秘钥已经被别人篡改了。因此，我们还需要对这个秘钥进行认证的能力，以确保我们通信的对方是我们所期望的对象。

目前的做法是使用由数字证书认证机构颁发的公开秘钥证书。服务器的运营人员可以向认证机构提出公开秘钥申请。认证机构在审核之后，会将公开秘钥与共钥证书绑定。服务器就可以将这个共钥证书下发给客户端，客户端在收到证书后，使用认证机构的公开秘钥进行验证。一旦验证成功，即可知道这个秘钥是可以信任的秘钥。

Https的通信流程：

1. Client发起请求
2. Server端响应请求，并在之后将证书发送至Client
3. Client使用认证机构的共钥认证证书，并从证书中取出Server端共钥。
4. Client使用共钥加密一个随机秘钥，并传到Server
5. Server使用私钥解密出随机秘钥
6. 通信双方使用随机秘钥最为对称秘钥进行加密解密。

TCP/IP 协议简介

IP

IP（Internet Protocol）协议提供了主机和主机间的通信。

为了完成不同主机的通信，我们需要某种方式来唯一标识一台主机，这个标识就是著名的 IP 地址。通过 IP 地址，IP 协议就能帮我们把一个数据包发送给对方。

TCP

上面说到，IP 协议提供了主机与主机间的通信。TCP 协议在 IP 协议提供的主机间通信功能的基础上，完成了两个主机上进程对进程的通信。

有了 IP，不同主机可以进行通信。但是计算机收到数据后，并不知道数据属于哪个进程（简单讲，进程就是一个正在运行的应用程序）。TCP的作用就在于，让我们知道这个数据属于哪个进程，从而完成进程间的通信。

为了标识数据属于哪个进程，我们给需要进行 TCP 通信的进程分配一个唯一的数字来标识它。这个数字就是我们常说的端口号。

TCP 的全称是 Transmission Control Protocol，大家对它说的最多的，大概是面向连接的特性了。之所以说它是有连接的，是说进行通信前，通信双方需要先经过一个三次握手的过程。三次握手完成后，连接便建立了。这时候我们才可以接受/发送数据。（与之对应的 UDP，不需要经过握手，就可以直接发送数据）。

三次握手过程：

1. 首先，客户向服务端发送一个 SYN，假设此时 sequence number 为 x。这个 x 是由操作系统根据一定的规则生成的，不妨认为它是一个随机数。
2. 服务端收到 SYN 后，会向客户端再发送一个 SYN，此时服务器的 seq number = y。与此同时，会 ACK x+1，告诉客户端“已经收到了 SYN，可以发送数据了”。
3. 客户端收到服务器的 SYN 后，回复一个 ACK y+1，这个 ACK 则是告诉服务器，SYN 已经收到，服务器可以发送数据了。

经过这 3 步，TCP 连接就建立了。这里需要注意的有三点：

1. 连接是由客户端主动发起的
2. 在第 3 步客户端向服务器回复 ACK 的时候，TCP 协议是允许我们携带数据的。之所以做不到，是 API 的限制导致的。
3. TCP 协议还允许 “四次握手” 的发生，同样的，由于 API 的限制，这个极端的情况并不会发生。

Socket 基本用法

Socket 是 TCP 层的封装，通过 Socket，我们就能进程 TCP 通信。

在 Java 的 SDK 中，socket 的共有两个接口：用于监听客户连接的 ServerSocket 和用于通信的 Socket。使用 socket 的步骤如下：

1. 创建 ServerSocket 并监听客户连接
2. 创建 Socket 连接服务端
3. 通过 Socket 获取输入输出流进行通信

Socket Demo：

​ 1、创建 ServerSocket 并监听客户连接

1. 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

   public class EchoServer { private final ServerSocket mServerSocket; public EchoServer(int port) throws IOException { // 1. 创建一个 ServerSocket 并监听端口 port mServerSocket = new ServerSocket(port); } public void run() throws IOException { // 2. 开始接受客户连接 Socket client = mServerSocket.accept(); handleClient(client); } private void handleClient(Socket socket) { // 3. 使用 socket 进行通信 ... } public static void main(String[] argv) { try { EchoServer server = new EchoServer(9877); server.run(); } catch (IOException e) { e.printStackTrace(); } } }

2、使用 Socket 连接服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class EchoClient {

    private final Socket mSocket;

    public EchoClient(String host, int port) throws IOException {
        // 创建 socket 并连接服务器
        mSocket = new Socket(host, port);
    }

    public void run() {
        // 和服务端进行通信
    }


    public static void main(String[] argv) {
        try {
            // 由于服务端运行在同一主机，这里我们使用 localhost
            EchoClient client = new EchoClient("localhost", 9877);
            client.run();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、通过 Socket 获取输入/输出流进行通信

首先，我们来实现服务端（服务端就是不停的输入数据，然后写会给客户端）：

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

public class EchoServer {
    // ...

    private void handleClient(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        byte[] buffer = new byte[1024];
        int n;
        while ((n = in.read(buffer)) > 0) {
            out.write(buffer, 0, n);
        }
    }
}

接下来，是客户端的实现（客户端在读取用户输入的同时，又会读取服务器的响应，所以需要创建一个线程来读取服务器的响应）：

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

public class EchoClient {
    // ...

    public void run() throws IOException {
        Thread readerThread = new Thread(this::readResponse);
        readerThread.start();

        OutputStream out = mSocket.getOutputStream();
        byte[] buffer = new byte[1024];
        int n;
        while ((n = System.in.read(buffer)) > 0) {
            out.write(buffer, 0, n);
        }
    }

    private void readResponse() {
        try {
            InputStream in = mSocket.getInputStream();
            byte[] buffer = new byte[1024];
            int n;
            while ((n = in.read(buffer)) > 0) {
                System.out.write(buffer, 0, n);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：

1. 在上面代码中没有处理异常，实际中在发生异常时需要关闭 socket，并根据实际业务做一些错误处理工作。
2. 在客户端，没有停止 readThread。实际中，可以通过关闭 socket 来让线程从阻塞中返回。
3. demo 中服务端只处理了一个客户连接，如果需要同时处理多个客户端，可以创建线程来处理请求。

项目中用到的自定义 view 还是有限的，所有有些知识点也是遗漏，这次做一个稍微全面点的总结，复习一下。

自定义 view 需要至少重写两个构造函数

1
2
3
4
5
6

public MyView(Context context) {         
	super(context);     
}      
public MyView(Context context, AttributeSet attrs) {
	super(context, attrs);     
}

而且大部分时候只需重写两个函数：onMeasure()、onDraw()。onMeasure() 方法负责对当前 view 的尺寸进行测量，onDraw（）方法负责把当前这个 view 绘制出来。

onMeasure

1

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)

在 onMeasure 方法中，参数 widthMeasureSpec 与 heightMeasureSpec 包含了尺寸的测量模式和尺寸大小。我们知道 int 类型数据占用 32 个 bit，这个参数数值将 int 数据的前两个 bit 用于区分不同的布局模式，后面 30 个 bit 用于存放尺寸的数据。Android 内置类 MeasureSpec 可以帮助计算测量模式与尺寸：

1
2

int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);

请注意，这里的尺寸大小并不是最终我们的 View 的尺寸大小，而是父 view 提供的参考大小。至于测量模式，表示了 view 与父 view 直接的关系，测量模式有三种：

测量模式与布局时 wrap_content、match_parent 以及写成固定尺寸对应关系：

match_parent –> EXACTLY。match_parent 要利用父 View 给子 View 提供的剩余空间，而父 View 的剩余空间是确定的，也就是这个测量模式对应的数值锁存放的尺寸。

wrap_content –> AT_MOST。就是我们想要将大小设置为包裹我们的 View 内容，那么尺寸就是父 View 给我们作为参考的尺寸，是要不超过这个尺寸就可以，具体尺寸可以根据我们的需求去设定。

固定尺寸 –>EXACTLY。用户自己制定尺寸的大小。

重新 onMeasure 方法

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

private int getMySize(int defaultSize, int measureSpec) {
        int mySize = defaultSize;

        int mode = MeasureSpec.getMode(measureSpec);
        int size = MeasureSpec.getSize(measureSpec);

        switch (mode) {
            case MeasureSpec.UNSPECIFIED: {//如果没有指定大小，就设置为默认大小
                mySize = defaultSize;
                break;
            }
            case MeasureSpec.AT_MOST: {//如果测量模式是最大取值为size
                //我们将大小取最大值,你也可以取其他值
                mySize = size;
                break;
            }
            case MeasureSpec.EXACTLY: {//如果是固定的大小，那就不要去改变它
                mySize = size;
                break;
            }
        }
        return mySize;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width = getMySize(100, widthMeasureSpec);
        int height = getMySize(100, heightMeasureSpec);

        if (width < height) {
            height = width;
        } else {
            width = height;
        }

        setMeasuredDimension(width, height);
}

重写 onDraw 方法

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

protected void onDraw(Canvas canvas) {
        //调用父View的onDraw函数，因为View这个类帮我们实现了一些
        // 基本的而绘制功能，比如绘制背景颜色、背景图片等
        super.onDraw(canvas);
        int r = getMeasuredWidth() / 2;//也可以是getMeasuredHeight()/2,本例中我们已经将宽高设置相等了
        //圆心的横坐标为当前的View的左边起始位置+半径
        int centerX = getLeft() + r;
        //圆心的纵坐标为当前的View的顶部起始位置+半径
        int centerY = getTop() + r;

        Paint paint = new Paint();
        paint.setColor(Color.GREEN);
        //开始绘制
        canvas.drawCircle(centerX, centerY, r, paint);


    }

自定义布局属性

• 首先需要再 res/values/styles.xml 文件（如果没有需要自己创建）里面生命一个需要自定义的属性；

1
2
3
4
5
6
7

<resources>
    <!--name为声明的"属性集合"名，可以随便取，但是最好是设置为跟我们的View一样的名称-->
    <declare-styleable name="MyView">
        <!--声明我们的属性，名称为default_size,取值类型为尺寸类型（dp,px等）-->
        <attr name="default_size" format="dimension" />
    </declare-styleable>
</resources>

• 在布局文件中使用自定义的属性；

  注意：需要再根标签中设定命名空间，命名空间的名称可以自己定义，命名空间的值为固定：“http://schemas.android.com/apk/res-auto”。

• 在自定义 View 里面通过参数 AttributeSet 把定义的属性取出。

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

private int defalutSize;
  public MyView(Context context, AttributeSet attrs) {
      super(context, attrs);
      //第二个参数就是我们在styles.xml文件中的<declare-styleable>标签
        //即属性集合的标签，在R文件中名称为R.styleable+name
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.MyView);
        
        //第一个参数为属性集合里面的属性，R文件名称：R.styleable+属性集合名称+下划线+属性名称
        //第二个参数为，如果没有设置这个属性，则设置的默认的值
        defalutSize = a.getDimensionPixelSize(R.styleable.MyView_default_size, 100);
        
        //最后记得将TypedArray对象回收
        a.recycle();
   }

sh

这个列表包含与网页抓取和数据处理的Python库

更新

fake_useragent - 实现随机请求头的设置。

pandas - 为了解决数据分析任务而创建的，可用来创建数据表。

网络

• 通用

  • urllib -网络库(stdlib)。
  • requests -网络库。
  • grab – 网络库（基于pycurl）。
  • pycurl – 网络库（绑定libcurl）。
  • urllib3 – Python HTTP库，安全连接池、支持文件post、可用性高。
  • httplib2 – 网络库。
  • RoboBrowser – 一个简单的、极具Python风格的Python库，无需独立的浏览器即可浏览网页。
  • MechanicalSoup -一个与网站自动交互Python库。
  • mechanize -有状态、可编程的Web浏览库。
  • socket – 底层网络接口(stdlib)。
  • Unirest for Python – Unirest是一套可用于多种语言的轻量级的HTTP库。
  • hyper – Python的HTTP/2客户端。
  • PySocks – SocksiPy更新并积极维护的版本，包括错误修复和一些其他的特征。作为socket模块的直接替换。

• 异步

  • treq – 类似于requests的API（基于twisted）。
  • aiohttp – asyncio的HTTP客户端/服务器(PEP-3156)。

网络爬虫框架

• 功能齐全的爬虫

  • grab – 网络爬虫框架（基于pycurl/multicur）。
  • scrapy – 网络爬虫框架（基于twisted），不支持Python3。
  • pyspider – 一个强大的爬虫系统。
  • cola – 一个分布式爬虫框架。

• 其他

  • portia – 基于Scrapy的可视化爬虫。
  • restkit – Python的HTTP资源工具包。它可以让你轻松地访问HTTP资源，并围绕它建立的对象。
  • demiurge – 基于PyQuery的爬虫微框架。

HTML/XML解析器

• 通用

  • lxml – C语言编写高效HTML/ XML处理库。支持XPath。
  • cssselect – 解析DOM树和CSS选择器。
  • pyquery – 解析DOM树和jQuery选择器。
  • BeautifulSoup – 低效HTML/ XML处理库，纯Python实现。
  • html5lib – 根据WHATWG规范生成HTML/ XML文档的DOM。该规范被用在现在所有的浏览器上。
  • feedparser – 解析RSS/ATOM feeds。
  • MarkupSafe – 为XML/HTML/XHTML提供了安全转义的字符串。
  • xmltodict – 一个可以让你在处理XML时感觉像在处理JSON一样的Python模块。
  • xhtml2pdf – 将HTML/CSS转换为PDF。
  • untangle – 轻松实现将XML文件转换为Python对象。

• 清理

  • Bleach – 清理HTML（需要html5lib）。
  • sanitize – 为混乱的数据世界带来清明。

文本处理

用于解析和操作简单文本的库。

• 通用

• • difflib – （Python标准库）帮助进行差异化比较。
  • Levenshtein – 快速计算Levenshtein距离和字符串相似度。
  • fuzzywuzzy – 模糊字符串匹配。
  • esmre – 正则表达式加速器。
  • ftfy – 自动整理Unicode文本，减少碎片化。

• 转换

• • unidecode – 将Unicode文本转为ASCII。

• 字符编码

• • uniout – 打印可读字符，而不是被转义的字符串。
  • chardet – 兼容 Python的2/3的字符编码器。
  • xpinyin – 一个将中国汉字转为拼音的库。
  • pangu.py – 格式化文本中CJK和字母数字的间距。

• Slug化

• • awesome-slugify – 一个可以保留unicode的Python slugify库。
  • python-slugify – 一个可以将Unicode转为ASCII的Python slugify库。
  • unicode-slugify – 一个可以将生成Unicode slugs的工具。
  • pytils – 处理俄语字符串的简单工具（包括pytils.translit.slugify）。

• 通用解析器

• • PLY – lex和yacc解析工具的Python实现。
  • pyparsing – 一个通用框架的生成语法分析器。

• 人的名字

• • python-nameparser -解析人的名字的组件。

• 电话号码

• • phonenumbers -解析，格式化，存储和验证国际电话号码。

• 用户代理字符串

• • python-user-agents – 浏览器用户代理的解析器。
  • HTTP Agent Parser – Python的HTTP代理分析器。

特定格式文件处理

解析和处理特定文本格式的库。

• 通用

• • tablib – 一个把数据导出为XLS、CSV、JSON、YAML等格式的模块。
  • textract – 从各种文件中提取文本，比如 Word、PowerPoint、PDF等。
  • messytables – 解析混乱的表格数据的工具。
  • rows – 一个常用数据接口，支持的格式很多（目前支持CSV，HTML，XLS，TXT – 将来还会提供更多！）。

• Office

• • python-docx – 读取，查询和修改的Microsoft Word2007/2008的docx文件。
  • xlwt / xlrd – 从Excel文件读取写入数据和格式信息。
  • XlsxWriter – 一个创建Excel.xlsx文件的Python模块。
  • xlwings – 一个BSD许可的库，可以很容易地在Excel中调用Python，反之亦然。
  • openpyxl – 一个用于读取和写入的Excel2010 XLSX/ XLSM/ xltx/ XLTM文件的库。
  • Marmir – 提取Python数据结构并将其转换为电子表格。

• PDF

• • PDFMiner – 一个从PDF文档中提取信息的工具。
  • PyPDF2 – 一个能够分割、合并和转换PDF页面的库。
  • ReportLab – 允许快速创建丰富的PDF文档。
  • pdftables – 直接从PDF文件中提取表格。

• Markdown

• • Python-Markdown – 一个用Python实现的John Gruber的Markdown。
  • Mistune – 速度最快，功能全面的Markdown纯Python解析器。
  • markdown2 – 一个完全用Python实现的快速的Markdown。

• YAML

• • PyYAML – 一个Python的YAML解析器。

• CSS

• • cssutils – 一个Python的CSS库。

• ATOM/RSS

• • feedparser – 通用的feed解析器。

• SQL

• • sqlparse – 一个非验证的SQL语句分析器。

• HTTP

• • http-parser – C语言实现的HTTP请求/响应消息解析器。

• 微格式

• • opengraph – 一个用来解析Open Graph协议标签的Python模块。

• 可移植的执行体

• • pefile – 一个多平台的用于解析和处理可移植执行体（即PE）文件的模块。

• PSD

• • psd-tools – 将Adobe Photoshop PSD（即PE）文件读取到Python数据结构。

自然语言处理

处理人类语言问题的库。

• NLTK -编写Python程序来处理人类语言数据的最好平台。
• Pattern – Python的网络挖掘模块。他有自然语言处理工具，机器学习以及其它。
• TextBlob – 为深入自然语言处理任务提供了一致的API。是基于NLTK以及Pattern的巨人之肩上发展的。
• jieba – 中文分词工具。
• SnowNLP – 中文文本处理库。
• loso – 另一个中文分词库。
• genius – 基于条件随机域的中文分词。
• langid.py – 独立的语言识别系统。
• Korean – 一个韩文形态库。
• pymorphy2 – 俄语形态分析器（词性标注+词形变化引擎）。
• PyPLN – 用Python编写的分布式自然语言处理通道。这个项目的目标是创建一种简单的方法使用NLTK通过网络接口处理大语言库。

浏览器自动化与仿真

• selenium – 自动化真正的浏览器（Chrome浏览器，火狐浏览器，Opera浏览器，IE浏览器）。
• Ghost.py – 对PyQt的webkit的封装（需要PyQT）。
• Spynner – 对PyQt的webkit的封装（需要PyQT）。
• Splinter – 通用API浏览器模拟器（selenium web驱动，Django客户端，Zope）。

多重处理

• threading – Python标准库的线程运行。对于I/O密集型任务很有效。对于CPU绑定的任务没用，因为python GIL。
• multiprocessing – 标准的Python库运行多进程。
• celery – 基于分布式消息传递的异步任务队列/作业队列。
• concurrent-futures – concurrent-futures 模块为调用异步执行提供了一个高层次的接口。

异步

异步网络编程库

• asyncio – （在Python 3.4 +版本以上的 Python标准库）异步I/O，时间循环，协同程序和任务。
• Twisted – 基于事件驱动的网络引擎框架。
• Tornado – 一个网络框架和异步网络库。
• pulsar – Python事件驱动的并发框架。
• diesel – Python的基于绿色事件的I/O框架。
• gevent – 一个使用greenlet 的基于协程的Python网络库。
• eventlet – 有WSGI支持的异步框架。
• Tomorrow – 异步代码的奇妙的修饰语法。

队列

• celery – 基于分布式消息传递的异步任务队列/作业队列。
• huey – 小型多线程任务队列。
• mrq – Mr. Queue – 使用redis & Gevent 的Python分布式工作任务队列。
• RQ – 基于Redis的轻量级任务队列管理器。
• simpleq – 一个简单的，可无限扩展，基于Amazon SQS的队列。
• python-gearman – Gearman的Python API。

云计算

• picloud – 云端执行Python代码。
• dominoup.com – 云端执行R，Python和matlab代码。

电子邮件

电子邮件解析库

• flanker – 电子邮件地址和Mime解析库。
• Talon – Mailgun库用于提取消息的报价和签名。

网址和网络地址操作

解析/修改网址和网络地址库。

• URL

  • furl – 一个小的Python库，使得操纵URL简单化。
  • purl – 一个简单的不可改变的URL以及一个干净的用于调试和操作的API。
  • urllib.parse – 用于打破统一资源定位器（URL）的字符串在组件（寻址方案，网络位置，路径等）之间的隔断，为了结合组件到一个URL字符串，并将“相对URL”转化为一个绝对URL，称之为“基本URL”。
  • tldextract – 从URL的注册域和子域中准确分离TLD，使用公共后缀列表。

• 网络地址

  • netaddr – 用于显示和操纵网络地址的Python库。

网页内容提取

提取网页内容的库。

• HTML页面的文本和元数据

  • newspaper – 用Python进行新闻提取、文章提取和内容策展。
  • html2text – 将HTML转为Markdown格式文本。
  • python-goose – HTML内容/文章提取器。
  • lassie – 人性化的网页内容检索工具
  • micawber – 一个从网址中提取丰富内容的小库。
  • sumy -一个自动汇总文本文件和HTML网页的模块
  • Haul – 一个可扩展的图像爬虫。
  • python-readability – arc90 readability工具的快速Python接口。
  • scrapely – 从HTML网页中提取结构化数据的库。给出了一些Web页面和数据提取的示例，scrapely为所有类似的网页构建一个分析器。

• 视频

  • youtube-dl – 一个从YouTube下载视频的小命令行程序。
  • you-get – Python3的YouTube、优酷/ Niconico视频下载器。

• 维基

  • WikiTeam – 下载和保存wikis的工具。

WebSocket

用于WebSocket的库。

• Crossbar – 开源的应用消息传递路由器（Python实现的用于Autobahn的WebSocket和WAMP）。
• AutobahnPython – 提供了WebSocket协议和WAMP协议的Python实现并且开源。
• WebSocket-for-Python – Python 2和3以及PyPy的WebSocket客户端和服务器库。

DNS解析

• dnsyo – 在全球超过1500个的DNS服务器上检查你的DNS。
• pycares – c-ares的接口。c-ares是进行DNS请求和异步名称决议的C语言库。

计算机视觉

• OpenCV – 开源计算机视觉库。
• SimpleCV – 用于照相机、图像处理、特征提取、格式转换的简介，可读性强的接口（基于OpenCV）。
• mahotas – 快速计算机图像处理算法（完全使用 C++ 实现），完全基于 numpy 的数组作为它的数据类型。

代理服务器

• tproxy – tproxy是一个简单的TCP路由代理（第7层），基于Gevent，用Python进行配置。

其他Python工具列表

• awesome-python
• pycrumbs
• python-github-projects
• python_reference
• pythonidae

本文转自伯乐在线http://python.jobbole.com/82633/

Activity

Activity生命周期

生命周期：onCreate() -> onStart() - > onResume() -> onPause() -> onStop() -> onDestroy()

特殊的生命周期

• 资源相关的系统配置发生改变会导致 activity 被杀死并重新创建。系统配置发生改变以后，activity 会销毁，其 onPause、onStop、onDestroy 会相继执行，因为是异常销毁，系统会调用 onSaveInstanceState 来保存 activity 当前状态，这个方法的调用时机是在 onStop 之前，与 onPause 无时序关系。activity 重建后会调用 onRestoreInstanceState，并且把销毁时 onSaveInstance 保存的 Bundle 对象作为参数同时传递给 onRestoreInstance 和 onCreate，onRestoreInstance 在 onStart 方法之后回调。同时，onRestoreInstance 方法会自动帮我们做一些恢复工作。另外，和 activity 一样，每个 view 都有自己相关的 onSaveInstanceState 方法和 onRestoreInstanceState 方法。

• 应用场景：假设 Activity A 位于栈顶，从 A 跳转 B 时声明周期

  当用户点击A中按钮来到B时，假设B全部遮挡住了A，将依次执行A:onPause -> B:onCreate -> B:onStart -> B:onResume -> A:onStop。

  此时如果点击Back键，将依次执行B:onPause -> A:onRestart -> A:onStart -> A:onResume -> B:onStop -> B:onDestroy。

Activity 启动模式

• standard - 默认模式

  默认的启动模式，既标准模式，在不指定启动模式的前提下，系统默认使用该模式启动 Activity，每次启动一个 Activity 都会重写一个新的实例，不管这个实例存在不存在。该 Activity 属于启动它的 Activity 所在的任务占中。

  应用场景：默认。

• singleTop - 栈顶复用模式

  该模式下，当前栈中已存在该 Activity 实例并且该实例位于栈顶，则不会重新创建 Activity 的实例，而是复用栈顶的实例，并且将 Intent 对象传入，回调 onNewIntent 方法。其余情况，与 standard 模式相同，会重新创建实例。

  应用场景：登录页面、WXPayEntryActivity、WXEntryActivity 、推送通知栏。

• singleTask - 栈内复用模式

  该模式下，如果栈中存在这个 Activity 的实例就会复用这个 Activity，不管它是否位于栈顶，复用时，会将它上面的 Activity 全部出栈，并且会回调该实例的 onNewIntent 方法。其实这个过程还存在一个任务栈的匹配，因为这个模式启动时，会在自己需要的任务栈中寻找实例，这个任务栈就是通过 taskAffinity 属性指定。如果这个任务栈不存在，则会创建这个任务栈。

  应用场景：应用主页面、WebView页面、扫一扫页面、电商中：确认订单页面，付款页面。

• singleInstance - 全局唯一模式

  该模式具备 singleTask 模式的所有特性，并且这种模式下的 Activity 会单独占用一个 Task 栈，具备全局唯一性，即整个系统中只有一个实例。由于栈内复用的特性，后续的请求不会创建新的 Activity 实例，除非这个特殊的任务栈被销毁。以 singleInstance 模式启动的 Activity 在整个系统中是单利的，如果启动这样的 Activity 时已经存在一个实例，那么会把它所在的任务调度到前台，重用这个实例。

  应用场景：系统 Launcher、锁屏键、来电显示等系统应用。

TaskAffinity 属性

任务相关性。

• 这个参数标识了一个 Activity 所需任务栈的名字。默认情况下，所有 Activity 所需的任务战的名字为应用的包名。
• 每个 Activity 的 taskAffinity 值都可以被指定，用来覆盖其默认值。
• 通常来说，具有相同 taskAffinity 的 Activity 属于同一个任务。
• 当设置一个 Activity 的 taskAffinity 属性为空字符串时，表明这个 Activity 不属于任何 task。
• taskAffinity 属性不对 standard 和 singleTop 模式有任何影响，这两种模式下不会创建新的 task（如果不指定默认值，即包名）。

Activity 与 Fragment 生命周期关系

创建过程：Fragment - onAttach -> Fragment - onCreate -> Fragment - onCreateView -> Activity - onCreate -> Fragment - onActivityCreate -> Activity - onStart -> Fragment - onStart -> Activity - onResume -> Fragment - onResume

销毁过程：Fragment - onPause -> Activity - onPause -> Fragment - onStop -> Activity - onStop -> Fragment - onDestroyView -> Fragment - onDestroy -> Fragment - onDetach -> Activity - onDestroy

Activity 与 menu 创建先后顺序

在 Activity 创建完回调 onResume 后创建 menu，回调 onCreateOptionMenu。

Service

本地服务（LocalService）

调用者和service在同一个进程里，所以运行在主进程的main线程中。所以不能进行耗时操作，可以采用在service里面创建一个Thread来执行任务。service影响的是进程的生命周期，讨论与Thread的区别没有意义。
任何 Activity 都可以控制同一 Service，而系统也只会创建一个对应 Service 的实例。

启动方式：

• start 方式启动服务

  步骤：

  1、定义一个类继承 service

  2、清单文件中配置 service

  3、使用 context 的 startService(Intent) 方法启动 service

  4、不使用时，调用 stopService(Intent) 方法停止服务

  生命周期：

  onCreate() – > onStartCommand() – > onDestory()
  注意：如果服务已经开启，不会重复回调onCreate()方法，如果再次调用context.startService()方法，service而是会调用onStart()或者onStartCommand()方法。停止服务需要调用context.stopService()方法，服务停止的时候回调onDestory被销毁。

  特点：

  一旦服务开启就跟调用者（开启者）没有任何关系了。开启者不能调用服务里面的方法。

• bind 方式启动服务

  步骤：

  定义一个类继承 service

  清单文件中注册 service

  使用 context 的 bindService(Intent,ServiceConnection,int) 方法启动 service

  不再使用时，调用 unbindService(ServiceConnection) 方法停止该服务

  生命周期：

  onCreate() – > onBind() –> onUnbind() – > onDestory()

  注意：

  绑定服务不会调用 onStart 或者 onStartCommand 方法

  特点：

  bind 的方式启动服务，绑定服务，服务的生命周期跟随绑定者。绑定者可以调用服务里面的方法。

远程服务

调用者和 service 不再同一个进程中， service 在单独的进程中的 main 线程，是一种跨进程通信方式。

在服务的内部创建一个内部类，提供一个方法，可以间接调用服务的方法；

把暴露的接口文件的扩展名改为 .aidl 文件，去掉访问修饰符；

实现服务的 onbind 方法，继承 Bander 和实现 aidl 定义的接口，提供给外界可调用的方法

在 Activity 中绑定服务 bindService；

在服务成功绑定的时候回调 onServiceConnected 方法，床底一个 IBinder 对象

aidl 定义的接口 .Stub.asInterface(binder) 调用接口里面的方法

IntentService

IntentService 是 Service 的子类，比普通的 Service 增加了额外的功能。

Service 本身存在的两个问题：

• Service 不会专门启动一个单独的进程，Service 与它所在的应用位于同一个进程中；
• Service 也不是专门一条新进程，因此不应该在 Service 中直接处理耗时的任务

IntentService 特征：

• 会创建独立的 worker 线程来处理所有的 Intent 请求；
• 会创建独立的 worker 线程来处理 onHandleIntent 方法实现的代码，无需处理多线程问题；
• 所有请求处理完成后，IntentService 会自动停止，无需调用 stopSelf 方法停止；
• 为 Service 的 onBind 提供默认实现，返回 null；
• 为 Service 的 onStartCommand 提供默认实现，将请求的 Intent 添加到队列中。

BroadcastReceiver

广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。普通广播是完全异步的，可以在同一时刻（逻辑上）被所有接收者接收到，消息传递的效率比较高，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；然而有序广播是按照接收者声明的优先级别（声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000。也可以调用IntentFilter对象的setPriority()进行设置），被接收者依次接收广播。如：A的级别高于B,B的级别高于C,那么，广播先传给A，再传给B，最后传给C。A得到广播后，可以往广播里存入数据，当广播传给B时,B可以从广播中得到A存入的数据。

发送广播

1
2
3
4
5
6

Context.sendBroadcast()
发送的是普通广播，所有订阅者都有机会获得并进行处理。

Context.sendOrderedBroadcast()
发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将处理结果通过setResultExtras(Bundle)方法存放进结果对象，然后传给下一个接收者，通过代码：Bundle bundle =getResultExtras(true))可以获取上一个接收者存入在结果对象中的数据。
系统收到短信，发出的广播属于有序广播。如果想阻止用户收到短信，可以通过设置优先级，让你们自定义的接收者先获取到广播，然后终止广播，这样用户就接收不到短信了。

注意：BroadCastReceiver 生命周期很短，在 onReceiver 中需要进行耗时操作时，应该考虑在 Service 中开启一个新线程处理。

静态注册和动态注册区别

• 动态注册广播不是常驻型广播，也就是说广播跟随activity的生命周期。注意: 在activity结束前，移除广播接收器。
  静态注册是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。
• 当广播为有序广播时：
  1 优先级高的先接收
  2 同优先级的广播接收器，动态优先于静态
  3 同优先级的同类广播接收器，静态：先扫描的优先于后扫描的，动态：先注册的优先于后注册的。
• 当广播为普通广播时：
  1 无视优先级，动态广播接收器优先于静态广播接收器
  2 同优先级的同类广播接收器，静态：先扫描的优先于后扫描的，动态：先注册的优先于后注册的。

小结：

• 在Android 中如果要发送一个广播必须使用sendBroadCast 向系统发送对其感兴趣的广播接收器中。
• 使用广播必须要有一个intent 对象必设置其action动作对象
• 使用广播必须在配置文件中显式的指明该广播对象
• 每次接收广播都会重新生成一个接收广播的对象
• 在BroadCastReceiver中尽量不要处理太多逻辑问题，建议复杂的逻辑交给Activity 或者 Service 去处理
• 如果在AndroidManifest.xml中注册，当应用程序关闭的时候，也会接收到广播。在应用程序中注册就不产生这种情况了。

ContentProvider

contentprovider是android四大组件之一的内容提供器，它主要的作用就是将程序的内部的数据和外部进行共享，为数据提供外部访问接口，被访问的数据主要以数据库的形式存在，而且还可以选择共享哪一部分的数据。这样一来，对于程序当中的隐私数据可以不共享，从而更加安全。contentprovider是android中一种跨程序共享数据的重要组件。

原文：

​ https://blog.csdn.net/mynameishuangshuai/article/details/51491074

​ https://www.jianshu.com/p/51aaa65d5d25

新年要立新的 flag，2018 过去就过去吧，2019重新开始吧。列一下 2019 年想要学习的东西吧。有些可能很零碎，先写出来，再去归类总结吧。

1、四大组件（总结记录）

四大组件的使用、Activity启动模式、Service的start和bind

学习资料：

学习资料：
Android 四大组件 - 简书
彻底弄懂Activity四大启动模式 - Android研发专栏 - CSDN博客

2、自定义 view

Android 自定义 View 合集 - Android - 掘金

3、网络

了解HTTP/HTTPS、状态码、header，get和post等；掌握网络请求API和相关网络库；熟悉长连接。

HTTP 必知必会的那些
Android HttpURLConnection详解 - 简书
手把手教你写 Socket 长连接

4、图片加载

了解drawable加载规则以及图片缓存

Android中Bitmap内存优化 - 简书
Android drawable微技巧，你所不知道的drawable的那些细节 - 郭霖的专栏 - …
Android照片墙完整版，完美结合LruCache和DiskLruCache - 郭霖的专栏 - …
Android DiskLruCache完全解析，硬盘缓存的最佳方案 - 郭霖的专栏 - CSDN博…

5、文件和数据库

了解文件流、sqlite

Java 文件流总结 - 简书 详细介绍了文件输入输出流
Java 随机访问文件_w3cschoolJava随机访问文件
Java 序列化的高级认识 Java的序列化原理以及对象输入输出流
Android SQLite详解 - 简书sqlite数据库如何使用
Concurrent database access - Dmytro Danylyk sqlite到底是线程安全的吗？

6、Handler 机制

Android Handler的基本使用 - 简书 了解Handler最基本的使用方式，文章清晰易懂
Android Handler详解 - 简书简单理解Handler的内部原理

7、Binder、AIDL、多进程

Binder原理、AIDL的使用、多进程的定义和特性

https://blog.csdn.net/universus/article/details/6211589

8、View的绘制

View的measure、layout和draw，View的工作原理

图解View测量、布局及绘制原理 - 简书
android ListView 工作原理 - Android - 掘金

9、事件分发

事件分发原理和规则

Android事件分发机制，大表哥带你慢慢深入 - 简书
Android ViewGroup事件分发机制 - Hongyang - CSDN博客

10、消息队列

Handler、Looper、Thread三者之间的关系；得知道子线程创建Handler为什么会报错，如何才能不报错

源码角度讲解子线程创建Handler报错的原因 - 曹银飞的专栏 - CSDN博客

11、Activity难点

setResult和finish的顺序关系
onSaveInstanceState()和onRestoreInstanceState()
onNewIntent()和onConfigurationChanged()

setResult()的调用时机 - 沙翁 - 博客园【推荐理由】清晰易懂，直接了当。
onSaveInstanceState()和onRestoreInstanceState()使用详解…【推荐理由】简单好懂。
关于onConfigurationChanged方法及常见问题解决 - 朱小姐。的博客 - CSDN…

12、Service难点

先start再bind，如何停止一个Service
Service onStartCommand的返回值
bindService后，ServiceConnection里面的回调方法运行在哪个线程？它们的调用时机分别是什么？
Service的onCreate运行在哪个线程？

Android中startService和bindService的区别 - 简书
Service: onStartCommand 诡异的返回值 - CodingMan - CSDN博…
Service的onCreate、onStartCommand、onDestory等全部生命周期方法都运行在UI线程，ServiceConnection里面的回调方法也是运行在UI线程，大家一定要记住。

13、ContentProvider难点

ContentProvider的生命周期
ContentProvider的onCreate和CRUD运行在哪个线程？它们是线程安全的吗？
ContentProvider的内部存储只能是sqlite吗？

android ContentProvider onCreate()在 Application……
ContentProvider总结 - 简书
注意：ContentProvider的底层是Binder，当跨进程访问ContentProvider的时候，CRUD运行在Binder线程池中，不是线程安全的，而如果在同一个进程访问ContentProvider，根据Binder的原理，同进程的Binder调用就是直接的对象调用，这个时候CRUD运行在调用者的线程中。另外，ContentProvider的内部存储不一定是sqlite，它可以是任意数据。

14、AsyncTask原理

知道AsyncTask的工作原理，知道其串行和并行随版本的变迁
Android源码分析—带你认识不一样的AsyncTask - 任玉刚 - CSDN博客 【推荐理由】只看这一篇文章就够了
https://android.googlesource.com/platform/frameworks/base/ /android-8.1.0_r46/core/java/android/os/AsyncTask.java

今天有个需求，有个地区列表要改成可展开收起的列表，正好可以探索一下 recyclerview 的各个组成部分。

今天着重记录一下：ViewHolder、Adapter、AdapterDataObservable、RecyclerViewDataObServer、LayoutManager、Recycler、RecyclerPool。

先上一张图大致描述下他们之间的关系，这张图是 adapter.nofifyXX() 时 Recyclerview 的执行逻辑涉及到的一些类：

ViewHolder

对于Adapter来说，一个ViewHolder就对应一个data。它也是Recycler缓存池的基本单元。

1
2
3
4
5
6

public abstract static class ViewHolder {
        public final View itemView;
        int mPosition = NO_POSITION;
        int mItemViewType = INVALID_TYPE;
        int mFlags;
}

上面列举了 ViewHolder 中最重要的 4 个属性：

itemView：会被当做 child view 来添加到 RecyclerView 中。

mPosition：标记当前 ViewHolder 在 Adapter 中所处的位置。

mItemViewType：当前 ViewHolder 的 Type，在 ViewHolder 保存到 RecyclerPool 时，主要靠这个类型来对 ViewHolder 做复用。

mFlags：标记ViewHolder的状态，比如 FLAG_BOUND(显示在屏幕上)、FLAG_INVALID(无效，想要使用必须rebound)、FLAG_REMOVED(已被移除)等。

Adapter

其工作是把 data 和 view 绑定，即上面说的一个 data 对应一个 ViewHolder。主要负责 ViewHolder 的创建以及数据变化时通知 RecyclerView。

Adaper 会引用一个数据集合，getItemCount() 用来告诉 RecyclerView 展示的总条目。另外，Adapter 不是直接映射 data -> ViewHolder，而是 data position -> data type ->ViewHolder。所以对于 ViewHolder 来说，它知道的只是它的 view type。

AdapterDataObservable

Adapter 是数据源的直接接触者，当数据源发生变化时，它需要通知给 RecyclerView。这里使用的模式是观察者模式，AdapterDataObservable 是数据源变化是的被观察者， RecyclerViewDataObservable 是观察者。开发中使用的 notifyXX() 刷新 ui，就是抵用的 adapterDataObservable 的 notifyChanged() 。

RecyclerViewDataObserver

继承自 AdapterDataObserver，用来监听 Adapter 的数据变化。

LayoutManager

它是RecyclerView的布局管理者，RecyclerView在onLayout时，会利用它来layoutChildren,它决定了RecyclerView中的子View的摆放规则。但不止如此, 它做的工作还有:

1. 测量子View
2. 对子View进行布局
3. 对子View进行回收
4. 子View动画的调度
5. 负责RecyclerView滚动的实现
6. …

Recycler

对于 LayoutManager 来说，它是 ViewHolder 的提供者。对于 RecyclerView 来说，它是 ViewHolder 的管理者，是 RecyclerView 最核心的实现。下面这张图大致描述了它的组成:

scrap list

1
2

final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();
ArrayList<ViewHolder> mChangedScrap = null;

View Scrap状态

相信你在许多 RecyclerView 的 crash log 中都看到过这个单词。它是指 View 在 RecyclerView 布局期间进入分离状态的子视图。即它已经被 deatach(标记为 FLAG_TMP_DETACHED 状态)了。这种 View 是可以被立即复用的。

它在复用时，如果数据没有更新，是不需要调用 onBindViewHolder 方法的。如果数据更新了，那么需要重新调用 onBindViewHolder。

mAttachedScrap 和 mChangedScrap 中的 View 复用主要作用在 adapter.notifyXXX 时。这时候就会产生很多scrap 状态的 view。 也可以把它理解为一个 ViewHolder 的缓存。不过在从这里获取 ViewHolder 时完全是根据ViewHolder 的position 而不是 item type。如果在 notifyXX 时 data 已经被移除掉你，那么其中对应的ViewHolder 也会被移除掉。

mCacheViews

可以把它理解为 RecyclerView 的一级缓存。它的默认大小是3, 从中可以根据 item type 或者 position 来获取ViewHolder。可以通过 RecyclerView.setItemViewCacheSize() 来改变它的大小。

RecycledViewPool

它是一个可以被复用的 ViewHolder 缓存池。即可以给多个 RecycledView 来设置统一个 RecycledViewPool。这个对于多 tab feed 流应用可能会有很显著的效果。它内部利用一个 ScrapData 来保存 ViewHolder 集合:

1
2
3
4
5
6
7
8

class ScrapData {
    final ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
    int mMaxScrap = DEFAULT_MAX_SCRAP;   //最多缓存5个
    long mCreateRunningAverageNs = 0;
    long mBindRunningAverageNs = 0;
}

SparseArray<ScrapData> mScrap = new SparseArray<>();  //RecycledViewPool 用来保存ViewHolder的容器

一个 ScrapData 对应一种 type 的 ViewHolder 集合。看一下它的获取 ViewHolder 和保存 ViewHolder 的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//存
public void putRecycledView(ViewHolder scrap) {
    final int viewType = scrap.getItemViewType();
    final ArrayList<ViewHolder> scrapHeap = getScrapDataForType(viewType).mScrapHeap;
    if (mScrap.get(viewType).mMaxScrap <= scrapHeap.size())  return; //到最大极限就不能放了
    scrap.resetInternal();  //放到里面，这个view就相当于和原来的信息完全隔离了，只记得他的type，清除其相关状态
    scrapHeap.add(scrap);
}

//取
private ScrapData getScrapDataForType(int viewType) {
    ScrapData scrapData = mScrap.get(viewType);
    if (scrapData == null) {
        scrapData = new ScrapData();
        mScrap.put(viewType, scrapData);
    }
    return scrapData;
}

js 中 const、let、var 的区别

• const 定义的变量不可以修改（基本数据类型），并且必须初始化；
• var 定义的变量可以修改，未初始化不会报错，输出 undefined；
• let 是块级作用域，函数内部定义，对外部没影响。

js 中，中括号、大括号

{} 大括号标识一个对象，大部分情况下要有成对的属性和值，或者函数；

1
2
3
4
5
6
7
8
9
10

var LangShen = {"Name":"Langshen","AGE":"28"}; 

var LangShen = { 
	Name = function(){ 
		return "LangShen"; 
	}, 
	Age = function(){ 
		return "28"; 
	} 
}

[] 中括号标识一个数组，也可以理解为一个数组对象。

1
2
3

var LangShen = [ "Name","LangShen","AGE","28" ]; 

var LangShen = Array( "Name","LangShen","AGE","28" );

{ } 和[ ] 一起使用，我们前面说到，{ } 是一个对象，[ ] 是一个数组，我们可以组成一个对象数组

1
2
3
4

var LangShen = { "Name":"Langshen", 
	"MyWife":[ "LuLu","26" ], 
	"MySon":[{"Name":"Son1"},{"Name":"Son2"},{"Name":"Son3"}] 
}

数组

数组的创建

1
2
3

var arrayObj = new Array();　//创建一个数组  
var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度  
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值

要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。

数组的添加

1
2
3

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度 
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度 
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//方法向/从数组中添加/删除项目，然后返回被删除的项目。

数组元素的访问

1
2

var testGetArrValue = arrayObj[1]; //获取数组的元素值  
arrayObj[1]= "这是新值"; //给数组元素赋予新的值

数组元素的删除

1
2

arrayObj.pop()//移除最后一个元素并返回该元素
arrayObj.shift()//把数组的第一个元素从其中删除，并返回第一个元素的值

数组的截图和合并

1
2

arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素  
rrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组

数组的拷贝

1
2

arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向

数组元素的排序

1
2

arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址
arrayObj.sort(); //对数组元素排序，返回数组地址

突然觉得这个分类，应该改名奇巧淫技，或许会更好听点。偷鸡摸狗的话，并不是说这个是见不得人的东西。不过以后再说吧，毕竟不是今天的重点

前言

公司要每个技术序列的人都要做技术分享，一开始的时候确实没有想好要讲什么，毕竟同行，说的浅了没技术含量，说的深了担心自己给自己挖坑（滑稽脸）。最后，还是选择了 xposed 这个主题，因为 xposed 对于安卓来说确实是一个牛逼的存在，使用起来还是挺牛逼的，但是过程不是很复杂，作为技术去分享的话，可以自己控制一下。比如，设计的 Android 系统启动，xposed 的原理分析，还有一些 xposed 项目的分析，感觉这些应该能蒙混过去的把。。。心慌的，毕竟第一次。

xposed 是什么

百度说：

Xposed 框架是一款可以在不修改 APK 的情况下影响程序运行(修改系统)的框架服务，基于它可以制作出许多功能强大的模块，且在功能不冲突的情况下同时运作。

维基说：

Xposed框架（Xposed framework）是一套开源的、在 Android 高权限模式下运行的框架服务，可以在不修改 APK 文件的情况下修改程序的运行（修改系统），基于它可以制作出许多功能强大的模块，且在功能不冲突的情况下同时运作。这套框架需要设备打开了 Root 权限方可安装使用。

OK，其实 xposed 就是一个框架，通过这个框架你能拿到很多系统级别的东西，比如系统级别的数据返回（ Mac、手机型号、IMEI 等），这样你就可以直接欺骗一些应用，去设置你想设置的手机参数；再比如可以拿到运行在系统上的各个应用的试了，这样你就可以调用这些实例的方法，把 App 的界面改成自己想要的样子，去掉界面里不喜欢的东西（广告），自动抢红包，消息防撤回，步数修改等等。

当然，高收益常常伴随的是高风险，在这里，想要使用 xposed，风险就是需要 root 你的手机，经常搞基的人是知道这个的，具体操作就不在这里细说了，我用的机子是小米的，系统刷成开发版可以直接修改 root 权限的，还是挺方便的，VirtualXposed 倒是可以不用 root，不过属于阉割版，可玩性肯定就没那么好了。

有了 xposed，我们可以加载很多 App 插件，理论上通过这些插件，我们可以 hook 到系统任意一个 Java 进程（zygote、systemserver、systemui）。

xposed原理

首先，我们来简单梳理一下 Android 系统的启动流程：

1. 启动电源以及系统启动

   当电源按下时引导芯片代码开始从预定义的地方（固化在 ROM）开始执行。加载引导程序 Bootloader 到RAM，然后执行。

2. 引导程序 BootLoader

   引导程序 BootLoader 是在 Android 操作系统开始运行前的一个小程序，它的主要作用是把系统 OS 拉起来并运行。

3. Linux 内核启动

   内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置，它首先在系统文件中寻找 init.rc 文件，并启动 init 进程。

4. init 进程启动

   初始化和启动属性服务，并且启动 zygote 进程。

   init 进程有两个责任，一是挂载目录，比如/sys、/dev、/proc，二是运行 init.rc 脚本。

5. zygote 进程启动

   创建 JavaVM 并为 JavaVM 注册 JNI，创建服务端 Socket，启动 SystemServer 进程。在这个阶段，你可以看到启动动画。

6. SystemServer 进程启动

   启动 Binder 线程池和 SystemServiceManager，并且启动各种系统服务。

7. Launcher启动

   被 SystemServer 进程启动的 ActivityManagerService 会启动 Launcher，Launcher 启动后会将已安装应用的快捷图标显示到界面上。

在 Android 系统中，应用程序进程以及系统服务进程 SystemServer 都是有 zygote 进程孵化出来的，而 zygote 进程则是由 init 进程启动的（毕竟基于 Linux 系统），zygote 进程在启动的时候会创建一个 Dalvik（5.0以前默认，之后ART，空间交换时间） 虚拟机实每当它孵化一个新的应用程序简称时，都会将这个 Dalvik/ART 虚拟机实例复制到新的应用进程里面去，从而使得每一个应用程序进程都有各一个独立的 Dalvik/ART 虚拟机实例。而 zygote 进程对应的执行文件是/system/bin/app_process，而 Xposed 所做的就是替换了 app_process。

Xposed 用自己实现的 app_process 替换了系统提供的 app_process，加载一个额外的jar包，然后入口从原来的：com.android.internal.osZygoteInit.main() 被替换成了： de.robv.android.xposed.XposedBridge.main()， 然后创建的 Zygote 进程就变成 Hook 的 Zygote 进程了，而后面 Fork 出来的进程也是被Hook过的。

相关的一些文档：

• 官网：http://repo.xposed.info/
• 作者Github仓库：https://github.com/rovo89
• 官方教程：https://github.com/rovo89/XposedBridge/wiki/Development-tutorial
• XposedBridge.jar下载：https://jcenter.bintray.com/de/robv/android/xposed/api

工程组成

XposedInstaller

这是 Xposed 的插件管理和功能控制 APP，也就是说 Xposed 整体管控功能就是由这个APP来完成的，它包括启用Xposed 插件功能，下载和启用指定插件APP，还可以禁用 Xposed 插件功能等。注意，这个app要正常无误得运行必须能拿到 root 权限。

Xposed

这个项目属于 Xposed 框架，其实它就是单独搞了一套 xposed 版的 zygote。这个 zygote 会替换系统原生的zygote。所以，它需要由 XposedInstaller 在 root 之后放到 /system/bin 下。

XposedBridge

这个项目也是 Xposed 框架，它属于 Xposed 框架的Java部分，编译出来是一个 XposedBridge.jar 包。

XposedTools

Xposed 和 XposedBridge 编译依赖于Android源码，而且还有一些定制化的东西。所以XposedTools就是用来帮助我们编译 Xposed 和 XposedBridge的。

Xposed 项目创建

要上主菜了，先给大家说几句，其实 Xposed 插件就是一个完整的 apk，跟我们平常做的 apk 并没有多大的不同，只不过在项目中加了一些标识，让 Xposed 能狗识别，给这个 apk 特殊的权限，可以去影响其他 apk 的运行。

创建 Android 项目

当然，首先应该创建一个 Android 项目。

修改 AndroidManifest.xml

在 application 节点下添加三个 属性

1
2
3
4
5
6
7
8
9

<meta-data
    android:name="xposedmodule"
    android:value="true" />
<meta-data
    android:name="xposeddescription"
    android:value="主要是Xposed功能的一些简介" />
<meta-data
    android:name="xposedminversion"
    android:value="82" />

• xposedmodule： 一般设置为true,表示这是一个xposed模块
• xposeddescription: 一句话描述该模块的用途，可以引用string.xml中的字符串
• xposedminversion：要求支持的Xposed Framework最低版本。

引入 Xposed Framework API

在 app/build.gradle文件中声明 Xposed Framework API 的jar包依赖。

1

compileOnly 'de.robv.android.xposed:api:82'

• 请留意，这个82是Xposed Framework API的版本号，叫做xposedminversion。
• xposedminversion可以在这里进行查询： https://bintray.com/rovo89/de.robv.android.xposed/api
• Xposed Framework API文档请参考：http://api.xposed.info/reference/packages.html

创建 Xposed 入口文件

在 assets 文件夹下面创建一个名为 xposed_init 的文件， XposedBridge 会从 assets 目录中的 xposed_init 中获取入口点，比如：

1

top.programan.xposeddemo.XposedUtil

编写入口类

在此之前我们先修改下我们的MainActivity.java，修改下TextView显示的文字：

1
2
3
4
5
6
7
8

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        text2.text = "罗纳尔多"
    }
}

然后编写入口类，代码如下：

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

class XposedInit : IXposedHookLoadPackage {
    @Throws(Throwable::class)
    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
        //1.判断应用的包名
        if (lpparam.packageName.equals("top.programan.xposeddyhook")) {
            //2.找到对应的类并hook掉对应相应的方法
            //需要注意findAndHookMethod方法的参数：
            //(1): 要hook掉的类名:需要全路径
            //(2): classloader：
            //(3): 要hook掉的方法名:只需方法名
            //(4): 方法的参数:有几个写几个
            //(5): XC_MethodHook,实现具体的方法，
            // beforeHookedMethod为hook前做的一些操作，afterHookedMethod为hook后做的一些操作

            XposedHelpers.findAndHookMethod("top.programan.xposeddyhook.MainActivity",
                lpparam.classLoader, "onCreate", Bundle::class.java, object : XC_MethodHook() {
                    @Throws(Throwable::class)
                    override fun beforeHookedMethod(param: MethodHookParam) {
                        super.beforeHookedMethod(param)
                    }

                    @Throws(Throwable::class)
                    override fun afterHookedMethod(param: MethodHookParam) {
                        val clazz = lpparam.classLoader.loadClass("top.programan.xposeddyhook.MainActivity")
                        val field = clazz.getDeclaredField("text")
                        field.isAccessible = true
                        XposedBridge.log("MainActivity")//Xposed日志
                        val textView = field.get(param.thisObject) as TextView
                        textView.text = "尤文图斯"
                    }
                })

        }
    }
}

OK，到这里一个简单的 Xposed 项目已经完成了，安装我们完成的 apk，记得要在 XposedInstaller 里面选择该插件，然后重启手机。不出意外的话，应该是可以正常运行的。

如上发现，一个普通的 Xposed 项目是不难实现，更难实现的应该是怎么样去逆向逆向 hook 的应用，并找到逆向 hook 对应的代码。

Xposed 相关 API

IXposedHookLoadPackage

1 2 3 4 5 6 7 8

> /** > * Get notified when an app ("Android package") is loaded. > * This is especially useful to hook some app-specific methods. > * > * <p>This interface should be implemented by the module's main class. Xposed will take care of > * registering it as a callback automatically. > */ >

翻译起来就是：

当APP加载的时候就会收到通知，对于hook一些应用的特殊方法时十分有效，插件的主方法应该实现这个接口，Xposed将会自动的为他注册回调。

所以来说这个接口的作用很明显，如果是一个应用级别的插件那么入口类就需要实现的这个接口，当插件要hook的应用启动时就会回调这个接口的方法。Xposed自动帮我们做，很贴心。猜测源码实现应该是一个观察者模式。

使用代码如下：

1
2
3
4
5
6

class XposedInit : IXposedHookLoadPackage {
    @Throws(Throwable::class)
    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
    	//相应逻辑
    }
}

IXposedHookLoadPackage接口的回调方法handleLoadPackage的参数XC_LoadPackage.LoadPackageParam的源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
	 * Wraps information about the app being loaded.
	 */
	public static final class LoadPackageParam extends XCallback.Param {
		/** @hide */
		public LoadPackageParam(CopyOnWriteSortedSet<XC_LoadPackage> callbacks) {
			super(callbacks);
		}

		/** The name of the package being loaded. */
		public String packageName;

		/** The process in which the package is executed. */
		public String processName;

		/** The ClassLoader used for this package. */
		public ClassLoader classLoader;

		/** More information about the application being loaded. */
		public ApplicationInfo appInfo;

		/** Set to {@code true} if this is the first (and main) application for this process. */
		public boolean isFirstApplication;
	}

可以看到主要是要加载的应用的一些相关信息。

IXposedHookZygoteInit

1 2 3 4 5 6 7 8 9 10 11 12

> /** > * Hook the initialization of Zygote process(es), from which all the apps are forked. > * > * <p>Implement this interface in your module's main class in order to be notified when Android is > * starting up. In {@link IXposedHookZygoteInit}, you can modify objects and place hooks that should > * be applied for every app. Only the Android framework/system classes are available at that point > * in time. Use {@code null} as class loader for {@link XposedHelpers#findAndHookMethod(String, ClassLoader, String, Object...)} > * and its variants. > * > * <p>If you want to hook one/multiple specific apps, use {@link IXposedHookLoadPackage} instead. > */ >

翻译起来的大体意思就是：

hook初始的Zygote进程，所有的应用都会适用。在你插件的主方法实现这个接口，这样当android启动的时候这个接口就会被通知，你修改和hook的地方对所有的应用都会有效，假如你只想对某个应用起作用建议你只需要实现IXposedHookLoadPackage这个接口就行了。

使用代码如下：

1
2
3
4
5
6

class XposedZygoteInit : IXposedHookZygoteInit {
    @Throws(Throwable::class)
    override fun initZygote(startupParam: IXposedHookZygoteInit.StartupParam?) {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}

IXposedHookZygoteInit接口的回调方法initZygote的参数StartupParam的源码如下：

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

/** Data holder for {@link #initZygote}. */
	final class StartupParam {
		/*package*/ StartupParam() {}

		/** The path to the module's APK. */
		public String modulePath;

		/**
		 * Always {@code true} on 32-bit ROMs. On 64-bit, it's only {@code true} for the primary
		 * process that starts the system_server.
		 */
		public boolean startsSystemServer;
	}

在Zygote启动时调用，用于系统服务的Hook 回调方法initZygote()。

IXposedHookInitPackageResources

1 2 3 4 5 6 7 8

> /** > * Get notified when the resources for an app are initialized. > * In {@link #handleInitPackageResources}, resource replacements can be created. > * > * <p>This interface should be implemented by the module's main class. Xposed will take care of > * registering it as a callback automatically. > */ >

翻译起来的大体意思就是：

当应用资源被初始化的时候会被通知调用，在handleInitPackageResources方法里面可以替换资源。应该在主方法里面被实现，Xposed会自动注册通知调用回调方法。

1
2
3
4
5
6

class XposedZygoteInit : IXposedHookInitPackageResources {
    @Throws(Throwable::class)
    override fun handleInitPackageResources(resparam: XC_InitPackageResources.InitPackageResourcesParam?) {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}

IXposedHookInitPackageResources接口的回调方法handleInitPackageResources的参数InitPackageResourcesParam的源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
	 * Wraps information about the resources being initialized.
	 */
	public static final class InitPackageResourcesParam extends XCallback.Param {
		/** @hide */
		public InitPackageResourcesParam(CopyOnWriteSortedSet<XC_InitPackageResources> callbacks) {
			super(callbacks);
		}

		/** The name of the package for which resources are being loaded. */
		public String packageName;

		/**
		 * Reference to the resources that can be used for calls to
		 * {@link XResources#setReplacement(String, String, String, Object)}.
		 */
		public XResources res;
	}

有了这个XResource对象，就可以拿到通过覆写hookLayout方法拿到布局资源树。

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

class XposedZygoteInit : IXposedHookInitPackageResources {
    @Throws(Throwable::class)
    override fun handleInitPackageResources(resparam: XC_InitPackageResources.InitPackageResourcesParam?) {
        //hookLayout方法的参数：
        //1.包名：直接从参数中获取即可
        //2.资源的类型：有id，drawable，layout等等
        //3.布局名称：
        //4.回调接口
        resparam?.res?.hookLayout(resparam.packageName, "layout", "activity_main", object : XC_LayoutInflated() {
            @Throws(Throwable::class)
            override fun handleLayoutInflated(liparam: LayoutInflatedParam) {

            }
        })
    }
}

我们看下回调接口LayoutInflatedParam的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
	 * Wraps information about the inflated layout.
	 */
	public static final class LayoutInflatedParam extends XCallback.Param {
		/** @hide */
		public LayoutInflatedParam(CopyOnWriteSortedSet<XC_LayoutInflated> callbacks) {
			super(callbacks);
		}

		/** The view that has been created from the layout. */
		public View view;

		/** Container with the ID and name of the underlying resource. */
		public ResourceNames resNames;

		/** Directory from which the layout was actually loaded (e.g. "layout-sw600dp"). */
		public String variant;

		/** Resources containing the layout. */
		public XResources res;
	}

注意上面的View变量，这个就是布局资源树，可以进行遍历，拿到特定的控件，玩一些狂拽炫酷的东西。

XposedHelpers

findAndHookMethod

具体的使用和相关的参数介绍上面已经说过了，就不再重复，不过需要关注下findAndHookMethod的参数MethodHookParam，具体的源码如下：

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

/**
	 * Wraps information about the method call and allows to influence it.
	 */
	public static final class MethodHookParam extends XCallback.Param {
		...

		/** The {@code this} reference for an instance method, or {@code null} for static methods. */
		public Object thisObject;

		/** Arguments to the method call. */
		public Object[] args;

		private Object result = null;
		private Throwable throwable = null;
		/* package */ boolean returnEarly = false;

		/** Returns the result of the method call. */
		public Object getResult() {
			return result;
		}

		/**
		 * Modify the result of the method call.
		 *
		 * <p>If called from {@link #beforeHookedMethod}, it prevents the call to the original method.
		 */
		public void setResult(Object result) {
			this.result = result;
			this.throwable = null;
			this.returnEarly = true;
		}
        ...
	}

需要关注下thisObject，代表调用该方法的对象实例，如果是静态方法，返回一个Null，比如这里调用onCreate()方法的是MainActivity，那么获得的就是MainActivity实例。

其他的一些方法

• callMethod(Object obj,String methodName, Object… args)：在APP中调用特定方法； 参数依次是：调用方法的所在类，调用方法名，方法参数
• findClass(String className,ClassLoader classLoader)：获取class类实例 参数依次是类名，类加载器
• findMethodExact：通过反射查找类的成员方法(可setAccessible(true)设置非私有)
• findConstructorExact：通过反射查找构造函数(同样可设置可访问下性)
• findAndHookXXX：查找并Hook
• 只能Hook方法与构造方法，不能Hook接口和抽象方法

Xposed 模块开发优势和不足

优势

1. 功能强大，既可以修改系统应用，也可以修改其他应用。hook android,hook everything.
2. 使用灵活，既可以针对一款应用进行Hook，也可以针对所有应用进行Hook。

不足

1. 无法调试。只能通过打印日志进行跟踪。（例如：XposedBridge.log）
2. 无法即时生效。启用/禁用模块，你需要重启手机。
3. multidex 支持不足。详见Multidex support

抖音自动翻页

如果有时间的话，跟大家一块 hook 一下抖音，实现自动翻页的功能。

小结

以上，是本次分享的全部了。温馨提示，搞基需谨慎。

目录操作

文件操作

选择操作

安全操作

编程操作

进程操作

时间操作

网络与通信操作

Korn Shell 命令

其它命令

原文地址：https://www.jianshu.com/p/3291de46f3ff