我们的小程序框架的底层，我把它分为四个部分，主要是

• 多线程模型
• runtime 框架
• js 沙箱
• 其他

我们一个一个来

多线程模型和线程通信

多线程模型

说到多线程，我们首先想到的就是多线程的调度和通信，我们先讲通信，通常来说，多线程的非 UI 线程都是没有 dom 环境的，无论是 js 引擎还是 worker

所以为了能跑一个前端框架，我们不得另寻出路，主要方案有三种，其中幻灯片的第二种，写一个 dom 无关的 diff 算法，这是写不出来什么好算法的，所以我们主要看剩下两种思路

还记得小程序架构的前提吗？没错，就是最小资源分配

因为我们不想给小程序分配过多的资源，所以像 react、vue 这种 runtime 特别重的框架，其实是不适合用作小程序的

甚至 fre 也不适合，因为大家可能对“轻量”这个词有误解，不是代码越少就越轻量，代码量是很重要的一个方面，但是更重要的是代码的内存占用，以及算法的算力和复杂度

fre 虽然代码量少，但它的算法和 vue 是一样的，算力相同，内存占用也不少

然后我们来讲讲沙箱，也就是 js 引擎和 worker，这部分适合语言爱好者

选型

通常来说，一提到 js 引擎，大家都是 v8 v8 v8

但是实际上，v8 是一个高度优化的 JIT 引擎，它跑 js 确实是足够快的，但对于 UI 来说，我们更多要的不是跑得快

实际上，AOT 的语言或引擎更适合 UI 框架，比如 RN 的 hermes，dart 也支持 AOT，它可以编译成字节码，只需要一次构建即可，当然，AOT 也有缺点，就是 热更新 比较难做

另外除了 js 引擎，worker 也是一个非常赞的选择，方便好用，而且还提供了 bom 接口，比如 offscreen canvas，fetch，indexdb，requestAnimationFrame……

总结

哈哈哈总结，我们基于最小分配的前提去设计这个架构，每个环节都选择节省资源的方案

事实上写代码就是这样的，比如我写 fre，那么我追求 1kb，0 依赖，我写业务框架，我追求 0 配置，1mb 的 node_modules 总大小

我写小程序，我追求最小资源分配，不管做啥，有痛点然后有追求然后才有设计

其他

其实小程序还有很多东西可以做，比如现在的小程序都需要兼容微信小程序，也就是类似 wxml，wxss，wxs这些非标准的文件，还要得是个多 Page 的 mpa

比如 ide，我们可以使用 nobundle 的思路来加快构建速度

当然，为了服务业务，在我们公司我没有使用 nobundle

比如剧透一下，我在公司中为了兼容微信小程序，开的新坑

原理是将微信的文件（wxml，wxss，wxs）先编译成可识别的文件（jsx，css，js），然后使用 babel、postCss 去转移，形成一个个 umd 的子应用

然后通过 berial（微前端框架）的路由，沙箱，生命周期，将它们跑在 h5 端，这样就可以在浏览器中模拟和调试啦

最后我们通过三张图和一个问题，来补充和结束一下这次分享

第一张图是微信小程序的后台桌面，有没有感觉和操作系统有点像，但其实不是的，操作系统的软件是进程的关系，只能切换，不能共存，而小程序是多进程，这些小程序可以在后台留驻，随时保持唤醒

第二张图是钉钉的仪表盘，这也是小程序最常用的场景，就是和这种一堆子应用的 app

第三张图是 vscode 的插件系统，是的，想不到吧，这玩意也是小程序架构，而且也是同样的思想，我不让你操作 dom

然后最后的问题：canvas 怎么办？

这个问题实际上非常难搞，如果我们使用 worker 作为 js 沙箱还好，有 offscreen canvas 和 requestAnimationFrame

如果我们使用 js 引擎怎么办呢，走上面提到的线程通信成本就太高了，动画走这个通信，等接收到消息，动画已经卡死了

所以还有什么办法，这里不得不再次提多线程的特性，也就是多线程的内存是共享的，我们可以 js 引擎中，将 canvas 整个元素放到堆栈里，然后 UI 线程和 js 线程共享这一块内存

这样就不需要走线程通信了，适合 canvas，动画这种场景

链接：https://juejin.cn/post/6962028699872919559

   今日份跟大佬聊到说前端基础架构平台的东西、涉及到基础组件库、公共工具类等内容, 然后期望能自我驱动带头去做, 陷入深深滴沉思, 该考虑如何做?
思绪一片混乱, 那就写篇文章冷静冷静,故有了此篇, 仅供参考。

微信小程序原生有提供一套日期组件, 大概如下:

那就开干, 为尽可能保持代码的最小颗粒度(这里不考虑弹窗外壳的封装、纯日期组件).
话不多说、这里直接贴上代码、预留的坑位都会在代码内有备注, 请参考:

// 组件wxml
<!-- 预留坑位: 按道理该日期组件应该是做在弹窗上的、这里为了简化代码故直接写在了页面上; 
     后期使用者烦请自己做个弹窗套上、用showModal属性控制其显示隐藏-->
<view class="picker" wx:if="{{showModal}}">
   <picker-view indicator-class="picker-indicator" value="{{pickerIndexList}}" bindchange="bindChangeDate">
      <picker-view-column>
        <view wx:for="{{yearList}}" wx:key="index" class="{{pickerIndexList[0]==index?'txt-active':''}}">{{item}}年</view>
      </picker-view-column>
      <picker-view-column>
        <view wx:for="{{monthList}}" wx:key="index" class="{{pickerIndexList[1]==index?'txt-active':''}}">{{item}}月</view>
      </picker-view-column>
      <picker-view-column>
        <view wx:for="{{dayList}}" wx:key="index" class="{{pickerIndexList[2]==index?'txt-active':''}}">{{item}}日</view>
      </picker-view-column>
    </picker-view>
    <!-- 预留坑位: 日期组件可能仅允许数据回选、不允许修改。
    思路: 通过自定义蒙层盖在日期控件上从而达到禁止控件滚动的效果.
     -->
    <view wx:if="{{!canEdit}}" class="disabled-picker"></view>
</view>

// 组件wxss
.picker{
    position: relative;
    height: 300rpx;
    width: 600rpx;
    margin: 0 auto;
    border: 1rpx solid red;
}
.picker picker-view {
    width: 100%;
    height: 100%;
}
.picker-indicator {
    height: 60rpx;
    line-height: 60rpx;
}
.picker picker-view-column view {
    font-size: 40rpx;
    line-height: 60rpx;
    text-align: center;
}
.txt-active {
    color: #2c2c2c;
}
/* 预留坑位: 为便于区分真的有遮罩层盖住、特意加了个背景色、实际使用过程可改成透明色 */
    .disabled-picker{
    width: 600rpx;
    position: absolute;
    top: 0;
    left: 0;
    height: 300rpx;
    z-index: 999;
    background: rgb(255,222,173,0.7);
}


// 组件js
Component({
  properties: {},
  data: {
    yearList: [],
    monthList: [],
    dayList: [],
    pickerIndexList: [0, 0, 0]
  },
  methods: {
    // dateString格式: 'YYYY-MM-DD'
    initPicker (dateString) {
      let nowDate = new Date()
      // 预留个坑位: 若需要指定某一日期则从外面传入、否则默认当天
      if(dateString){
        // 预留个坑位: 判定传入的数据类型是否符合要求、若不符合该报错的报错
        nowDate = new Date(dateString)
      }

      // 预留个坑位: 因为下面的日期指定在1900.01.01-2100.12.31、故这里最好校验下传入日期是否在区间内.
      let nowYear = nowDate.getFullYear()
      let nowMonth = nowDate.getMonth() + 1
      let yearList = this.getYearList(nowYear)
      let monthList = this.getMonthList()
      let dayList = this.getDayList(nowYear, nowMonth)

      // 获取多列选择器的选中值下标
      let pickerIndexList = []
      pickerIndexList[0] = yearList.findIndex(o => o === nowDate.getFullYear())
      pickerIndexList[1] = monthList.findIndex(o => o === nowDate.getMonth()+1)
      pickerIndexList[2] = dayList.findIndex(o => o === nowDate.getDate())
      this.setData({
        yearList,
        monthList,
        dayList,
        pickerIndexList,
        showModal: true
      })
    },
    // 获取年份
    getYearList (nowYear) {
      let yearList = []
      if(nowYear < 1900 || nowYear > 2100){
        return false
      }
      for (let i = 1900; i <= 2100; i++) {
        yearList.push(i)
      }
      return yearList
    },
    // 获取月份
    getMonthList () {
      let monthList = []
      for (let i = 1; i <= 12; i++) {
        monthList.push(i)
      }
      return monthList
    },
    // 获取日期 -> 根据年份&月份
    getDayList (year, month) {
      let dayList = []
      month = parseInt(month, 10) 
      // 特别注意: 这里要根据年份&&月份去计算当月有多少天[切记切记]
      let temp = new Date(year, month, 0)
      let days = temp.getDate()
      for (let i = 1; i <= days; i++) {
        dayList.push(i)
      }
      return dayList
    },
    // 日期选择改变事件
    bindChangeDate (e) {
      let pickerColumnList = e.detail.value
      const { yearList=[], monthList=[] } = this.data
      const nowYear = yearList[pickerColumnList[0]]
      const nowMonth = monthList[pickerColumnList[1]]
      this.setData({
        dayList: this.getDayList(nowYear, nowMonth),
        pickerIndexList: pickerColumnList
      })
    },
    show (birthday) {
      // 预留坑位: 这里也许会有一定的逻辑判定是否允许编辑日期控件, 故预留canEdit属性去控制
      this.setData({
        canEdit: true
      })
      this.initPicker(birthday)
    },
    // 预留坑位、点击确定按钮获取到选中的日期
    surePicker () {
      const { pickerIndexList, yearList, monthList, dayList } = this.data
      // 预留坑位: 月份&日期补0
      let txtDate = `${yearList[pickerIndexList[0]]}-${monthList[pickerIndexList[1]]}-${dayList[pickerIndexList[2]]}`
      console.log(txtDate)
    },
  }
})

接下来我们看看使用方是怎么使用的?

// 页面wxml
<!-- 预留坑位: 这里仅展示触发事件、开发者替换成实际业务即可-->
  <view bind:tap="openPicker" style="margin:20rpx; text-align:center;">打开日期控件</view>

// 页面json: 记得在使用页面的json处引入该组件、配置组件路径

// 页面js
  methods: {
    openPicker (){
      // 获取组件实例、这里可选择是否传入日期
      this.date_picker = this.selectComponent && this.selectComponent('#date_picker')
      this.date_picker && this.date_picker.show()
    },
  }

一切准备就绪、我们看看效果图!
这是日期可编辑时、你是可滚动选择器的:

我们看看日期不可编辑时、仅可查看的效果图:

简介

Onboard主要用于引导页制作，源码写的相当规范，值得参考.

项目主页: https://github.com/mamaral/Onboard
实例下载: https://github.com/mamaral/Onboard/archive/master.zip

样式

设置背景图片或者背景movie，然后在它们之上生成数个ViewController，默认是顶部一张图片，下面是标题和详细介绍，最下面是按钮和page

导入

pod 'Onboard'

使用

导入头文件#import “OnboardingViewController.h”

图片为背景

蒙板控制器生成方法

1、title是标题
2、body是介绍
3、image是顶部图片
4、buttonText是按钮文本
5、block是按钮点击事件

OnboardingContentViewController *firstPage = [OnboardingContentViewController contentWithTitle:@"What A Beautiful Photo" body:@"This city background image is so beautiful." image:[UIImage imageNamed:@"blue"] buttonText:@"Enable Location Services" action:^{
}];

OnboardingContentViewController *secondPage = [OnboardingContentViewController contentWithTitle:@"I'm so sorry" body:@"I can't get over the nice blurry background photo." image:[UIImage imageNamed:@"red"] buttonText:@"Connect With Facebook" action:^{
}];       
secondPage.movesToNextViewController = YES;
secondPage.viewDidAppearBlock = ^{
};

OnboardingContentViewController *thirdPage = [OnboardingContentViewController contentWithTitle:@"Seriously Though" body:@"Kudos to the photographer." image:[UIImage imageNamed:@"yellow"] buttonText:@"Get Started" action:^{
}];
 ```


#### 底部图片控制器

```objc 
    OnboardingViewController *onboardingVC = [OnboardingViewController onboardWithBackgroundImage:[UIImage imageNamed:@"milky_way.jpg"] contents:@[firstPage, secondPage, thirdPage]];




<div class="se-preview-section-delimiter"></div>

底部video控制器

NSBundle *bundle = [NSBundle mainBundle];
    NSString *moviePath = [bundle pathForResource:@"yourVid" ofType:@"mp4"];
    NSURL *movieURL = [NSURL fileURLWithPath:moviePath];
    OnboardingViewController *onboardingVC = [OnboardingViewController onboardWithBackgroundVideoURL:movieURL contents:@[firstPage, secondPage, thirdPage]];




<div class="se-preview-section-delimiter"></div>

定制
1、默认的会给背景图片或者movie加一层黑色的蒙板，可以去掉它们：

onboardingVC.shouldFadeTransitions = YES;




<div class="se-preview-section-delimiter"></div>

2、可以给图片加上模糊效果（相当漂亮）：

onboardingVC.shouldBlurBackground = YES;




<div class="se-preview-section-delimiter"></div>

3、可以给蒙板上的文字加上淡出效果：

onboardingVC.shouldFadeTransitions = YES;

转自：https://blog.csdn.net/sinat_30800357/article/details/50016319

知识点概述

1.KVO实现原理
2.runtime使用

目的

给NSObject添加一个Category，用于给实例对象添加观察者，当该实例对象的某个属性发生变化的时候通知观察者。

大体思路

添加观察者的方法中

- (void)SQ_addObserver:(NSObject *)observer
            forKeyPath:(NSString *)keyPath 
               options:(NSKeyValueObservingOptions)options 
               context:(nullable void *)context;

会用runtime的方式手动创建一个其子类，并且将该对象变为该子类。该子类会复写观察方法中keyPath的setter方法，使这个setter被调用时利用runtime去调用observer的回调方法

-(void)observeValueForKeyPath:(NSString *)keyPath 
                     ofObject:(id)object 
                       change:(NSDictionary<NSKeyValueChangeKey,id> *)change
                      context:(void *)context;

实现

这里只做KVO的基本功能，当被观察者改变属性的时候通知观察者，所以定义如下方法

NSObject+SQKVO.h

/**
 添加观察者

 @param observer 观察者
 @param keyPath 被观察的属性名
 */
- (void)SQ_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;


/**
 当被观察的观察属性改变的时候的回调函数

 @param keyPath 所观察被观察者的属性名
 @param object 被观察者
 @param value 被观察的属性的新值
 */
- (void)SQ_observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object changeValue:(id)value;

@end

因为这里要用到runtime所以需要添加runtime的头文件

#import <objc/message.h>

而且因为用到objc_msgSend所以要改变一下工程的环境变量

一.动态生成子类

在被观察者调用- SQ_addObserver:forKeyPath:时首先动态生成一个其子类。

// 1.生成子类
    // 1.1获取名称
    Class selfClass = [self class];
    NSString *className = NSStringFromClass(selfClass);
    NSString *KVOClassName = [className stringByAppendingString:@"_SQKVO"];
    const char *KVOClassNameChar = [KVOClassName UTF8String];
    // 1.2创建子类
    Class KVOClass = objc_allocateClassPair(selfClass, KVOClassNameChar, 0);
    // 1.3注册
    objc_registerClassPair(KVOClass);

这里可以看到，我们将子类的类名命名为“类名”+“SQKVO”，譬如类名为“Person”，这个子类是“Person_SQKVO”。
这里有个注意点，一般为动态创建的类名应尽量复杂一些避免重复。最好加上“”。

二.根据KeyPath动态添加对应的setter

1 确定setter的名字
举个例子，如果用户给的keyPath是name，应该动态添加一个-setName:的方法。而这个setter的名字是 "set" + "把keyPath变为首字母大写" + ":"
所以可以得出

NSString *setterString =
    [NSString stringWithFormat:@"set%@:", [keyPath capitalizedString]];
    SEL setter =  NSSelectorFromString(setterString);

2 利用class_addMethod()给子类动态添加方法

BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types);

1、cls:
给哪个类添加方法。即新生成的子类，上面生成的 KVOClass。
2、name：
所添加方法的名称。即上一步生成的字符串 setterString。
3、imp：
所添加方法的实现。即这个方法的C语言实现，首先在下面先写一个C语言的方法。稍后会讲具体实现。

void setValue(id self, SEL _cmd, id newVale) {
}

4、types：
所添加方法的编码类型。setter的返回值是void，参数是一个对象(id)。void用"v"表示，返回值和参数之间用“@:”隔开，对象用"@"表示。最后我们可以得出结果"v@:@"。
具体其他的编码类型可以参考苹果文档。
ps: 这里说下为什么返回值和参数之间用“@:”隔开。“:”代表字符串，所有的OC方法都有两个隐藏参数在参数列表的最前面，“发起者”和 “方法描述符”，“@”就是这个发起者，“:”是方法描述符。而这个types其实是imp返回值和参数的编码。因为OC方法中返回值和参数之间必然有“发起者”和“SEL”隔着，所以“@:”自然而然就成了返回值和参数之间的分隔符。
当然我们还可以用@encode来得到我们想要的编码类型

NSString *encodeString =
[NSString stringWithFormat:@"%s%s%s%s",
@encode(void), 
@encode(id), 
@encode(SEL), 
@encode(id)];

3 将当前对象的类变为我们所创建的子类的类型，即更改isa指针

object_setClass(self, KVOClass);

4 将keyPath和观察者关联(associate)到我们的对象上

用下面这个函数可以很方便的将一个对象用键值对的方式绑定到一个目标对象上。
*如果想了解跟多可以查找《Effective Objective-C》的第10条

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy);

1、object
目标对象

2、key
绑定对象的键，相当于NSDictionary的key
这里的key一般采用下面的方式声明:

static const void *SQKVOObserverKey = &SQKVOObserverKey;
static const void *SQKVOKeyPathKey = &SQKVOKeyPathKey;

这样做是因为若想令两个键匹配到同一个值，则两者必须是完全相同的指针才行。

3、value
绑定对象，相当于NSDictionary的value

4、policy
绑定对象的缓存策略
@property (nonatomic, weak) ：OBJC_ASSOCIATION_ASSIGN
@property (nonatomic, strong) ：OBJC_ASSOCIATION_RETAIN_NONATOMIC
@property (nonatomic, copy) ：OBJC_ASSOCIATION_COPY_NONATOMIC
@property (atomic, strong) ：OBJC_ASSOCIATION_RETAIN
@property (atomic, weak) ：OBJC_ASSOCIATION_COPY

最后关联的代码:

objc_setAssociatedObject(self, SQKVOObserverKey, observer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
objc_setAssociatedObject(self, SQKVOKeyPathKey, keyPath, OBJC_ASSOCIATION_COPY_NONATOMIC);

三.setValue()的实现

这个函数的目的主要是：
1.利用objc_msgSend触发原先类的setter
2.利用objc_msgSend触发观察者的回调方法

1. 触发原先的setter方法

// 保存子类
    Class KVOClass = [self class];
    
    // 变回原先的类型，去触发setter
    object_setClass(self, class_getSuperclass(KVOClass));
    NSString *keyPath = objc_getAssociatedObject(self, SQKVOKeyPathKey);
    NSString *setterString = [NSString stringWithFormat:@"set%@:", [keyPath capitalizedString]];
    SEL setter = NSSelectorFromString(setterString);
    objc_msgSend(self, setter, newVale);

2. 调用观察者的回调方法

id observer = objc_getAssociatedObject(self, SQKVOObserverKey);
    objc_msgSend(observer, @selector(SQ_observeValueForKeyPath:ofObject:changeValue:), keyPath, self, newVale);

3.改回KVO类

object_setClass(self, KVOClass);

四.实现空的回调方法

- (void)SQ_observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object changeValue:(id)value {
    
}

五.调用自定义的KVO

恭喜你看到这里，并且恭喜你已经成功了！

六.代码

代码下载地址

转自：https://www.jianshu.com/p/eb067f68c2b7

示例代码下载

手动引用计数

MRC内存管理的思考方式

1、自己生成的对象自己持有
2、不是自己生成的对象，自己也能持有
3、不在需要自己持有的对象时释放
4、不是自己持有的对象无法释放

对象操作与Objective-C方法的对应

实现一个MRCObject类：

@implementation MRCObject
- (void)dealloc {
    NSLog(@"%@(%@)销毁了", NSStringFromClass(self.class), self);
    
    [super dealloc];
}
+ (instancetype)object {
    MRCObject *obj = [self allocObject];
    [obj autorelease];
    return obj;
}

+ (instancetype)allocObject {
    MRCObject *obj = [[MRCObject alloc] init];
    NSLog(@"%@(%@)生成了", NSStringFromClass(obj.class), obj);
    
    return obj;
}

@end

自己生成并持有对象：

MRCObject *obj = [MRCObject allocObject];

不是自己生成的对象也能持有：

MRCObject *obj = [MRCObject object];
[obj retain];

不在需要自己持有的对象时释放：

MRCObject *obj = [self allocObject];
[obj release];

无法释放自己没有持有的对象：

MRCObject *obj = [self allocObject];
[obj release];
[obj release];//会奔溃

autorelease

autorelease像c语言的自动变量来对待对象实例，当超出其作用域（相当于变量作用域），对象实例的release方法被调用。与c语言自动变量不同的是，可以autorelease的作用域。

autorelease的使用方法：

1、生成NSAutoreleasePool对象
2、调用已分配对象实例的autorelease方法
3、废弃NSAutoreleasePool对象

在应用程序中，由于主线程的NSRunloop对NSAutoreleasePool对象进行生成、持有和废弃处理。因此开发者不一定非得使用NSAutoreleasePool对象来进行开发工作。如下图：

在大量产生autorelease对象时，只要不废弃NSAutoreleasePool对象，autorelease对象就不会被释放，因此会产生内存不足的现象。如下两段代码：

for (int index = 0; index < 1000; index++) {
        NSString *path = [[NSBundle mainBundle] pathForResource:@"1553667540126" ofType:@"jpeg"];
        UIImage *image = [[UIImage alloc] initWithContentsOfFile:path];
        [image autorelease];
    }

for (int index = 0; index < 1000; index++) {
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        NSString *path = [[NSBundle mainBundle] pathForResource:@"1553667540126" ofType:@"jpeg"];
        UIImage *image = [[UIImage alloc] initWithContentsOfFile:path];
        [image autorelease];
        [pool drain];
    }

ARC

ARC规则

ARC有效时，id类型和对象类型同c语言其他类型不同，必须添加所有权修饰符。共如下4种所有权修饰符：

1、__strong修饰符
2、__weak修饰符
3、__unsafe_unretained修饰符
4、__outoreleasing修饰符

import "ARCObject.h"

实现一个ARCObject类：

@interface ARCObject ()
{
    __strong id _strongObj;
    __weak id _weakObj;
}

@end

@implementation ARCObject

- (void)dealloc {
    NSLog(@"%@(%@)销毁了", NSStringFromClass(self.class), self);
}
+ (instancetype)allocObject {
    ARCObject *obj = [[ARCObject alloc] init];
    NSLog(@"%@(%@)生成了", NSStringFromClass(obj.class), obj);
    return obj;
}
- (void)setStrongObject:(id)obj {
    _strongObj = obj;
}
- (void)setWeakObject:(id)obj {
    _weakObj = obj;
}

@end

__strong修饰符

__strong修饰符是所有id类型和对象类型默认的所有权修饰符，表示对对象的强引用，在超出其作用域或被重新赋值时被废弃。

{
    ARCObject *obj = [ARCObject allocObject];
    NSLog(@"作用域最后一行%@", obj);
}
NSLog(@"作用域已经结束");

ARCObject *obj = [ARCObject allocObject];
NSLog(@"重新赋值前%@", obj);
obj = [ARCObject allocObject];
NSLog(@"重新赋值前后%@", obj);

__strong、__weak、__outoreleasing修饰符的自动变量默认初始化为nil。

__weak修饰符

__weak修饰符与__strong修饰符相反，提供弱引用，弱引用不持有对象实例。

循环引用容易发生内存泄漏，内存泄漏就是应当废弃的对象在超出其生存周期后依然存在。可以使用__weak修饰符来避免。

ARCObject *aObj = [ARCObject allocObject];
ARCObject *bObj = [ARCObject allocObject];
[aObj setStrongObject:bObj];
[bObj setStrongObject:aObj];

ARCObject *obj = [ARCObject allocObject];
[obj setStrongObject:obj];

ARCObject *aObj = [ARCObject allocObject];
ARCObject *bObj = [ARCObject allocObject];
ARCObject *cObj = [ARCObject allocObject];
[aObj setWeakObject:bObj];
[bObj setWeakObject:aObj];
[cObj setWeakObject:cObj];

__weak修饰符有一个优点就是：在持有某对象的弱引用时，如果该对象被废弃，则该对象弱引用自动失效且被置为nil。

__unsafe_unretained修饰符

__unsafe_unretained修饰符，正如其名一样是不安全的所有权修饰符。尽管ARC的内存管理是编译器的工作，但是这一点需要注意特别注意，__unsafe_unretained修饰符的变量不属于编译器内存管理的对象。

__unsafe_unretained修饰符和__weak修饰符的变量一样不会持有对象，但是__unsafe_unretained修饰符的变量在销毁时并不会自动置为nil，在其地址被覆盖后就会因为反问垂悬指正而造成奔溃。因此__unsafe_unretained修饰符变量赋值给__strong修饰符变量时要确保对象的真实存在。因为__weak修饰符是在iOS5中实现的，__unsafe_unretained修饰符存在的意义就是在iOS4中代替__weak修饰符的作用。

ARCObject __unsafe_unretained *obj = nil;
{
    ARCObject *obj1 = [ARCObject allocObject];
    obj = obj1;
}
NSLog(@"%@(%@)", NSStringFromClass(obj.class), obj);

__outoreleasing修饰符

ARC有效时不能使用outorelease方法，也不能使用NSAutoreleasePool类。这样就导致outorelease无法直接使用，但实际上outorelease功能是起作用的。使用@outoreleasepool{}块代码来代替NSAutoreleasePool类对象的生成持有以及废弃。通过赋值给__outoreleasing修饰符的变量来代替调用outorelease方法，也就是说对象被注册到autoreleasepool中。

@autoreleasepool {
    ARCObject __autoreleasing *obj1 = [ARCObject allocObject];
    NSLog(@"autoreleasepool块最后一行%@", obj1);
}
NSLog(@"autoreleasepool块已经结束");

ARC有效时，cocoa中由于编译器会检查方法名是否以alloc/new/copy/mutableCopy开始，如果不是则自动将返回值的对象注册到outoreleasepool中。所以非显示的使用__outoreleasing修饰符也是可以的。

NSMutableArray __weak *array = nil;
NSLog(@"作用域块开始前%@", array);
{
    NSMutableArray *arr = [NSMutableArray arrayWithObject:@(1)];
    array = arr;
    NSLog(@"作用域块最后一行%@", array);
}
NSLog(@"作用域块已经结束%@", array);

打印结果：

2019-03-28 11:56:52.316360+0800 ProfessionalExample[82984:16680615] 作用域块开始前(null)
2019-03-28 11:56:52.316538+0800 ProfessionalExample[82984:16680615] 作用域块最后一行(
    1
)
2019-03-28 11:56:52.316627+0800 ProfessionalExample[82984:16680615] 作用域块已经结束(
    1
)

id的指针和对象的指针在没有显式指定修饰符时会被附加上__outoreleasing修饰符。

- (BOOL)performOperationWithError:(ARCObject **)obj {
    *obj = [ARCObject object];
    return NO;
}

调用方法则为如下所示，自动转化为__autoreleasing修饰符：

[self performOperationWithError:<#(ARCObject *__autoreleasing *)#>];

id的指针和对象的指针变量必须指明所有权修饰符，并且赋值的所有权修饰符必须一致：

NSObject **pObj;//编报错，没有所有权修饰符

NSObject *obj = [[NSObject alloc] init];
NSObject *__autoreleasing*pObj = &obj;//编译报错，会更改所有权属性

纠正一个比较普遍的错误认知，for循环中并不是循环结束才释放循环内的局部变量，并不是所有产生大量对象的for循环中都需要加NSAutoreleasePool，而是产生大量autorelease对象时才需要添加。如下示例代码：

for (int index = 0; index < 2; index++) {
        if (index == 0) {
            NSLog(@"-------------begin");
            ARCObject *obj = [[ARCObject alloc] init];
            NSLog(@"%@(%@)生成了", NSStringFromClass(obj.class), obj);
        }
        if (index == 1) {
            NSLog(@"-------------end");
        }
    }

下面是这段代码的打印内容：

2019-03-28 15:27:19.179194+0800 ProfessionalExample[85692:16955598] -------------begin
2019-03-28 15:27:19.179366+0800 ProfessionalExample[85692:16955598] ARCObject(<ARCObject: 0x600001ded3a0>)生成了
2019-03-28 15:27:19.179449+0800 ProfessionalExample[85692:16955598] ARCObject(<ARCObject: 0x600001ded3a0>)销毁了
2019-03-28 15:27:19.179521+0800 ProfessionalExample[85692:16955598] -------------end

ARC编码规则

1、不能使用retain/release/retainCount/autorelease
2、不能使用NSAllocateObject/NSDeallocateObject
3、须遵守内存管理的方法命名规则
4、不能显式调用dealloc方法
5、使用@autoreleasepool{}代替NSAutoreleasePool
6、不能使用NSZone
7、对象变量不能作为c语言结构体的成员
8、显式转换id和void *

内存管理的方法命名规则

以alloc/new/copy/mutableCopy开头的方法返回对象时，必须返回给调用方应当持有的对象。这在ARC有效时是一样的，不同的是以init开头的方法必须是实例方法且需要返回对象，该返回对象并不注册到autoreleasepool上。

对象变量不能作为c语言结构体的成员

要把对象类型变量加入到结构体中，需强制转为void *或者前面附加__unsafe_unretained修饰符。

显式转换id和void *

可以使用（__bridge）转换void *和OC对象，但是其安全性和赋值给__unsafe_unretained修饰符相近或者更低。如果管理时不注意赋值对象的所有者就会因为垂悬指针而奔溃或者内存泄漏。

NSObject *obj = [[NSObject alloc] init];
void *p = (__bridge void *)obj;
obj = (__bridge NSObject *)p;

__bridge_retained转换可使要赋值的变量持有所赋值的变量。__bridge_transfer则与之相反。

NSObject *obj = [[NSObject alloc] init];
void *p = (__bridge_retained void *)obj;
obj = (__bridge_transfer NSObject *)p;

NSObject对象与Core Fundation对象之间的相互转换，即免费桥（Toll-Freee-Bridge）转换。CFBridgingRetain函数（等价于__bridge_retained转换），CFBridgingRelease函数（等价于__bridge_transfer）。

NSObject *obj = [[NSObject alloc] init];
CFTypeRef ref = CFBridgingRetain(obj);
obj = CFBridgingRelease(ref);

属性

属性声明的属性与所有权修饰符对应关系

c数组

c静态数组，各修饰符的使用OC对象一样没有区别。

以__strong为例，其初始化为nil，超过作用域销毁：

{
    ARCObject *array[2];
    array[0] = [ARCObject allocObject];
    NSLog(@"array第一个元素：%@", array[0]);
    NSLog(@"array第二个元素：%@", array[1]);
    array[1] = nil;
    NSLog(@"array第二个元素：%@", array[1]);
}
NSLog(@"作用域块已经结束");

打印结果：

2019-03-28 19:19:26.697408+0800 ProfessionalExample[88859:17353905] ARCObject(<ARCObject: 0x6000005f8500>)生成了
2019-03-28 19:19:26.697661+0800 ProfessionalExample[88859:17353905] array第一个元素：<ARCObject: 0x6000005f8500>
2019-03-28 19:19:26.697761+0800 ProfessionalExample[88859:17353905] array第二个元素：(null)
2019-03-28 19:19:26.697845+0800 ProfessionalExample[88859:17353905] array第二个元素：(null)
2019-03-28 19:19:26.697930+0800 ProfessionalExample[88859:17353905] ARCObject(<ARCObject: 0x6000005f8500>)销毁了
2019-03-28 19:19:26.697995+0800 ProfessionalExample[88859:17353905] 作用域块已经结束

c动态数组，c语言中动态数组声明用指针即id *array(NSObject **array)。需要注意如下几点：

1、_strong/__weak修饰符的OC变量初始化为nil，并不代表其指针初始化为nil。所以分配内存后，需要对其初始化为nil，否则非常危险。calloc函数分配的就是nil初始化后的内存，malloc函数分配内存后必须使用memset将内存填充为0(nil)。
2、必须置空_strong修饰符的态数数组内的元素，使其强引用失效，元素才能释放。因为动态数组的生命周期有开发者管理，编译器不能确定销毁动态数组内元素的时机。

{
    ARCObject *__strong *array;
    array = (ARCObject *__strong *)calloc(2, sizeof(ARCObject *));
    NSLog(@"array第一个元素：%@", array[0]);
    NSLog(@"array第二个元素：%@", array[1]);
    array[0] = [ARCObject allocObject];
    array[1] = [ARCObject allocObject];
    array[0] = nil;
    NSLog(@"array第一个元素：%@", array[0]);
    NSLog(@"array第二个元素：%@", array[1]);
    free(array);
}
NSLog(@"作用域块已经结束");

打印结果：

2019-03-28 19:29:26.162245+0800 ProfessionalExample[89048:17394552] array第一个元素：(null)
2019-03-28 19:29:26.162586+0800 ProfessionalExample[89048:17394552] array第二个元素：(null)
2019-03-28 19:29:26.162763+0800 ProfessionalExample[89048:17394552] ARCObject(<ARCObject: 0x600001a32b40>)生成了
2019-03-28 19:29:26.162867+0800 ProfessionalExample[89048:17394552] ARCObject(<ARCObject: 0x600001a395c0>)生成了
2019-03-28 19:29:26.162945+0800 ProfessionalExample[89048:17394552] ARCObject(<ARCObject: 0x600001a32b40>)销毁了
2019-03-28 19:29:26.163011+0800 ProfessionalExample[89048:17394552] array第一个元素：(null)
2019-03-28 19:29:26.163083+0800 ProfessionalExample[89048:17394552] array第二个元素：<ARCObject: 0x600001a395c0>
2019-03-28 19:29:26.163160+0800 ProfessionalExample[89048:17394552] 作用域块已经结束

转自：https://www.jianshu.com/p/82849c350b0b

CYLTabBarController 是一个自定义的TabBarController, 集成非常简单

https://github.com/ChenYilong/CYLTabBarController

1.首先使用CocoaPods 进行集成： 

pod 'CYLTabBarController'
在终端上执行： 
pod install --verbose --no-repo-update

2. 创建TabBar对应的视图控制器

3.创建CYLTabBarControllerConfig

#import <Foundation/Foundation.h>  
  
#import "CYLTabBarController.h"  
@interface CYLTabBarControllerConfig : NSObject  
  
@property (nonatomic, retain) CYLTabBarController * tabBarController;  
  
@end

#import "CYLTabBarControllerConfig.h"  
  
#import "FirstViewController.h"  
#import "SecondViewController.h"  
#import "ThirdViewController.h"  
#import "FourthViewController.h"  
  
  
@implementation CYLTabBarControllerConfig  
  
- (CYLTabBarController *)tabBarController {  
    if (_tabBarController == nil) {  
        FirstViewController * firstViewController = [[FirstViewController alloc] init];  
        UIViewController * firstNavigationController = [[UINavigationController alloc] initWithRootViewController:firstViewController];  
          
        SecondViewController * secondViewController = [[SecondViewController alloc] init];  
        UIViewController * secondNavigationController = [[UINavigationController alloc] initWithRootViewController:secondViewController];  
          
        ThirdViewController * thirdViewController = [[ThirdViewController alloc] init];  
        UIViewController * thirdNavigationController = [[UINavigationController alloc] initWithRootViewController:thirdViewController];  
          
        FourthViewController * fourthViewController = [[FourthViewController alloc] init];  
        UIViewController * fourthNavigationController = [[UINavigationController alloc] initWithRootViewController:fourthViewController];  
          
          
        NSArray * tabBarItemsAttributes = [self tabBarItemsAttributes];  
        NSArray * viewControllers = @[firstNavigationController, secondNavigationController, thirdNavigationController, fourthNavigationController];  
          
        CYLTabBarController * tabBarController = [[CYLTabBarController alloc] init];  
          
        tabBarController.tabBarItemsAttributes = tabBarItemsAttributes;  
        tabBarController.viewControllers = viewControllers;  
          
        _tabBarController = tabBarController;  
          
    }  
      
    return _tabBarController;  
}  
  
  
- (NSArray *)tabBarItemsAttributes {  
    NSDictionary * tabBarItem1Attribute = @{  
                                            CYLTabBarItemTitle : @"首页",  
                                            CYLTabBarItemImage : @"home_normal",  
                                            CYLTabBarItemSelectedImage : @"home_highlight"  
                                   };  
    NSDictionary * tabBarItem2Attribute = @{  
                                            CYLTabBarItemTitle : @"同城",  
                                            CYLTabBarItemImage : @"mycity_normal",  
                                            CYLTabBarItemSelectedImage : @"mycity_highlight"  
                                            };  
    NSDictionary * tabBarItem3Attribute = @{  
                                            CYLTabBarItemTitle : @"消息",  
                                            CYLTabBarItemImage : @"message_normal",  
                                            CYLTabBarItemSelectedImage : @"message_highlight"  
                                            };  
    NSDictionary * tabBarItem4Attribute = @{  
                                            CYLTabBarItemTitle : @"我的",  
                                            CYLTabBarItemImage : @"account_normal",  
                                            CYLTabBarItemSelectedImage : @"account_highlight"  
                                            };  
    NSArray * tarBarItemsAttrbutes = @[tabBarItem1Attribute, tabBarItem2Attribute, tabBarItem3Attribute, tabBarItem4Attribute];  
      
    return tarBarItemsAttrbutes;  
}  
  
  
/** 
 *  更多TabBar自定义设置：比如：tabBarItem 的选中和不选中文字和背景图片属性、tabbar 背景图片属性 
 */  
+ (void)customizeTabBarAppearance {  
      
    //去除 TabBar 自带的顶部阴影  
    [[UITabBar appearance] setShadowImage:[[UIImage alloc] init]];  
      
    // set the text color for unselected state  
    // 普通状态下的文字属性  
    NSMutableDictionary *normalAttrs = [NSMutableDictionary dictionary];  
    normalAttrs[NSForegroundColorAttributeName] = [UIColor blackColor];  
      
    // set the text color for selected state  
    // 选中状态下的文字属性  
    NSMutableDictionary *selectedAttrs = [NSMutableDictionary dictionary];  
    selectedAttrs[NSForegroundColorAttributeName] = [UIColor blackColor];  
      
    // set the text Attributes  
    // 设置文字属性  
    UITabBarItem *tabBar = [UITabBarItem appearance];  
    [tabBar setTitleTextAttributes:normalAttrs forState:UIControlStateNormal];  
    [tabBar setTitleTextAttributes:selectedAttrs forState:UIControlStateSelected];  
      
    // Set the dark color to selected tab (the dimmed background)  
    // TabBarItem选中后的背景颜色  
    [[UITabBar appearance] setSelectionIndicatorImage:[self imageFromColor:[UIColor colorWithRed:26 / 255.0 green:163 / 255.0 blue:133 / 255.0 alpha:1] forSize:CGSizeMake([UIScreen mainScreen].bounds.size.width / 5.0f, 49) withCornerRadius:0]];  
      
    // set the bar background color  
    // 设置背景图片  
    // UITabBar *tabBarAppearance = [UITabBar appearance];  
    // [tabBarAppearance setBackgroundImage:[UIImage imageNamed:@"tabbar_background_ios7"]];  
}  
  
+ (UIImage *)imageFromColor:(UIColor *)color forSize:(CGSize)size withCornerRadius:(CGFloat)radius {  
    CGRect rect = CGRectMake(0, 0, size.width, size.height);  
    UIGraphicsBeginImageContext(rect.size);  
      
    CGContextRef context = UIGraphicsGetCurrentContext();  
    CGContextSetFillColorWithColor(context, [color CGColor]);  
    CGContextFillRect(context, rect);  
      
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();  
    UIGraphicsEndImageContext();  
      
    // Begin a new image that will be the new image with the rounded corners  
    // (here with the size of an UIImageView)  
    UIGraphicsBeginImageContext(size);  
      
    // Add a clip before drawing anything, in the shape of an rounded rect  
    [[UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:radius] addClip];  
    // Draw your image  
    [image drawInRect:rect];  
      
    // Get the image, here setting the UIImageView image  
    image = UIGraphicsGetImageFromCurrentImageContext();  
      
    // Lets forget about that we were drawing  
    UIGraphicsEndImageContext();  
    return image;  
}

4. AppDelegate 设置根视图控制器

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {  
    // TabBar  
    CYLTabBarControllerConfig * TabBarControllerConfig = [[CYLTabBarControllerConfig alloc] init];  
    self.window.rootViewController = TabBarControllerConfig.tabBarController;  
    [self customizeInterface];  
      
    return YES;  
}  
- (void)customizeInterface {  
    [self setUpNavigationBarAppearance];  
}  
  
/** 
 *  设置navigationBar样式 
 */  
- (void)setUpNavigationBarAppearance {  
    UINavigationBar *navigationBarAppearance = [UINavigationBar appearance];  
      
    UIImage *backgroundImage = nil;  
    NSDictionary *textAttributes = nil;  
    if (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_6_1) {  
        backgroundImage = [UIImage imageNamed:@"navigationbar_background_tall"];  
          
        textAttributes = @{  
                           NSFontAttributeName: [UIFont boldSystemFontOfSize:18],  
                           NSForegroundColorAttributeName: [UIColor blackColor],  
                           };  
    } else {  
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0  
        backgroundImage = [UIImage imageNamed:@"navigationbar_background"];  
          
        textAttributes = @{  
                           UITextAttributeFont: [UIFont boldSystemFontOfSize:18],  
                           UITextAttributeTextColor: [UIColor blackColor],  
                           UITextAttributeTextShadowColor: [UIColor clearColor],  
                           UITextAttributeTextShadowOffset: [NSValue valueWithUIOffset:UIOffsetZero],  
                           };  
#endif  
    }  
      
    [navigationBarAppearance setBackgroundImage:backgroundImage  
                                  forBarMetrics:UIBarMetricsDefault];  
    [navigationBarAppearance setTitleTextAttributes:textAttributes];  
}

运行即可实现效果，如果想实现凸起的加号效果需要 CYLPlusButtonSubclass

#import "CYLPlusButton.h"  
  
@interface CYLPlusButtonSubclass : CYLPlusButton <CYLPlusButtonSubclassing>  
  
@end

#import "CYLPlusButtonSubclass.h"  
  
@interface CYLPlusButtonSubclass ()<UIActionSheetDelegate> {  
    CGFloat _buttonImageHeight;  
}  
  
@end  
  
@implementation CYLPlusButtonSubclass  
  
#pragma mark -  
#pragma mark - Life Cycle  
  
+ (void)load {  
    [super registerSubclass];  
}  
  
- (instancetype)initWithFrame:(CGRect)frame {  
    if (self = [super initWithFrame:frame]) {  
        self.titleLabel.textAlignment = NSTextAlignmentCenter;  
        self.adjustsImageWhenHighlighted = NO;  
    }  
    return self;  
}  
  
//上下结构的 button  
- (void)layoutSubviews {  
    [super layoutSubviews];  
      
    // 控件大小,间距大小  
    CGFloat const imageViewEdge   = self.bounds.size.width * 0.6;  
    CGFloat const centerOfView    = self.bounds.size.width * 0.5;  
    CGFloat const labelLineHeight = self.titleLabel.font.lineHeight;  
    CGFloat const verticalMarginT = self.bounds.size.height - labelLineHeight - imageViewEdge;  
    CGFloat const verticalMargin  = verticalMarginT / 2;  
      
    // imageView 和 titleLabel 中心的 Y 值  
    CGFloat const centerOfImageView  = verticalMargin + imageViewEdge * 0.5;  
    CGFloat const centerOfTitleLabel = imageViewEdge  + verticalMargin * 2 + labelLineHeight * 0.5 + 5;  
      
    //imageView position 位置  
    self.imageView.bounds = CGRectMake(0, 0, imageViewEdge, imageViewEdge);  
    self.imageView.center = CGPointMake(centerOfView, centerOfImageView);  
      
    //title position 位置  
    self.titleLabel.bounds = CGRectMake(0, 0, self.bounds.size.width, labelLineHeight);  
    self.titleLabel.center = CGPointMake(centerOfView, centerOfTitleLabel);  
}  
  
#pragma mark -  
#pragma mark - Public Methods  
  
/* 
 * 
 Create a custom UIButton with title and add it to the center of our tab bar 
 * 
 */  
+ (instancetype)plusButton {  
      
    CYLPlusButtonSubclass *button = [[CYLPlusButtonSubclass alloc] init];  
      
    [button setImage:[UIImage imageNamed:@"post_normal"] forState:UIControlStateNormal];  
    [button setTitle:@"发布" forState:UIControlStateNormal];  
      
    [button setTitleColor:[UIColor grayColor] forState:UIControlStateNormal];  
    button.titleLabel.font = [UIFont systemFontOfSize:9.5];  
    [button sizeToFit];  
      
    [button addTarget:button action:@selector(clickPublish) forControlEvents:UIControlEventTouchUpInside];  
    return button;  
}  
/* 
 * 
 Create a custom UIButton without title and add it to the center of our tab bar 
 * 
 */  
//+ (instancetype)plusButton  
//{  
//  
//    UIImage *buttonImage = [UIImage imageNamed:@"hood.png"];  
//    UIImage *highlightImage = [UIImage imageNamed:@"hood-selected.png"];  
//  
//    CYLPlusButtonSubclass* button = [CYLPlusButtonSubclass buttonWithType:UIButtonTypeCustom];  
//  
//    button.autoresizingMask = UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleBottomMargin | UIViewAutoresizingFlexibleTopMargin;  
//    button.frame = CGRectMake(0.0, 0.0, buttonImage.size.width, buttonImage.size.height);  
//    [button setBackgroundImage:buttonImage forState:UIControlStateNormal];  
//    [button setBackgroundImage:highlightImage forState:UIControlStateHighlighted];  
//    [button addTarget:button action:@selector(clickPublish) forControlEvents:UIControlEventTouchUpInside];  
//  
//    return button;  
//}  
  
#pragma mark -  
#pragma mark - Event Response  
  
- (void)clickPublish {  
    UITabBarController *tabBarController = (UITabBarController *)self.window.rootViewController;  
    UIViewController *viewController = tabBarController.selectedViewController;  
      
    UIActionSheet *actionSheet = [[UIActionSheet alloc] initWithTitle:nil  
                                                             delegate:self  
                                                    cancelButtonTitle:@"取消"  
                                               destructiveButtonTitle:nil  
                                                    otherButtonTitles:@"拍照", @"从相册选取", @"淘宝一键转卖", nil nil];  
    [actionSheet showInView:viewController.view];  
}  
  
#pragma mark - UIActionSheetDelegate  
- (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex {  
    NSLog(@"index: %ld", buttonIndex);  
}  
  
  
#pragma mark - CYLPlusButtonSubclassing  
//+ (NSUInteger)indexOfPlusButtonInTabBar {  
//    return 3;  
//}  
  
+ (CGFloat)multiplerInCenterY {  
    return  0.3;  
}  
  
@end

Demo 下载地址：

http://download.csdn.net/detail/vbirdbest/9431253

实现效果如图：

转自：https://blog.csdn.net/man_liang/article/details/56671353

Purpose
FXBlurView is a UIView subclass that replicates the iOS 7 realtime background blur effect, but works on iOS 5 and above. It is designed to be as fast and as simple to use as possible. FXBlurView offers two modes of operation: static, where the view is rendered only once when it is added to a superview (though it can be updated by calling setNeedsDisplay or updateAsynchronously:completion:) or dynamic, where it will automatically redraw itself on a background thread as often as possible.
FXBlurView 是一个 UIView 的子类，复制了 iOS7 的实时背景模糊效果，但是可以运行在 iOS5 以上的版本。它的设计简单易用。FXBlurView 提供两种模式：静态模糊和动态模糊。

FXBlurView methods

+(void)setBlurEnabled:(BOOL)blurEnabled;

This method can be used to globally enable/disable the blur effect on all FXBlurView instances. This is useful for testing, or if you wish to disable blurring on iPhone 4 and below (for consistency with iOS7 blur view behavior). By default blurring is enabled.

这个方法用来设置全局 使能/不使能 模糊效果在 FXBlurView 的实例上。默认情况下模糊效果是启动。

+(void)setUpdatesEnabled;
+(void)setUpdatesDisabled;

These methods can be used to enable and disable updates for all dynamic FXBlurView instances with a single command. Useful for disabling updates immediately before performing an animation so that the FXBlurView updates don’t cause the animation to stutter. Calls can be nested, but ensure that the enabled/disabled calls are balanced, or the updates will be left permanently enabled or disabled.

这两个方法用来设置所以的动态 FXBlurView 是否进行更新，通过一条指令执行。在展示动画之前立即对没有用的更新进行更新，使 FXBlurView 更新不会产生动画断断续续的效果。调用可以嵌套，但确保 启用/禁用 调用平衡，否则更新会留下永久 启用/禁用。

-(void)updateAsynchronously:(BOOL)async completion:(void (^)())completion;

This method can be used to trigger an update of the blur effect (useful when dynamic = NO). The async argument controls whether the blur will be redrawn on the main thread or in the background. The completion argument is an optional callback block that will be called when the blur is completed.

这个方法可以用于触发更新模糊效果。（在属性 "dynamic = NO"情况下有用）。异步参数控制是否模糊将要在主线程上或在后台进行重绘。完成参数是一个可供选择的回调块，将在模糊完成的时候进行调用。

-(void)setNeedsDisplay;

Inherited from UIView, this method can be used to trigger a (synchronous) update of the view. Calling this method is more-or-less equivalent to calling [view updateAsynchronously:NO completion:NULL].

继承 UIView，这个方法用于触发一个（同步）更新视图。调用这个方法或多或少等同于调用[view updateAsynchronously:NO completion:NULL].

FXBlurView properties

@property (nonatomic, getter = isBlurEnabled) BOOL blurEnabled;

This property toggles blurring on and off for an individual FXBlurView instance. Blurring is enabled by default. Note that if you disable blurring using the +setBlurEnabled method then that will override this setting.

这个属性用来切换 FXBlurView 单独实例模糊启动还是关闭。默认情况下模糊是使能的。请注意，如果您禁用模糊方法 setBlurEnabled，那么它将覆盖此设置。

@property (nonatomic, getter = isDynamic) BOOL dynamic;

This property controls whether the FXBlurView updates dynamically, or only once when the view is added to its superview. Defaults to YES. Note that if dynamic is set to NO, you can still force the view to update by calling setNeedsDisplay or updateAsynchronously:completion:. Dynamic blurring is extremely cpu-intensive, so you should always disable dynamic views immediately prior to performing an animation to avoid stuttering. However, if you have multiple FXBlurViews on screen then it is simpler to disable updates using the setUpdatesDisabledmethod rather than setting the dynamic property to NO.

这个属性控制 FXBlurView 是否动态更新，还是只有在视图加入到它的父视图中。默认情况下是 YES ，请注意，如果你设置 dynamic 属性为 NO，你可以强制视图更新通过调用 setNeedsDisplay或者updateAsynchronously:completion:。动态模糊非常消耗 CPU 内存，所以您应该禁用立即执行的动态视图避免出现断断续续的动画。然而，如果您在屏幕上有多个 FXBlurViews ，通过设置方法 setUpdatedsDisabled来禁止更新比用设置动态属性为 NO 更为简单。

@property (nonatomic, assign) NSUInteger iterations;

The number of blur iterations. More iterations improves the quality but reduces the performance. Defaults to 2 iterations.

模糊迭代的次数。更多的迭代提高质量，但会降低性能。默认值为 2 的迭代。

@property (nonatomic, assign) NSTimeInterval updateInterval;

This controls the interval (in seconds) between successive updates when the FXBlurView is operating in dynamic mode. This defaults to zero, which means that the FXBlurView will update as fast as possible. This yields the best frame rate, but is also extremely CPU intensive and may cause the rest of your app’s performance to degrade, especially on older devices. To alleviate this, try increasing the updateInterval value.

此属性控制 FXBlurView 在动态模式下，距离成功更新的时间间隔（以秒计）。默认值为 0 ，这表示 FXBlurView 更新越快越好。 这将生成最佳的帧速率，但是也是非常消耗 CPU内存，导致你的其他 apps 无法无法加载，特别是旧设备。为了减缓这些情况，尝试增加updateInterval 的值。

@property (nonatomic, assign) CGFloat blurRadius;

This property controls the radius of the blur effect (in points). Defaults to a 40 point radius, which is similar to the iOS 7 blur effect.

此属性控制模糊效果的半径 （以像素点计）。默认是半径为40个像素点，这个值与 iOS7 模糊效果相似。

@property (nonatomic, strong) UIColor *tintColor;

This in an optional tint color to be applied to the FXBlurView. The RGB components of the color will be blended with the blurred image, resulting in a gentle tint. To vary the intensity of the tint effect, use brighter or darker colors. The alpha component of the tintColor is ignored. If you do not wish to apply a tint, set this value to nil or [UIColor clearColor]. Note that if you are using Xcode 5 or above, FXBlurViews created in Interface Builder will have a blue tint by default.

这是应用在 FXBlurView 可选的色调选择。颜色的 RGB 分量将会掺入到模糊图像上，导致产生一个柔和的色调。为了验证色调效果，若要改变色调效果的强度，使用更亮或更暗的颜色。颜色的透明参数是被忽略的。如果您不想应用色调，设置[UIColor clearColor]。请注意，如果您现在使用 Xcode5及以上，FXBlurViews 产生一个接口生成器将默认有一个一个蓝色的色调。

@property (nonatomic, weak) UIView *underlyingView;

This property specifies the view that the FXBlurView will sample to create the blur effect. If set to nil (the default), this will be the superview of the blur view itself, but you can override this if you need to.

此属性表明该视图是 FXBlurView 产生模糊效果的子视图。如果设置为 nil（默认），则该视图的父视图是模糊视图本身，但是如果您有需要您可以进行覆盖它。

总结

今天通过学习 FXBlurView ，提高对英语文档的理解和翻译能力，增加了自己的学习兴趣，也懂得了如何去使用 FXBlurView 的模糊效果特效。在实际中提升自己的能力，年轻，就是资本！Oh Yeah!

参考

https://github.com/cnbin/FXBlurView

转自：https://cnbin.github.io/blog/2015/05/25/ioskai-yuan-xiang-mu-fxblurview/

Logger

简单，漂亮，强大的android日志

配置

下载

implementation 'com.orhanobut:logger:2.2.0'

初始化

Logger.addLogAdapter(new AndroidLogAdapter());

使用

Logger.d("hello");

输出

属性

Logger.d("debug");

Logger.e("error");

Logger.w("warning");

Logger.v("verbose");

Logger.i("information");

Logger.wtf("What a Terrible Failure");

支持字符串格式参数

Logger.d("hello %s", "world");

支持集合（仅适用于调试日志）

Logger.d(MAP);

Logger.d(SET);

Logger.d(LIST);

Logger.d(ARRAY);

Json和Xml支持（输出将处于调试级别）

Logger.json(JSON_CONTENT);

Logger.xml(XML_CONTENT);

高级用法

FormatStrategy formatStrategy = PrettyFormatStrategy.newBuilder()

  .showThreadInfo(false)  // （可选）是否显示线程信息。默认为 true

  .methodCount(0)         // （可选）要显示的方法行数。默认为 2

  .methodOffset(7)        // （可选）隐藏内部方法调用直到偏移量。默认值5

  .logStrategy(customLog) // （可选）将日志策略更改为打印输出。默认LogCat

  .tag("My custom tag")   // （可选）每个日志的全局标记。默认PRETTY_LOGGER

  .build();



Logger.addLogAdapter(new AndroidLogAdapter(formatStrategy));

日志开启

日志适配器通过检查此功能来检查日志是否应打印。

如果要禁用/隐藏输出日志，请重写isLoggable'方法。true会打印日志消息，false` 会忽略它。

Logger.addLogAdapter(new AndroidLogAdapter() {

  @Override public boolean isLoggable(int priority, String tag) {

    return BuildConfig.DEBUG;

  }

});

将日志保存到文件

//TODO: 稍后将添加更多信息

Logger.addLogAdapter(new DiskLogAdapter());

将自定义标记添加到Csv格式策略

FormatStrategy formatStrategy = CsvFormatStrategy.newBuilder()

  .tag("custom")

  .build();



Logger.addLogAdapter(new DiskLogAdapter(formatStrategy));

工作原理

更多

• 使用过滤器以获得更好的结果。或者你的自定义标签

  
  

• 确保已禁用“环绕”选项

  
  

• 也可以通过更改设置来简化输出。

  
  

• Timber 集成

  // 将methodOffset设置为5以隐藏内部方法调用
  
  Timber.plant(new Timber.DebugTree() {
  
  @Override protected void log(int priority, String tag, String message, Throwable t) {
  
    Logger.log(priority, tag, message, t);
  
  }
  
  });
  
  

  
  

github地址：https://github.com/orhanobut/logger
下载地址：
master.zip

前言

在软件开发系统中，“方法的请求者”与“方法的实现者”之间经常存在紧密的耦合关系，这不利于软件功能的扩展与维护。例如，想对方法进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与实现者解耦？”变得很重要，命令模式就能很好地解决这个问题。

在现实生活中，命令模式的例子也很多。比如看电视时，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者）。

再比如，我们去餐厅吃饭，菜单不是等到客人来了之后才定制的，而是已经预先配置好的。这样，客人来了就只需要点菜，而不是任由客人临时定制。餐厅提供的菜单就相当于把请求和处理进行了解耦，这就是命令模式的体现。

定义与特点

命令（Command）模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

优点

通过引入中间件（抽象接口）降低系统的耦合度。
扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。
可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。

缺点

可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解。
命令模式的结构与实现
可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离，其结构如下。

结构

抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

实现

命令模式的代码如下：

package command;

public class CommandPattern {

    public static void main(String[] args) {

        Command cmd = new ConcreteCommand();

        Invoker ir = new Invoker(cmd);

        System.out.println("客户访问调用者的call()方法...");

        ir.call();

    }

}

//调用者

class Invoker {

    private Command command;

    public Invoker(Command command) {

        this.command = command;

    }

    public void setCommand(Command command) {

        this.command = command;

    }

    public void call() {

        System.out.println("调用者执行命令command...");

        command.execute();

    }

}

//抽象命令

interface Command {

    public abstract void execute();

}

//具体命令

class ConcreteCommand implements Command {

    private Receiver receiver;

    ConcreteCommand() {

        receiver = new Receiver();

    }

    public void execute() {

        receiver.action();

    }

}

//接收者

class Receiver {

    public void action() {

        System.out.println("接收者的action()方法被调用...");

    }

}

程序的运行结果如下：

客户访问调用者的call()方法...

调用者执行命令command...

接收者的action()方法被调用...

实例

假如我们开发一个播放器，播放器播放功能、拖动进度条功能、停止播放功能、暂停功能，我们在操作播发器的时候并不知道之间调用播放器
哪个功能，而是通过一个控制传达去传递指令给播放器内核，具体传达什么指令，会被封装成一个个按钮。那么每个按钮就相当于一条命令的封装。
用控制条实现了用户发送指令与播放器内核接收指令的解耦。下面来看代码，首先创建播放器内核类：

public class GPlayer {

    public void play() {

        System.out.println("正常播放");

    }



    public void speed() {

        System.out.println("拖动进度条");

    }



    public void stop() {

        System.out.println("停止播放");

    }



    public void pause() {

        System.out.println("暂停播放");

    }

}

创建命令接口：

public interface IAction {

    void execute();

}

创建播放指令类：

public class PlayAction implements IAction {

    private GPlayer gplayer;



    public PlayAction(GPlayer gplayer) {

        this.gplayer = gplayer;

    }



    public void execute() {

        gplayer.play();

    }

}

创建暂停指令类：

public class PauseAction implements IAction {

    private GPlayer gplayer;



    public PauseAction(GPlayer gplayer) {

        this.gplayer = gplayer;

    }



    public void execute() {

        gplayer.pause();

    }

}

创建拖动进度条类：

public class SpeedAction implements IAction {

    private GPlayer gplayer;



    public SpeedAction(GPlayer gplayer) {

        this.gplayer = gplayer;

    }



    public void execute() {

        gplayer.speed();

    }

}

创建停止播放指令：

public class StopAction implements IAction {

    private GPlayer gplayer;



    public StopAction(GPlayer gplayer) {

        this.gplayer = gplayer;

    }



    public void execute() {

        gplayer.stop();

    }

}

创建控制条controller类：

public class Controller {

    private List<IAction> actions = new ArrayList<IAction>();



    public void addAction(IAction action) {

        actions.add(action);

    }



    public void execute(IAction action) {

        action.execute();

    }



    public void executes() {

        for (IAction action : actions) {

            action.execute();

        }

        actions.clear();

    }

}

从上面代码来看，控制条可以执行单条命令，也可以批量执行多条命令。下面看客户端的测试代码：

public class Test {

    public static void main(String[] args) {



        GPlayer player = new GPlayer();

        Controller controller = new Controller();

        controller.execute(new PlayAction(player));



        controller.addAction(new PauseAction(player));

        controller.addAction(new PlayAction(player));

        controller.addAction(new StopAction(player));

        controller.addAction(new SpeedAction(player));

        controller.executes();

    }

}

由于控制条已经与播放器内核解耦了，以后如果想扩展新命令，只需要增加命令即可，控制条的结构无须改动。

java源码中的命令模式

首先来看 JDK 中的 Runnable 接口，Runnable 相当于命令模式中的抽象命令角色。Runnable 中的 run() 方法就当于 execute() 方法。

public interface Runnable {

    public abstract void run();

}

public class T implements Runnable {

    @Override

    public void run() {

        LazySingleton lazySingleton = LazySingleton.getInstance();

        System.out.println(Thread.currentThread().getName() + " : " + lazySingleton);

    }

}



public class Test {

    public static void main(String[] args) {

        Thread t1 = new Thread(new T());

        Thread t2 = new Thread(new T());

        t1.start();

        t2.start();

        System.out.println("Program End");

    }

}

只要是实现了 Runnable 接口的类都被认为是一个线程，相当于命令模式中的具体命令角色。

实际上调用线程的 start() 方法之后，就有资格去抢 CPU 资源，而不需要编写获得 CPU 资源的逻辑。而线程抢到 CPU 资源后，就会执行 run() 方法中的内容，用 Runnable 接口把用户请求和 CPU 执行进行解耦。

前言

在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。

既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：

1. 暴露了聚合类的内部表示，使其数据不安全；
2. 增加了客户的负担。

“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

迭代器模式在生活中应用的比较广泛，比如：物流系统中的传送带，不管传送的是什么物品，都会被打包成一个个箱子，并且有一个统一的二维码。这样我们不需要关心箱子里是什么，在分发时只需要一个个检查发送的目的地即可。再比如，我们平时乘坐交通工具，都是统一刷卡或者刷脸进站，而不需要关心是男性还是女性、是残疾人还是正常人等信息。

定义与特点

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式

优点

• 访问一个聚合对象的内容而无须暴露它的内部表示。
• 遍历任务交由迭代器完成，这简化了聚合类。
• 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
• 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点

增加了类的个数，这在一定程度上增加了系统的复杂性。

在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的 API 完全够用。

结构

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。

• 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
• 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
• 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
• 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

模式的实现

package net.biancheng.c.iterator;

import java.util.*;

public class IteratorPattern {

    public static void main(String[] args) {

        Aggregate ag = new ConcreteAggregate();

        ag.add("中山大学");

        ag.add("华南理工");

        ag.add("韶关学院");

        System.out.print("聚合的内容有：");

        Iterator it = ag.getIterator();

        while (it.hasNext()) {

            Object ob = it.next();

            System.out.print(ob.toString() + "\t");

        }

        Object ob = it.first();

        System.out.println("\nFirst：" + ob.toString());

    }

}

//抽象聚合

interface Aggregate {

    public void add(Object obj);

    public void remove(Object obj);

    public Iterator getIterator();

}

//具体聚合

class ConcreteAggregate implements Aggregate {

    private List<Object> list = new ArrayList<Object>();

    public void add(Object obj) {

        list.add(obj);

    }

    public void remove(Object obj) {

        list.remove(obj);

    }

    public Iterator getIterator() {

        return (new ConcreteIterator(list));

    }

}

//抽象迭代器

interface Iterator {

    Object first();

    Object next();

    boolean hasNext();

}

//具体迭代器

class ConcreteIterator implements Iterator {

    private List<Object> list = null;

    private int index = -1;

    public ConcreteIterator(List<Object> list) {

        this.list = list;

    }

    public boolean hasNext() {

        if (index < list.size() - 1) {

            return true;

        } else {

            return false;

        }

    }

    public Object first() {

        index = 0;

        Object obj = list.get(index);

        ;

        return obj;

    }

    public Object next() {

        Object obj = null;

        if (this.hasNext()) {

            obj = list.get(++index);

        }

        return obj;

    }

}

运行结果

聚合的内容有：中山大学    华南理工    韶关学院   

First：中山大学

java源码分析

Iterator

public interface Iterator<E> {



    boolean hasNext();



    E next();



    default void remove() {

        throw new UnsupportedOperationException("remove");

    }



    //剩余元素迭代

    default void forEachRemaining(Consumer<? super E> action) {

        Objects.requireNonNull(action);

        while (hasNext())

            action.accept(next());

    }

}

上面是迭代器Iterator接口的代码，定义了一些需要子类实现的方法和默认的方法。在这里说一下上面两个default方法都是JDK1.8之后才有的接口新特性，在JDK1.8之前接口中不能有方法实体。

ArrayList

public class ArrayList<E> extends AbstractList<E>

        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

{

    private class Itr implements Iterator<E> {

        int cursor;       // index of next element to return

        int lastRet = -1; // index of last element returned; -1 if no such

        int expectedModCount = modCount;



        public boolean hasNext() {

            return cursor != size;

        }



        @SuppressWarnings("unchecked")

        public E next() {

            checkForComodification();

            int i = cursor;

            if (i >= size)

                throw new NoSuchElementException();

            Object[] elementData = ArrayList.this.elementData;

            if (i >= elementData.length)

                throw new ConcurrentModificationException();

            cursor = i + 1;

            return (E) elementData[lastRet = i];

        }



        public void remove() {

            if (lastRet < 0)

                throw new IllegalStateException();

            checkForComodification();



            try {

                ArrayList.this.remove(lastRet);

                cursor = lastRet;

                lastRet = -1;

                expectedModCount = modCount;

            } catch (IndexOutOfBoundsException ex) {

                throw new ConcurrentModificationException();

            }

        }



        @Override

        @SuppressWarnings("unchecked")

        public void forEachRemaining(Consumer<? super E> consumer) {

            Objects.requireNonNull(consumer);

            final int size = ArrayList.this.size;

            int i = cursor;

            if (i >= size) {

                return;

            }

            final Object[] elementData = ArrayList.this.elementData;

            if (i >= elementData.length) {

                throw new ConcurrentModificationException();

            }

            while (i != size && modCount == expectedModCount) {

                consumer.accept((E) elementData[i++]);

            }

            // update once at end of iteration to reduce heap write traffic

            cursor = i;

            lastRet = i - 1;

            checkForComodification();

        }



        final void checkForComodification() {

            if (modCount != expectedModCount)

                throw new ConcurrentModificationException();

        }

    }

}

上面是简化的ArrayList类，因为具体实现迭代器Itr的类在ArrayList中作为内部类存在，这个内部类将接口中的方法做了具体实现，并且是只对ArrayList这个类进行实现的。

public interface List<E> extends Collection<E> {

    Iterator<E> iterator();

}

上面是简化的List接口，充当的是聚合接口，可以看见内部创建了相应迭代器接口的方法。

public class ArrayList<E> extends AbstractList<E>

        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

{

    public Iterator<E> iterator() {

        return new Itr();

    }

}

上面是简化的ArrayList类，充当的是具体聚合类角色，在这里是直接返回了一个具体实现迭代器的类。

public class Test1 {



    public static void main(String[] args) {

      List<Integer> a=new ArrayList<>();

      a.add(1);

      a.add(2);

      a.add(3);

      Iterator itr=a.iterator();

      while(itr.hasNext()){

          System.out.println(itr.next());

      }

    }

}

前言

在现实生活中，常常会出现好多对象之间存在复杂的交互关系，这种交互关系常常是“网状结构”，它要求每个对象都必须知道它需要交互的对象。例如，每个人必须记住他（她）所有朋友的电话；而且，朋友中如果有人的电话修改了，他（她）必须让其他所有的朋友一起修改，这叫作“牵一发而动全身”，非常复杂。

如果把这种“网状结构”改为“星形结构”的话，将大大降低它们之间的“耦合性”，这时只要找一个“中介者”就可以了。如前面所说的“每个人必须记住所有朋友电话”的问题，只要在网上建立一个每个朋友都可以访问的“通信录”就解决了。这样的例子还有很多，例如，你刚刚参加工作想租房，可以找“房屋中介”；或者，自己刚刚到一个陌生城市找工作，可以找“人才交流中心”帮忙。

在软件的开发过程中，这样的例子也很多，例如，在 MVC 框架中，控制器（C）就是模型（M）和视图（V）的中介者；还有大家常用的 QQ 聊天程序的“中介者”是 QQ 服务器。所有这些，都可以采用“中介者模式”来实现，它将大大降低对象之间的耦合性，提高系统的灵活性。
模式的定义与特点

定义

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

优点

类之间各司其职，符合迪米特法则。
降低了对象之间的耦合性，使得对象易于独立地被复用。
将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

缺点

中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。
模式的结构与实现
中介者模式实现的关键是找出“中介者”，下面对它的结构和实现进行分析。

结构

抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

实现

中介者模式的实现代码如下：

package net.biancheng.c.mediator;

import java.util.*;

public class MediatorPattern {

    public static void main(String[] args) {

        Mediator md = new ConcreteMediator();

        Colleague c1, c2;

        c1 = new ConcreteColleague1();

        c2 = new ConcreteColleague2();

        md.register(c1);

        md.register(c2);

        c1.send();

        System.out.println("-------------");

        c2.send();

    }

}

//抽象中介者

abstract class Mediator {

    public abstract void register(Colleague colleague);

    public abstract void relay(Colleague cl); //转发

}

//具体中介者

class ConcreteMediator extends Mediator {

    private List<Colleague> colleagues = new ArrayList<Colleague>();

    public void register(Colleague colleague) {

        if (!colleagues.contains(colleague)) {

            colleagues.add(colleague);

            colleague.setMedium(this);

        }

    }

    public void relay(Colleague cl) {

        for (Colleague ob : colleagues) {

            if (!ob.equals(cl)) {

                ((Colleague) ob).receive();

            }

        }

    }

}

//抽象同事类

abstract class Colleague {

    protected Mediator mediator;

    public void setMedium(Mediator mediator) {

        this.mediator = mediator;

    }

    public abstract void receive();

    public abstract void send();

}

//具体同事类

class ConcreteColleague1 extends Colleague {

    public void receive() {

        System.out.println("具体同事类1收到请求。");

    }

    public void send() {

        System.out.println("具体同事类1发出请求。");

        mediator.relay(this); //请中介者转发

    }

}

//具体同事类

class ConcreteColleague2 extends Colleague {

    public void receive() {

        System.out.println("具体同事类2收到请求。");

    }

    public void send() {

        System.out.println("具体同事类2发出请求。");

        mediator.relay(this); //请中介者转发

    }

}

程序的运行结果如下：

具体同事类1发出请求。

具体同事类2收到请求。

-------------

具体同事类2发出请求。

具体同事类1收到请求。

应用场景

前面分析了中介者模式的结构与特点，下面分析其以下应用场景。
当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

java源码中的体现

在看其他人写的关于Timer 的中介者设计模式，我觉得写的都不是很清楚。我大概用源码来解释一下，顺便再分析一下Timer的所有关联类的源码：

private void sched(TimerTask task, long time, long period) {

        if (time < 0)

            throw new IllegalArgumentException("Illegal execution time.");



        // Constrain value of period sufficiently to prevent numeric

        // overflow while still being effectively infinitely large.

        if (Math.abs(period) > (Long.MAX_VALUE >> 1))

            period >>= 1;



        synchronized(queue) {

            if (!thread.newTasksMayBeScheduled)

                throw new IllegalStateException("Timer already cancelled.");



            synchronized(task.lock) {

                if (task.state != TimerTask.VIRGIN)

                    throw new IllegalStateException(

                        "Task already scheduled or cancelled");

                task.nextExecutionTime = time;

                task.period = period;

                task.state = TimerTask.SCHEDULED;

            }



            queue.add(task);

            if (queue.getMin() == task)

                queue.notify();

        }

    }

说明：所有的schedule方法都调用了sched ，那这个类的主要作用是啥呢？

将timertask加入到队列里，然后从队列里取出min任务（二叉堆的数据结构，下面会说明），判断如果min任务等于当前任务的话让队列wait的状态变为运行状态，如果不等于的话，那么线程的mainloop方法肯定是一直再运行状态的，其他任务就可以依次执行

看如下的源码

private void mainLoop() {

        while (true) {

            try {

                TimerTask task;

                boolean taskFired;

                synchronized(queue) {

                    // Wait for queue to become non-empty

                    while (queue.isEmpty() && newTasksMayBeScheduled)

                        queue.wait();

                    if (queue.isEmpty())

                        break; // Queue is empty and will forever remain; die



                    // Queue nonempty; look at first evt and do the right thing

                    long currentTime, executionTime;

                    task = queue.getMin();

                    synchronized(task.lock) {

                        if (task.state == TimerTask.CANCELLED) {

                            queue.removeMin();

                            continue;  // No action required, poll queue again

                        }

                        currentTime = System.currentTimeMillis();

                        executionTime = task.nextExecutionTime;

                        if (taskFired = (executionTime<=currentTime)) {

                            if (task.period == 0) { // Non-repeating, remove

                                queue.removeMin();

                                task.state = TimerTask.EXECUTED;

                            } else { // Repeating task, reschedule

                                queue.rescheduleMin(

                                  task.period<0 ? currentTime   - task.period

                                                : executionTime + task.period);

                            }

                        }

                    }

                    if (!taskFired) // Task hasn't yet fired; wait

                        queue.wait(executionTime - currentTime);

                }

                if (taskFired)  // Task fired; run it, holding no locks

                    task.run();

            } catch(InterruptedException e) {

            }

        }

    }

Timer相当于中介者来执行队列里的任务，用户只管将任务抛给timer就可以了。

如下详细timer源码分析

在Java中，很常见的一个定时器的实现就是 Timer 类，用来实现定时、延迟执行、周期性执行任务的功能。

Timer 是定义在 java.util 中的一个工具类，提供简单的实现定时器的功能。和它配合使用的，是 TimerTask 类，这是对一个可以被调度的任务的封装。使用起来非常简单，如下示例：

// 定义一个可调度的任务，继承自 TimerTask

class FooTimerTask extends TimerTask {



    @Override

    public void run() {

        // do your things

    }

}



// 初始化Timer 定时器对象

Timer timer = new Timer("barTimer");



// 初始化需要被调度的任务对象

TimerTask task = new FooTimerTask();



// 调度任务。延迟1000毫秒后执行，之后每2000毫秒定时执行一次

timer.schedule(task, 1000, 2000);

以上，就是一个简单的使用Timer 的示例，下文将会分析Timer的源码实现。

概述

在Timer 机制中，涉及到的关键类如下：

• Timer: 主要的调用的，提供对外的API；
• TimerTask: 是一个抽象类，定义一个任务，继承自Runnable
• TimerThread: 继承自 Thread，是一个自定义的线程类；
• TaskQueue: 一个任务队列，包含有当前Timer的所有任务，内部使用二叉堆来实现。

以上几个关键类的引用关系如下：

简要描述的话，是：

1个 TimerThread —-> 实现1个 线程

1个 Timer对象 —-> 持有1个 TimerThread 对象

1个 Timer对象 —-> 持有1个 TimerQueue 对象

1个 TimerQueue 对象 —-> 持有 n个 TimerTask 对象

源码分析

Timer类的源码分析
源码分析的话，我们最好是按照Timer 的使用流程来分析。 首先，是Timer 的创建：

// Timer有四个构造方法，但是本质上其实是做的相同的事情，即

// 1. 使用name 和 isDeamon 两个参数给 thread 对象做了参数设置；

// 2. 调用 thread 的 start() 方法启动线程

public Timer() {

    this("" + serialNumber());

}



public Timer(boolean isDaemon) {

    this("" + serialNumber(), isDaemon);

}





public Timer(String name) {

    thread.setName(name);

    thread.start();

}



public Timer(String name, boolean isDaemon) {

    thread.setName(name);

    thread.setDaemon(isDaemon);

    thread.start();

}

那么，或许大家会有一个疑问，thread 成员的初始化呢？这个时候，在代码里面找，就能发现：

// 这两个成员都是直接在声明的时候进行了初始化。

private final TaskQueue queue = new TaskQueue();

private final TimerThread thread = new TimerThread(queue);

可以看到 thread 和 queue两个成员都是在声明的时候直接初始化的，并且有意思的是，两个成员都是 final 类型的，这也就意味着这两个成员一旦创建就不会再改了，等于说把 thread、queue 和 Timer 对象这三者的生命周期强行绑定在一起了，大家一起创建，并且一经创建将会无法改变。

然后，创建了Timer 后，与之相关的队列也已经创建成功，而且相关联的线程也启动了，就可以进行任务的调度了，我们看下它的任务调度方法：

// Timer 包含有一组重载方法，参数为以下几个：

// 1. TimerTask task：需要被调度的任务

// 2. long delay: 指定延迟的时间；

// 3. long period: 指定调度的执行周期；

schedule(TimerTask task, long delay, long period)

多个重载的调度方法在经过一些一些列的状态判断、参数设置、以及把delay时间转换成实际的执行时间等之后， 最终完成该功能的是 sched 方法，详情见注释部分:

这里涉及到一个需要留意的点，是在调用schedule 方法的时候，会根据TimerTask 的类型来进行不同的计算，进而给TimerTask设置不同的 period 参数，TimerTask 的类型有以下几种：

• 非周期性任务；对应 TimerTask.period 值为0；
• 周期性任务，但是没有delay值，即立即执行；对应 TimerTask.period 值为正数；
• 周期性任务，同时包含有 delay值；对应 TimerTask.period 值为负数；

在schedule 方法中，会

// 执行任务调度的方法

// 这里的 time 已经是经过转换的，表示该task 需要被执行的时间戳

private void sched(TimerTask task, long time, long period) {

    // 参数的合法性检查

    if (time < 0)

        throw new IllegalArgumentException("Illegal execution time.");



    if (Math.abs(period) > (Long.MAX_VALUE >> 1))

        period >>= 1;



    // 核心的调度逻辑

    // 由于是在多线程环境中使用的，这里为了保证线程安全，使用的是 synchronized 代码段

    // 对象锁使用的是在 Timer 对象中唯一存在的 queue 对象

    synchronized(queue) {



        // thread.newTasksMayBeScheduled 是一个标识位，在timer cancel之后 或者 thread 被停止后该标识位会被设为false

        // newTasksMayBeScheduled 为false 则表示该timer 的关联线程已经停止了。

        if (!thread.newTasksMayBeScheduled)

            throw new IllegalStateException("Timer already cancelled.");



        // 这里是把外部的参数，如执行时间点、执行周期、设置状态等等。

        // 这里为了线程安全的考虑，使用对 task 内部的 lock 对象加锁来保证。

        synchronized(task.lock) {

            if (task.state != TimerTask.VIRGIN)

                throw new IllegalStateException(

                    "Task already scheduled or cancelled");

            task.nextExecutionTime = time;

            task.period = period;

            task.state = TimerTask.SCHEDULED;

        }



        // 最后，把新的 task 添加到关联队列里面

        queue.add(task);



        // 这里，会使用打 TimerQueue 对象的 getMin() 方法，这个方法是获取到接下来将要被执行的TimerTask 对象

        // 这里的逻辑是check 新添加的 task 对象是不是接下来马上会被执行

        // 如果刚添加的对象是需要马上执行的话，会使用  queue.notify 来通知在等待的线程。



        // 那么，会有谁在等待这个 notify 呢？是TimerThread 内部，TimerThread 会有一个死循环，在不停从queue中取任务来执行

        // 当queue为空的时候，TimerThread 会进行 queue.wait() 来进行休眠的状态，直到有新的来任务来唤醒它

        // 下面的代码就是，当queue为空的时候，这个判断条件会成立，然后就通知 TimerThread 重新唤醒

        // 当然，下面的条件成立也不全是 queue 为空的情况下

        if (queue.getMin() == task)

            queue.notify();

    }

}

TimerTask 的源码分析

接下来，本文将会分析 TimerTask 的源码。相对于Timer 来说，它的源码其实很简单，TimerTask 是实现了Runnable 接口，同时也是一个抽象类，它并没有对 Runnable 的 run() 方法提供实现，而是需要子类来实现。

它对外提供了以下几个功能：

包含有一段可以执行的代码（实现的Runnable 接口的run方法）
包含状态的定义。它有一个固定的状态：VIRGIN（新创建）、SCHEDULED（被调度进某一个 timer 的队列中了，但是还没有执行到）、EXECUTED（以及执行过了）、CANCELLED（任务被取消了）。
包含有取消的方法。
包含有获取下一次执行时间的方法。

相关的源码如下：

// 取消该任务

public boolean cancel() {

    synchronized(lock) {

        boolean result = (state == SCHEDULED);

        state = CANCELLED;

        return result;

    }

}



// 根据执行周期，和设置的执行时间，来确定Task的下一次执行时间。

public long scheduledExecutionTime() {

    synchronized(lock) {

        // 其中，period 的值分为3种情况：

        // 取值为0: 表示该Task是非周期性任务；

        // 取值为正数: 表示该Task 是立即执行没有delay的周期性任务，period 的数值表示该Task 的周期

        // 取值为负数: 表示该Task 是有 delay 的周期性任务，period 相反数是该Task 的周期

        return (period < 0 ? nextExecutionTime + period

                           : nextExecutionTime - period);

    }

}

TimerThread 的源码分析

TimerThread 首先是一个 Thread 的子类，而且我们知道，在Java中，一个Thread 的对象就是代表了一个JVM虚拟机线程。那么，这个 TimerThread 其实也就是一个线程。

对于一个线程来说，那么它的关键就是它的 run() 方法，在调用线程的 start() 方法启动线程之后，接下来就会执行线程的 run() 方法,我们看下 TimerThread 的run() 方法：

public void run() {

    try {

        // 启动 mainLoop() 方法，这是一个阻塞方法，正常情况下会一只阻塞在这里

        // 当 mainLoop() 执行完毕的时候，也即是这个线程退出的时候。

        mainLoop();

    } finally {

        // Someone killed this Thread, behave as if Timer cancelled

        // 做一些收尾工作

        synchronized(queue) {

            newTasksMayBeScheduled = false;

            queue.clear();  // Eliminate obsolete references

        }

    }

}

从以上可以明确得看出，TimerThread 里的实现是调用 mainLoop() 启动了一个死循环，这个死循环内部的工作就是这个线程的具体工作了，一旦线程的死循环执行完毕，线程的 run 方法就执行完了，线程紧接着就退出了。熟悉Android的朋友可能已经觉得这里的实现非常眼熟了，没错，这里的实现和Android平台的 Handler + HandlerThread + Looper 的机制非常相像，可以认为Android平台最初研发这套机制的时候，就是参考的Timer 的机制，然后在上面做了些升级和适合Android平台的一些改动。

下面是 mainLoop() 方法：

private void mainLoop() {

    // 一个死循环

    while (true) {

        try {

            TimerTask task;

            boolean taskFired;

            synchronized(queue) {

                // 会等待到队列不为空，结合上面章节的分析，我们可以确定在新添加 TimerTask 到queue中的时候

                // 会触发到 queue.notify() 然后通知到这里。

                while (queue.isEmpty() && newTasksMayBeScheduled)

                    queue.wait();



                // queue 为空，说明 timer 被取消了

                if (queue.isEmpty())

                    break; // Queue is empty and will forever remain; die





                long currentTime, executionTime;

                // 又一次看到这个 queue.getMin() ，这个是根据接下来的执行时间来获取下一个需要被执行的任务

                task = queue.getMin();



                // 需要修改 task对象的内部数值，使用synchronized 保证线程安全

                synchronized(task.lock) {

                    // TimerTask 有多种状态，一旦一个 TimerTask 被取消之后，它就不会被执行了。

                    if (task.state == TimerTask.CANCELLED) {

                        queue.removeMin();

                        continue;  // No action required, poll queue again

                    }



                    // 获取到当前时间，和这个取出来的task 的下一次执行时间

                    currentTime = System.currentTimeMillis();

                    executionTime = task.nextExecutionTime;



                    // 这里会check 当前这个 task 是不是已经到时间了

                    // 这里会把是否到时间了这个状态保存在 taskFired 里面

                    if (taskFired = (executionTime<=currentTime)) {

                        // 根据上文的分析，TimerTask 根据 task.period 值的不同，被分为3种类型

                        // 这里的 task.period == 0 的情况，是对应于一个非周期性任务

                        if (task.period == 0) {

                            // 非周期性任务，处理完就完事了，改状态，移除队列

                            queue.removeMin();

                            task.state = TimerTask.EXECUTED;

                        } else {

                            // 周期性任务，会被重新调度，也不会被移除队列

                            queue.rescheduleMin(

                              task.period<0 ? currentTime   - task.period

                                            : executionTime + task.period);

                        }

                    }

                }



                // 这里是另一个会等待的地方，这个是为了等待任务的到期，等待时间就是距离到执行之间的时长

                if (!taskFired)

                    queue.wait(executionTime - currentTime);

            }



            // taskFired 变量经过上面的步骤以及判断过了，如果是 true，说明task以及到时间了

            // 到时间就运行完事。

            if (taskFired)

                task.run();

        } catch(InterruptedException e) {

        }

    }

}

TimerThread 中除了上面的主要逻辑之外，还有一些需要关注的地方，那就是它持有一个 TimerQueue 的对象，这个对象是在创建的时候外部传进来的，也是和当前的Timer 关联的TimerQueue：

// 这里的官方注释，说明了为什么是在TimerThread 中引用了 TimerQueue而不是引用了 Timer。

// 这么做是为了避免循环引用（因为Timer中引用了TimerThread），进而避免循环引用可能导致的JVM gc 失败的问题

// 我们都知道，Java 是一门通用的语言，虽然官方的HotSpot JVM中是能解决循环引用的GC问题的，但是这并不意味着

// 其他第三方的JVM也能解决循环引用导致的GC问题，所以这里干脆就避免了循环引用。



/**

 * Our Timer's queue.  We store this reference in preference to

 * a reference to the Timer so the reference graph remains acyclic.

 * Otherwise, the Timer would never be garbage-collected and this

 * thread would never go away.

 */

private TaskQueue queue;

TimerQueue 的源码分析（主要是实现一个二叉堆）

TimerQueue 的逻辑上是一个队列，所有它包含有一个队列常见的那些方法，如 size()、add()、clear()等方法。下面我们找一些重要的方法进行分析：

首先，在上文的分析中，我们以及见过TimeQueue 的 getMin() 方法了，这个方法是获取当前的队列里面，接下来应该被执行的TimerTask，也就是说，是执行时间点 数值最小的那一个，那么我们就先看下它的源码：

/**

 * Return the "head task" of the priority queue.  (The head task is an

 * task with the lowest nextExecutionTime.)

 */

TimerTask getMin() {

    return queue[1];

}

What??? 就这吗？为啥这么简单？为啥就返回 queue[1] 就对了？

你是不是也有这样的疑问，那么带着疑问往下看吧。

接下来，是添加一个TimerTask 到队列中：

// 内部存放TimerTask 数据的，是一个数组，设置的数组初始大小是128

private TimerTask[] queue = new TimerTask[128];



// 存放当前的TimerTask 的数量

// 而且 TimerTask 是存放在 [1 - size] 位置的，数组的第0位置没有数据

// 至于为什么要 存放在 [1 - size] 请看下文。 

private int size = 0;



/**

 * Adds a new task to the priority queue.

 */

void add(TimerTask task) {

    // check 下数据的容量是否还够添加，不够的话会先进行数组的扩容

    // 这扩容一次就是2倍增加

    if (size + 1 == queue.length)

        queue = Arrays.copyOf(queue, 2*queue.length);



    // 把新的TimerTask 放在数组的最后一个位置

    // size 的初始化值是0，从这里可以看出来，这里会先把size自增1，然后再添加到数组中

    // 其实是从数组位置的 1 开始添加 TimerTask 的，0的位置是空的

    queue[++size] = task;



    // 然后调用了这个数据上浮的方法

    fixUp(size);

}

从上文看出，add 方法本身也没什么奇特的，就是很简单地把新的 TimerTask 放在了数据的最新的位置，只是里面调用了一下另一个方法 fixUp() ，好，那么我们接着分析这个方法：

// 从上文可以看出，参数 k 是当前的数组size 值，也是最后一个TimerTask 的下标索引

private void fixUp(int k) {

    // 首先，这是一个循环，循环条件是 k > 1

    while (k > 1) {

        // 位运算，操作，把 k 右移一位，得到的结果是：偶数相当于除以2，奇数相当于先减1再除以2

        int j = k >> 1;



        // 比较 j 和 k 两个位置的下次执行时间，j 不大于 k 的话，就停止循环了

        if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)

            break;



        // j 大于 k 位置的时间的话，就要进行下面的动作

        // 这是一个典型的交换操作

        TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;



        // k 值缩小到j，去逼近循环条件 k>1

        k = j;

    }

}

看了上面对 fixUp() 的分析，是不是仍然一脸懵？或许也有些熟悉算法的朋友已经觉察出些什么了，那么这个地方的逻辑是什么呢？

有了右移一位、[1, size]的区间等蛛丝马迹，我想聪明的你已经猜出来了，这个数组queue 里面，是存放了一个完全二叉树。

在发现 queue 数组是一个二叉树之后，再去理解上面的 fixUp() 方法其实就很简单了，里面的过程是这样的：

从二叉树的最后一个叶子结点开始循环；
获取这个叶子结点的父结点（完全二叉树中对应的父结点的索引是：子结点位运算右移一位得到的）
判断父结点和子结点中对应的 TimerTask 的 nextExecutionTime 的大小，如果父比子的小，则停止循环；如果父比子的大，则交互负责结点；
重复以上循环，直到遍历到根结点；

通过以上分析，能发现在每一次新增一个结点后，使用 fixUp()，方法直接对整个二叉树进行了重排序，使得 TimerTask 的nextExecutionTime 值最小的结点，永远被放置在了二叉树的根结点上，也即是queue[1]。这也就搞明白了为什么 getMin 的实现，是直接获取的 queue[1] 。

同样的道理，在每一次执行 Timer.purge() 方法，清理了TimerQueue中已经取消的Task之后，会执行另一个 fixDown() 方法，它的逻辑正好是和 fixUp() 相反的，它是从根结点开始遍历的，然后到达每一个叶子结点以整理这个二叉树，这里就不再赘述。

回过头来，我们再看下TimerQueue中的实现，会发现它其实是一个二叉堆，二叉堆是一个带有权重的二叉树，这里不再多说。

总结

通过以上的分析，总的来说，就是每一个 Timer对象中，包含有一个线程（TaskThread）和一个队列（TaskQueue）。TaskQueue 的实现是一个二叉堆（Binary Heap）的结构，二叉堆的每一个节点，就是 TimerTask 的对象。

使用方式

【最新版本号以这里为准】

由于JCenter关闭服务，从1.4.5版本开始改为发布到MavenCentral，引用方式有更新！！！
由于JCenter关闭服务，从1.4.5版本开始改为发布到MavenCentral，引用方式有更新！！！
由于JCenter关闭服务，从1.4.5版本开始改为发布到MavenCentral，引用方式有更新！！！

#last-version请查看上面的最新版本号



#只支持AndroidX



#从1.4.5版本开始GroupId、ArtifactId均有更新，请按如下方式引用

implementation "com.lwkandroid.library:rcvadapter:last-version"

基础功能

• 快速实现适配器，支持多种ViewType模式
• 支持添加HeaderView、FooterView、EmptyView
• 支持滑到底部加载更多
• 支持每条Item显示的动画
• 支持嵌套Section（1.1.0版本新增）
• 支持悬浮标签StickyLayout（1.2.0版本新增）

效果图

使用方式

1. 当Item样式一样时，只需继承RcvSingleAdapter<T>即可，示例：

public class TestSingleAdapter extends RcvSingleAdapter<TestData>

{

    public TestSingleAdapter(Context context, List<TestData> datas)

    {

        super(context, android.R.layout.simple_list_item_1, datas);

    }



    @Override

    public void onBindView(RcvHolder holder, TestData itemData, int position)

    {

	    //在这里绑定UI和数据，RcvHolder中提供了部分快速设置数据的方法，详情请看源码

        holder.setTvText(android.R.id.text1, itemData.getContent());

    }

}

2. 当Item样式不一样时，即存在多种ViewType类型的Item，需要将每种ViewType的Item单独实现，再关联到RcvMultiAdapter<T>中，示例：

//第一步：每种Item分别继承RcvBaseItemView<T>

public class LeftItemView extends RcvBaseItemView<TestData>

{

    @Override

    public int getItemViewLayoutId()

    {

	    //这里返回该Item的布局id

        return R.layout.layout_item_left;

    }



    @Override

    public boolean isForViewType(TestData item, int position)

    {

	    //这里判断何时引用该Item

        return position % 2 == 0;

    }



    @Override

    public void onBindView(RcvHolder holder, TestData testData, int position)

    {

	    //在这里绑定UI和数据，RcvHolder中提供了部分快速设置数据的方法，详情请看源码

        holder.setTvText(R.id.tv_left, testData.getContent());

    }

}



//第二步：将所有Item关联到适配器中

public class TestMultiAdapter extends RcvMultiAdapter<TestData>

{

    public TestMultiAdapter(Context context, List<TestData> datas)

    {

        super(context, datas);

        //只需在构造方法里将所有Item关联进来,无论多少种ViewType都轻轻松松搞定

        addItemView(new LeftItemView());

        addItemView(new RightItemView());

    }

}

3.优雅的添加HeaderView、FooterView、EmptyView，只需要在RecyclerView设置LayoutManager后调用相关方法即可：

//要先设置LayoutManager

mRecyclerView.setLayoutManager(new LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false));



//添加HeaderView(若干个)

mAdapter.addHeaderView(headerView01,headerView02,headerView03...);



//添加FooterView(若干个)

mAdapter.addFooterView(footerView01,footerView02,footerView03...);



//添加EmptyView（只能设置一个）

//设置了EmptyView后，当数据量为0的时候会显示EmptyView

mAdapter.setEmptyView(emptyView);

或者

mAdapter.setEmptyView(layoutId);

4.设置滑动到底部自动加载更多，先上示例代码吧：

自1.4.3版本开始删除了之前的调用方式

//可以先设置加载样式，继承RcvBaseLoadMoreView实现自定义样式

//不设置的话会使用默认的样式，参考RcvDefLoadMoreView源码

RcvDefLoadMoreView loadMoreView = new RcvDefLoadMoreView.Builder()

                .setBgColor(Color.GREEN)

                .setTextColor(Color.RED)

                .build(this);

mAdapter.setLoadMoreLayout(loadMoreView);

//再开启并设置监听

mAdapter.enableLoadMore(true);

mAdapter.setOnLoadMoreListener(RcvLoadMoreListener listener);

//禁止加载更多,通常用在配合下拉刷新的过程中

mAdapter.enableLoadMore(false);

注：
① 默认的样式实现是类RcvDefLoadMoreView
② 如需自定义样式，只需继承RcvBaseLoadMoreView，只要重写各状态UI的实现，无须关心状态切换，可参考RcvDefLoadMoreView内的实现方式。

5.设置Item显示动画，先直接上代码：

//使用默认的动画（Alpha动画）

mAdapter.enableItemShowingAnim(true);



//使用自定义动画

mAdapter.enableItemShowingAnim(true, ? extends RcvBaseAnimation);

注：
①默认动画的实现是类RcvAlphaInAnim
②自定义样式需要继承RcvBaseAnimation，可参考RcvAlphaInAnim内部实现。

6.设置Item点击监听：

    //设置OnItemClickListener

    mAdapter.setOnItemClickListener(new RcvItemViewClickListener<TestData>()

        {

            @Override

            public void onItemViewClicked(RcvHolder holder, TestData testData, int position)

            {

                //onClick回调

            }

        });



    //设置OnItemLongClickListener

    mAdapter.setOnItemLongClickListener(new RcvItemViewLongClickListener<TestData>()

        {

            @Override

            public void onItemViewLongClicked(RcvHolder holder, TestData testData, int position)

            {

                //onLongClick回调

            }

        });

7. 添加分割线，直接上代码：

1.2.9版本针对分割线进行了重写，原有方法不变，新增支持自定义颜色和部分快速创建的方法：

#适用于LinearLayoutManager

//创建默认竖直排列的分割线

RcvLinearDecoration.createDefaultVertical(Context context);

//创建自定义色值默认竖直排列的分割线

RcvLinearDecoration.createDefaultVertical(int color);

//创建默认水平排列的分割线

RcvLinearDecoration.createDefaultHorizontal(Context context);

//创建自定义色值默认水平排列的分割线

RcvLinearDecoration.createDefaultHorizontal(int color);

//构造方法：默认Drawable分割线

new RcvLinearDecoration(Context context, int orientation);

//构造方法：自定义Drawable分割线

new RcvLinearDecoration(Context context, Drawable drawable, int orientation);

//构造方法：自定义Drawable分割线

new RcvLinearDecoration(Context context, @DrawableRes int drawableResId, int orientation);

//构造方法：自定义Color分割线（宽度或者高度默认1px）

new RcvLinearDecoration(@ColorInt int color, int orientation);

//构造方法：自定义Color分割线

new RcvLinearDecoration(@ColorInt int color, int size, int orientation);



#适用于GridLayoutManager、StaggeredGridLayoutManager

//创建默认分割线

RcvGridDecoration.createDefault(Context context);

//创建自定义色值默认分割线

RcvGridDecoration.createDefault(int color);

//构造方法：默认Drawable的分割线

new RcvGridDecoration(Context context);

//构造方法：自定义Drawable的分割线

new RcvGridDecoration(Context context, Drawable drawable);

//构造方法：自定义Drawable的分割线

new RcvGridDecoration(Context context, @DrawableRes int drawableResId);

//构造方法：自定义Color的分割线（默认分割线宽高均为1px）

new RcvGridDecoration(@ColorInt int color);

//构造方法：自定义Color的分割线

new RcvGridDecoration(@ColorInt int color, int width, int height);

注：
①是直接设置给RecyclerView的，不是设置给适配器的，不要看错哦
②支持自定义drawable当分割线

8.嵌套Section，稍微复杂一点，配合代码讲解：

1.4.0版本开始删除以前的使用方法，采用下面的方式

带有Section功能的适配器为RcvSectionMultiLabelAdapter和RcvSectionSingleLabelAdapter,需要指定两个泛型，第一个代表Section，第二个代表普通数据Data， 两者都支持多种Data类型的子布局，唯一不同的是，RcvSectionMultiLabelAdapter还支持多种Section类型的子布局，但不可以和RcvStickyLayout联动，而RcvSectionSingleLabelAdapter 仅支持一种Section类型的子布局，但是可以和RcvStickyLayout联动。需要注意的是，传给适配器的数据均需要自行预处理，用RcvSectionWrapper封装后才可传入适配器。

#只有一种Section类型，配合多种Data类型的适配器

public class TestSectionAdapter extends RcvSectionSingleLabelAdapter<TestSection, TestData>

{

    public TestSectionAdapter(Context context, List<RcvSectionWrapper<TestSection, TestData>> datas)

    {

        super(context, datas);

    }



    @Override

    protected RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>[] createDataItemViews()

    {

        return new RcvBaseItemView[]{new DataItemView01(), new DataItemView02()};

    }



    @Override

    public int getSectionLabelLayoutId()

    {

        return R.layout.layout_section_label;

    }



    @Override

    public void onBindSectionLabelView(RcvHolder holder, TestSection section, int position)

    {

        holder.setTvText(R.id.tv_section_label, section.getSection());

    }



    //第一种Data ItemView

    private class DataItemView01 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.adapter_item_long;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return !item.isSection() && item.getData().getType() == 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            TextView textView = holder.findView(R.id.tv_item_long);

            textView.setBackgroundColor(Color.GREEN);

            textView.setText("第一种数据类型：" + wrapper.getData().getContent());

        }

    }



    //第二种Data ItemView

    private class DataItemView02 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.adapter_item_short;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return !item.isSection() && item.getData().getType() != 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            TextView textView = holder.findView(R.id.tv_item_short);

            textView.setBackgroundColor(Color.RED);

            textView.setText("第二种数据类型：" + wrapper.getData().getContent());

        }

    }

}



#多种Section类型，配合多种Data类型的适配器

public class TestSectionMultiLabelAdapter extends RcvSectionMultiLabelAdapter<TestSection, TestData>

{

    public TestSectionMultiLabelAdapter(Context context, List<RcvSectionWrapper<TestSection, TestData>> datas)

    {

        super(context, datas);

    }



    @Override

    protected RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>[] createLabelItemViews()

    {

        return new RcvBaseItemView[]{new LabelItemView01(), new LabelItemView02()};

    }



    @Override

    protected RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>[] createDataItemViews()

    {

        return new RcvBaseItemView[]{new DataItemView01(), new DataItemView02()};

    }





    //第一种Label ItemView

    private class LabelItemView01 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.layout_section_label;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return item.isSection() && item.getSection().getType() == 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            holder.setTvText(R.id.tv_section_label, wrapper.getSection().getSection());

        }

    }



    //第二种Label ItemView

    private class LabelItemView02 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.layout_section_label02;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return item.isSection() && item.getSection().getType() != 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            holder.setTvText(R.id.tv_section_label, wrapper.getSection().getSection());

        }

    }



    //第一种Data ItemView

    private class DataItemView01 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.adapter_item_long;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return !item.isSection() && item.getData().getType() == 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            TextView textView = holder.findView(R.id.tv_item_long);

            textView.setBackgroundColor(Color.GREEN);

            textView.setText("第一种数据类型：" + wrapper.getData().getContent());

        }

    }



    //第二种Data ItemView

    private class DataItemView02 extends RcvBaseItemView<RcvSectionWrapper<TestSection, TestData>>

    {

        @Override

        public int getItemViewLayoutId()

        {

            return R.layout.adapter_item_short;

        }



        @Override

        public boolean isForViewType(RcvSectionWrapper<TestSection, TestData> item, int position)

        {

            return !item.isSection() && item.getData().getType() != 0;

        }



        @Override

        public void onBindView(RcvHolder holder, RcvSectionWrapper<TestSection, TestData> wrapper, int position)

        {

            TextView textView = holder.findView(R.id.tv_item_short);

            textView.setBackgroundColor(Color.RED);

            textView.setText("第二种数据类型：" + wrapper.getData().getContent());

        }

    }

}

注：
①传给适配器的数据集合内实体类必须经过RcvSectionWrapper包装。
②向外公布的方法（例如点击监听）的实体类泛型不能传错。

9.悬浮标签StickyLayout

适配器方面无需改动，直接使用RcvSectionSingleLabelAdapter即可，在RecyclerView同级布局下添加RcvStickyLayout，然后在代码中关联起来即可：

    // xml布局中添加RcvStickyLayout：

    <FrameLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent">



        <android.support.v7.widget.RecyclerView

            android:id="@+id/rcv_sticky"

            android:layout_width="match_parent"

            android:layout_height="match_parent"/>



        <com.lwkandroid.rcvadapter.ui.RcvStickyLayout

            android:id="@+id/stickyLayout"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"/>

    </FrameLayout>







    //代码中关联RecyclerView

    RecyclerView recyclerView = (RecyclerView) findViewById(R.id.rcv_sticky);

    /...省略设置RecyclerView的LayoutMananger和Adapter.../

    RcvStickyLayout stickyLayout = (RcvStickyLayout) findViewById(R.id.stickyLayout);

    stickyLayout.attachToRecyclerView(recyclerView);

上面就是大部分基础功能的使用方法了，想了解更多方法请看源码。

混淆配置

-dontwarn com.lwkandroid.rcvadapter.**

-keep class com.lwkandroid.rcvadapter.**{*;}

待实现功能

• 暂时未想到

开源参考

1. https://github.com/hongyangAndroid/baseAdapter
2. https://github.com/CymChad/BaseRecyclerViewAdapterHelper

xLife

RxLife，相较于trello/RxLifecycle、uber/AutoDispose，具有如下优势：

• 直接支持在主线程回调
• 支持在子线程订阅观察者
• 简单易用，学习成本低
• 性能更优，在实现上更加简单

友情提示: RxLife与RxHttp搭配使用，味道更佳

RxLife详细介绍：https://juejin.im/post/5cf3e1235188251c064815f1

Gradle引用

将jitpack添加到项目的build.gradle文件中，如下：

allprojects {

    repositories {

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

    }

}

注：RxLife 2.1.0 版本起，已全面从JCenter迁移至jitpack

新版本仅支持AndroidX项目

dependencies {

   //kotlin协程

   implementation 'com.github.liujingxing.rxlife:rxlife-coroutine:2.1.0'



   //rxjava2

   implementation 'com.github.liujingxing.rxlife:rxlife-rxjava2:2.1.0'

       

   //rxjava3

   implementation 'com.github.liujingxing.rxlife:rxlife-rxjava3:2.1.0'

}

注意：RxJava2 使用Rxlife.asXxx方法；RxJava3使用Rxlife.toXxx方法

非AndroidX项目

非AndroidX项目，请使用旧版本RxLife

implementation 'com.rxjava.rxlife:rxlife:2.0.0'

由于Google在19年就停止了非AndroidX库的更新，故rxlife旧版本不再维护，请尽快将项目迁移至AndroidX

#Usage

1、FragmentActivity/Fragment

FragmentActivity/Fragment销毁时，自动关闭RxJava管道

Observable.timer(5, TimeUnit.SECONDS)

    .as(RxLife.as(this))     //此时的this FragmentActivity/Fragment对象

    .subscribe(aLong -> {

        Log.e("LJX", "accept =" + aLong);

    });

2、View

View被移除时，自动关闭RxJava管道

Observable.timer(5, TimeUnit.SECONDS)

    .as(RxLife.as(this))  //此时的this 为View对象

    .subscribe(aLong -> {

        Log.e("LJX", "accept =" + aLong);

    });

3、ViewModel

Activity/Fragment销毁时，自动关闭RxJava管道，ViewModel需要继承ScopeViewModel类，如下

public class MyViewModel extends ScopeViewModel {



    public MyViewModel(@NonNull Application application) {

        super(application);

    }

   

    public void test(){

        Observable.interval(1, 1, TimeUnit.SECONDS)

            .as(RxLife.asOnMain(this))  //继承ScopeViewModel后，就可以直接传this

            .subscribe(aLong -> {

                Log.e("LJX", "MyViewModel aLong=" + aLong);

            });

    }

}

注意: 一定要在Activity/Fragment通过以下方式获取ViewModel对象，否则RxLife接收不到生命周期的回调

MyViewModel viewModel = ViewModelProviders.of(this).get(MyViewModel.class);

4、任意类

Activity/Fragment销毁时，自动关闭RxJava管道，任意类需要继承BaseScope类，如P层：

public class Presenter extends BaseScope {



    public Presenter(LifecycleOwner owner) {

        super(owner); //添加生命周期监听

    }

    

    public void test(){

        Observable.interval(1, 1, TimeUnit.SECONDS)

            .as(RxLife.as(this)) //继承BaseScope后，就可以直接传this

            .subscribe(aLong -> {

                Log.e("LJX", "accept aLong=" + aLong);

            });

    }

}

5、kotlin用户

由于as是kotlin中的一个关键字，所以在kotlin中，我们并不能直接使用as(RxLife.as(this)),可以如下编写

Observable.intervalRange(1, 100, 0, 200, TimeUnit.MILLISECONDS)

    .`as`(RxLife.`as`(this))

    .subscribe { aLong ->

        Log.e("LJX", "accept=" + aLong)

    }

当然，相信没多少人会喜欢这种写法，故，RxLife针对kotlin用户，新增更为便捷的写法，如下：

Observable.intervalRange(1, 100, 0, 200, TimeUnit.MILLISECONDS)

    .life(this)

    .subscribe { aLong ->

        Log.e("LJX", "accept=" + aLong)

    }

使用life 操作符替代as操作符即可，其它均一样

6、小彩蛋

asOnMain操作符

RxLife还提供了asOnMain操作符，它可以指定下游的观察者在主线程中回调，如下：

Observable.timer(5, TimeUnit.SECONDS)

    .as(RxLife.asOnMain(this))

    .subscribe(aLong -> {

        //在主线程回调

       Log.e("LJX", "accept =" + aLong);

    });



        //等价于

Observable.timer(5, TimeUnit.SECONDS)

    .observeOn(AndroidSchedulers.mainThread())

    .as(RxLife.as(this))

    .subscribe(aLong -> {

        //在主线程回调

        Log.e("LJX", "accept =" + aLong);

    });

kotlin 用户使用lifeOnMain替代asOnMain操作符，其它均一样

注意: RxLife类里面as操作符，皆适用于Flowable、ParallelFlowable、Observable、Single、Maybe、Completable这6个被观察者对象

混淆

RxLife作为开源库，可混淆，也可不混淆，如果不希望被混淆，请在proguard-rules.pro文件添加以下代码

-keep class com.rxjava.rxlife.**{*;}

代码下载:327744707-rxjava-RxLife-master.zip

DialogUtilsApp

一、介绍

替换系统dialog风格后的通用提示框工具类，可以覆盖lib下的定义资源，改变现有的颜色风格，需要改变布局风格，可下载项目后自行调整

• APP 使用示例项目，libs下含有已编译最新的aar资源。
• dialogutilslib arr资源项目，需要引入的资源包项目。
• aar文件生成，在工具栏直接Gradle - (项目名) - dialogutilslib - Tasks - build - assemble，直到编译完成
• aar文件位置，打开项目所在文件夹，找到 dialogutilslib\build\outputs\aar 下。

二、工程引入工具包准备

下载项目，可以在APP项目的libs文件下找到DialogUtilsLib.aar文件（已编译为最新版），引入自己的工程 引入aar

dependencies {

   implementation files('libs/DialogUtilsLib-release.aar')

   ...

}

三、使用

注意下方只做了基础展示，dialog的都会返回对应的utils对象，registerActivityLifecycleCallbacks方法设置后，activity销毁时会自动把显示在此activity上的dialog一起关闭。

• application初始化设置

public class App extends Application {



    @Override

    public void onCreate() {

        super.onCreate();



        //初始化dialog工具类设置

        DialogLibInitSetting.getInstance()

                //设置debug

                .setDebug(BuildConfig.DEBUG)

                //注册全局activity生命周期监听

                .registerActivityLifecycleCallbacks(this);



    }

}

• 普通dialog

            DialogLibCommon.create(this)

                    .setMessage("普通对话框1")

                    .setAlias("text1")

                    .setOnBtnMessage(()->{

                        //描述区域点击时触发

                    })

                    .noShowCancel()

                    .show();

• 自定义dialog

            ImageView imageView = new ImageView(this);

            imageView.setImageDrawable(getResources().getDrawable(R.mipmap.ic_launcher));

            DialogLibCustom.create(this)

                    .noShowCancel()

                    .setAlias("text2")

                    .show(imageView);

• 输入型dialog

            DialogLibInput.create(this)

                    .setMessage("输入信息")

                    .setAlias("text3")

                    //自动弹出键盘

                    .setPopupKeyboard()

                    .setOnBtnOk(str -> {

                        Toast.makeText(MainActivity.this, str, Toast.LENGTH_SHORT).show();

                        return true;

                    })

                    .show();

• 等待型dialog

            DialogLibLoading.create(this)

                    .setTimeoutClose(2000)

                    .setAlias("text4")

                    .setOnLoading(() -> {

                        Toast.makeText(MainActivity.this, "我是显示对话框前触发的", Toast.LENGTH_SHORT).show();

                    })

                    .show();

• 完全自定义型dialog

            final DialogLibAllCustom dialog = DialogLibAllCustom.create(this)

                    .setCancelable(true)

                    .setAlias("text5");



            TextView view = new TextView(this);

            view.setBackgroundResource(R.color.design_default_color_secondary);

            view.setText("这是一个完全自定义布局的对话框，对话框显示后需要手动关闭");

            view.setOnClickListener(v2 -> {

                dialog.closeDialog();

            });



            dialog.show(view);

• 密码输入型dialog

              DialogLibInput.create(this)

                    .setMessage("123")

                    .setLength(6)

                    .setInputType(EditorInfo.TYPE_CLASS_NUMBER | EditorInfo.TYPE_NUMBER_VARIATION_PASSWORD)

                    .setAlias("text6")

                    //设置显示密码隐藏/显示图片

                    .setShowLookPassword()

                    //自动弹出键盘

                    .setPopupKeyboard()

                    .setOnBtnOk(str -> {

                        Toast.makeText(MainActivity.this, str, Toast.LENGTH_SHORT).show();

                        return true;

                    })

                    .show();

四、资源覆盖，改变颜色、字体大小、默认文字

• colors下可覆盖资源及注释，默认黑色和白色不建议覆盖，前景色：字体的颜色，背景色：布局的背景色

<resources>

    <!--黑色-->

    <color name="dialog_utils_lib_black">#FF000000</color>

    <!--白色-->

    <color name="dialog_utils_lib_white">#FFFFFFFF</color>



    <!--dialog的标题文字的前景色，适用于所有带标题的dialog-->

    <color name="dialog_utils_lib_title_fg">@color/dialog_utils_lib_black</color>

    <!--dialog的 确认 按钮文字的前景色-->

    <color name="dialog_utils_lib_ok_fg">@color/dialog_utils_lib_white</color>

    <!--dialog的 取消 按钮文字的前景色-->

    <color name="dialog_utils_lib_cancel_fg">@color/dialog_utils_lib_white</color>

    <!--dialog的 确认 按钮文字的背景色-->

    <color name="dialog_utils_lib_ok_bg">#22C5A3</color>

    <!--dialog的 取消 按钮文字的背景色-->

    <color name="dialog_utils_lib_cancel_bg">#F8A01A</color>

    <!--dialog的输入框下方显示2个按钮时，中间分隔的背景色-->

    <color name="dialog_utils_lib_button_split_bg">@color/dialog_utils_lib_white</color>



    <!--dialog的内容文字的前景色，适用于 DialogLibCommonUtils-->

    <color name="dialog_utils_lib_content_fg">@color/dialog_utils_lib_black</color>



    <!--dialog的输入框文字的前景色，适用于 DialogLibInputUtils-->

    <color name="dialog_utils_lib_input_fg">@color/dialog_utils_lib_black</color>

    <!--dialog的输入框下方分割线的背景色，适用于 DialogLibInputUtils-->

    <color name="dialog_utils_lib_input_split_line">@color/dialog_utils_lib_ok_bg</color>



    <!--dialog的加载框加载等待区域的背景色-->

    <color name="dialog_utils_lib_loading_content_bg">#FFc4c4c4</color>

    <!--dialog的加载框加载等待区域文字提示的前景色-->

    <color name="dialog_utils_lib_loading_content_text_fg">@color/dialog_utils_lib_white</color>

</resources>

• dimens下字体大小资源

<resources>

    <dimen name="dialog_utils_lib_text_size_normal">14sp</dimen>



    <!--标题字体大小，统一设定-->

    <dimen name="dialog_utils_lib_title_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>

    <!--确定 字体大小，统一设定-->

    <dimen name="dialog_utils_lib_ok_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>

    <!--取消 字体大小，统一设定-->

    <dimen name="dialog_utils_lib_cancel_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>

    <!--内容 字体大小，适用于 DialogLibCommonUtils的提示内容区域-->

    <dimen name="dialog_utils_lib_content_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>

    <!--输入框 字体大小，适用于 DialogLibInputUtils 输入区域-->

    <dimen name="dialog_utils_lib_input_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>

    <!--加载框 字体大小，适用于 DialogLibLoadingUtils 提示内容区域-->

    <dimen name="dialog_utils_lib_loading_text_size">@dimen/dialog_utils_lib_text_size_normal</dimen>



    <!--dialog 宽度占屏幕宽度的百分比，取值0-1之间，不包含边界，竖屏时的系数-->

    <item name="dialog_utils_lib_portrait_width_factor" format="float" type="dimen">0.85</item>

    <!--dialog 宽度占屏幕宽度的百分比，取值0-1之间，不包含边界，横屏时的系数-->

    <item name="dialog_utils_lib_landscape_width_factor" format="float" type="dimen">0.5</item>

</resources>

• strings下资源定义，注意：如果你的项目存在多语言，则必须覆盖

<resources>

    <string name="dialog_utils_lib_ok">确定</string>

    <string name="dialog_utils_lib_cancel">取消</string>

    <string name="dialog_utils_lib_default_title">提示</string>

    <string name="dialog_utils_lib_data_processing">数据处理中…</string>

</resources>

• mipmap下资源定义，注意：此2张图片为密码输入时显示/隐藏按钮的图片，png格式

dialog_utils_lib_password_hide 隐藏图片命名

dialog_utils_lib_password_show 显示图片命名

代码下载:mjsoftking-dialog-utils-app-master.zip

RxHttp

主要优势

1. 30秒即可上手，学习成本极低

2. 史上最优雅的支持 Kotlin 协程

3. 史上最优雅的处理多个BaseUrl及动态BaseUrl

4. 史上最优雅的对错误统一处理，且不打破Lambda表达式

5. 史上最优雅的文件上传/下载/断点下载/进度监听，已适配Android 10

6. 支持Gson、Xml、ProtoBuf、FastJson等第三方数据解析工具

7. 支持Get、Post、Put、Delete等任意请求方式，可自定义请求方式

8. 支持在Activity/Fragment/View/ViewModel/任意类中，自动关闭请求

9. 支持全局加解密、添加公共参数及头部、网络缓存，均支持对某个请求单独设置

请求三部曲

上手教程

30秒上手教程：30秒上手新一代Http请求神器RxHttp

协程文档：RxHttp ，比Retrofit 更优雅的协程体验

掘金详细文档：RxHttp 让你眼前一亮的Http请求框架

wiki详细文档：https://github.com/liujingxing/rxhttp/wiki (此文档会持续更新)

自动关闭请求用到的RxLife类，详情请查看RxLife库

更新日志      遇到问题，点击这里，99%的问题都能自己解决

上手准备

Maven依赖点击这里

1、RxHttp目前已适配OkHttp 3.12.0 - 4.9.1版本(4.3.0版本除外), 如你想要兼容21以下，请依赖OkHttp 3.12.x，该版本最低要求 API 9

2、asXxx方法内部是通过RxJava实现的，而RxHttp 2.2.0版本起，内部已剔除RxJava，如需使用，请自行依赖RxJava并告知RxHttp依赖的Rxjava版本

必须

将jitpack添加到项目的build.gradle文件中，如下：

allprojects {

    repositories {

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

    }

}

注：RxHttp 2.6.0版本起，已全面从JCenter迁移至jitpack

//使用kapt依赖rxhttp-compiler时必须

apply plugin: 'kotlin-kapt'



android {

    //必须，java 8或更高

    compileOptions {

        sourceCompatibility JavaVersion.VERSION_1_8

        targetCompatibility JavaVersion.VERSION_1_8

    }

}



dependencies {

    implementation 'com.github.liujingxing.rxhttp:rxhttp:2.6.1'

    implementation 'com.squareup.okhttp3:okhttp:4.9.1' //rxhttp v2.2.2版本起，需要手动依赖okhttp

    kapt 'com.github.liujingxing.rxhttp:rxhttp-compiler:2.6.1' //生成RxHttp类，纯Java项目，请使用annotationProcessor代替kapt

 }

可选

android {

    defaultConfig {

        javaCompileOptions {

            annotationProcessorOptions {

                arguments = [

                    //使用asXxx方法时必须，告知RxHttp你依赖的rxjava版本，可传入rxjava2、rxjava3

                    rxhttp_rxjava: 'rxjava3', 

                    rxhttp_package: 'rxhttp'   //非必须，指定RxHttp类包名

                ]

            }

        }

    }

}

dependencies {

    implementation 'com.github.liujingxing.rxlife:rxlife-coroutine:2.1.0' //管理协程生命周期，页面销毁，关闭请求

    

    //rxjava2   (RxJava2/Rxjava3二选一，使用asXxx方法时必须)

    implementation 'io.reactivex.rxjava2:rxjava:2.2.8'

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

    implementation 'com.github.liujingxing.rxlife:rxlife-rxjava2:2.1.0' //管理RxJava2生命周期，页面销毁，关闭请求



    //rxjava3

    implementation 'io.reactivex.rxjava3:rxjava:3.0.6'

    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'

    implementation 'com.github.liujingxing.rxlife:rxlife-rxjava3:2.1.0' //管理RxJava3生命周期，页面销毁，关闭请求



    //非必须，根据自己需求选择 RxHttp默认内置了GsonConverter

    implementation 'com.github.liujingxing.rxhttp:converter-fastjson:2.6.1'

    implementation 'com.github.liujingxing.rxhttp:converter-jackson:2.6.1'

    implementation 'com.github.liujingxing.rxhttp:converter-moshi:2.6.1'

    implementation 'com.github.liujingxing.rxhttp:converter-protobuf:2.6.1'

    implementation 'com.github.liujingxing.rxhttp:converter-simplexml:2.6.1'

}

最后，rebuild一下(此步骤是必须的) ，就会自动生成RxHttp类

混淆

RxHttp v2.2.8版本起，无需添加任何混淆规则(内部自带混淆规则)，v2.2.8以下版本，请查看混淆规则,并添加到自己项目中

代码下载:327744707-okhttp-RxHttp-master.zip

Pod update注意

1、先执行pod repo update 公司内部库specs
2、再执行pod update --no-repo-update这样就不会update github_specs，速度快

JSONSerialization

涉及到JSON Object<->NSData数据转换的地方，注意对NSError的处理和JSON Object合法性的校验，如：

BOOL validate = [NSJSONSerialization isValidJSONObject:parament];
            if (!validate) {
                // 对不是合法的JSON对象错误进行处理
                return;
            }
            NSError *error = nil;
            NSData *jsonData = [NSJSONSerialization dataWithJSONObject:parament options:NSJSONWritingPrettyPrinted error:&error];
            if (error) {
                // 对数据转换错误进行处理
                return;
            }

合法JSON对象满足：
1、Top level object is an NSArray or NSDictionary
2、All objects are NSString, NSNumber, NSArray, NSDictionary, or NSNull
3、All dictionary keys are NSStrings
4、NSNumbers are not NaN or infinity

补充一些代码规范、开发约定

写if else语句时可以else不换行紧跟if的}括号，但写if else if时，为了保持条件{}的可读性，务必请换行书写:

// if else
    BOOL flag = YES;
    if (flag) {
        
    } else {
        
    }

// if else if
    BOOL flag = YES;
    BOOL elseIfFlag = (1+1-1+2 == 5);
    if (flag) {
        
    }
// 这里换行书写
    else if(elseIfFlag) {
        
    }

对于@property声明的属性，如果初始化设置复杂，请采用懒加载getters方式，对于简单初始化的，应在.m文件中提供统一的-initData初始化数据的方法。

/// 懒加载方式-内部配置
@property(nonatomic, strong)UIView *redView;
/// 统一初始化
@property(nonatomic, strong)NSMutableArray *dataSourceArray;

/// 统一数据初始化
- (void)initData{
    _dataSourceArray = [NSMutableArray new];
}

/// 懒加载
- (UIView *)redView{
    if (!_redView) {
        _redView = [UIView new];
        _redView.backgroundColor = UIColor.redColor;
    }
    return _redView;
}

对于NSDictionary、NSArray等的初始化，为提高可读性起见，建议采用语法糖的初始化方式：

_dataSourceArray = [@[@"1", @"2"] mutableCopy];
_parameters = [@{@"action": @"add", @"id": @"22"} mutableCopy];

// X: 不推荐这样做
_dataSourceArray = [NSMutableArray new];
[_dataSourceArray addObject:@"1"];
[_dataSourceArray addObject:@"2"];

_parameters = [NSMutableDictionary new];
[_parameters setValue:@"add" forKey:@"action"];
[_parameters setValue:@"22" forKey:@"id"];

对于Category中的对外公有方法，务必采用categoryName_funcName的命名方式，以区别于主类里没有前缀的方法：

// TALPlayer+LogReport.h

/// 加载播放器
- (void)logReport_loadPlayer;
/// 开始播放
- (void)logReport_startPlay;

对于Category里的私有同名方法，可采用下划线方式如_mainClassFuncName以区别.
对于主类里的私有属性，在多个Category访问时，可采用属性中间件的方式，拆出一个独立的MainClass+InternalProperty来提供一些getters方法：

// TALPlayer+InternalProperty.h

- (TALPlayerLogModel *)internalProperty_logModel;
- (TALPlayerStaticsModel *)internalProperty_staticsModel;


// TALPlayer+InternalProperty.m

- (TALPlayerLogModel *)internalProperty_logModel{
    // 这里为方便以后调试断点用，建议拆开2行写
    id value = [self valueForKey:@"logModel"];
    return value;
}

对于需要跟服务器交互的网络请求参数字符串，务必独立出对应Category的DataInfoKeys扩展文件，方便查询、注释、全局引用、修改和拼写纠错：

// TALPlayer+LogReportDataInfoKeys.h

/// action
extern NSString *const LogReportDataInfoActionKey;
/// 心跳
extern NSString *const LogReportDataInfoActionHeartBeatKey;
/// 严重卡顿
extern NSString *const LogReportDataInfoActionSeriousBufferKey;


// TALPlayer+LogReportDataInfoKeys.m

// action
NSString *const LogReportDataInfoActionKey = @"action";
/// 心跳
NSString *const LogReportDataInfoActionHeartBeatKey = @"heartbeat";
/// 严重卡顿
NSString *const LogReportDataInfoActionSeriousBufferKey = @"seriousbuffer";


// 使用
#import "TALPlayerLogReportDataInfoKeys.h"

NSMutableDictionary *info = [NSMutableDictionary new];
info[LogReportDataInfoActionKey] = LogReportDataInfoActionHeartBeatKey;
// info[XXXKey] = value;

对于.h及.m文件中默认#pragma mark的规范，推荐如下:

// XXX.h

#pragma mark - Protocol

#pragma mark - Properties

#pragma mark - Methods

// XXX.m

#pragma mark - Consts

#pragma mark - UI Components

#pragma mark - Data Properties

#pragma mark - Initial Methods

#pragma mark - Lifecycle Methods

#pragma mark - Override Methods

#pragma mark - Public Methods

#pragma mark - Private Methods

#pragma mark - XXXDelegate

#pragma mark - Getters

#pragma mark - Setters

如上相关#pragma字符在Xcode中的自动配置，有机会我会单独分享给大家。
Xcode FileTemplate路径：Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/Xcode/Templates/File Templates/Source/Cocoa Touch Class.xctemplate/

对于OC文件中注释规范说明：

//MARK: mark here(类似于#pragma mark，只不过没有横线)

//TODO: todo here

//FIXME: fix me later

//???: What is this shit

//!!!: DO NOT TOUCH MY CODE

说明：
对于单行注释，尽量用//代替/**/格式，，务必请在//后加一个空格，再进行内容补充，如：// 这是单行注释而不要写成//这是单行注释
对于SDK内部私有方法，如果无参数，则采用/// 这是无参数方法注释格式；
对于SDK需要向外暴露的接口方法注释，请务必按照AppleDoc编写，写明@param、@return等：

/**
 * 这是一个demo方法
 * @param param1 第一个参数
 * @param param2 第二个参数
 * @return BOOL值
 */
 - (BOOL)thisIsADemoFuncWithParam1: (NSString *)param1
                            param2: (NSInteger)param2{
    return NO;
}

1、对于@property申明的SDK公开属性，务必写成/* 这是SDK公开属性注释 */，方便调用时Xcode提示；

2、对于SDK内部使用的属性，最好写成/// 这是属性注释而不是/**/；

3、另外，务必让对于>=2个参数的方法，各个参数折行对齐，务必保持.h和.m方法参数格式一致；

4、对于方法名的统一性说明：

  4.1 如果方法是功能性的，处理某些事件、计算、数据处理等的私有方法，则可定义方法名为handleXXX:，如-handleRedBtnClick:、-handleResponsedData:、-handlePlayerEvent:等；

  4.2 对于一些需要暴露的公有方法，则命名最好按照n的功能命名，如对于一个TALPlayer它可以play、stop、resume等；

  4.3 对于可以switch两种状态切换的状态方法，最好命名为toggleXXX:(BOOL)on，如- (void)toggleMute:(BOOL)on；

5、对于一些状态描述性的属性，可以用needs、is、should、has+adj/vb组合形式，如needsAutoDisplay、shouldAutoRotateOrientation、isFinished、hasData或hasNoData等；

对于一些NS_ENUM枚举定义，务必遵循统一前缀方式:

typedef enum : NSUInteger {
    TALPlayerEventA = 0,
    TALPlayerEventB,
    TALPlayerEventC,
} TALPlayerEvent;
// 或者
typedef NS_ENUM(NSUInteger, MyEnum) {
    MyEnumValueA,
    MyEnumValueB,
    MyEnumValueC,
};

6、对于一些全局宏的定义，务必SDK前缀全大写_NAME_组合如TALPLAYER_GLOBAL_MACRO_NAME，对于const类型的常量，务必加上k前缀，命名为kConstValue；

7、对于一些typedef的Block，命名最好指明Block的类别+用途，如TALPlayerLogReportHandler，如果有功能性区分的话，则可以定义为TALPlayerLogReportCompletionHandler、TALPlayerLogReportSuccessHandler、TALPlayerLogReportFailureHandler注意是名词组合形式；

8、调用Block时，一定要对block对象进行nil值判断，防止崩溃handler ? handler() : nil;

9、所有对于NSString校验的地方，都应该校验其length > 0，而不是!str；

10、所有对于NSURL校验的地方，都应该校验其[URL.scheme.lowercaseString isEqualToString: @"https"]方式，而不是!URL；

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

• 上一篇文章我们讲到了load方法，今天我们来看看initialize

新建项目，新建类（和上一篇文章所建的类相同，方便大家理解，具体的类相关关系可以看上一篇文章我的介绍）类结构图如下

将原来的load方法换成initialize

先告诉大家initialize方法调用的时间，以便大家带着答案去理解initialize：在类第一次接收到消息的时候调用，它区别于load(运行时加载类的时候调用)，下面我们来深入理解initialize

• 1. 相信大家在想什么叫第一次接收消息了，我们回到main（）

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

+ (void)initialize{

    NSLog(@"TCStudent +initialize");

}

@end

#import "TCStudent+TCStudentTest1.h"



@implementation TCStudent (TCStudentTest1)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest1) +initialize");

}

@end#import "TCStudent+TCStudentTest2.h"



@implementation TCStudent (TCStudentTest2)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest2) +initialize");

}

@end

2020-12-04 15:41:21.863260+0800 TCCateogry[1868:100750] TCPerson (TCtest2) +initialize

2020-12-04 15:41:21.863568+0800 TCCateogry[1868:100750] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

首先先看几个面试问题

• Cateogry里面有load方法么? load方法什么时候调用？load方法有继承么？

1. 新建一个项目，并添加TCPerson类，并给TCPerson添加两个分类

2.新建一个TCStudent类继承自TCPerson，并且给TCStudent也添加两个分类

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    

}

@end

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    

}

@end

#import <Foundation/Foundation.h>



int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

    }

    return 0;

}

@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

@end





@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

@end

@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

@end

从输出结果我们可以看出，三个load方法都被调用

问题：分类重写方法，真的是覆盖原有类的方法么？如果不是，到底分类的方法是怎么调用的？

• 首先我们在TCPerson申明一个方法+ (void)test并且在它的两个分类都重写+ (void)test

#import <Foundation/Foundation.h>



NS_ASSUME_NONNULL_BEGIN



@interface TCPerson : NSObject

+ (void)test;

@end



NS_ASSUME_NONNULL_END

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

+ (void)test{

    NSLog(@"TCPerson +test");

}

@end

分类重写test

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest1) +test1");

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest2) +test2");

}

@end

在main里面我们调用test

#import <Foundation/Foundation.h>

#import "TCPerson.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

    }

    return 0;

}

从输出结果中我们可以看到，只有分类2中的test被调用，为什么只调用分类2中的test了？

因为编译顺序是分类2在后，1在前，这个时候我们改变编译顺序（拖动文件就行了）

细心的老铁会看到，为什么load方法一直都在调用，这是为什么了？它和test方法到底有什么不同了？真的是我们理解中的load不覆盖，test覆盖了，所以才出现这种情况么？

我们打印TCPerson的类方法

void printMethodNamesOfClass(Class cls)

{

    unsigned int count;

    // 获得方法数组

    Method *methodList = class_copyMethodList(cls, &count);

    

    // 存储方法名

    NSMutableString *methodNames = [NSMutableString string];

    

    // 遍历所有的方法

    for (int i = 0; i < count; i++) {

        // 获得方法

        Method method = methodList[I];

        // 获得方法名

        NSString *methodName = NSStringFromSelector(method_getName(method));

        // 拼接方法名

        [methodNames appendString:methodName];

        [methodNames appendString:@", "];

    }

    

    // 释放

    free(methodList);

    

    // 打印方法名

    NSLog(@"%@ %@", cls, methodNames);

}

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

        printMethodNamesOfClass(object_getClass([TCPerson class]));

    }

    return 0;

}

可以看到，TCPerson的所有类方法名，并不是覆盖，三个load，三个test，方法都在

load源码分析：查看objc底层源码我们可以看到：

void call_load_methods(void)

{

    static bool loading = NO;

    bool more_categories;



    loadMethodLock.assertLocked();



    // Re-entrant calls do nothing; the outermost call will finish the job.

    if (loading) return;

    loading = YES;



    void *pool = objc_autoreleasePoolPush();



    do {

        // 1. Repeatedly call class +loads until there aren't any more

        while (loadable_classes_used > 0) {

            call_class_loads();

        }



        // 2. Call category +loads ONCE

        more_categories = call_category_loads();



        // 3. Run more +loads if there are classes OR more untried categories

    } while (loadable_classes_used > 0  ||  more_categories);



    objc_autoreleasePoolPop(pool);



    loading = NO;

}

load方法它是先调用 while (loadable_classes_used > 0) {call_class_loads(); }类的load，再调用more_categories = call_category_loads()分类的load，和编译顺序无关，都会调用
我们查看call_class_loads()方法

static void call_class_loads(void)

{

    int I;

    

    // Detach current loadable list.

    struct loadable_class *classes = loadable_classes;

    int used = loadable_classes_used;

    loadable_classes = nil;

    loadable_classes_allocated = 0;

    loadable_classes_used = 0;

    

    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Class cls = classes[i].cls;

        load_method_t load_method = (load_method_t)classes[i].method;

        if (!cls) continue; 



        if (PrintLoading) {

            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());

        }

        (*load_method)(cls, SEL_load);

    }

    

    // Destroy the detached list.

    if (classes) free(classes);

}

其通过的是load_method_t函数指针直接调用
函数指针直接调用

typedef void(*load_method_t)(id, SEL);

其分类load方法调用也是一样

static bool call_category_loads(void)

{

    int i, shift;

    bool new_categories_added = NO;

    

    // Detach current loadable list.

    struct loadable_category *cats = loadable_categories;

    int used = loadable_categories_used;

    int allocated = loadable_categories_allocated;

    loadable_categories = nil;

    loadable_categories_allocated = 0;

    loadable_categories_used = 0;



    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Category cat = cats[i].cat;

        load_method_t load_method = (load_method_t)cats[i].method;

        Class cls;

        if (!cat) continue;



        cls = _category_getClass(cat);

        if (cls  &&  cls->isLoadable()) {

            if (PrintLoading) {

                _objc_inform("LOAD: +[%s(%s) load]\n", 

                             cls->nameForLogging(), 

                             _category_getName(cat));

            }

            (*load_method)(cls, SEL_load);

            cats[i].cat = nil;

        }

    }

为什么test不一样了

因为test是因为消息机制调用的，objc_msgSend([TCPerson class], @selector(test));消息机制就牵扯到了isa方法查找，test在元类方法里面顺序查找的

load只在加载类的时候调用一次，且先调用类的load，再调用分类的

#import "TCStudent.h"



@implementation TCStudent



@end

最近一直在看React的一些东西，其实很早前就想开始重拾前端，但是一直提不起兴趣再去看JavaScript，对CSS这种布局方式也不是很来感，说白了，就是懒吧😂。去年年底开始在公司app里开始尝试接入Weex，所以不得不把JavaScript再重新撸了一遍，顺带着把ES6的一些新特性也了解了一下，更好的函数调用方式，Class的引入，Promise的运用等等，其实最吸引我的还是在用了Weex之后，感受到了Component带来的UI复用，高效开发的快感。Weex是运用Vue.js来调用，渲染native控件，来达到one code, run everywhere。不管是Vue.js，还是React，最终都是朝着W3C WebComponent的标准走了（今年会发布的Vue 3.0在组件上的语法基本上跟React一样了）。这篇就来讲讲我对React Component的理解，还有怎么把这个标准也能在native上面做运用

demo源码

iOS UI开发的痛点

对iOS开发来说，最常用的UI组件就是UICollectionView了，就是所谓的一个列表页，现在的app大部分页面都是由一个列表来呈现内容的。对iOS开发者来说，我们可以封装每个UICollectionViewCell，从而可以在每个页面的UICollectionView中能够复用，但是痛点是，这个复用仅仅是UI上的复用，在每写一个新的页面（UIViewController）的时候，还是需要新建一个UICollectionView，然后再把UICollectionView的DataSource和Delegate方法再实现一遍，把这些Cell再在这些方法里重新生成一遍，才能让列表展现出来。比方说我们首页列表底部有猜你喜欢的cell，个人中心页面底部也有猜你喜欢的cell，这两个页面，都需要在自己拥有的UICollectionView中注册这个猜你喜欢的cell，返回这个猜你喜欢cell的高度，设置这个cell的model并刷新数据，如果有Header或者Footer的话，还得重新设置这些Header跟Footer。所以新写一个列表页面，对iOS开发者来说，还是很麻烦。

使用Weex或者RN开发原生列表页

使用Weex开发列表页的时候，我们组内的小伙伴都觉得很爽，很高效，基本上几行代码就能绘制出一个列表页，举个RN和weex的例子

// React
render() {
    const cells = this.state.items.map((item, index) => {
        if (item.cellType === 'largeCell') {
            return <LargeCell cellData={item.entity}></LargeCell>
        } else if (item.cellType === 'mediumCell') {
            return <MediumCell cellData={item.entity}></MediumCell>
        } else if (item.cellType === 'smallCell') {
            return <SmallCell cellData={item.entity}></SmallCell>
        }
    });

    return(
        <Waterfall>
            { cells }
        </Waterfall>
    );
}

// Vue
<template>
    <waterfall>
        <cell v-for="(item, index) in itemsArray" :key="index">
            <div class="cell" v-if="item.cellType === 'largeCell'">
                <LargeCell :cellData="item.entity"></LargeCell>
            </div>
            <div class="cell" v-if="item.cellType === 'mediumCell'">
                <MediumCell :cellData="item.entity"></MediumCell>
            </div>
            <div class="cell" v-if="item.cellType === 'smallCell'">
                <SmallCell :cellData="item.entity"></SmallCell>
            </div>
        </cell>
    </waterfall>
</template>

const

waterfall对应的就是iOS中的UICollectionView，waterfall这个组件中有cell的子组件，这些cell的子组件可以是我们自己定义的不同类型样式的cell组件。LargeCell，MediumCell，SmallCell对应的就是原生中的我们自定义的UICollectionViewCell。这些Cell子组在任何waterfall组件下面都可以使用，在一个waterfall组件下面，我们只需要把我们把在这个列表中需要展示的cell放进来，通过props把数据传到cell组件中即可。这种方式对iOS开发者来说，真的是太舒服了。在觉得开发很爽的同时，我也在思考，既然这种Component的方式用起来很爽，那么能不能也运用到原生开发中呢？毕竟我们大部分的业务需求还是基于原生来开发的。

React的核心思想

1、先来解释下React中的React Element和React Component
1.1、React Elements

const element = <div id='login-button>Login</div>

这段JSX表达式返回的就是一个React Element，React element描述了用户将在屏幕上看到的那个UI，跟DOM elements不一样的是，React elements是一个单纯的对象，仅仅是对将要呈现到屏幕上的UI的一个描述，并不是真正渲染好的UI，创建一个React element开销是极其小的，渲染的事情是由背后的React DOM来处理的。上面的那段代码相当于：

const element = React.createElement(
  'div',
  {id: 'login-button'},
  'Login'
)

返回的React element对象相当于 =>

{
  type: 'div',
  props: {
      children: 'Login',
      id: 'login-button'
  }
}

1.2 React Components

React中最核心的一个思想就是Component了，官方的解释是Component允许我们将UI拆分为独立可复用的代码片段，组件中可以包含多个其他组件，这样将组件一个个单独抽离出来，并最终再组合到一起，大大提高了代码的可读性（Readability）、可维护性（Maintainability）、可复用性（Reusability）和可测试性（Testability）。这也是 React 里用 Component 抽象所有 UI 的意义所在。

class Button extends React.Component {
  render() {
    const element = <div id='login-button>{ this.props.title }</div>
    return (
      <div>
        { element }
      </div>
    )
}

这段代码中Button就是一个React Component，这个component接受一个叫props的参数，返回描述UI的React element。

2、可以看出React Component接受props是一个对象，也就是所谓的一种数据结构，返回React Element也是一种对象，所谓的另外一种数据结构，所以我认为的React Component其实就是一个function，这个function的主要功能就是将一种数据结构（描述原始数据）转换成另外一种数据结构（描述UI）。React element仅仅是一个描述UI的对象，可以认为是一个中间状态，我们可以用最小的开销来创建或者销毁element对象。

3、React的核心思想总结下来就是这样的一个流程
1、原始数据到UI数据的转化 props -> React Component -> React Element
2、React Element的作用是将Component的创建跟描述状态分离，Component内部主要负责这个Component的构建，React Element主要用来做描述这个Component的状态
3、多个Component返回的多个Elements，这个流程是进行UI组合
4、React Element并不是一个渲染结果，React DOM的作用是将UI的状态（即Element）和UI的渲染分离，React DOM负责element的渲染
5、最后一个流程就是UI渲染了
上述这几个流程基本上代表了React的核心概念

怎么在iOS中运用React Component概念

说了这么多，其实iOS中缺少的就是这个Component概念，iOS原生的流程是原始数据到UI布局，再到UI绘制。复用的只是UI绘制结果的那个view（e.g. UICollectionViewCell）

在使用UICollectionView的时候，我们的数据都是通过DataSource方法返回给UICollectionView，UICollectionView拿到这些数据之后，就直接去绘制UICollectionViewCell了。所以每个列表页都得重新建一个UICollectionView，再引入自定义的UICollectionViewCell来绘制列表，所有的DataSource跟Delegate方法都得走一遍。所以我在想，我们可以按照React的那种方式来绘制列表么？将一个个UI控件抽象成一个个组件，再将这些组件组合到一起，绘制出最后的页面，React或者Weex的绘制列表其实就是waterfall这个列表component里面按照列表顺序插入自定义的cell component（组合）。那么我们其实可以在iOS中也可以有这个waterfall的component，这个component支持一个insertChildComponent:的方法，这个方法里就是插入自定义的CellComponent到waterfall这个组件中，并通过传入props来创建这个component。所以我就先定义了一个组件的基类BaseComponent

@protocol ComponentProtocol <NSObject>

/**
 *  绘制组件
 *
 *  @param view 展示该组件的view
 */
- (void)drawComponentInView:(UIView *)view withProps:(id)props;

/**
 *  组件的尺寸
 *
 *  @param props 该component的数据model
 *  @return 该组件的size
 */
+ (CGSize)componentSize:(id)props;

@end

@interface BaseComponent : NSObject <ComponentProtocol>

- (instancetype)initWithProps:(id)props;

@property (nonatomic, strong, readonly) id props;

所有的Component的创建都是通过传入props参数，来返回一个组件实例，每个Component还遵守一个ComponentProtocol的协议，协议里两个方法：

1、- (void)drawComponentInView:(UIView *)view withProps:(id)props; 每个component通过这个方法来进行native控件的绘制，参数中view是将会展示该组件的view，比方说WaterfallComponent中的该方法view为UIViewController的view，因为UIViewController的view会用来展示WaterfallComponent这个组件，'props'是该组件创建时传入的参数，这个参数用来告诉组件应该怎样绘制UI
2、+ (CGSize)componentSize:(id)props; 来描述组件的尺寸。

有了这个Component概念之后，我们原生的绘制流程就变成

1、创建Component，传入参数props
2、Component内部执行创建代码，保存props
3、当页面需要绘制的时候（React中的render命令），component内部会执行- (void)drawComponentInView:(UIView *)view withProps:(id)props;方法来描述并绘制UI

原生代码中想实现React element，其实不是一件简单的事情，因为原生没有类似JSX这种语言来生成一套只用来描述UI，并不绘制UI的中间状态的对象（可以做，比方说自己定义一套语法来描述UI），所以目前我的做法是在component内部，等到绘制命令来了之后，通过在- (void)drawComponentInView:(UIView *)view withProps:(id)props方法中，调用原生自定义的UIKit控件，通过props来绘制该UIKit

所以将通过封装component的方式，我们之前UIKit代表的UI组件转换成组件，把这些组件一个个单独抽离出来，再通过搭积木的方式，将各种组件一个个组合到一起，怎么绘制交给component内部去描述，而不是交给每个页面对应的UIViewController

Demo

Demo中，我会创建一个WaterfallComponent组件，还有多个CellComponent来绘制列表页，每个不一样列表页面(UIViewController)都可以创建一个WaterfallComponent组件，然后将不一样的CellComponent按照顺序插入到WaterfallComponent组件中，即可完成绘制列表，不需要每个页面再去处理UICollectionView的DataSource，Delegate方法。

WaterfallComponent内部会有一个UICollectionView，WaterfallComponent的insertChildComponent方法中，会创建一个dataController来管理数据源，并用来跟UICollectionView的DataSource方法进行交互从而绘制出列表页，最终UIViewController中绘制列表的方法如下：

self.waterfallComponent = [[WaterfallComponent alloc] initWithProps:nil];
    
for (NSDictionary *props in datas) {
    if ([props[@"type"] isEqualToString:@"1"]) {
        FirstCellComponent *cellComponent = [[FirstCellComponent alloc] initWithProps:props];
        [self.waterfallComponent insertChildComponent:cellComponent];
    } else if ([props[@"type"] isEqualToString:@"2"]) {
        SecondCellComponent *cellComponent = [[SecondCellComponent alloc] initWithProps:props];
        [self.waterfallComponent insertChildComponent:cellComponent];
    }
}
[self.waterfallComponent drawComponentInView:self.view withProps:nil];

这样，每个我们自定义的Cell就可以以CellComponent的形式，被按照随意顺序插入到WaterfallComponent，从而做到了真正意义上的复用，Demo已上传到GitHub上，有兴趣的可以看

总结

React的核心思想是将组件一个个单独抽离出来，并最终再组合到一起，大大提高了代码的可读性、可维护性、可复用性和可测试性。这也是 React 里用 Component 抽象所有 UI 的意义所在。
原生开发中，使用Component的概念，用Component去抽象UIKit控件，也能达到同样的效果，这样也能统一每个开发使用UICollectionView时候的规范，也能统一对所有列表页的数据源做一些统一处理，比方说根据一个逻辑，统一在所有列表页，插入一个广告cell，这个逻辑完全可以在WaterfallComponent里统一处理。

思考

目前我们只用到了Component这个概念，其实React中，React Element的概念也是非常核心的，React Element隔离了UI描述跟UI绘制的逻辑，通过JSX来描述UI，并不去生成，绘制UI，这样我们能够以最小的代价来生成或者销毁React Elements，然后在交付给系统绘制elements里描述的UI，那么如果原生里也有这一套模板语言，那么我们就能真正做到在Component里，传入props，返回一个element描述UI，然后再交给系统去绘制，这样还能省去cell的创建，只创建CellComponent即可。其实我们可以通过定义一套语义去描述UI布局，然后通过解析这套语义，通过Core Text去做绘制，这一套还是值得我再去思考的。

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

HackingSwift: What’s new in Swift 5.0
Result<T> 还是 Result<T, E: Error>

背景

在异步获取数据的场景中，常见的回调的数据结构是这样的：表示获取成功的数据，表示获取失败的 error。因为数据可能获取成功，也可能失败。因此回调中的数据和错误都是 optional 类型。
比如 CloudKit 中保存数据的一个函数就是这样：

func save(_ record: CKRecord, completionHandler: @escaping (CKRecord?, Error?) -> Void)

这种形式的缺点是没有体现出两种结果的互斥关系：如果数据成功获取到了，那么 error 一定为空。如果 error 有值，数据一定是获取失败了。

Swift 中枚举的能力相比 OC 有着很大的进步，每个枚举值除了可以是常规的基础类型，还可以是一个关联的类型。有了这样的特性后用枚举来优化返回结果的数据结构显得水到渠成：

enum Result<Success, Failure> where Failure : Error {

    /// A success, storing a `Success` value.
    case success(Success)

    /// A failure, storing a `Failure` value.
    case failure(Failure)
}

基本用法

定义异步返回结果是 Int 类型的函数：

func fetchData(_ completionHandler: @escaping (Result<Int, Error>) -> Void) {
    DispatchQueue.global().async {
        let isSuccess = true
        if isSuccess {
            let resultValue = 6
            return completionHandler(.success(resultValue))
        } else {
            let error = NSError(domain: "custom error", code: -1, userInfo: nil)
            return completionHandler(.failure(error))
        }
    }
}

返回值的类型通过泛型进行约束，Result 第一个泛型类型表示返回值的类型，第二个类型表示错误的类型。对 Result 赋值和常规的枚举一样：

let valueResult: Result<Int, CustomError> = Result.success(4)

// 因为 swift 中会进行类型推断，编译器在确认返回的是 `Result` 类型后，可以省略枚举类型的声明
let errorResult = .failure(CustomError.inputNotValid)

取出 Result 值和获取普通的关联类型枚举是一样的：

fetchData { (result) in
    switch result {
    case .success(let value):
        print(value)
    case .failure(let error)
        print(error.localizedDescription)
    }
}

如果你只想要获取其中一项的值，也可以直接用 if case 拆包：

fetchDate { (result) in
    if case .success(let value) = result {
        print(value)
    }
}

可以判等

Enum 是一个值类型，是一个值就应该可以判断是否相等。如果 Result 的成功和失败的类型都是 Equatable，那么 Result就可以判等，源码如下：

extension Result : Equatable where Success : Equatable, Failure : Equatable { }

类似的，如果是成功和失败的类型都是 Hashable，那么 Result 也是 Hashable：

extension Result : Hashable where Success : Hashable, Failure : Hashable { }

如果实现了 Hashable ，可以用来当做字典的 key。

辅助的 API

map、mapError
与 Dictionary 类似，Swift 为 Result 提供了几个 map value 和 error 的方法。

let intResult: Result<Int, Error> = Result.success(4)
let stringResult = x.map { (value) -> Result<String, Error> in
    return  .success("map")
}

let originError = NSError(domain: "origin error", code: -1, userInfo: nil)
let errorResult: Result<Int, Error> = .failure(originError)
let newErrorResult = errorResult.mapError { (error) -> Error in
    let newError = NSError(domain: "new error", code: -2, userInfo: nil)
    return newError
}

flatMap、flatMapError
map 返回的是具体的结果和错误， flatMap 闭包中返回的是 Result 类型。如果 Result 中包含的是数据，效果和 map 一致，替换数据；如果 Result 中包含的是错误，那么不替换结果。

let intResult: Result<Int, Error> = Result.success(4)

// 替换成功
let flatMapResult = intResult.flatMap { (value) -> Result<String, Error> in
    return  .success("flatMap")
}

// 没有执行替换操作，flatMapIntResult 值还是 intResult
let flatMapIntResult = intResult.flatMap { (value) -> Result<String, Error> in
    return  .failure(NSError(domain: "origin error", code: -1, userInfo: nil))
}

get
很多时候只关心 Result 的值，Swift 提供了 get() 函数来便捷的直接获取值，需要注意的是这个函数被标记为 throws，使用时语句前需要加上 try：

let intResult: Result<Int, Error> = Result.success(4)

let value = try? intResult.get()

可抛出异常的闭包初始化器

很多时候获取返回值的闭包中可能会发生异常代表获取失败的错误，基于这个场景 Swift 提供了一个可抛出异常的闭包初始化器：

enum CustomError: Error, Equatable {
    case inputNotValid
}

let fetchInt = { () -> Int in
    if true {
        return 4
    } else {
        throw CustomError.inputNotValid
    }
}

let result: Result<Int, Error> = Result { try fetchInt() }

需要提醒是通过这种方式声明的 Result 的 error 类型只能是 Error，不能指定特定的 Error。

转自：https://www.jianshu.com/p/a3712edc9367

1.方法调用的几种Hook机制

iOS系统中一共有：C函数、Block、OC类方法三种形式的方法调用。Hook一个方法调用的目的一般是为了监控拦截或者统计一些系统的行为。Hook的机制有很多种，通常良好的Hook方法都是以AOP的形式来实现的。

当我们想Hook一个OC类的某些具体的方法时可以通过Method Swizzling技术来实现、当我们想Hook动态库中导出的某个C函数时可以通过修改导入函数地址表中的信息来实现(可以使用开源库fishhook来完成)、当我们想Hook所有OC类的方法时则可以通过替换objc_msgSend系列函数来实现。。。

那么对于Block方法呢而言呢？

2.Block的内部实现原理和实现机制简介

这里假定你对Block内部实现原理和运行机制有所了解，如果不了解则请参考文章《深入解构iOS的block闭包实现原理》或者自行通过搜索引擎搜索。

源程序中定义的每个Block在编译时都会转化为一个和OC类对象布局相似的对象，每个Block也存在着isa这个数据成员，根据isa指向的不同，Block分为__NSStackBlock、__NSMallocBlock、__NSGlobalBlock 三种类型。也就是说从某种程度上Block对象也是一种OC对象。下面的类图描述了Block类的层次结构。

Block类以及其派生类在CoreFoundation.framework中被定义和实现，并且没有对外公开。

每个Block对象在内存中的布局，也就是Block对象的存储结构被定义如下(代码出自苹果开源出来的库实现libclosure中的文件Block_private.h)：

//需要注意的是下面两个只是模板，具体的每个Block定义时总是按这个模板来定义的。

//Block描述，每个Block一个描述并定义在全局数据段
struct Block_descriptor_1 {
    uintptr_t reserved;   //记住这个变量和结构体，它很重要！！
    uintptr_t size;
};

//Block对象的内存布局
struct Block_layout {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved;
    uintptr_t invoke;   //Block对象的实现函数
    struct Block_descriptor_1 *descriptor;
    // imported variables，这里是每个block对象的特定数据成员区域
};

这里要关注一下struct Block_descriptor_1中的reserved这个数据成员，虽然系统没有用到它，但是下面就会用到它而且很重要！

在了解了Block对象的类型以及Block对象的内存布局后，再来考察一下一个Block从定义到调用是如何实现的。就以下面的源代码为例：

int main(int argc, char *argv[])
{
   //定义
    int a = 10;
    void (^testblock)(void) = ^(){
        NSLog(@"Hello world!%d", a);
    };
    
    //执行
    testblock();

    return 0;
}

在将OC代码翻译为C语言代码后每个Block的定义和调用将变成如下的伪代码：

//testblock的描述信息
struct Block_descriptor_1_fortestblock {
    uintptr_t reserved; 
    uintptr_t size;
};

//testblock的布局存储结构体
struct Block_layout_fortestblock {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved;
    uintptr_t invoke;   //Block对象的实现函数
    struct Block_descriptor_1_fortestblock *descriptor;
    int m_a;  //外部的传递进来的数据。
};

//testblock函数的实现。
void main_invoke_fortestblock(struct Block_layout_fortestblock *cself)
{
      NSLog(@"Hello world!%d", cself->m_a);
}

//testblock对象描述的实例，存储在全局内存区
struct Block_descriptor_1_fortestblock  _testblockdesc = {0, sizeof(struct Block_layout_fortestblock)};

int main(int argc, char *argv[])
{
   //定义部分
    int a = 10;
    struct Block_layout_fortestblock testblock = {
            .isa = __NSConcreteStackBlock,
            .flags =0,
            .reserved = 0,
            .invoke = main_invoke_fortestblock,
            .descriptor = & _testblockdesc,
            .m_a = a
    };

   //调用部分
   testblock.invoke();
   
    return 0;
}

可以看出Block对象的生成和调用都是在编译期间就已经固定在代码中了，它不像其他OC对象调用方法时需要通过runtime来执行间接调用。并且线上程序中所有关于Block的符号信息都会被strip掉。所以上述的所介绍的几种Hook方法都无法Hook住一个Block对象的函数调用。

如果想要Hook住系统的所有Block调用，需要解决如下几个问题：
a. 如何在运行时将所有的Block的invoke函数替换为一个统一的Hook函数。
b. 这个统一的Hook函数如何调用原始Block的invoke函数。
c. 如何构建这个统一的Hook函数。

3.实现Block对象Hook的方法和原理

一个OC类对象的实例通过引用计数来管理对象的生命周期。在MRC时代当对象进行赋值和拷贝时需要通过调用retain方法来实现引用计数的增加，而在ARC时代对象进行赋值和拷贝时就不再需要显示调用retain方法了，而是系统内部在编译时会自动插入相应的代码来实现引用计数的添加和减少。不管如何只要是对OC对象执行赋值拷贝操作，最终内部都会调用retain方法。

Block对象也是一种OC对象！！

每当一个Block对象在需要进行赋值或者拷贝操作时，也会激发对retain方法的调用。因为Block对象赋值操作一般是发生在Block方法执行之前，因此我们可以通过Method Swizzling的机制来Hook 类的retain方法，然后在重写的retain方法内部将Block对象的invoke数据成员替换为一个统一的Hook函数！

通过考察__NSStackBlock、__NSMallocBlock、__NSGlobalBlock 三个类的实现发现这三个类都重载了NSObject的retain方法，这样在执行Method Swizzling时就不需要对NSObject的retain方法执行替换，而只要对上述三个类的retain执行替换即可。

你可以说出为什么这三个派生类都会对retain方法进行重载吗？答案可以从这三种Block的类型定义以及所表示的意义中去寻找。

Block技术不仅可以用在OC语言中，LLVM对C语言进行的扩展也能使用Block，比如gcd库中大量的使用了Block。在C语言中如果对一个Block进行赋值或者拷贝系统需要通过C库函数：

//函数声明在Block.h头文件汇总
// Create a heap based copy of a Block or simply add a reference to an existing one.
// This must be paired with Block_release to recover memory, even when running
// under Objective-C Garbage Collection.
BLOCK_EXPORT void *_Block_copy(const void *aBlock)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);

来实现，这个函数定义在libsystem_blocks.dylib库中，并且库实现已经开源：libclosure。因此可以借助fishhook库来对__Block_copy这个函数进行替换处理，然后在替换的函数函数中将一个Block的原始的invoke函数替换为统一的Hook函数。

另外一个C语言函数objc_retainBlock，也是实现了对Block进行赋值时的引用计数增加，这个函数内部就是简单的调用__Block_copy方法。因此我们也可以添加对objc_retainBlock的替换处理。

解决了第一个问题后，接下来再解决第二个问题。还记得上面提到过的struct Block_descriptor_1中的reserved这个数据成员吗? 当我们通过上述的方法对所有Block对象的invoke成员替换为一个统一的Hook函数前，可以将Block对象的原始invoke函数保存到这个保留字段中去。然后就可以在统一的Hook函数内部读取这个保留字段中的保存的原始invoke函数来执行真实的方法调用了。

因为一个Block对象函数的第一个参数其实是一个隐藏的参数，这个隐藏的参数就是Block对象本身，因此很容易就可以从隐藏的参数中来获取到对应的保留字段。

下面的代码将展示通过方法交换来实现Hook处理的伪代码

struct Block_descriptor {
    void *reserved;
    uintptr_t size;
};

struct Block_layout {
    void *isa;
    int32_t flags; // contains ref count
    int32_t reserved;
    void  *invoke;
    struct Block_descriptor *descriptor;
};

//统一的Hook函数,这里以伪代码的形式提供
void blockhook(void *obj, ...)
{
   struct Block_layout *layout = (struct Block_layout*) obj;
   //调用原始的invoke函数
   layout->descriptor->reserved(...);
}
//模拟器下如果返回类型是结构体并且大于16字节那么第一个参数是返回值保存的内存地址，block对象变为第二个参数
void blockhook_stret(void *pret, void *obj, ...)
{
   struct Block_layout *layout = (struct Block_layout*) obj;
   //调用原始的invoke函数
   layout->descriptor->reserved(...);
}

//执行Block对象的方法替换处理
void replaceBlockInvokeFunction(const void *blockObj)
{
   struct Block_layout *layout = (struct Block_layout*)blockObj;
   if (layout != NULL && layout->descriptor != NULL){
         int32_t BLOCK_USE_STRET = (1 << 29);  //如果模拟器下返回的类型是一个大于16字节的结构体，那么block的第一个参数为返回的指针，而不是block对象。
         void *hookfunc = ((layout->flags & BLOCK_USE_STRET) == BLOCK_USE_STRET) ? blockhook_stret : blockhook;
         if (layout->invoke != hookfunc){
                layout->descriptor->reserved = layout->invoke;
                layout->invoke = hookfunc;
            }
    }
}

void *(*__NSStackBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSStackBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSStackBlock_retain_old(obj, cmd);
}

void *(*__NSMallocBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSMallocBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSMallocBlock_retain_old(obj, cmd);
}

void *(*__NSGlobalBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSGlobalBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSGlobalBlock_retain_old(obj, cmd);
}

int main(int argc, char *argv[])
{
      //因为类名和方法名都不能直接使用，所以这里都以字符串的形式来转换获取。
    __NSStackBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSStackBlock"), sel_registerName("retain"), (IMP)__NSStackBlock_retain_new, nil);
    __NSMallocBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSMallocBlock"), sel_registerName("retain"), (IMP)__NSMallocBlock_retain_new, nil);
    __NSGlobalBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSGlobalBlock"), sel_registerName("retain"), (IMP)__NSGlobalBlock_retain_new, nil);

    return 0;
 }

解决了第二个问题后，就需要解决第三个问题。上面的统一Hook函数blockhook和block_stret只是伪代码实现，因为任何一个Block中的函数的参数类型和个数是不一样的，而且统一Hook函数也需要在适当的时候调用原始的默认Block函数实现，并且不能破坏参数信息。为了解决这些问题就使得这个统一的Hook函数不能用高级语言来实现，而只能用汇编语言来实现。下面就是在arm64位体系下的实现代码：

.text
.align 5
.private_extern _blockhook   
_blockhook:
   //为了不破坏原有参数，这里将所有参数压入栈中
  stp q6, q7, [sp, #-0x20]!
  stp q4, q5, [sp, #-0x20]!
  stp q2, q3, [sp, #-0x20]!
  stp q0, q1, [sp, #-0x20]!
  stp x6, x7, [sp, #-0x10]!
  stp x4, x5, [sp, #-0x10]!
  stp x2, x3, [sp, #-0x10]!
  stp x0, x1, [sp, #-0x10]!
  stp x8, x30, [sp, #-0x10]!
  
  //这里可以添加任意逻辑来进行hook处理。

  //这里将所有参数还原
  ldp x8, x30, [sp], #0x10
  ldp x0, x1, [sp], #0x10
  ldp x2, x3, [sp], #0x10
  ldp x4, x5, [sp], #0x10
  ldp x6, x7, [sp], #0x10
  ldp q0, q1, [sp], #0x20
  ldp q2, q3, [sp], #0x20
  ldp q4, q5, [sp], #0x20
  ldp q6, q7, [sp], #0x20

  ldr x16, [x0, #0x18]   //将block对象的descriptor数据成员取出
  ldr x16, [x16]         //获取descriptor中的reserved成员
  br x16                 //执行reserved中保存的原始函数指针。
LExit_blockhook:

对于x86_64/arm32位系统来说，如果block函数的返回是一个结构体并且长度超过16字节(arm32是8字节)。那么block对象里面的flags属性就会设置为BLOCK_USE_STRET。而x86_64/arm32位系统对于这种返回类型的函数就会将返回值存放到第一个参数所指向的内存中，同时会把原本的block对象变化为第二个参数，因此需要对这种情况进行特殊处理。

关于在运行时Hook所有Block方法调用的技术实现原理就介绍到这里了。当然一个完整的系统可能需要其他一些能力：

1、如果你只想Hook可执行程序中定义的Block，那么请参考我的文章：深入iOS系统底层之映像操作API介绍 中的内容来实现Hook函数的过滤处理。
2、如果你不想借助Block_descriptor中的reserved来保存原始的invoke函数，那么可以参考我的文章：Thunk程序的实现原理以及在iOS中的应用(二)中介绍的技术来实现统一Hook函数以及完成对原始invoke函数的调用技术。

具体完整的代码可以访问我的github中的项目:YSBlockHook。这个项目以AOP的形式实现了真机arm64位模式下对可执行程序中所有定义的Block进行Hook的方法，Hook所做的事情就是在所有Block调用前，打印出这个Block的符号信息。

链接：https://www.jianshu.com/p/0a3d00485c7f

AsyncDisplayKit 已移动并重命名：Texture

性能提升

AsyncDisplayKit 的基本单位是node. ASDisplayNode 是对 的抽象UIView，而后者又是对 的抽象CALayer。与只能在主线程上使用的视图不同，节点是线程安全的：您可以在后台线程上并行实例化和配置它们的整个层次结构。

为了保持其用户界面流畅和响应迅速，您的应用程序应以每秒 60 帧的速度呈现——这是 iOS 的黄金标准。这意味着主线程有六十分之一秒来推动每一帧。执行所有布局和绘图代码需要 16 毫秒！并且由于系统开销，您的代码在导致丢帧之前的运行时间通常不到 10 毫秒。

AsyncDisplayKit 允许您将图像解码、文本大小调整和渲染、布局和其他昂贵的 UI 操作移出主线程，以保持主线程可用于响应用户交互。

随着框架的发展，添加了许多功能，通过消除现代 iOS 应用程序中常见的样板样式结构，可以为开发人员节省大量时间。如果您曾经处理过单元格重用错误，尝试为页面或滚动样式界面高效地预加载数据，或者甚至只是试图防止您的应用丢失太多帧，您都可以从集成 ASDK 中受益。

详细的api介绍:

https://texturegroup.org/appledocs.html

常见问题及demo下载:

https://github.com/facebookarchive/AsyncDisplayKit

源码下载:

前言

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。

例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

定义

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

优点

相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

享元模式的本质是缓存共享对象，降低内存消耗。

结构

抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

享元模式的实现

应用实例的话，其实上面的模板就已经是一个很好的例子了，类似于String常量池，没有的对象创建后存在池中，若池中存在该对象则直接从池中取出。

　　为了更好的理解享元模式，这里再举一个实例，比如接了我一个小型的外包项目，是做一个产品展示网站，后来他的朋友们也希望做这样的网站，但要求都有些不同，我们当然不能直接复制粘贴再来一份，有任希望是新闻发布形式的，有人希望是博客形式的等等，而且因为经费原因不能每个网站租用一个空间。

　　其实这里他们需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，这是造成服务器的大量资源浪费。如果整合到一个网站中，共享其相关的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源；而对于代码，由于是一份实例，维护和扩展都更加容易。

　　那么此时就可以用到享元模式了。UML图如下：
　　
网站抽象类
　

 public abstract class WebSite {



     public abstract void use();



 }

具体网站类

public class ConcreteWebSite extends WebSite {



    private String name = "";



    public ConcreteWebSite(String name) {

        this.name = name;

    }



    @Override

    public void use() {

        System.out.println("网站分类：" + name);

    }



}

网络工厂类
　　这里使用HashMap来作为池，通过put和get方法实现加入池与从池中取的操作。

public class WebSiteFactory {



    private HashMap<String, ConcreteWebSite> pool = new HashMap<>();



    //获得网站分类

    public WebSite getWebSiteCategory(String key) {

        if(!pool.containsKey(key)) {

            pool.put(key, new ConcreteWebSite(key));

        }



        return (WebSite)pool.get(key);

    }



    //获得网站分类总数

    public int getWebSiteCount() {

        return pool.size();

    }



}

Client客户端
　　这里测试用例给了两种网站，原先我们需要做三个产品展示和三个博客的网站，也即需要六个网站类的实例，但其实它们本质上都是一样的代码，可以利用用户ID号的不同，来区分不同的用户，具体数据和模板可以不同，但代码核心和数据库却是共享的。

public class Client {



    public static void main(String[] args) {

        WebSiteFactory factory = new WebSiteFactory();



        WebSite fx = factory.getWebSiteCategory("产品展示");

        fx.use();



        WebSite fy = factory.getWebSiteCategory("产品展示");

        fy.use();



        WebSite fz = factory.getWebSiteCategory("产品展示");

        fz.use();



        WebSite fa = factory.getWebSiteCategory("博客");

        fa.use();



        WebSite fb = factory.getWebSiteCategory("博客");

        fb.use();



        WebSite fc = factory.getWebSiteCategory("博客");

        fc.use();



        System.out.println("网站分类总数为：" + factory.getWebSiteCount());

    }



}

源码中的享元模式

享元模式很重要，因为它能帮你在一个复杂的系统中大量的节省内存空间。在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a=”abc”，其中”abc”就是一个字符串常量。

熟悉java的应该知道下面这个例子：

Stringa="hello";

Stringb="hello";

if(a==b)

　System.out.println("OK");

else

　System.out.println("Error");

输出结果是：OK。可以看出if条件比较的是两a和b的地址，也可以说是内存空间 核心总结，可以共享的对象，也就是说返回的同一类型的对象其实是同一实例，当客户端要求生成一个对象时，工厂会检测是否存在此对象的实例，如果存在那么直接返回此对象实例，如果不存在就创建一个并保存起来，这点有些单例模式的意思。通常工厂类会有一个集合类型的成员变量来用以保存对象，如hashtable,vector等。在java中，数据库连接池，线程池等即是用享元模式的应用。

首先String不属于8种基本数据类型，String是一个对象。
因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；
String str=”kvill”；
String str=new String (“kvill”);的区别：
在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。
看例1：

String s0=”kvill”; 



String s1=”kvill”; 



String s2=”kv” + “ill”; 



System.out.println( s0==s1 ); 



System.out.println( s0==s2 );

结果为：

true 



true

首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。

所以我们得出s0==s1==s2;

用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

看例2：

String s0=”kvill”; 



String s1=new String(”kvill”); 



String s2=”kv” + new String(“ill”); 



System.out.println( s0==s1 ); 



System.out.println( s0==s2 ); 



System.out.println( s1==s2 );

结果为：

false 



false 



false

例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

String.intern()：

再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

例3：

String s0= “kvill”; 



String s1=new String(”kvill”); 



String s2=new String(“kvill”); 



System.out.println( s0==s1 ); 



System.out.println( “**********” ); 



s1.intern(); 



s2=s2.intern(); //把常量池中“kvill”的引用赋给s2 



System.out.println( s0==s1); 



System.out.println( s0==s1.intern() ); 



System.out.println( s0==s2 );

结果为：

false 



********** 



false //虽然执行了s1.intern(),但它的返回值没有赋给s1 



true //说明s1.intern()返回的是常量池中”kvill”的引用 



true

最后我再破除一个错误的理解：

有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

看例4：

String s1=new String("kvill"); 



String s2=s1.intern(); 



System.out.println( s1==s1.intern() ); 



System.out.println( s1+" "+s2 ); 



System.out.println( s2==s1.intern() );

结果：

false 



kvill kvill 



true

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

s1==s1.intern()为false说明原来的“kvill”仍然存在；

s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

关于equals()和==:

这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

关于String是不可变的

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;

就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。

okhttp3 kotlin ConnectionPool 源码分析

ConnectionPool的说明：
管理http和http/2的链接，以便减少网络请求延迟。同一个address将共享同一个connection。该类实现了复用连接的目标。

class RealConnectionPool(

  /** 每个address的最大空闲连接数 */

  private val maxIdleConnections: Int,

  keepAliveDuration: Long,

  timeUnit: TimeUnit

) {

    /**

     * Background threads are used to cleanup expired connections. There will be at most a single

     * thread running per connection pool. The thread pool executor permits the pool itself to be

     * garbage collected.

     */

     //这是一个用于清楚过期链接的线程池，每个线程池最多只能运行一个线程，并且这个线程池允许被垃圾回收

    private val executor = ThreadPoolExecutor(

        0, // corePoolSize.

        Int.MAX_VALUE, // maximumPoolSize.

        60L, TimeUnit.SECONDS, // keepAliveTime.

        SynchronousQueue(),

        threadFactory("OkHttp ConnectionPool", true)

    )

    //双向队列

  private val connections = ArrayDeque<RealConnection>()

  //路由的数据库

  val routeDatabase = RouteDatabase()

  //清理任务正在执行的标志

  var cleanupRunning: Boolean = false

1. 主要就是connections，可见ConnectionPool内部以队列方式存储连接；
2. routDatabase是一个黑名单，用来记录不可用的route，但是看代码貌似ConnectionPool并没有使用它。所以此处不做分析。
3. 剩下的就是和清理有关了，所以executor是清理任务的线程池，cleanupRunning是清理任务的标志，cleanupRunnable是清理任务。

class ConnectionPool(

  maxIdleConnections: Int,

  keepAliveDuration: Long,

  timeUnit: TimeUnit

) {

  //创建一个适用于单个应用程序的新连接池。

 //该连接池的参数将在未来的okhttp中发生改变

 //目前最多可容乃5个空闲的连接，存活期是5分钟

  constructor() : this(5, 5, TimeUnit.MINUTES)

}



init {

    //保持活着的时间，否则清理将旋转循环

    require(keepAliveDuration > 0L) { "keepAliveDuration <= 0: $keepAliveDuration" }

  }

通过这个构造器我们知道了这个连接池最多维持5个连接，且每个链接最多活5分钟。并且包含一个线程池包含一个清理任务。
所以maxIdleConnections和keepAliveDurationNs则是清理中淘汰连接的的指标，这里需要说明的是maxIdleConnections是值每个地址上最大的空闲连接数。所以OkHttp只是限制与同一个远程服务器的空闲连接数量，对整体的空闲连接并没有限制。

这时候说下ConnectionPool的实例化的过程，一个OkHttpClient只包含一个ConnectionPool，其实例化也是在OkHttpClient的过程。这里说一下ConnectionPool各个方法的调用并没有直接对外暴露，而是通过OkHttpClient的Internal接口统一对外暴露。

然后我们来看下他的transmitterAcquirePooledConnection(获取连接)和put方法

fun transmitterAcquirePooledConnection(

    address: Address,

    transmitter: Transmitter,

    routes: List<Route>?,

    requireMultiplexed: Boolean

  ): Boolean {

   //断言，判断线程是不是被自己锁住了

    assert(Thread.holdsLock(this))

 // 遍历已有连接集合

    for (connection in connections) {

      if (requireMultiplexed && !connection.isMultiplexed) continue

          //如果connection和需求中的"地址"和"路由"匹配

      if (!connection.isEligible(address, routes)) continue

      //复用这个连接

      transmitter.acquireConnectionNoEvents(connection)



      return true

    }

    return false

  }

put方法更为简单，就是异步触发清理任务，然后将连接添加到队列中

  fun put(connection: RealConnection) {

    assert(Thread.holdsLock(this))

    if (!cleanupRunning) {

      cleanupRunning = true

      executor.execute(cleanupRunnable)

    }

    connections.add(connection)

  }

private val cleanupRunnable = object : Runnable {

    override fun run() {

      while (true) {

        val waitNanos = cleanup(System.nanoTime())

        if (waitNanos == -1L) return

        try {

          this@RealConnectionPool.lockAndWaitNanos(waitNanos)

        } catch (ie: InterruptedException) {

          // Will cause the thread to exit unless other connections are created!

          evictAll()

        }

      }

    }

  }

这个逻辑也很简单，就是调用cleanup方法执行清理，并等待一段时间，持续清理，其中cleanup方法返回的值来来决定而等待的时间长度。那我们继续来看下cleanup函数：

fun cleanup(now: Long): Long {

    var inUseConnectionCount = 0

    var idleConnectionCount = 0

    var longestIdleConnection: RealConnection? = null

    var longestIdleDurationNs = Long.MIN_VALUE



    // Find either a connection to evict, or the time that the next eviction is due.

    synchronized(this) {

      for (connection in connections) {

        // If the connection is in use, keep searching.

        if (pruneAndGetAllocationCount(connection, now) > 0) {

          inUseConnectionCount++

          continue

        }

//统计空闲连接数量

        idleConnectionCount++



        // If the connection is ready to be evicted, we're done.

        val idleDurationNs = now - connection.idleAtNanos

        if (idleDurationNs > longestIdleDurationNs) {

        //找出空闲时间最长的连接以及对应的空闲时间

          longestIdleDurationNs = idleDurationNs

          longestIdleConnection = connection

        }

      }



      when {

        longestIdleDurationNs >= this.keepAliveDurationNs

            || idleConnectionCount > this.maxIdleConnections -> {

          // We've found a connection to evict. Remove it from the list, then close it below

          // (outside of the synchronized block).

          //在符合清理条件下，清理空闲时间最长的连接

          connections.remove(longestIdleConnection)

        }

        idleConnectionCount > 0 -> {

          // A connection will be ready to evict soon.

           //不符合清理条件，则返回下次需要执行清理的等待时间，也就是此连接即将到期的时间

          return keepAliveDurationNs - longestIdleDurationNs

        }

        inUseConnectionCount > 0 -> {

          // All connections are in use. It'll be at least the keep alive duration 'til we run

          // again.

          //没有空闲的连接，则隔keepAliveDuration(分钟)之后再次执行

          return keepAliveDurationNs

        }

        else -> {

          // No connections, idle or in use.

          cleanupRunning = false

          return -1

        }

      }

    }

//关闭socket资源

    longestIdleConnection!!.socket().closeQuietly()



    // Cleanup again immediately.

    //这里是在清理一个空闲时间最长的连接以后会执行到这里，需要立即再次执行清理

    return 0

  }