TYAttributedLabel

1、TYAttributedLabel 简单，强大的属性文本控件(无需了解CoreText)
2、支持富文本，图文混排显示，支持行间距，字间距，自适应高度，指定行数
3、支持添加高度自定义文本属性
4、支持添加属性文本，自定义链接，新增高亮效果显示（文字和背景）
5、支持添加UIImage和UIView控件

demo演示

重点类简介

TYAttributedLabel

创建label（可接受文本及富文本）
设置字体间距
设置行间距
设置字体大小
设置view的位置和宽，会自动计算高度
设置链接文本，并用代理（TYAttributedLabelDelegate）方法完成点击后需完成的任务

TYImageStorage

可创建一个append在TYAttributedLabel后的图片控件，可自定义图片大小，及对齐样式

TYTextStorage

文本文件，可设置文本大小及字体颜色

TYTextContainer

属性文本生成器（使用 RegexKitLite）
具体代码及使用细节请看作者的demo（作者是华人），讲的很详细，这里就不再赘述

链接：TYAttributedLabel

链接：https://www.jianshu.com/p/5d81bf7e79c8

某天闲着无聊想练一下手速，去上拉一个小程序项目中一个有1万多条商品数据的列表。在数据加载到1000多条后，是列表居然出现了白屏。看了一下控制台：

‘Dom limit exceeded’，dom数超出了限制， 不知道微信是出于什么考虑，要限制页面的dom数量。

一.小程序页面限制多少个wxml节点？

写了个小dome做了个测试。 listData的数据结构为：

listData:[
   {
    isDisplay:true,
    itemList:[{
          qus:'下面哪位是刘发财女朋友?',
          answerA:'刘亦菲',
          answerB:'迪丽热巴',
          answerC:'斋藤飞鸟',
          answerD:'花泽香菜',
       }
      .......//20条数据
     ]
   }]

页面渲染效果：

     
         {{item.qus}}
         
              A. {{item.answerA}}
              B. {{item.answerB}}
              C. {{item.answerC}}
              D. {{item.answerD}}
         
           

2.dome2，删除了不必要的dom嵌套

     
         {{item.qus}}
         
              A. {{item.answerA}}
              B. {{item.answerB}}
              C. {{item.answerC}}
              D. {{item.answerD}}
         
           

通过大致计算，一个小程序页面大概可以渲染2万个wxml节点 而小程序官方的性能测评得分条件为少于1000个wxml节点官方链接

二.列表页面优化

newList=[{...},{...}];
   this.setData({
     listData:[...this.data.listData,...newList]
   })

let index=0;
  this.setData({
     [`listData[${index}].isDisplay`]:false,
  })

for(let index=0;index<10;index++){
     this.setData({
        [`listData[${index}].isDisplay`]:false,
     })
  }

let changeData={};
  for(let index=0;index<10;index++){
      changeData[[`listData[${index}].isDisplay`]]=false;
  }
  this.setData(changeData);

这样我们就把数组listData中下标从0到9的元素的isDisplay属性改成了false。

• setDate往数组末尾添加数据

如果只添加一条数据

let newData={...};
  this.setData({
    [`listData[${this.data.listData.length}]`]:newData
  })

如果是添加多条数据

let newData=[{...},{...},{...},{...},{...},{...}];
  let changeData={};
  let index=this.data.listData.length
    newData.forEach((item) => {
        changeData['listData[' + (index++) + ']'] = item //赋值，索引递增
    }) 
  this.setData(changeData)

三.使用自定义组件

可以把列表的一行或者多行封装到自定义组件里，在列表页使用一个组件，只算一个节点，这样你的列表能渲染的数据可以成倍数的增加。组件内的节点数也是有限制的，但是你可以一层层嵌套组件实现列表的无限加载，如果你不怕麻烦的话

四.使用虚拟列表

经过上面的一系列操作后，列表的性能会得到很大的提升，但是如果数据量实在太大，wxml节点数也会超出限制，导致页面发生错误。我们的处理方法是使用虚拟列表，页面只渲染当前可视区域以及可视区域上下若干条数据的节点，通过isDisplay控制节点的渲染。

• 可视区域上方：above
• 可视区域：screen
• 可视区域下方：below

listData:[
   {
    isDisplay:true,
    itemList:[{
          qus:'下面哪位是刘发财女朋友?',
          answerA:'刘亦菲',
          answerB:'迪丽热巴',
          answerC:'斋藤飞鸟',
          answerD:'花泽香菜',
       }
      .......//二维数组中的条数根据项目实际情况
     ]
   }]

data{
       itemHeight:4520,//列表第一层dom高度，单位为rpx
       itemPxHeight:'',//转化为px高度,因为小程序获取的滚动条高度单位为px
       aboveShowIndex:0,//已渲染数据的第一条的Index
       belowShowNum:0,//显示区域下方隐藏的条数
       oldSrollTop:0,//记录上一次滚动的滚动条高度，判断滚动方向
       prepareNum:5,//可视区域上下方要渲染的数量
       throttleTime:200，//滚动事件节流的时间，单位ms
   }

3.wxml的dom结构

     
   
    
        
           {{item.qus}}
           
                A. {{item.answerA}}
                B. {{item.answerB}}
                C. {{item.answerC}}
                D. {{item.answerD}}
           
           
    
    
     

4.获取列表第一层dom的px高度

let query = wx.createSelectorQuery();
  query.select('.content').boundingClientRect(rect=>{
    let clientWidth = rect.width;
    let ratio = 750 / clientWidth;
    this.setData({
      itemPxHeight:Math.floor(this.data.itemHeight/ratio),
     })
   }).exec();

5.页面滚动时间节流

function throttle(fn){
  let valid = true
  return function() {
     if(!valid){
         return false 
     }
     // 工作时间，执行函数并且在间隔期内把状态位设为无效
      valid = false
      setTimeout(() => {
          fn.call(this,arguments);
          valid = true;
      }, this.data.throttleTime)
  }
}

6.页面滚动事件处理

onPageScroll:throttle(function(e){
    let scrollTop=e[0].scrollTop;//滚动条高度
    let itemNum=Math.floor(scrollTop/this.data.itemPxHeight);//计算出可视区域的数据Index
    let clearindex=itemNum-this.data.prepareNum+1;//滑动后需要渲染数据第一条的index
    let oldSrollTop=this.data.oldSrollTop;//滚动前的scrotop,用于判断滚动的方向
    let aboveShowIndex=this.data.aboveShowIndex；//获取已渲染数据第一条的index
    let listDataLen=this.data.listData.length;
    let changeData={}
  //向下滚动
    if(scrollTop-oldSrollTop>0){
        if(clearindex>0){
         //滚动后需要变更的条数
          for(let i=aboveShowIndex;i                changeData[[`listData[${i}].isDisplay`]]=false;
                let belowShowIndex=i+2*this.data.prepareNum;
                if(i+2*this.data.prepareNum                  changeData[[`listData[${belowShowIndex}].isDisplay`]]=true;
                 }
          }   
        }    
    }else{//向上滚动
        if(clearindex>=0){
         let changeData={}
         for(let i=aboveShowIndex-1;i>=clearindex;i--){
           let belowShowIndex=i+2*this.data.prepareNum
           if(i+2*this.data.prepareNum<=listDataLen-1){
            changeData[[`listData[${belowShowIndex}].isDisplay`]]=false;
           }
           changeData[[`listData[${i}].isDisplay`]]=true;
         }  
        }else{
          if(aboveShowIndex>0){
            for(let i=0;i              this.setData({
                [`listData[${i}].isDisplay`]:true,
              })
            }
          }
        }      
    }
    clearindex=clearindex>0?clearindex:0
    if(clearindex>=0&&!(clearindex>0&&clearindex==this.data.aboveShowIndex)){
      changeData.aboveShowIndex=clearindex;
      let belowShowNum=this.data.listData.length-(2*this.data.prepareNum+clearindex)
      belowShowNum=belowShowNum>0?belowShowNum:0
      if(belowShowNum>=0){
        changeData.belowShowNum=belowShowNum
      }
      this.setData(changeData)
    }
    this.setData({
      oldSrollTop:scrollTop
    })
  }),

经过上面的处理后，页面的wxml节点数量相对稳定，可能因为可视区域数据的index计算误差，页面渲染的数据有小幅度的浮动，但是已经完全不会超过小程序页面的节点数量的限制。理论上100万条数据的列表也不会有问题，只要你有耐心和精力一直划列表加载这么多数据。

Moya最新版本11.0.2

由于前段时间写了这篇文章，最新Moya已更新最新版本，故此也更新了下用法，本人已使用，故特意奉上最新的使用demo供参考。
Moya11.0.2Demo

Moya简介

Moya 是你的 app 中缺失的网络层。不用再去想在哪儿（或者如何）安放网络请求，Moya 替你管理。

Moya有几个比较好的特性:

1、编译时检查正确的API端点访问.

2、使你定义不同端点枚举值对应相应的用途更加明晰.

3、提高测试地位从而使单元测试更加容易.

Swift我们用Alamofire来做网络库.而Moya在Alamofire的基础上又封装了一层,如下流程图说明Moya的简单工作流程图:

** Moya**的官方下载地址点我强大的Moya,有具体的使用方法在demo里面有说明。

本文主要介绍一下Moya的用法

1、设置请求头部信息
2、设置超时时间
3、自定义插件
4、自签名证书
注意：以下所出现的NetAPIManager跟官网上demo的** GitHub**是一样类型的文件，都是这个enum实现一个协议TargetType，点进去可以看到TargetType定义了我们发送一个网络请求所需要的东西，什么baseURL，parameter，method等一些计算性属性，我们要做的就是去实现这些东西，当然有带默认值的我们可以不去实现，但是设置头部信息跟超时时间就要修改这些系统默认设置了。

为了看得更加清楚，贴上NetAPIManager文件的内容

//
//  NetAPIManager.swift
//  NN110
//
//  Created by 陈亦海 on 2017/5/12.
//  Copyright © 2017年 陈亦海. All rights reserved.
//

import Foundation
import Moya


enum NetAPIManager {
    case Show
    case upload(bodyData: Data)
    case download
    case request(isTouch: Bool, body: Dictionary<String, Any>? ,isShow: Bool)
}


extension NetAPIManager: TargetType {
    var baseURL: URL {//服务器地址
        
        switch self {
        case .request( _, _, _):
            return URL(string: "https://www.pmphmall.com")!
        default:
            return URL(string: "https://httpbin.org")!
        }
        
        
    }
    
    var path: String {//具体某个方法的路径
        switch self {
        case .Show:
            return ""
        case .upload(_):
            return ""
        case .request(_, _, _):
            return "/app/json.do"
        case .download:
            return ""
        }
    }
    
    var method: Moya.Method {//请求的方法 get或者post之类的
        switch self {
        case .Show:
            return .get
        case .request(_, _, _):
            return .post
        default:
            return .post
        }
    }
    
    var parameters: [String: Any]? {//请求的get post给服务器的参数
        switch self {
        case .Show:
            return nil
        case .request(_, _, _):
            return ["msg":"H4sIAAAAAAAAA11SSZJFIQi7EqPAEgTvf6TP62W7sMoSQhKSWDrs6ZUKVWogLwYV7RjHFBZJlNlzloN6LVqID4a+puxqRdUKVNLwE1TRcZIC/fjF2rPotuXmb84r1gMXbiASZIZbhQdKEewJlz41znDkujCHuQU3dU7G4/PmVRnwArMLXukBv0J23XVahNO3VX35wlgce6TLUzzgPQJFuHngAczl6VhaNXpmRLxJBlMml6gdLWiXxTdO7I+iEyC7XuTirCQXOk4dotgArgkH/InxVjfNTnE/uY46++hyAiLFuFL4cv1Z8WH5DgB2GnvFXMh5gm53Tr13vqqrEYtcdXfkNsMwKB+9sAQ77grNJmquFWOhfXA/DELlMB0KKFtHOc/ronj1ml+Z7qas82L3VWiCVQ+HEitjTVzoFw8RisFN/jJxBY4awvq427McXqnyrfCsl7oeEU6wYgW9yJtj1lOkx0ELL5Fw4z071NaVzRA9ebxWXkFyothgbB445cpRmTC+//F73r1kOyQ3lTpec12XNDR00nnq5/YmJItW3+w1z27lSOLqgVctrxG4xdL9WVPdkH1tkiZ/pUKBGhADAAA="]
        default:
            return nil
        
        }
    }
    
    var sampleData: Data { //编码转义
       return "{}".data(using: String.Encoding.utf8)!
    }
    
    var task: Task { //一个请求任务事件
        
        switch self {

        
        case let .upload(data):
        return .upload(.multipart([MultipartFormData(provider: .data(data), name: "file", fileName: "gif.gif", mimeType: "image/gif")]))
            
        default:
            return .request

       }

     }
    
    var parameterEncoding: ParameterEncoding {//编码的格式
        switch self {
        case .request(_, _, _):
            return URLEncoding.default
        default:
            return URLEncoding.default
        }
        
    }
    //以下两个参数是我自己写，用来控制网络加载的时候是否允许操作，跟是否要显示加载提示，这两个参数在自定义插件的时候会用到
    var touch: Bool { //是否可以操作
        
        switch self {
        case .request(let isTouch, _, _):
            return isTouch
        default:
            return false
        }
        
    }
    
    var show: Bool { //是否显示转圈提示
        
        switch self {
        case .request( _, _,let isShow):
            return isShow
        default:
            return false
        }
        
    }
    
    
}

如何设置Moya请求头部信息

头部信息的设置在开发过程中很重要，如服务器生成的token，用户唯一标识等
我们直接上代码，不说那么多理论的东西，哈哈

// MARK: - 设置请求头部信息
let myEndpointClosure = { (target: NetAPIManager) -> Endpoint<NetAPIManager> in
    
    
    let url = target.baseURL.appendingPathComponent(target.path).absoluteString
    let endpoint = Endpoint<NetAPIManager>(
        url: url,
        sampleResponseClosure: { .networkResponse(200, target.sampleData) },
        method: target.method,
        parameters: target.parameters,
        parameterEncoding: target.parameterEncoding
    )

    //在这里设置你的HTTP头部信息
    return endpoint.adding(newHTTPHeaderFields: [
        "Content-Type" : "application/x-www-form-urlencoded",
        "ECP-COOKIE" : ""
        ])
    
}

如何设置请求超时时间

// MARK: - 设置请求超时时间
let requestClosure = { (endpoint: Endpoint<NetAPIManager>, done: @escaping MoyaProvider<NetAPIManager>.RequestResultClosure) in
    
    guard var request = endpoint.urlRequest else { return }
    
    request.timeoutInterval = 30    //设置请求超时时间
    done(.success(request))
}

自定义插件

自定义插件必须PluginType协议的两个方法willSend与didReceive

//
//  MyNetworkActivityPlugin.swift
//  NN110
//
//  Created by 陈亦海 on 2017/5/10.
//  Copyright © 2017年 CocoaPods. All rights reserved.
//

import Foundation
import Result
import Moya


/// Network activity change notification type.
public enum MyNetworkActivityChangeType {
    case began, ended
}

/// Notify a request's network activity changes (request begins or ends).
public final class MyNetworkActivityPlugin: PluginType {
    
    
    
    public typealias MyNetworkActivityClosure = (_ change: MyNetworkActivityChangeType, _ target: TargetType) -> Void
    let myNetworkActivityClosure: MyNetworkActivityClosure
    
    public init(newNetworkActivityClosure: @escaping MyNetworkActivityClosure) {
        self.myNetworkActivityClosure = newNetworkActivityClosure
    }
    
    // MARK: Plugin
    
    /// Called by the provider as soon as the request is about to start
    public func willSend(_ request: RequestType, target: TargetType) {
        myNetworkActivityClosure(.began,target)
    }
    
    /// Called by the provider as soon as a response arrives, even if the request is cancelled.
    public func didReceive(_ result: Result<Moya.Response, MoyaError>, target: TargetType) {
        myNetworkActivityClosure(.ended,target)
    }
}

使用自定义插件方法

// MARK: - 自定义的网络提示请求插件
let myNetworkPlugin = MyNetworkActivityPlugin { (state,target) in
    if state == .began {
        //        SwiftSpinner.show("Connecting...")
        
        let api = target as! NetAPIManager
        if api.show {
            print("我可以在这里写加载提示")
        }
        
        if !api.touch {
            print("我可以在这里写禁止用户操作，等待请求结束")
        }

        print("我开始请求\(api.touch)")
        
        UIApplication.shared.isNetworkActivityIndicatorVisible = true
    } else {
        //        SwiftSpinner.show("request finish...")
        //        SwiftSpinner.hide()
        print("我结束请求")
        UIApplication.shared.isNetworkActivityIndicatorVisible = false
        
    }
}

自签名证书

在16年的WWDC中，Apple已表示将从2017年1月1日起，所有新提交的App必须强制性应用HTTPS协议来进行网络请求。默认情况下非HTTPS的网络访问是禁止的并且不能再通过简单粗暴的向Info.plist中添加NSAllowsArbitraryLoads
设置绕过ATS(App Transport Security)的限制（否则须在应用审核时进行说明并很可能会被拒）。所以还未进行相应配置的公司需要尽快将升级为HTTPS的事项提上进程了。本文将简述HTTPS及配置数字证书的原理并以配置实例和出现的问题进行说明，希望能对你提供帮助。(比心~)

HTTPS：
简单来说，HTTPS就是HTTP协议上再加一层加密处理的SSL协议,即HTTP安全版。相比HTTP，HTTPS可以保证内容在传输过程中不会被第三方查看、及时发现被第三方篡改的传输内容、防止身份冒充，从而更有效的保证网络数据的安全。
HTTPS客户端与服务器交互过程：
1、 客户端第一次请求时，服务器会返回一个包含公钥的数字证书给客户端；
2、 客户端生成对称加密密钥并用其得到的公钥对其加密后返回给服务器；
3、 服务器使用自己私钥对收到的加密数据解密，得到对称加密密钥并保存；
4、 然后双方通过对称加密的数据进行传输。

数字证书：
在HTTPS客户端与服务器第一次交互时，服务端返回给客户端的数字证书是让客户端验证这个数字证书是不是服务端的，证书所有者是不是该服务器，确保数据由正确的服务端发来，没有被第三方篡改。数字证书可以保证数字证书里的公钥确实是这个证书的所有者(Subject)的，或者证书可以用来确认对方身份。证书由公钥、证书主题(Subject)、数字签名(digital signature)等内容组成。其中数字签名就是证书的防伪标签，目前使用最广泛的SHA-RSA加密。
证书一般分为两种：

1、一种是向权威认证机构购买的证书，服务端使用该种证书时，因为苹果系统内置了其受信任的签名根证书，所以客户端不需额外的配置。为了证书安全，在证书发布机构公布证书时，证书的指纹算法都会加密后再和证书放到一起公布以防止他人伪造数字证书。而证书机构使用自己的私钥对其指纹算法加密，可以用内置在操作系统里的机构签名根证书来解密，以此保证证书的安全。
2、另一种是自己制作的证书，即自签名证书。好处是不需要花钱购2买，但使用这种证书是不会受信任的，所以需要我们在代码中将该证书配置为信任证书.

自签名证书具体实现:

我们在使用自签名证书来实现HTTPS请求时，因为不像机构颁发的证书一样其签名根证书在系统中已经内置了，所以我们需要在App中内置自己服务器的签名根证书来验证数字证书。首先将服务端生成的.cer格式的根证书添加到项目中，注意在添加证书要一定要记得勾选要添加的targets。这里有个地方要注意：苹果的ATS要求服务端必须支持TLS 1.2或以上版本；必须使用支持前向保密的密码；证书必须使用SHA-256或者更好的签名hash算法来签名，如果证书无效，则会导致连接失败。由于我在生成的根证书时签名hash算法低于其要求，在配置完请求时一直报NSURLErrorServerCertificateUntrusted = -1202错误，希望大家可以注意到这一点。

那么如何在Moya中使用自签名的证书来实现HTTPS网络请求呢，请期待下回我专门分享......需要自定义一个Manager管理

综合使用的方法如下

定义一个公用的Moya请求服务对象

let MyAPIProvider = MoyaProvider<NetAPIManager>(endpointClosure: myEndpointClosure,requestClosure: requestClosure, plugins: [NetworkLoggerPlugin(verbose: true, responseDataFormatter: JSONResponseDataFormatter),myNetworkPlugin])

// MARK: -创建一个Moya请求
func sendRequest(_ postDict: Dictionary<String, Any>? = nil,
                 success:@escaping (Dictionary<String, Any>)->(),
                 failure:@escaping (MoyaError)->()) -> Cancellable? {
    
   let request = MyAPIProvider.request(.Show) { result in    
        switch result {
        case let .success(moyaResponse):
            
            
            do {
                let any = try moyaResponse.mapJSON()
                let data =  moyaResponse.data
                let statusCode =  moyaResponse.statusCode
                MyLog("\(data) --- \(statusCode) ----- \(any)")
                
                success(["":""])
                

            } catch {
                
            }
            
           
            
        case let .failure(error):
            
            print(error)
            failure(error)
        }
    }
    
    return request
}

取消所有的Moya请求

// MARK: -取消所有请求
func cancelAllRequest() {
//    MyAPIProvider.manager.session.invalidateAndCancel()  //取消所有请求
    MyAPIProvider.manager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
        dataTasks.forEach { $0.cancel() }
        uploadTasks.forEach { $0.cancel() }
        downloadTasks.forEach { $0.cancel() }
    }
    
    //let sessionManager = Alamofire.SessionManager.default
    //sessionManager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
    //    dataTasks.forEach { $0.cancel() }
    //    uploadTasks.forEach { $0.cancel() }
    //    downloadTasks.forEach { $0.cancel() }
    //}

}

转自：https://www.jianshu.com/p/38fbc22a1e2b

##WelikeAndroid 是什么? WelikeAndroid 是一款引入即用的便捷开发框架,致力于为程序员打造最佳的编程体验,
使用WelikeAndroid, 你会觉得写代码是一件很轻松的事情.

##Welike带来了哪些特征？

WelikeAndroid目前包含五个大模块:

• 异常安全隔离模块(实验阶段):当任何线程抛出任何异常,我们的异常隔离机制都会让UI线程继续运行下去.
• Http模块: 一行代码完成POST、GET请求和Download,支持上传, 高度优化Disk的缓存加载机制,
  自由设置缓存大小、缓存时间(也支持永久缓存和不缓存).
• Bitmap模块: 一行代码完成异步显示图片,无需考虑OOM问题,支持加载前对图片做自定义处理.
• Database模块: 支持NotNull,Table,ID,Ignore等注解,Bean无需Getter和Setter,一键式部署数据库.
• ui操纵模块: 我们为Activity基类做了完善的封装,继承基类可以让代码更加优雅.
• 另:请不要认为功能相似,框架就不是原创,源码摆在眼前,何不看一看?

使用WelikeAndroid需要以下权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<uses-permission android:name="android.permission.INTERNET" />

##下文将教你如何圆润的使用WelikeAndroid:
###通过WelikeContext在任意处取得上下文:

• WelikeContext.getApplication(); 就可以取得当前App的上下文
• WelikeToast.toast("你好!"); 简单一步弹出Toast.
  

##WelikeGuard(异常安全隔离机制用法):

• 第一步,开启异常隔离机制:

WelikeGuard.enableGuard();

• 第二步,注册一个全局异常监听器:

WelikeGuard.registerUnCaughtHandler(new Thread.UncaughtExceptionHandler() {

@Override

public void uncaughtException(Thread thread, Throwable ex) {



 WelikeGuard.newThreadToast("出现异常了: " + ex.getMessage() );



}

});

• 你也可以自定义异常:

/**

*

* 自定义的异常,当异常被抛出后,会自动回调onCatchThrowable函数.

*/

@Catch(process = "onCatchThrowable")

public class CustomException extends IllegalAccessError {



   public static void onCatchThrowable(Thread t){

    WeLog.e(t.getName() + "  抛出了一个异常...");

   }

}

• 另外,继承自UncaughtThrowable的异常我们不会对其进行拦截.

使用Welike做屏幕适配:

Welike的ViewPorter类提供了屏幕适配的Fluent-API,我们可以通过一组流畅的API轻松做好屏幕适配.

        ViewPorter.from(button).ofScreen().divWidth(2).commit();//宽度变为屏幕的二分之一

        ViewPorter.from(button).of(viewGroup).divHeight(2).commit();//高度变为viewGroup的二分之一

        ViewPorter.from(button).div(2).commit();//宽度和高度变为屏幕的四分之一

        ViewPorter.from(button).of(this).fillWidth().fillHeight().commit();//宽度和高度铺满Activity

        ViewPorter.from(button).sameAs(imageView).commit();//button的宽度和高度和imageView一样

WelikeHttp入门:

首先来看看框架的调试信息,是不是一目了然.  

• 第一步,取得WelikeHttp默认实例.

WelikeHttp welikeHttp = WelikeHttp.getDefault();

• 第二步,发送一个Get请求.

HttpParams params = new HttpParams();

params.putParams("app","qr.get",

                 "data","Test");//一次性放入两对 参数 和 值



//发送Get请求

HttpRequest request = welikeHttp.get("http://api.k780.com:88", params, new HttpResultCallback() {

    @Override

    public void onSuccess(String content) {

    super.onSuccess(content);

    WelikeToast.toast("返回的JSON为:" + content);

    }



    @Override

    public void onFailure(HttpResponse response) {

    super.onFailure(response);

    WelikeToast.toast("JSON请求发送失败.");

    }



    @Override

    public void onCancel(HttpRequest request) {

    super.onCancel(request);

    WelikeToast.toast("请求被取消.");

    }

});



    //取消请求,会回调onCancel()

    request.cancel();

当然,我们为满足需求提供了多种扩展的Callback,目前我们提供以下Callback供您选择:

• HttpCallback(响应为byte[]数组)
• FileUploadCallback(仅在上传文件时使用)
• HttpBitmapCallback(建议使用Bitmap模块)
• HttpResultCallback(响应为String)
• DownloadCallback(仅在download时使用)

如需自定义Http模块的配置(如缓存时间),请查看HttpConfig.

WelikeBitmap入门:

• 第一步,取得默认的WelikeBitmap实例:

//取得默认的WelikeBitmap实例

WelikeBitmap welikeBitmap = WelikeBitmap.getDefault();

• 第二步,异步加载一张图片:

BitmapRequest request = welikeBitmap.loadBitmap(imageView,

"http://img0.imgtn.bdimg.com/it/u=937075122,1381619862&fm=21&gp=0.jpg",

android.R.drawable.btn_star,//加载中显示的图片

android.R.drawable.ic_delete,//加载失败时显示的图片

new BitmapCallback() {



    @Override

    public Bitmap onProcessBitmap(byte[] data) {

    //如果需要在加载时处理图片,可以在这里处理,

    //如果不需要处理,就返回null或者不复写这个方法.

    return null;

    }



    @Override

    public void onPreStart(String url) {

    super.onPreStart(url);

    //加载前回调

    WeLog.d("===========> onPreStart()");

    }



    @Override

    public void onCancel(String url) {

    super.onCancel(url);

    //请求取消时回调

    WeLog.d("===========> onCancel()");

    }



    @Override

    public void onLoadSuccess(String url, Bitmap bitmap) {

    super.onLoadSuccess(url, bitmap);

    //图片加载成功后回调

    WeLog.d("===========> onLoadSuccess()");

    }



    @Override

    public void onRequestHttp(HttpRequest request) {

    super.onRequestHttp(request);

    //图片需要请求http时回调

    WeLog.d("===========> onRequestHttp()");

    }



    @Override

    public void onLoadFailed(HttpResponse response, String url) {

    super.onLoadFailed(response, url);

    //请求失败时回调

    WeLog.d("===========> onLoadFailed()");

    }

});

• 如果需要自定义Config,请看BitmapConfig这个类.

##WelikeDAO入门：

• 首先写一个Bean.

/*表名,可有可无,默认为类名.*/

@Table(name="USER",afterTableCreate="afterTableCreate")

public class User{

@ID

public int id;//id可有可无,根据自己是否需要来加.



/*这个注解表示name字段不能为null*/

@NotNull

public String name;



    public static void afterTableCreate(WelikeDao dao){

        //在当前的表被创建时回调,可以在这里做一些表的初始化工作

    }

}

• 然后将它写入到数据库

WelikeDao db = WelikeDao.instance("Welike.db");

User user = new User();

user.name = "Lody";

db.save(user);

• 从数据库取出Bean

User savedUser = db.findBeanByID(1);

• SQL复杂条件查询

List<User> users = db.findBeans().where("name = Lody").or("id = 1").find();

• 更新指定ID的Bean

User wantoUpdateUser = new User();

wantoUpdateUser.name = "NiHao";

db.updateDbByID(1,wantoUpdateUser);

• 删除指ID定的Bean

db.deleteBeanByID(1);

• 更多实例请看DEMO和API文档.

##十秒钟学会WelikeActivity

• 我们将Activity的生命周期划分如下:

=>@initData(所有标有InitData注解的方法都最早在子线程被调用)

=>initRootView(bundle)

=>@JoinView(将标有此注解的View自动findViewByID和setOnClickListener)

=>onDataLoaded(数据加载完成时回调)

=>点击事件会回调onWidgetClick(View Widget)

###关于@JoinView的细节:

• 有以下三种写法:

@JoinView(name = "welike_btn")

Button welikeBtn;

@JoinView(id = R.id.welike_btn)

Button welikeBtn;

@JoinView(name = "welike_btn",click = false)

Button welikeBtn;

• click为true时会自动调用view的setOnClickListener方法,并在onWidgetClick回调.
• 当需要绑定的是一个Button的时候, click属性默认为true,其它的View则默认为false.

一个简洁而又优雅的Android原生UI框架，解放你的双手！还不赶紧点击使用说明文档，体验一下吧！

涵盖绝大部分的UI组件：TextView、Button、EditText、ImageView、Spinner、Picker、Dialog、PopupWindow、ProgressBar、LoadingView、StateLayout、FlowLayout、Switch、Actionbar、TabBar、Banner、GuideView、BadgeView、MarqueeView、WebView、SearchView等一系列的组件和丰富多彩的样式主题。

在提issue前，请先阅读【提问的智慧】，并严格按照issue模板进行填写，节约大家的时间。

在使用前，请一定要仔细阅读使用说明文档,重要的事情说三遍！！！

在使用前，请一定要仔细阅读使用说明文档,重要的事情说三遍！！！

在使用前，请一定要仔细阅读使用说明文档,重要的事情说三遍！！！

X系列库快速集成

为了方便大家快速集成X系列框架库，我提供了一个空壳模版供大家参考使用: https://github.com/xuexiangjys/TemplateAppProject

除此之外，我还特别制作了几期视频教程供大家学习参考.

特征

• 简洁优雅，尽可能少得引用资源文件的数量，项目库整体大小不足1M(打包后大约644k）。

• 组件丰富，提供了绝大多数我们在开发者常用的功能组件。

• 使用简单，为方便快速开发，提高开发效率，对api进行了优化，提供一键式接入。

• 样式统一，框架提供了一系列统一的样式，使UI整体看上去美观和谐。

• 兼容性高，框架还提供了3种不同尺寸设备的样式（4.5英寸、7英寸和10英寸），并且最低兼容到Android 17, 让UI兼容性更强。

• 扩展性强，各组件提供了丰富的属性和样式API，可以通过设置不同的样式属性，构建不同风格的UI。

如何使用

在决定使用XUI前，你必须明确的一点是，此框架给出的是一整套UI的整体解决方案，如果你只是想使用其中的几个控件，那大可不必引入如此庞大的一个UI库，Github上会有更好的组件库。如果你是想拥有一套可以定制的、统一的UI整体解决方案的话，那么你就继续往下看吧！

添加Gradle依赖

1.先在项目根目录的 build.gradle 的 repositories 添加:

allprojects {

     repositories {

        ...

        maven { url "https://jitpack.io" }

    }

}

2.然后在dependencies添加:

dependencies {

  ...

  //androidx项目

  implementation 'com.github.xuexiangjys:XUI:1.1.7'



  implementation 'androidx.appcompat:appcompat:1.1.0'

  implementation 'androidx.recyclerview:recyclerview:1.1.0'

  implementation 'com.google.android.material:material:1.1.0'

  implementation 'com.github.bumptech.glide:glide:4.11.0'

}

【注意】如果你的项目目前还未使用androidx，请使用如下配置：

dependencies {

  ...

  //support项目

  implementation 'com.github.xuexiangjys:XUI:1.0.9-support'



  implementation 'com.android.support:appcompat-v7:28.0.0'

  implementation 'com.android.support:recyclerview-v7:28.0.0'

  implementation 'com.android.support:design:28.0.0'

  implementation 'com.github.bumptech.glide:glide:4.8.0'

}

初始化XUI设置

1.调整应用的基础主题（必须）

必须设置应用的基础主题，否则组件将无法正常使用！必须保证所有用到XUI组件的窗口的主题都为XUITheme的子类，这非常重要！！！

基础主题类型：

• 大平板(10英寸, 240dpi, 1920*1200）：XUITheme.Tablet.Big

• 小平板(7英寸, 320dpi, 1920*1200）：XUITheme.Tablet.Small

• 手机（4.5英寸, 320dpi, 720*1280）：XUITheme.Phone

<style name="AppTheme" parent="XUITheme.Phone">


    <!-- 自定义自己的主题样式 -->


    <item name="colorPrimary">@color/colorPrimary</item>

    <item name="colorPrimaryDark">@color/colorPrimaryDark</item>

    <item name="colorAccent">@color/colorAccent</item>


</style>

当然也可以在Activity刚开始时调用如下代码动态设置主题

@Override

protected void onCreate(Bundle savedInstanceState) {

    XUI.initTheme(this);

    super.onCreate(savedInstanceState);

    ...

}

2.调整字体库（对字体无要求的可省略）

（1）设置你需要修改的字体库路径（assets下）

//设置默认字体为华文行楷，这里写你的字体库

XUI.getInstance().initFontStyle("fonts/hwxk.ttf");

（2）在项目的基础Activity中加入如下代码注入字体.

注意：1.1.4版本之后使用如下设置注入

@Override

protected void attachBaseContext(Context newBase) {

    //注入字体

    super.attachBaseContext(ViewPumpContextWrapper.wrap(newBase));

}

注意：1.1.3版本及之前的版本使用如下设置注入

@Override

protected void attachBaseContext(Context newBase) {

    //注入字体

    super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase));

}

混淆配置

-keep class com.xuexiang.xui.widget.edittext.materialedittext.** { *; }

代码下载:XUI.zip

接入指南：

1、导入libSdk 依赖工程

2、配置 AndroidManifest文件（配置内容，请看下文，此处支持 两种方式来配置 第三方支付 参数【①可以在AndroidManifest 对应的meta-data 配置；②支持在代码中配置；选其一即可】）

• 2.1 拷贝assets/data.bin 文件到 项目中

3、项目中实际使用支付：具体使用看下文 ---> 调起支付 。

请配置正确的参数，否则支付宝和微信 会出现无法调起的情况。

//配置 AndroidManifest

    <activity

        android:name="net.lbh.pay.PaymentActivity"

        android:launchMode="singleTop"

        android:theme="@android:style/Theme.Translucent.NoTitleBar" />



    <activity-alias

        android:name=".wxapi.WXPayEntryActivity"

        android:exported="true"

        android:targetActivity="net.lbh.pay.PaymentActivity" />

    <!-- 微信支付 end -->





    <!-- 支付宝 begin -->

    <activity

        android:name="com.alipay.sdk.app.H5PayActivity"

        android:configChanges="orientation|keyboardHidden|navigation"

        android:exported="false"

        android:screenOrientation="behind"

        android:windowSoftInputMode="adjustResize|stateHidden" />

    <!-- 支付宝 end -->





    <!-- 银联支付 begin -->

    

    <activity

        android:name="com.unionpay.uppay.PayActivity"

        android:configChanges="orientation|keyboardHidden"

        android:excludeFromRecents="true"

        android:screenOrientation="portrait"

        android:windowSoftInputMode="adjustResize" />

        

    <activity

        android:name="com.unionpay.UPPayWapActivity"

        android:configChanges="orientation|keyboardHidden"

        android:screenOrientation="portrait"

        android:windowSoftInputMode="adjustResize" />



    <!-- 银联支付 end -->





    <!-- 微信 广播 start -->

    <receiver android:name="net.lbh.pay.wxpay.AppRegister" >

        <intent-filter>

            <action android:name="com.tencent.mm.plugin.openapi.Intent.ACTION_REFRESH_WXAPP" />

        </intent-filter>

    </receiver>

    <!-- 微信 广播 end -->





    <!-- 微信支付 参数 appid， 需要替换成你自己的 -->

    <meta-data

        android:name="WXPAY_APP_ID"

        android:value="替换成自己的 app id" >

    </meta-data>

    <meta-data

        android:name="WXPAY_MCH_ID"

        android:value="替换成自己的   MCH_ID" >

    </meta-data>

    <meta-data

        android:name="WXPAY_API_KEY"

        android:value="替换成自己的 api key" >

    </meta-data>

    <!-- 微信支付 参数 end  需要替换成你自己的 -->





    <!-- 支付宝 参数 appid， 需要替换成你自己的 -->  //如果是 超过10位数字，要在前边加 ,Eg: \0223987667567887653

    <meta-data

        android:name="ALIPAY_PARTNER_ID"

        android:value="替换成自己的 partenr id" >

    </meta-data>

    <meta-data

        android:name="ALIPAY_SELLER_ID"

        android:value="替换成自己的 seller id" >

    </meta-data>



    <meta-data

        android:name="ALIPAY_PRIVATE_KEY"

        android:value="替换成自己的 private key" >

    </meta-data>



    <meta-data

        android:name="ALIPAY_PUBLIC_KEY"

        android:value="替换成自己的 public key" >

    </meta-data>

    <!-- 支付宝 参数 end  需要替换成你自己的 -->

// 初始化支付组件

	PayAgent payAgent = PayAgent.getInstance();

	payAgent.setDebug(true);

	

// 代码初始化 参数， 此处针对场景，所有参数有 自己app server保管的时候，动态的支付配置下发参数

	payAgent.initAliPayKeys(partnerId, sellerId, privateKey, publicKey);

	payAgent.initWxPayKeys(appId, mchId, appKey)

	//		初始化 银联支付 所需的 验签 参数

	//payAgent.initUpPayKeys(PublicKeyPMModulus, publicExponent, PublicKeyProductModulus);

// 代码动态初始化为 可选 

payAgent.initPay(this);

// 调起支付

    PayAgent.getInstance().onPay(payType, this, payInfo,

			new OnPayListener() {



				@Override

				public void onStartPay() {

					

					progressDialog.setTitle("加载中。。。");

					progressDialog.show();

				}



				@Override

				public void onPaySuccess() {

					

					Toast.makeText(MainActivity.this,"支付成功！", 1).show();

					

					if (null != progressDialog) {

						progressDialog.dismiss();

					}



				}



				@Override

				public void onPayFail(String code, String msg) {

					Toast.makeText(MainActivity.this,

							"code:" + code + "msg:" + msg, 1).show();

					Log.e(getClass().getName(), "code:" + code + "msg:" + msg);

					

					if (null != progressDialog) {

						progressDialog.dismiss();

					}

				}

			});

支付参数说明：

PayType: 支付的支付方式，目前支持：

• 1、PayAgent.PayType.WECHATPAY（微信支付）；
• 2、PayAgent.PayType.ALIPAY（支付宝）；
• 3、PayAgent.PayType.UPPAY（银联）。

Activity: 调起支付的 Activity

PayInfo：

/** 商品名称*/

private String subject;



/** 商品详细信息  商品的标题/交易标题/订单标题/订单关键字等。该参数最长为128个汉字*/

private String body;



/** 商品价格*/

private String price;



/** 商品订单号*/

private String orderNo;



/** 支付通知地址*/

private String notifyUrl;

OnPayListener： 支付监听器：

• onStartPay() 开始支付，可以在此做 支付前准备提示
• onPaySuccess(); 支付成功
• onPayFail(String code, String msg); 支付失败，code和msg 均为第三方原样返回

配置第三方参数说明：

• 1、支付宝：

注意：

• 1、支付宝支付，调用支付宝时， 所有参数为必须向
• 2、微信支付，orderNo 为必须项
• 3、银联支付时，orderNo 为必须项 -4、关于支付后，通知回调，只有支付宝是 在客户端手动设置，其余都是在 后台配置。

注意事项：

• 1、当测试时，可以使用Debug模式，开启方式为： PayAgent payAgent = PayAgent.getInstance(); payAgent.setDebug(true);

• 2、调试模式(非正式环境，目前只有 银联)： PayAgent payAgent = PayAgent.getInstance(); payAgent.setOnlieMode(false);

版本說明：

• 1、银联支付：3.3.2
• 2、支付宝：
• 3、微信：

更新日志：

• 2016.04.15更新：

• 1、2016.4.14 银联更新sdk，更新银联支付控件为3.3.3

• 2、去除银联客户端验签；添加银联需要权限（nfc等）

• 1、更新银联支付控件为3.3.2

• 2、添加调试模式（非正式环境模式、主要正对银联支付）

payAgent.setOnlieMode(false);

• 3、添加银联 验证签名，初始化签名参数
• 4、修改Demo ，测试 Demo能正常运行。

其他说明：

• 银联支付平台官网：https://open.unionpay.com/ajweb/product/detail?id=3
• 支付宝平台官网：https://doc.open.alipay.com/doc2/detail?treeId=54&articleId=103419&docType=1
• 微信支付平台官网：https://open.weixin.qq.com/cgi-bin/showdocument?action=dir_list&t=resource/res_list&verify=1&id=open1419317784&token=&lang=zh_CN
• https://pay.weixin.qq.com/wiki/doc/api/app.php?chapter=11_1

CocoaLumberjack

CocoaLumberjack是适用于 macOS、iOS、tvOS 和 watchOS 的快速简单但功能强大且灵活的日志记录框架。

首先，通过CocoaPods、Carthage、Swift Package Manager或手动安装 CocoaLumberjack 。然后使用DDOSLoggeriOS 10 及更高版本，或DDTTYLogger和DDASLLogger早期版本开始记录消息。

CocoaPods

platform :ios, '9.0'



target 'SampleTarget' do

  use_frameworks!

  pod 'CocoaLumberjack/Swift'

end

platform :ios, '9.0'



target 'SampleTarget' do

    pod 'CocoaLumberjack'

end

Carthage

github "CocoaLumberjack/CocoaLumberjack"

用法

[DDLog addLogger: [DDOSLogger sharedInstance ]]; //使用 os_log



DDFileLogger *fileLogger = [[DDFileLogger alloc ] init ]; //文件记录器

fileLogger.rollingFrequency = 60 * 60 * 24 ; // 24 小时滚动

fileLogger.logFileManager.maximumNumberOfLogFiles = 7 ;

[DDLog addLogger: fileLogger];



...



DDLogVerbose ( @"详细" );

DDLogDebug ( @"调试" );

DDLogInfo ( @"信息" );

DDLogWarn ( @"警告" );

DDLogError ( @"错误" );

Objective-C ARC 语义问题

将 Lumberjack 集成到现有的 Objective-C 中时，可能会遇到Multiple methods named 'tag' found with mismatched result, parameter type or attributes构建错误。

#define DD_LEGACY_MESSAGE_TAG 0在导入 CocoaLumberjack 之前添加或添加#define DD_LEGACY_MESSAGE_TAG 0或添加-DDD_LEGACY_MESSAGE_TAG=0到Xcode 项目中的其他 C 标志/ OTHER_CFLAGS。

快速日志后端

CocoaLumberjack 还附带了swift-log的后端实现。只需将 CocoaLumberjack 作为依赖项添加到您的 SPM 目标（见上文），并将CocoaLumberjackSwiftLogBackend产品作为依赖项添加到您的目标。

然后，您可以将DDLogHandler其用作 swift-log 的后端，它将所有消息转发到 CocoaLumberjack 的DDLog. 您仍将通过 配置您想要的记录器和日志格式化程序DDLog，但将使用Loggerswift-log完成写入日志消息。

在您自己的日志格式化程序中，您可以使用swiftLogInfoon 属性DDLogMessage来检索通过 swift-log 记录的消息的详细信息。

在大多数情况下，它比 NSLog 快一个数量级。

当您的应用程序启动时，只需一行代码即可配置 lumberjack。然后只需将您的 NSLog 语句替换为 DDLog 语句即可。（而且 DDLog 宏的格式和语法与 NSLog 完全相同，因此非常简单。）

一个日志语句可以发送到多个记录器，这意味着您可以同时记录到一个文件和控制台。想要更多？创建您自己的记录器（这很容易）并通过网络发送您的日志语句。或者到数据库或分布式文件系统。天空才是极限。

根据需要配置您的日志记录。更改每个文件的日志级别（非常适合调试）。更改每个记录器的日志级别（详细控制台，但简洁的日志文件）。更改每个 xcode 配置的日志级别（详细调试，但简洁发布）。将您的日志语句从发布版本中编译出来。为您的应用程序自定义日志级别的数量。添加您自己的细粒度日志记录。在运行时动态更改日志级别。选择您希望日志文件滚动的方式和时间。将您的日志文件上传到中央服务器。压缩归档日志文件以节省磁盘空间...

在以下情况下，此框架适合您：

Shimmer

Shimmer 是一种向应用程序中的任何视图添加闪烁效果的简单方法。它作为一个不显眼的加载指示器很有用。

Shimmer 最初是为了在Paper 中显示加载状态而开发的。

用法

要使用 Shimmer，请创建一个FBShimmeringView或FBShimmeringLayer并添加您的内容。要开始闪烁，请将shimmering属性设置为YES。

使标签闪烁的示例：

FBShimmeringView *shimmeringView = [[FBShimmeringView alloc ] initWithFrame: self .view.bounds];

[ self .view addSubview: shimmeringView];



UILabel *loadingLabel = [[UILabel alloc ] initWithFrame: shimmeringView.bounds];

loadingLabel.textAlignment = NSTextAlignmentCenter;

loadingLabel.text = NSLocalizedString( @" Shimmer " , nil );

shimmeringView.contentView = loadingLabel;



//开始闪烁。

shimmeringView.shimmering = YES ;

还有一个示例项目。在示例中，您可以水平和垂直滑动以尝试各种闪烁参数，或点击以开始或停止闪烁。（要在本地构建示例，您需要打开FBShimmering.xcworkpace而不是.xcodeproj.）

安装

有两种选择：

1. 微光Shimmer在Cocoapods 中可用。
2. 手动将文件添加到您的 Xcode 项目中。稍微简单一点，但更新也是手动的。

Shimmer 需要 iOS 6 或更高版本。

这个怎么运作

Shimmer 使用该-[CALayer mask]属性来启用闪烁，类似于 John Harper 2009 年 WWDC 演讲中所描述的内容（不幸的是不再在线）。Shimmer 使用 CoreAnimation 的计时功能在启动和停止微光时平滑过渡“节拍”。

demo及常见问题:https://github.com/facebookarchive/Shimmer

源码下载:Shimmer-master.zip

// 加载一个基本的url（利用了扩展函数，对target无任何侵入）

imageView.load("https://www.website.com/image.jpg")



// Coil 支持加载 urls, uris, resources, drawables, bitmaps, files 等等

imageView.load(R.drawable.image)

imageView.load(File("/path/to/image.jpg"))

imageView.load(Uri.parse("content://com.android.externalstorage/image.jpg"))



// Requests的配置项可以通过load的lambda参数方式实现

imageView.load("https://www.website.com/image.jpg") {

    crossfade(true)

    placeholder(R.drawable.image)

    transformations(CircleCropTransformation())

}



// 自定义targets，包含开始、成功和失败的回调 

Coil.load(context, "https://www.website.com/image.jpg") {

    target { drawable ->

        // Handle the successful result.

    }

}



// 通过使用挂起函数get来直接获取图片对象

val drawable = Coil.get("https://www.website.com/image.jpg")

下载地址：main.zip

FastImageCache

快速图像缓存是一种在 iOS 应用程序中存储和检索图像的高效、持久且最重要的快速方式。任何良好的 iOS 应用程序的用户体验的一部分是快速、平滑的滚动，而快速图像缓存有助于使这变得更容易。

对于像Path这样的图形丰富的应用程序，性能的一个重大负担是图像加载。从磁盘加载单个图像的传统方法太慢了，尤其是在滚动时。Fast Image Cache 就是专门为解决这个问题而创建的。

快速图像缓存的作用

• 将相似大小和样式的图像存储在一起
• 将图像数据保存到磁盘
• 比传统方法更快地将图像返回给用户
• 根据使用情况自动管理缓存过期
• 利用基于模型的方法来存储和检索图像
• 允许在将图像存储到缓存之前按模型处理图像

事实证明，从压缩的磁盘图像数据到用户可以实际看到的渲染核心动画层的过程非常昂贵。随着要显示的图像数量的增加，这种成本很容易导致帧速率显着下降。可滚动视图进一步加剧了这种情况，因为内容可以快速变化，需要快速处理时间才能保持 60FPS 的流畅。¹

考虑从磁盘加载图像并将其显示在屏幕上时发生的工作流程：

1. +[UIImage imageWithContentsOfFile:]使用Image I/OCGImageRef从内存映射数据创建一个。此时，图像还没有被解码。
2. 返回的图像被分配给一个UIImageView.
3. 隐式CATransaction捕获这些层树修改。
4. 在主运行循环的下一次迭代中，Core Animation 提交隐式事务，这可能涉及创建已设置为图层内容的任何图像的副本。根据图像，复制它涉及以下部分或全部步骤：²
   1. 缓冲区被分配用于管理文件 IO 和解压操作。
   2. 文件数据从磁盘读取到内存中。
   3. 压缩的图像数据被解码为其未压缩的位图形式，这通常是一个非常占用 CPU 的操作。³
   4. 然后 Core Animation 使用未压缩的位图数据来渲染图层。

这些成本很容易累积并扼杀感知的应用程序性能。特别是在滚动时，给用户呈现的用户体验不尽如人意，与 iOS 的整体体验不符。

解决方案

快速图像缓存使用各种技术最大限度地减少（或完全避免）上述大部分工作：

映射内存

快速图像缓存工作原理的核心是图像表。图像表类似于精灵表，通常用于 2D 游戏。图像表将相同尺寸的图像打包到一个文件中。该文件只打开一次，只要应用程序保留在内存中，就保持打开状态以供读取和写入。

图像表使用mmap系统调用将文件数据直接映射到内存中。没有memcpy发生。这个系统调用只是在磁盘上的数据和内存区域之间创建一个映射。

当请求图像缓存返回特定图像时，图像表（以恒定时间）在它维护的文件中找到所需图像数据的位置。该文件数据区域被映射到内存中，并创建一个新CGImageRef的后备存储是映射的文件数据。

当返回的CGImageRef（包装成 a UIImage）准备好被绘制到屏幕上时，iOS 的虚拟内存系统页面中的实际文件数据。这是使用映射内存的另一个好处；VM 系统会自动为我们处理内存管理。此外，映射内存“不计入”应用程序的实际内存使用量。

以类似的方式，当图像数据被存储在图像表中时，会创建一个内存映射位图上下文。与原始图像一起，此上下文被传递到图像表的相应实体对象。该对象负责将图像绘制到当前上下文中，可选地进一步配置上下文（例如，将上下文裁剪为圆角矩形）或进行任何额外的绘制（例如，在原始图像上绘制叠加图像）。mmap将绘制的图像数据编组到磁盘，因此不会在内存中分配图像缓冲区。

未压缩的图像数据

为了避免昂贵的图像解压缩操作，图像表将未压缩的图像数据存储在它们的文件中。如果源图像被压缩，则必须首先解压缩图像表才能使用它。这是一次性成本。此外，可以利用图像格式系列为一组相似的图像格式只执行一次这种解压缩。

然而，这种方法有明显的后果。未压缩的图像数据需要更多的磁盘空间，压缩和未压缩文件大小之间的差异可能很大，尤其是对于 JPEG 等图像格式。出于这个原因，快速图像缓存最适用于较小的图像，尽管没有强制执行此操作的 API 限制。

字节对齐

对于高性能滚动，Core Animation 能够使用图像而无需首先创建副本是至关重要的。Core Animation 创建图像副本的原因之一是图像底层CGImageRef. 正确对齐的每行字节值必须是 的倍数8 pixels × bytes per pixel。对于典型的 ARGB 图像，对齐的每行字节值是 64 的倍数。每个图像表都配置为从一开始就为 Core Animation 始终正确地对每个图像进行字节对齐。因此，当从图像表中检索图像时，它们已经处于 Core Animation 可以直接使用的形式，而无需创建副本。

为了便于项目集成，Fast Image Cache 可作为CocoaPod 使用。

手动

• 克隆这个存储库，或者下载最新的master.
• 从FastImageCache根目录，将源文件从内部FastImageCache子目录复制到您的 Xcode 项目。
• FICImageCache.h在您使用图像缓存的任何地方导入。
• 导入FICEntity.h每个类符合FICEntity。

静态 NSString *XXImageFormatNameUserThumbnailSmall = @" com.mycompany.myapp.XXImageFormatNameUserThumbnailSmall " ;

静态 NSString *XXImageFormatNameUserThumbnailMedium = @" com.mycompany.myapp.XXImageFormatNameUserThumbnailMedium " ;

静态 NSString *XXImageFormatFamilyUserThumbnails = @" com.mycompany.myapp.XXImageFormatFamilyUserThumbnails " ;



FICImageFormat *smallUserThumbnailImageFormat = [[FICImageFormat alloc ] init ];

smallUserThumbnailImageFormat.name = XXImageFormatNameUserThumbnailSmall;

smallUserThumbnailImageFormat.family = XXImageFormatFamilyUserThumbnails;

smallUserThumbnailImageFormat.style = FICImageFormatStyle16BitBGR;

smallUserThumbnailImageFormat.imageSize = CGSizeMake( 50 , 50 );

smallUserThumbnailImageFormat.maximumCount = 250 ;

smallUserThumbnailImageFormat.devices = FICImageFormatDevicePhone;

smallUserThumbnailImageFormat.protectionMode = FICImageFormatProtectionModeNone;



FICImageFormat *mediumUserThumbnailImageFormat = [[FICImageFormat alloc ] init ];

mediumUserThumbnailImageFormat.name = XXImageFormatNameUserThumbnailMedium;

mediumUserThumbnailImageFormat.family = XXImageFormatFamilyUserThumbnails;

mediumUserThumbnailImageFormat.style = FICImageFormatStyle32BitBGRA;

mediumUserThumbnailImageFormat.imageSize = CGSizeMake( 100 , 100 );

mediumUserThumbnailImageFormat.maximumCount = 250 ;

mediumUserThumbnailImageFormat.devices = FICImageFormatDevicePhone;

mediumUserThumbnailImageFormat.protectionMode = FICImageFormatProtectionModeNone;



NSArray *imageFormats = @[smallUserThumbnailImageFormat, mediumUserThumbnailImageFormat];

配置图像缓存

一旦定义了一种或多种图像格式，就需要将它们分配给图像缓存。除了分配图像缓存的委托之外，没有其他可以在图像缓存本身上配置的内容。

FICImageCache *sharedImageCache = [FICImageCache sharedImageCache ];

sharedImageCache.delegate = self;

sharedImageCache.formats = imageFormats;

实体是符合FICEntity协议的对象。实体唯一标识图像表中的条目，并且它们还负责绘制它们希望存储在图像缓存中的图像。已经定义了模型对象（可能由 Core Data 管理）的应用程序通常是合适的候选实体。

@interface  XXUser : NSObject 



@property ( nonatomic , assign , getter = isActive) BOOL active;

@property ( nonatomic , copy ) NSString *userID;

@属性（非原子，副本）NSURL * userPhotoURL;



@结尾

这是该FICEntity协议的示例实现。

- ( NSString *)UUID {

     CFUUIDBytes UUIDBytes = FICUUIDBytesFromMD5HashOfString (_userID);

    NSString *UUID = FICStringWithUUIDBytes (UUIDBytes);



    返回UUID；

}



- ( NSString *)sourceImageUUID {

     CFUUIDBytes sourceImageUUIDBytes = FICUUIDBytesFromMD5HashOfString ([_userPhotoURL absoluteString ]);

    NSString *sourceImageUUID = FICStringWithUUIDBytes (sourceImageUUIDBytes);



    返回sourceImageUUID;

}



- ( NSURL *)sourceImageURLWithFormatName:( NSString *)formatName {

     return _sourceImageURL;

}



- (FICEntityImageDrawingBlock)drawingBlockForImage:(UIImage *)image withFormatName:( NSString *)formatName {

    FICEntityImageDrawingBlockdrawingBlock = ^( CGContextRef context, CGSize contextSize) {

         CGRect contextBounds = CGRectZero ;

        上下文边界。大小= 上下文大小；

        CGContextClearRect（上下文，contextBounds）；



        //剪辑中等缩略图，使它们具有圆角

        if ([formatName isEqualToString: XXImageFormatNameUserThumbnailMedium]) {

            UIBezierPath clippingPath = [ self  _clippingPath ];

            [剪辑路径添加剪辑];

        }

        

        UIGraphicsPushContext（上下文）；

        [图像drawInRect： contextBounds];

        UIGraphicsPopContext ();

    };

    

    返回绘图块；

}

理想情况下，实体的UUID永远不应该改变。这就是为什么在应用程序使用从 API 检索的资源的情况下，它与模型对象的服务器生成的 ID 很好地对应。

一个实体的可以改变。例如，如果用户更新了他们的个人资料照片，则该照片的 URL 也应更改。将保持不变，标识相同的用户，但改变了个人资料照片网址将表明，有一个新的源图像。sourceImageUUID UUID

注意：通常，最好对用于定义UUID和 的任何标识符进行哈希处理sourceImageUUID。Fast Image Cache 提供了实用功能来执行此操作。由于散列可能很昂贵，因此建议仅计算一次散列（或仅在标识符更改时）并存储在实例变量中。

当要求图像缓存为特定实体和格式名称提供图像时，该实体负责提供 URL。URL 甚至不需要指向实际资源——例如，URL 可能由自定义 URL 方案构成——但它必须是一个有效的 URL。

图像缓存仅使用这些 URL 来跟踪哪些图像请求已经在进行中；正确处理对同一图像的图像缓存的多个请求，而不会浪费任何精力。选择使用 URL 作为键控图像缓存请求的基础实际上补充了许多实际应用程序设计，其中图像资源（而不是图像本身）的 URL 包含在服务器提供的模型数据中。

注意：快速图像缓存不提供任何网络请求机制。这是图像缓存委托的责任。

最后，一旦源图像可用，实体就会被要求提供一个绘图块。将存储最终图像的图像表设置文件映射位图上下文并调用实体的绘图块。这使得每个实体可以方便地决定如何处理特定图像格式的源图像。

从图像缓存中请求图像

快速图像缓存在 Cocoa 常见的按需、延迟加载设计模式下工作。

XXUser *user = [self _currentUser];
NSString *formatName = XXImageFormatNameUserThumbnailSmall;
FICImageCacheCompletionBlock completionBlock = ^(id <FICEntity> entity, NSString *formatName, UIImage *image) {
    _imageView.image = image;
    [_imageView.layer addAnimation:[CATransition animation] forKey:kCATransition];
};

BOOL imageExists = [sharedImageCache retrieveImageForEntity:user withFormatName:formatName completionBlock:completionBlock];
    
if (imageExists == NO) {
    _imageView.image = [self _userPlaceholderImage];
}

统计数据

以下统计数据是从演示应用程序的运行中测得的：

demo下载及常见问题:https://github.com/path/FastImageCache

源码下载:FastImageCache-master.zip

美丽流畅的自定义加载视图

使用

<com.tuyenmonkey.mkloader.MKLoader

          android:layout_width="wrap_content"

          android:layout_height="wrap_content"

          app:mk_type="<loading_type>" (Optional. Default is ClassicSpinner)

          app:mk_color="<color>" (Optional. Default is #ffffff)

      />

类型

• Sharingan
• TwinFishesSpinner
• ClassicSpinner
• LineSpinner
• FishSpinner
• PhoneWave
• ThreePulse
• FourPulse
• FivePulse
• Worm
• Whirlpool
• Radar

安装

Gradle

dependencies {

  compile 'com.tuyenmonkey:mkloader:1.4.0'

}

github地址：https://github.com/nntuyen/mkloader

下载地址：master.zip

为什么要给程序瘦身？

随着应用程序的功能越来越多，实现越来越复杂，第三方库的引入，UI体验的优化等众多因素程序中的代码量成倍的增长，从而导致应用程序包的体积越来越大。当程序体积变大后不仅会出现编译流程变慢，而且还会出现运行性能问题，会增加应用下载时长和消耗用户的移动网络流量等等。因此在这些众多的问题下需要对应用进行瘦身处理。

一个应用程序由众多资源文件和可执行程序文件组成，资源文件的优化不在本文探讨范围。本文主要讨论对可执行程序代码瘦身的方法。

对可执行程序代码瘦身主要就是想办法让程序中不会被调用的源代码不参与编译或链接。我们可以通过一些源代码分析工具来查找哪些函数或者类方法没有被调用并从代码中删除掉来解决编译链接前的瘦身问题。这些分析工具也不在本文的讨论范围内。应用程序在编译时会对工程中的所有代码都执行编译处理并生成目标文件。而在链接阶段则会根据程序代码中对符号的引用关系来将所有相关的目标文件链接为一个大的可执行程序文件，并且在链接阶段链接器会优化掉所有没被调用的C/C++函数代码，但是对于OC类中的没有调用的方法则不会被优化掉。所以为了对可执行程序在编译链接阶段进行瘦身处理就需要了解源代码的编译链接规则。这也是本文所要介绍的针对工程通过静态库的形式进行编译和链接的方式来减少可执行程序代码的尺寸。您可以从文章：《深入iOS系统底层之静态库介绍》中详细的了解到静态库的编译链接过程，以及相关的技术细节。

一个瘦身的例子！

为了验证和具体的实践，我在github上建立了一个项目：YSAppSizeTest。您可以从这个项目中看到如何对工程进行构建以实现程序的瘦身处理。

在示例项目中同一个Workspace中分别建立ThinApp和FatApp两个工程，这两个工程实现的功能是一样。在整个应用程序中分别定义了CA、CB、CC、CD、CE一共5个OC类，定义了一个UIView(Test)分类，还有定义了两个C函数：libFoo1和libFoo1。

整个应用程序中只使用了CA和CC两个OC类，以及调用了UIView(Test)分类方法，以及调用了libFoo1函数，并且同时都采用导入静态库的形式。因为这两个工程对文件的定义和分布策略不同使得两个应用程序的最终可执行代码的尺寸是不相同的。

FatApp中的文件定义和分布策略

1、FatApp工程依赖并导入了FatAppLib静态库工程。
2、CA,CB两个类都定义在主程序工程中。
3、CC,CD,CE三个类，以及UIView(Test)分类，还有libFoo1,libFoo2两个函数都定义在FatAppLib静态库工程中。
4、CC,CD两个类定义在同一个文件中，CE类则定义在单独的文件中。
5、FatApp工程的Other Linker Flags中设置了 -ObjC选项。

ThinApp中的文件定义和分布策略

1、ThinApp工程依赖并导入了ThinAppLib静态库工程。
2、主程序工程就是一个壳工程。
3、CA,CB,CC,CD,CE5个类，以及UIView(Test)分类，还有libFoo1,libFoo2两个函数都定义在ThinAppLib静态库工程中。
4、上述的5个类都分别定义在不同的文件中。
5、ThinApp工程的Other Linker Flags中没有设置-ObjC选项。

上述两个工程的程序被Archive出来后，FatApp可执行程序的尺寸是367KB，而ThinApp可执行程序的尺寸是334KB。通过一些工具比如Mach-O View或者 IDA可以看出：FatApp中5个OC类的代码以及libFoo1函数还有UIView(Test)分类的代码都被链接进可执行程序中；而ThinApp中则只有CA,CC两个类以及libFoo1函数还有UIView(Test)分类的代码被链接进可执行程序中。在ThinApp中虽然没有使用-Objc链接选项，但是静态库中的分类也被链接进可执行程序中。

应用程序工程构建规则

根据对项目中的文件定义和引用策略以及相关的理论基础我们可以按照如下的规则来构建您的应用程序：

1、尽量将所有代码都移植到静态库中，而主程序则保留为一个壳程序。具体操作方法是建立一个Workspace，然后主程序工程就只有默认创建工程时的代码，所有新加入的代码都建立并存放到静态库工程中去，然后通过工程依赖来引入这些静态库工程，或者借助一些工程化工具比如Cocoapods来实现这种拆分和引用处理。主程序工程中只保留AppDelegate的代码，其他代码都一致到静态库中。然后在AppDelegate中的相关代码处调用静态库中定义的业务代码。

2、按业务组件对工程进行解耦每个组件是一个静态库工程。静态库中的每一个文件中最好只有一个类的实现，并且类的分类实现最好和类实现编写在同一个文件中，相同功能的代码以及可能都会被调用的代码尽量存放在一个文件中。

3、不要在主程序工程中使用-ObjC和-all_load两个选项而改为用-force_load 来单独指定要执行加载的静态库。-ObjC和-all_load选项会把主程序工程以及所依赖的所有静态库中的工程中的全部代码都链接到可执行程序中而不管代码是否有被调用过或者使用过。而force_load则只会将指定的静态库中的所有代码链接到可执行程序中，当然force_load如果没有必要也尽量不要使用。

4、尽量减少在静态库中定义OC类的分类方法，如果一定要定义分类方法则可以将分类方法定义在和类定义相同的文件中，或者将分类方法定义在一个一定会被调用和引用的实现文件中。因为根据链接规则静态库中的分类是不会被链接进可执行程序中的，除非使用了上述的三个链接选项。如果将分类代码单独的定义在一个文件中的话则可以通过在分类的头文件中定义一个内联函数，内联函数调用分类实现文件中的一个dumy函数,这样只要这个分类的头文件被include或者import就会把整个分类的实现链接到可执行程序中去。一般情况下我们在静态库中建立分类那就表明一定会被某个文件引用这个分类，从而实现整个文件的链接处理。在分类中定义的这两个函数则因为没有被任何地方调用，因此会在链接优化中将这两个函数给优化掉。这样就使得即使我们不用-ObjC选项也能将静态库中的分类链接到可执行程序中去。最后需要注意的是在每个分类中定义的这两个函数名最好能够唯一这样就不会出现符号重名冲突的问题了。

//分类文件的头文件UIView+XXX.h
@interface UIView (XXX)

//分类中定义的方法

@end

/*
  通过在分类的头文件中定义一个内联函数，内联函数调用分类实现文件中的一个dumy函数,这样只要这个分类的头文件被include或者import就会把
  整个分类的实现链接到可执行程序中去。一般情况下我们在静态库中建立分类那就表明一定会被某个文件引用这个分类，从而实现整个文件的链接处理。
  而在分类中定义的这两个函数则因为没有被任何地方调用，因此会在链接优化中将这两个函数给优化掉。这样就使得即使我们不用-ObjC选项也能
  将静态库中的分类链接到可执行程序中去。最后需要注意的是在每个分类中定义的这两个函数名最好能够唯一这样就不会出现符号重名冲突的问题了。
 */
extern void _cat_UIView_XXX_Impl(void);
inline void _cat_UIView_XXX_Decl(void){_cat_UIView_XXX_Impl();}


------------------------------------------------------------
//分类文件的实现文件UIView+XXX.m
#import "UIView+XXX.h"

@implementation UIView (XXX)

//分类的实现代码

@end

void _cat_UIView_XXX_Impl(void){}


---------------------------------------------------------------
//最后把这个分类头文件放入到某个对外暴露的头文件中，比如本例中将分类代码放入到了ThinAppLib.h文件中
//ThinAppLib.h

#import "UIView+XXX.h"
//其他头文件

5、除了可以通过-force_load来加载指定静态库中的所有代码外。我们还可以在构建静态库时，在静态库的工程的Build Settings中将Perform Single-Object Prelink 中的开关选项打开。当这个开关打开时，系统会对生成的静态库的所有目标文件执行预链接操作，预链接操作会将所有的目标文件组合成为一个单独的大的目标文件。这样根据以文件为单位的链接规则就会将静态库中的所有代码全部都链接进可执行程序中去，但是这样带来的问题就是最后在dead code stripping时删除不掉已经链接进来的那些没有被任何地方使用过的OC类了。

6、对于引入的一些第三方静态库或者第三方的开源库来说因为我们无法去改变其实现逻辑。如果这个静态库中没有任何分类代码的定义则正常引用即可，如果静态库中有分类方法的定义则单独对这个静态库采用-force_load选项。

总之一句话：为了让你的程序瘦身，尽量将代码放到静态库中，不要使用-Objc和-all_load选项

为了验证上述方法的有效性，笔者对项目中的应用做了一个测试：分别是有带-ObjC选项和没有带-ObjC选项的情况下的应用程序包中可执行程序的大小从115M减少到95M，减少了20M的尺寸。

链接：https://www.jianshu.com/p/2078e00891fd

ChatKit 开源且提供完全自由的授权协议，开发者可以对其进行任意修改、扩展和二次封装，但是 LeanCloud 并不对 ChatKit 的二次开发提供技术支持。

获取项目

git clone git@github.com:leancloud/LeanCloudChatKit-Android.git

运行 Demo

获取源代码之后，用 Android Studio 打开项目，左侧的 Project 视图显示为：

「ChatKit-Android」Project 包含两个模块：

• leancloudchatkit
  
  是一个封装了 LeanCloud 即时通讯的 UI lib，其目的是让开发者更快速地接入 LeanCloud 即时通讯的功能。


• chatkitapplication
  
  为 Demo 项目，它是一个简单的示例项目，用来指导开发者如何使用 leancloudchatkit。

然后，请确保电脑上已经连接了一台真机或者虚拟机用作调试。

点击 Debug 或者 Run，第一次启动会运行 Gradle Build。建议打开全局网络代理，否则 Gradle Build 可能会因为网络原因无法完成。

使用方法

开发者可以将 ChatKit 导入到自己的 Project 中使用。下面我们将新建一个 Project（名为 ChatDemo） 用以导入 ChatKit。导入方式推荐通过源代码导入。

源代码导入

1. 浏览器访问 https://github.com/leancloud/LeanCloudChatKit-Android；


2. 执行以下命令行，将项目 clone 到本地（如 ChatKit 文件夹中，或者直接下载 zip 包自行解压缩到此文件夹下）：

   git clone https://github.com/leancloud/LeanCloudChatKit-Android.git`
   

   
   


3. 将文件夹 leancloudchatkit 复制到 ChatDemo 根目录；


4. 修改 ChatDemo/settings.gradle 加入 include ':leancloudchatkit'；


5. 修改 ChatDemo/app/build.gradle，在 dependencies 中添加 compile project(":leancloudchatkit")。

最后只要 Sync Project，这样 ChatKit 就算是导入到项目中了。

自定义使用

一、实现自己的 Application

ChatKit 在使用之前需要进行初始化，就像直接使用 LeanCloud 基础 SDK 时需要调用 AVOSCloud.initialize(appId, appKey) 一样。初始化逻辑应该放在 Application.onCreate 方法中实现。

ChatDemo 中新建一个 Class，名字叫做 ChatDemoApplication，让它继承自 Application 类，代码如下：

public class ChatDemoApplication extends Application {



// appId、appKey 可以在「LeanCloud  控制台 > 设置 > 应用 Key」获取

  private final String APP_ID = "********";

  private final String APP_KEY = "********";



  @Override

  public void onCreate() {

    super.onCreate();

    // 关于 CustomUserProvider 可以参看后面的文档

    LCChatKit.getInstance().setProfileProvider(CustomUserProvider.getInstance());

    LCChatKit.getInstance().init(getApplicationContext(), APP_ID, APP_KEY);

  }

}

二、在 AndroidMainfest.xml 中配置 ChatDemoApplication

<application

  ...

  android:name=".ChatDemoApplication" >

  ...

</application>

三、实现自己的用户体系

一般来说，聊天界面要相对复杂一些，不但要支持文字、表情、图片、语音等消息格式，还要展示用户信息，比如用户的头像、昵称等。而 LeanCloud 的消息流中只包含用户的 clientId 这一唯一标识，所以要获取头像这类额外的用户信息，就需要开发者接入自己的用户系统来实现。

为了保证通用性和扩展性，让开发者可以更容易将聊天界面嵌入自己的应用中，ChatKit 在设计上抽象出了一个「用户体系」的接口，需要开发者自己提供用户信息的获取方式。该接口只有一个方法需要开发者实现：

/**

 * 用户体系的接口，开发者需要实现此接口来接入 LCChatKit

 */

public interface LCChatProfileProvider {

  // 根据传入的 clientId list，查找、返回用户的 Profile 信息(id、昵称、头像)

  public void fetchProfiles(List<String> userIdList, LCChatProfilesCallBack profilesCallBack);

}

为此，我们在 ChatDemo 中新建一个 Class，名字叫做 CustomUserProvider，代码如下：

public class CustomUserProvider implements LCChatProfileProvider {



  private static CustomUserProvider customUserProvider;



  public synchronized static CustomUserProvider getInstance() {

    if (null == customUserProvider) {

      customUserProvider = new CustomUserProvider();

    }

    return customUserProvider;

  }



  private CustomUserProvider() {

  }



  private static List<LCChatKitUser> partUsers = new ArrayList<LCChatKitUser>();



  // 此数据均为模拟数据，仅供参考

  static {

    partUsers.add(new LCChatKitUser("Tom", "Tom", "http://www.avatarsdb.com/avatars/tom_and_jerry2.jpg"));

    partUsers.add(new LCChatKitUser("Jerry", "Jerry", "http://www.avatarsdb.com/avatars/jerry.jpg"));

    partUsers.add(new LCChatKitUser("Harry", "Harry", "http://www.avatarsdb.com/avatars/young_harry.jpg"));

    partUsers.add(new LCChatKitUser("William", "William", "http://www.avatarsdb.com/avatars/william_shakespeare.jpg"));

    partUsers.add(new LCChatKitUser("Bob", "Bob", "http://www.avatarsdb.com/avatars/bath_bob.jpg"));

  }



  @Override

  public void fetchProfiles(List<String> list, LCChatProfilesCallBack callBack) {

    List<LCChatKitUser> userList = new ArrayList<LCChatKitUser>();

    for (String userId : list) {

      for (LCChatKitUser user : partUsers) {

        if (user.getUserId().equals(userId)) {

          userList.add(user);

          break;

        }

      }

    }

    callBack.done(userList, null);

  }



  public List<LCChatKitUser> getAllUsers() {

    return partUsers;

  }

}

当用户昵称和头像需要更新时，需要覆盖旧的 LCChatKitUser 对象并更新本地缓存：

    LCChatKitUser user = new LCChatKitUser("唯一 userId 不可变", "要变更的昵称", "要变更的 avatarURL");

    LCIMProfileCache.getInstance().cacheUser(user);

四、打开即时通讯，并且跳转到聊天页面

我们支持通过两种方式来打开聊天界面：

1. 通过指定另一个参与者的 clientId 的方式，开启一对一的聊天；
   
   此时，通过调用 intent.putExtra(LCIMConstants.PEER_ID, "peermemberId") 来传递另一参与者的 clientId。


2. 通过指定一个已经存在的 AVIMConversation id 的方式，开启单人、多人或者开放式聊天室；
   
   此时，通过调用 LCIMConstants.CONVERSATION_ID, "particularConversationId") 来传递特定对话 Id。

下面的代码展示了如何通过第一种方式来开启聊天界面：

LCChatKit.getInstance().open("Tom", new AVIMClientCallback() {

      @Override

      public void done(AVIMClient avimClient, AVIMException e) {

        if (null == e) {

          finish();

          Intent intent = new Intent(MainActivity.this, LCIMConversationActivity.class);

          intent.putExtra(LCIMConstants.PEER_ID, "Jerry");

          startActivity(intent);

        } else {

          Toast.makeText(MainActivity.this, e.toString(), Toast.LENGTH_SHORT).show();

        }

      }

    });

这样，Tom 就可以和 Jerry 愉快地聊天了。

接口以及组件

以下介绍在 ChatKit 中开发者常需要关注的业务逻辑组件（Interface）和界面组件（UI）。

用户

LCChatKitUser 是 ChatKit 封装的参与聊天的用户，它提供了如下属性：

使用这些默认的属性基本可以满足一个聊天应用的需求，同时开发者可以通过继承 LCChatKitUser 类实现更多属性。具体用法请参考 Demo 中的 MembersAdapter.java。

用户信息管理类

LCChatProfileProvider 接口需要用户 implements 后实现 fetchProfiles 函数，以使 ChatKit 在需要显示的时候展示用户相关的信息。

例如 Demo 中的 CustomUserProvider 这个类，它实现了 LCChatProfileProvider 接口，在 fetchProfiles 方法里加载了 Tom、Jerry 等人的信息。

核心类

LCChatKit 是 ChatKit 的核心类，具体逻辑可以参看代码，注意以下几个主要函数：

public void init(Context context, String appId, String appKey)

此函数用于初始化 ChatKit 的相关设置，此函数要在 Application 的 onCreate 中调用，否则可能会引起异常。

public void setProfileProvider(LCChatProfileProvider profileProvider)

此函数用于设置用户体系，因为 LeanCloud 即时通讯功能已经实现了完全剥离用户体系的功能，这里接入已有的用户体系会很方便。

public void open(final String userId, final AVIMClientCallback callback)

此函数用于开始即时通讯，open 成功后可以执行自己的逻辑，或者跳转到聊天页面。

对话列表界面

对话 AVIMConversation 是 LeanMessage 封装的用来管理对话中的成员以及发送消息的载体，不论是群聊还是单聊都是在一个对话当中；而对话列表可以作为聊天应用默认的首页显示出来，主流的社交聊天软件，例如微信，就是把最近的对话列表作为登录后的首页。

因此，我们也提供了对话列表 LCIMConversationListFragment 页面供开发者使用，在 Demo 项目中的 MainActivity 中的 initTabLayout 方法中演示了如何引入对话列表页面：

  private void initTabLayout() {

    String[] tabList = new String[]{"会话", "联系人"};

    final Fragment[] fragmentList = new Fragment[] {new LCIMConversationListFragment(),

            new ContactFragment()};

    // 以上这段代码为新建了一个 Fragment 数组，并且把 LCIMConversationListFragment 作为默认显示的第一个 Tab 页面



    tabLayout.setTabMode(TabLayout.MODE_FIXED);

    for (int i = 0; i < tabList.length; i++) {

      tabLayout.addTab(tabLayout.newTab().setText(tabList[i]));

    }

    ...

}

具体的显示效果如下：

聊天界面

聊天界面是显示频率最高的前端页面，ChatKit 通过 LCIMConversationFragment 和 LCIMConversationActivity 来实现这一界面。在 Demo 的 ContactItemHolder 界面包含了使用 LCIMConversationActivity 的实例：

  public void initView() {

    nameView = (TextView)itemView.findViewById(R.id.tv_friend_name);

    avatarView = (ImageView)itemView.findViewById(R.id.img_friend_avatar);



    itemView.setOnClickListener(new View.OnClickListener() {

      @Override

      public void onClick(View v) {

        // 点击联系人，直接跳转进入聊天界面 

        Intent intent = new Intent(getContext(), LCIMConversationActivity.class);

        // 传入对方的 Id 即可

        intent.putExtra(LCIMConstants.PEER_ID, lcChatKitUser.getUserId());

        getContext().startActivity(intent);

      }

    });

  }

具体的显示效果如下：

联系人列表页面

因为 ChatKit 是与应用的用户体系完全解耦的，所以 ChatKit 中并没有包含联系人列表页面，但部分开发者可能有此需求，所以 chatkitapplication 实现了一个基于 LCChatProfileProvider 的联系人列表页面，具体代码可以参考 ContactFragment.java，
具体效果如下：

常见问题

ChatKit 组件收费么？

ChatKit 是完全开源并且免费给开发者使用，使用聊天所产生的费用以账单为准。

接入 ChatKit 有什么好处？

它可以减轻应用或者新功能研发初期的调研成本，直接引入使用即可。ChatKit 从底层到 UI 提供了一整套的聊天解决方案。

alerter克服了toast和snackbar的缺点，并布局很简单

生成

为了简单起见，Alerter采用了builder模式，以便于轻松集成到任何应用程序中。

可自定义的警报视图将动态添加到窗口的装饰视图中，覆盖所有内容。

安装配置

allprojects {

 repositories {

    jcenter()

    maven { url "https://jitpack.io" }

 }

}

build.gradle

dependencies {

    implementation 'com.github.tapadoo:alerter:$current-version'

}

使用

Activity -

Alerter.create(this@DemoActivity)

       .setTitle("Alert Title")

       .setText("Alert text...")

       .show()

Fragment -

Alerter.create(activity)

       .setTitle("Alert Title")

       .setText("Alert text...")

       .show()

展示 -

Alerter.isShowing()

隐藏 -

Alerter.hide()

定制

背景颜色

Alerter.create(this@DemoActivity)

       .setTitle("Alert Title")

       .setText("Alert text...")

       .setBackgroundColorRes(R.color.colorAccent) // or setBackgroundColorInt(Color.CYAN)

       .show()

图标

Alerter.create(this@DemoActivity)

       .setText("Alert text...")

       .setIcon(R.drawable.alerter_ic_mail_outline)

       .setIconColorFilter(0) // Optional - Removes white tint

       .setIconSize(R.dimen.custom_icon_size) // Optional - default is 38dp

       .show()

自定义屏幕持续时间（毫秒）

Alerter.create(this@DemoActivity)

       .setTitle("Alert Title")

       .setText("Alert text...")

       .setDuration(10000)

       .show()

无标题

Alerter.create(this@DemoActivity)

       .setText("Alert text...")

       .show()

添加 Click Listener

 Alerter.create(this@DemoActivity)

        .setTitle("Alert Title")

        .setText("Alert text...")

        .setDuration(10000)

        .setOnClickListener(View.OnClickListener {

            Toast.makeText(this@DemoActivity, "OnClick Called", Toast.LENGTH_LONG).show();

        })

        .show()

长的文本

 Alerter.create(this@DemoActivity)

        .setTitle("Alert Title")

        .setText("The alert scales to accommodate larger bodies of text. " +

                 "The alert scales to accommodate larger bodies of text. " +

                 "The alert scales to accommodate larger bodies of text.")

        .show()

自定义进入/退出动画

  Alerter.create(this@KotlinDemoActivity)

         .setTitle("Alert Title")

         .setText("Alert text...")

         .setEnterAnimation(R.anim.alerter_slide_in_from_left)

         .setExitAnimation(R.anim.alerter_slide_out_to_right)

         .show()

可见性回调

 Alerter.create(this@KotlinDemoActivity)

        .setTitle("Alert Title")

        .setText("Alert text...")

        .setDuration(10000)

        .setOnShowListener(OnShowAlertListener {

            Toast.makeText(this@KotlinDemoActivity, "Show Alert", Toast.LENGTH_LONG).show()

        })

        .setOnHideListener(OnHideAlertListener {

            Toast.makeText(this@KotlinDemoActivity, "Hide Alert", Toast.LENGTH_LONG).show()

        })

        .show()

自定义字体和文本外观

 Alerter.create(this@DemoActivity)

        .setTitle("Alert Title")

        .setTitleAppearance(R.style.AlertTextAppearance_Title)

        .setTitleTypeface(Typeface.createFromAsset(getAssets(), "Pacifico-Regular.ttf"))

        .setText("Alert text...")

        .setTextAppearance(R.style.AlertTextAppearance_Text)

        .setTextTypeface(Typeface.createFromAsset(getAssets(), "ScopeOne-Regular.ttf"))

        .show()

退出

 Alerter.create(this@DemoActivity)

        .setTitle("Alert Title")

        .setText("Alert text...")

        .enableSwipeToDismiss()

        .show()

Progress Bar

 Alerter.create(this@DemoActivity)

        .setTitle("Alert Title")

        .setText("Alert text...")

        .enableProgress(true)

        .setProgressColorRes(R.color.colorAccent)

        .show()

带按钮

 Alerter.create(this@KotlinDemoActivity)

        .setTitle(R.string.title_activity_example)

        .setText("Alert text...")

        .addButton("Okay", R.style.AlertButton, View.OnClickListener {

            Toast.makeText(this@KotlinDemoActivity, "Okay Clicked", Toast.LENGTH_LONG).show()

        })

        .addButton("No", R.style.AlertButton, View.OnClickListener {

            Toast.makeText(this@KotlinDemoActivity, "No Clicked", Toast.LENGTH_LONG).show()

        })

        .show()

自定义layout

 Alerter.create(this@KotlinDemoActivity, R.layout.custom_layout)

        .setBackgroundColorRes(R.color.colorAccent)

        .also { alerter ->

            val tvCustomView = alerter.getLayoutContainer()?.tvCustomLayout

            tvCustomView?.setText(R.string.with_custom_layout)

        }

        .show()

github地址：https://github.com/Tapadoo/Alerter
下载地址：master.zip

对于平常的应用程序开发，我们很少需要关注编译和链接过程。我们平常Xcode开发就是集成的的开发环境（IDE）,这样的IDE一般都将编译和链接的过程一步完成，通常将这种编译和链接合并在一起的过程称为构建，即使使用命令行来编译一个源代码文件,简单的一句gcc hello.c命令就包含了非常复杂的过程!

正是因为集成开发环境的强大，很多系统软件的运行机制与机理被掩盖，其程序的很多莫名其妙的错误让我们无所适从，面对程序运行时种种性能瓶颈我们束手无策。我们看到的是这些问题的现象，但是却很难看清本质，所有这些问题的本质就是软件运行背后的机理及支撑软件运行的各种平台和工具，如果能深入了解这些机制，那么解决这些问题就能够游刃有余，收放自如了。

编译流程分析
现在我们通过一个C语言的经典例子，来具体了解一下这些机制：

#include <stdio.h>
int main(){
    printf("Hello World");
    return 0;
}

在linux下只需要一个简单的命令（假设源代码文件名为hello.c）：

$ gcc hello.c
$ ./a.out
Hello World

其实上述过程可以分解为四步:

1、预处理（Prepressing）
2、编译（Compilation）
3、汇编（Assembly）
4、链接（Linking）

预编译
首先是源代码文件hello.c和相关的头文件（如stdio.h等）被预编译器cpp预编译成一个.i文件。第一步预编译的过程相当于如下命令（-E 表示只进行预编译）：

$ gcc –E hello.c –o hello.i

还可以下面的表达

$ cpp hello.c > hello.i

预编译过程主要处理源代码文件中以”#”开头的预编译指令。比如#include、#define等，主要处理规则如下：

1、将所有的#define删除，并展开所有的宏定义
2、处理所有条件预编译指令，比如#if，#ifdef，#elif，#else，#endif
3、处理#include预编译指令，将被包含的文件插入到该预编译指令的位置。
4、删除所有的注释//和/**/
5、添加行号和文件名标识，比如#2 “hello.c” 2。
6、保留所有的#pragma编译器指令
截图个大家看看效果

经过预编译后的文件（.i文件）不包含任何宏定义，因为所有的宏已经被展开，并且包含的文件也已经插入到.i文件中，所以当我们无法判断宏定义是否正确或头文件包含是否正确时，可以查看预编译后的文件来确定问题。

编译（compliation）
编译过程就是把预处理完的文件进行一系列的：词法分析、语法分析、语义分析及优化后生产相应的汇编代码文件，此过程是整个程序构建的核心部分，也是最复杂的部分之一。其编译过程相当于如下命令：

$ gcc –S hello.i –o hello.s

通过上图我们不难得出，通过命令得到汇编输出文件hello.s.

汇编（assembly）
汇编器是将汇编代码转变成机器可以执行的指令，每一个汇编语句几乎对应一条机器令。所以汇编器的汇编过程相对于编译器来讲比较简单，它没复杂的语法，也没有语义，也不需要做指令优化，只是根据汇编指令和机器指令的对照表一一翻译就可以了。其汇编过程相当于如下命令：

as hello.s –o hello.o

或者

gcc –c hello.s –o hello.o

或者使用gcc命令从C源代码文件开始，经过预编译、编译和汇编直接输出目标文件：

gcc –c hello.c –o hello.o

链接（linking）
链接通常是一个让人比较费解的过程，为什么汇编器不直接输出可执行文件而是输出一个目标文件呢？为什么要链接？下面让我们来看看怎么样调用ld才可以产生一个能够正常运行的Hello World程序：

注意默认情况没有gcc / 记得 ：
$ brew install gcc

链接相应的库

下面在贴出我们的写出的源代码是如何变成目标代码的流程图：

主要通过我们的编译器做了以下任务：扫描、语法分析、语义分析、源代码优化、代码生成和目标代码优化

到这我们就可以得到以下的文件，不知道你是否有和我一起操作，玩得感觉还是不错，继续往下面看

iOS的编译器
iOS现在为了达到更牛逼的速度和优化效果，采用了LLVM

1.LLVM核心库:
LLVM提供一个独立的链接代码优化器为许多流行CPU（以及一些不太常见的CPU）的代码生成支持。这些库是围绕一个指定良好的代码表示构建的，称为LLVM中间表示（“LLVM IR”）。LLVM还可以充当JIT编译器 - 它支持x86 / x86_64和PPC / PPC64程序集生成，并具有针对编译速度的快速代码优化。。

2.LLVM IR 生成器Clang: Clang是一个“LLVM原生”C / C ++ / Objective-C编译器，旨在提供惊人的快速编译（例如，在调试配置中编译Objective-C代码时比GCC快3倍），非常有用的错误和警告消息以及提供构建优秀源代码工具的平台。

3.LLDB项目:
LLDB项目以LLVM和Clang提供的库为基础，提供了一个出色的本机调试器。它使用Clang AST和表达式解析器，LLVM JIT，LLVM反汇编程序等，以便提供“正常工作”的体验。在加载符号时，它也比GDB快速且内存效率更高。

4.libc和libc++:
libc 和libc++ ABI项目提供了C ++标准库的标准符合性和高性能实现，包括对C ++ 11的完全支持。

5.lld项目:
lld项目旨在成为clang / llvm的内置链接器。目前，clang必须调用系统链接器来生成可执行文件。

LLVM采用三相设计，前端Clang负责解析，验证和诊断输入代码中的错误，然后将解析的代码转换为LLVM IR，后端LLVM编译把IR通过一系列改进代码的分析和优化过程提供，然后被发送到代码生成器以生成本机机器代码。

编译器前端的任务是进行：

1、语法分析
2、语义分析
3、生成中间代码(intermediate representation )

在这个过程中，会进行类型检查，如果发现错误或者警告会标注出来在哪一行。

以上图解内容所做的是事情和gcc编译一模模一样样！

iOS程序-详细编译过程
1.写入辅助文件：将项目的文件结构对应表、将要执行的脚本、项目依赖库的文件结构对应表写成文件，方便后面使用；并且创建一个 .app 包，后面编译后的文件都会被放入包中；
2.运行预设脚本：Cocoapods 会预设一些脚本，当然你也可以自己预设一些脚本来运行。这些脚本都在 Build Phases中可以看到；
3.编译文件：针对每一个文件进行编译，生成可执行文件 Mach-O，这过程 LLVM 的完整流程，前端、优化器、后端；
4.链接文件：将项目中的多个可执行文件合并成一个文件；
5.拷贝资源文件：将项目中的资源文件拷贝到目标包；
6.编译 storyboard 文件：storyboard 文件也是会被编译的；
7.链接 storyboard 文件：将编译后的 storyboard 文件链接成一个文件；
8.编译 Asset 文件：我们的图片如果使用 Assets.xcassets 来管理图片，那么这些图片将会被编译成机器码，除了 icon 和 launchImage；
9.运行 Cocoapods 脚本：将在编译项目之前已经编译好的依赖库和相关资源拷贝到包中。
10.生成 .app 包
11.将 Swift 标准库拷贝到包中
12.对包进行签名
13.完成打包

链接：https://www.jianshu.com/p/b60612c4d9ca

我们不是迷信测试，但它应该帮助我们加快开发进度，并且让事情变得更有趣。

让事情保持简单

测试简单的事情很简单，同样，测试复杂的事会很复杂。就像我们在其他文章中指出的那样，让事情保持简单小巧总是好的。除此之外，它还有利于我们测试。这是件双赢的事。让我们来看看测试驱动开发（简称 TDD），有些人喜欢它，有些人则不喜欢。我们在这里不深入讨论，只是如果用 TDD，你得在写代码之前先写好测试。如果你好奇的话，可以去找 Wikipedia 上的文章看看。同时，我们也认为重构和测试可以很好地结合在一起。

测试 UI 部分通常很麻烦，因为它们包含太多活动部件。通常，view controller 需要和大量的 model 和 view 类交互。为了使 view controller 便于测试，我们要让任务尽量分离。

幸好，我们在更轻量的 view controller 这篇文章中的阐述的技术可以让测试更加简单。通常，如果你发现有些地方很难做测试，这就说明你的设计出了问题，你应该重构它。你可以重新参考更轻量的 view controller 这篇文章来获得一些帮助。总的目标就是有清晰的关注点分离。每个类只做一件事，并且做好。这样就可以让你只测试这件事。

记住：测试越多，回报的增长趋势越慢。首先你应该做简单的测试。当你觉得满意时，再加入更多复杂的测试。

Mocking

当你把一个整体拆分成小零件（比如更小的类）时，我们可以针对每个小的类来进行测试。但由于我们测试的类会和其他类交互，这里我们用一个所谓的 mock 或 stub 来绕开它。把 mock 对象看成是一个占位符，我们测试的类会跟这个占位符交互，而不是真正的那个对象。这样，我们就可以针对性地测试，并且保证不依赖于应用程序的其他部分。

在示例程序中，我们有个包含数组的 data source 需要测试。这个 data source 会在某个时候从 table view 中取出（dequeue）一个 cell。在测试过程中，还没有 table view，但是我们传递一个 mock 的 table view，这样即使没有 table view，也可以测试 data source，就像下面你即将看到的。起初可能有点难以理解，多看几次后，你就能体会到它的强大和简单。

Objective-C 中有个用来 mocking 的强大工具叫做 OCMock。它是一个非常成熟的项目，充分利用了 Objective-C 运行时强大的能力和灵活性。它使用了一些很酷的技巧，让通过 mock 对象来测试变得更加有趣。

本文后面有 data source 测试的例子，它更加详细地展示了这些技术如何工作在一起。

SenTestKit

编者注 这一节有一些过时了。在 Xcode 5 中 SenTestingKit 已经被 XCTest 完全取代，不过两者使用上没有太多区别，我们可以通过 Xcode 的 Edit -> Refactor -> Convert to XCTest 选项来切换到新的测试框架

我们将要使用的另一个工具是一个测试框架，开发者工具的一部分：Sente 的 SenTestingKit。这个上古神器从 1997 年起就伴随在 Objective-C 开发者左右，比第一款 iPhone 发布还早 10 年。现在，它已经集成到 Xcode 中了。SenTestingKit 会运行你的测试。通过 SenTestingKit，你将测试组织在类中。你需要给每一个你想测试的类创建一个测试类，类名以 Tests 结尾，它反应了这个类是干什么的。

这些测试类里的方法会做具体的测试工作。方法名必须以 test 开头来作为触发一个测试运行的条件。还有特殊的 -setUp 和 -tearDown 方法，你可以重载它们来设置各个测试。记住，你的测试类就是个类而已：只要对你有帮助，可以按需求在里面加 properties 和辅助方法。

做测试时，为测试类创建基类是个不错的模式。把通用的逻辑放到基类里面，可以让测试更简单和集中。可以通过示例程序中的例子来看看这样带来的好处。我们没有使用 Xcode 的测试模板，为了让事情简单有效，我们只创建了单独的 .m 文件。通过把类名改成以 Tests 结尾，类名可以反映出我们在对什么做测试。

编者注 Xcode 5 中 默认的测试模板也不再会自动创建 .h 文件了

与 Xcode 集成

测试会被 build 成一个 bundle，其中包含一个动态库和你选择的资源文件。如果你要测试某些资源文件，你得把它们加到测试的 target 中，Xcode 就会将它们打包到一个 bundle 中。接着你可以通过 NSBundle 来定位这些资源文件，示例项目实现了一个 -URLForResource:withExtension: 方法来方便的使用它。

Xcode 中的每个 scheme 定义了相应的测试 bundle 是哪个。通过 ⌘-R 运行程序，⌘-U 运行测试。

测试的运行依附于程序的运行，当程序运行时，测试 bundle 将被注入（injected）。测试时，你可能不想让你的程序做太多的事，那样会对测试造成干扰。可以把下面的代码加到 app delegate 中：

static BOOL isRunningTests(void) __attribute__((const));

- (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    if (isRunningTests()) {
        return YES;
    }

    //
    // Normal logic goes here
    //

    return YES;
}

static BOOL isRunningTests(void)
{
    NSDictionary* environment = [[NSProcessInfo processInfo] environment];
    NSString* injectBundle = environment[@"XCInjectBundle"];
    return [[injectBundle pathExtension] isEqualToString:@"octest"];
}

编辑 Scheme 给了你极大的灵活性。你可以在测试之前或之后运行脚本，也可以有多个测试 bundle。这对大型项目来说很有用。最重要的是，可以打开或关闭个别测试，这对调试测试非常有用，只是要记得之后再把它们重新全部打开。

还要记住你可以为测试代码下断点，当测试执行时，调试器会在断点处停下来。

测试 Data Source
好了，让我们开始吧。我们已经通过拆分 view controller 让测试工作变得更轻松了。现在我们要测试 ArrayDataSource。首先我们新建一个空的，基本的测试类。我们把接口和实现都放到一个文件里；也没有哪个地方需要包含 @interface，放到一个文件会显得更加漂亮和整洁。

#import "PhotoDataTestCase.h"

@interface ArrayDataSourceTest : PhotoDataTestCase
@end

@implementation ArrayDataSourceTest
- (void)testNothing;
{
    STAssertTrue(YES, @"");
}
@end

这个类没做什么事，只是展示了基本的设置。当我们运行这个测试时，-testNothing 方法将会运行。特别地，STAssert宏将会做琐碎的检查。注意，前缀 ST 源自于 SenTestingKit。这些宏和Xcode 集成，会把失败显示到侧边面板的Issues导航栏中。

第一个测试

我们现在把 testNothing 替换成一个简单、真正的测试：

- (void)testInitializing;
{
    STAssertNil([[ArrayDataSource alloc] init], @"Should not be allowed.");
    TableViewCellConfigureBlock block = ^(UITableViewCell *a, id b){};
    id obj1 = [[ArrayDataSource alloc] initWithItems:@[]
                                      cellIdentifier:@"foo"
                                  configureCellBlock:block];
    STAssertNotNil(obj1, @"");
}

接着，我们想测试ArrayDataSource实现的方法：

- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath;

为此，我们创建一个测试方法：

- (void)testCellConfiguration;

首先，创建一个 data source：

__block UITableViewCell *configuredCell = nil;
__block id configuredObject = nil;
TableViewCellConfigureBlock block = ^(UITableViewCell *a, id b){
    configuredCell = a;
    configuredObject = b;
};
ArrayDataSource *dataSource = [[ArrayDataSource alloc] initWithItems:@[@"a", @"b"]
                                                      cellIdentifier:@"foo"
                                                  configureCellBlock:block];

注意，configureCellBlock 除了存储对象以外什么都没做，这可以让我们可以更简单地测试它。

然后，我们为 table view 创建一个 mock 对象：

id mockTableView = [OCMockObject mockForClass:[UITableView class]];

Data source 将在传进来的 table view 上调用 -dequeueReusableCellWithIdentifier:forIndexPath: 方法。我们将告诉 mock object 当它收到这个消息时要做什么。首先创建一个 cell，然后设置 mock。

UITableViewCell *cell = [[UITableViewCell alloc] init];
NSIndexPath* indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
[[[mockTableView expect] andReturn:cell]
        dequeueReusableCellWithIdentifier:@"foo"
                             forIndexPath:indexPath];

第一次看到它可能会觉得有点迷惑。我们在这里所做的，是让 mock 记录特定的调用。Mock 不是一个真正的 table view；我们只是假装它是。-expect 方法允许我们设置一个 mock，让它知道当这个方法调用时要做什么。

另外，-expect 方法也告诉 mock 这个调用必须发生。当我们稍后在 mock 上调用 -verify 时，如果那个方法没有被调用过，测试就会失败。相应地，-stub 方法也用来设置 mock 对象，但它不关心方法是否被调用过。

现在，我们要触发代码运行。我们就调用我们希望测试的方法。

NSIndexPath* indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
id result = [dataSource tableView:mockTableView
            cellForRowAtIndexPath:indexPath];

然后我们测试是否一切正常：

STAssertEquals(result, cell, @"Should return the dummy cell.");
STAssertEquals(configuredCell, cell, @"This should have been passed to the block.");
STAssertEqualObjects(configuredObject, @"a", @"This should have been passed to the block.");
[mockTableView verify];

STAssert宏测试值的相等性。注意，前两个测试，我们通过比较指针来完成；我们不使用-isEqual:，是因为我们实际希望测试的是result，cell和configuredCell都是同一个对象。第三个测试要用 -isEqual:，最后我们调用 mock的 -verify方法。

注意，在示例程序中，我们是这样设置 mock 的：

id mockTableView = [self autoVerifiedMockForClass:[UITableView class]];

这是我们测试基类中的一个方便的封装，它会在测试最后自动调用 -verify 方法。

测试 UITableViewController
下面，我们转向PhotosViewController。它是个 UITableViewController 的子类，它使用了我们刚才测试过的 data source。View controller 剩下的代码已经相当简单了。

我们想测试点击 cell 后把我们带到详情页面，即一个 PhotoViewController的实例被 push 到 navigation controller 里面。我们再次使用 mocking 来让测试尽可能不依赖于其他部分。

首先我们创建一个 UINavigationController 的 mock：

id mockNavController = [OCMockObject mockForClass:[UINavigationController class]];

接下来，我们要使用部分 mocking。我们希望 PhotosViewController 实例的navigationController 返回 mockNavController。我们不能直接设置 navigation controller，所以我们简单地用 stub 来替换掉 PhotosViewController实例这个方法，让它返回mockNavController 就可以了。

PhotosViewController *photosViewController = [[PhotosViewController alloc] init];
id photosViewControllerMock = [OCMockObject partialMockForObject:photosViewController];
[[[photosViewControllerMock stub] andReturn:mockNavController] navigationController];

现在，任何时候对 photosViewController 调用 -navigationController 方法，都会返回 mockNavController。这是个强大的技巧，OCMock 就有这样的本领。

接下来，我们要告诉 navigation controller mock 我们调用的期望，即，一个 photo 不为 nil 的 detail view controller。

UIViewController* viewController = [OCMArg checkWithBlock:^BOOL(id obj) {
    PhotoViewController *vc = obj;
    return ([vc isKindOfClass:[PhotoViewController class]] &&
            (vc.photo != nil));
}];
[[mockNavController expect] pushViewController:viewController animated:YES];

现在，我们触发 view 加载，并且模拟一行被点击：

UIView *view = photosViewController.view;
STAssertNotNil(view, @"");
NSIndexPath* indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
[photosViewController tableView:photosViewController.tableView
        didSelectRowAtIndexPath:indexPath];

最后我们验证 mocks 上期望的方法被调用过：

[mockNavController verify];
[photosViewControllerMock verify];

现在我们有了一个测试，用来测试和 navigation controller 的交互，以及正确 view controller 的创建。

又一次地，我们在示例程序中使用了便捷的方法：

- (id)autoVerifiedMockForClass:(Class)aClass;
- (id)autoVerifiedPartialMockForObject:(id)object;

于是，我们不需要记住调用-verify。

进一步探索

就像你从上面看到的那样，部分 mocking 非常强大。如果你看看 -[PhotosViewController setupTableView]方法的源码，你就会看到它是如何从 app delegate 中取出 model 对象的。

NSArray *photos = [AppDelegate sharedDelegate].store.sortedPhotos;

上面的测试依赖于这行代码。打破这种依赖的一种方式是再次使用 部分 mocking，让 app delegate 返回预定义的数据，就像这样：

id storeMock; // 假设我们已经设置过了
id appDelegate = [AppDelegate sharedDelegate]
id appDelegateMock = [OCMockObject partialMockForObject:appDelegate];
[[[appDelegateMock stub] andReturn:storeMock] store];

现在，无论何时调用[AppDelegate sharedDelegate].store，它将返回 storeMock。将这个技术使用好的话，可以确保让你的测试恰到好处地在保持简单和应对复杂之间找到平衡。

需要记住的事

部分 mock 技术将会在 mocks 的存在期间替换并保持被 mocking 的对象，并且一直有效。你可以通过提前调用[aMock stopMocking]来终于这种行为。大多数时候，你希望 部分 mock 在整个测试期间都保持有效。如果要提前终止，请确保在测试方法最后放置[aMock verify]。否则 ARC 会过早释放这个 mock，这样你就不能 -verify了，这不太可能是你想要的结果。

测试 NIB 加载

PhotoCell设置在一个 NIB 中，我们可以写一个简单的测试来检查 outlets 设置得是否正确。我们来回顾一下PhotoCell类：

@interface PhotoCell : UITableViewCell

+ (UINib *)nib;

@property (weak, nonatomic) IBOutlet UILabel* photoTitleLabel;
@property (weak, nonatomic) IBOutlet UILabel* photoDateLabel;

@end

我们的简单测试的实现看上去是这样：

@implementation PhotoCellTests

- (void)testNibLoading;
{
    UINib *nib = [PhotoCell nib];
    STAssertNotNil(nib, @"");

    NSArray *a = [nib instantiateWithOwner:nil options:@{}];
    STAssertEquals([a count], (NSUInteger) 1, @"");
    PhotoCell *cell = a[0];
    STAssertTrue([cell isMemberOfClass:[PhotoCell class]], @"");

    // 检查 outlet 是否正确设置
    STAssertNotNil(cell.photoTitleLabel, @"");
    STAssertNotNil(cell.photoDateLabel, @"");
}

@end

非常基础，但是能出色完成工作。

值得一提的是，当有发生改变时，我们需要同时更新测试以及相应的类或 nib 。这是事实。你需要考虑改变类或者 nib 文件时可能会打破原有的 outlets 连接。如果你用了 .xib 文件，你可能要注意了，这是经常发生的事。

关于 Class 和 Injection
我们已经从与 Xcode 集成得知，测试 bundle 会注入到应用程序中。省略注入的如何工作的细节（它本身是个巨大的话题），简单地说：注入是把待注入的 bundle（我们的测试 bundle）中的 Objective-C 类添加到运行的应用程序中。这很好，因为这样允许我们运行测试了。

还有一件事会很让人迷惑，那就是如果我们同时把一个类添加到应用程序和测试 bundle中。如果在上面的示例程序中，我们（不小心）把 PhotoCell 类同时添加到测试 bundle 和应用程序里的话，在测试 bundle 中调用 [PhotoCell class]会返回一个不同的指针（你应用程序中的那个类）。于是我们的测试将会失败：

STAssertTrue([cell isMemberOfClass:[PhotoCell class]], @"");

再一次声明：注入很复杂。你应该确认的是：不要把应用程序中的 .m 文件添加到测试 target 中。否则你会得到预想不到的行为。

额外的思考

如果你使用一个持续集成 (CI) 的解决方案，让你的测试启动和运行是一个好主意。详细的描述超过了本文的范围。这些脚本通过 RunUnitTests 脚本触发。还有个 TEST_AFTER_BUILD 环境变量。

另一种有趣的选择是创建单独的测试 bundle 来自动化性能测试。你可以在测试方法里做任何你想做的。定时调用一些方法并使用 STAssert 来检查它们是否在特定阈值里面是其中一种选择。

链接：https://www.jianshu.com/p/733fa8bbca95

本文介绍Java版MQTT 客户端，如何连接环信MQTT消息云快速实现消息的自收自发。

一、前提条件

1.部署Java开发环境

安装IDE。您可以使用IntelliJ IDEA或者Eclipse，本文以IntelliJ IDEA为例。
下载安装JDK。 

2.导入项目依赖

在IntelliJ IDEA中创建工程，并确认pom.xml中包含以下依赖。

    commons-codec
    commons-codec
    1.10


    org.eclipse.paho
    org.eclipse.paho.client.mqttv3
    1.2.2


    org.apache.httpcomponents
    httpclient
    4.5.2


     com.alibaba
     fastjson
     1.2.76

二、实现流程

1、获取鉴权

     为保障客户安全性需求，环信MQTT消息云服务为客户提供【token+clientID】方式实现鉴权认证，其中AppID(clientID中的关键字段)及token标识获取流程如下:

【登录console】
     欢迎您登录环信云console控制台，在此控制台中，为您提供应用列表、解决方案、DEMO体验以及常见问题等功能。
     在应用列表中，若您未在APP中开通MQTT业务，可参见APP  MQTT开通流程
     若APP已开通MQTT业务，可在应用列表中选中Appname，点击【查看】操作，进入应用详情。

【获取AppID及连接地址】 
      进入【查看】后，点击左侧菜单栏【MQTT】->【服务概览】，在下图红色方框内获取当前AppID及服务器连接地址。

【获取token】
     为实现对用户管控及接入安全性，环信云console提供用户认证功能，支持对用户账户的增、删、改、查以及为每个用户账户分配唯一token标识，获取token标识可选择以下两种形式。
  形式一：console控制台获取（管理员视角）
  * 点击左侧菜单栏【应用概览】->【用户认证】页面，点击【创建IM用户】按钮，增添新的账户信息（包  括用户名及密码）。
  * 创建成功后，在【用户ID】列表中选中账户，点击【查看token】按钮获取当前账户token信息。

  形式二：客户端代码获取（客户端视角）
  * 获取域名：点击左侧菜单栏【即时通讯】->【服务概览】页面，查看下图中token域名、org_name、app_name。

  * 拼接URL：获取token URL格式为：http:/ /token域名/org_name/app_name/token。 
  * 用户名/密码：使用【用户ID】列表中已有账户的用户名及密码，例“用户名：test/密码：test123”。

客户端获取token代码示例如下：

public static void main() 

{
    // 获取token的URL
    http://{token域名}/{org_name}/{app_name}/token
    // 获取token
    String token = "";
    // 取token
    try (final CloseableHttpClient httpClient = HttpClients.createDefault())

    {    
        final HttpPost httpPost = new HttpPost("http://{token域名}/{org_name}/{app_name}/token");
        Map params = new HashMap<>();
        params.put("grant_type", "password");
        params.put("username", "test");
        params.put("password", "test123");
        //设置请求体参数
        StringEntity entity = new StringEntity(JSONObject.toJSONString(params), Charset.forName("utf-8"));
        entity.setContentEncoding("utf-8");
        httpPost.setEntity(entity);
        //设置请求头部
        httpPost.setHeader("Content-Type", "application/json");
        //执行请求，返回请求响应
        try (final CloseableHttpResponse response = httpClient.execute(httpPost)

        {
            //请求返回状态码
            int statusCode = response.getStatusLine().getStatusCode();
            //请求成功
            if (statusCode == HttpStatus.SC_OK && statusCode <= HttpStatus.SC_TEMPORARY_REDIRECT) 

            {
                //取出响应体
                final HttpEntity entity2 = response.getEntity();
                //从响应体中解析出token
                String responseBody = EntityUtils.toString(entity2, "utf-8");
                JSONObject jsonObject = JSONObject.parseObject(responseBody);
                token = jsonObject.getString("access_token");
            } 

            else 

            {
                 //请求失败
                throw new ClientProtocolException("请求失败，响应码为：" + statusCode);
            }
        }
    } 

    catch (IOException e) 

    {
        e.printStackTrace();
    }
}

返回结果

 {
    "access_token": "YWMtN8a0oqV3EeuF0AmiqRgEh-grzF8zZk2Wp8GS3pF-orDW_F-gj3kR6os3h_oz3ROQAwMAAAF5BxhGlwBPGgAvTR8vDrdVsDPNZMQj0fFjv7EaohgZhzMHM9ncVLE30g",
    "expires_in": 5184000,
    "user": 

    {
        "uuid": "d6fc5fa0-8f79-11ea-8b37-87fa33dd1390",
        "type": "user",
        "created": 1588756404898,
        "modified": 1588756404898,
        "username": "test",
        "activated": true
    }
 }
 access_token即为要获取的token

2、初始化

      在IntelliJ IDEA工程中创建MQTT客户端，客户端初始配置包括创建clientID，topic名称，QoS质量，连接地址等信息。

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import static org.eclipse.paho.client.mqttv3.MqttConnectOptions.MQTT_VERSION_3_1_1;

public class MqttDemoStarter 

{
    public static void main(String[] args) throws MqttException, InterruptedException {
        /**
        * 用户指定
        * /
        String deviceId = "xxxxx-xxxx-xxxxx-xxxxx-xxxxx";
        /**
        * 从console控制台获取
        * /
        String appId = "1NQ1E9";
        /**
         * 设置接入点，进入console控制台获取
         */
        String endpoint = "1NQ1E9.sandbox.mqtt.chat";
        /**
         * MQTT客户端ID，由业务系统分配，需要保证每个TCP连接都不一样，保证全局唯一，如果不同的客户端对象（TCP连接）使用了相同的clientId会导致之前的连接断开。
         * clientId由两部分组成，格式为DeviceID@appId，其中DeviceID由业务方自己设置，appId在console控制台创建，clientId总长度不得超过64个字符。
         */
        String clientId = deviceId + "@" + appId;

        /**
         * 需要订阅或发送消息的topic名称
         * 如果使用了没有创建或者没有被授权的Topic会导致鉴权失败，服务端会断开客户端连接。
         */
        final String myTopic = "myTopic";

        /**
         * QoS参数代表传输质量，可选0，1，2。详细信息，请参见名词解释。
         */
        final int qosLevel = 0;
        final MemoryPersistence memoryPersistence = new MemoryPersistence();

        /**
         * 客户端协议和端口。客户端使用的协议和端口必须匹配，如果是ws或者wss，使用http://；如果是mqtt或者mqtts，使用tcp://
         */
        final MqttClient mqttClient = new MqttClient("tcp://" + endpoint + ":1883", clientId, memoryPersistence);
        /**
         * 设置客户端发送超时时间，防止无限阻塞。
         */
        mqttClient.setTimeToWait(5000);

        final ExecutorService executorService = new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>());
}

3、连接服务器

    配置连接密码、cleansession标志、心跳间隔、超时时间等信息，调用connect（）函数连接至环信MQTT消息云。

MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
        /**
         * 用户名，在console中注册
         */
        mqttConnectOptions.setUserName("test");
        /**
         * 用户密码为第一步中申请的token
         */
        mqttConnectOptions.setPassword(token.toCharArray());
        mqttConnectOptions.setCleanSession(true);
        mqttConnectOptions.setKeepAliveInterval(90);
        mqttConnectOptions.setAutomaticReconnect(true);
        mqttConnectOptions.setMqttVersion(MQTT_VERSION_3_1_1);
        mqttConnectOptions.setConnectionTimeout(5000);
        mqttClient.connect(mqttConnectOptions);
        //暂停1秒钟，等待连接订阅完成
        Thread.sleep(1000);