async/await 的错误捕获
一、案发现场
为了更好的说明，举一个很常见的例子：
function getData(data) {
return new Promise((resolve, reject) => {
if (data === 1) {
setTimeout(() => {
resolve('getdata success')
}, 1000)
} else {
setTimeout(() => {
reject('getdata error')
}, 1000)
}
})
}
window.onload = async () => {
let res = await getData(1)
console.log(res) //getdata success
}
这样写可以正常打印getdata success 但是如果我们给getData传入的参数不是1，getData会返回一个reject的Promise，而这个地方我们并没有对这个错误进行捕获，则会在控制台看见这样一个鲜红的报错Uncaught (in promise) getdata error
二、尝试捕获它
1. 踹一脚
捕捉错误，首先想到的就是“踹一脚”：
window.onload = async () => {
try {
let res = await getData(3)
console.log(res)
} catch (error) {
console.log(res) //getdata error
}
}
看似问题已经被解决，但是如果我们有一堆请求，每一个await都需要对应一个trycatch，那就多了很多垃圾代码。或许我们可以用一个trycatch将所有的await包起来，但是这样就很不方便对每一个错误进行对应的处理，还得想办法区分每一个错误。
2. then()
因为返回的是一个Promise，那我们首先想到的就是.then()和.catch()，于是很快就能写出以下代码：
window.onload = async () => {
let res = await getData(3).then(r=>r).catch(err=>err);
console.log(res) //getdata error
}
这样看起来比“踹一脚”高大上一点了……
三、有没有更好的方式
上面那种方法是有一定问题的，如果getData()返回是resolve，res则是我们想要的结果，但是如果getData()返回是reject，res则是err，这样错误和正确的结果混在一起了，显然是不行的。
window.onload = async () => {
let res = await getData(3)
.then((res) => [null, res])
.catch((err) => [err, null])
console.log(res) // ["getdata error",null]
}
这种方式有的类似error first的风格。这样可以将错误和正确返回值进行区分了。但是这种方式会让每一次使用await都需要写很长一段冗余的代码，因此考虑提出来封装成一个工具函数：
function awaitWraper(promise) {
return promise.then((res) => [null, res])
.catch((err) => [err, null])
}
window.onload = async () => {
let res = await awaitWraper(getData(3))
console.log(res) // ["getdata error",null]
}
好多了，就先这样吧。
原文链接：https://zhuanlan.zhihu.com/p/114487312
收起阅读 »
先看看 VS Code Extension 知识点，再写个 VS Code 扩展玩玩
TL;DR
文章篇幅有点长 ，可以先收藏再看 。要是想直接看看怎么写一个扩展，直接去第二部分 ，或者直接去github看源码 。
第一部分 --- Extension 知识点
一、扩展的启动
- 如何保证性能 --- 扩展激活（Extension Activation） 我们会往VS Code中安装非常多的扩展，VS Code是如何保证性能的呢？ 在VS Code中有一个扩展激活（Extension Activation）的概念：VS Code会尽可能晚的加载扩展（懒加载），并且不会加载会话期间未使用的扩展，因此不会占用内存。为了完成扩展的延迟加载，VS Code定义了所谓的激活事件（
activation events）。 VS Code根据特定活动触发激活事件，并且扩展可以定义需要针对哪些事件进行激活。例如，仅当用户打开Markdown文件时，才需要激活用于编辑Markdown的扩展名。 - 如何保证稳定性 --- 扩展隔离（Extension Isolation） 很多扩展都写得很棒 ，但是有的扩展有可能会影响启动性能或VS Code本身的整体稳定性。作为一个编辑器用户可以随时打开，键入或保存文件，确保响应性UI不受扩展程序在做什么的影响是非常重要的。 为了避免扩展可能带来的这些负面问题，VS Code在单独的Node.js进程（扩展宿主进程
extension host process）中加载和运行扩展，以提供始终可用的，响应迅速的编辑器。行为不当的扩展程序不会影响VS Code，尤其不会影响其启动时间 。
四、Activation Events --- package.json
既然扩展是延迟加载（懒加载）的，我们就需要向VS Code提供有关何时应该激活什么扩展程序的上下文，其中比较重要的几个： - onLanguage:${language} - onCommand:${command} - workspaceContains:${toplevelfilename} - *
activationEvents.onLanguage
根据编程语言确定时候激活。比如我们可以这样：
"activationEvents": [
"onLanguage:javascript"
]当检测到是js的文件时，就会激活该扩展。
activationEvents.onCommand
使用命令激活。比如我们可以这样：
"activationEvents": [
"onCommand:extension.sayHello"
]activationEvents.workspaceContains
文件夹打开后，且文件夹中至少包含一个符合glob模式的文件时激活。比如我们可以这样：
"activationEvents": [
"workspaceContains:.editorconfig"
]当打开的文件夹含有.editorconfig文件时，就会激活该扩展。
activationEvents.*
每当VS Code启动，就会激活。比如我们可以这样：
"activationEvents": [
"*"
]五、Contribution Points --- package.json
其中配置的内容会暴露给用户，我们扩展大部分的配置都会写在这里： - configuration - commands - menus - keybindings - languages - debuggers - breakpoints - grammars - themes - snippets - jsonValidation - views - problemMatchers - problemPatterns - taskDefinitions - colors
contributes.configuration
在configuration中配置的内容会暴露给用户，用户可以从“用户设置”和“工作区设置”中修改你暴露的选项。 configuration是JSON格式的键值对，VS Code为用户提供了良好的设置支持。 你可以用vscode.workspace.getConfiguration('myExtension')读取配置值。
contributes.commands
设置命令标题和命令，随后这个命令会显示在命令面板中。你也可以加上category前缀，在命令面板中会以分类显示。
注意：当调用命令时（通过组合键或者在命令面板中调用），VS Code会触发激活事件onCommand:${command}。
六、package.json其他比较特殊的字段
engines:说明扩展程序将支持哪些版本的VS CodedisplayName:在左侧显示的扩展名icon:扩展的图标categories:扩展所属的分类。可以是：Languages, Snippets, Linters, Themes, Debuggers, Formatters, Keymaps, Other
第二部分 --- 自己写个扩展玩玩
我们经常使用console.log来打印日志进行调试，我们就写一个用来美化、简化console.log的扩展玩玩。最终实现的效果：
实现这个扩展，需要注意以下几点： 1. console.log使用css样式 2. VS Code插入内容 3. VS Code光标和选区 4. VS Code删除内容 5. VS Code读取用户配置
下面火速实操(p≧w≦q)。
如何开始
要开始写VS Code扩展，需要两个工具：
- yeoman：有助于启动新项目
- vscode-generator-code：由VS Code团队使用
yeoman构建的生成器 可以使用yarn或npm安装这两个工具，安装完成之后执行yo code，等一会之后它会帮我们生成起始项目，并会询问几个问题：
确认信息之后，会帮我们初始化好整个项目，此时的目录结构是这样的：
我们只需要关注src/extension.ts和package.json即可，其中package.json里面的内容之前已经介绍过。
console.log使用css样式
这里有一篇比较完整的文章：https://www.telerik.com/blogs/how-to-style-console-log-contents-in-chrome-devtools 简单的说，这句代码执行之后打印的是下面图片那样console.log("%cThis is a green text", "color:green");:
后面的样式会应用在%c后面的内容上
vscode扩展读取用户配置
上文提到过，我们可以在contributes里面定义用户配置：
"contributes": {
"configuration": {
"type": "object",
"title": "Special-console.log",
"properties": {
"special-console.log.projectName": {
"type": "string",
"default": "MyProject",
"description": "Project name"
},
"special-console.log.showLine": {
"type": "boolean",
"default": true,
"description": "Show line number"
},
"special-console.log.deleteAll": {
"type": "boolean",
"default": false,
"description": "delete all logs or delete the log containing [color] and [background]"
}
}
}
},
然后使用vscode.workspace.getConfiguration()读取用户配置
激活扩展
前面提到扩展是延迟加载（懒加载）的，我们只需要向VS Code提供有关何时应该激活什么扩展程序的上下文即可。我们在package.json中定义两个激活的事件：
"activationEvents": [
"onCommand:extension.insertLog",
"onCommand:extension.deleteLogs"
],
接着在contributes中添加快捷键：
"keybindings": [
{
"command": "extension.insertLog",
"key": "shift+ctrl+l",
"mac": "shift+cmd+l",
"when": "editorTextFocus"
},
{
"command": "extension.deleteLogs",
"key": "shift+ctrl+d",
"mac": "shift+cmd+d"
}
],
还可以将命令添加到命令面板里面，也就是按Ctrl +Shift+P弹出来的面板：
"commands": [
{
"command": "extension.insertLog",
"title": "Insert Log"
},
{
"command": "extension.deleteLogs",
"title": "Delete console.log"
}
],
insertLog表示往内容中插入console.log，deleteLogs则表示删除。具体的实现我们放到src/extension.ts的activate中：
export function activate(context: vscode.ExtensionContext) {
const insertLog = vscode.commands.registerCommand('extension.insertLog', () => {})
context.subscriptions.push(insertLog)
const deleteLogs = vscode.commands.registerCommand('extension.deleteLogs', () => {})
context.subscriptions.push(deleteLogs)
}
插入console.log
- 插入
console.log大概的过程是获取当前选区的内容，获取用户配置，根据用户配置和当前选区的内容填充console.log，最后插入到选区的下一行。
const insertLog = vscode.commands.registerCommand('extension.insertLog', () => {
const editor = vscode.window.activeTextEditor
if (!editor) { return }
const selection = editor.selection
const text = editor.document.getText(selection) // 当前选区内容
// 用户配置
if (userConfig) {
projectName = userConfig.projectName || projectName
showLine = userConfig.showLine || showLine
line = showLine?`%cline:${lineNumber}`:'%c'
}
// 设置console.log
...
// 在下一行插入
vscode.commands.executeCommand('editor.action.insertLineAfter')
.then(() => {
insertText(logToInsert, !text, noTextStr.length)
})
})
插入内容：
const insertText = (val: string, cursorMove: boolean, textLen: number) => {
const editor = vscode.window.activeTextEditor
if (!editor) {
vscode.window.showErrorMessage('Can\'t insert log because no document is open')
return
}
editor.edit((editBuilder) => {
editBuilder.replace(range, val) // 插入内容
}).then(() => {
// 修改选区
})
}
删除console.log
删除的时候只需要遍历找一下console.log在判断一下是不是我们加入的内容，是就删除
const deleteLogs = vscode.commands.registerCommand('extension.deleteLogs', () => {
const editor = vscode.window.activeTextEditor
if (!editor) { return }
const document = editor.document
const documentText = editor.document.getText()
let workspaceEdit = new vscode.WorkspaceEdit()
// 获取log
const logStatements = getAllLogs(document, documentText)
// 删除
deleteFoundLogs(workspaceEdit, document.uri, logStatements)
})
删除的时候可以使用workspaceEdit.delete(docUri, log)，当然，删除之后我们可以右下角搞个弹窗提示一下用户删除了几个console.log：
vscode.workspace.applyEdit(workspaceEdit).then(() => {
vscode.window.showInformationMessage(`${logs.length} console.log deleted`)
})
具体的代码可以看看github
发布
这个就注册一下账号然后发布就行
原文链接：https://zhuanlan.zhihu.com/p/320220574
收起阅读 »
iOS- 集成Bugly详解
SDK 集成
Bugly提供两种集成方式供iOS开发者选择：
- 通过CocoaPods集成
- 手动集成
如果您是从Bugly 2.0以下版本升级过来的，请查看
Bugly iOS SDK 最低兼容系统版本 iOS 7.0
通过CocoaPods集成
在工程的Podfile里面添加以下代码：
pod 'Bugly'保存并执行pod install,然后用后缀为.xcworkspace的文件打开工程。
注意:
命令行下执行pod search Bugly,如显示的Bugly版本不是最新的，则先执行pod repo update操作更新本地repo的内容
关于CocoaPods的更多信息请查看 。
手动集成
- 下载
- 拖拽
Bugly.framework文件到Xcode工程内(请勾选Copy items if needed选项) - 添加依赖库
SystemConfiguration.frameworkSecurity.frameworklibz.dylib或libz.tbdlibc++.dylib或libc++.tbd
初始化SDK
导入头文件
在工程的AppDelegate.m文件导入头文件
#import <Bugly/Bugly.h>如果是
Swift工程，请在对应bridging-header.h中导入
初始化Bugly
在工程AppDelegate.m的application:didFinishLaunchingWithOptions:方法中初始化：
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
[Bugly startWithAppId:@"此处替换为你的AppId"];
return YES;
}默认Debug模式,是不会生成dSYM文件,需要开启.重新编译CMD+B，修改配置如下图
Bugly后台显示异常数据
生成后,在哪里可以找到dSYM文件?
@interface AppDelegate ()<BuglyDelegate>2.设置代理对象
BuglyConfig *config = [[BuglyConfig alloc] init];
config.delegate = self;
[Bugly startWithAppId:@"你的AppId" config:config];3.实现代理方法attachmentForException
#pragma mark - Bugly代理 - 捕获异常,回调(@return 返回需上报记录，随 异常上报一起上报)
- (NSString *)attachmentForException:(NSException *)exception {
#ifdef DEBUG // 调试
return [NSString stringWithFormat:@"我是携带信息:%@",[self redirectNSLogToDocumentFolder]];
#endif
return nil;
}
#pragma mark - 保存日志文件
- (NSString *)redirectNSLogToDocumentFolder{
//如果已经连接Xcode调试则不输出到文件
if(isatty(STDOUT_FILENO)) {
return nil;
}
UIDevice *device = [UIDevice currentDevice];
if([[device model] hasSuffix:@"Simulator"]){
//在模拟器不保存到文件中
return nil;
}
//获取Document目录下的Log文件夹，若没有则新建
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *logDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"Log"];
NSFileManager *fileManager = [NSFileManager defaultManager];
BOOL fileExists = [fileManager fileExistsAtPath:logDirectory];
if (!fileExists) {
[fileManager createDirectoryAtPath:logDirectory withIntermediateDirectories:YES attributes:nil error:nil];
}
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setLocale:[[NSLocale alloc] initWithLocaleIdentifier:@"zh_CN"]];
[formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"]; //每次启动后都保存一个新的日志文件中
NSString *dateStr = [formatter stringFromDate:[NSDate date]];
NSString *logFilePath = [logDirectory stringByAppendingFormat:@"/%@.txt",dateStr];
// freopen 重定向输出输出流，将log输入到文件
freopen([logFilePath cStringUsingEncoding:NSASCIIStringEncoding], "a+", stdout);
freopen([logFilePath cStringUsingEncoding:NSASCIIStringEncoding], "a+", stderr);
return [[NSString alloc] initWithContentsOfFile:logFilePath encoding:NSUTF8StringEncoding error:nil];
}Bugly iOS 符号表配置
<起始地址> <结束地址> <函数> [<文件名:行号>]
UPLOAD_DEBUG_SYMBOLS=0
iOS- 研发助手DoraemonKit技术实现（二）
一、前言
- 第一、很多测试同学比较关注App质量，但是他们却没有Xcode运行环境，他们对于质量数据无法很有效的查看。
- 第二、App端实时的查看App的质量数据，不依赖IDE，方便快捷直观。
- 第三、实时采集性能数据，为后期结合测试平台产生性能数据报表提供数据来源。
二、技术实现
3.1：帧率展示
- (void)startRecord{
if (_link) {
_link.paused = NO;
}else{
_link = [CADisplayLink displayLinkWithTarget:self selector:@selector(trigger:)];
[_link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
_record = [DoraemonRecordModel instanceWithType:DoraemonRecordTypeFPS];
_record.startTime = [[NSDate date] timeIntervalSince1970];
}
}
- (void)trigger:(CADisplayLink *)link{
if (_lastTime == 0) {
_lastTime = link.timestamp;
return;
}
_count++;
NSTimeInterval delta = link.timestamp - _lastTime;
if (delta < 1) return;
_lastTime = link.timestamp;
CGFloat fps = _count / delta;
_count = 0;
NSInteger intFps = (NSInteger)(fps+0.5);
// 0~60 对应 高度0~200
[self.record addRecordValue:fps time:[[NSDate date] timeIntervalSince1970]];
[_oscillogramView addHeightValue:fps*200./60. andTipValue:[NSString stringWithFormat:@"%zi",intFps]];
}3.2：CPU展示
- 使用task_threads函数，获取当前App行程中所有的线程列表。
- 对于第一步中获取的线程列表进行遍历，通过thread_info函数获取每一个非闲置线程的cpu使用率，进行相加。
- 使用vm_deallocate函数释放资源。
+ (CGFloat)cpuUsageForApp {
kern_return_t kr;
thread_array_t thread_list;
mach_msg_type_number_t thread_count;
thread_info_data_t thinfo;
mach_msg_type_number_t thread_info_count;
thread_basic_info_t basic_info_th;
// get threads in the task
// 获取当前进程中 线程列表
kr = task_threads(mach_task_self(), &thread_list, &thread_count);
if (kr != KERN_SUCCESS)
return -1;
float tot_cpu = 0;
for (int j = 0; j < thread_count; j++) {
thread_info_count = THREAD_INFO_MAX;
//获取每一个线程信息
kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
(thread_info_t)thinfo, &thread_info_count);
if (kr != KERN_SUCCESS)
return -1;
basic_info_th = (thread_basic_info_t)thinfo;
if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
// cpu_usage : Scaled cpu usage percentage. The scale factor is TH_USAGE_SCALE.
//宏定义TH_USAGE_SCALE返回CPU处理总频率：
tot_cpu += basic_info_th->cpu_usage / (float)TH_USAGE_SCALE;
}
} // for each thread
// 注意方法最后要调用 vm_deallocate，防止出现内存泄漏
kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
assert(kr == KERN_SUCCESS);
return tot_cpu;
}测试结果基本和Xcode测量出来的cpu使用率是一样的，还是比较准确的。
3.3：内存展示
//当前app消耗的内存
+ (NSUInteger)useMemoryForApp{
task_vm_info_data_t vmInfo;
mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
kern_return_t kernelReturn = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
if(kernelReturn == KERN_SUCCESS)
{
int64_t memoryUsageInByte = (int64_t) vmInfo.phys_footprint;
return memoryUsageInByte/1024/1024;
}
else
{
return -1;
}
}
//设备总的内存
+ (NSUInteger)totalMemoryForDevice{
return [NSProcessInfo processInfo].physicalMemory/1024/1024;
}3.4：流量监控
@interface DoraemonNSURLProtocol()<NSURLConnectionDelegate,NSURLConnectionDataDelegate>
@property (nonatomic, strong) NSURLConnection *connection;
@property (nonatomic, assign) NSTimeInterval startTime;
@property (nonatomic, strong) NSURLResponse *response;
@property (nonatomic, strong) NSMutableData *data;
@property (nonatomic, strong) NSError *error;
@end
@implementation DoraemonNSURLProtocol
+ (BOOL)canInitWithRequest:(NSURLRequest *)request{
if ([NSURLProtocol propertyForKey:kDoraemonProtocolKey inRequest:request]) {
return NO;
}
if (![DoraemonNetFlowManager shareInstance].canIntercept) {
return NO;
}
if (![request.URL.scheme isEqualToString:@"http"] &&
![request.URL.scheme isEqualToString:@"https"]) {
return NO;
}
//NSLog(@"DoraemonNSURLProtocol == %@",request.URL.absoluteString);
return YES;
}
+ (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request{
//NSLog(@"canonicalRequestForRequest");
NSMutableURLRequest *mutableReqeust = [request mutableCopy];
[NSURLProtocol setProperty:@YES forKey:kDoraemonProtocolKey inRequest:mutableReqeust];
return [mutableReqeust copy];
}
- (void)startLoading{
//NSLog(@"startLoading");
self.connection = [[NSURLConnection alloc] initWithRequest:[[self class] canonicalRequestForRequest:self.request] delegate:self];
[self.connection start];
self.data = [NSMutableData data];
self.startTime = [[NSDate date] timeIntervalSince1970];
}
- (void)stopLoading{
//NSLog(@"stopLoading");
[self.connection cancel];
DoraemonNetFlowHttpModel *httpModel = [DoraemonNetFlowHttpModel dealWithResponseData:self.data response:self.response request:self.request];
if (!self.response) {
httpModel.statusCode = self.error.localizedDescription;
}
httpModel.startTime = self.startTime;
httpModel.endTime = [[NSDate date] timeIntervalSince1970];
httpModel.totalDuration = [NSString stringWithFormat:@"%f",[[NSDate date] timeIntervalSince1970] - self.startTime];
[[DoraemonNetFlowDataSource shareInstance] addHttpModel:httpModel];
}
#pragma mark - NSURLConnectionDelegate
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error{
[[self client] URLProtocol:self didFailWithError:error];
self.error = error;
}
- (BOOL)connectionShouldUseCredentialStorage:(NSURLConnection *)connection {
return YES;
}
- (void)connection:(NSURLConnection *)connection didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
[[self client] URLProtocol:self didReceiveAuthenticationChallenge:challenge];
}
- (void)connection:(NSURLConnection *)connection didCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
[[self client] URLProtocol:self didCancelAuthenticationChallenge:challenge];
}
#pragma mark - NSURLConnectionDataDelegate
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response{
[[self client] URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageAllowed];
self.response = response;
}
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data{
[[self client] URLProtocol:self didLoadData:data];
[self.data appendData:data];
}
- (NSCachedURLResponse *)connection:(NSURLConnection *)connection willCacheResponse:(NSCachedURLResponse *)cachedResponse{
return cachedResponse;
}
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
[[self client] URLProtocolDidFinishLoading:self];
}3.5：自定义监控
DoraemonKit项目地址：github.com/didi/Doraem…
摘自：https://blog.csdn.net/weixin_33847182/article/details/91472599
iOS- 研发助手DoraemonKit技术实现（一）
一、前言
- 常用工具 : App信息展示，沙盒浏览、MockGPS、H5任意门、子线程UI检查、日志显示。
- 性能工具 : 帧率监控、CPU监控、内存监控、流量监控、自定义监控。
- 视觉工具 : 颜色吸管、组件检查、对齐标尺。
- 业务专区 : 支持业务测试组件接入到DoraemonKit面板中。
二、技术实现
2.1：App信息展示
我们要看一些手机信息或者App的一些基本信息的时候，需要到系统设置去找，比较麻烦。特别是权限信息，在我们app装的比较多的时候，我们很难快速找到我们app的权限信息。而这些信息从代码角度都是比较容易获取的。我们把我们感兴趣的信息列表出来直接查看，避免了去手机设置里查看或者查看源代码的麻烦。
获取手机型号
+ (NSString *)iphoneType{
struct utsname systemInfo;
uname(&systemInfo);
NSString *platform = [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding];
//iPhone
if ([platform isEqualToString:@"iPhone1,1"]) return @"iPhone 1G";
...
//其他对应关系请看下面对应表
return platform;
}
获取手机系统版本
//获取手机系统版本
NSString *phoneVersion = [[UIDevice currentDevice] systemVersion];
复制代码获取App BundleId
一个app分为测试版本、企业版本、appStore发售版本，每一个app长得都一样，如何对他们进行区分呢，那就要用到BundleId这个属性了。
//获取bundle id
NSString *bundleId = [[NSBundle mainBundle] bundleIdentifier];
获取App 版本号
//获取App版本号
NSString *bundleVersionCode = [[[NSBundle mainBundle]infoDictionary] objectForKey:@"CFBundleVersion"];权限信息查看
- NotDetermined => 用户还没有选择。
- Restricted => 该权限受限，比如家长控制。
- Denied => 用户拒绝使用该权限。
- Authorized => 用户同意使用该权限。
2.2：沙盒浏览
以前如果我们要去查看App缓存、日志信息，都需要访问沙盒。由于iOS的封闭性，我们无法直接查看沙盒中的文件内容。如果我们要去访问沙盒，基本上有两种方式，第一种使用Xcode自带的工具，从Windows-->Devices进入设备管理界面，通过Download Container的方式导出整个app的沙盒。第二种方式，就是自己写代码，访问沙盒中指定文件，然后使用NSLog的方式打印出来。这两种方式都比较麻烦。
- (void)shareFileWithPath:(NSString *)filePath{
NSURL *url = [NSURL fileURLWithPath:filePath];
NSArray *objectsToShare = @[url];
UIActivityViewController *controller = [[UIActivityViewController alloc] initWithActivityItems:objectsToShare applicationActivities:nil];
NSArray *excludedActivities = @[UIActivityTypePostToTwitter, UIActivityTypePostToFacebook,
UIActivityTypePostToWeibo,
UIActivityTypeMessage, UIActivityTypeMail,
UIActivityTypePrint, UIActivityTypeCopyToPasteboard,
UIActivityTypeAssignToContact, UIActivityTypeSaveToCameraRoll,
UIActivityTypeAddToReadingList, UIActivityTypePostToFlickr,
UIActivityTypePostToVimeo, UIActivityTypePostToTencentWeibo];
controller.excludedActivityTypes = excludedActivities;
[self presentViewController:controller animated:YES completion:nil];
}
2.3：MockGPS
/*
* locationManager:didUpdateLocations:
*
* Discussion:
* Invoked when new locations are available. Required for delivery of
* deferred locations. If implemented, updates will
* not be delivered to locationManager:didUpdateToLocation:fromLocation:
*
* locations is an array of CLLocation objects in chronological order.
*/
- (void)locationManager:(CLLocationManager *)manager
didUpdateLocations:(NSArray<CLLocation *> *)locations API_AVAILABLE(ios(6.0), macos(10.9));- (void)doraemon_swizzleLocationDelegate:(id)delegate {
if (delegate) {
//1、让所有的CLLocationManager的代理都设置为[DoraemonGPSMocker shareInstance]，让他做中间转发
[self doraemon_swizzleLocationDelegate:[DoraemonGPSMocker shareInstance]];
//2、绑定所有CLLocationManager实例与delegate的关系，用于[DoraemonGPSMocker shareInstance]做目标转发用。
[[DoraemonGPSMocker shareInstance] addLocationBinder:self delegate:delegate];
//3、处理[DoraemonGPSMocker shareInstance]没有实现的selector，并且给用户提示。
Protocol *proto = objc_getProtocol("CLLocationManagerDelegate");
unsigned int count;
struct objc_method_description *methods = protocol_copyMethodDescriptionList(proto, NO, YES, &count);
NSMutableArray *array = [NSMutableArray array];
for(unsigned i = 0; i < count; i++)
{
SEL sel = methods[i].name;
if ([delegate respondsToSelector:sel]) {
if (![[DoraemonGPSMocker shareInstance] respondsToSelector:sel]) {
NSAssert(NO, @"你在Delegate %@ 中所使用的SEL %@，暂不支持，请联系DoraemonKit开发者",delegate,sel);
}
}
}
free(methods);
}else{
[self doraemon_swizzleLocationDelegate:delegate];
}
} "0x2800a07a0_binder" = "<CLLocationManager: 0x2800a07a0>";
"0x2800a07a0_delegate" = "<MAMapLocationManager: 0x2800a04d0>";
"0x2800b59a0_binder" = "<CLLocationManager: 0x2800b59a0>";
"0x2800b59a0_delegate" = "<KDDriverLocationManager: 0x2829d3bf0>";
}2.4：H5任意门
有的时候Native和H5开发同时开发一个功能，H5依赖native提供入口，而这个时候Native还没有开发好，这个时候H5开发就没法在App上看到效果。再比如，有些H5页面处于的位置比较深入，就像我们代驾司机端，做单流程比较多，有的H5界面需要很繁琐的操作才能展示到App上，不方便我们查看和定位问题。 这个时候我们可以为app做一个简单的浏览器，输入url，使用自带的容器进行跳转。因为每一个app的H5容器基本上都是自定义过得，都会有自己的bridge定制化，所以这个H5容器没有办法使用系统原生的UIWebView或者WKWebView，就只能交给业务方自己去完成。我们在DorameonKit初始化的时候，提供了一个回调让业务方用自己的H5容器去打开这个Url：
[[DoraemonManager shareInstance] addH5DoorBlock:^(NSString *h5Url) {
//使用自己的H5容器打开这个链接
}];2.5：子线程UI检查
@implementation UIView (Doraemon)
+ (void)load{
[[self class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsLayout) swizzledSel:@selector(doraemon_setNeedsLayout)];
[[self class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsDisplay) swizzledSel:@selector(doraemon_setNeedsDisplay)];
[[self class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsDisplayInRect:) swizzledSel:@selector(doraemon_setNeedsDisplayInRect:)];
}
- (void)doraemon_setNeedsLayout{
[self doraemon_setNeedsLayout];
[self uiCheck];
}
- (void)doraemon_setNeedsDisplay{
[self doraemon_setNeedsDisplay];
[self uiCheck];
}
- (void)doraemon_setNeedsDisplayInRect:(CGRect)rect{
[self doraemon_setNeedsDisplayInRect:rect];
[self uiCheck];
}
- (void)uiCheck{
if([[DoraemonCacheManager sharedInstance] subThreadUICheckSwitch]){
if(![NSThread isMainThread]){
NSString *report = [BSBacktraceLogger bs_backtraceOfCurrentThread];
NSDictionary *dic = @{
@"title":[DoraemonUtil dateFormatNow],
@"content":report
};
[[DoraemonSubThreadUICheckManager sharedInstance].checkArray addObject:dic];
}
}
}
@end2.6：日志显示
收起阅读 »移动架构 (八) 人人都能看得懂的动态化加载插件技术模型实现
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。
移动架构 (五) 仅仅对 Java Bean 的操作，就能完成对数据持久化
基本概念
插件化其实也就是 模块化->组件化 演变而来, 属于动态加载技术，主要用于解决应用越来越庞大以及功能模块的解耦，小项目中一般用的不多。
原理: 插件化的原理其实就是在 APP 壳运行过程中，动态加载一些程序中原本不存在的可执行文件并运行这些文件中的代码逻辑。可执行文件总的来说分为两个，其一是动态链接库 so,其二是 dex 相关文件包括 jar/apk 文件。
发展历史
很早以前插件化这项技术已经有公司在研究了，淘宝，支付宝做的是比较早，但是淘宝这项技术一直都是保密的，直到 2015 年左右市面上才出现了一些关于插件化的框架，Android 插件化分为很多技术流派，实现的方式都不太一样。下面我就简单以时间线来举例几个比较有代表性的插件框架:
| 时间 | 框架名称 | 作者 | 框架简介 |
|---|---|---|---|
| 2014年底 | dynamic-load-apk | 主席任玉刚 | 动态加载技术 + 代理实现 |
| 2015年 8 月 | DroidPlugin | 360 手机助手 | 可以直接运行第三方的独立 APK 文件，完全不需要对 APK 进行修改或安装。一种新的插件机制，一种免安装的运行机制，是一个沙箱（但是不完全的沙箱。就是对于使用者来说，并不知道他会把 apk 怎么样）， 是模块化的基础。 |
| 2015年底 | Small | wequick | Small 是一种实现轻巧的跨平台插件化框架，基于“轻量、透明、极小化、跨平台”的理念 |
| 2017年 6 月 | VirtualAPK | 滴滴 | VirtualAPK 对插件没有额外的约束，原生的 apk 即可作为插件。插件工程编译生成 apk 后，即可通过宿主 App 加载，每个插件 apk 被加载后，都会在宿主中创建一个单独的 LoadedPlugin 对象。通过这些 LoadedPlugin 对象，VirtualAPK 就可以管理插件并赋予插件新的意义，使其可以像手机中安装过的 App 一样运行。 |
| 2017年 7 月 | RePlgin | 360手机卫士 | RePlugin 是一套完整的、稳定的、适合全面使用的，占坑类插件化方案，由 360 手机卫士的RePlugin Team 研发，也是业内首个提出”全面插件化“（全面特性、全面兼容、全面使用）的方案。 |
| 2019 | Shadow | 腾讯 | Shadow 是一个腾讯自主研发的 Android 插件框架，经过线上亿级用户量检验。 Shadow 不仅开源分享了插件技术的关键代码，还完整的分享了上线部署所需要的所有设计（零反射） |
插件化必备知识
- Binder
- APP 打包流程
- APP 安装流程
- APP 启动流程
- 资源加载机制
- 反射，ClassLoader
- ...
实现简易版本插件化框架
今天我们这里就以动态加载技术，ClassLoader + 反射 + 代理模式 等基本技术来实现动态加载 APK 中的（Activity, Broadcast, Service ,资源）项目地址
先来看一个我们最终实现的效果
加载插件 APK
在加载 APK 之前我们先来了解下 ClassLoader 家族，继承关系图
DexClassLoader 加载流程
从上面 2 张图中，我们得知动态加载 APK 需要用到 DexClassLoader ，既然知道了用 DexClassLoader 来加载 APK , 那么native 中将 apk -> dex 解析出来，class 又怎么加载勒？ 通过 DexClassLoader 流程图得知可以直接调用 loadClass(String classPath) 来加载，下面我们就正式进行今天的主题了。
代码实现加载 APK
/**
* 加载插件 APK
*/
public boolean loadPlugin(Context context, String filePath) {
if (context == null || filePath == null || filePath.isEmpty())
throw new NullPointerException("context or filePath is null ?");
this.mContext = context.getApplicationContext();
this.apkFilePath = filePath;
//拿到 包管理
packageManager = mContext.getPackageManager();
if (getPluginPackageInfo(apkFilePath) == null) {
return false;
}
//从包里获取 Activity
pluginPackageInfo = getPluginPackageInfo(apkFilePath);
//存放 DEX 路径
mDexPath = new File(Constants.IPluginPath.PlugDexPath);
if (mDexPath.exists())
mDexPath.delete();
else
mDexPath.mkdirs();
//通过 DexClassLoader 加载 apk 并通过 native 层解析 apk 输出 dex
//第二个参数可以为 null
if (getPluginClassLoader(apkFilePath, mDexPath.getAbsolutePath()) == null || getPluginResources(filePath) == null)
return false;
this.mDexClassLoader = getPluginClassLoader(apkFilePath, mDexPath.getAbsolutePath());
this.mResources = getPluginResources(filePath);
return true;
}
复制代码/**
* @return 得到对应插件 APK 的 Resource 对象
*/
public Resources getPluginResources() {
return getPluginResources(apkFilePath);
}
/**
* 得到对应插件 APK 中的 加载器
*
* @param apkFile
* @param dexPath
* @return
*/
public DexClassLoader getPluginClassLoader(String apkFile, String dexPath) {
return new DexClassLoader(apkFile, dexPath, null, mContext.getClassLoader());
}
/**
* 得到对应插件 APK 中的 加载器
*
* @return
*/
public DexClassLoader getPluginClassLoader() {
return getPluginClassLoader(apkFilePath, mDexPath.getAbsolutePath());
}
/**
* 得到插件 APK 中 包信息
*/
public PackageInfo getPluginPackageInfo(String apkFilePath) {
if (packageManager != null)
return packageManager.getPackageArchiveInfo(apkFilePath, PackageManager.GET_ACTIVITIES);
return null;
}
/**
* 得到插件 APK 中 包信息
*/
public PackageInfo getPluginPackageInfo() {
return getPluginPackageInfo(apkFilePath);
}
复制代码加载插件中 Activity
实现流程
代码实现流程
代理类 ProxyActivity 实现
public class ProxyActivity extends AppCompatActivity {
/**
* 需要加载插件的全类名
*/
protected String activityClassName;
private String TAG = this.getClass().getSimpleName();
private IActivity iActivity;
private ProxyBroadcast receiver;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
activityClassName = getLoadClassName();
//拿到加载插件的的全类名 通过反射实例化
try {
Class<?> pluginClassName = getClassLoader().loadClass(activityClassName);
//拿到构造函数
Constructor<?> constructor = pluginClassName.getConstructor(new Class[]{});
//实例化 拿到插件 UI
Object pluginObj = constructor.newInstance(new Object[]{});
if (pluginObj != null) {
iActivity = (IActivity) pluginObj;
iActivity.onActivityCreated(this, savedInstanceState);
}
} catch (Exception e) {
Log.e(TAG, e.getMessage());
}
}
}
复制代码
重写代理类中的 startActivity
/**
* 这里的 startActivity 是插件促使调用的
*/
@Override
public void startActivity(Intent intent) {
//需要开启插件 Activity 的全类名
String className = getLoadClassName(intent);
Intent proxyIntent = new Intent(this, ProxyActivity.class);
proxyIntent.putExtra(Constants.ACTIVITY_CLASS_NAME, className);
super.startActivity(proxyIntent);
}
复制代码
插件 Activity 实现 IActivity 的生命周期并且重写一些重要函数，都交于插件中处理
public class BaseActivityImp extends AppCompatActivity implements IActivity {
private final String TAG = getClass().getSimpleName();
/**
* 代理 Activity
*/
protected Activity that;
@Override
public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {
this.that = activity;
Log.i(TAG, " onActivityCreated");
onCreate(bundle);
}
/**
* 通过 View 方式加载
*
* @param view
*/
@Override
public void setContentView(View view) {
Log.i(TAG, " setContentView --> view");
if (that != null) {
that.setContentView(view);
} else {
super.setContentView(view);
}
}
/**
* 通过 layoutID 加载
*
* @param layoutResID
*/
@Override
public void setContentView(int layoutResID) {
Log.i(TAG, " setContentView --> layoutResID");
if (that != null) {
that.setContentView(layoutResID);
} else {
super.setContentView(layoutResID);
}
}
/**
* 通过代理 去找布局 ID
*
* @param id
* @param <T>
* @return
*/
@Override
public <T extends View> T findViewById(int id) {
if (that != null)
return that.findViewById(id);
return super.findViewById(id);
}
/**
* 通过 代理去开启 Activity
*
* @param intent
*/
@Override
public void startActivity(Intent intent) {
if (that != null) {
Intent tempIntent = new Intent();
tempIntent.putExtra(Constants.ACTIVITY_CLASS_NAME, intent.getComponent().getClassName());
that.startActivity(tempIntent);
} else
super.startActivity(intent);
}
@Override
public String getPackageName() {
return that.getPackageName();
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
Log.i(TAG, " onActivityStarted");
onStart();
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
Log.i(TAG, " onActivityResumed");
onResume();
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
Log.i(TAG, " onActivityPaused");
onPause();
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
Log.i(TAG, " onActivityStopped");
onStop();
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle bundle) {
onSaveInstanceState(bundle);
Log.i(TAG, " onActivitySaveInstanceState");
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
Log.i(TAG, " onActivityDestroyed");
onDestroy();
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
}
@Override
protected void onStart() {
}
@Override
protected void onResume() {
}
@Override
protected void onStop() {
}
@Override
protected void onPause() {
}
@Override
protected void onSaveInstanceState(Bundle outState) {
}
@Override
protected void onDestroy() {
}
@Override
public void onBackPressed() {
}
}
复制代码
加载插件中 Broadcast
流程图
代码实现
代理 ProxyActivity 中重写注册广播
@Override
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
IntentFilter proxyIntentFilter = new IntentFilter();
for (int i = 0; i < filter.countActions(); i++) {
//内部是一个数组
proxyIntentFilter.addAction(filter.getAction(i));
}
//交给代理广播去注册
this.receiver = new ProxyBroadcast(receiver.getClass().getName(), this);
return super.registerReceiver(this.receiver, filter);
}
复制代码
加载插件中需要注册的广播全路径
public ProxyBroadcast(String broadcastClassName, Context context) {
this.broadcastClassName = broadcastClassName;
this.iBroadcast = iBroadcast;
//通过加载插件的 DexClassLoader loadClass
try {
Class<?> pluginBroadcastClassName = PluginManager.getInstance().getPluginClassLoader().loadClass(broadcastClassName);
Constructor<?> constructor = pluginBroadcastClassName.getConstructor(new Class[]{});
iBroadcast = (IBroadcast) constructor.newInstance(new Object[]{});
//返回给插件中广播生命周期
iBroadcast.attach(context);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, e.getMessage());
}
}
复制代码
接收到消息返回给插件中
@Override
public void onReceive(Context context, Intent intent) {
iBroadcast.onReceive(context, intent);
}
复制代码
插件中广播注册
/**
* 动态注册广播
*/
public void register() {
//动态注册广播
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("_DevYK");
receiver = new PluginBroadReceiver();
registerReceiver(receiver, intentFilter);
}
/**
* 通过代理去注册广播
*
* @param receiver
* @param filter
* @return
*/
@Override
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
if (that != null) {
return that.registerReceiver(receiver, filter);
} else
return super.registerReceiver(receiver, filter);
}
复制代码
插件中实现代理广播中的生命周期并实现接收函数
public class BaseBroadReceiverImp extends BroadcastReceiver implements IBroadcast {
//代理广播中绑定成功插件广播
@Override
public void attach(Context context) {
}
//代理广播接收到数据转发给插件中
@Override
public void onReceive(Context context, Intent intent) {
}
}
复制代码
加载插件中 Service
流程图
代码实现
ProxyAcitivy 开启插件中服务
/**
* 加载插件中 启动服务
* @param service
* @return
*/
@Override
public ComponentName startService(Intent service) {
String className = getLoadServiceClassName(service);
Intent intent = new Intent(this,ProxyService.class);
intent.putExtra(Constants.SERVICE_CLASS_NAME,className);
return super.startService(intent);
}
复制代码ProxyService.java
public class ProxyService extends Service {
private IService iService;
@Override
public IBinder onBind(Intent intent) {
return iService.onBind(intent);
}
@Override
public void onCreate() {
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (iService == null)
init(intent);
return iService.onStartCommand(intent, flags, startId);
}
@Override
public void onStart(Intent intent, int startId) {
super.onStart(intent, startId);
iService.onStart(intent,startId);
}
@Override
public boolean onUnbind(Intent intent) {
iService.onUnbind(intent);
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
super.onDestroy();
iService.onDestroy();
}
//初始化
public void init(Intent proIntent) {
//拿到需要启动服务的全类名
String serviceClassName = getServiceClassName(proIntent);
try {
Class<?> pluginService = PluginManager.getInstance().getPluginClassLoader().loadClass(serviceClassName);
Constructor<?> constructor = pluginService.getConstructor(new Class[]{});
iService = (IService) constructor.newInstance(new Object[]{});
iService.onCreate(getApplicationContext());
} catch (Exception e) {
//加载 class
}
}
@Override
public ClassLoader getClassLoader() {
return PluginManager.getInstance().getPluginClassLoader();
}
public String getServiceClassName(Intent intent) {
return intent.getStringExtra(Constants.SERVICE_CLASS_NAME);
}
}
复制代码
插件服务实现 IService
public class BaseServiceImp extends Service implements IService {
...
}
复制代码
插件中重写 startService 交于代理中处理
/**
* 加载插件中服务，交于代理处理
* @param service
* @return
*/
@Override
public ComponentName startService(Intent service) {
String className = getLoadServiceClassName(service);
Intent intent = new Intent(this,ProxyService.class);
intent.putExtra(Constants.SERVICE_CLASS_NAME,className);
return super.startService(intent);
}
复制代码
总结
动态加载 Activity, Broadcast , Service 其实基本原理就是将插件中需要启动四大组件的信息告诉代理类中，让代理类来负责处理插件中的逻辑，代理类中处理完之后通过 IActivity, IBroadcast, IService 来通知插件。
动态加载插件我们这篇文章就讲到这里了，感兴趣的可以参考项目地址 ，这个实现方案不适合线上商业项目，使用需谨慎。如果项目中只用到了插件中的生命周期可以选择性的使用。
感谢阅览本篇文章，谢谢！
参考文章
作者：DevYK
链接：https://juejin.cn/post/6844903924000882695
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动架构 (六) 轻量级进程间通信框架设计
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。
移动架构 (五) 仅仅对 Java Bean 的操作，就能完成对数据持久化
概述
现在多进程传递数据使用越来越广泛了，在 Android 中进程间通信提供了 文件 、AIDL 、Binder 、Messenger 、ContentProvider 、Socket 、MemoryFile 等，实际开发中使用最多的应该是 AIDL ,但是 AIDL 需要编写 aidl 文件，如果使用 AIDL 仅仅是为了传递数据, 那么 YKProBus 是你不错的选择。
YKProBus
怎么使用？
1. root/build.gradle 中添加框架 maven
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
复制代码2. app/build.gradle 中添加框架 依赖
dependencies {
implementation 'com.github.yangkun19921001:YKProBus:1.0.1'
}
复制代码3. 发送进程绑定接收进程服务
EventManager.getInstance().bindApplication(Context context,String proName);
复制代码4. 发送消息
EventManager.getInstance().sendMessage(int messageTag,Bundle bundle);
复制代码5. 接收进程中需要在清单文件注册服务
<service
android:name="com.devyk.component_eventbus.proevent.service.MessengerService"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="com.devyk.component_eventbus.service"></action>
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
复制代码6. 接收消息
6.1 在需要接收消息的类中实现 IMessageHandler 并实例化一个 Handler 用于接收发送进程发来的消息
public class MainActivity extends Activity implements IMessageHandler{
...
/**
* 接收其它进程发送过来的消息
*
* @return
*/
@Override
public Handler getHandler() {
return new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0x001:
...
break;
}
}
};
}
...
}
复制代码6.2 注册当前类需要接收消息
EventManager.getInstance().registerMessager(int messageTag, Object obj);
复制代码框架设计大概流程
Messenger 源码分析
Messenger 内部其实也是依赖 aidl 实现的进程间通信。
服务端
@Override
public IBinder onBind(Intent intent) {
return mServiceMessenger.getServiceMessenger().getBinder();
}
复制代码getBinder() 跟进去
public IBinder getBinder() {
return mTarget.asBinder();
}
复制代码mTarget 从何而来，从源码找找
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
复制代码这里是我们实例化 服务端 Messenger 传入的 Handler target
/**
* 初始化服务端 Messenger
*/
public MessengerManager() {
if (null == mServiceMessenger)
mServiceMessenger = new Messenger(mMessengerServiceHandler);
}
复制代码那么我们在点击 getIMessenger() 在看看内部实现
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}
复制代码继续点击 MessengerImple
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}
复制代码这个是一个内部实现的类，可以看到继承的是 IMessenger.Stub 然后实现 send (Message msg) 函数，然后通过 mTarget.sendMessage(msg) 发送消息，最后在我们传入进去的 mMessengerServiceHandler 的 handleMessage (Message) 接收发来的消息。
既然这里内部帮我们写了 aidl 文件 ，并且也继承了 IMessenger.Stub 我们今天就要看到 aidl 才死心 ， 好吧我们来找找 IMessenger aidl 文件。
可以看到是在 framework/base/core/java/android/os 路径中，我们点击在来看下文件中怎么写的
内部就一个 send 函数，看到这，大家应该都明白了，Messenger 其实也没什么大不了，就是系统内部帮我们写了 aidl 并且也实现了 aidl ，最后又帮我们做了一个 Handler 线程间通信，所以服务端收到了客服端发来的消息。
客服端
客服端需要在 bindServicer onServiceConnected 回调中拿到 servicer, 平时我们自己写 应该是这么拿到 Ibinder 对象吧
IMessenger mServiceMessenger = IMessenger.Stub.asInterface(service);
复制代码但是我们实际客服端是这样拿到服务端的 Messenger
/**
* 服务端消息是否连接成功
*/
private class EventServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
isBindApplication = true;
// 得到服务信使对象
mServiceMessenger = new Messenger(service);
//将本地信使告诉服务端
registerMessenger();
String proName = ProcessUtils.getProName(mApplicationContext);
Log.d(TAG, " EventServiceConnection " + proName);
}
@Override
public void onServiceDisconnected(ComponentName name) {
isBindApplication = false;
}
}
复制代码// 得到服务信使对象
mServiceMessenger = new Messenger(service);
复制代码跟进去
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
复制代码这不就是我们刚刚说的自己实现的那种写法吧，到这里我们都懂了吧，我们平时写的 aidl android 中已经帮我们写了，想当于在 aidl 中封装下就变成了现在的 Messenger , 而我们又在 Messenger 上封装了下，想当于 三次封装了，为了使用更简单。封装才是王道！
总结
我们自己的 YKProBus 为了进程间通信使用更简单方便，其实相当于在 AIDL 中的三次封装。想要了解的可以去看下我具体的封装或者 Messenger 源码。
感谢大家抽空阅览文章，谢谢！
作者：DevYK
链接：https://juejin.cn/post/6844903910587498510
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
iOS使用RunLoop监控线上卡顿
通过iOS性能优化 我们知道，简单来说App卡顿，就是FPS达不到60帧率，丢帧现象，就会卡顿。但是很多时候，我们只知道丢帧了。具体为什么丢帧，却不是很清楚，那么我们要怎么监控呢，首先我们要明白，要找出卡顿，就是要找出主线程做了什么，而线程消息，是依赖RunLoop的，所以我们可以使用RunLoop来监控。
RunLoop是用来监听输入源，进行调度处理的。如果RunLoop的线程进入睡眠前方法的执行时间过长而导致无法进入睡眠，或者线程唤醒后接收消息时间过长而无法进入下一步，就可以认为是线程受阻了。如果这个线程是主线程的话，表现出来的就是出现了卡顿。
RunLoop和信号量
我们可以使用CFRunLoopObserverRef来监控NSRunLoop的状态,通过它可以实时获得这些状态值的变化。
runloop
关于runloop,可以参照 RunLoop详解之源码分析 这篇文章详细了解。这里简单总结一下:
runloop的状态
/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
kCFRunLoopEntry = (1UL << 0), // 即将进入Loop
kCFRunLoopBeforeTimers = (1UL << 1), //即将处理Timer
kCFRunLoopBeforeSources = (1UL << 2), //即将处理Source
kCFRunLoopBeforeWaiting = (1UL << 5), //即将进入休眠
kCFRunLoopAfterWaiting = (1UL << 6), //刚从休眠中唤醒
kCFRunLoopExit = (1UL << 7), //即将退出Loop
kCFRunLoopAllActivities = 0x0FFFFFFFU //所有状态改变
};CFRunLoopObserverRef 的使用流程
设置Runloop observer的运行环境
CFRunLoopObserverContext context = {0, (__bridge void *)self, NULL, NULL};2. 创建Runloop observer对象
第一个参数：用于分配observer对象的内存
第二个参数：用以设置observer所要关注的事件
第三个参数：用于标识该observer是在第一次进入runloop时执行还是每次进入runloop处理时均执行
第四个参数：用于设置该observer的优先级
第五个参数：用于设置该observer的回调函数
第六个参数：用于设置该observer的运行环境
// 创建Runloop observer对象
_observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
kCFRunLoopAllActivities,
YES,
0,
&runLoopObserverCallBack,
&context);
3. 将新建的observer加入到当前thread的runloop
CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
4. 将observer从当前thread的runloop中移除
CFRunLoopRemoveObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
5. 释放 observer
CFRelease(_observer); _observer = NULL;信号量
关于信号量，可以详细参考 GCD信号量-dispatch_semaphore_t
简单来说,主要有三个函数
dispatch_semaphore_create(long value); // 创建信号量
dispatch_semaphore_signal(dispatch_semaphore_t deem); // 发送信号量
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); // 等待信号量dispatch_semaphore_create(long value);和GCD的group等用法一致，这个函数是创建一个dispatch_semaphore_类型的信号量，并且创建的时候需要指定信号量的大小。
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 等待信号量。如果信号量值为0，那么该函数就会一直等待，也就是不返回（相当于阻塞当前线程），直到该函数等待的信号量的值大于等于1，该函数会对信号量的值进行减1操作，然后返回。
dispatch_semaphore_signal(dispatch_semaphore_t deem); 发送信号量。该函数会对信号量的值进行加1操作。
通常等待信号量和发送信号量的函数是成对出现的。并发执行任务时候，在当前任务执行之前，用dispatch_semaphore_wait函数进行等待（阻塞），直到上一个任务执行完毕后且通过dispatch_semaphore_signal函数发送信号量（使信号量的值加1），dispatch_semaphore_wait函数收到信号量之后判断信号量的值大于等于1，会再对信号量的值减1，然后当前任务可以执行，执行完毕当前任务后，再通过dispatch_semaphore_signal函数发送信号量（使信号量的值加1），通知执行下一个任务……如此一来，通过信号量，就达到了并发队列中的任务同步执行的要求。
监控卡顿
原理: 利用观察Runloop各种状态变化的持续时间来检测计算是否发生卡顿
一次有效卡顿采用了“N次卡顿超过阈值T”的判定策略，即一个时间段内卡顿的次数累计大于N时才触发采集和上报：举例，卡顿阈值T=500ms、卡顿次数N=1，可以判定为单次耗时较长的一次有效卡顿；而卡顿阈值T=50ms、卡顿次数N=5，可以判定为频次较快的一次有效卡顿
主要代码
// minimum
static const NSInteger MXRMonitorRunloopMinOneStandstillMillisecond = 20;
static const NSInteger MXRMonitorRunloopMinStandstillCount = 1;
// default
// 超过多少毫秒为一次卡顿
static const NSInteger MXRMonitorRunloopOneStandstillMillisecond = 50;
// 多少次卡顿纪录为一次有效卡顿
static const NSInteger MXRMonitorRunloopStandstillCount = 1;
@interface YZMonitorRunloop(){
CFRunLoopObserverRef _observer; // 观察者
dispatch_semaphore_t _semaphore; // 信号量
CFRunLoopActivity _activity; // 状态
}
@property (nonatomic, assign) BOOL isCancel; //f是否取消检测
@property (nonatomic, assign) NSInteger countTime; // 耗时次数
@property (nonatomic, strong) NSMutableArray *backtrace;-(void)registerObserver{
// 1. 设置Runloop observer的运行环境
CFRunLoopObserverContext context = {0, (__bridge void *)self, NULL, NULL};
// 2. 创建Runloop observer对象
// 第一个参数：用于分配observer对象的内存
// 第二个参数：用以设置observer所要关注的事件
// 第三个参数：用于标识该observer是在第一次进入runloop时执行还是每次进入runloop处理时均执行
// 第四个参数：用于设置该observer的优先级
// 第五个参数：用于设置该observer的回调函数
// 第六个参数：用于设置该observer的运行环境
_observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
kCFRunLoopAllActivities,
YES,
0,
&runLoopObserverCallBack,
&context);
// 3. 将新建的observer加入到当前thread的runloop
CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
// 创建信号 dispatchSemaphore的知识参考：https://www.jianshu.com/p/24ffa819379c
_semaphore = dispatch_semaphore_create(0); ////Dispatch Semaphore保证同步
__weak __typeof(self) weakSelf = self;
// dispatch_queue_t queue = dispatch_queue_create("kadun", NULL);
// 在子线程监控时长
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// dispatch_async(queue, ^{
__strong __typeof(weakSelf) strongSelf = weakSelf;
if (!strongSelf) {
return;
}
while (YES) {
if (strongSelf.isCancel) {
return;
}
// N次卡顿超过阈值T记录为一次卡顿
// 等待信号量：如果信号量是0，则阻塞当前线程；如果信号量大于0，则此函数会把信号量-1，继续执行线程。此处超时时间设为limitMillisecond 毫秒。
// 返回值：如果线程是唤醒的，则返回非0，否则返回0
long semaphoreWait = dispatch_semaphore_wait(self->_semaphore, dispatch_time(DISPATCH_TIME_NOW, strongSelf.limitMillisecond * NSEC_PER_MSEC));
if (semaphoreWait != 0) {
// 如果 RunLoop 的线程，进入睡眠前方法的执行时间过长而导致无法进入睡眠(kCFRunLoopBeforeSources)，或者线程唤醒后接收消息时间过长(kCFRunLoopAfterWaiting)而无法进入下一步的话，就可以认为是线程受阻。
//两个runloop的状态，BeforeSources和AfterWaiting这两个状态区间时间能够监测到是否卡顿
if (self->_activity == kCFRunLoopBeforeSources || self->_activity == kCFRunLoopAfterWaiting) {
if (++strongSelf.countTime < strongSelf.standstillCount){
NSLog(@"%ld",strongSelf.countTime);
continue;
}
[strongSelf logStack];
[strongSelf printLogTrace];
NSString *backtrace = [YZCallStack yz_backtraceOfMainThread];
NSLog(@"++++%@",backtrace);
[[YZLogFile sharedInstance] writefile:backtrace];
if (strongSelf.callbackWhenStandStill) {
strongSelf.callbackWhenStandStill();
}
}
}
strongSelf.countTime = 0;
}
});
}demo测试
我把demo放在了github demo地址
使用时候，只需要
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
// Override point for customization after application launch.
[[YZMonitorRunloop sharedInstance] startMonitor];
[YZMonitorRunloop sharedInstance].callbackWhenStandStill = ^{
NSLog(@"eagle.检测到卡顿了");
};
return YES;
}控制器中，每次点击屏幕，休眠1秒钟，如下
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
usleep(1 * 1000 * 1000); // 1秒
}
@end点击屏幕之后，打印如下
YZMonitorRunLoopDemo[10288:1915706] ==========检测到卡顿之后调用堆栈==========
(
"0 YZMonitorRunLoopDemo 0x00000001022c653c -[YZMonitorRunloop logStack] + 96",
"1 YZMonitorRunLoopDemo 0x00000001022c62a0 __36-[YZMonitorRunloop registerObserver]_block_invoke + 484",
"2 libdispatch.dylib 0x00000001026ab6f0 _dispatch_call_block_and_release + 24",
"3 libdispatch.dylib 0x00000001026acc74 _dispatch_client_callout + 16",
"4 libdispatch.dylib 0x00000001026afad4 _dispatch_queue_override_invoke + 876",
"5 libdispatch.dylib 0x00000001026bddc8 _dispatch_root_queue_drain + 372",
"6 libdispatch.dylib 0x00000001026be7ac _dispatch_worker_thread2 + 156",
"7 libsystem_pthread.dylib 0x00000001b534d1b4 _pthread_wqthread + 464",
"8 libsystem_pthread.dylib 0x00000001b534fcd4 start_wqthread + 4"
)
libsystem_kernel.dylib 0x1b52ca400 __semwait_signal + 8
libsystem_c.dylib 0x1b524156c nanosleep + 212
libsystem_c.dylib 0x1b5241444 usleep + 64
YZMonitorRunLoopDemo 0x1022c18dc -[ViewController touchesBegan:withEvent:] + 76
UIKitCore 0x1e1f4fcdc <redacted> + 336
UIKitCore 0x1e1f4fb78 <redacted> + 60
UIKitCore 0x1e1f5e0f8 <redacted> + 1584
UIKitCore 0x1e1f5f52c <redacted> + 3140
UIKitCore 0x1e1f3f59c <redacted> + 340
UIKitCore 0x1e2005714 <redacted> + 1768
UIKitCore 0x1e2007e40 <redacted> + 4828
UIKitCore 0x1e2001070 <redacted> + 152
CoreFoundation 0x1b56bf018 <redacted> + 24
CoreFoundation 0x1b56bef98 <redacted> + 88
CoreFoundation 0x1b56be880 <redacted> + 176
CoreFoundation 0x1b56b97即可定位到卡顿位置
-[ViewController touchesBegan:withEvent:]
卡顿日志写入本地
上面已经监控到了卡顿，和调用堆栈。如果是debug模式下，可以直接看日志，如果想在线上查看的话，可以写入本地，然后上传到服务器
写入本地数据库
创建本地路径
-(NSString *)getLogPath{
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,NSUserDomainMask,YES);
NSString *homePath = [paths objectAtIndex:0];
NSString *filePath = [homePath stringByAppendingPathComponent:@"Caton.log"];
return filePath;
}如果是第一次写入，带上设备信息，手机型号等信息
NSString *filePath = [self getLogPath];
NSFileManager *fileManager = [NSFileManager defaultManager];
if(![fileManager fileExistsAtPath:filePath]) //如果不存在
{
NSString *str = @"卡顿日志";
NSString *systemVersion = [NSString stringWithFormat:@"手机版本: %@",[YZAppInfoUtil iphoneSystemVersion]];
NSString *iphoneType = [NSString stringWithFormat:@"手机型号: %@",[YZAppInfoUtil iphoneType]];
str = [NSString stringWithFormat:@"%@\n%@\n%@",str,systemVersion,iphoneType];
[str writeToFile:filePath atomically:YES encoding:NSUTF8StringEncoding error:nil];
}如果本地文件已经存在，就先判断大小是否过大，决定是否直接写入，还是先上传到服务器
float filesize = -1.0;
if ([fileManager fileExistsAtPath:filePath]) {
NSDictionary *fileDic = [fileManager attributesOfItemAtPath:filePath error:nil];
unsigned long long size = [[fileDic objectForKey:NSFileSize] longLongValue];
filesize = 1.0 * size / 1024;
}
NSLog(@"文件大小 filesize = %lf",filesize);
NSLog(@"文件内容 %@",string);
NSLog(@" ---------------------------------");
if (filesize > (self.MAXFileLength > 0 ? self.MAXFileLength:DefaultMAXLogFileLength)) {
// 上传到服务器
NSLog(@" 上传到服务器");
[self update];
[self clearLocalLogFile];
[self writeToLocalLogFilePath:filePath contentStr:string];
}else{
NSLog(@"继续写入本地");
[self writeToLocalLogFilePath:filePath contentStr:string];
}压缩日志，上传服务器
因为都是文本数据，所以我们可以压缩之后，打打降低占用空间，然后进行上传，上传成功之后，删除本地，然后继续写入，等待下次写日志
压缩工具
使用 SSZipArchive具体使用起来也很简单，
// Unzipping
NSString *zipPath = @"path_to_your_zip_file";
NSString *destinationPath = @"path_to_the_folder_where_you_want_it_unzipped";
[SSZipArchive unzipFileAtPath:zipPath toDestination:destinationPath];
// Zipping
NSString *zippedPath = @"path_where_you_want_the_file_created";
NSArray *inputPaths = [NSArray arrayWithObjects:
[[NSBundle mainBundle] pathForResource:@"photo1" ofType:@"jpg"],
[[NSBundle mainBundle] pathForResource:@"photo2" ofType:@"jpg"]
nil];
[SSZipArchive createZipFileAtPath:zippedPath withFilesAtPaths:inputPaths];代码中
NSString *zipPath = [self getLogZipPath];
NSString *password = nil;
NSMutableArray *filePaths = [[NSMutableArray alloc] init];
[filePaths addObject:[self getLogPath]];
BOOL success = [SSZipArchive createZipFileAtPath:zipPath withFilesAtPaths:filePaths withPassword:password.length > 0 ? password : nil];
if (success) {
NSLog(@"压缩成功");
}else{
NSLog(@"压缩失败");
}具体如果上传到服务器，使用者可以用AFN等将本地的 zip文件上传到文件服务器即可，就不赘述了。
至此，我们做到了，用runloop，监控卡顿，写入日志，然后压缩上传服务器，删除本地的过程。
详细代码见demo地址
转自：https://www.jianshu.com/p/05ae5ff5a9c1
移动架构 (五) 仅仅对 Java Bean 的操作，就能完成对数据持久化
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。
前言
GitHub 上面开源了多个 Android 数据库，比如 GreenDao , LitePal , ORMLite 等，开源的数据库一般都是使用非常简单，不用开发者写 SQL，创建 table 等一些繁琐的操作，都是基于对对象的一些操作。那么我们自己可以设计一款不用自己来写 SQL 的轻量级数据库吗？当然可以，下面我们就来开干。
使用
给一个 Object 对象定义协定好的注解 table ,id
@YKTable("tb_police")
public class Police {
/**
* 人员 id
*/
@YKField("_id")
private String id;
/**
* 人员姓名
*/
private String name;
public Police(String id, String name) {
this.id = id;
this.name = name;
}
public Police() {
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Police{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
'}';
}
}
复制代码
插入数据
BaseDaoFactory.getOurInstance().getBaseDao(Police.class).insert(new Police("01", "DevYK"));
复制代码
删除数据
BaseDaoFactory.getOurInstance().getBaseDao(Police.class).delete(new Police("01", "DevYK"));
复制代码
更新数据
BaseDaoFactory.getOurInstance().getBaseDao(Police.class).updata(new Police("02", "BaseDevYK"), new Police("01", "DevYK"));
复制代码
查询数据
BaseDaoImp<Police> mBaseDao BaseDaoFactory.getOurInstance().getBaseDao(Police.class);
Police police = new Police();
police.setId("02");
List<Police> policeLists = mBaseDao.query(police);
复制代码
到这里，增删改查咱们都已经操作完了，使用是不是非常的简单，不用使用者写一行 SQL 语句，基本上一行代码解决，下面我们来看看源码实现，它到底做了些什么？
自动创建 table
流程
创建表核心代码
/**
* 初始化
*
* @param sqLiteDatabase
* @param entityClass
*/
public void init(SQLiteDatabase sqLiteDatabase, Class<T> entityClass) {
this.mSQLiteDatabase = sqLiteDatabase;
this.mEntityClass = entityClass;
if (!isInit) {
//自动建表，取得表名
if (entityClass != null && (entityClass.getAnnotation(YKTable.class) == null)) {
//通过反射得到类名
this.mTableName = entityClass.getSimpleName();
} else {
if (TextUtils.isEmpty(entityClass.getAnnotation(YKTable.class).value())) {
//如果有注解但是注解为空的话，就取当前 类名
this.mTableName = entityClass.getSimpleName();
} else {
//取得注解上面的表名
this.mTableName = entityClass.getAnnotation(YKTable.class).value();
}
}
//执行创建表的操作， 使用 getCreateTabeSql () 生成 sql 语句
String autoCreateTabSql = getCreateTableSql();
Log.i(TAG, "tagSQL-->" + autoCreateTabSql);
//执行创建表的 SQL
this.mSQLiteDatabase.execSQL(autoCreateTabSql);
mCacheMap = new HashMap<>();
initCacheMap();
isInit = true;
}
}
复制代码insert 插入数据
流程
插入核心代码
/**
* 插入数据
* @param entity
* @return
*/
@Override
public long insert(T entity) {
//1. 准备好 ContentValues 中需要的数据
Map<String, String> map = getValues(entity);
if (map == null || map.size() == 0) return 0;
//2. 把数据转移到 ContentValues 中
ContentValues values = getContentValues(map);
//将数据插入表中
return mSQLiteDatabase.insert(mTableName, null, values);
}
复制代码- 首先接收外部传入的数据对象。
- 对数据对象进行解析，拿到数据库表中对应字段的值，拿到之后将字段 key,对应的值 values 存入 map。
- 将 map 解析为 ContentValues。
- 进行数据库插入 mSQLiteDatabase.insert。
delete 删除数据
流程图
核心代码流程
拿到对应字段的值
/**
* key(字段) - values(成员变量) ---》getValues 后 ---》key (成员变量的名字) ---values 成员变量的值 id 1，name alan , password 123
*
* @param entity
* @return
*/
private Map<String, String> getValues(T entity) {
HashMap<String, String> map = new HashMap<>();
//返回所有的成员变量
Iterator<Field> iterator = mCacheMap.values().iterator();
while (iterator.hasNext()) {
Field field = iterator.next();
field.setAccessible(true);
try {
Object object = field.get(entity);
if (object == null) {
continue;
}
String values = object.toString();
String key = "";
if (field.getAnnotation(YKField.class) != null) {
key = field.getAnnotation(YKField.class).value();
} else {
key = field.getName();
}
if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(values)) {
map.put(key, values);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return map;
}
复制代码
将拿到要删除的 key,values 字段对应的值，自动生成 SQL
public Condition(Map<String,String> whereCasue) {
//whereArgs 里面的内容存入的 list
ArrayList list = new ArrayList();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("1=1");
//取得所有成员变量的名字
Set<String> keys = whereCasue.keySet();
Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()) {
String key = iterator.next();
String value = whereCasue.get(key);
if (value != null){
stringBuffer.append(" and " + key + "=?");
list.add(value);
}
}
this.whereClause = stringBuffer.toString();
this.whereArgs = (String[]) list.toArray(new String[list.size()]);
}
复制代码
根据生成的 SQL 条件删除数据
int delete = mSQLiteDatabase.delete(mTableName, condition.getWhereClause(), condition.getWhereArgs());
复制代码
query 查询数据
流程图
核心代码流程
拿到查询的条件的对象，转为 key,values 的 map 对象
Map<String, String> values = getValues(where);
private Map<String, String> getValues(T entity) {
HashMap<String, String> map = new HashMap<>();
//返回所有的成员变量
Iterator<Field> iterator = mCacheMap.values().iterator();
while (iterator.hasNext()) {
//拿到成员变量
Field field = iterator.next();
//设置可操作的权限
field.setAccessible(true);
try {
//拿到成员变量对应的值 values
Object object = field.get(entity);
if (object == null) {
continue;
}
String values = object.toString();
String key = "";
//如果成员变量上声明了注解，直接拿到该值 key,反之反射拿
if (field.getAnnotation(YKField.class) != null) {
key = field.getAnnotation(YKField.class).value();
} else {
key = field.getName();
}
//将类中拿到的 key values 存入 map 中
if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(values)) {
map.put(key, values);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return map;
}
复制代码
将 map 转为自动生成 SQL 对象
public Condition(Map<String,String> whereCasue) {
//whereArgs 里面的内容存入的 list
ArrayList list = new ArrayList();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("1=1");
//取得所有成员变量的名字
Set<String> keys = whereCasue.keySet();
Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()) {
String key = iterator.next();
String value = whereCasue.get(key);
if (value != null){
//查询的条件 sql
stringBuffer.append(" and " + key + "=?");
//查询的条件对应的 值
list.add(value);
}
}
this.whereClause = stringBuffer.toString();
this.whereArgs = (String[]) list.toArray(new String[list.size()]);
}
复制代码
查询数据，并遍历 Cursor 取出数据
Cursor cursor = mSQLiteDatabase.query(mTableName,null,condition.getWhereClause(), condition.getWhereArgs(), null, limitString, orderBy);
List<T> result = getResult(cursor, where);
复制代码
update 更新数据
流程图
核心代码流程
拿到需要更新的值，转为 map
Map<String, String> values = getValues(entity);
复制代码
将需要更新的 map 转为 ContentValues
ContentValues contentValues = getContentValues(values);
复制代码
将条件转为 map
//条件
Map<String, String> whereMp = getValues(where);
复制代码
将条件 map 转为 sql
public Condition(Map<String,String> whereCasue) {
//whereArgs 里面的内容存入的 list
ArrayList list = new ArrayList();
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("1=1");
//取得所有成员变量的名字
Set<String> keys = whereCasue.keySet();
Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()) {
String key = iterator.next();
String value = whereCasue.get(key);
if (value != null){
//查询的条件 sql
stringBuffer.append(" and " + key + "=?");
//查询的条件对应的 值
list.add(value);
}
}
this.whereClause = stringBuffer.toString();
this.whereArgs = (String[]) list.toArray(new String[list.size()]);
}
复制代码
总结
通过上面的步骤，我们不编写 SQL ，完全是依赖数据对象来做操作，对 SQL 不太熟悉的很友好。对于那些开源框架为什么可以自动建表，不用填写 SQL ，仅仅通过数据 Bean 就能操作数据库的好奇，在没有了解它们内部实现的原理下，看看自己能不能实现，结果也没那么难嘛。但是实际项目还是建议在了解内部实现原理的情况下使用开源框架。在这里推荐下 郭霖大神的 LitePal 框架非常稳定，使用非常简单，易上手。
如果对上面源码感兴趣的可以去我的代码仓库YKDB详细了解。
作者：DevYK
链接：https://juejin.cn/post/6844903907613753351
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
收起阅读 »
移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。
移动架构 (一) 架构第一步，学会画各种 UML 图
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
EventBus 我相信大家不会很默认，应该也都在项目中使用过，虽然 EventBus 在项目中不便于管理，发射出去的消息不便于跟踪或者阅读，但是不可否认它是一个优秀的开源项目，还是值得我们大家学习的，我个人感觉唯一不足的就是 EventBus 功能上不能根据 TAG 来进行发射和接收消息，只能通过注解 + 消息类型进行找消息。那么我们自己可以实现这个功能吗？不可否认，当然可以! 想要实现这个功能，我们先大概简要的了解下 EventBus 使用及源码是怎么实现的。
EventBus 简单使用
EventBus 可以代替 Android 传统的 Intent, Handler, Broadcast 或接口函数, 在 Fragment, Activity, Service 线程间进行数据传递。
添加 EventBus 到项目中
implementation 'org.greenrobot:eventbus:3.1.1'
复制代码register
EventBus.getDefault().register(this);
复制代码注解实现接收的 Event
@Subscribe(threadMode = ThreadMode.MAIN)
public void receive(String event){
Log.d(TAG,"接收到 EventBus post message:" + event);
}
复制代码发射数据
EventBus.getDefault().post("发射一个测试消息");
复制代码注销注册的事件
EventBus.getDefault().unregister(this);
复制代码这里就简单介绍下 EventBus 使用，想详细了解的可以看 EventBus GitHub
EventBus 3.1.1 源码分析
上面小节咱们学习了 EventBus 的简单使用，那么我们就根据上面使用到的来进行源码分析。
register
流程图:
register 代码:
/**
*
*EventBus register
*/
public void register(Object subscriber) {
//1. 拿到当前注册 class
Class<?> subscriberClass = subscriber.getClass();
//2. 查找当前 class 类中所有订阅者的方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//3.
subscribe(subscriber, subscriberMethod);
}
}
}
复制代码subscribe（x,x）代码：
//必须加锁调用
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
//拿到订阅者参数类型
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//根据参数类型，拿到当前所有订阅者
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
//4. 如果没有拿到，则存进去缓存中
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
//如果已经存在相同类型的注册事件，就抛出异常
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
......
}
复制代码
拿到当前传入进来的 this 对象。
查找当前 this 类中所有订阅的函数。
subscriptionsByEventType 完成数据初始化。
subscriptionsByEventType = new HashMap();
复制代码// 参考上图注释 4 ，根据参数类型存储订阅者和订阅方法
post
流程图:
代码
/** 发送事件*/
public void post(Object event) {
//在当前线程中取出变量数据
PostingThreadState postingState = currentPostingThreadState.get();
//将需要发送的数据添加进当前线程的队列中
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
postingState.isPosting = true;
if (postingState.canceled) {
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
while (!eventQueue.isEmpty()) {
//开启取出数据
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}
复制代码 private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
//查找所有的事件类型
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
//发送事件
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
复制代码 private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
//这里的容器就是 register 的时候添加进行去的，现在拿出来
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
//发送到订阅者哪里去
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
复制代码 private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
//根据订阅者 threadMode 来进行发送
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
//通过反射发送
invokeSubscriber(subscription, event);
break;
case MAIN:
//如果是主线程直接在当前线程发送
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
//开启一个子线程发送
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED:
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
invokeSubscriber(subscription, event);
}
break;
case BACKGROUND:
if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
case ASYNC:
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
复制代码步骤
- post
- 获取事件类型
- 根据类型，获取订阅者和订阅方法
- 根据订阅者的 threadMode 来判断线程
- 通过反射直接调用订阅者的订阅方法来完成本次通信息
Subscribe
这里是订阅者的意思，通过自定义注解实现
@Documented
@Retention(RetentionPolicy.RUNTIME) //注解会在class字节码文件中存在，在运行时可以通过反射获取到
@Target({ElementType.METHOD}) //只能在方法上声明
public @interface Subscribe {
ThreadMode threadMode() default ThreadMode.POSTING; //默认在 post 线程
boolean sticky() default false; //默认不是粘性事件
int priority() default 0; //线程优先级默认
}
复制代码threadMode
package org.greenrobot.eventbus;
public enum ThreadMode {
POSTING, // post 线程
MAIN,//指定主线程
MAIN_ORDERED,
BACKGROUND,//后台进行
ASYNC;//异步
private ThreadMode() {
}
}
复制代码unregister
流程:
EventBus 源码总结
到这里我们就简单的分析了 注册 - > 订阅 - > 发送 - >接收事件 简单的流程就是这样了，如果想更深入的话，建议下载源码来看 EventBus GitHub 架构方面还是要注重基础知识，比如 注解 + 反射 + 设计模式 (设计模式的话建议去看 《Android 源码设计模式》一书 )，现在开源项目几乎离不开这几项技术。只有我们掌握了基础 + 实现原理。我们模仿着也能写出来同样的项目。
下面我们就简单模仿下 EventBus 原理，实现自己的 EventBus 框架。
YEventBus 根据 TAG 实现接收消息架构实现
说明一点，这里我们还是根据 EventBus 的核心原理实现，并不会有 EventBus 那么多功能，我们只是学习 EventBus 原理的同时，能根据它的原理，自己写一套轻量级的 EventBus 架构。
最后一共差不多 300 行代码实现根据 TAG 发送/接收事件，下面是效果图：
以下我就直接贴代码了 每一步代码都有详细的注释，相信应该不难理解。
使用方式
添加依赖
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
dependencies {
implementation 'com.github.yangkun19921001:YEventBus:Tag'
}
复制代码
注册事件
//开始注册事件。模仿 EventBus
YEventBus.getDefault().register(this);
复制代码
订阅消息
/**
* 这里是自定义的注册，最后通过反射来获取当前类里面的订阅者
*
* @param meg
*/
@YSubscribe(threadMode = YThreadMode.MAIN, tag = Constants.TAG_1)
public void onEvent(String meg) {
Toast.makeText(getApplicationContext(), "收到：" + meg, Toast.LENGTH_SHORT).show();
}
复制代码
发送消息
YEventBus.getDefault().post(Constants.TAG_1, "发送 TAG 为 1 的消息");
复制代码
register
/**
* 注册方法
*/
public void register(Object subscriber) {
//拿到当前注册的所有的订阅者
List<YSubscribleMethod> ySubscribleMethods = mChacheSubscribleMethod.get(subscriber);
//如果订阅者已经注册了 就不需要再注册了
if (ySubscribleMethods == null) {
//开始反射找到当前类的订阅者
ySubscribleMethods = getSubscribleMethods(subscriber);
//注册了就存在缓存中，避免多次注册
mChacheSubscribleMethod.put(subscriber, ySubscribleMethods);
}
}
/**
* 拿到当前注册的所有订阅者
*
* @param subscriber
* @return
*/
private List<YSubscribleMethod> getSubscribleMethods(Object subscriber) {
//拿到注册的 class
Class<?> subClass = subscriber.getClass();
//定义一个容器，用来装订阅者
List<YSubscribleMethod> ySubscribleMethodList = new ArrayList<>();
//开始循环找到
while (subClass != null) {
//1. 开始进行筛选，如果是系统的就不需要进行下去
String subClassName = subClass.getName();
if (subClassName.startsWith(Constants.JAVA) ||
subClassName.startsWith(Constants.JAVA_X) ||
subClassName.startsWith(Constants.ANDROID) ||
subClassName.startsWith(Constants.ANDROID_X)
) {
break;
}
//2. 遍历拿到当前 class
Method[] declaredMethods = subClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
//3. 检测当前方法中是否有 我们的 订阅者 注解也就是 YSubscribe
YSubscribe annotation = declaredMethod.getAnnotation(YSubscribe.class);
//如果没有直接跳出查找
if (annotation == null)
continue;
// check 这个方法的参数是否有多个
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
if (parameterTypes.length > 1) {
throw new RuntimeException("YEventBus 只能接收一个参数");
}
//4. 符合要求，最后添加到容器中
//4.1 拿到需要在哪个线程中接收事件
YThreadMode yThreadMode = annotation.threadMode();
//只能在当前 tag 相同下才能接收事件
String tag = annotation.tag();
YSubscribleMethod subscribleMethod = new YSubscribleMethod(tag, declaredMethod, yThreadMode, parameterTypes[0]);
ySubscribleMethodList.add(subscribleMethod);
}
//去父类找订阅者
subClass = subClass.getSuperclass();
}
return ySubscribleMethodList;
}
复制代码post (这里不是粘性事件)
/**
* post 方法
*/
public void post(String tag, Object object) {
//拿到当前所有订阅者持有的类
Set<Object> subscriberClass = mChacheSubscribleMethod.keySet();
//拿到迭代器，
Iterator<Object> iterator = subscriberClass.iterator();
//进行循环遍历
while (iterator.hasNext()) {
//拿到注册 class
Object subscribleClas = iterator.next();
//获取类中所有添加订阅者的注解
List<YSubscribleMethod> ySubscribleMethodList = mChacheSubscribleMethod.get(subscribleClas);
for (YSubscribleMethod subscribleMethod : ySubscribleMethodList) {
//判断这个方法是否接收事件
if (!TextUtils.isEmpty(tag) && subscribleMethod.getTag().equals(tag) //注解上面的 tag 是否跟发送者的 tag 相同，相同就接收
&& subscribleMethod.getEventType().isAssignableFrom(object.getClass() //判断类型
)
) {
//根据注解上面的线程类型来进行切换接收消息
postMessage(subscribleClas, subscribleMethod, object);
}
}
}
}
private void postMessage(final Object subscribleClas, final YSubscribleMethod subscribleMethod, final Object message) {
//根据需要的线程来进行切换
switch (subscribleMethod.getThreadMode()) {
case MAIN:
//如果接收的是主线程，那么直接进行反射，执行订阅者的方法
if (isMainThread()) {
postInvoke(subscribleClas, subscribleMethod, message);
} else {//如果接收消息在主线程，发送线程在子线程那么进行线程切换
mHandler.post(new Runnable() {
@Override
public void run() {
postInvoke(subscribleClas, subscribleMethod, message);
}
});
}
break;
case ASYNC://需要在子线程中接收
if (isMainThread())
//如果当前 post 是在主线程中，那么切换为子线程
ThreadUtils.executeByCached(new ThreadUtils.Task<Boolean>() {
@Nullable
@Override
public Boolean doInBackground() throws Throwable {
postInvoke(subscribleClas, subscribleMethod, message);
return true;
}
@Override
public void onSuccess(@Nullable Boolean result) {
Log.i(TAG, "执行成功");
}
@Override
public void onCancel() {
}
@Override
public void onFail(Throwable t) {
}
});
else
postInvoke(subscribleClas, subscribleMethod, message);
break;
case POSTING:
case BACKGROUND:
case MAIN_ORDERED:
postInvoke(subscribleClas, subscribleMethod, message);
break;
default:
break;
}
}
/**
* 反射调用订阅者
*
* @param subscribleClas
* @param subscribleMethod
* @param message
*/
private void postInvoke(Object subscribleClas, YSubscribleMethod subscribleMethod, Object message) {
Log.i(TAG, "post message: " + "TAG:" + subscribleMethod.getTag() + " 消息体：" + message);
Method method = subscribleMethod.getMethod();
//执行
try {
method.invoke(subscribleClas, message);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
复制代码Subscribe 订阅者
/**
* <pre>
* author : devyk on 2019-07-27 18:05
* blog : https://juejin.im/user/3368559355637566/posts
* github : https://github.com/yangkun19921001
* mailbox : yang1001yk@gmail.com
* desc : This is YSubscribe
* </pre>
*/
@Target(ElementType.METHOD) //target 描述此注解在哪里使用
@Retention(RetentionPolicy.RUNTIME) //retention 描述此注解保留的时长 这里是在运行时
public @interface YSubscribe {
YThreadMode threadMode() default YThreadMode.POSTING; //默认是在 post 线程接收数据
String tag() default "";//根据消息来接收事件
}
复制代码TreadMode 线程模式
/**
* <pre>
* author : devyk on 2019-07-27 18:14
* blog : https://juejin.im/user/3368559355637566/posts
* github : https://github.com/yangkun19921001
* mailbox : yang1001yk@gmail.com
* desc : This is YThreadMode
* </pre>
*/
public enum YThreadMode {
/**
* Subscriber will be called directly in the same thread, which is posting the event. This is the default. Event delivery
* implies the least overhead because it avoids thread switching completely. Thus this is the recommended mode for
* simple tasks that are known to complete in a very short time without requiring the main thread. Event handlers
* using this mode must return quickly to avoid blocking the posting thread, which may be the main thread.
*/
POSTING,
/**
* On Android, subscriber will be called in Android's main thread (UI thread). If the posting thread is
* the main thread, subscriber methods will be called directly, blocking the posting thread. Otherwise the event
* is queued for delivery (non-blocking). Subscribers using this mode must return quickly to avoid blocking the main thread.
* If not on Android, behaves the same as {@link #POSTING}.
*/
MAIN,
/**
* On Android, subscriber will be called in Android's main thread (UI thread). Different from {@link #MAIN},
* the event will always be queued for delivery. This ensures that the post call is non-blocking.
*/
MAIN_ORDERED,
/**
* On Android, subscriber will be called in a background thread. If posting thread is not the main thread, subscriber methods
* will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single
* background thread, that will deliver all its events sequentially. Subscribers using this mode should try to
* return quickly to avoid blocking the background thread. If not on Android, always uses a background thread.
*/
BACKGROUND,
/**
* Subscriber will be called in a separate thread. This is always independent from the posting thread and the
* main thread. Posting events never wait for subscriber methods using this mode. Subscriber methods should
* use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number
* of long running asynchronous subscriber methods at the same time to limit the number of concurrent threads. EventBus
* uses a thread pool to efficiently reuse threads from completed asynchronous subscriber notifications.
*/
ASYNC
}
复制代码unRegister取消注册
/**
* 取消注册订阅者
*/
public void unRegister(Object subscriber) {
Log.i(TAG, "unRegister start：当前注册个数" + mChacheSubscribleMethod.size());
Class<?> subClas = subscriber.getClass();
List<YSubscribleMethod> ySubscribleMethodList = mChacheSubscribleMethod.get(subClas);
if (ySubscribleMethodList != null)
mChacheSubscribleMethod.remove(subscriber);
Log.i(TAG, "unRegister success：当前注册个数" + mChacheSubscribleMethod.size());
}
复制代码框架怎么实现根据 TAG 接收消息
这个其实很简单，拿到 post 发送的 tag,跟订阅者的 tag 比较下就行了。其实只要了解原理也没有那么难得。
//判断这个方法是否接收事件
if (!TextUtils.isEmpty(tag) && subscribleMethod.getTag().equals(tag) //注解上面的 tag 是否跟发送者的 tag 相同，相同就接收
&& subscribleMethod.getEventType().isAssignableFrom(object.getClass() //判断类型
)
复制代码总结
最后我们根据开源项目 EventBus 实现了自己 代码传送阵 YEventBus 框架，可以根据 TAG 发送/接收消息。只要了解开源框架原理，根据自己需求改动原有框架或者实现自己的框架都不是太难，加油！
作者：DevYK
链接：https://juejin.cn/post/6844903901129342989
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
收起阅读 »
移动架构 (三) AMS 源码分析
移动架构 (一) 架构第一步，学会画各种 UML 图
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
AMS 介绍
ActivityManagerService 简称 AMS , 是 Android 内核中核心功能之一，由 com.android.server.SystemService.java 启动。
AMS 启动流程
以下流程因为涉及的源代码太多了 , 我这里以 UML 流程图跟代码截图以示
Android 系统启动
应用进程启动
ServiceManager 启动
AMS 注册
AMS 启动详解
代码流程:
AMS 具体是在 SystemService 进中启动的，主要是在
com/android/server/SystemServer.javamain() 函数中进行。
/**
* 这里的 main 函数 主要是 zygote 通过反射调用
*/
public static void main(String[] args) {
new SystemServer().run();
}
复制代码
从上图可以得知 main 方法主要是执行的
com/android/server/SystemServer.javarun() 函数，我们具体来看下 run() 到底干了什么？
private void run() {
try {
....
//加载了动态库libandroid_servers.so
System.loadLibrary("android_servers");
//创建SystemServiceManager，它会对系统的服务进行创建、启动和生命周期管理
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
} finally {
}
// 启动各种服务
try {
traceBeginAndSlog("StartServices");
//启动了ActivityManagerService、PowerManagerService、PackageManagerService 等服务
startBootstrapServices();
// 启动了BatteryService、UsageStatsService和WebViewUpdateService 等服务
startCoreServices();
// 启动了CameraService、AlarmManagerService、VrManagerService等服务
startOtherServices();
SystemServerInitThreadPool.shutdown();
....
} catch (Throwable ex) {
throw ex;
} finally {
traceEnd();
}
// Loop forever.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
复制代码run () 函数核心任务就是初始化一些事务和核心服务启动，这里核心服务初略有 80 多个，系统把核心服务大概分为了 3 类，分别是引导服务、核心服务和其他服务，因为这小节主要研究 AMS 启动，所以我们只关注 startBootstrapServices(); 内容就行了。
startBoostrapService() 这个函数的主要作用，根据官方的意思就是启动需要获得的小型的关键服务。 这些服务具有复杂的相互依赖性，这就是我们在这里将它们全部初始化的原因。 除非您的服务也与这些依赖关系缠绕在一起，否则应该在其他一个函数中初始化它。
public void startBootstrapServices(){
...
//启动 AMS 服务
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
//设置管理器
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
//设置安装器
mActivityManagerService.setInstaller(installer);
...
}
复制代码这里主要调用 SystemServiceManager 的 startService 方法，方法的参数是
ActivityManagerService.Lifecycle.classcom/android/server/SystemServiceManager.java我们再来看看 SSM 的 startService 方法主要干嘛了?
SSM startService(Class serviceClass)
publicT startService(Class serviceClass) {
try {
...
final T service;
try {
Constructorconstructor = serviceClass.getConstructor(Context.class);
//实例化对象
service = constructor.newInstance(mContext);
} catch (InvocationTargetException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service constructor threw an exception", ex);
}
startService(service);
return service;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
复制代码跟踪代码可以得知 startService 方法传入的参数是 Lifecycle.class，Lifecycle 继承自 SystemService 。首先，通过反射来创建 Lifecycle 实例，得到传进来的 Lifecycle 的构造器 constructor ，接着又调用 constructor 的newInstance 方法来创建 Lifecycle 类型的 service 对象。接着将刚创建的 service 添加到 ArrayList 类型的mServices 对象中来完成注册。最后在调用 service 的 onStart 方法来启动 service ，并返回该 service 。Lifecycle 是 AMS 的内部类。
Lifecycle 走向
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context);
}
@Override
public void onStart() {
mService.start();
}
public ActivityManagerService getService() {
return mService;
}
}
复制代码主要执行 Lifecyle onStart()
public void startService(@NonNull final SystemService service) {
// 把 AMS 服务添加到系统服务中
mServices.add(service);
// Start it.
long time = System.currentTimeMillis();
try {
//执行 Lifecyle 重 onStart 函数方法
service.onStart();
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
}
复制代码上面第四步调用 constructor 的 newInstance 方法已经实例化了 Lifecycle 并创建 new
ActivityManagerService(context); 对象，接着又在第四步 startService(service) 调用了 service.start();实际上是调用了 Lifecyle onStart 函数方法。
ActivityManagerService getService()
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
复制代码从上面代码得知实际上是调用了 AMS 中内部类 Lifecycle 中的 getService 函数返回了 AMS 实例，那么 AMS 实例就相当于创建了。
最后启动 AMS 进程是在 Zygote 中执行的，可以参考应用进程中的流程图。
作者：DevYK
链接：https://juejin.cn/post/6844903894166798349
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
iOS序列化的进阶方案——Protocol Buffer
前言
最近项目需要，引入Protocol Buffer来做对象序列化。
正文
Protocol Buffer是Google出的序列化数据格式，下面简称pb。
我们更常用的序列化数据格式应该是json，json和pb本质上都是对象的序列化和反序列化，在项目中json也是前后端通信的主要数据格式。
在本地存储时，我们可以使用YYModel将对象转成json对应的NSData，也可以使用NSKeyedArchiver结合实现NSCoding协议把对象转成NSData，进而将二进制数据存储在沙盒中或者数据库。
那么为什么不使用json，而要用pb？
因为项目中序列化数据到沙盒是一个高频场景，尝试过数据库、NSCoding+NSKeyedArchiver、YYModel等方法都有各自瓶颈：数据内容比较大数据库会造成体积膨胀过快不便管理，NSCoding+NSKeyedArchiver在序列化数据量较大的情况下性能不佳，YYModel在变动的时候不太友好。
相对而言，pb有以下特点：
pb是一种可扩展的序列化数据数据格式，新老版本的数据可以相互读取；
pb是使用字节流方式进行序列化，体积小速度快；（相对而言json是用字符串表示的，光表示字符串的""符号就有很多）
pb的代码是由描述文件proto生成，proto是文本文件便于做版本管理；
pb的使用
使用pb首先要定义proto的数据结构，语法非常简单，可以直接上手写：
syntax = "proto3";
message LYItemData {
uint32 itemId = 1;
string itemContentStr = 2;
}这里定义一个最简单的message，第一行是声明proto的版本，然后添加两个属性itemId和itemContentStr；
使用的时候，用[LYItemData parseFromData:data error:nil];可以将NSData转换成对象，访问LYItemData类的data属性，可以拿到其序列化之后的二进制数据；
代码很简单， 序列化和反序列化都只有一行，使用样例：
NSString *path = [NSHomeDirectory() stringByAppendingPathComponent:@"test_data"];
NSData *data = [[NSData alloc] initWithContentsOfFile:path];
LYItemData *itemData;
if (data) {
itemData = [LYItemData parseFromData:data error:nil]; // 反序列化
}
else {
itemData = [LYItemData new];
itemData.itemId = (int)time(NULL);
itemData.itemContentStr = [self timeStampConversionNSString:itemData.itemId];
[[NSFileManager defaultManager] createFileAtPath:path contents:itemData.data attributes:nil]; // 访问itemData.data属性时会做一次序列化
}message可以定义容器类型，包括数组、map等；
定义数组使用repeated，表示该元素是重复的，数量从0到若干个不等；
定义字典使用map，map里面带两个参数，分别表示key和value的type；
message LYArrayData {
repeated LYItemData items = 1;
map<int32, string> idToContentStrMap = 2;
}也可以在message中声明另外一个message 的属性
message LYProtobufLocalData {
uint64 dataId = 1;
string dataContentStr = 2;
uint32 updateTime = 3;
LYArrayData arrData = 4;
}了解这些常见的message定义方式，就可以满足大多数开发，其他用到再学也不迟。
其他使用方式例如any、oneof、reserved、enum、import、package可以自行探究，我们项目中没有使用到。
不管哪种定义方式，在定义成员属性的时候，都需要指定一个数字，这个数字是tag，需要保证在类中是唯一的。
tag是属性的唯一标识符，pb会在存储和读取的时候用到这个属性。
了解这些常见的message定义方式，就可以满足大多数开发，其他用到再学也不迟。
其他使用方式例如any、oneof、reserved、enum、import、package可以自行探究，我们项目中没有使用到。
不管哪种定义方式，在定义成员属性的时候，都需要指定一个数字，这个数字是tag，需要保证在类中是唯一的。
tag是属性的唯一标识符，pb会在存储和读取的时候用到这个属性。
代码生成
代码生成可以和Xcode结合，在每次编译之后自动生成。
在 Build Phases 里面添加一段脚本（下图中的Run Proto）：先cd到proto所在的目录，然后运行脚本即可。
cd ${SOURCE_ROOT}/LearnProtoBuf/PB/
./protoc ProtobufData.proto --objc_out=./
如果项目中有多个proto，此处可以使用sh脚本，把路径名作为参数传入，在sh脚本里面分别对每个proto文件做代码生成。
如果不想使用这种方式，也可以按照传统方法先安装protobuf，网上教程比较多，这里不再赘述。
总结
在Restful架构逐渐被RPC架构淘汰的现在，pb取代json作为前后端的通信数据格式也是时代的潮流。
json最大的优势或许是后端已有的很多服务都是用json通信，一时间无法完全替换。
pb简单易用，对持续变更更加友好。
一次定义，多端使用；
版本更迭，格式兼容。
附录
官方参考文档--OC代码生成
PB-Github
二进制encode原理
转自：https://www.jianshu.com/p/e2baa9bb4f5e
探讨SWIFT 5.2的新功能特性
从表面上看，SWIFT 5.2在新的语言特性方面肯定是一个小版本，因为这个新版本的大部分重点是提高SWIFT底层基础结构的速度和稳定性，例如如何报告编译器错误，以及如何解决构建级依赖。
然而，斯威夫特5.2总数新的语言特性可能相对较小，它确实包括两个新功能，它们可能会对SWIFT的整体功能产生相当大的影响。函数式程序设计语言.
本周，让我们探讨这些特性，以及我们如何可能使用它们来接受一些在函数式编程世界中非常流行的不同范例--在面向对象的SWIFT代码库中，它们可能会感觉更加一致和熟悉。
在我们开始之前，作为Xcode 11.4的一部分，SWIFT5.2仍然处于测试版，请注意，本文是一篇非常探索性的文章，代表了我对这些新语言特性的第一印象。随着我在生产中使用新特性获得更多经验，我的观点可能会发生变化，尽管我将尝试在这种情况下更新这篇文章，但我建议您使用本文作为灵感，亲自探索这些新特性，而不是直接使用以原样呈现的解决方案。
有了这个小小的免责声明，让我们开始探索吧！
一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：1012951431， 分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！希望帮助开发者少走弯路。
调用类型为函数
尽管SWIFT并不是一种严格的函数式编程语言，但毫无疑问，函数在其总体设计和使用中扮演着非常重要的角色。从闭包如何作为异步回调使用，到集合如何大量使用典型的函数模式(如map和reduce-职能无处不在。
SWIFT5.2的有趣之处在于它开始模糊函数和类型之间的界限。尽管我们一直能够将任何给定类型的实例方法作为函数传递(因为SWIFT支持一级函数)，我们现在能够调用某些类型，就好像它们本身是函数一样。.
让我们先来看看一个使用Cache我们内置的类型“SWIFT中的缓存”-这提供了一个更多的“快速友好”包装上的APINSCache:
class Cache {
private let wrapped = NSCache()
private let dateProvider: () -> Date
private let entryLifetime: TimeInterval
...
func insert(_ value: Value, forKey key: Key) {
...
}
} 假设我们想要向上面的类型添加一个方便的API--让我们自动使用插入值的id作为它的缓存键，以防当前Value类型符合标准库的Identifiable协议。虽然我们可以简单地命名新的apiinsert还有，我们要给它起一个非常特别的名字-callAsFunction:
extension Cache where Value: Identifiable, Key == Value.ID {
func callAsFunction(_ value: Value) {
insert(value, forKey: value.id)
}
}这似乎是一种奇怪的命名约定，但通过这样命名我们的新方便方法，我们实际上已经给出了Cache输入一个有趣的新功能--它现在可能被称为函数--如下所示：
let document: Document = ...
let cache = Cache()
// We can now call our 'cache' variable as if it was referencing a
// function or a closure:
cache(document) 可以说，这既很酷，也很奇怪。但问题是-它有什么用呢？让我们继续探索，看看DocumentRenderer协议，它为用于呈现的各种类型定义了一个公共接口。Document应用程序中的实例：
protocol DocumentRenderer {
func render(_ document: Document,
in context: DocumentRenderingContext,
enableAnnotations: Bool)
}类似于我们之前向我们的Cache类型，让我们在这里做同样的事情-只是这一次，我们将扩展上面的协议，以允许任何符合的类型被调用为一个函数，其中包含一组默认参数：
extension DocumentRenderer {
func callAsFunction(_ document: Document) {
render(document,
in: .makeDefaultContext(),
enableAnnotations: false
)
}
}上述两个变化在孤立的情况下看起来可能不那么令人印象深刻，但是如果我们将它们放在一起，我们就可以看到为一些更复杂的类型提供基于功能的方便API的吸引力。例如，我们在这里构建了一个DocumentViewController-使用我们的Cache类型，以及基于核心动画的DocumentRenderer协议--在加载文档时，这两种协议现在都可以简单地作为函数调用：
class DocumentViewController: UIViewController {
private let cache: Cache
private let render: CoreAnimationDocumentRenderer
...
private func documentDidLoad(_ document: Document) {
cache(document)
render(document)
}
}这很酷，特别是如果我们的目标是轻量级API设计或者如果我们在建造某种形式的领域专用语言。虽然通过传递实例方法来实现类似的结果一直是可能的好像它们是封闭的-通过允许直接调用我们的类型，我们都避免了手动传递这些方法，并且能够保留API可能使用的任何外部参数标签。
例如，假设我们还想做一个PriceCalculator变成一个可调用的类型。为了维护原始API的语义，我们将保留for外部参数标签，即使在声明callAsFunction执行情况-如下：
extension PriceCalculator {
func callAsFunction(for product: Product) -> Int {
calculatePrice(for: product)
}
}下面是上述方法与存储对类型的引用的比较calculatePrice方法-请注意第一段代码是如何丢弃参数标签的，而第二段代码是如何保留参数标签的：
// Using a method reference:
let calculatePrice = PriceCalculator().calculatePrice
...
calculatePrice(product)
// Calling our type directly:
let calculatePrice = PriceCalculator()
...
calculatePrice(for: product)让类型像函数一样被调用是一个非常有趣的概念，但也许更有趣的是，它还使我们能够走相反的方向--并将函数转换为适当的类型。
面向对象的函数式编程
虽然在许多函数式编程概念中有着巨大的威力，但当使用大量面向对象的框架(就像大多数Apple的框架一样)时，应用这些概念和模式往往是很有挑战性的。让我们看看SWIFT5.2的新可调用类型功能是否可以帮助我们改变这种状况。
后续精彩内容请转到我的博客继续观看
转自：https://www.jianshu.com/p/c8f0f4ae63e5
收起阅读 »
iOS- WMZDropDownMenu:App各种类型筛选菜单
软件介绍
一个能几乎实现所有 App 各种类型筛选菜单的控件，可悬浮。目前已实现 闲鱼 / 美团 / Boss直聘 / 京东 / 饿了么 / 淘宝 / 拼多多 / 赶集网 / 美图外卖 等等的筛选菜单，可以自由调用代理实现自己想组装的筛选功能和 UI，且控件的生命周期自动管理，悬浮自动管理。实现功能
- 组合自定义功能
- 支持自定义多选|单选|复选
- 支持自定义弹出的动画 (目前已实现向下,向左全屏,向右全屏,拼多多对话框弹出,boss直聘全屏弹出)
- 支持自定义tableView/collectionView头尾视图
- 支持自定义全局头尾视图
- 支持自定义collectionCell/tableViewCell视图
- 支持自定义标题
- 支持自定义点击回收视图
- 支持自定义回收列表
- 支持任意级的联动(由于数据比较庞杂,暂时自动适配不了无限级的联动,所以需要你调用一个方法更新数据传给我,详情看Demo)
- 支持嵌套使用,即两个筛选菜单可以连着使用
- 支持放在放在任意视图上,tableviewHeadView毫无疑问支持且无须写其他代码只要放上去即可
- 支持控制器消失自动关闭视图，无须再控制器消失方法里手动关闭
- 链式实现所有配置的自定义修改 (总之，你想要的基本都有,不想要的也有)
效果图
用法：
组装全在一些代理里,代理方法可能有点多~ ~,不过只有两个是必实现的,其他的都是可选的）
WMZDropMenuDelegate
@required 一定实现的方法
*/
- (NSArray*)titleArrInMenu:(WMZDropDownMenu *)menu;
/*
*返回WMZDropIndexPath每行 每列的数据
*/
- (NSArray*)menu:(WMZDropDownMenu *)menu
dataForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
@optional 可选实现的方法
/*
*返回setion行标题有多少列 默认1列
*/
- (NSInteger)menu:(WMZDropDownMenu *)menu numberOfRowsInSection:
(NSInteger)section;
/*
*自定义tableviewCell内容 默认WMZDropTableViewCell 如果要使用默认的
cell返回 nil
*/
- (UITableViewCell*)menu:(WMZDropDownMenu *)menu
cellForUITableView:(WMZDropTableView*)tableView AtIndexPath:
(NSIndexPath*)indexpath dataForIndexPath:(WMZDropTree*)model;
/*
*自定义tableView headView
*/
- (UITableViewHeaderFooterView*)menu:(WMZDropDownMenu *)menu
headViewForUITableView:(WMZDropTableView*)tableView
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*自定义tableView footView
*/
- (UITableViewHeaderFooterView*)menu:(WMZDropDownMenu *)menu
footViewForUITableView:(WMZDropTableView*)tableView
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*自定义collectionViewCell内容
*/
- (UICollectionViewCell*)menu:(WMZDropDownMenu *)menu
cellForUICollectionView:(WMZDropCollectionView*)collectionView
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath:
(NSIndexPath*)indexpath dataForIndexPath:(WMZDropTree*)model;
/*
*自定义collectionView headView
*/
- (UICollectionReusableView*)menu:(WMZDropDownMenu *)menu
headViewForUICollectionView:(WMZDropCollectionView*)collectionView
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath:
(NSIndexPath*)indexpath;
/*
*自定义collectionView footView
*/
- (UICollectionReusableView*)menu:(WMZDropDownMenu *)menu
footViewForUICollectionView:(WMZDropCollectionView*)collectionView
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath:
(NSIndexPath*)indexpath;
/*
*headView标题
*/
- (NSString*)menu:(WMZDropDownMenu *)menu
titleForHeadViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*footView标题
*/
- (NSString*)menu:(WMZDropDownMenu *)menu
titleForFootViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*返回WMZDropIndexPath每行 每列 indexpath的cell的高度 默认35
*/
- (CGFloat)menu:(WMZDropDownMenu *)menu heightAtDropIndexPath:
(WMZDropIndexPath*)dropIndexPath AtIndexPath:
(NSIndexPath*)indexpath;
/*
*自定义headView高度 collectionView默认35
*/
- (CGFloat)menu:(WMZDropDownMenu *)menu
heightForHeadViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*自定义footView高度
*/
- (CGFloat)menu:(WMZDropDownMenu *)menu
heightForFootViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
#pragma -mark 自定义用户交互的每行的头尾视图
/*
*自定义每行全局头部视图 多用于交互事件
*/
- (UIView*)menu:(WMZDropDownMenu *)menu
userInteractionHeadViewInSection:(NSInteger)section;
/*
*自定义每行全局尾部视图 多用于交互事件
*/
- (UIView*)menu:(WMZDropDownMenu *)menu
userInteractionFootViewInSection:(NSInteger)section;
#pragma -mark 样式动画相关代理
/*
*返回WMZDropIndexPath每行 每列的UI样式 默认MenuUITableView
注:设置了dropIndexPath.section 设置了 MenuUITableView 那么row则全部
为MenuUITableView 保持统一风格
*/
- (MenuUIStyle)menu:(WMZDropDownMenu *)menu
uiStyleForRowIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*返回section行标题数据视图出现的动画样式 默认
MenuShowAnimalBottom
注:最后一个默认是筛选 弹出动画为 MenuShowAnimalRight
*/
- (MenuShowAnimalStyle)menu:(WMZDropDownMenu *)menu
showAnimalStyleForRowInSection:(NSInteger)section;
/*
*返回section行标题数据视图消失的动画样式 默认 MenuHideAnimalTop
注:最后一个默认是筛选 消失动画为 MenuHideAnimalLeft
*/
- (MenuHideAnimalStyle)menu:(WMZDropDownMenu *)menu
hideAnimalStyleForRowInSection:(NSInteger)section;
/*
*返回WMZDropIndexPath每行 每列的编辑类型 单选|多选 默认单选
*/
- (MenuEditStyle)menu:(WMZDropDownMenu *)menu
editStyleForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*返回WMZDropIndexPath每行 每列 显示的个数
注:
样式MenuUITableView 默认4个
样式MenuUICollectionView 默认1个 传值无效
*/
- (NSInteger)menu:(WMZDropDownMenu *)menu
countForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*WMZDropIndexPath是否显示收缩功能 default >参数
wCollectionViewSectionShowExpandCount 显示
*/
- (BOOL)menu:(WMZDropDownMenu *)menu
showExpandAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*WMZDropIndexPath上的内容点击 是否关闭视图 default YES
*/
- (BOOL)menu:(WMZDropDownMenu *)menu
closeWithTapAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*是否关联 其他标题 即选中其他标题 此标题会不会取消选中状态 default
YES 取消，互不关联
*/
- (BOOL)menu:(WMZDropDownMenu *)menu
dropIndexPathConnectInSection:(NSInteger)section;
#pragma -mark 交互自定义代理
/*
*cell点击方法
*/
- (void)menu:(WMZDropDownMenu *)menu
didSelectRowAtDropIndexPath:(WMZDropIndexPath *)dropIndexPath
dataIndexPath:(NSIndexPath*)indexpath data:(WMZDropTree*)data;
/*
*标题点击方法
*/
- (void)menu:(WMZDropDownMenu *)menu didSelectTitleInSection:
(NSInteger)section btn:(WMZDropMenuBtn*)selectBtn;
/*
*确定方法 多个选择
selectNoramalData 转化后的的模型数据
selectData 字符串数据
*/
- (void)menu:(WMZDropDownMenu *)menu didConfirmAtSection:
(NSInteger)section selectNoramelData:(
NSMutableArray*)selectNoramalData selectStringData:
(NSMutableArray*)selectData;
/*
*自定义标题按钮视图 返回配置 参数说明
offset 按钮的间距
y 按钮的y坐标 自动会居中
*/
- (NSDictionary*)menu:(WMZDropDownMenu *)menu
customTitleInSection:
(NSInteger)section withTitleBtn:(WMZDropMenuBtn*)menuBtn;
/*
*自定义修改默认collectionView尾部视图
*/
- (void)menu:(WMZDropDownMenu *)menu
customDefauultCollectionFootView:(WMZDropConfirmView*)confirmView;下载地址：https://gitee.com/mirrors/WMZDropDownMenu
收起阅读 »
IOS-图片浏览之YBImageBrowser的简单使用
1.安装
第一种方式 使用 cocoapods
第二种方式 手动导入
pod 'SDWebImage', '~> 4.3.3'
pod 'FLAnimatedImage', '~> 1.0.12'2.使用
我这里是采用代理数据源的方式，完整代码如下：
#import "ViewController.h"
#import "YBImageBrowser.h"
#import
@interface ViewController (){
NSArray *imageArray;
NSMutableArray *imageViewArray;
NSInteger currentIndex;
}
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
imageViewArray = [[NSMutableArray alloc]init];
imageArray = @[
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118687954&di=d92e4024fe4c2e4379cce3d3771ae105&imgtype=0&src=http%3A%2F%2Fimg3.duitang.com%2Fuploads%2Fitem%2F201605%2F18%2F20160518181939_nCZWu.gif",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118772581&di=29b994a8fcaaf72498454e6d207bc29a&imgtype=0&src=http%3A%2F%2Fimglf2.ph.126.net%2F_s_WfySuHWpGNA10-LrKEQ%3D%3D%2F1616792266326335483.gif",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118803027&di=beab81af52d767ebf74b03610508eb36&imgtype=0&src=http%3A%2F%2Fe.hiphotos.baidu.com%2Fbaike%2Fpic%2Fitem%2F2e2eb9389b504fc2995aaaa1efdde71190ef6d08.jpg",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118823131&di=aa588a997ac0599df4e87ae39ebc7406&imgtype=0&src=http%3A%2F%2Fimg3.duitang.com%2Fuploads%2Fitem%2F201605%2F08%2F20160508154653_AQavc.png",
@"https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=722693321,3238602439&fm=27&gp=0.jpg",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118892596&di=5e8f287b5c62ca0c813a548246faf148&imgtype=0&src=http%3A%2F%2Fwx1.sinaimg.cn%2Fcrop.0.0.1080.606.1000%2F8d7ad99bly1fcte4d1a8kj20u00u0gnb.jpg",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118914981&di=7fa3504d8767ab709c4fb519ad67cf09&imgtype=0&src=http%3A%2F%2Fimg5.duitang.com%2Fuploads%2Fitem%2F201410%2F05%2F20141005221124_awAhx.jpeg",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118934390&di=fbb86678336593d38c78878bc33d90c3&imgtype=0&src=http%3A%2F%2Fi2.hdslb.com%2Fbfs%2Farchive%2Fe90aa49ddb2fa345fa588cf098baf7b3d0e27553.jpg",
@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118984884&di=7c73ddf9d321ef94a19567337628580b&imgtype=0&src=http%3A%2F%2Fimg5q.duitang.com%2Fuploads%2Fitem%2F201506%2F07%2F20150607185100_XQvYT.jpeg"
];
[self initUI];
// Do any additional setup after loading the view, typically from a nib.
}
-(void)initUI{
NSInteger rowCount = 3;
CGFloat width = self.view.bounds.size.width;
CGFloat imgW = width/rowCount;
CGFloat imgH = imgW;
CGFloat xPoint = 0;
CGFloat yPoint = 100;
NSInteger index = 0;
for (NSString *imgUrl in imageArray) {
UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(xPoint, yPoint, imgW, imgH)];
button.userInteractionEnabled = YES;
button.tag = index;
//点击图片放大
[button addTarget:self action:@selector(imgViewClick:) forControlEvents:UIControlEventTouchUpInside];
UIImageView *img = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, imgW, imgH)];
[button addSubview:img];
[img sd_setImageWithURL:[NSURL URLWithString:imgUrl] placeholderImage:[UIImage imageNamed:@"no_img.png"]];
[imageViewArray addObject:img];
xPoint += imgW;
if ((index+1)%rowCount==0) {
yPoint += imgH;
xPoint = 0;
}
[self.view addSubview:button];
index++;
}
}
-(void)imgViewClick:(UIButton *)btn{
currentIndex = btn.tag;
YBImageBrowser *browser = [YBImageBrowser new];
browser.dataSource = self;
browser.currentIndex = btn.tag;
//展示
[browser show];
}
//YBImageBrowserDataSource 代理实现赋值数据
- (NSInteger)numberInYBImageBrowser:(YBImageBrowser *)imageBrowser {
return imageArray.count;
}
- (YBImageBrowserModel *)yBImageBrowser:(YBImageBrowser *)imageBrowser modelForCellAtIndex:(NSInteger)index {
NSString *urlStr = [imageArray objectAtIndex:index];
YBImageBrowserModel *model = [YBImageBrowserModel new];
model.url = [NSURL URLWithString:urlStr];
//model.sourceImageView = [imageViewArray objectAtIndex:index];
return model;
}
- (UIImageView *)imageViewOfTouchForImageBrowser:(YBImageBrowser *)imageBrowser {
return [imageViewArray objectAtIndex:currentIndex];
}
- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}
@end 3.效果
git地址：https://github.com/indulgeIn/YBImageBrowser
移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架
Android 中消息机制
Android 的消息机制主要指 Handler 的运行机制，先来看下 Handler 的一张运行架构图来对 Handler 有个大概的了解。
Handler 消息机制图:
Handler 类图:
以上图的解释:
- 以 Handler 的 sendMessage () 函数为例，当发送一个 message 后，会将此消息加入消息队列 MessageQueue 中。
- Looper 负责去遍历消息队列并且将队列中的消息分发非对应的 Handler 进行处理。
- 在 Handler 的 handlerMessage 方法中处理该消息，这就完成了一个消息的发送和处理过程。
这里从图中可以看到 Android 中 Handler 消息机制最重要的四个对象分别为 Handler 、Message 、MessageQueue 、Looper。
ThreadLocal 的工作原理
ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据, 数据存储以后，只有再指定线程中可以获取到存储的数据，对于其它线程来说则是无法获取到存储的对象。下面就是我们验证 ThreadLocal 存取是否是按照刚刚那样所说。
子线程中存，子线程中取
// 代码测试
new Thread("thread-1"){
@Override
public void run() {
ThreadLocal<String> mThread_A = new ThreadLocal();
mThread_A.set("thread-1");
System.out.println("mThread_A :"+mThread_A.get());
}
}.start();
//打印结果
mThread_A :thread-1
复制代码主线程中存，子线程取
//主线程中存，子线程取
final ThreadLocal<String> mThread_B = new ThreadLocal();
mThread_B.set("thread_B");
new Thread(){
@Override
public void run() {
System.out.println("mThread_B :"+mThread_B.get());
}
}.start();
//打印结果
mThread_B :null
复制代码主线程存，主线程取
//主线程存，主线程取
ThreadLocal<String> mThread_C = new ThreadLocal();
mThread_C.set("thread_C");
System.out.println("mThread_C :"+mThread_C.get());
//打印结果
mThread_C :thread_C
复制代码
结果是不是跟上面我们所说的答案一样，那么为什么会是这样勒？现在我们带着问题去看下 ThreadLocal 源码到底做了什么？
从上图可以 ThreadLocal 主要函数组成部分，这里我们用到了 set , get 那么就从 set , get 入手吧。
ThreadLocal set(T):
（图 1）
（图 2）
（图 3）
(图 四)
从 (图一) 得知 set 函数里面获取了当前线程，这里我们主要看下 getMap(currentThread) 主要干什么了？
从 (图二) 中我们得知 getMap 主要是从当前线程拿到 ThreadLocalMap 这个实例对象，如果当前线程的 ThreadLocalMap 为 NULL ，那么就 createMap ，这里的 ThreadLocalMap 可以暂时理解为一个集合对象就行了，它 (图四) 底层是一个数组实现的添加数据。
ThreadLocal T get():
这里的 get() 函数其实已经能够说明为什么在不同线程存储的数据拿不到了。因为存储是在当前线程存储的，取数据也是在当前所在的线程取得，所以不可能拿到的。带着问题我们找到了答案。是不是有点小激动呀？(^▽^)
Android 消息机制源码分析
这里我们就直接看源码，一下是我看源码的流程。
创建全局唯一的 Looper 对象和全局唯一 MessageQueue 消息对象。
Activity 中创建 Handler。
Handler sendMessage 发送一个消息的走向。
Handler 消息处理。
消息阻塞和延时
阻塞和延时
Looper 的阻塞主要是靠 MessageQueue 来实现的，在 MessageQueue -> next() nativePollOnce(ptr, nextPollTimeoutMillis) 进行阻塞 , 在 MessageQueue -> enqueueMessage() -> nativeWake(mPtr) 进行唤醒。主要依赖 native 层的 looper epoll 进制进行的。
阻塞和延时，主要是 next() 的 nativePollOnce(ptr , nextPollTimeoutMillis) 调用 native 方法来操作管道，由 nextPollTimeoutMillis 决定是否需要阻塞 , nextPollTimeoutMilis 为 0 的时候表示不阻塞 , 为 -1 的时候表示一直阻塞直到被唤醒，其它时间表示延时。
唤醒
主要是指 enqueueMessage () @MessageQueue 进行唤醒。
阻塞 -> 唤醒 消息切换
总结
简单的理解阻塞和唤醒就是在主线程的 MessageQueue 没有消息时，便阻塞在 Loop 的 queue.next() 中的 nativePollOnce() 方法里面，此时主线程会释放 CPU 资源进入休眠状态，直到下一个消息到达或者有消息的时候才触发，通过往 pipe 管道写端写入数据来唤醒主线程工作。
这里采用的 epoll 机制，是一种 IO 多路复用机制，可以同时监控多个描述符，当某个描述符就绪 (读或写就绪) , 则立刻通知相应程序进行读或者写操作，本质同步 I/O , 即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量的 CPU 资源。
延时入队
主要指 enqueueMessage() 消息入队列（Message 单链表），上图代码对 message 对象池重新排序，遵循规则 ( when 从小到大) 。
此处 for 死循环退出情况分为两种
- p == null 表示对象池中已经运行到了最后一个，无需要再循环。
- 碰到下一个消息 when 小于前一个，立马退出循环 (不管对象池中所有 message 是否遍历完) 进行重新排序。
好了，到了这里 Handler 源码分析算是告一段落了，下面我们来看下面试中容易被问起的问题。
常见问题分析
为什么不能在子线程中更新 UI ，根本原因是什么？
mThread 是主线程，这里会检查当前线程是否是主线程，那么为什么没有在 onCreate 里面没有进行这个检查呢？这个问题原因出现在 Activity 的生命周期中 , 在 onCreate 方法中， UI 处于创建过程，对用户来说界面还不可见，直到 onStart 方法后界面可见了，再到 onResume 方法后页面可以交互，从某种程度来讲, 在 onCreate 方法中不能算是更新 UI，只能说是配置 UI，或者是设置 UI 属性。 这个时候不会调用到 ViewRootImpl.checkThread () , 因为 ViewRootImpl 没有创建。 而在 onResume 方法后， ViewRootImpl 才被创建。 这个时候去交户界面才算是更新 UI。
setContentView 知识建立了 View 树，并没有进行渲染工作 (其实真正的渲染工作实在 onResume 之后)。也正是建立了 View 树，因此我们可以通过 findViewById() 来获取到 View 对象，但是由于并没有进行渲染视图的工作，也就是没有执行 ViewRootImpl.performTransversal。同样 View 中也不会执行 onMeasure (), 如果在 onResume() 方法里直接获取 View.getHeight() / View.getWidth () 得到的结果总是 0。
为什么主线程用 Looper 死循环不会引发 ANR 异常？
简单来说就是在主线程的 MessageQueue 没有消息时，便阻塞在 loop 的 queue.next() 中的 nativePollOnce() 方法，此时主线程会释放 CPU 资源进入休眠状态，直到下个消息到达或者有事务发生，通过往 pipe 管道写入数据来唤醒主线程工作。这里采用的是 epoll 机制，是一种 IO 多路复用机制。
为什么 Handler 构造方法里面的 Looper 不是直接 new ?
如果在 Handler 构造方法里面直接 new Looper(), 可能是无法保证 Looper 唯一，只有用 Looper.prepare() 才能保证唯一性，具体可以看 prepare 方法。
MessageQueue 为什么要放在 Looper 私有构造方法初始化？
因为一个线程只绑定一个 Looper ,所以在 Looper 构造方法里面初始化就可以保证 mQueue 也是唯一的 Thread 对应一个 Looper 对应一个 mQueue。
Handler . post 的逻辑在哪个线程执行的？是由 Looper 所在线程还是 Handler 所在线程决定的？
由 Looper 所在线程决定的。逻辑是在 Looper.loop() 方法中，从 MessageQueue 中拿出 message ,并且执行其逻辑，这里在 Looper 中执行的，因此有 Looper 所在线程决定。
MessageQueue.next() 会因为发现了延迟消息，而进行阻塞。那么为什么后面加入的非延迟消息没有被阻塞呢？
可以参考 消息阻塞和延时 -> 唤醒
Handler 的 dispatchMessage () 分发消息的处理流程？
属于 Runnable 接口。
通过下面代码形式调用。
private static Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return true;
}
});
复制代码如果第一步，第二部都不满足直接走下面 handlerMessage 参考下面代码实现方式
private static Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
复制代码
也可以通过 debug 方式来具体看 dispatchMessage 执行状态。
实现自己的 Handler 简单架构
主要实现测试代码
作者：DevYK
链接：https://juejin.cn/post/6844903892828815367
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
移动架构 (一) 架构第一步，学会画各种 UML 图
注意: 文章中 UML 图开始用是 Windows PowerDesigner 工具，后来换电脑了用的 StarUML。
UML
定义
UML 是统一建模语言, 是一种开放的方法，用于说明、可视化、构建和编写一个正在开发的、面向对象的、软件密集系统的制品的开放方法。
作用
- 帮组开发团队以一种可视化的方式理解系统的功能需求。
- 有利于开发团队队员之间在各个开发环节间确立沟通的标准，便于系统文档的制定和项目的管理。因为 UML 的简单、直观和标准性，在一个团队中用 UML 来交流比用文字说明的文档要好的多。
- UML 为非专业编程人士理解软件的功能和构造，提供了一种直白、简单、通俗的方法。
- 使用 UML 可以方便的理解各种框架的设计方式。
面向对象模型
用例图 (User Case Diagram)
概述
- 用例图主要模拟系统中的动态行为，并且描述了用户、需求、以及系统功能单元之间的关系。
- 用例图由参与者 (用户) ，用例 (功能) 和它们之间的关系组成。
目的
- 用来收集系统的要求。
- 用于获取系统的外观图。
- 识别外部和内部影响因素。
- 显示要求之间的相互作用是参与者。
构成元素
| 组成元素 | 说明 | 符号表示 |
|---|---|---|
| 参与者 (Actor) | 表示与你自己的程序或者系统进行正在交互的动作。用一个小人表示 | |
| 用例 (User Case) | 表示在一个系统或者程序中某个功能的描述。用一个椭圆代表 | |
| 关联关系 (Association) | 表示参与者与用例之间的关系。用一个箭头表示 | |
| 包含关系 (Include) | 表示一个大的功能分解成多个小模块的动作。用一个带包含文字的虚线箭头表示 | |
| 扩展关系 (Extend) | 表示用例功能的延伸，相当于是为用例提供附加功能。用一个带扩展文字的虚线箭头表示 | |
| 依赖 (dependency) | 表示一个用例依赖于另一个用例（相当于程序里面的一个类引用另一个类的关系）。用一个带依赖文字的虚线箭头表示 | |
| 泛化 (Generalization) | 相当于程序里面的继承关系。用一个箭头表示 |
用例图例子
需求: 以一个登录的例子来画一个用例图
- 包含 登录/注册/
- 登录/注册 支持手机号码、第三方 QQ/weichat/GitHub 登录注册
效果图:
提供的登录用例基本上已经包含了刚刚所学的组成元素部分。
结构图
类图 (Class Diagram)
概念
类图 (Class Diagram) 是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其它类的关系等。
类图不显示暂时性的信息，类图是面向对象建模的主要组成部分。它即用于应用程序的系统分类的一般概念建模，也用于详细建模，将模型转换成编程代码。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 泛化 (Generalization) | 是一种继承关系, 表示一般与特殊的关系, 它指定了子类如何特化父类的所有特征和行为。用一个带三角箭头的实线，箭头指向父类表示 | |
| 实现 (Realization) | 是一种类与接口的关系, 表示类是接口所有特征和行为的实现。用一个带三角箭头的虚线，箭头指向接口表示. | |
| 关联 (Association) | 1. 是一种拥有的关系, 它使一个类知道另一个类的属性和方法. 2.关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头。用一个带普通箭头的实心线，指向被拥有者 | |
| 依赖 (Dependency) | 是一种使用的关系, 即一个类的实现需要另一个类的协助, 所以要尽量不使用双向的互相依赖.用一个带箭头的虚线，指向被使用者 | |
| 聚合 (Aggregation) | 聚合是一种特殊的关联 (Association) 形式，表示两个对象之间的所属 (has-a) 关系。所有者对象称为聚合对象，它的类称为聚合类；从属对象称为被聚合对象，它的类称为被聚合类。例如，一个公司有很多员工就是公司类 Company 和员工类Employee 之间的一种聚合关系。被聚合对象和聚合对象有着各自的生命周期，即如果公司倒闭并不影响员工的存在。用一个带空心菱形的实心线，菱形指向整体 | |
| 组合 (Composition) | 是整体与部分的关系, 但部分不能离开整体而单独存在. 如公司和部门是整体和部分的关系, 没有公司就不存在部门。用一个带实心菱形的实线，菱形指向整体表示。 |
类图例子
需求: 基于 google 官方 MVP 架构 绘制一个基本的 MVP 类图架构
组合结构图 (Composite Structure Diagram)
概念
用来显示组合结构或部分系统的内部构造，包括类、接口、包、组件、端口和连接器等元素。比类图更抽象的表示，一般来说先画组合结构图，再画类图。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 类 (Class) | 表示对某件事物的描述 | |
| 接口 (Interface) | 表示用于对 Class 的说明 | |
| 端口 (port) | 表示部件和外部环境的交互点 | |
| 部件 (part) | 表示被描述事物所拥有的内部成分 | |
| 泛化 (Generalication) | 是一种继承关系, 表示一般与特殊的关系, 它指定了子类如何特化父类的所有特征和行为。用一个带三角箭头的实线，箭头指向父类表示 | |
| 实现 (Realization) | 是一种类与接口的关系, 表示类是接口所有特征和行为的实现。用一个带三角箭头的虚线，箭头指向接口表示. | |
| 关联 (Association) | 1. 是一种拥有的关系, 它使一个类知道另一个类的属性和方法. 2.关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头。用一个带普通箭头的实心线，指向被拥有者 | |
| 依赖 (Dependency) | 是一种使用的关系, 即一个类的实现需要另一个类的协助, 所以要尽量不使用双向的互相依赖.用一个带箭头的虚线，指向被使用者 | |
| 聚合 (Aggregation) | 聚合是一种特殊的关联 (Association) 形式，表示两个对象之间的所属 (has-a) 关系。所有者对象称为聚合对象，它的类称为聚合类；从属对象称为被聚合对象，它的类称为被聚合类。例如，一个公司有很多员工就是公司类 Company 和员工类Employee 之间的一种聚合关系。被聚合对象和聚合对象有着各自的生命周期，即如果公司倒闭并不影响员工的存在。用一个带空心菱形的实心线，菱形指向整体 | |
| 组合 (Composition) | 是整体与部分的关系, 但部分不能离开整体而单独存在. 如公司和部门是整体和部分的关系, 没有公司就不存在部门。用一个带实心菱形的实线，菱形指向整体表示。 |
注意事项
侧重类的整体特性，就用类图；侧重类的内部结构，就使用组合结构图。
组合结构图例子
对象图 (Object Diagram)
概念
显示某时刻对象和对象之间的关系
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 对象 (Object) | 代表某个事物 | |
| 实例链接 (Instance Link) | 链是类之间关系的实例 | |
| 依赖 (Dependency) | 想当于 A 对象使用 B 对象里面的属性 |
对象图例子
包图 (Package Diagram)
概念
包与包的之间的关系
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 包 (Package) | 当对一个比较复杂的软件系统进行建模时，会有大量的类、接口、组件、节点和图需要处理；如果放在同一个地方的话，信息量非常的大，显得很乱，不方便查询，所以就对这些信息进行分组，将语义或者功能相同的放在同一个包中，这样就便于理解和处理整个模型 | |
| 泛化 (Generalization) | 是一种继承关系, 表示一般与特殊的关系, 它指定了子类如何特化父类的所有特征和行为。用一个带三角箭头的实线，箭头指向父类表示 | |
| 依赖 (Dependency) | 是一种使用的关系, 即一个类的实现需要另一个类的协助, 所以要尽量不使用双向的互相依赖.用一个带箭头的虚线，指向被使用者 |
包图例子
动态图
时序图 (Sequence Diagram)
概念
时序图（Sequence Diagram) , 又名序列图、循序图、顺序图，是一种UML交互图。
它通过描述对象之间发送消息的时间顺序显示多个对象之间的动态协作。
它可以表示用例的行为顺序，当执行一个用例行为时，其中的每条消息对应一个类操作或状态机中引起转换的触发事件。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 参与者 (Actor) | 表示与你自己的程序或者系统进行正在交互的动作。用一个小人表示 | |
| 对象 (Object) | 代表某个事物 | |
| 控制焦点 (Activation) | 控制焦点是顺序图中表示时间段的符号，在这个时间段内对象将执行相应的操作。用小矩形表示 | |
| 消息 (Message) | 消息一般分为同步消息（Synchronous Message），异步消息（Asynchronous Message）和返回消息（Return Message） |
时序图例子
需求：这里为了简单就用一个登陆的时序图为参考
通讯图 (Communication Diagram)
概念
顺序图强调先后顺序，通信图则是强调相互之间的关系。顺序图和通信图基本同构，但是很少使用通信图，因为顺序图更简洁，更直观。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 参与者 (Actor) | 表示与你自己的程序或者系统进行正在交互的动作。用一个小人表示 | |
| 对象 (Object) | 代表某个事物 | |
| 实例链接 (Instance Link) | 链是类之间关系的实例 | |
| 消息 (Message) | 消息一般分为同步消息（Synchronous Message），异步消息（Asynchronous Message）和返回消息（Return Message） |
通讯图例子
活动图 (Activity Diagram)
概念
活动图是 UML 用于对系统的动态行为建模的另一种常用工具，它描述活动的顺序，展现从一个活动到另一个活动的控制流。活动图在本质上是一种流程图。活动图着重表现从一个活动到另一个活动的控制流，是内部处理驱动的流程。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 活动 (Activity) | 活动状态用于表达状态机中的非原子的运行 | |
| 对象节点 (Object Node) | 某件事物的具体代表 | |
| 判断 (Decision) | 对某个事件进行判断 | |
| 同步 (synchronization) | 指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程; | |
| 开始 (final) | 表示成实心黑色圆点 | |
| 结束 (Flow Final) | 分为活动终止节点（activity final nodes）和流程终止节点（flow final nodes)。而流程终止节点表示是子流程的结束。 |
活动图例子
需求: 点开直播 -> 观看直播的动作
状态图 (Statechart Diagram)
概念
描述了某个对象的状态和感兴趣的事件以及对象响应该事件的行为。转换 (transition) 用标记有事件的箭头表示。状态（state）用圆角矩形表示。通常的做法会包含一个初始状态，当实例创建时，自动从初始状态转换到另外一个状态。
状态图显示了对象的生命周期：即对象经历的事件、对象的转换和对象在这些事件之间的状态。当然，状态图不必要描述所有的事件。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 开始 (final) | 表示成实心黑色圆点 | |
| 结束 (Flow Final) | 分为活动终止节点（activity final nodes）和流程终止节点（flow final nodes)。而流程终止节点表示是子流程的结束。 | |
| 状态 (state) | 某一时刻变化的记录 | |
| 过渡 (Transition) | 相当于 A 点走向 B 点的过渡 | |
| 同步 (synchronization) | 共同执行一个指令 |
状态图例子
需求: 这里直接借鉴 Activity 官方状态图
交错纵横图 (Interaction overview Diagram)
概念
用来表示多张图之间的关联
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 开始 (final) | 表示成实心黑色圆点 | |
| 结束 (Flow Final) | 分为活动终止节点（activity final nodes）和流程终止节点（flow final nodes)。而流程终止节点表示是子流程的结束。 | |
| 同步 (synchronization) | 共同执行一个指令 | |
| 判断 (Decision) | 对某个事件进行判断 | |
| 流 (Flow) | 事件流的走向 | 可以参考，开始跟结束 |
交错纵横图例子
交互图
组件图 (Component Diagram)
概念
组件图(component diagram)是用来反映代码的物理结构。从组件图中，您可以了解各软件组件（如源代码文件或动态链接库）之间的编译器和运行时依赖关系。使用组件图可以将系统划分为内聚组件并显示代码自身的结构
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 组件 (Component) | 组件用一个左侧带有突出两个小矩形的矩形来表示 | |
| 接口 (Interface) | 接口由一组操作组成，它指定了一个契约，这个契约必须由实现和使用这个接口的构件的所遵循 |
组件图例子
部署图 (Deployment Diagram)
概念
部署图可以用于描述规范级别的架构，也可以描述实例级别的架构。这与类图和对象图有点类似，做系统集成很方便。
构成元素
| 构成元素 | 说明 | 表示符号 |
|---|---|---|
| 节点 (node) | 结点是存在与运行时的代表计算机资源的物理元素，可以是硬件也可以是运行其上的软件系统 | |
| 节点实例 (Node Instance) | 与结点的区别在于名称有下划线 | |
| 物件(Artifact) | 物件是软件开发过程中的产物，包括过程模型（比如用例图、设计图等等）、源代码、可执行程序、设计文档、测试报告、需求原型、用户手册等等。 |
部署图例子
经典例子
微信支付时序图
总结
只要掌握常用的几种图 (用例图、类图、时序图、活动图) ，就已经迈向架构第一步了，加油！
作者：DevYK
链接：https://juejin.cn/post/6844903891067207693
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
iOS- 多页面嵌套（JXPagerView、JXCategoryView）
目录
1. 示例
2. 详细说明Podfile中导入
pod 'JXPagingView/Pager'
pod 'JXCategoryView'1. 示例
VC
// 头部View高
#define JXTableHeaderViewHeight (kIs_iPhoneX?200+44:200)
// 菜单项View高
#define JXheightForHeaderInSection 40
#import <JXPagingView/JXPagerView.h>
#import <JXCategoryView/JXCategoryView.h>
<JXPagerViewDelegate, JXCategoryViewDelegate>
/**
顶部View（自定义View）
*/
@property (nonatomic,strong) ZYTeamplayerHeadView *teamplayerHeadV;
/**
菜单项View
*/
@property (nonatomic,strong) JXCategoryTitleView *categoryView;
/**
内容View
*/
@property (nonatomic, strong) JXPagerView *pagingView;
/**
内容View,建议这里使用控制器
*/
@property (nonatomic, strong) NSArray <ZYTeamplayerContentView *> *listViewArray;
/**
菜单项标题数组
*/
@property (nonatomic,copy) NSArray *itemArr;-(void)viewDidLoad{
[super viewDidLoad];
[self.view addSubview:self.pagingView];
}
#pragma mark - JXPagingViewDelegate
/**
自定义头部视图
*/
- (UIView *)tableHeaderViewInPagerView:(JXPagerView *)pagerView {
return self.teamplayerHeadV;
}
/**
自定义头部视图高
@param pagerView pagerView
@return 头部视图高
*/
- (NSUInteger)tableHeaderViewHeightInPagerView:(JXPagerView *)pagerView {
return JXTableHeaderViewHeight;
}
/**
菜单项View
@param pagerView pagerView
@return 菜单项View
*/
- (UIView *)viewForPinSectionHeaderInPagerView:(JXPagerView *)pagerView {
return self.categoryView;
}
/**
菜单项View高
@param pagerView pagerView
@return 菜单项View高
*/
- (NSUInteger)heightForPinSectionHeaderInPagerView:(JXPagerView *)pagerView {
return JXheightForHeaderInSection;
}
/**
内容子视图数组
@param pagerView pagerView
@return 内容子视图数组
*/
- (NSArray<UIView<JXPagerViewListViewDelegate> *> *)listViewsInPagerView:(JXPagerView *)pagerView {
return self.listViewArray;
}
/**
上下滚动后调用
*/
- (void)mainTableViewDidScroll:(UIScrollView *)scrollView {
//计算偏移量
CGFloat P = scrollView.contentOffset.y/(JXTableHeaderViewHeight-kNavBarAndStatusBarHeight);
}
#pragma mark - JXCategoryViewDelegate
/**
选中菜单项后调用
@param categoryView 菜单项View
@param index 下表
*/
- (void)categoryView:(JXCategoryBaseView *)categoryView didSelectedItemAtIndex:(NSInteger)index {
self.navigationController.interactivePopGestureRecognizer.enabled = (index == 0);
}
/**
滑动并切换内容视图后调用
@param categoryView 菜单项View
@param index 下表
*/
- (void)categoryView:(JXCategoryBaseView *)categoryView didScrollSelectedItemAtIndex:(NSInteger)index{
}
#pragma mark 懒加载
/**
总视图
*/
-(JXPagerView *)pagingView{
if(!_pagingView){
//
_pagingView = [[JXPagerView alloc] initWithDelegate:self];
_pagingView.frame = self.view.bounds;
}
return _pagingView;
}
/**
自定义头部视图
*/
-(ZYTeamplayerHeadView *)teamplayerHeadV{
if(!_teamplayerHeadV){
_teamplayerHeadV=[ZYTeamplayerHeadView new];
[_teamplayerHeadV setFrame:CGRectMake(0, 0, kScreenWidth, JXTableHeaderViewHeight)];
}
return _teamplayerHeadV;
}
/**
菜单项视图View
*/
-(JXCategoryTitleView *)categoryView{
if(!_categoryView){
//
_categoryView = [[JXCategoryTitleView alloc] initWithFrame:CGRectMake(0, 0, kScreenWidth, JXheightForHeaderInSection)];
// dele
_categoryView.delegate = self;
// 设置菜单项标题数组
_categoryView.titles = self.itemArr;
// 背景色
_categoryView.backgroundColor = [UIColor whiteColor];
// 标题色、标题选中色、标题字体、标题选中字体
_categoryView.titleColor = kTitleColor;
_categoryView.titleSelectedColor = kTintClolor;
_categoryView.titleFont=kFont(16);
_categoryView.titleSelectedFont=kFontBold(16);
// 标题色是否渐变过渡
_categoryView.titleColorGradientEnabled = YES;
// 下划线
JXCategoryIndicatorLineView *lineView = [[JXCategoryIndicatorLineView alloc] init];
// 下划线颜色
lineView.indicatorLineViewColor = kTintClolor;
// 下划线宽度
lineView.indicatorLineWidth = 35;
_categoryView.indicators = @[lineView];
// 联动（categoryView和pagingView）
_categoryView.contentScrollView = self.pagingView.listContainerView.collectionView;
// 返回上一页侧滑手势（仅在index==0时有效）
self.navigationController.interactivePopGestureRecognizer.enabled = (_categoryView.selectedIndex == 0);
}
return _categoryView;
}
/**
内容视图数组
*/
-(NSArray<ZYTeamplayerContentView *> *)listViewArray{
if(!_listViewArray){
// 内容视图（通过PageType属性区分页面）
CGRect rect=CGRectMake(0, 0, kScreenWidth, kScreenHeight-kNavBarAndStatusBarHeight-JXTableHeaderViewHeight-JXheightForHeaderInSection);
ZYTeamplayerContentView *playerView = [[ZYTeamplayerContentView alloc] initWithFrame:rect];
[playerView setPageType:ZYTeamplayerContentViewTypePlayer];
ZYTeamplayerContentView *infoView = [[ZYTeamplayerContentView alloc] initWithFrame:rect];
[infoView setPageType:ZYTeamplayerContentViewTypeTeam];
_listViewArray = @[playerView, infoView];
}
return _listViewArray;
}
/**
菜单项标题数组
*/
-(NSArray *)itemArr{
if(!_itemArr){
_itemArr=@[@"球员",@"信息"];
}
return _itemArr;
}添加下拉刷新
__weak typeof(self)weakSelf = self;
self.pagingView.mainTableView.mj_header = [MJRefreshNormalHeader headerWithRefreshingBlock:^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 修改
// [self.categoryView reloadData];
// [self.pagingView reloadData];
[weakSelf.pagingView.mainTableView.mj_header endRefreshing];
});
}];自定义内容视图View
#import "JXPagerView.h"
typedef enum{
ZYTeamplayerContentViewTypePlayer, // 球员
ZYTeamplayerContentViewTypeTeam, // 信息
}ZYTeamplayerContentViewType;
<JXPagerViewListViewDelegate>
/**
页面类型
*/
@property (nonatomic,assign) ZYTeamplayerContentViewType pageType;@property (nonatomic, copy) void(^scrollCallback)(UIScrollView *scrollView);
// 必须加（用于联动）
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
self.scrollCallback(scrollView);
}
#pragma mark - JXPagingViewListViewDelegate
- (UIView *)listView {
return self;
}
/**
返回一个可滚动的视图
*/
- (UIScrollView *)listScrollView {
return self.contentTableView;
}
/**
用于联动
*/
- (void)listViewDidScrollCallback:(void (^)(UIScrollView *))callback {
self.scrollCallback = callback;
}
-(void)layoutSubviews{
[self.contentTableView setFrame:self.bounds];
}
-(UITableView *)contentTableView{
if(!_contentTableView){
_contentTableView=[[UITableView alloc]initWithFrame:CGRectZero style:UITableViewStyleGrouped];
[_contentTableView setDelegate:self];
[_contentTableView setDataSource:self];
[_contentTableView setSeparatorStyle:UITableViewCellSeparatorStyleNone];
[_contentTableView setBackgroundColor:[UIColor whiteColor]];
[_contentTableView setContentInset:UIEdgeInsetsMake(0, 0, kNavBarAndStatusBarHeight, 0)]; //
[self addSubview:_contentTableView];
[_contentTableView mas_makeConstraints:^(MASConstraintMaker *make) {
make.left.right.top.bottom.mas_equalTo(0);
}];
}
return _contentTableView;
}2. 详细说明
菜单项
JXCategoryTitleView 文本菜单项
收起阅读 »
美团外卖Android Crash治理之路
Crash率是衡量一个App好坏的重要指标之一，如果你忽略了它的存在，它就会愈演愈烈，最后造成大量用户的流失，进而给公司带来无法估量的损失。本文讲述美团外卖Android客户端团队在将App的Crash率从千分之三做到万分之二过程中所做的大量实践工作，抛砖引玉，希望能够为其他团队提供一些经验和启发。
面临的挑战和成果
面对用户使用频率高，外卖业务增长快，Android碎片化严重这些问题，美团外卖Android App如何持续的降低Crash率，是一项极具挑战的事情。通过团队的全力全策，美团外卖Android App的平均Crash率从千分之三降到了万分之二，最优值万一左右（Crash率统计方式：Crash次数/DAU）。
美团外卖自2013年创建以来，业务就以指数级的速度发展。美团外卖承载的业务，从单一的餐饮业务，发展到餐饮、超市、生鲜、果蔬、药品、鲜花、蛋糕、跑腿等十多个大品类业务。目前美团外卖日完成订单量已突破2000万，成为美团点评最重要的业务之一。美团外卖客户端所承载的业务模块越来越多，产品复杂度越来越高，团队开发人员日益增加，这些都给App降低Crash率带来了巨大的挑战。
Crash的治理实践
对于Crash的治理，我们尽量遵守以下三点原则：
- 由点到面。一个Crash发生了，我们不能只针对这个Crash的去解决，而要去考虑这一类Crash怎么去解决和预防。只有这样才能使得这一类Crash真正被解决。
- 异常不能随便吃掉。随意的使用try-catch，只会增加业务的分支和隐蔽真正的问题，要了解Crash的本质原因，根据本质原因去解决。catch的分支，更要根据业务场景去兜底，保证后续的流程正常。
- 预防胜于治理。当Crash发生的时候，损失已经造成了，我们再怎么治理也只是减少损失。尽可能的提前预防Crash的发生，可以将Crash消灭在萌芽阶段。
常规的Crash治理
常规Crash发生的原因主要是由于开发人员编写代码不小心导致的。解决这类Crash需要由点到面，根据Crash引发的原因和业务本身，统一集中解决。常见的Crash类型包括：空节点、角标越界、类型转换异常、实体对象没有序列化、数字转换异常、Activity或Service找不到等。这类Crash是App中最为常见的Crash，也是最容易反复出现的。在获取Crash堆栈信息后，解决这类Crash一般比较简单，更多考虑的应该是如何避免。下面介绍两个我们治理的量比较大的Crash。
NullPointerException
NullPointerException是我们遇到最频繁的，造成这种Crash一般有两种情况：
- 对象本身没有进行初始化就进行操作。
- 对象已经初始化过，但是被回收或者手动置为null，然后对其进行操作。
针对第一种情况导致的原因有很多，可能是开发人员的失误、API返回数据解析异常、进程被杀死后静态变量没初始化导致，我们可以做的有：
- 对可能为空的对象做判空处理。
- 养成使用@NonNull和@Nullable注解的习惯。
- 尽量不使用静态变量，万不得已使用SharedPreferences来存储。
- 考虑使用Kotlin语言。
针对第二种情况大部分是由于Activity/Fragment销毁或被移除后，在Message、Runnable、网络等回调中执行了一些代码导致的，我们可以做的有：
- Message、Runnable回调时，判断Activity/Fragment是否销毁或被移除；加try-catch保护；Activity/Fragment销毁时移除所有已发送的Runnable。
- 封装LifecycleMessage/Runnable基础组件，并自定义Lint检查，提示使用封装好的基础组件。
- 在BaseActivity、BaseFragment的onDestory()里把当前Activity所发的所有请求取消掉。
IndexOutOfBoundsException
这类Crash常见于对ListView的操作和多线程下对容器的操作。
针对ListView中造成的IndexOutOfBoundsException，经常是因为外部也持有了Adapter里数据的引用(如在Adapter的构造函数里直接赋值)，这时如果外部引用对数据更改了，但没有及时调用notifyDataSetChanged()，则有可能造成Crash，对此我们封装了一个BaseAdapter，数据统一由Adapter自己维护通知， 同时也极大的避免了The content of the adapter has changed but ListView did not receive a notification，这两类Crash目前得到了统一的解决。
另外，很多容器是线程不安全的，所以如果在多线程下对其操作就容易引发IndexOutOfBoundsException。常用的如JDK里的ArrayList和Android里的SparseArray、ArrayMap，同时也要注意有一些类的内部实现也是用的线程不安全的容器，如Bundle里用的就是ArrayMap。
系统级Crash治理
众所周知，Android的机型众多，碎片化严重，各个硬件厂商可能会定制自己的ROM，更改系统方法，导致特定机型的崩溃。发现这类Crash，主要靠云测平台配合自动化测试，以及线上监控，这种情况下的Crash堆栈信息很难直接定位问题。下面是常见的解决思路：
- 尝试找到造成Crash的可疑代码，看是否有特异的API或者调用方式不当导致的，尝试修改代码逻辑来进行规避。
- 通过Hook来解决，Hook分为Java Hook和Native Hook。Java Hook主要靠反射或者动态代理来更改相应API的行为，需要尝试找到可以Hook的点，一般Hook的点多为静态变量，同时需要注意Android不同版本的API，类名、方法名和成员变量名都可能不一样，所以要做好兼容工作；Native Hook原理上是用更改后方法把旧方法在内存地址上进行替换，需要考虑到Dalvik和ART的差异；相对来说Native Hook的兼容性更差一点，所以用Native Hook的时候需要配合降级策略。
- 如果通过前两种方式都无法解决的话，我们只能尝试反编译ROM，寻找解决的办法。
我们举一个定制系统ROM导致Crash的例子，根据Crash平台统计数据发现该Crash只发生在vivo V3Max这类机型上，Crash堆栈如下：
java.lang.RuntimeException: An error occured while executing doInBackground()
at android.os.AsyncTask$3.done(AsyncTask.java:304)
at java.util.concurrent.FutureTask.finishCompletion(FutureTask.java:355)
at java.util.concurrent.FutureTask.setException(FutureTask.java:222)
at java.util.concurrent.FutureTask.run(FutureTask.java:242)
at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:231)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1112)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:587)
at java.lang.Thread.run(Thread.java:818)
Caused by: java.lang.NullPointerException: Attempt to invoke interface method 'int java.util.List.size()' on a null object reference
at android.widget.AbsListView$UpdateBottomFlagTask.isSuperFloatViewServiceRunning(AbsListView.java:7689)
at android.widget.AbsListView$UpdateBottomFlagTask.doInBackground(AbsListView.java:7665)
at android.os.AsyncTask$2.call(AsyncTask.java:292)
at java.util.concurrent.FutureTask.run(FutureTask.java:237)
... 4 more
复制代码我们发现原生系统上对应系统版本的AbsListView里并没有UpdateBottomFlagTask类，因此可以断定是vivo该版本定制的ROM修改了系统的实现。我们在定位这个Crash的可疑点无果后决定通过Hook的方式解决，通过源码发现AsyncTask$SerialExecutor是静态变量，是一个很好的Hook的点，通过反射添加try-catch解决。因为修改的是final对象所以需要先反射修改accessFlags，需要注意ART和Dalvik下对应的Class不同，代码如下：
public static void setFinalStatic(Field field, Object newValue) throws Exception {
field.setAccessible(true);
Field artField = Field.class.getDeclaredField("artField");
artField.setAccessible(true);
Object artFieldValue = artField.get(field);
Field accessFlagsFiled = artFieldValue.getClass().getDeclaredField("accessFlags");
accessFlagsFiled.setAccessible(true);
accessFlagsFiled.setInt(artFieldValue, field.getModifiers() & ~Modifier.FINAL);
field.set(null, newValue);
}
复制代码private void initVivoV3MaxCrashHander() {
if (!isVivoV3()) {
return;
}
try {
setFinalStatic(AsyncTask.class.getDeclaredField("SERIAL_EXECUTOR"), new SafeSerialExecutor());
Field defaultfield = AsyncTask.class.getDeclaredField("sDefaultExecutor");
defaultfield.setAccessible(true);
defaultfield.set(null, AsyncTask.SERIAL_EXECUTOR);
} catch (Exception e) {
L.e(e);
}
}
复制代码美团外卖App用上述方法解决了对应的Crash，但是美团App里的外卖频道因为平台的限制无法通过这种方式，于是我们尝试反编译ROM。
Android ROM编译时会将framework、app、bin等目录打入system.img中，system.img是Android系统中用来存放系统文件的镜像 (image)，文件格式一般为yaffs2或ext。但Android 5.0开始支持dm-verity后，system.img不再提供，而是提供了三个文件system.new.dat，system.patch.dat，system.transfer.list，因此我们首先需要通过上述的三个文件得到system.img。但我们将vivo ROM解压后发现厂商将system.new.dat进行了分片，如下图所示：
经过对system.transfer.list中的信息和system.new.dat 1 2 3 ... 文件大小对比研究，发现一些共同点，system.transfer.list中的每一个block数*4KB 与对应的分片文件的大小大致相同,故大胆猜测，vivo ROM对system.patch.dat分片也只是单纯的按block先后顺序进行了分片处理。所以我们只需要在转化img前将这些分片文件合成一个system.patch.dat文件就可以了。最后根据system.img的文件系统格式进行解包，拿到framework目录，其中有framework.jar和boot.oat等文件，因为Android4.4之后引入了ART虚拟机，会预先把system/framework中的一些jar包转换为oat格式，所以我们还需要将对应的oat文件通过ota2dex将其解包获得dex文件，之后通过dex2jar和jd-gui查看源码。
OOM
OOM是OutOfMemoryError的简称，在常见的Crash疑难排行榜上，OOM绝对可以名列前茅并且经久不衰。因为它发生时的Crash堆栈信息往往不是导致问题的根本原因，而只是压死骆驼的最后一根稻草。
导致OOM的原因大部分如下：
- 内存泄漏，大量无用对象没有被及时回收导致后续申请内存失败。
- 大内存对象过多，最常见的大对象就是Bitmap，几个大图同时加载很容易触发OOM。
内存泄漏
内存泄漏指系统未能及时释放已经不再使用的内存对象，一般是由错误的程序代码逻辑引起的。在Android平台上，最常见也是最严重的内存泄漏就是Activity对象泄漏。Activity承载了App的整个界面功能，Activity的泄漏同时也意味着它持有的大量资源对象都无法被回收，极其容易造成OOM。
常见的可能会造成Activity泄漏的原因有：
- 匿名内部类实现Handler处理消息，可能导致隐式持有的Activity对象无法回收。
- Activity和Context对象被混淆和滥用，在许多只需要Application Context而不需要使用Activity对象的地方使用了Activity对象，比如注册各类Receiver、计算屏幕密度等等。
- View对象处理不当，使用Activity的LayoutInflater创建的View自身持有的Context对象其实就是Activity，这点经常被忽略，在自己实现View重用等场景下也会导致Activity泄漏。
对于Activity泄漏，目前已经有了一个非常好用的检测工具：LeakCanary，它可以自动检测到所有Activity的泄漏情况，并且在发生泄漏时给出十分友好的界面提示，同时为了防止开发人员的疏漏，我们也会将其上报到服务器，统一检查解决。另外我们可以在debug下使用StrictMode来检查Activity的泄露、Closeable对象没有被关闭等问题。
大对象
在Android平台上，我们分析任一应用的内存信息，几乎都可以得出同样的结论：占用内存最多的对象大都是Bitmap对象。随着手机屏幕尺寸越来越大，屏幕分辨率也越来越高，1080p和更高的2k屏已经占了大半份额，为了达到更好的视觉效果，我们往往需要使用大量高清图片，同时也为OOM埋下了祸根。
对于图片内存优化，我们有几个常用的思路：
- 尽量使用成熟的图片库，比如Glide，图片库会提供很多通用方面的保障，减少不必要的人为失误。
- 根据实际需要，也就是View尺寸来加载图片，可以在分辨率较低的机型上尽可能少地占用内存。除了常用的BitmapFactory.Options#inSampleSize和Glide提供的BitmapRequestBuilder#override之外，我们的图片CDN服务器也支持图片的实时缩放，可以在服务端进行图片缩放处理，从而减轻客户端的内存压力。
分析App内存的详细情况是解决问题的第一步，我们需要对App运行时到底占用了多少内存、哪些类型的对象有多少个有大致了解，并根据实际情况做出预测，这样才能在分析时做到有的放矢。Android Studio也提供了非常好用的Memory Profiler，堆转储和分配跟踪器功能可以帮我们迅速定位问题。
AOP增强辅助
AOP是面向切面编程的简称，在Android的Gradle插件1.5.0中新增了Transform API之后，编译时修改字节码来实现AOP也因为有了官方支持而变得非常方便。
在一些特定情况下，可以通过AOP的方式自动处理未捕获的异常：
- 抛异常的方法非常明确，调用方式比较固定。
- 异常处理方式比较统一。
- 和业务逻辑无关，即自动处理异常后不会影响正常的业务逻辑。典型的例子有读取Intent Extras参数、读取SharedPreferences、解析颜色字符串值和显示隐藏Window等等。
这类问题的解决原理大致相同，我们以Intent Extras为例详细介绍一下。读取Intent Extras的问题在于我们非常常用的方法 Intent#getStringExtra 在代码逻辑出错或者恶意攻击的情况下可能会抛出ClassNotFoundException异常，而我们平时在写代码时又不太可能给所有调用都加上try-catch语句，于是一个更安全的Intent工具类应运而生，理论上只要所有人都使用这个工具类来访问Intent Extras参数就可以防止此类型的Crash。但是面对庞大的旧代码仓库和诸多的业务部门，修改现有代码需要极大成本，还有更多的外部依赖SDK基本不可能使用我们自己的工具类，此时就需要AOP大展身手了。
我们专门制作了一个Gradle插件，只需要配置一下参数就可以将某个特定方法的调用替换成另一个方法：
WaimaiBytecodeManipulator {
replacements(
"android/content/Intent.getIntExtra(Ljava/lang/String;I)I=com/waimai/IntentUtil.getInt(Landroid/content/Intent;Ljava/lang/String;I)I",
"android/content/Intent.getStringExtra(Ljava/lang/String;)Ljava/lang/String;=com/waimai/IntentUtil.getString(Landroid/content/Intent;Ljava/lang/String;)Ljava/lang/String;",
"android/content/Intent.getBooleanExtra(Ljava/lang/String;Z)Z=com/waimai/IntentUtil.getBoolean(Landroid/content/Intent;Ljava/lang/String;Z)Z",
...)
}
}
复制代码上面的配置就可以将App代码（包括第三方库）里所有的Intent.getXXXExtra调用替换成IntentUtil类中的安全版实现。当然，并不是所有的异常都只需要catch住就万事大吉，如果真的有逻辑错误肯定需要在开发和测试阶段及时暴露出来，所以在IntentUtil中会对App的运行环境做判断，Debug下会将异常直接抛出，开发同学可以根据Crash堆栈分析问题，Release环境下则在捕获到异常时返回对应的默认值然后将异常上报到服务器。
依赖库的问题
Android App经常会依赖很多AAR， 每个AAR可能有多个版本，打包时Gradle会根据规则确定使用的最终版本号（默认选择最高版本或者强制指定的版本），而其他版本的AAR将被丢弃。如果互相依赖的AAR中有不兼容的版本，存在的问题在打包时是不能发现的，只有在相关代码执行时才会出现，会造成NoClassDefFoundError、NoSuchFieldError、NoSuchMethodError等异常。如图所示，order和store两个业务库都依赖了platform.aar，一个是1.0版本，一个是2.0版本，默认最终打进APK的只有platform 2.0版本，这时如果order库里用到的platform库里的某个类或者方法在2.0版本中被删除了，运行时就可能发生异常，虽然SDK在升级时会尽量做到向下兼容，但很多时候尤其是第三方SDK是没法得到保证的，在美团外卖Android App v6.0版本时因为这个原因导致热修复功能丧失，因此为了提前发现问题，我们接入了依赖检查插件Defensor。
Defensor在编译时通过DexTask获取到所有的输入文件(也就是被编译过的class文件)，然后检查每个文件里引用的类、字段、方法等是否存在。
除此之外我们写了一个Gradle插件SVD(strict version dependencies)来对那些重要的SDK的版本进行统一管理。插件会在编译时检查Gradle最终使用的SDK版本是否和配置中的一致，如果不一致插件会终止编译并报错，并同时会打印出发生冲突的SDK的所有依赖关系。
Crash的预防实践
单纯的靠约定或规范去减少Crash的发生是不现实的。约定和规范受限于组织架构和具体执行的个人，很容易被忽略，只有靠工程架构和工具才能保证Crash的预防长久的执行下去。
工程架构对Crash率的影响
在治理Crash的实践中，我们往往忽略了工程架构对Crash率的影响。Crash的发生大部分原因是源于程序员的不合理的代码，而程序员工作中最直接的接触的就是工程架构。对于一个边界模糊，层级混乱的架构，程序员是更加容易写出引起Crash的代码。在这样的架构里面，即使程序员意识到导致某种写法存在问题，想要去改善这样不合理的代码，也是非常困难的。相反，一个层级清晰，边界明确的架构，是能够大大减少Crash发生的概率，治理和预防Crash也是相对更容易。这里我们可以举几个我们实践过的例子阐述。
业务模块的划分
原来我们的Crash基本上都是由个别同学关注解决的，团队里的每个同学都会提交可能引起Crash的代码，如果负责Crash的同学因为某些事情，暂时没有关注App的Crash率，那么造成Crash的同学也不会知道他的代码引起了Crash。
对于这个问题，我们的做法是App的业务模块化。业务模块化后，每个业务都有都有唯一包名和对应的负责人。当某个模块发生了Crash，可以根据包名提交问题给这个模块的负责人，让他第一时间进行处理。业务模块化本身也是工程架构优先需要考虑的事情之一。
页面跳转路由统一处理页面跳转
对外卖App而言，使用过程中最多的就是页面间的跳转，而页面间跳转经常会造成ActivityNotFoundException，例如我们配了一个scheme，但对方的scheme路径已经发生了变化；又例如，我们调用手机上相册的功能，而相册应用已被用户自己禁用或移除了。解决这一类Crash，其实也很简单，只需要在startActivity增加ActivityNotFoundException异常捕获即可。但一个App里，启动Activity的地方，几乎是随处可见，无法预测哪一处会造成ActivityNotFoundException。
我们的做法是将页面的跳转，都通过我们封装的scheme路由去分发。这样的好处是，通过scheme路由，在工程架构上所有业务都是解耦，模块间不需要相互依赖就可以实现页面的跳转和基本类型参数的传递；同时，由于所有的页面跳转都会走scheme路由，我们只需要在scheme路由里一处加上ActivityNotFoundException异常捕获即可解决这种类型的Crash。路由设计示意图如下：
网络层统一处理API脏数据
客户端的很大一部分的Crash是因为API返回的脏数据。比如当API返回空值、空数组或返回不是约定类型的数据，App收到这些数据，就极有可能发生空指针、数组越界和类型转换错误等Crash。而且这样的脏数据，特别容易引起线上大面积的崩溃。
最早我们的工程的网络层用法是：页面监听网络成功和失败的回调，网络成功后，将JSON数据传递给页面，页面解析Model，初始化View，如图所示。这样的问题就是，网络虽然请求成功了，但是JSON解析Model这个过程可能存在问题，例如没有返回数据或者返回了类型不对的数据，而这个脏数据导致问题会出现在UI层，直接反应给用户。
根据上图，我们可以看到由于网络层只承担了请求网络的职责，没有承担数据解析的职责，数据解析的职责交给了页面去处理。这样使得我们一旦发现脏数据导致的Crash，就只能在网络请求的回调里面增加各种判断去兼容脏数据。我们有几百个页面，补漏完全补不过来。通过几个版本的重构，我们重新划分了网络层的职责，如图所示：
从图上可以看出，重构后的网络层负责请求网络和数据解析，如果存在脏数据的话，在网络层就会发现问题，不会影响到UI层，返回给UI层的都是校验成功的数据。这样改造后，我们发现这类的Crash率有了极大的改善。
大图监控
上面讲到大对象是导致OOM的主要原因之一，而Bitmap是App里最常见的大对象类型，因此对占用内存过大的Bitmap对象的监控就很有必要了。
我们用AOP方式Hook了三种常见图片库的加载图片回调方法，同时监控图片库加载图片时的两个维度：
- 加载图片使用的URL。外卖App中除静态资源外，所有图片都要求发布到专用的图片CDN服务器上，加载图片时使用正则表达式匹配URL，除了限定CDN域名之外还要求所有图片加载时都要添加对应的动态缩放参数。
- 最终加载出的图片结果（也就是Bitmap对象）。我们知道Bitmap对象所占内存和其分辨率大小成正比，而一般情况下在ImageView上设置超过自身尺寸的图片是没有意义的，所以我们要求显示在ImageView中的Bitmap分辨率不允许超过View自身的尺寸（为了降低误报率也可以设定一个报警阈值）。
开发过程中，在App里检测到不合规的图片时会立即高亮出错的ImageView所在的位置并弹出对话框提示ImageView所在的Activity、XPath和加载图片使用的URL等信息，如下图，辅助开发同学定位并解决问题。在Release环境下可以将报警信息上报到服务器，实时观察数据，有问题及时处理。
Lint检查
我们发现线上的很多Crash其实可以在开发过程中通过Lint检查来避免。Lint是Google提供的Android静态代码检查工具，可以扫描并发现代码中潜在的问题，提醒开发人员及早修正，提高代码质量。
但是Android原生提供的Lint规则（如是否使用了高版本API）远远不够，缺少一些我们认为有必要的检测，也不能检查代码规范。因此我们开始开发自定义Lint，目前我们通过自定义Lint规则已经实现了Crash预防、Bug预防、提升性能/安全和代码规范检查这些功能。如检查实现了Serializable接口的类，其成员变量（包括从父类继承的）所声明的类型都要实现Serializable接口，可以有效的避免NotSerializableException；强制使用封装好的工具类如ColorUtil、WindowUtil等可以有效的避免因为参数不正确产生的IllegalArgumentException和因为Activity已经finish导致的BadTokenException。
Lint检查可以在多个阶段执行，包括在本地手动检查、编码实时检查、编译时检查、commit时检查，以及在CI系统中提Pull Request时检查、打包时检查等，如下图所示。更详细的内容可参考《美团外卖Android Lint代码检查实践》。
资源重复检查
在之前的文章《美团外卖Android平台化架构演进实践》中讲述了我们的平台化演进过程，在这个过程中大家很大的一部分工作是下沉，但是下沉不完全就会导致一些类和资源的重复，类因为有包名的限制不会出现问题。但是一些资源文件如layout、drawable等如果同名则下层会被上层覆盖，这时layout里view的id发生了变化就可能导致空指针的问题。为了避免这种问题，我们写了一个Gradle插件通过hook MergeResource这个Task，拿到所有library和主库的资源文件，如果检查到重复则会中断编译过程，输出重复的资源名及对应的library name，同时避免有些资源因为样式等原因确实需要覆盖，因此我们设置了白名单。同时在这个过程中我们也拿到了所有的的图片资源，可以顺手做图片大小的本地监控，如下图所示：
Crash的监控&止损的实践
监控
在经过前面提到的各种检查和测试之后，应用便开始发布了。我们建立了如下图的监控流程，来保证异常发生时能够及时得到反馈并处理。首先是灰度监控，灰度阶段是增量Crash最容易暴露的阶段，如果这个阶段没有很好的把握住，会使得增量变存量，从而导致Crash率上升。如果条件允许的话，可以在灰度期间制定一些灰度策略去提高这个阶段Crash的暴露。例如分渠道灰度、分城市灰度、分业务场景灰度、新装用户的灰度等等，尽量覆盖所有的分支。灰度结束之后便开始全量，在全量的过程中我们还需要一些日常Crash监控和Crash率的异常报警来防止突发情况的发生，例如因为后台上线或者运营配置错误导致的线上Crash。除此之外还需要一些其他的监控，例如，之前提到的大图监控，来避免因为大图导致的OOM。具体的输出形式主要有邮件通知、IM通知、报表。
止损
尽管我们在前面做了那么多，但是Crash还是无法避免的，例如，在灰度阶段因为量级不够，有些Crash没有被暴露出来；又或者某些功能客户端比后台更早上线，而这些功能在灰度阶段没有被覆盖到；这些情况下，如果出现问题就需要考虑如何止损了。
问题发生时首先需要评估重要性，如果问题不是很严重而且修复成本较高可以考虑在下个版本再修复，相反如果问题比较严重，对用户体验或下单有影响时就必须要修复。修复时首先考虑业务降级，主要看该部分异常的业务是否有兜底或者A/B策略，这样是最稳妥也是最有效的方式。如果业务不能降级就需要考虑热修复了，目前美团外卖Android App接入的热修复框架是自研的Robust，可以修复90%以上的场景，热修成功率也达到了99%以上。如果问题发生在热修复无法覆盖的场景，就只能强制用户升级。强制升级因为覆盖周期长，同时影响用户的体验，只在万不得已的情况下才会使用。
展望
Crash的自我修复
我们在做新技术选型时除了要考虑是否能满足业务需求、是否比现有技术更优秀和团队学习成本等因素之外，兼容性和稳定性也非常重要。但面对国内非富多彩的Android系统环境，在体量百万级以上的的App中几乎不可能实现毫无瑕疵的技术方案和组件，所以一般情况下如果某个技术实现方案可以达到0.01‰以下的崩溃率，而其他方案也没有更好的表现，我们就认为它是可以接受的。但是哪怕仅仅十万分之一的崩溃率，也代表还有用户受到影响，而我们认为Crash对用户来说是最糟糕的体验，尤其是涉及到交易的场景，所以我们必须本着每一单都很重要的原则，尽最大努力保证用户顺利执行流程。
实际情况中有一些技术方案在兼容性和稳定性上做了一定妥协的场景，往往是因为考虑到性能或扩展性等方面的优势。这种情况下我们其实可以再多做一些，进一步提高App的可用性。就像很多操作系统都有“兼容模式”或者“安全模式”，很多自动化机械机器都配套有手动操作模式一样，App里也可以实现备用的降级方案，然后设置特定条件的触发策略，从而达到自动修复Crash的目的。
举例来讲，Android 3.0中引入了硬件加速机制，虽然可以提高绘制帧率并且降低CPU占用率，但是在某些机型上还是会有绘制错乱甚至Crash的情况，这时我们就可以在App中记录硬件加速相关的Crash问题或者使用检测代码主动检测硬件加速功能是否正常工作，然后主动选择是否开启硬件加速，这样既可以让绝大部分用户享受硬件加速带来的优势，也可以保障硬件加速功能不完善的机型不受影响。
还有一些类似的可以做自动降级的场景，比如：
- 部分使用JNI实现的模块，在SO加载失败或者运行时发生异常则可以降级为Java版实现。
- RenderScript实现的图片模糊效果，也可以在失败后降级为普通的Java版高斯模糊算法。
- 在使用Retrofit网络库时发现OkHttp3或者HttpURLConnection网络通道失败率高，可以主动切换到另一种通道。
这类问题都需要根据具体情况具体分析，如果可以找到准确的判定条件和稳定的修复方案，就可以让App稳定性再上一个台阶。
特定Crash类型日志自动回捞
外卖业务发展迅速，即使我们在开发时使用各种工具、措施来避免Crash的发生，但Crash还是不可避免。线上某些怪异的Crash发生后，我们除了分析Crash堆栈信息之外，还可以使用离线日志回捞、下发动态日志等工具来还原Crash发生时的场景，帮助开发同学定位问题，但是这两种方式都有它们各自的问题。离线日志顾名思义，它的内容都是预先记录好的，有时候可能会漏掉一些关键信息，因为在代码中加日志一般只是在业务关键点，在大量的普通方法中不可能都加上日志。动态日志（Holmes）存在的问题是每次下发只能针对已知UUID的一个用户的一台设备，对于大量线上Crash的情况这种操作并不合适，因为我们并不能知道哪个发生Crash的用户还会再次复现这次操作，下发配置充满了不确定性。
我们可以改造Holmes使其支持批量甚至全量下发动态日志，记录的日志等到发生特定类型的Crash时才上报，这样一来可以减少日志服务器压力，同时也可以极大提高定位问题的效率，因为我们可以确定上报日志的设备最后都真正发生了该类型Crash，再来分析日志就可以做到事半功倍。
总结
业务的快速发展，往往不可能给团队充足的时间去治理Crash，而Crash又是App最重要的指标之一。团队需要由一个个Crash个例，去探究每一个Crash发生的最本质原因，找到最合理解决这类Crash的方案，建立解决这一类Crash的长效机制，而不能饮鸩止渴。只有这样，随着版本的不断迭代，我们才能在Crash治理之路上离目标越来越近。
作者：美团技术团队
链接：https://juejin.cn/post/6844903620920492046
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Kotlin集成Arouter
使用场景
为了软件间的解耦操作，确保模块之间
Activity的相互跳转不受影响。故引用阿里巴巴的Arouter。但官网上还没有针对Kotlin的集成说明，故在此记录下来
如何使用
gradle配置- 目录配置，常量类配置
- 在
Application中进行Arouter初始化 Activity的配置
1. gradle配置
注意需要在两个地方进行配置
1.根目录下的build.gradle中配置，在dependencies中增加arouter-register引用
dependencies {
classpath "com.alibaba:arouter-register:1.0.2"
}
复制代码2.在模块所在的build.gradle中添加引用及编译配置
plugins {
// 1.增加kotlin-kapt引用
id 'kotlin-kapt'
}
android {
// 2.增加Arouter编译配置，注意顺序。此处应该在android{}中
kapt {
arguments {
arg("AROUTER_MODULE_NAME", project.getName())
}
}
}
dependencies {
// 3. 添加gradle引用
implementation 'com.alibaba:arouter-api:1.5.1'
kapt "com.alibaba:arouter-compiler:1.5.1"
}
复制代码注意：此处的与官网教程不一样。官网的配置是针对java的，所以我没有使用
javaCompileOptions和annotationProcessor'com.alibaba:arouter-compiler:1.5.1'这两个配置对kotlin不生效。
2. 目录配置，常量类配置
新建一个ui包用于存放需要跳转的Activity，随后新建一个Constant的Object文件。添加Activity的常量资源
常量类Constants
object Constants {
object Activitys{
const val RECYCLELIST_ACTIVITY = "/ui/RecycleListActivity"
}
}
复制代码目录结构
3. 在Application中进行Arouter初始化
class App : Application() {
override fun onCreate() {
super.onCreate()
if (BuildConfig.DEBUG){
ARouter.openLog()
ARouter.openDebug()
}
ARouter.init(this)
}
override fun onTerminate() {
super.onTerminate()
ARouter.getInstance().destroy()
}
}
复制代码**注意:**此处有两个小坑。
- 重写的
APP类需要在Manifest中进行添加，否则不会执行。（只需要在application节点中添加name并指向这个类即可) - 注意
BuildConfig这个类是引用谁的，因为Arouter本身也有BuildConfig。此处需要引用Anroid的BuildConfig。博主引用错了后，一直无法跳转。而且也一直没有报错，坑了很久
4. Activity的配置
以上工作做完后，就可以在需要跳转的Activity进行配置了。
跳转到的Activity，增加@Route注解
@Route(path = Constants.Activitys.RECYCLELIST_ACTIVITY)
class RecycleListActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_recycle_list)
}
}
复制代码需要进行跳转的Activity，调用Arouter单例进行跳转
mBtnList.setOnClickListener {
ARouter.getInstance().build(Constants.Activitys.RECYCLELIST_ACTIVITY).navigation()
}作者：约束№证
链接：https://juejin.cn/post/6955465825809760286
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Object类和Any详解
Any
Any类是kotlin类结构的跟，每个kotlin都继承或间接继承于Any类
/**
* The root of the Kotlin class hierarchy. Every Kotlin class has [Any] as a superclass.
*/
public open class Any {
// kotlin的函数可以没有函数体，其不是Abstract方法，所以子类不必重写。
public open operator fun equals(other: Any?): Boolean
public open fun hashCode(): Int
public open fun toString(): String
}
复制代码里面有三个open的方法equals、hashCode和toString，其中equals和hashCode如果需要修改就必须同时修改。
Object
同样java中Object也是class结构的根，每个类继承或者间接继承于Object
package java.lang;
public class Object {
public Object() {
}
private static native void registerNatives();
public final native Class<?> getClass();
public native int hashCode();
public boolean equals(Object var1) {
return this == var1;
}
protected native Object clone() throws CloneNotSupportedException;
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}
public final native void notify();
public final native void notifyAll();
public final native void wait(long var1) throws InterruptedException;
public final void wait(long var1, int var3) throws InterruptedException {
if (var1 < 0L) {
throw new IllegalArgumentException("timeout value is negative");
} else if (var3 >= 0 && var3 <= 999999) {
if (var3 > 0) {
++var1;
}
this.wait(var1);
} else {
throw new IllegalArgumentException("nanosecond timeout value out of range");
}
}
public final void wait() throws InterruptedException {
this.wait(0L);
}
protected void finalize() throws Throwable {
}
static {
registerNatives();
}
}
复制代码相比于Kotlin，java中的class方法丰富的多，十二个。其中7个本地方法包含一个静态本地方法，5个可以被子类覆盖的方法
private static native void registerNatives();
static {
registerNatives();
}
复制代码静态本地方法在类加载时执行。该方法的作用是通过类加载器加载一些本地方法到JVM中。Object类在被加载时，会加载一些methods中的本地方法到JVM中如下：
static JNINativeMethod methods[] = {
{“hashCode”, “()I”, (void *)&JVM_IHashCode},
{“wait”, “(J)V”, (void *)&JVM_MonitorWait},
{“notify”, “()V”, (void *)&JVM_MonitorNotify},
{“notifyAll”, “()V”, (void *)&JVM_MonitorNotifyAll},
{“clone”, “()Ljava/lang/Object;”, (void *)&JVM_Clone},
};
复制代码@Contract(pure = true) public final native Class<?> getClass();
返回该对象的类的Class对象。Class对象可以用于反射等场景。
public native int hashCode();
返回对象的哈希值，主要用于HashMap的hash tables。
哈希需要注意的几点：
相等的对象必须要有相同的哈希码
不相等的对象一定有着不同的哈希码——错！
有同一个哈希值的对象一定相等——错！
重写equals时必须重写hashCode
equals
public boolean equals(Object var1) {
return this == var1;
}
复制代码判断引用是否指向同一个地址，就是判断两个引用指向的对象是否是同一个对象， String重写了该方法，判断字符串是否相等。
protected native Object clone() throws CloneNotSupportedException;
该方法用于拷贝。要调用该方法需要类实现Cloneable接口，否则抛出CloneNotSupportedException。
浅拷贝，重写clone方法，调用super.clone()：
public class TestOne implements Cloneable {
@NonNull
@Override
protected TestOne clone() {
TestOne obj = null;
try {
obj = (TestOne) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
复制代码深拷贝
public class TestTwo implements Cloneable {
public TestOne var;
@NonNull
@Override
protected TestTwo clone() {
TestTwo obj = null;
try {
obj = (TestTwo) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
obj.var = obj.var.clone();
return obj;
}
}
复制代码public String toString()
返回类名和对象的哈希值的十六进制字符串，推荐子类重写该方法。
notify()、notifyAll()、wait()方法
从1.0版开始，Java中的每一个对象都有一个内部锁。如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须获得内部的对象锁。
public synchronize void method(){
method body
}
等同于
public void method(){
this.intrinsicLock.lock();
try{
method body
}
finally{ this.intrinsicLock.unlock();}
}
复制代码从这个示例我们即可看出上面几个方法的作用。
public final native void notify();
随机选择一个在该对象上调用wait方法的线程，解除其阻塞状态。该方法只能在一个同步方法或同步块中调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。
public final native void notifyAll();
解除那些在该对象上调用wait方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。
public final void wait() throws InterruptedException
使线程进入等待状态直到它被通知。该方法只能在一个同步方法中调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。
public final void wait(long millis, int nanos) throws InterruptedException
public final native void wait(long millis) throws InterruptedException;
参数：millis 毫秒数 nanos 纳秒数 < 1000 000
使线程进入等待状态直到它被通知或者经过指定的时间。这些方法只能在一个同步方法中调用。如果当前线程不是对象锁的持有者该方法抛出一个IllegalMonitorStateException异常。
protected void finalize() throws Throwable
当一个堆空间中的对象没有被栈空间变量指向的时候，这个对象会等待被java回收。
GC特点：
- 当对象不再被程序所使用的时候，垃圾回收器将会将其回收
- 垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他可以尽快回收资源（System.gc()和Runtime.getRuntime().gc()）
- 垃圾回收器在回收某个对象的时候，首先会调用该对象的finalize()方法
- GC主要针对堆内存
- 单例模式的缺点
Any和Object相同点
Kotlin中的Any只存在于编译期，运行期就不存在了。
val any = Any()
println("any:$any ")
println("anyClass:${any.javaClass} ")
val obj = any as Object
synchronized(obj){
obj.wait()
}
println("obj:$obj ")
println("obj:${any.`class`} ")
I/System.out: any:java.lang.Object@d12ebc1
I/System.out: anyClass:class java.lang.Object
I/System.out: obj:java.lang.Object@d12ebc1
I/System.out: obj:class java.lang.Object
复制代码从上面的示例可以看出在runtime，Any变成了Object，在kotlin中也可以将Any强转为Object。
从Kolitn的官方文档 kotlinlang.org/docs/java-i… 可以看到Object对应的就是Any
Kotlin专门处理一些Java类型。这些类型不是按原样从Java加载的，而是映射到相应的Kotlin类型。映射只在编译时起作用，运行时表示保持不变。Java的原语类型映射到相应的Kotlin类型（保持平台类型）
从上面的示例可以看出obj可以any混用，any强转后不仅可以使用notify()等方法，还可以使用Any的扩展方法，如使用 obj.apply { }
作者：zbt
链接：https://juejin.cn/post/6955413784143855629
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
iOS-TZImagePickerController获取图片视频
TZImagePickerControllerDemo
项目介绍
TZImagePickerControllerDemo
使用说明
1. 定义 类变量：
UIImagePickerController* picker_library_;
2.实现 UIImagePickerControllerDelegate 这个delegate，还需要UINavigationControllerDelegate 这个代理
3. 以模态的方式，显示 图片选取器
picker_library_ = [[UIImagePickerController alloc] init];
picker_library_.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
picker_library_.allowsEditing = YES;
picker_camera_.allowsImageEditing=YES;
picker_library_.delegate = self;
[self presentModalViewController: picker_library_
animated: YES];其中，sourceType 指定了 几种 图片的来源：
UIImagePickerControllerSourceTypePhotoLibrary：表示显示所有的照片
UIImagePickerControllerSourceTypeCamera：表示从摄像头选取照片
UIImagePickerControllerSourceTypeSavedPhotosAlbum：表示仅仅从相册中选取照片。
allowEditing和allowsImageEditing 设置为YES，表示 允许用户编辑图片，否则，不允许用户编辑。
选照片
//MaxImagesCount 可以选着的最大条目数
TZImagePickerController *imagePicker = [[TZImagePickerController alloc] initWithMaxImagesCount:1 delegate:self];
// 是否显示可选原图按钮
imagePicker.allowPickingOriginalPhoto = NO;
// 是否允许显示视频
imagePicker.allowPickingVideo = NO;
// 是否允许显示图片
imagePicker.allowPickingImage = YES;
// 这是一个navigation 只能present
[self presentViewController:imagePicker animated:YES completion:nil];选择照片的回调
// 选择照片的回调
-(void)imagePickerController:(TZImagePickerController *)picker
didFinishPickingPhotos:(NSArray<UIImage *> *)photos
sourceAssets:(NSArray *)assets
isSelectOriginalPhoto:(BOOL)isSelectOriginalPhoto{
}选视频
//MaxImagesCount 可以选着的最大条目数
TZImagePickerController *imagePicker = [[TZImagePickerController alloc] initWithMaxImagesCount:2 delegate:self];
// 是否显示可选原图按钮
imagePicker.allowPickingOriginalPhoto = NO;
// 是否允许显示视频
imagePicker.allowPickingVideo = YES;
// 是否允许显示图片
imagePicker.allowPickingImage = NO;
// 这是一个navigation 只能present
[self presentViewController:imagePicker animated:YES completion:nil];选择视频的回调
// 选择视频的回调
-(void)imagePickerController:(TZImagePickerController *)picker
didFinishPickingVideo:(UIImage *)coverImage
sourceAssets:(PHAsset *)asset{
}
Android修炼系列（五），写一篇超全面的annotation讲解(2)
自定义编译期注解（CLASS）
为什么要最后说编译期注解呢，因为相对前面的自定义注解来说，编译期注解有些难度，涉及到的东西比较多，但却是平时用到的最多的注解，因为编译期注解不存在反射，所以对性能没有影响。
本来也想用绑定 View 的例子讲解，但是现在这样的 demo 网上各种泛滥，而且还有各路大牛写的，所以我就没必要班门弄斧了。在这里以跳转界面为例：
Intent intent = new Intent (this, NextActivity.class);
startActivity (intent);
复制代码本着方便就是改进的原则，让我们定义一个编译期注解，来自动生成上述的代码，想想每次需要的时候只需要一个注解就能跳转到想要跳转的界面是不是很刺激。
1.首先新建一个 android 项目，在创建两个 java module（File -> New -> new Module ->java Module），因为有的类在android项目中不支持，建完后项目结构如下：
其中 annotation 中盛放自定义的注解，annotationprocessor 中创建注解处理器并做相关处理，最后的 app 则为我们的项目。
注意：MyFirstProcessor类为上文讲解 AbstractProcessor 所建的类，可以删去，跟本项目没有关系。
2.处理各自的依赖
3.编写自定义注解，这是一个应用到字段之上的注解，被注解的字段为传递的参数
/**
* 这是一个自定义的跳转传值所用到的注解。
* value 表示要跳转到哪个界面activity的元素，传入那个界面的名字。
*/
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface IntentField {
String value () default " ";
}
复制代码4.自定义注解处理器，获取被注解元素的类型，进行相应的操作。
@AutoService(javax.annotation.processing.Processor.class)
public class MyProcessot extends AbstractProcessor{
private Map<Element, List<VariableElement>> items = new HashMap<>();
private List<Generator> generators = new LinkedList<>();
// 做一些初始化工作
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
Utils.init();
generators.add(new ActivityEnterGenerator());
generators.add(new ActivityInitFieldGenerator());
}
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
// 获取所有注册IntentField注解的元素
for (Element elem : roundEnvironment.getElementsAnnotatedWith(IntentField.class)) {
// 主要获取ElementType 是不是null，即class，interface，enum或者注解类型
if (elem.getEnclosingElement() == null) {
// 直接结束处理器
return true;
}
// 如果items的key不存在，则添加一个key
if (items.get(elem.getEnclosingElement()) == null) {
items.put(elem.getEnclosingElement(), new LinkedList<VariableElement>());
}
// 我们这里的IntentField是应用在一般成员变量上的注解
if (elem.getKind() == ElementKind.FIELD) {
items.get(elem.getEnclosingElement()).add((VariableElement)elem);
}
}
List<VariableElement> variableElements;
for (Map.Entry<Element, List<VariableElement>> entry : items.entrySet()) {
variableElements = entry.getValue();
if (variableElements == null || variableElements.isEmpty()) {
return true;
}
// 去通过自动javapoet生成代码
for (Generator generator : generators) {
generator.genetate(entry.getKey(), variableElements, processingEnv);
generator.genetate(entry.getKey(), variableElements, processingEnv);
}
}
return false;
}
// 指定当前注解器使用的Java版本
@Override public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
// 指出注解处理器 处理哪种注解
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> annotations = new LinkedHashSet<>(2);
annotations.add(IntentField.class.getCanonicalName());
return annotations;
}
}
复制代码5.这是一个工具类方法，提供了本 demo 中所用到的一些方法，其实实际里面的方法都很常见，只不过做了一个封装而已.
public class Utils {
private static Set<String> supportTypes = new HashSet<>();
/** 当getIntent的时候，每种类型写的方式都不一样，所以把每种方式都添加到了Set容器中。*/
static void init() {
supportTypes.add(int.class.getSimpleName());
supportTypes.add(int[].class.getSimpleName());
supportTypes.add(short.class.getSimpleName());
supportTypes.add(short[].class.getSimpleName());
supportTypes.add(String.class.getSimpleName());
supportTypes.add(String[].class.getSimpleName());
supportTypes.add(boolean.class.getSimpleName());
supportTypes.add(boolean[].class.getSimpleName());
supportTypes.add(long.class.getSimpleName());
supportTypes.add(long[].class.getSimpleName());
supportTypes.add(char.class.getSimpleName());
supportTypes.add(char[].class.getSimpleName());
supportTypes.add(byte.class.getSimpleName());
supportTypes.add(byte[].class.getSimpleName());
supportTypes.add("Bundle");
}
/** 获取元素所在的包名。*/
public static String getPackageName(Element element) {
String clazzSimpleName = element.getSimpleName().toString();
String clazzName = element.toString();
return clazzName.substring(0, clazzName.length() - clazzSimpleName.length() - 1);
}
/** 判断是否是String类型或者数组或者bundle，因为这三种类型getIntent()不需要默认值。*/
public static boolean isElementNoDefaultValue(String typeName) {
return (String.class.getName().equals(typeName) || typeName.contains("[]") || typeName.contains("Bundle"));
}
/**
* 获得注解要传递参数的类型。
* @param typeName 注解获取到的参数类型
*/
public static String getIntentTypeName(String typeName) {
for (String name : supportTypes) {
if (name.equals(getSimpleName(typeName))) {
return name.replaceFirst(String.valueOf(name.charAt(0)), String.valueOf(name.charAt(0)).toUpperCase())
.replace("[]", "Array");
}
}
return "";
}
/**
* 获取类的的名字的字符串。
* @param typeName 可以是包名字符串，也可以是类名字符串
*/
static String getSimpleName(String typeName) {
if (typeName.contains(".")) {
return typeName.substring(typeName.lastIndexOf(".") + 1, typeName.length());
}else {
return typeName;
}
}
/** 自动生成代码。*/
public static void writeToFile(String className, String packageName, MethodSpec methodSpec, ProcessingEnvironment processingEnv, ArrayList<FieldSpec> listField) {
TypeSpec genedClass;
if(listField == null) {
genedClass = TypeSpec.classBuilder(className)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(methodSpec).build();
}else{
genedClass = TypeSpec.classBuilder(className)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(methodSpec)
.addFields(listField).build();
}
JavaFile javaFile = JavaFile.builder(packageName, genedClass)
.build();
try {
javaFile.writeTo(processingEnv.getFiler());
} catch (IOException e) {
e.printStackTrace();
}
}
}
复制代码6.自定义一个接口，把需要自动生成的每个java文件的方法都独立出去。
public interface Generator {
void genetate(Element typeElement
, List<VariableElement> variableElements
, ProcessingEnvironment processingEnv);
}
复制代码7.编写自动生成文件的格式，生成后的类格式如下：
上图为本例中的MainActivity$Enter类，如果你想生成一个类，那么这个类的格式和作用肯定已经在你的脑海中有了定型，如果你自己都不知道想要生成啥，那还玩啥。
/**
* 这是一个要自动生成跳转功能的.java文件类
* 主要思路：1.使用javapoet生成一个空方法
* 2.为方法加上实参
* 3.方法的里面的代码拼接
* 主要需要：获取字段的类型和名字，获取将要跳转的类的名字
*/
public class ActivityEnterGenerator implements Generator{
private static final String SUFFIX = "$Enter";
private static final String METHOD_NAME = "intentTo";
@Override
public void genetate(Element typeElement, List<VariableElement> variableElements, ProcessingEnvironment processingEnv) {
MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(METHOD_NAME)
.addModifiers(Modifier.PUBLIC)
.returns(void.class);
// 设置生成的METHOD_NAME方法第一个参数
methodBuilder.addParameter(Object.class, "context");
methodBuilder.addStatement("android.content.Intent intent = new android.content.Intent()");
// 获取将要跳转的类的名字
String name = "";
// VariableElement 主要代表一般字段元素，是Element的一种
for (VariableElement element : variableElements) {
// Element 只是一种语言元素，本身并不包含信息，所以我们这里获取TypeMirror
TypeMirror typeMirror = element.asType();
// 获取注解在身上的字段的类型
TypeName type = TypeName.get(typeMirror);
// 获取注解在身上字段的名字
String fileName = element.getSimpleName().toString();
// 设置生成的METHOD_NAME方法第二个参数
methodBuilder.addParameter(type, fileName);
methodBuilder.addStatement("intent.putExtra(\"" + fileName + "\"," +fileName + ")");
// 获取注解上的元素
IntentField toClassName = element.getAnnotation(IntentField.class);
String name1 = toClassName.value();
if(null != name && "".equals(name)){
name = name1;
}
// 理论上每个界面上的注解value一样，都是要跳转到的那个类名字，否则提示错误
else if(name1 != null && !name1.equals(name)){
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "同一个界面不能跳转到多个活动，即value必须一致");
}
}
methodBuilder.addStatement("intent.setClass((android.content.Context)context, " + name +".class)");
methodBuilder.addStatement("((android.content.Context)context).startActivity(intent)");
/**
* 自动生成.java文件
* 第一个参数：要生成的类的名字
* 第二个参数：生成类所在的包的名字
* 第三个参数：javapoet 中提供的与自动生成代码的相关的类
* 第四个参数：能够为注解器提供Elements,Types和Filer
*/
Utils.writeToFile(typeElement.getSimpleName().toString() + SUFFIX, Utils.getPackageName(typeElement), methodBuilder.build(), processingEnv,null);
}
}
复制代码当我们定义了跳转的类，那么接下来肯定就是在另一个界面获取传递过来的数据了，参考格式如下，这是本demo中自动生成的MainActivity$Init 类。
/**
* 要生成一个.Java文件，在这个Java文件里生成一个获取上个界面传递过来数据的方法
* 主要思路：1.使用Javapoet生成一个空的的方法
* 2.为方法添加需要的形参
* 3.拼接方法内部的代码
* 主要需要：获取传递过来字段的类型
*/
public class ActivityInitFieldGenerator implements Generator {
private static final String SUFFIX = "$Init";
private static final String METHOD_NAME = "initFields";
@Override
public void genetate(Element typeElement, List<VariableElement> variableElements, ProcessingEnvironment processingEnv) {
MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(METHOD_NAME)
.addModifiers(Modifier.PROTECTED)
.returns(Object.class);
final ArrayList<FieldSpec> listField = new ArrayList<>();
if (null != variableElements && variableElements.size() != 0) {
VariableElement element = variableElements.get(0);
// 当前接收数据的字段的名字
IntentField currentClassName = element.getAnnotation(IntentField.class);
String name = currentClassName.value();
methodBuilder.addParameter(Object.class, "currentActivity");
methodBuilder.addStatement(name + " activity = (" + name + ")currentActivity");
methodBuilder.addStatement("android.content.Intent intent = activity.getIntent()");
}
for (VariableElement element : variableElements) {
// 获取接收字段的类型
TypeName currentTypeName = TypeName.get(element.asType());
String currentTypeNameStr = currentTypeName.toString();
String intentTypeName = Utils.getIntentTypeName(currentTypeNameStr);
// 字段的名字，即key值
Name filedName = element.getSimpleName();
// 创建成员变量
FieldSpec fieldSpec = FieldSpec.builder(TypeName.get(element.asType()),filedName+"")
.addModifiers(Modifier.PUBLIC)
.build();
listField.add(fieldSpec);
// 因为String类型的获取 和 其他基本类型的获取在是否需要默认值问题上不一样，所以需要判断是哪种
if (Utils.isElementNoDefaultValue(currentTypeNameStr)) {
methodBuilder.addStatement("this."+filedName+"= intent.get" + intentTypeName + "Extra(\"" + filedName + "\")");
} else {
String defaultValue = "default" + element.getSimpleName();
if (intentTypeName == null) {
// 当字段类型为null时，需要打印错误信息
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "the type:" + element.asType().toString() + " is not support");
} else {
if ("".equals(intentTypeName)) {
methodBuilder.addStatement("this." + filedName + "= (" + TypeName.get(element.asType()) + ")intent.getSerializableExtra(\"" + filedName + "\")");
} else {
methodBuilder.addParameter(TypeName.get(element.asType()), defaultValue);
methodBuilder.addStatement("this."+ filedName +"= intent.get"
+ intentTypeName + "Extra(\"" + filedName + "\", " + defaultValue + ")");
}
}
}
}
methodBuilder.addStatement("return this");
Utils.writeToFile(typeElement.getSimpleName().toString() + SUFFIX, Utils.getPackageName(typeElement), methodBuilder.build(), processingEnv, listField);
}
}
复制代码8、在Activity中使用刚才的自定义注解。
public class MainActivity extends AppCompatActivity {
@IntentField("NextActivity")
int count = 10;
@IntentField("NextActivity")
String str = "编译器注解";
@IntentField("NextActivity")
StuBean bean = new StuBean(1,"No1");
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
addOnclickListener();
}
public void addOnclickListener() {
findViewById(R.id.tvnext).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 从哪个界面进行跳转，则以哪个界面打头，enter 结尾
// 例如 MainActivity$Enter
new MainActivity$Enter()
.intentTo(MainActivity.this, count, str, bean);
}
});
}
}
复制代码9.这是实体bean
public class StuBean implements Serializable{
public StuBean(int id , String name) {
this.id = id;
this.name = name;
}
//学号
public int id;
//姓名
public String name;
}
复制代码10、在NextActivity接收并打印数据:
public class NextActivity extends AppCompatActivity {
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_next);
textView = (TextView) findViewById(R.id.tv);
// 想获取从哪个界面传递过来的数据，就已哪个类打头，init结尾
// 例如 MainActivity$Init
MainActivity$Init formIntent = (MainActivity$Init)new MainActivity$Init().initFields(this,0);
textView.setText(formIntent.count + "---" + formIntent.str + "---" +formIntent.bean.name);
// 打印上个界面传递过来的数据
Log.i("Tag",formIntent.count + "---" + formIntent.str + "---" + formIntent.bean.name);
}
}
复制代码11.运行结果：
总结
好了，看到这里，你应该对注解有所了解了，但是看的再懂也不如自己动手练一下。如果你仔细研究了，你会发现一个非常奇怪的事情，当我们设置 RetentionPolicy.CLASS 级别的时候，仍能通过反射获取注解信息，当我们设置 RetentionPolicy.SOURCE 级别的时候，仍能走通编译期注解，是不是非常迷惑。
之后只能又找了一些资料（非权威），看到了一个比较受认同的解释：这个属性主要给IDE 或者编译器开发者准备的，一般应用级别上不太会用到。
好了，本文到这里就结束了，关于注解的讲解应该非常全面了。如果本文对你有用，来点个赞吧，大家的肯定也是阿呆i坚持写作的动力。
参考 1、B.E，Java编程思想：机械工业出版社
作者：矛盾的阿呆i
链接：https://juejin.cn/post/6936609673416015908
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Android修炼系列（五），写一篇超全面的annotation讲解(1)
不学注解，也许是因为平时根本不需要没事自定义个这玩意玩，可随着Android形势越来越内卷，不学点东西是真不行了。而通过本文的学习，可以让你对于注解有个全面的认识，你会发现，小小的注解，大有可为，编不下去了..
注解不同于注释，注释的作用是为了方便自己或者别人的阅读，能够利用 javadoc 提取源文件里的注释来生成人们所期望的文档，对于代码本身的运行是没有任何影响的。
而注解的功能就要强大很多，不但能够生成描述符文件，而且有助于减轻编写“样板”代码的负担，使代码干净易读。通过使用扩展的注解（annotation）API 我们能够在 编译期 和 运行期 对代码进行操控。
注解（也被称为元数据）为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后的某个时刻非常方便的使用这些数据。 —Jeremy Meyer
本文主要对于下面几个方面进行讲解，篇幅很长，建议收藏查看：
Java 最初内置的三种标准注解
注解是 java SE5中的重要的语言变化之一，你可能对注解的原理不太理解，但你每天的开发中可能无时无刻不在跟注解打交道，最常见的就是 @Override 注解，所以注解并没有那么神秘，也没有那么冷僻，不要害怕使用注解（虽然使用的注解大部分情况都是根据需要自定义的注解），用的多了自然就熟了。为什么说最初的三种标准注解呢，因为在后续的 java 版本中又陆陆续续的增加了一些注解，不过原理都是一样的。
| java SE5内置的标准注解 | 含义 |
|---|---|
| @Override | 表示当前的方法定义将覆盖超类中的方法，如果方法拼写错误或者方法签名不匹配，编译器便会提出错误提示 |
| @Deprecated | 表示当前方法已经被弃用，如果开发者使用了注解为它的元素，编译器便会发出警告信息 |
| @SuppressWarnings | 可以关闭不当的编译器警告信息 |
Java 提供的四种元注解和一般注解
所谓元注解（meta-annotation）也是一种注解，只不过这种注解负责注解其他的注解。所以再说元注解之前我们来看一下普通的注解：
public @interface LogClassMessage {}
这是一个最普通的注解，注解的定义看起来很像一个接口，在 interface 前加上 @ 符号。事实上在语言级别上，注解也和 java 中的接口、类、枚举是同一个级别的，都会被编译成 class 文件。而前面提到的元注解存在的目的就是为了修饰这些普通注解，但是要明确一点，元注解只是给普通注解提供了作用，并不是必须存在的。
| java 提供的元注解 | 作用 |
|---|---|
| @Target | 定义你的注解应用到什么地方（详见下文解释） |
| @Retention | 定义该注解在哪个级别可用（详见下文解释） |
| @Documented | 将此注解包含在 javadoc 中 |
| @Inherited | 允许子类继承超类中的注解 |
〔1〕@Target使用的时候添加一个 ElementType 参数，表示当前注解可以应用到什么地方，即可以指定一种，也可以同时指定多种，使用方法如下：
// 表示当前的注解只能应用到类、接口（包括注解）、enum上面
@Target(ElementType.TYPE)
public @interface LogClassMessage {}
复制代码 // 表示当前的注解只能应用到方法和成员变量上面
@Target({ElementType.METHOD,ElementType.FIELD})
public @interface LogClassMessage {}
复制代码下面来看一下 ElementType 的全部参数含义：
| ElementType 参数 | 说明 |
|---|---|
| ElementType.CONSTRUCTOR | 构造器的声明 |
| ElementType.FIELD | 域的声明（包括enum的实例） |
| ElementType.LOCATION_VARLABLE | 局部变量的声明 |
| ElementType.METHOD | 方法的声明 |
| ElementType.PACKAGE | 包的声明 |
| ElementType.PARAMETER | 参数的声明 |
| ElementType.TYPE | 类、接口（包括注解类型）、enum声明 |
〔2〕@Retention用来注解在哪一个级别可用，需要添加一个 RetentionPolicy 参数，用来表示在源代码中（SOURCE），在类文件中（CLASS）或者运行时（RUNTIME）：
// 表示当前注解运行时可用
@Retention(RetentionPolicy.RUNTIME)
public @interface LogClassMessage {}
复制代码下面来看一下 RetentionPolicy 的全部参数含义：
| RetentionPolicy 参数 | 说明 |
|---|---|
| RetentionPolicy.SOURCE | 注解将被编译器丢弃，只能存于源代码中 |
| RetentionPolicy.CLASS | 注解在class文件中可用，能够存于编译之后的字节码之中，但会被VM丢弃 |
| RetentionPolicy.RUNTIME | VM在运行期也会保留注解，因此运行期注解可以通过反射获取注解的相关信息 |
在注解中，一般都会包含一些元素表示某些值，并且可以为这些元素设置默认值，没有元素的注解也称为标记注解（marker annotation）
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.FIELD})
public @interface LogClassMessage {
public int id () default -1;
public String message() default "";
}
复制代码注：虽然上面的 id 和 message 定义和接口的方法定义很类似，但是在注解中将 id 和 message 称为：int 元素 id , String 元素 message。而且注解元素的类型是有限制的，并不是任何类型都可以，主要包括：基本数据类型（理论上是没有基本类型的包装类型的，但是由于自动封装箱，所以也不会报错）、String 类型、enum 类型、Class 类型、Annotation 类型、以及以上类型的数组，（没有等字，说明目前注解的元素类型只支持上面列出的这几种），否则编译器便会提示错误。
invalid type 'void ' for annotation member // 例如注解类型为void的错误信息
对于默认值限制 ，Bruce Eckel 在其书中是这样描述的：编译器对元素的默认值有些过分挑剔，首先，元素不能有不确定的值。也就是说，元素必须要么具有默认值，要么在使用注解时提供注解的值。其次，对于非基本类型的元素，无论在源代码声明中，或者在注解接口中定义默认值时，都不能以 null 作为其值。这个约束使得处理器很难表现一个元素的存在或缺失的状态，因为在每个注解的声明中，所有元素都存在，并且都具有相应的值。为了绕开这个约束，我们只能自己定义一些特殊的值，例如空字符串或者负数，以此表示某个元素的不存在，这算得上是一个习惯用法。
参考系统的标准注解
怎么说呢，接触一种知识的途径有很多，可能每一种的结果都是大同小异的，都能让你学到东西，但是实现的方式、实现过程中的规范、方法和思路却并不一定是最佳的。
上文讲到的是注解的基本语法，那么系统是怎么用的呢？首先让我们来看一下使用频率最高的 @Override ：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {}
复制代码〔1〕首先系统定义一个没有元素的标记注解 Override ，随后使用元注解 @Target 指明 Override 注解只能应用于方法之上（你可以细想想，是不是在我们实际使用这个注解的时候，只能是重写方法，没有见过重写类或者字段的吧），使用注解 @Retention 表示当前注解只能存在源代码中，并不会出现在编译之后的 class 文件之中。
@Override
protected void onResume() {
super.onResume();
}
复制代码〔2〕如在 Activity 中我们可以重写 onResume() 方法，添加注解 @override 之后编译器便会去检查父类中是否存在相同方法，如果不存在便会报错。
〔3〕也许到这里你会感到很疑惑，注解到底是怎么工作的，怎么系统这样定义一个注解 Override 它就能工作了？黑魔法吗，擦擦，完成看不到实现过程嘛（泪流满面），经过查阅了一些资料（非权威）了解到，其实处理过程都编写在了编译器里面，也就是说编译器已经给我们写好了处理方法，当编译器进行检查的时候就会调用相应的处理方法。
注解处理器
介绍之前，先引用 Jeremy Meyer 的一段话：如果没有用来读取注解的工具，那么注解也不会比注释更有用。使用注解的过程中，很重要的一个部分就是创建与使用注解处理器。Java SE5 扩展了反射机制的API，以帮助程序员构造这类工具。同时，它还提供了一个外部工具 apt帮助程序员解析带有注解的 java 源代码。
根据上面描述我们可以知道，注解处理器并不是一个特定格式，并不是只有继承了 AbstractProcessor 这个抽象类才叫注解处理器，凡是根据相关API 来读取注解的类或者方法都可以称为注解处理器。
反射机制下的处理器
最简单的注解处理器莫过于，直接使用反射机制的 getDeclaredMethods 方法获取类上所有方法（字段原理是一样的），再通过调用 getAnnotation 获取每个方法上的特定注解，有了注解便可以获取注解之上的元素值，方法如下：
public void getAnnoUtil(Class<?> cl) {
for(Method m : cl.getDeclaredMethods()) {
LogClassMessage logClassMessage = m.getAnnotation(LogClassMessage .class);
if(null != logClassMessage) {
int id = logClassMessage.id();
String method = logClassMessage.message();
}
}
}
复制代码由于反射对性能会有一定的损耗，所以上述类型的注解处理器并不占主流，现在使用最多的还是 AbstractProcessor 自定义注解处理器，因为后者并不需要通过反射实现，效率和直接调用普通方法没有区别，这也是为什么编译期注解比运行时注解更受欢迎。
但是并不是说为了性能运行期注解就不能用了，只能说不能滥用，要在性能方面给予考虑。目前主要的用到运行期注解的框架差不多都有缓存机制，只有在第一次使用时通过反射机制，当再次使用时直接从缓存中取出。
好了，说着说着就跑题，还是来聊一下这个 AbstractProcessor 类吧，到底有何魅力让这么多人为她沉迷，方法如下：
public class MyFirstProcessor extends AbstractProcessor {
/**
* 做一些初始化工作，注释处理工具框架调用了这个方法，给我们传递一个 ProcessingEnvironment 类型的实参。
*
* <p>如果在同一个对象多次调用此方法，则抛出IllegalStateException异常。
*
* @param processingEnvironment 这个参数里面包含了很多工具方法
*/
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
// 返回用来在元素上进行操作的某些工具方法的实现
Elements es = processingEnvironment.getElementUtils();
// 返回用来创建新源、类或辅助文件的Filer
Filer filer = processingEnvironment.getFiler();
// 返回用来在类型上进行操作的某些实用工具方法的实现
Types types = processingEnvironment.getTypeUtils();
// 这是提供给开发者日志工具，我们可以用来报告错误和警告以及提示信息
// 注意 message 使用后并不会结束过程，Kind 参数表示日志级别
Messager messager = processingEnvironment.getMessager();
messager.printMessage(Diagnostic.Kind.ERROR, "例如当默认值为空则提示一个错误");
// 返回任何生成的源和类文件应该符合的源版本
SourceVersion version = processingEnvironment.getSourceVersion();
super.init(processingEnvironment);
}
/**
* @return 如果返回true 不要求后续Processor处理它们，反之，则继续执行处理。
*/
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
/**
* TypeElement 这表示一个类或者接口元素集合常用方法不多，TypeMirror getSuperclass()返回直接超类。
*
* <p>详细介绍下 RoundEnvironment 这个类,常用方法：
* boolean errorRaised() 如果在以前的处理round中发生错误，则返回true
* Set<? extends Element> getElementsAnnotatedWith(Class<? extends Annotation> a)
* 这里的 a 即你自定义的注解class类，返回使用给定注解类型注解的元素的集合
* Set<? extends Element> getElementsAnnotatedWith(TypeElement a)
*
* <p>Element 的用法：
* TypeMirror asType() 返回此元素定义的类型 如int
* ElementKind getKind() 返回元素的类型 如 e.getkind() = ElementKind.FIELD 字段
* boolean equals(Object obj) 如果参数表示与此元素相同的元素，则返回true
* Name getSimpleName() 返回此元素的简单名称
* List<? extends Elements> getEncloseElements 返回元素直接封装的元素
* Element getEnclosingElements 返回此元素的最里层元素，如果这个元素是个字段等，则返回为类
*/
return false;
}
/**
* 指出注解处理器 处理哪种注解
* 在 jdk1.7 中，我们可以使用注解 {@SupportedAnnotationTypes()} 代替
*/
@Override
public Set<String> getSupportedAnnotationTypes() {
return super.getSupportedAnnotationTypes();
}
/**
* 指定当前注解器使用的Jdk版本。
* 在 jdk1.7 中，我们可以使用注解{@SupportedSourceVersion()}代替
*/
@Override
public SourceVersion getSupportedSourceVersion() {
return super.getSupportedSourceVersion();
}
}
复制代码自定义运行期注解（RUNTIME）
我们在开发中经常会需要计算一个方法所要执行的时间，以此来直观的比较哪个实现方式最优，常用方法是开始结束时间相减
System.currentTimeMillis()
但是当方法多的时候，是不是减来减去都要减的怀疑人生啦，哈哈，那么下面我就来写一个运行时注解来打印方法执行的时间。
1.首先我们先定义一个注解，并给注解添加我们需要的元注解：
/**
* 这是一个自定义的计算方法执行时间的注解。
* 只能作用于方法之上,属于运行时注解，能被VM处理，可以通过反射得到注解信息。
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CalculateMethodRunningTime {
// 要计算时间的方法的名字
String methodName() default "no method to set";
}
复制代码2.利用反射方法在程序运行时，获取被添加注解的类的信息：
public class AnnotationUtils {
// 使用反射通过类名获取类的相关信息。
public static void getClassInfo(String className) {
try {
Class c = Class.forName(className);
// 获取所有公共的方法
Method[] methods = c.getMethods();
for (Method m : methods) {
Class<CalculateMethodRunningTime> ctClass = CalculateMethodRunningTime.class;
if (m.isAnnotationPresent(ctClass)) {
CalculateMethodRunningTime anno = m.getAnnotation(ctClass);
// 当前方法包含查询时间的注解时
if (anno != null) {
final long beginTime = System.currentTimeMillis();
m.invoke(c.newInstance(), null);
final long time = System.currentTimeMillis() - beginTime;
Log.i("Tag", anno.methodName() + "方法执行所需要时间：" + time + "ms");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
复制代码3.在 activity 中使用注解，注意咱们的注解是作用于方法之上的：
public class ActivityAnnotattion extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_anno);
AnnotationUtils.getClassInfo("com.annotation.zmj.annotationtest.ActivityAnnotattion");
}
@CalculateMethodRunningTime(methodName = "method1")
public void method1() {
long i = 100000000L;
while (i > 0) { i--; }
}
}
复制代码4.运行结果：
作者：矛盾的阿呆i
链接：https://juejin.cn/post/6936609673416015908
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
Android修炼系列（四），谈起泛型，大家都很佛性
当我们new了一个对象，会发生什么呢？来段代码：
public class Tested {
public static int T = 10;
public int c = 1;
}
复制代码类初始化
在编译期，编译器会将 Tested.java类转换成 Tested.class 字节码文件。当虚拟机接收到new 字节码指令时，如果此时类还未被初始化，则虚拟机会先进行类的初始化过程。
在类加载完成后。虚拟机会为new Tested() 的Tested对象，在java堆中分配内存。而对象所需要的内存大小在类加载完成后就被确定了。
指针碰撞
如果 java 中的内存是规整的，即使用过的放在一边，空闲的在另一边，中间放着指针作为分界点的指示器。那所分配的内存就仅仅是将指针像空闲空间挪动一段与对象大小相等的距离。这种方式内称为指针碰撞。
空闲列表
如果 java 中的内存是不工整的，使用过的和空闲的内存相互交错，那么虚拟机就必须维护一个列表记录哪些内存是可用的。在分配的时候从列表中找到一块足够大的空间给对象示例，并更新表的记录。这种分配方式称为空闲列表。
对象初始化
当我们的对象内存被分配完毕后，虚拟机就会对对象进行初始化操作。
此时Tested 对象在我们眼里就算出生了，在虚拟机眼里就是真正可用的了。可对象的生命并不是无穷的，它也会经历自己的死亡。
可达性分析
在主流实现中，我们通过可达性分析来判断一个对象是否存活。实现思路是：通过一系列被称为 “GC Roots” 的对象作为起始点，从这些节点开始像下搜索，搜索所走的路径被称为引用链，当一个对象到GC Roots没有任何引用链相连，则证明此对象是不可用的。见图：
即使 Obj5 与 Obj4 由于与 GC Roots 没有引用链相连，所以我们称 GC Roots 到对象 Obj4 和 Obj5 不可达。所以 Obj4 和 Obj5 就是可回收的。
既然Obj4 和 Obj5 是可回收的，那么是否一定会被回收呢？不一定。此时虚拟机会进行第一次的标记过程。因为 java 内能够重写 finalize() 方法（在这里只是分析特例，不推荐在任何情况下使用此方法），当对象重写了此方法，并且 finalize() 方法还未被虚拟机调用，那么虚拟机就会将此对象放入一个专门的F-Queue队列，由一个单独的 Finalizer 线程去执行它，如果队列中对象的 finalize() 方法在虚拟机第二次标记之前执行，并在此次执行过程中又将自己与GC Roots 引用链相连，那么虚拟机在进行第二次标记时，就会将该对象从 F-Queue队列移除，否则就宣告该对象死亡。注意：finalize() 方法只会被执行一次，所以一个对象一生只有一次机会进入F-Queue队列，有机会逃脱本此死亡。
如果对象已经宣告死亡了，那么虚拟机怎么来回收它吗？
标记-清除算法
这是最基础的收集算法，主要分为标记和清除两个阶段。首先标记出所以需要回收的对象，在标记完成后统一回收所有被标记的对象。可以参考上面的空闲列表。其有两点不足：
a. 效率问题，标记和清除两个过程效率都不高。
b. 空间问题，因为堆中的内存不是规整的，已使用的和空闲的内存相互交错，这也就导致了每次GC回收后，产生大量的内存碎片，而当再次分配一个大对象时，如果无法找到足够的连续内存，又会再此触发GC回收。
复制算法
复制算法是将堆内存分成大小相等的两块，每次只使用其中一块，这样内存就是规整的了，参考指针碰撞。每当一块内存使用完了，就将该块内存中存活的对象复制到另一边，随后将该块内存一次清理掉。
现在的虚拟机都采用这种方式来回收新生代，只是并不是按照1:1的比例来划分内存，而是将内存分为一块较大的 Eden 空间，和两块较小的 Survivor 空间（HotSpot虚拟机默认Eden：Survivor = 8 :1）。每次只使用 Eden 和 其中一块 Survivor 空间，当回收时，将 Eden 空间和当前正使用的 Survivor 空间内存活的对象复制到另一块空闲的 Survivor空间，随后清空 Eden 和 刚才用过的 Survivor 内存。
注意：由于我们无法保证每次 存活的对象所占内存一直都不大于 Survivor 内存值，所以就会有溢出风险。所以在 分代收集算法 中，虚拟机会将内存先划分为一块新生代内存和一块为老年代内存。而在新生代内存中，会采用这种8:1:1的内存分配方式，如果溢出了，就将该情况下的存活对象全部放在老年代内存里，说白了就是一种兜底策略。这里要注意的是，不是溢出的那部分，而是全部的存活对象。
标记-整理算法
标记-整理算法中的标记过程，与标记-清除算法中的标记过程一样，不同的是，当标记完成并清理回收完对象后，会将当前不连续的碎片内存就行整理，即存活的对象都移到一端，来保证接下来要分配的内存的规整性。我们的 分代收集算法 中的老年代内存块，就是采用的该算法（当然也可以是标记-清除算法，不同虚拟机的策略不同）。所以就不再对分代收集算法就行赘述了。
好了，本文到这里，关于“对象”的生命周期的讲解就结束了。如果本文对你有用，来点个赞吧，大家的肯定也是阿呆i坚持写作的动力。
参考
1、周志明，深入理解JAVA虚拟机：机械工业出版社
作者：矛盾的阿呆i
链接：https://juejin.cn/post/6935481800365981727
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
iOS-MBprogressHUD的使用
看开发文档中，涉及到六种基础的提示框
typedef NS_ENUM(NSInteger, MBProgressHUDMode) {
/**使用UIActivityIndicatorView显示进度。这是菊花默认值。 */
MBProgressHUDModeIndeterminate,
/** 使用圆形的饼图来显示进度。 */
MBProgressHUDModeDeterminate,
/** 使用水平进度条显示进度 */
MBProgressHUDModeDeterminateHorizontalBar,
/** 使用圆环进度视图显示进度。*/
MBProgressHUDModeAnnularDeterminate,
/** 自定义的view*/
MBProgressHUDModeCustomView,
/** 仅显示标签 */
MBProgressHUDModeText
};使用函数
+ (void)showToast:(NSString *)title withView:(UIView *)view {
MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:view animated:YES];
hud.mode = MBProgressHUDModeIndeterminate;
hud.labelText = title;
[hud hide:YES afterDelay:1];
}运行例子：
//1,设置背景框的透明度 默认0.8
hud.opacity = 1;
//2,设置背景框的背景颜色和透明度， 设置背景颜色之后opacity属性的设置将会失效
hud.color = [UIColor redColor];
hud.color = [HUD.color colorWithAlphaComponent:1];
//3,设置背景框的圆角值，默认是10
hud.cornerRadius = 20.0;
//4,设置提示信息 信息颜色，字体
hud.labelColor = [UIColor blueColor];
hud.labelFont = [UIFont systemFontOfSize:13];
hud.labelText = @"Loading...";
//5,设置提示信息详情 详情颜色，字体
hud.detailsLabelColor = [UIColor blueColor];
hud.detailsLabelFont = [UIFont systemFontOfSize:13];
hud.detailsLabelText = @"LoadingLoading...";
//6，设置菊花颜色 只能设置菊花的颜色
hud.activityIndicatorColor = [UIColor blackColor];
//7,设置一个渐变层
hud.dimBackground = YES;
//9，设置提示框的相对于父视图中心点的便宜，正值 向右下偏移，负值左上
hud.xOffset = -80;
hud.yOffset = -100;
//10，设置各个元素距离矩形边框的距离
hud.margin = 0;
//11，背景框的最小大小
hud.minSize = CGSizeMake(50, 50);
//12设置背景框的实际大小 readonly
CGSize size = HUD.size;
//13,是否强制背景框宽高相等
hud.square = YES;WKWebView 使用问题整理
一. WKWebView处理window.open问题
WKWebView加载页面, 当页面使用window.open跳转时候, 无响应, 需要实现WKUIDelegate协议实现
-(WKWebView *)webView:(WKWebView *)webView createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration forNavigationAction:(WKNavigationAction *)navigationAction windowFeatures:(WKWindowFeatures *)windowFeatures{
WKFrameInfo *frameInfo = navigationAction.targetFrame;
if (![frameInfo isMainFrame]) {
//1. 本页跳转
[webView loadRequest:navigationAction.request];
//2. 获取url 打开新的 vc 实现跳转到新页面
//NSString *urlStr = [[navigationAction.request URL] absoluteString];
}
return nil;
}注意 :
1- 使用 window.open 在移动端可能引发兼容问题, 建议前端对移动端标签使用location.href处理
2- ajax 处理window.open时候, 同步时可以响应跳转, 异步时不会响应跳转
$.ajax({
url: '',
async: true,
complete: function (xhr) {
window.open("http://www.baidu.com");
}
});二. WKWebView处理a标签问题
方案1: 不建议使用
- (void)webView:(WKWebView *)webView didFinishNavigation:(null_unspecified WKNavigation *)navigation{
// 将a标签 跳转方式全部改为本页
[webView evaluateJavaScript:@"var aArr = document.getElementsByTagName('a');for(var i=0;i} 方案2: WKNavigationDelegate协议实现
-(void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler{
// webview 本页重新加载
if (navigationAction.targetFrame == nil) {
[webView loadRequest:navigationAction.request];
}
decisionHandler(WKNavigationActionPolicyAllow);
return;
}方案3: WKUIDelegate协议实现
-(WKWebView *)webView:(WKWebView *)webView createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration forNavigationAction:(WKNavigationAction *)navigationAction windowFeatures:(WKWindowFeatures *)windowFeatures{
WKFrameInfo *frameInfo = navigationAction.targetFrame;
if (![frameInfo isMainFrame]) {
// 可创建新页面打开 [WebView new]
// 也可重新加载本页面 [webView loadRequest:navigationAction.request];
}
return nil;
}注意 : 如果方案2与方案3 代码中均实现, 程序会先执行方案2
三. WKWebView处理alert 问题
WKWebView加载页面, 当页面使用alert()、confirm()和prompt(),默认无响应. 若要正常使用这三个方法，需要实现WKUIDelegate中的三个方法模拟JS的这三个方法
JS 处理实现方法
function showAlert() {
alert("js_alertMessage");
}
function showConfirm() {
confirm("js_confirmMessage");
}
function showPrompt() {
prompt("js_prompt", "js_prompt_defaultMessage");
}
App 处理
//! alert(message)
- (void)webView:(WKWebView *)webView runJavaScriptAlertPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(void))completionHandler {
completionHandler();
}
//! confirm(message)
- (void)webView:(WKWebView *)webView runJavaScriptConfirmPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(BOOL))completionHandler {
completionHandler();
}
//! prompt(prompt, defaultText)
- (void)webView:(WKWebView *)webView runJavaScriptTextInputPanelWithPrompt:(NSString *)prompt defaultText:(NSString *)defaultText initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(NSString *))completionHandler {
completionHandler();
}注意: completionHandler();需要被执行, 不然会引发crash.
四. WKWebView与JS简单交互
-WKWebView加载页面, 当需要给js简单交互, 可如下处理
// JS 处理
document.getElementById("btn").onclick = function () {
var url = "APP://action?params";
window.location.href = url;
}
// App 处理
-(void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler{
if ([navigationAction.request.URL.scheme caseInsensitiveCompare:@"APP"] == NSOrderedSame) {
// 进行业务处理
decisionHandler(WKNavigationActionPolicyCancel);
}else{
if (navigationAction.targetFrame == nil) {
[webView loadRequest:navigationAction.request];
}
decisionHandler(WKNavigationActionPolicyAllow);
}
return;
}// App 处理
NSString *func = [NSString stringWithFormat:@"loadData('%@', '%@')", @"aaa", @"bbb"];
[webView evaluateJavaScript:func completionHandler:nil];
// JS 处理
function loadData(action, params){
document.getElementById("returnValue").innerHTML = action + '?' + params;
}注意:
1 webView调用 evaluateJavaScript:completionHandler:方法, 要确保前端的JS方法不在闭包中, 如window.onload = function() {} 中的方法就无法调用.
2 如果交互复杂 可以使用 WebViewJavascriptBridge 实现
五. WKWebView相关文档
转自：https://www.jianshu.com/p/b9a88a537d87
iOS面试题（四）
1. OC 的消息机制
消息机制可以分为三个部分
1. 消息传递
当我么调用方法的时候，方法的调用都会转化为objc_msgSend这样来传递。
第一步会根据对象的isa指针找到所属的类(也就是类对象)
第二步，会根据类对象里面的catch里面查找。catch是个散列表，是根据@selector(方法名)来获取对应的IMP，从而开始调用
第三步，如果第二步没有找到，会继续查找到类对象里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面
第四步，如果第三部也没有找到，会根据类对象里面的superclass指针，查找super的catch,如果也是没有查找，会继续查找到superclass里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面
第五步，如果第四部还是没有查找到，此时会根据类的superclass,继续第四部操作
.......
第六步。如果一直查找到基类都没有找到响应的方法，则会进入动态解析里面
2. 动态解析
当消息传递，没有找到对应的IMP的时候，会进入的动态解析中
此时会根据方法是类方法，还是实例方法分别调用+(BOOL)resolveClassMethod:(SEL)sel、+(BOOL)resolveInstanceMethod:(SEL)sel
我们可以实现这两个方法，使用Runtime的class_addMethod来添加对应的IMP
如果添加后，返回true,没有添加则调用父类方法
注意：其实返回true或者false,结果都是一样的，再次掉消息传递步骤
3. 消息转发
如果我们没有实现动态解析方法，就会走到消息转发这里
第一步，会调用-(id)forwardingTargetForSelector:(SEL)aSelector方法，我们可以在这里，返回一个响应aSelector的对象。当返回不为nil时候，系统会继续再次走消息转发，继续查找对应的IMP
第二步，如果第一步返回nil或者self(自己),此时系统会继续走这里-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector,需要返回aSelector的一个签名
第三步，如果返回了签名，就会到这里-(void)forwardInvocation:(NSInvocation *)anInvocation,相应的我们可以根据anInvocation,可以获取到参数、target、方法名等，再次操作的空间就很多了，看你需求喽。此时我们什么都不操作也是没问题的，
注意：当我们是类方法的时候，其实我们可以将以上方法的-改为+，即可实现了类方法的转发
2.weak表是如何存储__weak指针的
weak关键字，我们都知道，当对象销毁的时候，也会将指针赋值为nil，而weak的底层也是将指针和对象以键值对的形式存储在哈希表里面
当使用__weak修饰的时候，底层会调用id objc_storeWeak(id *location, id newObj)传递两个参数
第一个参数为指针,第二个参数为所指向的对象
第二步，继续调用storeWeak(location, (objc_object *)newObj)
1. 第一个参数是指针，第二个参数是对象的地址
2. 再次方法里面会根据对象地址生成一个SideTables对象
第三步，调用id weak_register_no_lock(weak_table_t *weak_table, id referent_id, id *referrer_id, bool crashIfDeallocating)
1. weak_table则为SideTables的一个属性，referent_id为对象，referrer_id则为那个弱引用的指针
2. 在此里面会根据对象地址和指针生成一个weak_entry_t
第四步，会继续调用static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
重点：在此方法里面会根据对象 & weak_table->mask(表示weak表里面可以存储的大小减一，例如：表可以存储10个对象，那么mask就是9), 生成对应的index，如果index对应已经存储上对象，则会index++的方式找到未存储的对应，并将new_entry存储进去，储存在weak_table里的weak_entries属 性里面
注意：当一个对象多个weak指针指向的时候，生成的也是一个entry，多个指针时保存在entry里面referrers属性里面
以下为简易的源码：
id
objc_storeWeak(id *location, id newObj)
{
return storeWeak
(location, (objc_object *)newObj);
}
static id
storeWeak(id *location, objc_object *newObj) {
// 根据对象生成新的SideTable
SideTable *newTable = &SideTables()[newObj];
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location, crashIfDeallocating);
}
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, bool crashIfDeallocating){
objc_object *referent = (objc_object *)referent_id;
objc_object **referrer = (objc_object **)referrer_id;
// 根据对象和指针生成一个entry
weak_entry_t new_entry(referent, referrer);
// 检查是是否该去扩容
weak_grow_maybe(weak_table);
// 将新的entry 插入到表里面
weak_entry_insert(weak_table, &new_entry);
}
static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
{
weak_entry_t *weak_entries = weak_table->weak_entries;
size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
size_t index = begin;
size_t hash_displacement = 0;
while (weak_entries[index].referent != nil) {
index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_entries);
hash_displacement++;
}
weak_entries[index] = *new_entry;
weak_table->num_entries++;
}weak_table的扩容，根据存储条数 >= 最大存储条数的3/4时，就会按照两倍的方式进行扩容，并且会将已经有的条目再次生成新的index(因为扩容后，weak_table的mask发生了改变)。进行保存
以下为简易的源码：
static void weak_grow_maybe(weak_table_t *weak_table)
{
size_t old_size = (weak_table->mask ? weak_table->mask + 1 : 0);
if (weak_table->num_entries >= old_size * 3 / 4) {
weak_resize(weak_table, old_size ? old_size*2 : 64);
}
}
static void weak_resize(weak_table_t *weak_table, size_t new_size)
{
size_t old_size = TABLE_SIZE(weak_table);
weak_entry_t *old_entries = weak_table->weak_entries;
// calloc 分配新的控件
weak_entry_t *new_entries = (weak_entry_t *)
calloc(new_size, sizeof(weak_entry_t));
// mask 就是大小减一
weak_table->mask = new_size - 1;
weak_entry_t *entry;
weak_entry_t *end = old_entries + old_size;
for (entry = old_entries; entry < end; entry++) {
if (entry->referent) {
weak_entry_insert(weak_table, entry);
}
}
}3. 方法catch表是如何存储方法的
我们都是知道调用方法的时候，会根据对象的isa查找到对象类对象，并开始在catch表里面查询对应的IMP
其实catch是个散列表,是根据方法的@selector(方法名) & catch->mask(catck表最大数量 - 1)得到index，如果index已经存储了新的方法，那么就会index++，如果index对应的值为nil时，将响应的方法，插入到catch表里面
核心代码
static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver) {
// 获取类对象的catch地址
cache_t *cache = &cls->cache
// 获取key
cache_key_t key = (cache_key_t)sel;
// 找到bucket
bucket_t *bucket = cache->find(key, receiver);
}
bucket_t * cache_t::find(cache_key_t k, id receiver)
{
// catch表的buckets属性
bucket_t *b = buckets();
// catch 表示的mask 最大值 - 1
mask_t m = mask();
mask_t begin = cache_hash(k, m);
mask_t i = begin;
do {
if (b[i].key() == 0 || b[i].key() == k) {
return &b[i];
}
} while ((i = cache_next(i, m)) != begin);
}
static inline mask_t cache_next(mask_t i, mask_t mask) {
return (i+1) & mask;
}注意：catch表的扩容，同样也是和weak_table一样按照2倍的方式进行扩容，但是注意：扩容后，以前缓存的方法则会被删除掉。
简易代码
void cache_t::expand() {
uint32_t oldCapacity = capacity();
uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;
reallocate(oldCapacity, newCapacity);
}
void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity)
{
// 获取旧的oldBuckets
bucket_t *oldBuckets = buckets();
// 重新分配新的
bucket_t *newBuckets = allocateBuckets(newCapacity);
// free 掉旧的
cache_collect_free(oldBuckets, oldCapacity);
}4. 优化后isa指针是什么样的？存储都有哪些内容？
最新的Objective-C的对象里面的isa指针已经不是单单的指向所属类的地址了的指针了，而时变成了一个共用体,并且使用位域来存储更多的信息
5. App启动流程，以及如何优化？
启动顺序
1. dyld，Apple的动态连接器，可以用来装载Mach-O文件(可执行文件、动态库)
1.1、装载App的可执行文件，同事递归加载所有依赖的动态库
1.2 、当dyld把可执行文件、动态库装载完毕后，会通知Runtime进行下一步的处理
Runtime
1. 调用map_images进行可执行文件内容的解析和处理
2. 在load_images里面调用call_load_methods,调用所有class和category的+load方法
3. 进行各种objc结构的初始化(注册Objc类，初始化类对象等等)
4. 到目前未知，可执行文件和动态库中所有的符号(Class,Protocol,Selector,IMP..)都已经按照格式成功加载到内存中，被runtime管理
main函数调用
1. 所有初始化工作结束后，dyld就会调用main函数
2. 截下来就是UIApplicationMan函数，AppDelegate的application:didFinishLaunchingWithOptions:的
- App启动速度优化
1. dyld
1.1、减少动态库，合并一些自定义的动态库，以及定期清理一些不需要的动态库
1.2、较少Objc类、category的数量、以及定期清理一些不必要的类和分类
1.3、Swift尽量使用struct
2. Runtime
2.1、使用+initialize和dispatch_once取代Objc的+load方法、C++的静态构造器
3. main
3.1、再不印象用户体验的情况下面，尽可能的将一些操作延迟，不要全部放到finishLaunching
3.2、一些网络请求
3.3、一些第三方的注册
3.4、以及window的rootViewController 的viewDidload方法，也别做耗时操作
4. 注意：我们可以添加环境变量可以打印出App的启动时间分析(Edit scheme -> Run -> Arguments)
4.1、DYLD_PRINT_STATISTICS设置为1，可以打印出来每个阶段的时间
4.2、如果需要更详细的信息，那就设置DYLD_PRINT_STATISTICS_DETAILS为1
6. App瘦身
资源(图片、音频、视频等)
1. 可以采取无损压缩
2. 使用LSUnusedResources去除没有用的资源 LSUnusedResources
可执行文件瘦身
1. Strip Linked Product、Make Strings Read-Only、Symbols Hidden by Default设置为true
2. 去掉一些异常支持 Enable C++ Exceptions、Enable Objective-C Exceptions设置为false
3. 使用AppCode检测未使用的代码：菜单栏 -> Code -> Inspect Code，等编译完成后，会看到未使用的类
生成LinkMap文件，可以查看可执行文件的具体组成
1. 可借助第三方工具解析LinkMap文件LinkMap
Link Map解析结果
iOS面试题（三）
1. ARC帮我们做了什么？
使用LLVM + Runtime 结合帮我管理对象的生命周期
LLVM 帮我们在代码合适的地方添加release、retarn、autorelease等添加计数器或者减少计数器操作
Runtime 帮我们像__weak、copy等关键字的操作
2.initialize和load是如何调用的？它们会多次调用吗？
load方法说在应用加载的时候，Runtime直接拿到load的IMP直接去调用的，而不是像其他方式根据objc_msgSend(消息机制)来调用方法的
load方法调用的顺序是根据类的加载的前后进行调用的，但是每个类调用的顺序是superclass->class->category顺序调用的，每个load方法只会调用一次(手动调用不算)
一下为Runtime源码的主要代码：
load_images(const char *path __unused, const struct mach_header *mh) {
// 准备class 和category
prepare_load_methods((const headerType *)mh);
// 调用load方法
call_load_methods();
}
void prepare_load_methods(const headerType *mhdr) {
classref_t *classlist =
_getObjc2NonlazyClassList(mhdr, &count);
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
for (i = 0; i < count; i++) {
category_t *cat = categorylist[i];
add_category_to_loadable_list(cat);
}
}
static void schedule_class_load(Class cls) {
// 开始递归，加载superclass
schedule_class_load(cls->superclass);
add_class_to_loadable_list(cls);
}
void call_load_methods(void) {
do {
while (loadable_classes_used > 0) {
call_class_loads();
}
more_categories = call_category_loads();
} while (loadable_classes_used > 0 || more_categories);
}
static void call_class_loads(void) {
// 在此add_class_to_loadable_list 里面准备了所有重写load的方法的类
struct loadable_class *classes = loadable_classes;
// Call all +loads for the detached list.
for ( int i = 0; i < used; i++) {
Class cls = classes[i].cls;
// 获取到load 方法的imp
load_method_t load_method = (load_method_t)classes[i].method;
// 调用laod 方法
(*load_method)(cls, SEL_load);
}
}
static bool call_category_loads(void) {
// 在prepare_load_methods 方法里面准备了所有重新load方法的category
struct loadable_category *cats = loadable_categories;
for (int i = 0; i < used; i++) {
// 获取到catgegory
Category cat = cats[i].cat;
// 获取category 的load 方法的IMP实现
load_method_t load_method = (load_method_t)cats[i].method;
cls = _category_getClass(cat);
if (cls && cls->isLoadable()) {
// 调用load方法
(*load_method)(cls, SEL_load);
}
}
}initialize方法的调用其实和其他方法调用一样的，objc_msgSend(消息机制)来调用的。调用的数序是：没有初始话的superclass -> 实现initialize的categort 或者 实现了initialize的class，如果class没有实现initialize 方法，则会调用superclass的initialize,因为initialize的底层是使用了objc_msgSend
看下Runtime底层调用_class_initialize的源码
void _class_initialize(Class cls) {
supercls = cls->superclass;
if (supercls && !supercls->isInitialized()) {
// 又是个递归
_class_initialize(supercls);
}
// 调用 initialize方法
callInitialize(cls);
}
// objc_msgSend 调用 initialize 方法
void callInitialize(Class cls) {
// **注意：因为使用了objc_msgSend,有可能调用class的 initialize **
objc_msgSend(cls, SEL_initialize);
}总结:
load方法一个类只会调用一次(除去手动调用)，而调用的数序是，从superclass -> class -> category,category里面的顺序是先编译，先调用
initialize方法，一个类可能会调用多次，如果子类没有实现initialize方法，当第一次使用此类的时候，会调用superclass。而调用的顺序是，superclass -> 实现initialize的category 或者 实现了initialize方法(没有category实现initialize) 或者 superclass的initialize (没有子类和category实现initialize方法)
3.说下autoreleasepool
在MRC下，当对象调用autorerelease方法时候，会将对象加入到对象前面的哪一个autoreleasepool里面,并且当autoreleasepool作用域释放的时候，会对里面的所有的对象进行一次release操作。
autoreleasepool底层是使用了AutoreleasePoolPage对象来管理的，AutoreleasePoolPage是一个双向的链表,每个AutoreleasePoolPage都有4096个字节，除了用来存放内部的成员变量，剩下的控件都会用来存放autorelease对象的地址
/// AutoreleasePoolPage 的简化的结构
class AutoreleasePoolPage {
magic_t const magic;
// 下一次可以存储对象的地址
id *next;
pthread_t const thread;
// 标识上一个page对象
AutoreleasePoolPage * const parent;
// 标识下一个page对昂
AutoreleasePoolPage *child;
uint32_t const depth;
uint32_t hiwat;
}当autoreleasepool开始的时候，会调用AutorelasePoolPage的push方法，会讲一个标识POOL_BOUNDARY添加到AutoreleasePoolPage对象里面，并且返回POOL_BOUNDARY的地址r1(暂且这样叫)
当对像进行relase的时候，会将对象的地址添加到当前AutorelasePoolPage里面，依次添加。
当autoreleasepool作用域结束的时候，会调用AutorelasePoolPage的pop(r1)方法(r1为当前aotoreleasepool开始的加入标识POOL_BOUNDARY的地址)，AutorelasePoolPage则会将里面保存的对象的从左后一个开始进行release操作，当碰到r1时候，标识当前那个autoreleasepool里面所有的对象都进行了一次release操作。
@autoreleasepool {
// 此处会调用
void *ctxt = AutoreleasePoolPage::push();
// 添加到最近的一个autoreleasepool中
[[[NSObject alloc]init] autorelease];
//移除作用域的时候调用
AutoreleasePoolPage:pop(ctxt)
}
// autoreleasepool 作用域开始会调用AutoreleasePoolPage::push()
static inline void *push() {
id *dest;
if (DebugPoolAllocation) {
// 创建一个心的page对象
dest = autoreleaseNewPage(POOL_BOUNDARY);
} else {
// 已经有了page对象，讲`pool_boundary`添加进去
dest = autoreleaseFast(POOL_BOUNDARY);
}
}
static inline id *autoreleaseFast(id obj)
{
// 获取正在使用的page对昂
AutoreleasePoolPage *page = hotPage();
// page还没有装满
if (page && !page->full()) {
return page->add(obj);
} else if (page) {
// 已经添加满了
return autoreleaseFullPage(obj, page);
} else {
// 没有page对象，创建心的page对象
return autoreleaseNoPage(obj);
}
}
// 对象调用release 的简介源码
id objc_object::rootAutorelease2() {
return AutoreleasePoolPage::autorelease((id)this);
}
static inline id autorelease(id obj) {
// 同样也是添加进去
id *dest = autoreleaseFast(obj);
return obj;
}
// page调用pop简介源码 *token 表示结束的标识
static inline void pop(void *token) {
AutoreleasePoolPage *page;
id *stop;
page = pageForPointer(token);
stop = (id *)token;
page->releaseUntil(stop);
}
// 释放对象的源码
void releaseUntil(id *stop) {
// next 标识当前page可以存储对象的下一个地址
while (this->next != stop) {
AutoreleasePoolPage *page = hotPage();
// 因为page是个双向链表，当page为空的时候，需要往上查找parent的page对象里面存储的睇相
while (page->empty()) {
page = page->parent;
setHotPage(page);
}
id obj = *--page->next;
if (obj != POOL_BOUNDARY) {// obj 不是刚开始传入的POOL_BOUNDARY及表示对象，所以需要调用一次操作
objc_release(obj);
}
}
}
autoreleasepool和runloop的关系
runloop里面会注册两个Observer来监听runloop的状态变化
其中一个Observer监听的状态为kCFRunLoopEntry进入runloop的状态，则会调用AutoreleasePoolPage::push()方法
另外中一个Observer监听的状态为kCFRunLoopBeforeWaiting、kCFRunLoopExit,即将休眠和退出当前的runloop。
在kCFRunLoopBeforeWaiting的回掉里面会调用AutoreleasePoolPage::pop(ctxt)和AutoreleasePoolPage::(push)方法，释放上一个autoreleasepool里面添加的对象，并开启下一个autoreleasepool。
在kCFRunLoopExit的Observer回掉里面会调用AutoreleasePoolPage::(push)释放autoreleasepool里面的对象
4.category属性是存储在那里？
我们都知道可以使用Runtime的objc_setAssociatedObject、objc_getAssociatedObject两个方法给category的属性重写get、set方法，而此属性的值是存储在那里呢？
其实此属性的值保存在一个AssociationsManager里面。
我们也是可以根据源码看一下
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// 一下为精简的代码
id new_value = value ? acquireValue(value, policy) : nil;
{
AssociationsManager manager;
AssociationsHashMap &associations(manager.associations());
disguised_ptr_t disguised_object = DISGUISE(object);
if (new_value) {
ObjectAssociationMap *refs = new ObjectAssociationMap;
associations[disguised_object] = refs;
(*refs)[key] = ObjcAssociation(policy, new_value);
}
}
}
5.category方法是如何添加的？
当我们给分类添加相同的方法的时候，会调用category里面的方法，而不是调用我们class里面的方法
当编译器编译的时候，编译器会将category编译成category_t这样的结构体，等类初始化的时候，会将分类的信息同步到class_rw_t里面,包含：method、property、protocol等，同步的时候会将category里面的信息添加到class的前面(而不是替换掉class里面的方法)，而方法调用的时候，而是遍历class_rw_t里面的方法，所以找到分类里面的IMP则返回。
- 使用memmove,将类方法移动到后面
- 使用memcpy,将分类的方法copy到前面
- 当多个分类有相同的方法的时候，调用的顺序是后编译先调用
- 当类初始化同步category的时候，会使用while(i--)的倒序循环，将后编译的category添加到最前面。
react中的组件设计
react的组件设计有很多模式。下面列举几种常见的：
完全受控组件
这种组件设计的特点是，组件的所有state和action都来自props，组件自身没有状态，只负责展示UI层。model层完全交给全局状态管理库比如redux或mobx。不推荐这种组件设计，因为后期不好维护。这是典型的滥用全局状态管理库的现象。
什么叫滥用全局状态管理库？
就是没有认识到状态管理库的作用，或者说我们什么时候需要状态管理库？
拿 react 来说，react 是有组内状态的，状态可以通过 props 传递。但是，但当 app 比较庞大的时候，兄弟组件，远亲组件这些的交流就变得困难起来，
它们必须依赖相同的父组件来完成信息的传递。这时，就是我们使用状态管理库的时候。
但是，很多人把所有状态都往 redux 里面丢，虽然这方便了开发，但缺点却很明显:
- 组件很难复用：因为状态只有一份。
- 耦合度高：根据高内聚低耦合的设计原则，一个模块应该有独立的功能，不依赖外部，在内部实现复杂度，只暴露接口来与外界交流。但如果把组内的一些状态放在全局 model，就提供了让其他组件修改的能力，并且代码没有内聚。
非受控组件
划分好状态的等级，尽量把状态放在组件内。当遇到共享组内状态困难的场景时，提升状态到全局状态管理库。
这种组件，有view层、model层、services层。因为它是有独立功能的，然后通过向外界暴露api来提供自己的能力，同时把复杂度隐藏在内部。
例如一个列表组件：
// 方案一
// ListDemo.jsx
import React,{useEffect} from 'react';
import {getData} from 'services/api';
export default function ListDemo({requestId}){
// model
const [data,setData] = useState([]);
const [visible,setVisible] = useState(false);
useEffect(()=>{
// services 层
getData().then(data=>{
setData(data)
});
/**
* 当requestId变化时，列表会重新请求
* 这里的requestId是组件向外界暴露的一个api
**/
},[requestId])
useEffect(()=>{
if(visible===true){
// clearState
setVisible(false);
}
},[requestId])
return (
// view
<div>
{
data.map(item=><li>{item}</li>
}
{
visible && (
<div>
this is a modal
</div>
)
}
</div>
)
)
}
// app.jsx
<ListDemo />
这种组件设计的特点是，组件可以重置自身状态的时机是由自身控制的。如果你觉得这样麻烦，你可以把重置自身状态的时机交给外部，通过key来 “销毁组件”=>“重新渲染组件”。上面的代码可以简化成：
// 方案二
// ListDemo.jsx
import React,{useEffect} from 'react';
import {getData} from 'services/api';
export default function ListDemo({requestId}){
// model
const [data,setData] = useState([]);
const [visible,setVisible] = useState(false);
useEffect(()=>{
// services 层
getData().then(data=>{
setData(data)
});
},[])
return (
// view
<div>
{
data.map(item=><li>{item}</li>
}
{
visible && (
<div>
this is a modal
</div>
)
}
</div>
)
)
}
// app.jsx
/*
*当requestId变化时，ListDemo会重新渲染
*/
<ListDemo key={requestId} />
方案二的代码比较整洁，且出错率比方案一低，但是方案二存在重新渲染组件的一个环节，性能开支会比方案一多一点点（大部分情况你都可以忽略不计）。
很多情况下，我们应该采用方案二。
原文：https://zhuanlan.zhihu.com/p/88593781
收起阅读 »
如何用webpack优化moment.js的体积
本篇为转译，原出处。
当你在代码中写了var moment = require('moment') 然后再用webpack打包, 打出来的包会比你想象中的大很多，因为打包结果包含了各地的local文件.
解决方案是下面的两个webpack插件，任选其一:
IgnorePluginContextReplacementPlugin
方案一：使用 IgnorePlugin插件
IgnorePlugin的原理是会移除moment的所有本地文件，因为我们很多时候在开发中根本不会使用到。 这个插件的使用方式如下：
const webpack = require('webpack');
module.exports = {
//...
plugins: [
// 忽略 moment.js的所有本地文件
new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/),
],
};那么你可能会有疑问，所有本地文件都被移除了，但我想要用其中的一个怎么办。不用担心，你依然可以在代码中这样使用：
const moment = require('moment');
require('moment/locale/ja');
moment.locale('ja');
...这个方案被用在 create-react-app.
方案二：使用 ContextReplacementPlugin
这个方案其实跟方案一有点像。原理是我们告诉webpack我们会使用到哪个本地文件，具体做法是在插件项中这样添加ContextReplacementPlugin：
const webpack = require('webpack');
module.exports = {
//...
plugins: [
// 只加载 `moment/locale/ja.js` 和 `moment/locale/it.js`
new webpack.ContextReplacementPlugin(/moment[/\\]locale$/, /ja|it/),
],
};值得注意的是，这样你就不需要在代码中再次引入本地文件了：
const moment = require('moment');
// 不需要
moment.locale('ja');
...体积对比
对比条件：
- webpack: v3.10.0
- moment.js: v2.20.1
具体表现：
可见，处理后的体积小了很多。
原文链接：https://zhuanlan.zhihu.com/p/90748774
git 撤销对文件的追踪
撤销暂存区(index)区的track
当我们新增加文件时，使用git status会打印出：
Untracked files:
(use "git add ..." to include in what will be committed)
hello.txt
nothing added to commit but untracked files present (use "git add" to track) 可见，git add 命令可以用来追踪文件。
当我们使用 git add hello.txt后，再使用git status后，会打印出：
Changes to be committed:
(use "git restore --staged ..." to unstage)
new file: hello.txt 可见，文件已经被追踪了，只是还没提交到本地仓库。此时可以使用git restore来撤销这个追踪。
> git restore hello.txt --staged
> git status
On branch master
Your branch is up to date with 'origin/master'.
Untracked files:
(use "git add ..." to include in what will be committed)
hello.txt 撤销“已经提交到本地仓库的文件”的追踪
当一个文件（例如hello.txt）已经提交到本地仓库时。后续你再往.gitignore添加它，也不会起作用。怎么解除这种追踪呢？最常见的做法是直接删除这个文件，流程是：本地删除，提交删除这个commit到仓库。
但这样本地的也会被删除。有时我们只是想删除仓库的副本，可以使用git rm --cached。git rm经常被用来删除工作区和暂存区的文件。它可以携带一个cache参数，作用如下（摘自文档）：
git rm --cached
Use this option to unstage and remove paths only from the index. Working tree files, whether modified or not, will be left alone.
使用这个项来解除暂存区的缓存，工作区的文件将保持不动。意思就是不会在实际上删掉这个文件，只是解除它的追踪关系。
举例：
> git rm --cached hello.txt
// rm 'hello.txt'
> git status
On branch master
Your branch is up to date with 'origin/master'.
Changes to be committed:
(use "git restore --staged ..." to unstage)
deleted: hello.txt
工作区的hello.txt还在，但已经没有被git追踪了。之后，只要我们把hello.txt添加到.gitignore后，修改hello.txt并不会产生改动。
接下来我们提交下这个改动。
git commit -m 'delete hello.txt'
[master d7a2e3e] delete hello.txt
1 files changed, 17 deletions(-)
delete mode 100644 hello.txt使用rm这个命令时，我们经常会用到-r这个命令。-r是递归的意思，表示删除整个文件夹，包括它的子文件夹。
原文：https://zhuanlan.zhihu.com/p/139950341
web前端常见的三种manifest文件
manifest.json
manifest.json经常被用在PWA，用来 告知浏览器 关于PWA应用的一些信息如应用图标、启动应用的画面。举例：
{
"short_name": "React App",
"name": "Create React App Sample",
"icons": [
{
"src": "favicon.ico",
"sizes": "64x64 32x32 24x24 16x16",
"type": "image/x-icon"
},
{
"src": "logo192.png",
"type": "image/png",
"sizes": "192x192"
},
{
"src": "logo512.png",
"type": "image/png",
"sizes": "512x512"
}
],
"start_url": ".",
"display": "standalone",
"theme_color": "#000000",
"background_color": "#ffffff"
}assets-manifest.json
assets-manifest.json经常会在create-react-app这个脚手架的打包文件上看到，由webpack-manifest-plugin这个webpack插件产生。举例：
{
"files": {
"main.css": "/static/css/main.491bee12.chunk.css",
"main.js": "/static/js/main.14bfbead.chunk.js",
"main.js.map": "/static/js/main.14bfbead.chunk.js.map",
"runtime-main.js": "/static/js/runtime-main.e89362ac.js",
"runtime-main.js.map": "/static/js/runtime-main.e89362ac.js.map",
"static/js/2.017bb613.chunk.js": "/static/js/2.017bb613.chunk.js",
"static/js/2.017bb613.chunk.js.map": "/static/js/2.017bb613.chunk.js.map",
"index.html": "/index.html",
"precache-manifest.33b41575e0c64a21bca1a6091e8a5c6d.js": "/precache-manifest.33b41575e0c64a21bca1a6091e8a5c6d.js",
"service-worker.js": "/service-worker.js",
"static/css/main.491bee12.chunk.css.map": "/static/css/main.491bee12.chunk.css.map",
"static/media/logo.svg": "/static/media/logo.25bf045c.svg"
},
"entrypoints": [
"static/js/runtime-main.e89362ac.js",
"static/js/2.017bb613.chunk.js",
"static/css/main.491bee12.chunk.css",
"static/js/main.14bfbead.chunk.js"
]
}wepack-mainfest-plugin对它自身的介绍是：
This will generate amanifest.jsonfile in your root output directory with a mapping of all source file names to their corresponding output file。意思就是assets-manifest.json其实只是源文件和加哈希后文件的一个对比表，仅此而已。它不会对应用的运行产生任何影响，浏览器也不会去请求它。
precache-manifest.js
这个文件由workbox-webpack-plugin插件生成， 用来告诉workbox哪些静态文件可以缓存。例如：
/**
* The workboxSW.precacheAndRoute() method efficiently caches and responds to
* requests for URLs in the manifest.
* See https://goo.gl/S9QRab
*/
self.__precacheManifest = [].concat(self.__precacheManifest || []);
workbox.precaching.precacheAndRoute(self.__precacheManifest, {});
其中self.__precacheManifest的值就是precache-manifest.js的内容。
原文链接：https://zhuanlan.zhihu.com/p/90829472
收起阅读 »
iOS-一些常用第三方资源
一：第三方插件
1:基于响应式编程思想的oc
地址：https://github.com/ReactiveCocoa/ReactiveCocoa
2：hud提示框
地址：https://github.com/jdg/MBProgressHUD
3：XML/HTML解析
地址：https://github.com/topfunky/hpple
4：有文字输入时，能根据键盘是否弹出来调整自身显示内容的位置
地址：https://github.com/michaeltyson/TPKeyboardAvoiding
5：状态栏提示框
地址：https://github.com/jaydee3/JDStatusBarNotification
6：block工具包。将很多需要用delegate实现的方法整合成了block的形式
地址：https://github.com/zwaldowski/BlocksKit
7：图片加载
地址：https://github.com/rs/SDWebImage
8：正则表达式
地址：https://github.com/wezm/RegexKitLite
9：Masonry代码布局
地址：https://github.com/SnapKit/Masonry
10：弹出窗
地址：https://github.com/sberrevoets/SDCAlertView
11:Button的样式
地址：https://github.com/mattlawer/BButton
12：验证网络连接状态
地址：https://github.com/tonymillion/Reachability
13：自动计算表格行高
地址：https://github.com/forkingdog/UITableView-FDTemplateLayoutCell
14：动画效果的启动页
地址：https://github.com/IFTTT/JazzHands
15：iOS快速简单集成国内三大平台分享
地址：https://github.com/xumeng/XMShareModule
16：五项能力值展示的五边形
地址：https://github.com/dsxNiubility/SXFiveScoreShow
17：自动识别网址号码邮箱和表情的label
地址：https://github.com/molon/MLEmojiLabel
18：IM对话功能的封装
地址：https://github.com/ZhipingYang/UUChatTableView
19：字典转模型框架
地址：https://github.com/CoderMJLee/MJExtension
20：下拉上拉刷数据
地址：https://github.com/CoderMJLee/MJRefresh
21：表格行左右划动菜单
地址：https://github.com/MortimerGoro/MGSwipeTableCell
22:图文混搭
地址:https://github.com/zhouande/TLAttributedLabel
23:可以简单展示在UINavigationBar下方，类似Music app的播放列表视图，弹出菜单视图
地址：https://github.com/DrummerB/BFNavigationBarDrawer
24：比如筛选、模糊、优化、蒙版、调整大小、旋转以及保存等等。同时还提供了一个UIImageView子类从URL异步加载图片，并在下载完毕时展示图片。
地址：https://github.com/Nyx0uf/NYXImagesKit
25：底部TabBar
地址：https://github.com/robbdimitrov/RDVTabBarController
26:表情面版
地址：https://github.com/ayushgoel/AGEmojiKeyboard
27:记录框架
地址：https://github.com/CocoaLumberjack/CocoaLumberjack
28：IOS与javascript交互
地址：https://github.com/marcuswestin/WebViewJavascriptBridge
29：图表统计展示
地址：https://github.com/kevinzhow/PNChart
30:appStore评分
地址：https://github.com/arashpayan/appirater
31：iOS-Categories 扩展类大全
地址：https://github.com/shaojiankui/IOS-Categories
32：扫描二维码，仿微信效果，带有扫描条
地址：https://github.com/JxbSir/JxbScanQR
33:动效弹出视图(弹出窗里面为文字，可以定义弹出的方向，及显示的时间)--AMPopTip
地址：https://github.com/andreamazz/AMPopTip
34:基于Masonry自动计算行高扩展
地址：https://github.com/632840804/HYBMasonryAutoCellHeight
35:模仿新浪微博弹出菜单
地址：https://github.com/wwdc14/HyPopMenuView
36:搜索历史标签
地址：https://github.com/zhiwupei/SearchHistory
37：快速集成新手引导的类库
地址：https://github.com/StrongX/XSportLight
38：设置页面的封装
地址：https://github.com/renzifeng/ZFSetting
39：带箭头的弹出视图插件
地址：https://github.com/xiekw2010/DXPopover
40：下拉菜单插件
地址：https://github.com/dopcn/DOPDropDownMenu/
41：表格空白提示插件
地址：https://github.com/dzenbot/DZNEmptyDataSet
42:给任意UIView视图四条边框加上阴影，可以自定义阴影的颜色、粗细程度、透明程度以及位置（上下左右边框）
地址：https://github.com/Seitk/UIView-Shadow-Maker
43:不错的日期时间插件
地址：https://github.com/CoderXL/UUDatePicker
44:底部弹出选择
地址：https://github.com/skywinder/ActionSheetPicker-3.0
45:比较不错的引导页面插件
地址：https://github.com/ealeksandrov/EAIntroView
46:两个APP跳转的插件
地址：https://github.com/usebutton/DeepLinkKit
47:本地存取NSUserDefaults插件
地址：https://github.com/gangverk/GVUserDefaults
48:NSArray 和 NSDictionary关于LINQ的操作方式，封装一些常用的操作
地址：https://github.com/ColinEberhardt/LinqToObjectiveC
49:可以监控网络请求的内容
地址：https://github.com/coderyi/NetworkEye
50：时间帮助插件，可以快速获取时间，比较，增加等操作
地址：https://github.com/MatthewYork/DateTools
51: 不错的链式动作
地址：https://github.com/jhurray/JHChainableAnimations
52:弹出层视图，背景效果（可以自定义视图的内容）
地址：https://github.com/HJaycee/JCAlertView
53:圆形进度条的显示，中间可显示值
地址：https://github.com/mdinacci/MDRadialProgress
54:很帅的数据加载动画（可以用于数据列表加载的展现）
地址：https://github.com/NghiaTranUIT/FeSpinner
55:一个开源的AFnetworking上层的封装（猿题库等运用）
地址：https://github.com/yuantiku/YTKNetwork
56:CBStoreHouseRefreshControl：一个效果很酷炫的下拉刷新控件
地址：https://github.com/coolbeet/CBStoreHouseRefreshControl
57:AFNetworking-RACExtensions:针对ReactiveCocoa的AF封装
地址：https://github.com/CodaFi/AFNetworking-RACExtensions
58:模糊效果（毛玻璃）
地址：https://github.com/nicklockwood/FXBlurView
二：源代码实例
1:Coding.net客户端
地址：https://coding.net/u/coding/p/Coding-iOS/git
2:高仿美团iOS版
地址：https://github.com/lookingstars/meituan
3:模仿网易新闻做的精仿网易新闻
地址：https://github.com/dsxNiubility/SXNews
4:支付宝高仿版
地址：https://github.com/gsdios/GSD_ZHIFUBAO
5:高仿百度传课iOS版
地址：https://github.com/lookingstars/chuanke
6：模仿一元云购
地址：https://github.com/JxbSir/YiYuanYunGou
7：wordpress源代码
地址：https://github.com/wordpress-mobile/WordPress-iOS
8：v2ex源代码（文章类型，若报SVProgressHUD错，则把Podfile中的SVProgressHUD移除）
地址：https://github.com/singro/v2ex
9:PHPHub客户端(IOS8.0以上)
地址：https://github.com/Aufree/phphub-ios
10:快速搭建项目源代码
地址：https://github.com/wujunyang/MobileProject
三：辅助软件
1：XCODE文档注解插件VVDocumenter
地址：https://github.com/onevcat/VVDocumenter-Xcode
2：将JSON格式化输出为模型的属性
地址：https://github.com/EnjoySR/ESJsonFormat-Xcode
3：图片提示插件
地址：https://github.com/ksuther/KSImageNamed-Xcode
4：图片转换插件
地址：https://github.com/rickytan/RTImageAssets
ios-本地存储的五种方式
ios数据存储的5种方式
- NSUserDefaults（Preference偏好设置）
- plist存储
- 归档
- SQLite3
- CoreData
应用沙盒
Document:适合存储重要的数据， iTunes同步应用时会同步该文件下的内容,（比如游戏中的存档）Library/Caches：适合存储体积大，不需要备份的非重要数据，iTunes不会同步该文件Library/Preferences:通常保存应用的设置信息, iTunes会同步tmp:保存应用的临时文件，用完就删除，系统可能在应用没在运行时删除该目录下的文件，iTunes不会同步
获取沙盒路径
Document:
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject;NSuserDefault
- 不需要关心文件名
- 快速进行键值对存储
- 直接存储基本数据类型
- (IBAction)userDefaultSave:(id)sender {
NSArray *testArray = @[@"test1", @"test2", @"test3"];
[[NSUserDefaults standardUserDefaults] setObject:testArray forKey:@"arrayKey"];
[[NSUserDefaults standardUserDefaults] synchronize];
}- (IBAction)userDefaultLoad:(id)sender {
NSArray *testArray = [[NSUserDefaults standardUserDefaults] objectForKey:@"arrayKey"];
NSLog(@"%@", testArray);
}plist存储
plist支持的数据类型：
NSArray;
NSMutableArray;
NSDictionary;
NSMutableDictionary;
NSData;
NSMutableData;
NSString;
NSMutableString;
NSNumber;
NSDate;
不支持BOOL
而且最外层好像要用`NSArray 或 NSDictionary，偷个懒还没验证- (IBAction)plistSave:(id)sender {
NSString *cachePath = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
NSString *filePath = [cachePath stringByAppendingPathComponent:@"testPlist.plist"];
NSMutableDictionary *dict = [NSMutableDictionary dictionary];
[dict setObject:@"ran" forKey:@"name"];
[dict setObject:@"18" forKey:@"age"];
[dict writeToFile:filePath atomically:YES];
}
- (IBAction)plistLoad:(id)sender {
NSString *cachePath = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
NSString *filePath = [cachePath stringByAppendingPathComponent:@"testPlist.plist"];
NSDictionary *t = [NSDictionary dictionaryWithContentsOfFile:filePath];
NSLog(@"%@",t);
}归档
存储自定义对象
- 首先新建Person类，并遵守
NSCoding协议
@interface Person : NSObject<NSCoding>
@property(nonatomic, strong)NSString *name;
@property(nonatomic, strong)NSString *age;
@end实现协议方法：
@implementation Person
- (instancetype)initWithCoder:(NSCoder *)coder
{
self = [super init];
if (self) {
_name = [coder decodeObjectForKey:@"name"];
_age = [coder decodeObjectForKey:@"age"];
}
return self;
}
- (void)encodeWithCoder:(NSCoder *)coder
{
[coder encodeObject:self.name forKey:@"name"];
[coder encodeObject:self.age forKey:@"age"];
}
@end归档解档
- (IBAction)archive:(id)sender {
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject;
NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
Person *p1 = [[Person alloc] init];
p1.name = @"ran";
p1.age = @"18";
[NSKeyedArchiver archiveRootObject:p1 toFile:filePath];
}
- (IBAction)unarchive:(id)sender {
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject ;
NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
Person *p1 = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath] ;
NSLog(@"%@", p1.name);
NSLog(@"%@", p1.age);
}但是这种方法只能存储一个对象，存储多个对象要采用如下的方法：
- (IBAction)archiveManyObject:(id)sender {
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject ;
NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
NSMutableData *data = [[NSMutableData alloc] init];
NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data]; //将数据区连接到NSKeyedArchiver对象
Person *p1 = [[Person alloc] init];
p1.name = @"ran1";
p1.age = @"18";
[archiver encodeObject:p1 forKey:@"person1"];
Person *p2 = [[Person alloc] init];
p2.name = @"ran2";
p2.age = @"19";
[archiver encodeObject:p2 forKey:@"person2"];
[archiver finishEncoding];
[data writeToFile:filePath atomically:YES];
}
- (IBAction)unarchiveManyObject:(id)sender {
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject ;
NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
NSData *data = [NSData dataWithContentsOfFile:filePath];
NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
Person *p1 = [unarchiver decodeObjectForKey:@"person1"];
Person *p2 = [unarchiver decodeObjectForKey:@"person2"];
[unarchiver finishDecoding];
NSLog(@"%@", p1.name);
NSLog(@"%@", p2.name);
}SQLite3
- 该方案可以存储大量的数据,存储和检索的速度非常快.
- 能对数据进行大量的聚合,这样比起使用对象来讲操作要快.
- 它没有提供数据库的创建方式
- 它的底层是基于C语言框架设计的, 没有面向对象的API, 用起来非常麻烦
- 发杂的数据模型的数据建表,非常麻烦
在实际开发中我们都是使用的是FMDB第三方开源的数据库,该数据库是基于splite封装的面向对象的框架.
#import "SqliteVC.h"
#import "Person.h"
@interface SqliteVC() {
sqlite3 *_db;
}
@end
@implementation SqliteVC
- (void)viewDidLoad {
[super viewDidLoad];
NSString *fileName = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] stringByAppendingPathComponent:@"student.sqlite"];
NSLog(@"fileName = %@",fileName);
int result = sqlite3_open(fileName.UTF8String, &_db); //创建(打开)数据库,如果数据库不存在，会自动创建 数据库文件的路径必须以C字符串(而非NSString)传入
if (result == SQLITE_OK) {
NSLog(@"成功打开数据库");
char *errorMesg = NULL;
const char *sql = "create table if not exists t_person (id integer primary key autoincrement, name text, age integer);";
int result = sqlite3_exec(_db, sql, NULL, NULL, &errorMesg); //sqlite3_exec()可以执行任何SQL语句，比如创表、更新、插入和删除操作。但是一般不用它执行查询语句，因为它不会返回查询到的数据
if (result == SQLITE_OK) {
NSLog(@"成功创建t_person表");
} else {
NSLog(@"创建t_person表失败:%s",errorMesg);
}
} else {
NSLog(@"打开数据库失败");
}
}
- (IBAction)insert:(id)sender {
for (int i = 0; i < 30; i++) {
NSString *name = [NSString stringWithFormat:@"person-%d",arc4random()0];
int age = arc4random() % 100;
char *errorMesg = NULL;
NSString *sql = [NSString stringWithFormat:@"insert into t_person (name,age) values ('%@',%d);",name, age];
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
if (result == SQLITE_OK) {
NSLog(@"添加数据成功");
} else {
NSLog(@"添加数据失败");
}
}
}
- (IBAction)delete:(id)sender {
char *errorMesg = NULL;
NSString *sql = @"delete from t_person where age >= 0";
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
if (result == SQLITE_OK) {
NSLog(@"删除成功");
}else {
NSLog(@"删除失败");
}
}
- (IBAction)query:(id)sender {
const char *sql = "select id, name, age from t_person;"; //"select id, name, age from t_person where age >= 50;"
sqlite3_stmt *stmt = NULL; //定义一个stmt存放结果集
int result = sqlite3_prepare_v2(_db, sql, -1, &stmt, NULL); //检测SQL语句的合法性
if (result == SQLITE_OK) {
NSLog(@"查询语句合法");
while (sqlite3_step(stmt) == SQLITE_ROW) {
int ID = sqlite3_column_int(stmt, 0);
const unsigned char *sname = sqlite3_column_text(stmt, 1);
NSString *name = [NSString stringWithUTF8String:(const char *)sname];
int age = sqlite3_column_int(stmt, 2);
NSLog(@"%d %@ %d",ID, name, age);
}
} else {
NSLog(@"查询语句非法");
}
}
- (IBAction)update:(id)sender {
NSString *sql = @"update t_person set name = '哈哈' where age > 60";
char *errorMesg = NULL;
int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
if (result == SQLITE_OK) {
NSLog(@"更改成功");
}else {
NSLog(@"更改失败");
}
}coreData
SQLite
1、基于C接口，需要使用SQL语句，代码繁琐
2、在处理大量数据时，表关系更直观
3、在OC中不是可视化，不易理解
CoreData
1、可视化，且具有undo/redo能力
2、可以实现多种文件格式：
* NSSQLiteStoreType
* NSBinaryStoreType
* NSInMemoryStoreType
* NSXMLStoreTyp
3、苹果官方API支持，与iOS结合更紧密CoreData核心类与结构
NSManagedObjectContext(数据上下文)
- 对象管理上下文，负责数据的实际操作(重要)
- 作用：插入数据，查询数据，删除数据，更新数据
- 相当于数据库的连接器
- 作用：设置数据存储的名字，位置，存储方式，和存储时机
- 数据库所有表格或数据结构，包含各实体的定义信息
- 作用：添加实体的属性，建立属性之间的关系
- 操作方法：视图编辑器，或代码
- 数据库中的表格记录
NSEntityDescription(实体结构)
- 相当于表格结构
NSFetchRequest(数据请求)
- 相当于查询语句
后缀为.xcdatamodeld的包
- 里面是.xcdatamodel文件，用数据模型编辑器编辑
- 编译后为.momd或.mom文件
步骤：
1.创建模型文件 ［相当于一个数据库］
2.添加实体 ［一张表］
3.创建实体类 [相当模型--表结构]
4.生成上下文 关联模型文件生成数据库1.创建模型文件
New File -> iOS -> Core Data ->Data Model
2.创建实体
Codegen
3.创建实体类
创建结果如图所示：
1.生成上下文 关联模型文件生成数据库，进行增删查改操作
#import "coredataVC.h"
#import <CoreData/CoreData.h>
#import "Student+CoreDataProperties.h"
@interface coredataVC ()
@property(nonatomic, strong)NSManagedObjectContext *context;
@end
@implementation coredataVC
- (void)viewDidLoad {
[super viewDidLoad];
//entity 记得勾选 language:objective-c 和 codegen:manual/none
[self createSql];
}
- (void)createSql {
//获取模型路径
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"Person" withExtension:@"momd"];
//根据模型文件创建模型对象
NSManagedObjectModel *model = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
//利用模型对象创建持久化存储助理
NSPersistentStoreCoordinator *store = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:model];
//数据库的名称和路径
NSString *docStr = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
NSString *sqlPath = [docStr stringByAppendingPathComponent:@"coreData.sqlite"];
NSURL *sqlUrl = [NSURL fileURLWithPath:sqlPath];
NSLog(@"数据库 path = %@", sqlPath);
NSError *error = nil; //设置数据库相关信息 添加一个持久化存储库并设置类型和路径，NSSQLiteStoreType：SQLite作为存储库
[store addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:sqlUrl options:nil error:&error];
if (error) {
NSLog(@"添加数据库失败:%@",error);
} else {
NSLog(@"添加数据库成功");
}
//3、创建上下文 保存信息 对数据库进行操作 关联持久化助理
NSManagedObjectContext *context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
context.persistentStoreCoordinator = store;
_context = context;
}增
- (IBAction)insertClick:(id)sender {
Student * student = [NSEntityDescription insertNewObjectForEntityForName:@"Student" inManagedObjectContext:_context];
student.name = [NSString stringWithFormat:@"stu-%d",arc4random()0];
student.age = arc4random()%30;
NSError *error = nil;
if ([_context save:&error]) {
NSLog(@"数据插入到数据库成功");
}else{
NSLog(@"数据插入到数据库失败");
}
}删
- (IBAction)deleteClick:(id)sender {
//创建删除请求
NSFetchRequest *deleRequest = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
//删除条件 没有任何条件就是读取所有的数据
//NSPredicate *pre = [NSPredicate predicateWithFormat:@"age < %d", 10];
//deleRequest.predicate = pre;
//返回需要删除的对象数组
NSArray *deleArray = [_context executeFetchRequest:deleRequest error:nil];
//从数据库中删除
for (Student *stu in deleArray) {
[_context deleteObject:stu];
}
NSError *error = nil;
if ([_context save:&error]) {
NSLog(@"删除数据成功");
}else{
NSLog(@"删除数据失败, %@", error);
}
}查
- (IBAction)queryClick:(id)sender {
//创建查询请求
NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
//查询条件 没有任何条件就是读取所有的数据
NSPredicate *pre = [NSPredicate predicateWithFormat:@"age >= 0"];
request.predicate = pre;
// 从第几页开始显示 通过这个属性实现分页
//request.fetchOffset = 0;
// 每页显示多少条数据
//request.fetchLimit = 6;
//发送查询请求
NSArray *resArray = [_context executeFetchRequest:request error:nil];
//打印查询结果
for (Student *stu in resArray) {
NSLog(@"name=%@, age=%d",stu.name, stu.age);
}
}改
- (IBAction)updateClick:(id)sender {
//创建查询请求
NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
NSPredicate *pre = [NSPredicate predicateWithFormat:@"age >= 0"];
request.predicate = pre;
//发送请求
NSArray *resArray = [_context executeFetchRequest:request error:nil];
//修改
for (Student *stu in resArray) {
stu.name = @"ran";
}
NSError *error = nil;
if ([_context save:&error]) {
NSLog(@"更新数据成功");
}else{
NSLog(@"更新数据失败, %@", error);
}
}
@end转自：https://blog.csdn.net/u013712343/article/details/106698848
收起阅读 »
iOS 显示动态图、GIF图方法总结
一、WebView加载
可以通过WebView加载本地Gif图和网络Gif图，但图片大小不能自适应控件大小，也不能设置Gif图播放时间。使用如下：
// 1、WebView加载
- (void)webViewShowGif {
UIWebView *webView = self.viewArr[0];
// 本地地址
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"hello" ofType:@"gif"];
// 网路地址
// NSString *imagePath = @"http://qq.yh31.com/tp/zjbq/201711092144541829.gif";
NSURL *imageUrl = [NSURL URLWithString:imagePath];
NSURLRequest *request = [NSURLRequest requestWithURL:imageUrl];
[webView loadRequest:request];
}二、UIImageView加载多图动画
把动态图拆分成一张张图片，将一系列帧添加到animationImages数组里面，然后设置animation一系列属性，如动画时间，动画重复次数。例：
// 2、UIImageView加载多张图片，播放
- (void)imageViewStartAnimating {
UIImageView *imageView = self.viewArr[1];
NSMutableArray *imageArr = [NSMutableArray arrayWithCapacity:3];
for (int i = 0; i<3; i++) {
NSString *imageStr = [NSString stringWithFormat:@"import_progress%d",i + 1];
UIImage *image = [UIImage imageNamed:imageStr];
[imageArr addObject:image];
}
imageView.animationImages = imageArr;
imageView.animationDuration = 2;
[imageView startAnimating];
}三、SDWebImage加载本地GIF
在SDWebImage这个库里有一个UIImage+GIF的类别，使用sd_animatedGIFWithData方法可以将GIF图片数据专为图片。例：
// 3、SDWebImage加载本地GIF
- (void)imageViewLocalGif {
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"happy" ofType:@"gif"];
NSData *imageData = [NSData dataWithContentsOfFile:imagePath];
UIImage *image = [UIImage sd_animatedGIFWithData:imageData];
UIImageView *imageView = self.viewArr[2];
imageView.image = image;
}四、SDWebImage加载网络GIF
首先将网络gif图下载到本地，然后再用sd_animatedGIFWithData方法，转为可用的图片，下载gif图的方式有两种
方式一：采用SDWebImageDownloader下载，回调里面会有NSData。只是，你会发现采用SDWebImageDownloader下载，界面显示就是没有sd_setImageWithURL方法流畅，这是因为sd_setImageWithURL里面对cache和线程做了很多处理，保证了UI的流畅。
NSString *imageStr = @"http://qq.yh31.com/tp/zjbq/201711142021166458.gif";
NSURL *imgeUrl = [NSURL URLWithString:imageStr];
SDWebImageDownloaderOptions options = 0;
UIImageView *imageView = self.viewArr[3];
// 方法一 SDWebImageDownloader下载
SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
[downloader downloadImageWithURL:imgeUrl
options:options
progress:^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
} completed:^(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished) {
imageView.image = [UIImage sd_animatedGIFWithData:data];
}];方式二、sd_setImageWithURL下载，回调的时候不用image，去直接读cache。(首先要了解sd_setImageWithURL里的内部逻辑，下载完之后先入cache，再执行block，这才保证外面可以直接读取到)，取出来的就是NSData。首次下载成功时，可能获取data失败，因为这次图片可能还没存储成功，有延迟。
// 方法二 sd_setImageWithURL下载
SDWebImageOptions opt = SDWebImageRetryFailed | SDWebImageAvoidAutoSetImage;
[imageView sd_setImageWithURL:imgeUrl
placeholderImage:nil
options:opt
completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
if (image.images && image.images.count) {
NSString *path = [[SDImageCache sharedImageCache] defaultCachePathForKey:imageURL.absoluteString];
NSData *data = [NSData dataWithContentsOfFile:path];
UIImage *gifImage = [UIImage sd_animatedGIFWithData:data];
imageView.image = gifImage;
}
}];五、FLAnimatedImage使用
FLAnimatedImage 是由Flipboard开源的iOS平台上播放GIF动画的一个优秀解决方案，在内存占用和播放体验都有不错的表现。FLAnimatedImage项目的流程比较简单，FLAnimatedImage就是负责GIF数据的处理，然后提供给FLAnimatedImageView一个UIImage对象。FLAnimatedImageView拿到UIImage对象显示出来就可以了。 例：
// 5、FLAnimatedImage使用
- (void)animatedImageViewShowGif {
FLAnimatedImageView *imageView = self.viewArr[4];
NSURL *url = [[NSBundle mainBundle] URLForResource:@"weiwei" withExtension:@"gif"];
NSData *data = [NSData dataWithContentsOfURL:url];
FLAnimatedImage *animatedImage = [FLAnimatedImage animatedImageWithGIFData:data];
imageView.animatedImage = animatedImage;
}六、YYImage使用
1.显示本地gif
//load loacle gif image
- (void)loadLocaleGifImage{
//yyImage show gif image
[self labelFactoryWithFrame:CGRectMake(0, kScreenHeight/2 - 20, kScreenWidth, 20) title:@"yyImage"];
YYImage *yyimage = [YYImage imageNamed:@"test.gif"];
YYAnimatedImageView *yyImageView = [[YYAnimatedImageView alloc] initWithImage:yyimage];
yyImageView.frame = CGRectMake(0, kScreenHeight/2, kScreenWidth, kScreenHeight/3);
[self.view addSubview:yyImageView];
} 2.加载网络gif图
//download network gif image
- (void)downloadNetworkGifImage{
//yyImage show gif image
[self labelFactoryWithFrame:CGRectMake(0, kScreenHeight/2 - 20, kScreenWidth, 20) title:@"yyImage"];
YYImage *yyimage = [YYImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://photocdn.sohu.com/20151214/mp48444247_1450092561460_10.gif"]]];
YYAnimatedImageView *yyImageView = [[YYAnimatedImageView alloc] initWithImage:yyimage];
yyImageView.frame = CGRectMake(0, kScreenHeight/2, kScreenWidth, kScreenHeight/3);
[self.view addSubview:yyImageView];
}
- (void)labelFactoryWithFrame:(CGRect)frame title:(NSString *)title{
UILabel *label = [[UILabel alloc] initWithFrame:frame];
label.textAlignment = NSTextAlignmentCenter;
label.textColor = [UIColor blackColor];
label.font = [UIFont systemFontOfSize:14];
label.text = title;
[self.view addSubview:label];
}
iOS -Masonry详解
现在iPhone手机屏幕越来越多, 屏幕适配也越来越重要. Masonry就是为屏幕适配而生的三方框架.
Masonry基础API
mas_makeConstraints() 添加约束
mas_remakeConstraints() 移除之前的约束，重新添加新的约束
mas_updateConstraints() 更新约束，写哪条更新哪条，其他约束不变
equalTo() 参数是对象类型，一般是视图对象或者mas_width这样的坐标系对象
mas_equalTo() 和上面功能相同，参数可以传递基础数据类型对象，可以理解为比上面的API更强大
width() 用来表示宽度，例如代表view的宽度
mas_width() 用来获取宽度的值。和上面的区别在于，一个代表某个坐标系对象，一个用来获取坐标系对象的值更新约束和布局
Masonry本质上就是对系统AutoLayout进行的封装，包括里面很多的API，都是对系统API进行了一次二次包装。
typedef NS_OPTIONS(NSInteger, MASAttribute) {
MASAttributeLeft = 1 << NSLayoutAttributeLeft,
MASAttributeRight = 1 << NSLayoutAttributeRight,
MASAttributeTop = 1 << NSLayoutAttributeTop,
MASAttributeBottom = 1 << NSLayoutAttributeBottom,
MASAttributeLeading = 1 << NSLayoutAttributeLeading,
MASAttributeTrailing = 1 << NSLayoutAttributeTrailing,
MASAttributeWidth = 1 << NSLayoutAttributeWidth,
MASAttributeHeight = 1 << NSLayoutAttributeHeight,
MASAttributeCenterX = 1 << NSLayoutAttributeCenterX,
MASAttributeCenterY = 1 << NSLayoutAttributeCenterY,
MASAttributeBaseline = 1 << NSLayoutAttributeBaseline,
};Masonry示例代码
Masonry本质上就是对系统AutoLayout进行的封装，包括里面很多的API，都是对系统API进行了一次二次包装。
typedef NS_OPTIONS(NSInteger, MASAttribute) {
MASAttributeLeft = 1 << NSLayoutAttributeLeft,
MASAttributeRight = 1 << NSLayoutAttributeRight,
MASAttributeTop = 1 << NSLayoutAttributeTop,
MASAttributeBottom = 1 << NSLayoutAttributeBottom,
MASAttributeLeading = 1 << NSLayoutAttributeLeading,
MASAttributeTrailing = 1 << NSLayoutAttributeTrailing,
MASAttributeWidth = 1 << NSLayoutAttributeWidth,
MASAttributeHeight = 1 << NSLayoutAttributeHeight,
MASAttributeCenterX = 1 << NSLayoutAttributeCenterX,
MASAttributeCenterY = 1 << NSLayoutAttributeCenterY,
MASAttributeBaseline = 1 << NSLayoutAttributeBaseline,
};常用方法
设置内边距
/**
设置yellow视图和self.view等大，并且有10的内边距。
注意根据UIView的坐标系，下面right和bottom进行了取反。所以不能写成下面这样，否则right、bottom这两个方向会出现问题。
make.edges.equalTo(self.view).with.offset(10);
除了下面例子中的offset()方法，还有针对不同坐标系的centerOffset()、sizeOffset()、valueOffset()之类的方法。
*/
[self.yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
make.left.equalTo(self.view).with.offset(10);
make.top.equalTo(self.view).with.offset(10);
make.right.equalTo(self.view).with.offset(-10);
make.bottom.equalTo(self.view).with.offset(-10);
}];通过insets简化设置内边距的方式
// 下面的方法和上面例子等价，区别在于使用insets()方法。
[self.blueView mas_makeConstraints:^(MASConstraintMaker *make) {
// 下、右不需要写负号，insets方法中已经为我们做了取反的操作了。
make.edges.equalTo(self.view).with.insets(UIEdgeInsetsMake(10, 10, 10, 10));
}];更新约束
// 设置greenView的center和size，这样就可以达到简单进行约束的目的
[self.greenView mas_makeConstraints:^(MASConstraintMaker *make) {
make.center.equalTo(self.view);
// 这里通过mas_equalTo给size设置了基础数据类型的参数，参数为CGSize的结构体
make.size.mas_equalTo(CGSizeMake(300, 300));
}];
// 为了更清楚的看出约束变化的效果，在显示两秒后更新约束。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 指定更新size，其他约束不变。
[self.greenView mas_updateConstraints:^(MASConstraintMaker *make) {
make.size.mas_equalTo(CGSizeMake(100, 100));
}];
});大于等于和小于等于某个值的约束
[self.textLabel mas_makeConstraints:^(MASConstraintMaker *make) {
make.center.equalTo(self.view);
// 设置宽度小于等于200
make.width.lessThanOrEqualTo(@200);
// 设置高度大于等于10
make.height.greaterThanOrEqualTo(@(10));
}];
self.textLabel.text = @"这是测试的字符串。能看到1、2、3个步骤，第一步当然是上传照片了，要上传正面近照哦。上传后，网站会自动识别你的面部，如果觉得识别的不准，你还可以手动修改一下。左边可以看到16项修改参数，最上面是整体修改，你也可以根据自己的意愿单独修改某项，将鼠标放到选项上面，右边的预览图会显示相应的位置。";textLabel只需要设置一个属性即可
self.textLabel.numberOfLines = 0;使用基础数据类型当做参数
/**
如果想使用基础数据类型当做参数，Masonry为我们提供了"mas_xx"格式的宏定义。
这些宏定义会将传入的基础数据类型转换为NSNumber类型，这个过程叫做封箱(Auto Boxing)。
"mas_xx"开头的宏定义，内部都是通过MASBoxValue()函数实现的。
这样的宏定义主要有四个，分别是mas_equalTo()、mas_offset()和大于等于、小于等于四个。
*/
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.center.equalTo(self.view);
make.width.mas_equalTo(100);
make.height.mas_equalTo(100);
}];设置约束优先级
/**
Masonry为我们提供了三个默认的方法，priorityLow()、priorityMedium()、priorityHigh()，这三个方法内部对应着不同的默认优先级。
除了这三个方法，我们也可以自己设置优先级的值，可以通过priority()方法来设置。
*/
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.center.equalTo(self.view);
make.width.equalTo(self.view).priorityLow();
make.width.mas_equalTo(20).priorityHigh();
make.height.equalTo(self.view).priority(200);
make.height.mas_equalTo(100).priority(1000);
}];Masonry也帮我们定义好了一些默认的优先级常量，分别对应着不同的数值，优先级最大数值是1000。
static const MASLayoutPriority MASLayoutPriorityRequired = UILayoutPriorityRequired;
static const MASLayoutPriority MASLayoutPriorityDefaultHigh = UILayoutPriorityDefaultHigh;
static const MASLayoutPriority MASLayoutPriorityDefaultMedium = 500;
static const MASLayoutPriority MASLayoutPriorityDefaultLow = UILayoutPriorityDefaultLow;
static const MASLayoutPriority MASLayoutPriorityFittingSizeLevel = UILayoutPriorityFittingSizeLevel;设置约束比例
// 设置当前约束值乘以多少，例如这个例子是redView的宽度是self.view宽度的0.2倍。
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.center.equalTo(self.view);
make.height.mas_equalTo(30);
make.width.equalTo(self.view).multipliedBy(0.2);
}];小练习
子视图等高/等宽练习
/**
下面的例子是通过给equalTo()方法传入一个数组，设置数组中子视图及当前make对应的视图之间等高。
需要注意的是，下面block中设置边距的时候，应该用insets来设置，而不是用offset。
因为用offset设置right和bottom的边距时，这两个值应该是负数，所以如果通过offset来统一设置值会有问题。
*/
CGFloat padding = 10;
UIView *redView = [[UIView alloc]init];
redView.backgroundColor = [UIColor redColor];
[self.view addSubview:redView];
UIView *blueView = [[UIView alloc]init];
blueView.backgroundColor = [UIColor blueColor];
[self.view addSubview:blueView];
UIView *yellowView = [[UIView alloc]init];
yellowView.backgroundColor = [UIColor yellowColor];
[self.view addSubview:yellowView];
/********** 等高 ***********/
[redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.left.right.top.equalTo(self.view).insets(UIEdgeInsetsMake(padding, padding, 0, padding));
make.bottom.equalTo(blueView.mas_top).offset(-padding);
}];
[blueView mas_makeConstraints:^(MASConstraintMaker *make) {
make.left.right.equalTo(self.view).insets(UIEdgeInsetsMake(0, padding, 0, padding));
make.bottom.equalTo(yellowView.mas_top).offset(-padding);
}];
/**
下面设置make.height的数组是关键，通过这个数组可以设置这三个视图高度相等。其他例如宽度之类的，也是类似的方式。
*/
[yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
make.left.right.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(0, padding, padding, padding));
make.height.equalTo(@[blueView, redView]);
}];
/********** 等宽 ***********/
[redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.top.left.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(padding, padding, padding, 0));
make.right.equalTo(blueView.mas_left).offset(-padding);
}];
[blueView mas_makeConstraints:^(MASConstraintMaker *make) {
make.top.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(padding, 0, padding, 0));
make.right.equalTo(yellowView.mas_left).offset(-padding);
}];
[yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
make.top.bottom.right.equalTo(self.view).insets(UIEdgeInsetsMake(padding, 0, padding, padding));
make.width.equalTo(@[redView, blueView]);
}];
子视图垂直居中练习
CGFloat padding = 10;
UIView *redView = [[UIView alloc]init];
redView.backgroundColor = [UIColor redColor];
[self.view addSubview:redView];
UIView *blueView = [[UIView alloc]init];
blueView.backgroundColor = [UIColor blueColor];
[self.view addSubview:blueView];
[redView mas_makeConstraints:^(MASConstraintMaker *make) {
make.centerY.equalTo(self.view);
make.left.equalTo(self.view).mas_offset(padding);
make.right.equalTo(blueView.mas_left).mas_offset(-padding);
//make.width.equalTo(blueView);
make.height.mas_equalTo(150);
}];
[blueView mas_makeConstraints:^(MASConstraintMaker *make) {
make.centerY.equalTo(self.view);
make.right.equalTo(self.view).mas_offset(-padding);
make.width.equalTo(redView);
make.height.mas_equalTo(150);
}];
转自：https://www.jianshu.com/p/587efafdd2b3
收起阅读 »
谈谈react hooks的优缺点
谈一下个人认为的react hooks的优缺点，通过和传统的React.Component进行对比得出。
#优点
一、更容易复用代码
这点应该是react hooks最大的优点，它通过自定义hooks来复用状态，从而解决了类组件有些时候难以复用逻辑的问题。hooks是怎么解决这个复用的问题呢，具体如下：
- 每调用useHook一次都会生成一份独立的状态，这个没有什么黑魔法，函数每次调用都会开辟一份独立的内存空间。
- 虽然状态(from useState)和副作用(
useEffect)的存在依赖于组件，但它们可以在组件外部进行定义。这点是class component做不到的，你无法在外部声明state和副作用（如componentDidMount）。
上面这两点，高阶组件和renderProps也同样能做到。但hooks实现起来的代码量更少，以及更直观（代码可读性）。
举个例子，经常使用的antd-table，用的时候经常需要维护一些状态 ，并在合适的时机去更改它们:
componentDidMount(){
this.loadData();
}
loadData = ()=>{
this.setState({
current: xxx,
total: xxx,
pageSize: xxx,
dataSource: xxx[]
})
}
onTableChange = ()=>{
this.setState({
current: xxx,
total: xxx,
pageSize: xxx,
})
}
render(){
const {total,pageSize,current,dataSource} = this.state;
return <Table
dataSource={dataSource}
pagination={{total,pageSize,current}
onChange={this.onTableChange}
/>
}
每个table都要写一些这种逻辑，那还有啥时间去摸鱼。这些高度类似的逻辑，可以通过封装一个高阶组件来抽象它们。这个高阶组件自带这些状态，并可以自动调用server去获取remote data。
用高阶组件来实现的话会是这样：
import { Table } from 'antd'
import server from './api'
function useTable(server) {
return function (WrappedComponent) {
return class HighComponent extends React.Component {
state = {
tableProps: xxx,
};
render() {
const { tableProps } = this.state;
return <WrappedComponent tableProps={tableProps} />;
}
};
};
}
@useTable(server)
class App extends Component{
render(){
/**
* 高阶组件/renderProps是通过增强组件的props（赋予一个新的属性或者方法到组件的props属性），
* 实现起来比较隐式。你难以区分这个props是来自哪个高阶组件（特别是使用了较多的高阶组件时），
* 或者还是来自业务的父组件。
*/
const { tableProps } = this.props;
return (
<Table
columns={[...]}
// tableProps包含pagination, onChange, dataSource等属性。
{...tableProps}
/>
)
}
}
如果用hooks来实现的话，会是：
import { Table } from 'antd'
import server from './api'
function useTable(server) {
const [tableProps, setTableProps] = useState(xxx);
return tableProps;
}
function App {
const { tableProps } = useTable();
return (
<Table
columns={[...]}
// tableProps包含pagination, onChange, dataSource等属性
{...tableProps}
/>
)
}
/*
相对比高阶组件“祖父=>父=>子”的层层嵌套，
hooks是这样的：
const { brother1 } = usehook1;
const { brother2} = usehook2;
*/
可以看到，hooks的逻辑更清晰，可读性更好。
二、清爽的代码风格+代码量更少
1. 函数式编程风格，函数式组件、状态保存在运行环境、每个功能都包裹在函数中，整体风格更清爽，更优雅。
2. 对IDE更友好，对比类组件，函数组件里面的unused状态和unused-method更容易被编辑器发现。
3. 使用typescript的话，类型声明也变得更容易。
class Example{
hello: string;
constructor(){
this.hello = 'hello world'
}
}
// 代码量更少
function Example(){
const hello:string = 'hello world'
}
4. 向props或状态取值更加方便，函数组件的取值都从当前作用域直接获取变量，而类组件需要先访问实例this，再访问其属性或者方法，多了一步。
5. 更改状态也变得更加简单, `this.setState({ count:xxx })`变成 `setCount(xxx)`。
因为减少了很多模板代码，特别是小组件写起来更加省事，人们更愿意去拆分组件。而组件粒度越细，被复用的可能性越大。所以，hooks也在不知不觉中改变人们的开发习惯，提高项目的组件复用率。
#缺点
一、响应式的useEffect
写函数组件时，你不得不改变一些写法习惯。你必须清楚代码中useEffect和useCallback的“依赖项数组”的改变时机。有时候，你的useEffect依赖某个函数的不可变性，这个函数的不可变性又依赖于另一个函数的不可变性，这样便形成了一条依赖链。一旦这条依赖链的某个节点意外地被改变了，你的useEffect就被意外地触发了，如果你的useEffect是幂等的操作，可能带来的是性能层次的问题，如果是非幂等，那就糟糕了。
所以，对比componentDidmount和componentDidUpdate，useEffect带来的心智负担更大。
二、hooks不擅长异步的代码（旧引用问题）
函数的运行是独立的，每个函数都有一份独立的作用域。函数的变量是保存在运行时的作用域里面。当我们有异步操作的时候，经常会碰到异步回调的变量引用是之前的，也就是旧的（这里也可以理解成闭包）。比如下面的一个例子（codesandbox）：
import React, { useState } from "react";
const Counter = () => {
const [counter, setCounter] = useState(0);
const onAlertButtonClick = () => {
setTimeout(() => {
alert("Value: " + counter);
}, 3000);
};
return (
<div>
<p>You clicked {counter} times.</p>
<button onClick={() => setCounter(counter + 1)}>Click me</button>
<button onClick={onAlertButtonClick}>
Show me the value in 3 seconds
</button>
</div>
);
};
export default Counter;
当你点击Show me the value in 3 seconds的后，紧接着点击Click me使得counter的值从0变成1。三秒后，定时器触发，但alert出来的是0（旧值），但我们希望的结果是当前的状态1。
这个问题在class component不会出现，因为class component的属性和方法都存放在一个instance上，调用方式是：this.state.xxx和this.method()。因为每次都是从一个不变的instance上进行取值，所以不存在引用是旧的问题。
其实解决这个hooks的问题也可以参照类的instance。用useRef返回的immutable RefObject（把值保存在current属性上）来保存state，然后取值方式从counter变成了： counterRef.current。如下：
import React, { useState, useRef, useEffect } from "react";
const Counter = () => {
const [counter, setCounter] = useState(0);
const counterRef = useRef(counter);
const onAlertButtonClick = () => {
setTimeout(() => {
alert("Value: " + counterRef.current);
}, 3000);
};
useEffect(() => {
counterRef.current = counter;
});
return (
<div>
<p>You clicked {counter} times.</p>
<button onClick={() => setCounter(counter + 1)}>Click me</button>
<button onClick={onAlertButtonClick}>
Show me the value in 3 seconds
</button>
</div>
);
};
export default Counter;
结果如我们所期待，alert的是当前的值1。
我们可以把这个过程封装成一个custom hook，如下：
import { useEffect, useRef, useState } from "react";
const useRefState = <T>(
initialValue: T
): [T, React.MutableRefObject<T>, React.Dispatch<React.SetStateAction<T>>] => {
const [state, setState] = useState<T>(initialValue);
const stateRef = useRef(state);
useEffect(() => {
stateRef.current = state;
}, [state]);
return [state, stateRef, setState];
};
export default useRefState;
尽管这个问题被巧妙地解决了，但它不优雅、hack味道浓，且丢失了函数编程风格。
三、custom hooks有时严重依赖参数的不可变性
import {useState, useEffect} from 'react'
export function() useData(api){
const [data, setDate] = useState([]);
useEffect(()=>{
api().then(res=>setData(res.data)) ;
// 这里要求传入的api是immutable的，被useCallback/useMemo所包裹。不然每次api一变，
// 都会非预期地多调用一次useEffect。
},[api])
}
对于这点，除了在团队约定参数的不可变性，还可以对useCallback/useMemo进行魔改：
import React from "react";
let useCallback = React.useCallback;
if (__DEV__) {
useCallback = (fn, arr) => {
fn.__useCallback__ = true;
return useCallback(fn, arr);
};
}
export default useCallback;
然后在run-time中去检查是否存在__useCallback__这个属性:
import {useState, useEffect} from 'react'
function checkFn(fn){
if(__DEV__){
if(!fn.__useCallback__){
throw Error('请用团队封装的useCallback来包裹fn')
}
}
}
export function() useData(api){
const [data, setDate] = useState([]);
checkFn(api);
useEffect(()=>{
api().then(res=>setData(res.data)) ;
// 这里要求传入的api是immutable的，被useCallback/useMemo所包裹。不然每次api一变，
// 都会非预期地多调用一次useEffect。
},[api])
}
也有其他的方案：比如用eslint插件去检查。
#怎么避免react hooks的常见问题
- 不要在
useEffect里面写太多的依赖项，划分这些依赖项成多个单一功能的useEffect。其实这点是遵循了软件设计的“单一职责模式”。 - 如果你碰到状态不同步的问题，可以考虑下手动传递参数到函数。如：
// showCount的count来自父级作用域
const [count,setCount] = useState(xxx);
function showCount(){ console.log(count) }
// showCount的count来自参数
const [count,setCount] = useState(xxx);
function showCount(c){ console.log(c) }
但这个也只能解决一部分问题，很多时候你不得不使用上述的useRef方案。
3. 拆分组件，细化组件的粒度。复杂业务场景中使用hooks，应尽可能地细分组件，使得组件的功能尽可能单一，这样的hooks组件更好维护。
#感想
hooks很好用很强大，但它不擅长异步。但在有太多异步逻辑的代码时，class比它更适合、更稳、更好维护。
原文链接：https://zhuanlan.zhihu.com/p/88593858
收起阅读 »iOS动态换肤-支持暗夜模式
适配暗夜模式
iOS13新出现了暗夜模式，苹果新增了一些API方便我们来做适配。这里不做深入，只是稍微总结下。
适配暗夜模式，无非就是界面显示上的一些变化，暗夜模式下，主题由默认的白色调变为了深色调，相应的，我们的APP在显示上也需要做相应调整。主要包括两个方面：颜色的变化（视图颜色色，字体颜色等)和图片的改变；
关于颜色改变:UIcolor新增了一个分类\color{red}{UIColor (DynamicColors)}，提供了动态color的API。通过特征收集器traitCollection，可以动态判断当前手机的一些界面特征信息。
/*使用时可以做下进一步封装。*/
[UIColor colorWithDynamicProvider:^UIColor * _Nonnull(UITraitCollection * _Nonnull traitCollection) {
UIColor *color = [UIColor lightGrayColor];
if (@available(iOS 13.0,*)) {
if (traitCollection.userInterfaceStyle ==UIUserInterfaceStyleDark ) {
color =[UIColor blackColor];//dark
}else if(traitCollection.userInterfaceStyle ==UIUserInterfaceStyleLight){
color =[UIColor lightGrayColor];//light
}
}
return color;
}];关于图片:可以在Assets.xcassets中给每一套图片设置对应的模式，系统自动根据当前的模式取用相应的图片；
监听模式的改变:做好以上两点只能部分满足需求，很多时候我们需要确切的知道当前的模式，并且知道用户什么时候切换的模式；
- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection{
[super traitCollectionDidChange:previousTraitCollection];
if ([UITraitCollection currentTraitCollection].userInterfaceStyle !=previousTraitCollection.userInterfaceStyle ) {
NSLog(@"用户切换了模式，在这里做适配工作");
}else{
NSLog(@"用户没有切换模式");
}
}关于这种适配方式的几点看法：
工作繁琐，代码杂乱。界面如果需要做一些定制化的改变，就需要监听模式的改变，可能出现一个界面适配的代码出现在好几个地方。
扩展性不高。现在出现了一个暗夜模式，将来会不会再有其他模式？如果APP本来就有几套主题，那么适配起来更加繁琐杂乱。
细细想来，适配暗夜模式，不就是切换主题吗，单独给暗夜模式弄一套对应皮肤就完了。下面看看，如何给APP便捷高效、扩展性性高地换肤。
动态换肤（DynamicSkin）
代码简洁，便于维护；
自动适配暗夜模式，不需要自己每个界面去监听模式的切换；
使用步骤
1.引入框架，导入头文件
手动引入或者通过CocoaPods
pod 'DynamicSkin'#import "DPDynamicTheme.h"2.配置模型
继承DPThemeConfig，根据自己的需求，配置相应字段即可。
#import "DPThemeConfig.h"
NS_ASSUME_NONNULL_BEGIN
@interface TestConfig : DPThemeConfig
@property(nonatomic,copy)NSString*color1;
@property(nonatomic,copy)NSString*color2;
@property(nonatomic,copy)NSString*img1;
@property(nonatomic,copy)NSString*tabOne;
@property(nonatomic,copy)NSString*tabTwo;
@property(nonatomic,copy)NSString*tabThree;
@property(nonatomic,copy)NSString*tabTextColorNormal;
@property(nonatomic,copy)NSString*tabTextColorSelect;
@property(nonatomic,copy)NSString*state;
@end
NS_ASSUME_NONNULL_END3.设置默认主题
__weak typeof (self)weakSelf = self;
//用户切换暗夜模式，或则主动切换pushCurrentThemme:，会触发该回调
[self tz_dynamicTheme:^(TestConfig * _Nullable config) {
[weakSelf.image sd_setImageWithURL:[NSURL URLWithString:config.img1]];
weakSelf.statelabel.text = config.state;
} WithIdentifier:NSStringFromClass([self class])];
}4.数据绑定
__weak typeof (self)weakSelf = self;
//用户切换暗夜模式，或则主动切换pushCurrentThemme:，会触发该回调
[self tz_dynamicTheme:^(TestConfig * _Nullable config) {
[weakSelf.image sd_setImageWithURL:[NSURL URLWithString:config.img1]];
weakSelf.statelabel.text = config.state;
} WithIdentifier:NSStringFromClass([self class])];
}5.销毁不需要的回调
-(void)dealloc{
//identifer需要和当前界面绑定的保持一致
[[DPThemeManager manager] removeUpdateWithIdentifer:NSStringFromClass([self class])];
}转自：https://www.jianshu.com/p/50f24d5af4cd
收起阅读 »
React Hooks究竟是什么呢？
我们大部分 React 类组件可以保存状态，而函数组件不能？ 并且类组件具有生命周期，而函数组件却不能？
React 早期版本，类组件可以通过继承PureComponent来优化一些不必要的渲染，相对于函数组件，React 官网没有提供对应的方法来缓存函数组件以减少一些不必要的渲染，直接 16.6 出来的 React.memo函数。
React 16.8 新出来的Hook可以让React 函数组件具有状态，并提供类似 componentDidMount和componentDidUpdate等生命周期方法。
类被会替代吗？
Hooks不会替换类，它们只是一个你可以使用的新工具。React 团队表示他们没有计划在React中弃用类，所以如果你想继续使用它们，可以继续用。
我能体会那种总有新东西要学的感觉有多痛苦，不会就感觉咱们总是落后一样。Hooks 可以当作一个很好的新特性来使用。当然没有必要用 Hook 来重构原来的代码, React团队也建议不要这样做。
Go Go
来看看Hooks的例子,咱们先从最熟悉的开始:函数组件。
以下 OneTimeButton 是函数组件，所做的事情就是当我们点击的时候调用 sayHi 方法。
import React from 'react'; |
我们想让这个组件做的是，跟踪它是否被点击，如果被点击了，禁用按钮，就像一次性开关一样。
但它需要一个state，因为是一个函数，它不可能有状态(React 16.8之前)，所以需要重构成类。
函数组件转换为类组件的过程中大概有5个阶段：
否认：也许它不需要是一个类，我们可以把 state 放到其它地方。
实现： 废话，必须把它变成一个
class，不是吗？接受：好吧，我会改的。
努力加班重写：首先 写
class Thing extends React.Component，然后 实现render等等 。最后：添加state。
class OneTimeButton extends React.Component { |
这是相当多的代码，组件的结构也发生了很大的变化， 我们需要多个小的功能，就需要改写很多。
使用 Hook 轻松添加 State
接下来，使用新的 useState hook向普通函数组件添加状态：
import React, { useState } from 'react' |
这段代码是如何工作的
这段代码的大部分看起来像我们一分钟前写的普通函数组件，除了useState。
useState是一个hook。 它的名字以“use”开头（这是Hooks的规则之一 - 它们的名字必须以“use”开头）。
useState hook 的参数是 state 的初始值，返回一个包含两个元素的数组:当前state和一个用于更改state 的函数。
类组件有一个大的state对象，一个函数this.setState一次改变整个state对象。
函数组件根本没有状态，但useState hook允许我们在需要时添加很小的状态块。 因此，如果只需要一个布尔值，我们就可以创建一些状态来保存它。
由于Hook以某种特殊方式创建这些状态，并且在函数组件内也没有像setState函数来更改状态，因此 Hook 需要一个函数来更新每个状态。 所以 useState 返回是一对对应关系：一个值，一个更新该值函数。 当然，值可以是任何东西 - 任何JS类型 - 数字，布尔值，对象，数组等。
现在，你应该有很多疑问，如：
当组件重新渲染时，每次都不会重新创建新的状态吗？ React如何知道旧状态是什么？
为什么hook 名称必须以“use”开头？ 这看起来很可疑。
如果这是一个命名规则，那是否意味着我可以自定义 Hook。
如何存储更复杂的状态，很多场景不单单只有一个状态值这么简单。
Hooks 的魔力
将有状态信息存储在看似无状态的函数组件中，这是一个奇怪的悖论。这是第一个关于钩子的问题，咱们必须弄清楚它们是如何工作的。
原作者得的第一个猜测是某种编译器的在背后操众。搜索代码useWhatever并以某种方式用有状态逻辑替换它。
然后再听说了调用顺序规则(它们每次必须以相同的顺序调用)，这让我更加困惑。这就是它的工作原理。
React第一次渲染函数组件时，它同时会创建一个对象与之共存，该对象是该组件实例的定制对象，而不是全局对象。只要组件存在于DOM中，这个组件的对象就会一直存在。
使用该对象，React可以跟踪属于组件的各种元数据位。
请记住，React组件甚至函数组件都从未进行过自渲染。它们不直接返回HTML。组件依赖于React在适当的时候调用它们，它们返回的对象结构React可以转换为DOM节点。
React有能力在调用每个组件之前做一些设置，这就是它设置这个状态的时候。
其中做的一件事设置 Hooks 数组。 它开始是空的, 每次调用一个hook时，React 都会向该数组添加该 hook。
为什么顺序很重要
假设咱们有以下这个组件：
function AudioPlayer() { |
因为它调用useState 3次，React 会在第一次渲染时将这三个 hook 放入 Hooks 数组中。
下次渲染时，同样的3个hooks以相同的顺序被调用，所以React可以查看它的数组，并发现已经在位置0有一个useState hook ，所以React不会创建一个新状态，而是返回现有状态。
这就是React能够在多个函数调用中创建和维护状态的方式，即使变量本身每次都超出作用域。
多个useState 调用示例
让咱们更详细地看看这是如何实现的，第一次渲染：
- React 创建组件时，它还没有调用函数。React 创建元数据对象和Hooks的空数组。假设这个对象有一个名为
nextHook的属性，它被放到索引为0的位置上，运行的第一个hook将占用位置0。
- React 调用你的组件（这意味着它知道存储
hooks的元数据对象）。
调用
useState，React创建一个新的状态，将它放在hooks数组的第0位，并返回[volume，setVolume]对，并将volume设置为其初始值80，它还将nextHook索引递增1。再次调用
useState，React查看数组的第1位，看到它是空的，并创建一个新的状态。 然后它将nextHook索引递增为2，并返回[position，setPosition]。第三次调用
useState。 React看到位置2为空，同样创建新状态，将nextHook递增到3，并返回[isPlaying，setPlaying]。
现在，hooks 数组中有3个hook，渲染完成。 下一次渲染会发生什么？
React需要重新渲染组件, 由于 React 之前已经看过这个组件，它已经有了元数据关联。React将nextHook索引重置为0，并调用组件。调用
useState，React查看索引0处的hooks数组，并发现它已经在该槽中有一个hook。，所以无需重新创建一个，它将nextHook推进到索引1并返回[volume，setVolume]，其中volume仍设置为80。再次调用
useState。 这次，nextHook为1，所以React检查数组的索引1。同样，hook 已经存在，所以它递增nextHook并返回[position，setPosition]。第三次调用
useState，我想你知道现在发生了什么。
就是这样了，知道了原理，看起来也就不那么神奇了， 但它确实依赖于一些规则，所以才有使用 Hooks 规则。
Hooks 的规则
自定义 hooks 函数只需要遵守规则 3 ：它们的名称必须以“use”为前缀。
例如，我们可以从AudioPlayer组件中将3个状态提取到自己的自定义钩子中：
function AudioPlayer() { |
因此，咱们可以创建一个专门处理这些状态的新函数，并使用一些额外的方法返回一个对象，以便更容易启动和停止播放，例如：
function usePlayerState(lengthOfClip) { |
像这样提取状态的一个好处是可以将相关的逻辑和行为组合在一起。可以提取一组状态和相关事件处理程序以及其他更新逻辑，这不仅可以清理组件代码，还可以使这些逻辑和行为可重用。
另外，通过在自定义hooks中调用自定义hooks，可以将hooks组合在一起。hooks只是函数，当然，函数可以调用其他函数。
总结
Hooks 提供了一种新的方式来处理React中的问题，其中的思想是很有意思且新奇的。
React团队整合了一组很棒的文档和一个常见问题解答，从是否需要重写所有的类组件到钩Hooks是否因为在渲染中创建函数而变慢? 以及两者之间的所有东西，所以一定要看看。
原文：https://daveceddia.com/intro-to-hooks/
收起阅读 »
当面试官问Webpack的时候他想知道什么
前言
在前端工程化日趋复杂的今天，模块打包工具在我们的开发中起到了越来越重要的作用，其中webpack就是最热门的打包工具之一。
说到webpack，可能很多小伙伴会觉得既熟悉又陌生，熟悉是因为几乎在每一个项目中我们都会用上它，又因为webpack复杂的配置和五花八门的功能感到陌生。尤其当我们使用诸如umi.js之类的应用框架还帮我们把webpack配置再封装一层的时候，webpack的本质似乎离我们更加遥远和深不可测了。
当面试官问你是否了解webpack的时候，或许你可以说出一串耳熟能详的webpack loader和plugin的名字，甚至还能说出插件和一系列配置做按需加载和打包优化，那你是否了解他的运行机制以及实现原理呢，那我们今天就一起探索webpack的能力边界，尝试了解webpack的一些实现流程和原理，拒做API工程师。
你知道webpack的作用是什么吗？
从官网上的描述我们其实不难理解，webpack的作用其实有以下几点：
- 模块打包。可以将不同模块的文件打包整合在一起，并且保证它们之间的引用正确，执行有序。利用打包我们就可以在开发的时候根据我们自己的业务自由划分文件模块，保证项目结构的清晰和可读性。
- 编译兼容。在前端的“上古时期”，手写一堆浏览器兼容代码一直是令前端工程师头皮发麻的事情，而在今天这个问题被大大的弱化了，通过
webpack的Loader机制，不仅仅可以帮助我们对代码做polyfill，还可以编译转换诸如.less, .vue, .jsx这类在浏览器无法识别的格式文件，让我们在开发的时候可以使用新特性和新语法做开发，提高开发效率。 - 能力扩展。通过
webpack的Plugin机制，我们在实现模块化打包和编译兼容的基础上，可以进一步实现诸如按需加载，代码压缩等一系列功能，帮助我们进一步提高自动化程度，工程效率以及打包输出的质量。
说一下模块打包运行原理？
如果面试官问你Webpack是如何把这些模块合并到一起，并且保证其正常工作的，你是否了解呢？
首先我们应该简单了解一下webpack的整个打包流程：
- 1、读取
webpack的配置参数； - 2、启动
webpack，创建Compiler对象并开始解析项目； - 3、从入口文件（
entry）开始解析，并且找到其导入的依赖模块，递归遍历分析，形成依赖关系树； - 4、对不同文件类型的依赖模块文件使用对应的
Loader进行编译，最终转为Javascript文件； - 5、整个过程中
webpack会通过发布订阅模式，向外抛出一些hooks，而webpack的插件即可通过监听这些关键的事件节点，执行插件任务进而达到干预输出结果的目的。
其中文件的解析与构建是一个比较复杂的过程，在webpack源码中主要依赖于compiler和compilation两个核心对象实现。
compiler对象是一个全局单例，他负责把控整个webpack打包的构建流程。compilation对象是每一次构建的上下文对象，它包含了当次构建所需要的所有信息，每次热更新和重新构建，compiler都会重新生成一个新的compilation对象，负责此次更新的构建过程。
而每个模块间的依赖关系，则依赖于AST语法树。每个模块文件在通过Loader解析完成之后，会通过acorn库生成模块代码的AST语法树，通过语法树就可以分析这个模块是否还有依赖的模块，进而继续循环执行下一个模块的编译解析。
最终Webpack打包出来的bundle文件是一个IIFE的执行函数。
// webpack 5 打包的bundle文件内容
(() => { // webpackBootstrap
var __webpack_modules__ = ({
'file-A-path': ((modules) => { // ... })
'index-file-path': ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { // ... })
})
// The module cache
var __webpack_module_cache__ = {};
// The require function
function __webpack_require__(moduleId) {
// Check if module is in cache
var cachedModule = __webpack_module_cache__[moduleId];
if (cachedModule !== undefined) {
return cachedModule.exports;
}
// Create a new module (and put it into the cache)
var module = __webpack_module_cache__[moduleId] = {
// no module.id needed
// no module.loaded needed
exports: {}
};
// Execute the module function
__webpack_modules__[moduleId](module, module.exports, __webpack_require__ "moduleId");
// Return the exports of the module
return module.exports;
}
// startup
// Load entry module and return exports
// This entry module can't be inlined because the eval devtool is used.
var __webpack_exports__ = __webpack_require__("./src/index.js");
})和webpack4相比，webpack5打包出来的bundle做了相当的精简。在上面的打包demo中，整个立即执行函数里边只有三个变量和一个函数方法，__webpack_modules__存放了编译后的各个文件模块的JS内容，__webpack_module_cache__ 用来做模块缓存，__webpack_require__是Webpack内部实现的一套依赖引入函数。最后一句则是代码运行的起点，从入口文件开始，启动整个项目。
其中值得一提的是__webpack_require__模块引入函数，我们在模块化开发的时候，通常会使用ES Module或者CommonJS规范导出/引入依赖模块，webpack打包编译的时候，会统一替换成自己的__webpack_require__来实现模块的引入和导出，从而实现模块缓存机制，以及抹平不同模块规范之间的一些差异性。
你知道sourceMap是什么吗？
提到sourceMap，很多小伙伴可能会立刻想到Webpack配置里边的devtool参数，以及对应的eval，eval-cheap-source-map等等可选值以及它们的含义。除了知道不同参数之间的区别以及性能上的差异外，我们也可以一起了解一下sourceMap的实现方式。
sourceMap是一项将编译、打包、压缩后的代码映射回源代码的技术，由于打包压缩后的代码并没有阅读性可言，一旦在开发中报错或者遇到问题，直接在混淆代码中debug问题会带来非常糟糕的体验，sourceMap可以帮助我们快速定位到源代码的位置，提高我们的开发效率。sourceMap其实并不是Webpack特有的功能，而是Webpack支持sourceMap，像JQuery也支持souceMap。
既然是一种源码的映射，那必然就需要有一份映射的文件，来标记混淆代码里对应的源码的位置，通常这份映射文件以.map结尾，里边的数据结构大概长这样：
{
"version" : 3, // Source Map版本
"file": "out.js", // 输出文件（可选）
"sourceRoot": "", // 源文件根目录（可选）
"sources": ["foo.js", "bar.js"], // 源文件列表
"sourcesContent": [null, null], // 源内容列表（可选，和源文件列表顺序一致）
"names": ["src", "maps", "are", "fun"], // mappings使用的符号名称列表
"mappings": "A,AAAB;;ABCDE;" // 带有编码映射数据的字符串
}其中mappings数据有如下规则：
- 生成文件中的一行的每个组用“;”分隔；
- 每一段用“,”分隔；
- 每个段由1、4或5个可变长度字段组成；
有了这份映射文件，我们只需要在我们的压缩代码的最末端加上这句注释，即可让sourceMap生效：
//# sourceURL=/path/to/file.js.map有了这段注释后，浏览器就会通过sourceURL去获取这份映射文件，通过解释器解析后，实现源码和混淆代码之间的映射。因此sourceMap其实也是一项需要浏览器支持的技术。
如果我们仔细查看webpack打包出来的bundle文件，就可以发现在默认的development开发模式下，每个_webpack_modules__文件模块的代码最末端，都会加上//# sourceURL=webpack://file-path?，从而实现对sourceMap的支持。
sourceMap映射表的生成有一套较为复杂的规则，有兴趣的小伙伴可以看看以下文章，帮助理解soucrMap的原理实现：
Source Map的原理探究[1]
Source Maps under the hood – VLQ, Base64 and Yoda[2]
是否写过Loader？简单描述一下编写loader的思路？
从上面的打包代码我们其实可以知道，Webpack最后打包出来的成果是一份Javascript代码，实际上在Webpack内部默认也只能够处理JS模块代码，在打包过程中，会默认把所有遇到的文件都当作 JavaScript代码进行解析，因此当项目存在非JS类型文件时，我们需要先对其进行必要的转换，才能继续执行打包任务，这也是Loader机制存在的意义。
Loader的配置使用我们应该已经非常的熟悉：
// webpack.config.js
module.exports = {
// ...other config
module: {
rules: [
{
test: /^your-regExp$/,
use: [
{
loader: 'loader-name-A',
},
{
loader: 'loader-name-B',
}
]
},
]
}
}通过配置可以看出，针对每个文件类型，loader是支持以数组的形式配置多个的，因此当Webpack在转换该文件类型的时候，会按顺序链式调用每一个loader，前一个loader返回的内容会作为下一个loader的入参。因此loader的开发需要遵循一些规范，比如返回值必须是标准的JS代码字符串，以保证下一个loader能够正常工作，同时在开发上需要严格遵循“单一职责”，只关心loader的输出以及对应的输出。
loader函数中的this上下文由webpack提供，可以通过this对象提供的相关属性，获取当前loader需要的各种信息数据，事实上，这个this指向了一个叫loaderContext的loader-runner特有对象。有兴趣的小伙伴可以自行阅读源码。
module.exports = function(source) {
const content = doSomeThing2JsString(source);
// 如果 loader 配置了 options 对象，那么this.query将指向 options
const options = this.query;
// 可以用作解析其他模块路径的上下文
console.log('this.context');
/*
* this.callback 参数：
* error：Error | null，当 loader 出错时向外抛出一个 error
* content：String | Buffer，经过 loader 编译后需要导出的内容
* sourceMap：为方便调试生成的编译后内容的 source map
* ast：本次编译生成的 AST 静态语法树，之后执行的 loader 可以直接使用这个 AST，进而省去重复生成 AST 的过程
*/
this.callback(null, content);
// or return content;
}更详细的开发文档可以直接查看官网的 Loader API[3]。
是否写过Plugin？简单描述一下编写plugin的思路？
如果说Loader负责文件转换，那么Plugin便是负责功能扩展。Loader和Plugin作为Webpack的两个重要组成部分，承担着两部分不同的职责。
上文已经说过，webpack基于发布订阅模式，在运行的生命周期中会广播出许多事件，插件通过监听这些事件，就可以在特定的阶段执行自己的插件任务，从而实现自己想要的功能。
既然基于发布订阅模式，那么知道Webpack到底提供了哪些事件钩子供插件开发者使用是非常重要的，上文提到过compiler和compilation是Webpack两个非常核心的对象，其中compiler暴露了和 Webpack整个生命周期相关的钩子（compiler-hooks[4]），而compilation则暴露了与模块和依赖有关的粒度更小的事件钩子（Compilation Hooks[5]）。
Webpack的事件机制基于webpack自己实现的一套Tapable事件流方案（github[6]）
// Tapable的简单使用
const { SyncHook } = require("tapable");
class Car {
constructor() {
// 在this.hooks中定义所有的钩子事件
this.hooks = {
accelerate: new SyncHook(["newSpeed"]),
brake: new SyncHook(),
calculateRoutes: new AsyncParallelHook(["source", "target", "routesList"])
};
}
/* ... */
}
const myCar = new Car();
// 通过调用tap方法即可增加一个消费者，订阅对应的钩子事件了
myCar.hooks.brake.tap("WarningLampPlugin", () => warningLamp.on());Plugin的开发和开发Loader一样，需要遵循一些开发上的规范和原则：
- 插件必须是一个函数或者是一个包含
apply方法的对象，这样才能访问compiler实例； - 传给每个插件的
compiler和compilation对象都是同一个引用，若在一个插件中修改了它们身上的属性，会影响后面的插件; - 异步的事件需要在插件处理完任务时调用回调函数通知
Webpack进入下一个流程，不然会卡住;
了解了以上这些内容，想要开发一个 Webpack Plugin，其实也并不困难。
class MyPlugin {
apply (compiler) {
// 找到合适的事件钩子，实现自己的插件功能
compiler.hooks.emit.tap('MyPlugin', compilation => {
// compilation: 当前打包构建流程的上下文
console.log(compilation);
// do something...
})
}
}最后
本文也是结合一些优秀的文章和webpack本身的源码，大概地说了几个相对重要的概念和流程，其中的实现细节和设计思路还需要结合源码去阅读和慢慢理解。
Webpack作为一款优秀的打包工具，它改变了传统前端的开发模式，是现代化前端开发的基石。这样一个优秀的开源项目有许多优秀的设计思想和理念可以借鉴，我们自然也不应该仅仅停留在API的使用层面，尝试带着问题阅读源码，理解实现的流程和原理，也能让我们学到更多知识，理解得更加深刻，在项目中才能游刃有余的应用。
参考资料
[1]Source Map的原理探究: https://blog.fundebug.com/201...
[2]Source Maps under the hood – VLQ, Base64 and Yoda: *https://docs.microsoft.com/zh...
[3]Loader API: *https://www.webpackjs.com/api...
[4]compiler-hooks: https://webpack.js.org/api/co...
[5]Compilation Hooks: https://webpack.js.org/api/co...
[6]github: https://github.com/webpack/ta...
[7]Plugin API: https://www.webpackjs.com/api...
收起阅读 »
几个优雅的JavaScript运算符使用技巧
ECMAScript发展进程中，会有很多功能的更新，比如销毁，箭头功能，模块，它们极大的改变JavaScript编写方式，可能有些人喜欢，有些人不喜欢，但像每个新功能一样，我们最终会习惯它们。新版本的ECMAScript引入了三个新的逻辑赋值运算符：空运算符，AND和OR运算符，这些运算符的出现，也是希望让我们的代码更干净简洁，下面分享几个优雅的JavaScript运算符使用技巧
一、可选链接运算符【？.】
可选链接运算符（Optional Chaining Operator） 处于ES2020提案的第4阶段，因此应将其添加到规范中。它改变了访问对象内部属性的方式，尤其是深层嵌套的属性。它也可以作为TypeScript 3.7+中的功能使用。
相信大部分开发前端的的小伙伴们都会遇到null和未定义的属性。JS语言的动态特性使其无法不碰到它们。特别是在处理嵌套对象时，以下代码很常见：
if (data && data.children && data.children[0] && data.children[0].title) {
// I have a title!
}
上面的代码用于API响应，我必须解析JSON以确保名称存在。但是，当对象具有可选属性或某些配置对象具有某些值的动态映射时，可能会遇到类似情况，需要检查很多边界条件。
这时候，如果我们使用可选链接运算符，一切就变得更加轻松了。它为我们检查嵌套属性，而不必显式搜索梯形图。我们所要做的就是使用“？” 要检查空值的属性之后的运算符。我们可以随意在表达式中多次使用该运算符，并且如果未定义任何项，它将尽早返回。
对于静态属性用法是：
object?.property对于动态属性将其更改为：
object?.[expression]上面的代码可以简化为：
let title = data?.children?.[0]?.title;然后，如果我们有:
let data;
console.log(data?.children?.[0]?.title) // undefined
data = {children: [{title:'codercao'}]}
console.log(data?.children?.[0]?.title) // codercao这样写是不是更加简单了呢？ 由于操作符一旦为空值就会终止，因此也可以使用它来有条件地调用方法或应用条件逻辑
const conditionalProperty = null;
let index = 0;
console.log(conditionalProperty?.[index++]); // undefined
console.log(index); // 0对于方法的调用你可以这样写
object.runsOnlyIfMethodExists?.()例如下面的parent对象，如果我们直接调用parent.getTitle(),则会报Uncaught TypeError: parent.getTitle is not a function错误，parent.getTitle?.()则会终止不会执行
let parent = {
name: "parent",
friends: ["p1", "p2", "p3"],
getName: function() {
console.log(this.name)
}
};
parent.getName?.() // parent
parent.getTitle?.() //不会执行
与无效合并一起使用
提供了一种方法来处理未定义或为空值和表达提供默认值。我们可以使用??运算符，为表达式提供默认值
console.log(undefined ?? 'codercao'); // codercao因此，如果属性不存在，则可以将无效的合并运算符与可选链接运算符结合使用以提供默认值。
let title = data?.children?.[0]?.title ?? 'codercao';
console.log(title); // codercao二、逻辑空分配（?? =）
expr1 ??= expr2逻辑空值运算符仅在空值（空值或未定义undefined）时才将值分配给expr1，表达方式：
x ??= y可能看起来等效于：
x = x ?? y;但事实并非如此！有细微的差别。
空的合并运算符（??）从左到右操作，如果x不为空，则短路。因此，如果x不为null或未定义，则永远不会对表达式y进行求值。因此，如果y是一个函数，它将根本不会被调用。因此，此逻辑赋值运算符等效于
x ?? (x = y);三、逻辑或分配（|| =）
此逻辑赋值运算符仅在左侧表达式为 falsy值时才赋值。Falsy值与null有所不同，因为falsy值可以是任何一种值：undefined，null，空字符串(双引号""、单引号’’、反引号``)，NaN，0。IE浏览器中的 document.all，也算是一个。
语法
x ||= y等同于
x || (x = y)在我们想要保留现有值（如果不存在）的情况下，这很有用，否则我们想为其分配默认值。例如，如果搜索请求中没有数据，我们希望将元素的内部HTML设置为默认值。否则，我们要显示现有列表。这样，我们避免了不必要的更新和任何副作用，例如解析，重新渲染，失去焦点等。我们可以简单地使用此运算符来使用JavaScript更新HTML：
document.getElementById('search').innerHTML ||= '<i>No posts found matching this search.</i>'四、逻辑与分配（&& =）
可能你已经猜到了，此逻辑赋值运算符仅在左侧为真时才赋值。因此：
x &&= y等同于
x && (x = y)最后
本次分享几个优雅的JavaScript运算符使用技巧，重点分享了可选链接运算符的使用，这样可以让我们不需要再编写大量我们例子中代码即可轻松访问嵌套属性。但是IE不支持它，因此，如果需要支持该版本或更旧版本的浏览器，则可能需要添加Babel插件。对于Node.js，需要为此升级到Node 14 LTS版本，因为12.x不支持该版本。
如果你也有优雅的优雅的JavaScript运算符使用技巧，请不要吝惜，在评论区一起交流~
原文链接：https://segmentfault.com/a/1190000039885243
移动应用遗留系统重构（6）- 测试篇
前言
上一篇移动应用遗留系统重构（5）- 重构方法篇我们分享了进行依赖解除的重构流程。主要为4个操作步骤，识别内聚包、解除依赖、移动、验收。同时最后也提出了一个问题，重构时如何保证功能的正确性，不会修改出新问题？
其实这个问题容易但又不简单。容易的是把修改得功能仔细测一篇保证所有功能正常就可以了。不简单的是如何全面、高效、可重复的执行这个过程。我们很容易联想到的方案就是自动化测试。但最大的问题是，对大部分遗留系统来说都是没有任何自动化测试。而且大量的坏味道代码，可测试性低，我们也很难补充充分的自动化测试。那么我们有什么折中的策略吗？
测试策略
我们先来看看Google Android开发者官网上对于测试的介绍，将不同的类型的测试分为三类测试（即小型、中型和大型测试）。
- 小型测试是指单元测试，用于验证应用的行为，一次验证一个类。
- 中型测试是指集成测试，用于验证模块内堆栈级别之间的互动或相关模块之间的互动。
- 大型测试是指端到端测试，用于验证跨越了应用的多个模块的用户操作流程。
前面提到对于遗留单体系统来说通常没有任何自动化测试，并且通常内部结构耦合严重，所以实施中小型的成本非常高。显然对于遗留系统，测试金字塔模型适用度较低。 所以对于遗留系统，可能比较适合的策略模型如下：
对于遗留单体系统，一个可行的思路是先补充中大型的测试，作为基本的冒烟测试，重构优化内部结构后再及时补充中小型测试。
CloudDisk示例
对于我们这个浓缩版的CloudDisk，界面上也比较简单。主要是有一个主界面，主界面上主要为文件、动态、用户。（后续的MV*重构篇会持续补充页面交互及逻辑）
我们可以设计一组UI的测试验证基本的功能。主要的几个测试点如下：
- 主界面能正常运行并显示3个Fragment
- 3个Fragment能正常显示
- 点击登录按钮，能够跳转到登录页面
测试设计的用例如下：
@RunWith(AndroidJUnit4.class)
@LargeTest
public class SmokeTesting {
@Test
public void should_show_fragment_list_when_activity_launch() {
//given
ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);
scenario.onActivity(activity -> {
//when
onView(withText(R.string.tab_user)).perform(click());
//then
List fragments = activity.getSupportFragmentManager().getFragments();
assertThat(fragments.size() == 3);
assertThat(fragments.get(0) instanceof FileFragment);
assertThat(fragments.get(1) instanceof DynamicFragment);
assertThat(fragments.get(2) instanceof UserCenterFragment);
});
}
@Test
public void show_show_file_ui_when_click_tab_file() {
//given
ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);
scenario.onActivity(activity -> {
//when
onView(withText(R.string.tab_file)).perform(click());
//then
onView(withText("Hello file fragment")).check(matches(isDisplayed()));
});
}
@Test
public void show_show_dynamic_ui_when_click_tab_dynamic() {
//given
ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);
scenario.onActivity(activity -> {
//when
onView(withText(R.string.tab_dynamic)).perform(click());
//then
onView(withText("Hello dynamic fragment")).check(matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE)));
});
}
@Test
public void show_show_user_center_ui_when_click_tab_dynamic() {
//given
ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);
scenario.onActivity(activity -> {
//when
onView(withText(R.string.tab_user)).perform(click());
//then
onView(withText("Hello user center fragment")).check(matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE)));
});
}
@Test
public void show_show_login_ui_when_click_login_button() {
//given
ActivityScenario scenario = ActivityScenario.launch(MainActivity.class);
scenario.onActivity(activity -> {
Intents.init();
//when
onView(withId(R.id.fab)).perform(click());
//then
intended(IntentMatchers.hasComponent("com.cloud.disk.platform.login.LoginActivity"));
Intents.release();
});
}
}
复制代码 详细代码见Github提交
我们可以将用例运行在Robolectric上，提高反馈的速度，执行命令如下：
./gradlew testDebug --tests SmokeTesting
复制代码测试执行结果如下：
当然实际的项目里情况更复杂，数据可能来自网络服务、数据库等等。我们还需要进行Mock。后续的MV*重构篇会持续补充常见坏味道示例代码及更多的自动化测试用例。
更多测试框架及设计可以参考Google官方
在 Android 平台上测试应用
总结
这一篇我们介绍了常用的测试分类及遗留系统的测试策略，对于遗留单体系统，一个可行的思路是先补充中大型的测试，作为基本的冒烟测试，重构优化内部结构后再及时补充中小型测试。同时也给CloudDisk补充了一组基础的大型测试作为冒烟测试，作为后续重构的基本守护测试。
下一篇移动应用遗留系统重构（7）- 解耦重构演示篇（一） 我们将基于方法篇的流程开始对CloudDisk进行重构的改造，具体的解耦操作会以视频的方式展示。
参考资料
CloudDisk示例代码
系列链接
大纲
作者：JunBin
链接：https://juejin.cn/post/6954635678982340622
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动应用遗留系统重构（5）- 重构方法篇
前言
上一篇
移动应用遗留系统重构（4）-分析篇 我们根据CloudDisk未来的架构，借助ArchUnit进行架构测试守护以及Intellij的Dependendencies分析出了按照未来的架构设计需要解决的异常依赖。
这一篇开始我们将分享进行依赖解除的重构流程、方法以及常用的工具使用。
重构流程
1.识别内聚的包
对于移动应用通常我们可以通过产品的业务划分进行领域的识别划分。例如CloudDisk这个产品的相对还是比较清晰，业务上主要分为文件、动态及个人中心。
对于部分遗留系统来说，旧代码可能散落在不同的包下，或者原先的代码组织方式是以功能划分，而非业务划分。就像CloudDisk的代码一样，第一步我们得先把相关的业务代码组织到同一包下，这个阶段我们可以先不管是否存在异常依赖，因为只有先组织到一个内聚的包下才方便我们进行依赖分析及代码重构。
2.解除异常依赖
这里我们将介绍几种通用的依赖解除手法。包含下沉、接口提取、路由跳转。
后续的演示篇会通过视频进行具体的操作演示
| 依赖解除手法 | 使用场景 |
|---|---|
| 下沉 | 原本类功能属于Library或者Platform的，直接下沉。例如LogUtil 或 DateUtil等 |
| 接口提取 | 适用于Bundle间有数据或者行为依赖。例如某个BundleA中的classA需要触发BundleB的某个业务行为 |
| 路由跳转 | 适用于UI页面间跳转。例如某个BundleA中的Activity1，需要跳转到BundleB的Activity2 |
重构手法：
- 类下沉
将
具体类移动到适当的 Lib 模块中
在调用模块增加对该 Lib 的依赖
- 接口提取
- 在适当的公用模块中创建空的
接口 - 将调用具体页面类的跳转代码块所在的包中建立新的
实现类实现该接口 - (自动)将
调用代码块通过 Extract method 提取成新方法
如已经是独立方法跳过此步
- (自动)在原调用逻辑所属的类中增加
实现类的成员变量作为delegate
需要预留 Inject 接口，建议采用 Constructor Inject，静态成员提供setter
- (自动)将
新方法调用转移到delegate中
如果是静态方法先通过 Change Method Signature 将 delegate 作为参数传给该方法
- (自动)将新方法 Pull up 到
接口中 - (自动)将
实现类移动到壳程序中 - 在壳程序中实现
实现类的Inject
- 路由跳转
- 在跳转类定义对应的映射Path
- 在调用处使用对应的path进行跳转
3.移动代码及资源
当包的异常依赖全部解耦完后，就可以直接进行移动了。这里我们分享2中常用的代码移动方式。
- Move
这种方式大家应该比较常用，选择一个File或者Directory,按下F6选择希望移动后的目录则可。
但是这种方式会存在一个问题，就是被移动的类如果依赖了其他的类或者资源，移动后会出现依赖异常。
适用场景：移动的File或Directory没有其他的依赖
- Modularize
Modularize能够分析出移动的File存在的相关依赖，并一起关联移动，很好解决Move的痛点，非常适用于跨Module的移动。
选择移动的Module后点击Preview。
这里注意，有一些划线的文件，那是因为这个文件同时被多处引用，如果跟随一起移动，那么其他的地方会报错。所以我们需要将划线的文件先移动至公用的合适位置。待Preview没有任何的文件划线时，就可以进行移动。
4.包解耦验收
- 所有模块编译通过
- 所有新增模块符合模块依赖规则
- 通过架构守护测试
总结
这一篇我们分享了进行依赖解除的重构流程，主要为4个操作步骤，识别内聚包、解除依赖、移动、验收。同时也介绍了Intellij中非常好用的Modularize功能。接下来我们就可以开始动手进行代码重构，但此时我们又面临着另外一个问题，也是很多同学在做重构时经常担心的一个问题。重构时如何保证功能的正确性，不会修改出新问题。
下一篇移动应用遗留系统重构（6）- 测试篇，我们将分享对于单体移动应用遗留系统，如何制定测试策略及有效补充自动化测试，更好为重构保驾护航。
系列链接
大纲
作者：JunBin
链接：https://juejin.cn/post/6952298178095874055
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动应用遗留系统重构（4）-分析篇
前言
上一篇移动应用遗留系统重构（3）-示例篇我们介绍了CloudDisk的业务及代码现状。分享了“理想”（未来的架构设计）与“现实”（目前的代码现状），接下来在我们开始动手进行重构时，我们首先得知道往理想的设计架构演化，中间存在多少问题。一方面作为开始重构的输入，另外一方面我们有数据指标，也能更好评估工作量及衡量进度。
接下来我们将根据架构篇团队采用的架构设计，结合目前的代码，总结分析工具及方法。
架构设计
我们先回忆一下架构篇里团队采用的架构设计。
- 代码复用
- 公共能力复用，有一层专门统一管理应用公用的基础能力，如图片、网络、存储能力、安全等
- 公用业务能力复用，有一层专门统一管理应用的业务通用组件，如分享、推送、登录等
- 低耦合
- 业务模块间通过API方式依赖，不依赖具体的模块实现
- 依赖方向清晰，上层模块依赖下层模块
- 并行研发
- 业务模块支持独立编译调试
- 业务模块独立发布
结合该4层架构、已有的代码，以及业务的后续演化，团队设计的新架构如下
分析工具
ArchUnit
有了架构设计后，我们就能识别代码的边界，这里我们可以通过Archunit进行边界约束描述。我们可以得到2条通用的守护规则。
- 垂直方向，下层模块不能反向依赖上层
- 横向方向，组件之间不能存在相互的依赖
转化为ArchUnit的测试用例如下:
@ArchTest
public static final ArchRule architecture_layer_should_has_right_dependency =layeredArchitecture()
.layer("Library").definedBy("..cloud.disk.library..")
.layer("PlatForm").definedBy("..cloud.disk.platform..")
.layer("FileBundle").definedBy("..cloud.disk.bundle.file..")
.layer("DynamicBundle").definedBy("..cloud.disk.bundle.dynamic..")
.layer("UserBundle").definedBy("..cloud.disk.bundle.user..")
.layer("AllBundle").definedBy("..cloud.disk.bundle..")
.layer("App").definedBy("..cloud.disk.app..")
.whereLayer("App").mayOnlyBeAccessedByLayers()
.whereLayer("FileBundle").mayOnlyBeAccessedByLayers("App")
.whereLayer("DynamicBundle").mayOnlyBeAccessedByLayers("App")
.whereLayer("UserBundle").mayOnlyBeAccessedByLayers("App")
.whereLayer("PlatForm").mayOnlyBeAccessedByLayers("App","AllBundle")
.whereLayer("Library").mayOnlyBeAccessedByLayers("App","AllBundle","PlatForm");
复制代码当然这个用例的执行是失败的，因为我们基本的包结构还没有调整。但有了架构守护测试用例，我们就可以逐步把代码移动到对应的Package中，直到守护用例运行通过为止。
接下来我们先运用IDE工具进行基础的包结构调整，调整后的结构如下
调整后运行ArchUnit测试运行结果如下
这些异常的提示就是我们需要处理的异常依赖。但是ArchUnit的这个提示比较不不友好，接下来我们介绍另外一种分析异常依赖的方式，使用Intellij Dependencies 。
Intellij Dependencies
我们选择对应的Package，选择Analyze菜单，点击Dependencies，可以找出该Package所依赖的相关类。
我们选择dynamic Package进行分析后，发现根据现有的架构约束，存在横向的Bundle依赖需要进行解除依赖。
我是在实际重构过程中，我们可以频繁借助该功能验证耦合解除情况，并且同时通过ArchUnit测试做好守护。
详细代码见Cloud Disk
总结
这一篇我们分享了如何借助工具进行异常依赖的分析。当我们有了未来的架构设计后，可以借助ArchUnit进行架构测试守护，通过Intellij的Dependendencies 我们可以方便以Package或者Class为单位进行依赖分析。
当我们已经分析出需要处理的异常依赖，接下来我们就可以逐步进行重构。下一篇，我们将给大家分享实践总结的一些重构套路，移动应用遗留系统重构（5）- 重构方法篇。
系列链接
大纲
作者：JunBin
链接：https://juejin.cn/post/6950077521790500894
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动应用遗留系统重构（3）-示例篇
前言
上一篇移动应用遗留系统重构（2）-架构篇我们介绍了业内的优秀架构实践以及CloudDisk团队根据业务情况设计的分层架构。
这一篇我们将介绍一个浓缩版的示例，示例中我们设计了一些常见的异常依赖，后续的重构篇我们也将基于这个示例进行操作演示。为了简化代码及对业务上下文的理解，示例中的部分实现都是空实现，重点体现异常的耦合依赖。
仓库地址：CloudDisk
CloudDisk示例
项目概述
CloudDisk是一个类似于Google Drive的云存储应用。该应用主要拥有3大核心业务模块。
- 文件模块:用于管理用户云端文件系统。用户能够上传、下载、浏览文件。
- 动态模块:类似微信朋友圈，用于可以在动态上分享信息及文件
- 个人中心模块:用于管理用户个人信息
问题说明
该项目已经维护超过10年以上，目前有用开发人员100+。代码在一个大单体模块中，约30w行左右，编译时间5分钟以上。团队目前主要面临几个问题。
- 开发效率低，编译时间长，经常出现代码合并冲突
- 代码质量差，经常修改出新问题
- 市场响应慢，需要对齐各个模块进行整包发布
代码分析
代码在一个Module中，且在一个Git仓中管理。采用"MVC"结构，按功能进行划分Package。
包结构如下：
主要包说明：
| 包名 | 功能说明 |
|---|---|
| adapter | ViewPager RecycleView等适配器类 |
| callback | 接口回调 |
| controller | 主要的业务逻辑 |
| model | 数据模型 |
| ui | Activity、Fragment相关界面 |
| util | 公用工具类 |
主要类说明：
| 类名 | 功能说明 |
|---|---|
| MainActivity | 应用主界面，用于加载显示各个模块的Fragment |
| CallBack | 网络接口操作回调 |
| DynamicController | 动态模块主要业务逻辑，包含发布及获取列表 |
| FileController | 文件模块主要业务逻辑，主要包含上传、下载、获取文件列表 |
| UserController | 用户模块主要业务逻辑，主要包含登录，获取用户信息 |
| HttpUtils | 网络请求，用于发送get及post请求 |
| LogUtils | 主要用于进行日志记录 |
详细源码见CloudDisk
为了简化业务上下文理解，代码都是空实现，只体现模块的异常依赖，后续的MV*重构篇会持续补充常见坏味道示例代码。
总结
CloudDisk在业务最初发展的时候，采用了单一Module及简单“MVC”架构很好的支持了业务的发展，但随着业务的演化及人员膨胀，这样的模式已经很难高效的支持业务及团队的发展。
前面我们已经分享了“理想”（未来的架构设计）与“现实”（目前的代码现状），接下来在我们开始动手进行重构时，我们首先得知道往理想的设计架构演化，中间存在多少问题。一方面作为开始重构的输入，另外一方面我们有数据指标，也能评估工作量及衡量进度。
下一篇，我们将给大家分享移动应用遗留系统重构（4）-分析篇。介绍常用的分析工具及框架，并对CloudDisk团队目前的代码进行分析。
系列链接
大纲
作者：JunBin
链接：https://juejin.cn/post/6947855094272491556
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动应用遗留系统重构（2）-架构篇
前言
上一篇移动应用遗留系统重构（1）- 开篇我们分享了移动应用遗留系统常见的问题。那么好的实践或者架构设计是怎样的呢？
这一篇我们将整理业内优秀的移动应用架构设计，包含微信、淘宝、支付宝以及美团外卖。其中的部分产品也经历过遗留系统的重构改造，具有非常好的参考意义。
优秀实践
微信
从微信对外分享的架构演进文章中可知，微信应用其实也是经历了从大单体到模块化的演进。
图片来源 微信Android模块化架构重构实践
我们看下介绍中后续改造后的架构设计。
图片来源 微信Android模块化架构重构实践
设计中提到重构主要3个目标
- 改变通信方式 （API化）
- 重新设计模块 （中心化业务代码回归各自业务）
- 约束代码边界 （pins工程结构，更细粒度管控边界）
我们可以发现重构后架构比原来的单体应用的一些变化。
- 业务模块独立编译调试，耦合度低
- 代码复用高，有统一公共的组件库及kernel
- 模块职责、代码边界清晰，强约束
更多信息可阅读原文，微信Android模块化架构重构实践
手淘
从手机淘宝客户端架构探索实践的分享中介绍到手机淘宝从1.0用单工程编写开始，东西非常简陋；到2.0为索引许多三方库的庞大的单工程；再到3.0打破了单工程开发模式实现业务复用。
图片来源 手机淘宝客户端架构探索实践
淘宝架构主要分为四层，最上层是组件Bundle(业务组件)，往下是容器(核心层)，中间件Bundle(功能封装)，基础库Bundle(底层库)。
文章提到架构演化的一些优点及变化很值得深思。
- 业务复用，减少人力
- 基础复用，做深做精
- 敏捷开发，快速试错
支付宝
在支付宝mPass实践讨论分析一文中，提到支付宝客户端的总体架构图如下。
图片来源 开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨
分享文章中介绍到5层架构设计如下：
最底层是支付宝框架的容器层，包括类加载资源加载和安全模块；
第二层是我们抽离出来的组件层，包括网络库，日志库，缓存库，多媒体库，日志等等，简单说这些是一些通用的能力层；
第三层是我们定制的框架层，这是关键部分，是我们得以实现上千人，上千多个工程共同开发一个 App 的基础。
第四层是基于框架封装出来的业务服务层；
第五层便是具体的业务模块，其中每一个模块都是一个或多个具体的工程;
文章中介绍到关于工程之间的依赖关系的处理比较特别。
在支付宝的架构里，编译参与的部分是和运行期参与的部分是分离的：编译期使用 bundle 的接口包，运行期使用 bundle 包本身。bundle 的接口包是 bundle 包的一部分，即刚才说的 bundle 的代码部分。bundle 的资源包同时打进接口包，在编译期提供给另一个 bundle 引用。
更多信息可阅读原文，开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨
美团
最后看另外一个跨平台技术架构相关的分享，在外卖客户端容器化架构的演进分享中提到了美团外包的整体架构如下。
图片来源 外卖客户端容器化架构的演进
特别的一点是是采用了容器化架构，根据业务场景及PV，支持多种容器技术。在文末的总结提到，容器化架构相对于传统的移动端架构而言，充分地利用了现在的跨端技术，将动态化的能力最大化的赋予业务。通过动态化，带来业务迭代周期缩短、编译的加速、开发效率的提升等好处。同时，也解决了面临着的多端复用、平台能力、平台支撑、单页面多业务团队、业务动态诉求强等业务问题。但对线上的可用性、容器的可用性、支撑业务的线上发布上提出了更加严格的要求。
更多信息可阅读原文，外卖客户端容器化架构的演进
总结
架构是为了解决业务的问题，没有银弹。 但通过这些业内的优秀实践分享，我们可以发现一些优秀的设计范式。
- 代码复用
- 公共能力复用，有专门统一管理应用公用的基础能力，如图片、网络、存储能力、安全等
- 公用业务能力复用，有专门统一管理应用的业务通用组件，如分享、推送、登录等
- 低耦合，高内聚
- 业务模块间通过API方式依赖，不依赖具体的模块实现
- 依赖方向清晰，上层模块依赖下层模块
- 并行研发
- 业务模块支持独立编译调试
- 业务模块独立发布
结合这些特点及CloudDisk团队的业务，团队采用的架构设计如下。
下一篇，移动应用遗留系统重构（3）- 示例篇，我们将继续介绍CloudDisk的业务及团队问题，分析现有的代码。
参考
参考来自阿里云开发者社区，但链接已失效
开篇 | 模块化与解耦式开发在蚂蚁金服 mPaaS 深度实践探讨
系列链接
大纲
作者：JunBin
链接：https://juejin.cn/post/6945313969556946980
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 收起阅读 »
移动应用遗留系统重构（1）- 开篇
前言
2008年9月22日，谷歌正式对外发布第一款Android手机。苹果公司最早于2007年1月9日的MacWorld大会上公布IOS系统。移动应用领域的发展已经超过10年。在App Annie 最新的移动市场报告中分享2020应用下载量已经达到2180亿次，同比增加7%。根据Statista的统计，2020年度Google Play的应用数量为3148932个。
在移动互联网的高速发展及竞争中，更快及更高质量的交付用户，显然尤为重要。但很多产品随着移动互联网的发展，已经迭代超过10年。在这个过程中人员流动、技术债务累计、技术生态更新，使得产生了大量的遗留系统。就像一辆低排量的破旧汽车，再大的马路，技术再好的驾驶员，达到车辆本身的系统瓶颈，速度就很难再提升起来。
遗留系统
在以往的项目中，遇到了大量的这种遗留系统。这些系统具有以下一些特点。
- 大泥球架构，代码量上百万行，开发人员超过100+
- 内部耦合高，代码修改维护牵一发动全身，质量低
- 编译集成调试慢，没有任何自动化测试，开发效率低
- 技术栈陈旧，祖传代码，无人敢动
在这样的背景下，个别少的团队选择重写，当然没有良好的过程管理及方法，好多重写完又成了新的遗留系统。也有的团队选择重构，但目前相关的方法及教程比较少。这里推荐一下《重构（第2版）》，书中有基本的重构手法。另外一本《修改代码的艺术》，书中有很多基于遗留代码开发的示例。但对于开发人员来说，缺少比较贴近移动应用项目实战的重构指导及系统方法。很多团队依旧没有解决遗留系统根本的原因，仅靠不断的堆人，恶性循环。
CloudDisk 演示示例
CloudDisk是一个类似于Google Drive的云存储应用。该应用主要拥有3大核心业务模块，文件、动态及个人中心。
该项目已经维护超过10年以上，目前有用开发人员100+。目前代码在一个大模块中，约30w行左右，编译时间10分钟以上。团队目前主要还面临几个问题。
- 开发效率低
编译时间长，经常出现代码合并冲突。遗留大量技术债务，团队疲于交付需求
- 代码质量差
经常修改出新问题，版本提测问题多，没有任何自动化测试
- 版本发布周期长
往往需要1个月以上，市场反馈响应慢
我们希望通过一个更贴近实际工程项目的浓缩版遗留系统示例，持续解决团队在产品不断迭代中遇到的问题。从架构设计与分析、安全重构、基础生态设施、流水线、编译构建等方面，一步一步介绍如何进行持续演化。我们将通过文章及视频演示的方式进行分享，希望通过这个系列文章，大家可以更系统的掌握移动应用项目中实战的重构技巧及落地方法。
大纲
作者：JunBin
链接：https://juejin.cn/post/6943470229905211422
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
这15个Android开源库，只有经常逛Github的才知道！
哈喽，大家好，我是西哥！
又到了大家最喜欢了的环节--开源库推荐，前面为大家推荐了我收藏的一些非常酷的开源库，受到大家一致好评，还没看过的，请移步至：
【2020年GitHub 上那些优秀Android开源库，这里是Top10！】
本期又为大家带来了哪些有趣的库呢？本期为大家精选了15个有趣又有用的开源，排名不分先后，一起来看看吧！
1. Coil
Coil是Android上的一个全新的图片加载框架，它的全名叫做 coroutine image loader,即协程图片加载库。与传统的图片加载库Glide，Picasso或Fresco等相比。该具有轻量（只有大约1500个方法）、快、易于使用、更现代的API等优势。
它支持GIF和SVG，并且可以执行四个默认转换：模糊，圆形裁剪，灰度和圆角。
示例如下：
imageView.load(“https://www.example.com/image.jpg") {
crossfade(true)
placeholder(R.drawable.image)
transformations(CircleCropTransformation())
}
复制代码并且是全用Kotlin编写，如果你是纯Kotlin项目的话，那么这个库应该是你的首选。
Github地址：github.com/coil-kt/coi…
2. MultiSearchView
该库具有一个非常酷的Search View 动画！
使用非常简单，并且可以自定义，你可以在在styles.xml下添加自定义样式。
示例代码：
<com.iammert.library.ui.multisearchviewlib.MultiSearchView
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
复制代码multiSearchView.setSearchViewListener(object : MultiSearchView.MultiSearchViewListener{
override fun onItemSelected(index: Int, s: CharSequence) {
}
override fun onTextChanged(index: Int, s: CharSequence) {
}
override fun onSearchComplete(index: Int, s: CharSequence) {
}
override fun onSearchItemRemoved(index: Int) {
}
})
复制代码自定义样式：
<!-- Search Text Style. -->
<style name="SearchTextStyle">
<!-- Custom values write to here for SearchEditText. -->
<item name="android:focusable">true</item>
<item name="android:focusableInTouchMode">true</item>
<item name="android:enabled">true</item>
<item name="android:hint">Search</item>
<item name="android:imeOptions">actionSearch</item>
<item name="android:textSize">18sp</item>
<item name="android:maxLength">15</item>
<item name="android:inputType">textCapSentences</item>
<item name="android:textColorHint">#80999999</item>
<item name="android:textColor">#000</item>
</style>
复制代码然后，您应该将样式设置为MultiSearchView下的app：searchTextStyle。
Github地址：github.com/iammert/Mul…
3. CalendarView
CalendarView是一个高度可定制化的日历组件库，用recycleView实现。
它有如下特性：
- 单一或范围选择
- 周历或者月历模式
- 边界日期
- 自定义日历视图
- 水平或者垂直滚动模式
- 完全可定制的视图
该库的文档也非常全面，并包含许多示例。此外，还有一个示例应用程序展示了库的所有功能。
它是用纯Kotlin编写的，并在MIT许可下发布。如果您需要在应用程序中使用日历视图，这是一个不错的选择。
注意：该库通过Java 8+ API使用了java.time类，以便向后兼容，因为这些类是在Java 8中添加的。
因此，需要在app的build.gradle 中添加如下配置：
android {
defaultConfig {
// Required ONLY when setting minSdkVersion to 20 or lower
multiDexEnabled true
}
compileOptions {
// Flag to enable support for the new language APIs
coreLibraryDesugaringEnabled true
// Sets Java compatibility to Java 8
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
dependencies {
coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:<latest-version>'
}
复制代码Github: github.com/kizitonwose…
4. Bubble Navigation
| FloatingTopBarActivity | TopBarActivity |
|---|---|
| BottomBarActivity | EqualBottomBarActivity |
|---|---|
Bubble Navigation是一个轻巧的库，可通过大量自定义选项轻松制作精美的导航栏。
它有很多非常的特性：
针对不同用例的两种类型的
NavigationViews：
BubbleNavigationConstraintView（支持spreadspread，inside, 和packed莫斯）
BubbleNavigationLinearView（允许平均分配，使用权重或packed模式）
高度可定制化
您可以添加小红点，它具有
BubbleToggleView来创建新的UI组件，而不仅仅是导航
示例：
<com.gauravk.bubblenavigation.BubbleNavigationConstraintView
android:id="@+id/top_navigation_constraint"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="380dp"
android:background="@color/white"
android:elevation="4dp"
android:padding="12dp"
app:bnc_mode="spread">
<com.gauravk.bubblenavigation.BubbleToggleView
android:id="@+id/c_item_rest"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:bt_active="true"
app:bt_colorActive="@color/search_active"
app:bt_colorInactive="@color/search_inactive"
app:bt_icon="@drawable/ic_restaurant"
app:bt_shape="@drawable/transition_background_drawable_restaurant"
app:bt_title="@string/restaurant"
app:bt_padding="@dimen/internal_padding"
app:bt_titlePadding="@dimen/title_padding" />
<!-- Add more child items here - max upto 5 -->
</com.gauravk.bubblenavigation.BubbleNavigationConstraintView>
复制代码Github文档很完善，有很多示例，更多用法和属性可去Github了解。
Github:github.com/gauravk95/b…
5. FabFilter
这是一个有趣的项目，它不是一个直接可用的库，而是一个示例应用程序，展示了使用和不使用 MotionLayout两种方式来实现的高级UI动画。
详细的实现细节可以看看Medium上的系列文章：
“Complex UI/Animations on Android”
“Complex UI/Animations on Android — featuring MotionLayout”
Github:github.com/nikhilpanju…
6.android-showcase
android-showcase是一个非常优秀的开源项目，它是一个展示应用程序，展示了如何使用Kotlin和最新的Jetpack 技术栈来开发一个APP。
该项目为您带来了一系列最佳实践，工具和解决方案：
- 100% Kotlin
- 现代架构 (feature modules, clean architecture, Model-View-ViewModel, Model-View-Intent)
- Android Jetpack组件
- 单Activity模式，使用Navigation导航
看完这个项目，在模块化，Clean体系结构，测试、设置CI / CD工具，等方面，你将会受到启发。感谢作者的开源。
Github：github.com/igorwojda/a…
7. Croppy
Croppy是一个Android图片裁剪库。
它有很多强大的特性：
- 双指缩放
- 裁剪任意大小
- 按照长宽比例裁剪
- 显示裁剪后的Bitmap
- 自动居中裁剪
- 全面的动画使用体验
更多使用细节请看Github。
Github: github.com/lyrebirdstu…
8. RubberPicker
一个炫酷的、有趣的SeekBar动画库。
RubberPicker库包含RubberSeekBar和RubberRangePicker，其灵感来自Cuberto的iOS橡胶范围选择器。
使用示例：
布局文件中配置
<com.jem.rubberpicker.RubberSeekBar
...
app:minValue="20"
app:maxValue="80"
app:elasticBehavior="cubic"
app:dampingRatio="0.3"
app:stiffness="300"
app:stretchRange="24dp"
app:defaultThumbRadius="16dp"
app:normalTrackWidth="4dp"
app:highlightTrackWidth="8dp"
app:normalTrackColor="#AAAAAA"
app:highlightTrackColor="#BA1F33"
app:defaultThumbInsideColor="#FFF"
app:highlightDefaultThumbOnTouchColor="#CD5D67"/>
<!-- Similar attributes can be applied for RubberRangePicker as well-->
<com.jem.rubberpicker.RubberRangePicker
...
app:minValue="0"
app:maxValue="100"
app:elasticBehavior="linear"
app:dampingRatio="0.4"
app:stiffness="400"
app:stretchRange="36dp"
app:defaultThumbRadius="16dp"
app:normalTrackWidth="4dp"
app:highlightTrackWidth="8dp"
app:normalTrackColor="#AAAAAA"
app:highlightTrackColor="#BA1F33"
app:defaultThumbInsideColor="#CFCD5D67"
app:highlightDefaultThumbOnTouchColor="#CD5D67"/>
复制代码或者，在代码中动态配置：
val rubberSeekBar = RubberSeekBar(this)
rubberSeekBar.setMin(20)
rubberSeekBar.setMax(80)
rubberSeekBar.setElasticBehavior(ElasticBehavior.CUBIC)
rubberSeekBar.setDampingRatio(0.4F)
rubberSeekBar.setStiffness(1000F)
rubberSeekBar.setStretchRange(50f)
rubberSeekBar.setThumbRadius(32f)
rubberSeekBar.setNormalTrackWidth(2f)
rubberSeekBar.setHighlightTrackWidth(4f)
rubberSeekBar.setNormalTrackColor(Color.GRAY)
rubberSeekBar.setHighlightTrackColor(Color.BLUE)
rubberSeekBar.setHighlightThumbOnTouchColor(Color.CYAN)
rubberSeekBar.setDefaultThumbInsideColor(Color.WHITE)
val currentValue = rubberSeekBar.getCurrentValue()
rubberSeekBar.setCurrentValue(currentValue + 10)
rubberSeekBar.setOnRubberSeekBarChangeListener(object : RubberSeekBar.OnRubberSeekBarChangeListener {
override fun onProgressChanged(seekBar: RubberSeekBar, value: Int, fromUser: Boolean) {}
override fun onStartTrackingTouch(seekBar: RubberSeekBar) {}
override fun onStopTrackingTouch(seekBar: RubberSeekBar) {}
})
//Similarly for RubberRangePicker
val rubberRangePicker = RubberRangePicker(this)
rubberRangePicker.setMin(20)
...
rubberRangePicker.setHighlightThumbOnTouchColor(Color.CYAN)
val startThumbValue = rubberRangePicker.getCurrentStartValue()
rubberRangePicker.setCurrentStartValue(startThumbValue + 10)
val endThumbValue = rubberRangePicker.getCurrentEndValue()
rubberRangePicker.setCurrentEndValue(endThumbValue + 10)
rubberRangePicker.setOnRubberRangePickerChangeListener(object: RubberRangePicker.OnRubberRangePickerChangeListener{
override fun onProgressChanged(rangePicker: RubberRangePicker, startValue: Int, endValue: Int, fromUser: Boolean) {}
override fun onStartTrackingTouch(rangePicker: RubberRangePicker, isStartThumb: Boolean) {}
override fun onStopTrackingTouch(rangePicker: RubberRangePicker, isStartThumb: Boolean) {}
})
复制代码更多、更详细的使用请看Github。
Github：github.com/Chrisvin/Ru…
9. Switcher
一个炫酷的Switcher 切换动画库，真是的太可爱了，我前面也写过文章专门介绍过：
它的灵感来自于 Dribble上Oleg Frolov 的设计。
Github: github.com/bitvale/Swi…
10. StfalconImageViewer
StfalconImageViewer是一个图片查看库，
该库简单且可定制。它包含一个全屏图像查看器，具有共享的图像过渡支持，捏合缩放功能以及滑动手势来关闭手势。
Github文档说明了如何使用每个功能。同样值得注意的是：该库与所有最受欢迎的图像处理库（例如Picasso，Glide等）兼容。
所有可配置项如下：
StfalconImageViewer.Builder<String>(this, images, ::loadImage)
.withStartPosition(startPosition)
.withBackgroundColor(color)
//.withBackgroundColorResource(R.color.color)
.withOverlayView(view)
.withImagesMargin(R.dimen.margin)
//.withImageMarginPixels(margin)
.withContainerPadding(R.dimen.padding)
//.withContainerPadding(R.dimen.paddingStart, R.dimen.paddingTop, R.dimen.paddingEnd, R.dimen.paddingBottom)
//.withContainerPaddingPixels(padding)
//.withContainerPaddingPixels(paddingStart, paddingTop, paddingEnd, paddingBottom)
.withHiddenStatusBar(shouldHideStatusBar)
.allowZooming(isZoomingAllowed)
.allowSwipeToDismiss(isSwipeToDismissAllowed)
.withTransitionFrom(targeImageView)
.withImageChangeListener(::onImageChanged)
.withDismissListener(::onViewerDismissed)
.withDismissListener(::onViewerDismissed)
复制代码更详细的使用请看Github。
Github: github.com/stfalcon-st…
11. Broccoli
Broccoli是一个show View Loading 库，也就是我常说的骨架屏，在内容加载的时候，显示一个占位符。
该库带有很平滑的动画效果，你可以配合RecyclerView一起使用，等待加载内容时，再也不枯燥了。
示例：
Broccoli broccoli = new Broccoli();
//add the default style placeholder
broccoli.addPlaceholders('activity', 'view_id', 'view_id');
or
//add the default style placeholder
broccoli.addPlaceholders('view1', 'view2', 'view3');
or
//add the custom style placeholder
broccoli.addPlaceholder(new PlaceholderParameter.Builder()
.setView('view')
.setAnimation('scaleAnimation');
.setDrawable(DrawableUtils.createRectangleDrawable(placeHolderColor, 0))
.build());
or
//add the custom style placeholder with gradient animation
broccoli.addPlaceholder(new PlaceholderParameter.Builder()
.setView('view')
.setDrawable(new BroccoliGradientDrawable(Color.parseColor("#DDDDDD"),
Color.parseColor("#CCCCCC"), 0, 1000, new LinearInterpolator())
.build());
broccoli.show();
复制代码更多使用请看Github。
Github: github.com/samlss/Broc…
12. Orbit MVI
这是一个用于Kotlin和Android的Model-View-Intent （MVI）框架。它的灵感来自Jake Wharton，RxFeedback和Mosby的“Managing State with RxJava”。
根据ReadMe所说：
Orbit在您的redux实现周围提供了尽可能小的结构，以使其易于使用，但您仍可以使用RxJava的强大功能。
redux系统可能如下所示：
data class State(val total: Int = 0)
data class AddAction(val number: Int)
sealed class SideEffect {
data class Toast(val text: String) : SideEffect()
}
class CalculatorViewModel : OrbitViewModel<State, SideEffect> (State(), {
perform("addition")
.on<AddAction>()
.sideEffect { post(SideEffect.Toast("Adding ${event.number}")) }
.reduce {
currentState.copy(currentState.total + event.number)
}
...
})
复制代码activity / fragment 中：
// Example of injection using koin, your DI system might differ
private val viewModel by viewModel<CalculatorViewModel>()
override fun onCreate() {
...
addButton.setOnClickListener { viewModel.sendAction(AddAction) }
}
override fun onStart() {
viewModel.connect(this, ::handleState, ::handleSideEffect)
}
private fun handleState(state: State) {
...
}
private fun handleSideEffect(sideEffect: SideEffect) {
when (sideEffect) {
is SideEffect.Toast -> toast(sideEffect.text)
}
}
复制代码详细使用请看Github。
Github: github.com/babylonheal…
13. IndicatorScrollView
| IndicatorScrollView | IndicatorScrollView |
|---|---|
该库为NestedScrollView添加了逻辑，使它可以在滚动时，更改对指示器进行动态响应。
README文件包含开始项目所需的所有信息，例如如何使用IndicatorScrollView，IndicatorView和IndicatorItem。目前,它的版本为1.0.2，是根据Apache 2.0许可发布的。它支持API 16及更高版本。
文档示例很详细，更多使用相关请看Github。
Github： github.com/skydoves/In…
14. Cyanea
Cyanea 是一个Android 主题引擎库。
它允许那你动态更换应用主题，它内置了很多主题如：
Theme.Cyanea.DarkTheme.Cyanea.Dark.LightActionBarTheme.Cyanea.Dark.NoActionBarTheme.Cyanea.LightTheme.Cyanea.Light.DarkActionBarTheme.Cyanea.Light.NoActionBar
更多详细信息请看Github。
Github: github.com/jaredrummle…
15. Android MotionLayout Carousel
这是一个示例项目，它展示了如何使用MotionLayout来实现一个炫酷的轮播图。
文档几乎没有任何说明，但是如果你最近也在探索MotionLayout，这将是一个很好示例。
Github: github.com/faob-dev/Mo…
总结
以上就是本期的开源项目推荐，如果你也有好玩的、有趣的、强大的开源项目，也可以推荐给西哥，欢迎评论区留言讨论。
作者：依然范特稀西
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
收起阅读 »
