一、异常体系

1、error/exception

异常是 Throwable 这个父类实现的，下面有两大子类，Error与Exception

Error表示错误，exception表示异常

Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，

Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

2、unckecked exception/checked exception

非检查异常（unckecked exception）：

Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理 。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

检查异常（checked exception）：

除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。如SQLException , IOException,ClassNotFoundException 等。

二、异常使用

1、运行java异常处理机制

1. try…catch语句
2. finaly 任何情况下都会执行（健壮性）
3. throws 方法声明处抛出多个异常，用逗号隔开【public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN】
4. throw 抛出异常

2、异常处理原理

java虚拟机用方法调用栈（method invocation stack）来跟踪每个线程中一系列的方法调用过程。该堆栈保存了每个调用方法的本地信息（比如方法的局部变量）。每个线程都有一个独立的方法调用栈。对于Java应用程序的主线程，堆栈底部是程序的入口方法main()。当一个新方法被调用时，Java虚拟机把描述该方法的栈结构置入栈顶，位于栈顶的方法为正在执行的方法。

当一个方法正常执行完毕，Java虚拟机会从调用栈中弹出该方法的栈结构，然后继续处理前一个方法。如果在执行方法的过程中抛出异常，则Java虚拟机必须找到能捕获该异常的catch代码块。它首先查看当前方法是否存在这样的catch代码块，如果存在，那么就执行该catch代码块；否则，Java虚拟机会从调用栈中弹出该方法的栈结构，继续到前一个方法中查找合适的catch代码块。在回溯过程中，如果Java虚拟机在某个方法中找到了处理该异常的代码块，则该方法的栈结构将成为栈顶元素，程序流程将转到该方法的异常处理代码部分继续执行。当Java虚拟机追溯到调用栈的底部的方法时，如果仍然没有找到处理该异常的代码块，按以下步骤处理。

（1）调用异常对象的printStackTrace()方法，打印来自方法调用栈的异常信息。

（2）如果该线程不是主线程，那么终止这个线程，其他线程继续正常运行。如果该线程是主线程（即方法调用栈的底部为main()方法），那么整个应用程序被终止。

总结：方法进栈，只要没运行完就一直进栈，运行完出栈，一旦出现问题，找catch，当前代码块没找到就出栈，找到执行catch，未找到判断是否是主线程，不是则杀死当前线程，其他安全，是则退出。

3、异常流程的运行过程

finaly不执行的情况：

try{

      System.out.println("try");

      System.exit(0);

}catch (Exception e){

}finally {

      System.out.println("finally");

}

System.exit(0);关闭虚拟机，不会执行finally

catch块中有catch

public static void bar2()

    {

        try {

            System.out.println("try");

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            throw new NullPointerException();

        }finally {

            System.out.println("finally");

     }



public static void main(String[] args){

        try {

            bar2();

        }catch (Exception e){

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

        }

    }



执行结果

try

catch

finally

out catch

finally代码块会在return之前执行：

public static void main(String[] args){        

   int i = bar3();

   System.out.println(""+i);

}



try{

    return 1;

} catch (Exception e){

    System.out.println("catch");

} finally{

    System.out.println("finally");

}

return 0;



输出：

catch

finally

1



但是无法在finaly中改变返回值

public static int bar3(){

        int a = 4;

        try{

            return a;

        } catch (Exception e){

            System.out.println("catch");

        } finally{

            a++;

            System.out.println("finally");

        }

        return a;

    }



输出：

finally

4

finally会在return前执行，但也无法改变return变量的值。

finally中的return 会覆盖 try 或者catch中的返回值。

 int m = foo();

        System.out.println(""+m);

        int n = bar();

        System.out.println(""+n);



    }





    public static int foo() {

        try{

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            return 1;

        } finally{

            System.out.println("finally");

            return 2;

        }



    }



    public static int bar()

    {

        try {

            System.out.println("try");

            return 1;

        }finally {

            System.out.println("finally");

            return 2;

        }

    }



输出：

catch

finally

2

try

finally

2

finally中有return 会导致catch中的异常丢失：

 public static int bar2()

    {

        try {

            System.out.println("try");

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            throw new NullPointerException();

        }finally {

            System.out.println("finally");

            return 1;



        }

    }

结果：finally中绝对不要使用return语句

    public static int getSignature(Context context) {

        PackageManager pm = context.getPackageManager();

        PackageInfo pi;

        StringBuilder sb = new StringBuilder();

        // 获取签名信息

        try {

            pi = pm.getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES);

            Signature[] signatures = pi.signatures;

            for (Signature signature : signatures) {

                sb.append(signature.toCharsString());

            }

        } catch (PackageManager.NameNotFoundException e) {

            e.printStackTrace();

        }

        return sb.toString().hashCode();

    }

复制代码

    int signature = getSignature(getApplicationContext());

    if(!MD5Util.getMD5(String.valueOf(signature)).equals("发布时签名值")){

        // 可能被重编译了，需要退出

        android.os.Process.killProcess(android.os.Process.myPid());

    }

复制代码

    public static long getApkCRC(Context context) {

        ZipFile zf;

        try {

            zf = new ZipFile(context.getPackageCodePath());

            // 获取apk安装后的路径

            ZipEntry ze = zf.getEntry("classes.dex");

            return ze.getCrc();

        }catch (Exception e){

            return 0;

        }

    }

复制代码

    String srcStr = MD5Util.getMD5(String.valueOf(CommentUtils.getApkCRC(getApplicationContext())));

    if(!srcStr.equals(getString(R.string.classes_txt))){

        // 可能被重编译了，需要退出

        android.os.Process.killProcess(android.os.Process.myPid());

    }

复制代码

invoke-static {v0}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;



    move-result-object v0



    invoke-static {v0}, Lcom/lcmhy/c/a/d;->a(Ljava/lang/String;)Ljava/lang/String;



    move-result-object v0



    const-string v1, "F010AF8CFE611E1CC74845F80266"



    invoke-virtual {v0, v1}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z



    move-result v0



    if-nez v0, :cond_1

复制代码

    public static int getSignature(Context context) {

        PackageManager pm = context.getPackageManager();

        ...

        // 获取签名信息

        pi = pm.getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES);

        ...

    }

复制代码

    public void hookGetPackageInfo(Application app) throws Exception {

        Class clzActivityThread = Class.forName("android.app.ActivityThread");

        Method methodGetPackageManager = clzActivityThread.getDeclaredMethod("getPackageManager");

        methodGetPackageManager.setAccessible(true);

        Object sPackageManager = methodGetPackageManager.invoke(null);

        // 动态代理

        Class clzIPackageManager = Class.forName("android.content.pm.IPackageManager");

        Object proxy = Proxy.newProxyInstance(clzActivityThread.getClassLoader()

                , new Class[]{clzIPackageManager}

                , new PackageManagerProxy(app, sPackageManager));

        // 替换原sPackageManager

        Field filedIPackageManager = clzActivityThread.getDeclaredField("sPackageManager");

        filedIPackageManager.setAccessible(true);

        filedIPackageManager.set(null, proxy);

    }

复制代码

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if (method.getName().equals("getPackageInfo")) {

            String packageName = "";

            if (null != args && args.length > 0 && args[0] instanceof String) {

                packageName = (String) args[0];

            }

            final PackageInfo packageInfo;

            if (mApplication.getPackageName().equals(packageName)

                    && null != (packageInfo = (PackageInfo) method.invoke(mRealPackageManager, args))) {

                final byte[] b = null; // 原APK签名

                Signature signature = new Signature(b);

                if (null == packageInfo.signatures) {

                    packageInfo.signatures = new Signature[1];

                }

                packageInfo.signatures[0] = signature;

                return packageInfo;

            }

        }

        return method.invoke(mRealPackageManager, args);

    }

复制代码

作者：矛盾的阿呆i
链接：https://juejin.cn/post/6947234550879617037
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

    10:    invokevirtual #22 //Method ...A.hello:()V

复制代码

    public int a() {

        int a = 10;

        int b = 20;

        return (a + b) * 100;

    }

复制代码

   public int a();

    Code:

       0: bipush        10

       2: istore_1

       3: bipush        20

       5: istore_2

       6: iload_1

       7: iload_2

       8: iadd

       9: bipush        100

      11: imul

      12: ireturn

复制代码

作者：矛盾的阿呆i
链接：https://juejin.cn/post/6945253090056470541
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1    private static int getNum(int n) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            currentNum += i*i;

5        }

6        return currentNum;

7    

1    private static void getNum(int n) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            for(int j = 0; j < n; j++) {

5                currentNum++;

6            }

7        }

8   

1    private static void getNum(int n) {

2        int currentNum = 0;

3        for(int k = 0; k < n; k++) {

4            currentNum++;

5        }

6        for(int i = 0; i < n; i++) {

7            for(int j = 0; j < n; j++) {

8                currentNum++;

9            }

       }

   

1        if(condition) {

2            S1

3        } else {

4            S2

5        }

1    private static void getNum(int n) {

2        int currentNum = 0;

3        currentNum++;

4        if(currentNum > 0) {

5            currentNum--;

6        }

7    

1    private static void getNum(int n, int m) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            currentNum++;

5        }

6        for(int j = 0; j < m; j++) {

7            currentNum++;

8        }

9  

1    private static void getNum(int n) {

2        int currentNum = 1;

3        while (currentNum <= n) {

4            currentNum *= 2;

5        }

6    

1    private static void getNum(int n) {

2        int currentNum = 1;

3        for(int i = 0; i < n; i++, currentNum = 1) {

4            while (currentNum <= n) {

5                currentNum *= 2;

6            }

7        }

8   

1    private static void getNum(int n) {

2        int i = 0;

3        for(; i<n; i++){

4            i*=2;

5        }

6    

1    private static void getNum(int n) {

2        int i = 0;

3        int[] array = new int[n];

4        for(; i<array.length; i++){

5            i*=2;

6        }

7    

作者：矛盾的阿呆i
链接：https://juejin.cn/post/6938284594076581902
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Swift 5.0 都发布这么久了，而泛型作为该语言的重要特性，还是非常有必要了解一下的。
在 Swift 泛型的运用几乎随处可见，在系统层面，Swift 标准库是通过泛型代码构建出来的，Swift 的数组和字典类型都是泛型集。在主流的轮子里，也是有大量的泛型使用。使用泛型可以提审代码的复用性。
下面就通过实例看看我们的代码怎么写：

1、函数中使用泛型
举个简单的例子哦，比如现在有个简单的需求，就是写一个方法，这个方法需要把传过来的整数参数打印出来。

简单需求卡卡的代码就出来啦:

/// 打印一个整形数字
func myPrintInt(arg:Int){
     print(arg)
}

看着没啥毛病哦，产品姥爷又说我现在这个方法要支持字符串。

简单再给添加一个方法好啦:

func myPrintString(arg:String){
     print(arg)
}

产品：现在要支持Float、Array、Dictionary ......

这也好办啊：

// 打印任何东西
func myPrintAny(arg:Any){
     print(any1)
}

很好，现在我要你传进去两个参数，而且参数类型要一致，你要怎么写。

下面的写法可以不？参数靠大家自觉。

//参数类型千万要一样啊。。。。。
    func myPrintAny(any1:Any, any2:Any){
        print(any1)
        print(any2)
    }

写成这样的话就可以那赔偿走人啦。

这时候就应该使用泛型了。

// 打印任何东西
    func myPrint<T>(any1:T, any2:T){
        print(any1)
        print(any2)
    }

方法的使用:

myPrint(any1: 1, any2: 1)
        myPrint(any1: "1", any2: "1")
        myPrint(any1: ["1","2"], any2: ["3","4"])

这里就可以看出泛型的优势所在了，大大提升了代码的可复用性。而且同时也提升了代码的安全性。

泛型和Any的区别
从表面上看，这好像和泛型极其相似。Any 类型和泛型两者都能用于定义接受两个不同类型参数的函数。然而，理解两者之间的区别至关重要：泛型可以用于定义灵活的函数，类型检查仍然由编译器负责；而 Any 类型则可以避开 Swift 的类型系统 (所以应该尽可能避免使用)。

2、类中泛型
实现一个栈，栈里边的元素可以是任何类型，但是所有元素又必须是同一种类型，使用泛型实现的代码就是这样的。

//类作用域
class YJKStack<T>: NSObject {
    //栈空间
    private var list:[T] = []
    
    //进栈
    public func push(item:T){
        list.append(item)
    }
    
    //出栈
    public func pop() -> T{
        return list.removeLast()
    }
}

当你扩展一个泛型类的时候，原始类型定义中声明的类型参数列表在扩展里是可以使用的，并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用。

简单说就是类中的泛型，在其扩展中也是可以进行使用的。

extension YJKStack{
    /// 获取栈顶元素
    public func getLast() -> T?{
        return list.last
    }
}

3、泛型类型约束
在实际运用中，我们的参数虽然可以不是特定的类，但是通常需要这个参数要实现某个协议或者是某个类的子类。这时候就要给泛型添加约束了，代码就是下面这一堆喽

//class YJKProtocolStack<T: A&B>  须实现多个协议的话，用 & 符号链接就好啦。
class YJKProtocolStack<T: A>: NSObject {
    //栈空间
    private var list:[T] = []
    
    //进栈
    public func push(item:T){
        list.append(item)
    }
    
    //出栈
    public func pop() -> T{
        return list.removeLast()
    }
}

protocol A {}

protocol B {}

看了上面的代码，可能有的小伙伴就迷茫啦，既然有YJKProtocolStack<T: A&B>， 为啥没有 YJKProtocolStack<T: A|B>呢，其实想想就可以明白，如果用 | 的话，T 表示的就不是一个指定的类型啦，这样和泛型的定义是不一致的。

4、关联类
在类及函数里都知道泛型怎么玩了，那么在协议里怎么用啦，是不是和类是一样的呢，写个代码看一下：

//Protocols do not allow generic parameters; use associated types instead
//一敲出来，编译器就提示你错误啦，并且告诉你怎么写了。
protocol C<T> {

}

//正确的写法就是下面这样的哦
protocol C {
    // Swift 中使用 associatedtype 关键字来设置关联类型实例
    // 具体类型由实现类来决定
    associatedtype ItemType
    
    func itemAtIndex(index:Int) -> ItemType
    
    func myPrint(item:ItemType)
    
    // 局部作用域的泛型和类的写法是一样的。
    func test<T>(a:T)
}

//协议的泛型约束
protocol D {
    associatedtype ItemType:A
}

再来看看实现类怎么玩：

//遵循了 C 协议的类
class CClassOne<T>:C{
    
    //要指定 C 协议中， ItemType 的具体类型
    typealias ItemType = T
    
    public var list:[ItemType] = []
    
    //协议方法的实现
    func itemAtIndex(index:Int) -> ItemType{
        return list[index]
    }
    
    func myPrint(item:ItemType){
        
    }
    
    func test<T>(a: T) {
        
    }
}

//实现2
class CClassTwo:C{
    
    typealias ItemType = Int
    
    public var list:[ItemType] = []
    func itemAtIndex(index:Int) -> ItemType{
        return list[index]
    }
    
    func myPrint(item:ItemType){
        
    }
    
    func test<T>(a: T) {
        
    }
}

通过上面两个例子可以看出，只要在实现类中 指定 ItemType 的类型就好啦。这个类型 还可以是个泛型，也可以是具体的数据类型。

还有一点要讲的就是结构体中使用泛型和类是完全一样的处理哦。

5、Where 语句
Where 其实也是做类型约束的，你可以写一个where语句，紧跟在在类型参数列表后面，where语句后跟一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型间的等价(equality)关系。

看看下面几个代码就行啦，不多说了

func test4<T:A>(arg1:T){}
    func test5<T>(arg1:T) where T:A{}
    // 上面两个方法的作用是一模一样的

    //这个方法 arg1 和 arg2 只需是实现 C 协议的对象就好啦
    func test6<T1:C, T2:C>(arg1:T1, arg2:T2){}
   
    //这个方法 arg1 和 arg2 需要实现 C 协议, 并且 T1 与 T2 的泛型类型要一致
    func test7<T1:C, T2:C>(arg1:T1, arg2:T2) where T1.ItemType == T2.ItemType{}

    //这个方法 arg1 和 arg2 需要实现 C 协议, && T1 与 T2 的泛型类型要一致 && T1 的泛型 遵循A协议
    func test8<T1:C, T2:C>(arg1:T1, arg2:T2) where T1.ItemType == T2.ItemType, T1.ItemType:A{}

本文写到这里就没结束啦，简单介绍啦泛型在 Swift 中的使用，大家想要深入理解泛型，想要融会贯通、运用自如，还需要大家找时间多看看大神写的代码。

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

名词解释
原子：
同一时间只允许一个线程访问

临界区：
指的是一块对公共资源进行访问的代码，并非一种机制或是算法。

自旋锁：
是用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。 自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。

互斥锁（Mutex）：
是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。
当线程来到临界区，获取不到锁，就会去睡眠主动让出时间片，让出时间片会导致操作系统切换到另一个线程，这种上下文的切换也耗时

读写锁：
是计算机程序的并发控制的一种同步机制，也称“共享-互斥锁”、多读者-单写者锁) 用于解决多线程对公共资源读写问题。
读操作可并发重入，写操作是互斥的。 读写锁通常用互斥锁、条件变量、信号量实现。

信号量（semaphore）：
是一种更高级的同步机制，互斥锁可以说是semaphore在仅取值0/1时的特例。信号量可以有更多的取值空间，用来实现更加复杂的同步，而不单单是线程间互斥。

条件锁：
就是条件变量，当进程的某些资源要求不满足时就进入休眠，也就是锁住了。
当资源被分配到了，条件锁打开，进程继续运行。

递归锁：
递归锁有一个特点，就是同一个线程可以加锁N次而不会引发死锁。

互斥锁 ：

互斥锁：线程会从sleep（加锁）——>running（解锁），过程中有上下文的切换，cpu的抢占，信号的发送等开销。

1. NSLock
是 Foundation 框架中以对象形式暴露给开发者的一种锁（Foundation框架同时提供了NSConditionLock，NSRecursiveLock，NSCondition）
NSLock 内部封装了 pthread_mutex 属性为 PTHREAD_MUTEX_ERRORCHECK 它会损失一定的性能来换错误提示。
NSLock 比 pthread_mutex 要慢，因为他还要经过方法调用，但是有缓存多次调用影响不大

NSLock定义如下：

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end
@interface NSLock : NSObject  {
@private
    void *_priv;
}
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;
@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));
@end

lock 和 tryLock 方法都会请求加锁， 唯一不同的是 trylock 在没有获得锁的时候可以继续做一些任务和处理，lockBeforeDate方法也比较简单，就是在limit时间点之前获得锁，没有拿到返回NO。

2. pthread_mutex :
pthread 表示 POSIX thread，定义了一组跨平台的线程相关的 API，pthread_mutex 表示互斥锁。
互斥锁的实现原理与信号量非常相似，不是使用忙等，而是阻塞线程并睡眠，需要进行上下文切换，性能不及信号量。

// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
// 初始化锁
pthread_mutex_init(&(_ticketMutex), &attr);
// 销毁属性
pthread_mutexattr_destroy(&attr);

/*
* Mutex type attributes
*/
#define PTHREAD_MUTEX_NORMAL        0
#define PTHREAD_MUTEX_ERRORCHECK    1 // NSLock 使用
#define PTHREAD_MUTEX_RECURSIVE        2 // 递归锁
#define PTHREAD_MUTEX_DEFAULT        PTHREAD_MUTEX_NORMAL

备注：我们可以不初始化属性，在传属性的时候直接传NULL，表示使用默认属性 PTHREAD_MUTEX_NORMAL。pthread_mutex_init(mutex, NULL);

3. @synchronized :
@synchronized要一个参数，这个参数相当于信号量

// 用在防止多线程访问属性上比较多
- (void)setTestInt:(NSInteger)testInt {
    @synchronized (self) {
        _testInt = testInt;
    }
}

自旋锁 ：
实现原理 ： 保护临界区只有一个线程可以访问
伪代码 ：

do {  
    Acquire Lock  // 获取锁
        Critical section  // 临界区
    Release Lock  // 释放锁        
        Reminder section // 不需要锁保护的代码
}

实现思路很简单，理论上定义一个全局变量，用来表示锁的状态即可

bool lock = false; // 一开始没有锁上，任何线程都可以申请锁  
do {  
    while(lock); // 如果 lock 为 true 就一直死循环，相当于申请锁
    lock = true; // 挂上锁，这样别的线程就无法获得锁
        Critical section  // 临界区
    lock = false; // 相当于释放锁，这样别的线程可以进入临界区
        Reminder section // 不需要锁保护的代码        
}

有一个问题就是一开始有多个线程执行 while 循环， 他们都不会在这里卡住，而是继续执行，这样就无法保证锁的可靠性了，解决思路很简单，就是确保申请锁的过程是原子的。

bool lock = false; // 一开始没有锁上，任何线程都可以申请锁  
do {  
    while(test_and_set(&lock); // test_and_set 是一个原子操作
        Critical section  // 临界区
    lock = false; // 相当于释放锁，这样别的线程可以进入临界区
        Reminder section // 不需要锁保护的代码        
}

前言
相信大家在开发中都遇到过,有些隐秘信息需要做加密传输的场景.
A:你就把 XXX 做一下base64加密传过来就行

这些问题相信大家都遇到过,那么在实际开发中我们应该如何选择加密方法呢?

加密
这里我就直接抛出来几个加密规则

• AES 对称加密,双方只有同一个秘钥key

• RSA 非对称加密,生成一对公私钥.

首先要明确一点, 即使做了加密也不能保证我们的信息就是绝对安全的,只是尽可能的提升破解难度,加密算法的实现都是公开的,所以秘钥如何安全的存储是我们要重点考虑的问题.

关于这两种加密算法大家可以网上查一下原理,这里我不介绍原理,只介绍给大家特定场景下如何选择最优的加密规则,以及一些小Tips.

AES
对称加密,很好理解,生成唯一秘钥key,双方本别可以用key做加密/解密.是比较常用的加密首段,AES只是一种加密规则,具体的加密还有很多种,目前主流使用的是AES/GCM.

RSA
非对称加密,生成一对秘钥,public key/private key,
加解密使用时: public key加密, private key解密.
签名验证时 : private key签名 , public key 验签

这里说一下实际案例:

某某公司,2B的后台支付接口,突然有一天一个商家反馈为什么我账户里钱都没有了,通过日志一查发现都是正常操作刷走了.而某公司并没有办法证明自己的系统是没问题的.理论上这个接口的key下发给商户,但是某某公司也是有这个key的,所以到底是谁泄漏了key又是谁刷走了账户里的钱,谁也无法证明.

这里我们要想一个问题,我们要怎么做才能防止出现此类问题后,商户过来说不是我刷的钱,寻求赔偿的时候, 拿出证据打发他们?

这个问题就可以利用RSA来解决,在接入公司生成APP key 要求接入方自己生成一对RSA秘钥,然后讲 public key上传给我们, private key由接入方自己保存, 而我们只需要验证订单中的签名是否是由private key签名的,而非其他阿猫阿狗签名的订单. 如果出现了上诉问题,那么说明接入方的private key泄漏与我们无关,这样我们就能防止接入方抵赖.

完整性校验.防串改

很多情况下我们需要对数据的完整性做校验, 比如对方发过来一个文件, 我们怎么知道这个问题件就是源文件, 而非被别人恶意拦截串改后的问题?

早些年大家下载程序的时候应该会看到,当前文件的md5值是XXXXX,这个就是为了防止文件被修改的存在的.早期我们都是用md5/sha1来做完整性校验,后来由sha1升级出现了sha256.大家可能不知道应该如何选择.

下面是一个经典故事
Google之前公开过两个不同的PDF,而它们拥有相同的sha1值

两个不同的文件拥有相同sha1值,这意味着我们本地使用的程序sha1是源文件非串改后的,但实际上可能早已偷梁换柱.这是很可怕的.
所以推荐大家在用完整性校验时要使用sha256,会更安全些.

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

苹果在 2014 年 WWDC 发布了全新 Swift 编程语言，Swift 是苹果平台未来的编程语言。自那以后，很多第三方开发者开始使用 Swift 编写程序，不过苹果 iOS 和 macOS 系统，以及各种系统应用还是采用 Objective-C 编写。

这种情况存在很多原因，首先，苹果目前大量的 Objective-C 代码工作的很完美，没有必要为了重写而重写，没有问题就不要创造新的问题。其次，直到 Swift 5.0，ABI 才稳定，Swift 5.1，模块稳定，对于在系统级别大规模部署很重要。

自 iOS 9 之后，开发者 Alexandre Colucci 一直在统计苹果系统中 Swift 的使用情况。最新的数据显示，在 iOS 13 中，一共有 141 个使用 Swift 编写的二进制可执行文件，是 iOS 12 的两倍多，iOS 12 中有 66 个。

iOS 13 中，Sidecar 副屏、查找和提醒事项等新功能、新应用都采用 Swift 编写，其他使用 Swift 的 app 包括健康、Books 电子书以及一些系统服务，负责 AirPods 和 HomePod 配对的服务，以及查找 App 的离线查找功能等。

转自：https://www.jianshu.com/p/1227b27fcb2c

tips 没有购买cleanMyMac的同学，不要担心，我既然写了文章，肯定是不为了让同学们花钱购买软件的。
CoreSimulator与Xcode两个文件夹造成Mac中多了100G的“其他”空间；
请原谅我表述的不太明白，还是上图吧：

1.清理之前mac电脑只剩下了23.4GB的存储空间可用，“其他”这一项目占了200多GB

2.清理了Xcode文件夹中的部分文件

3.清理了CoreSimulator文件夹中的部分文件

使用Clean My Mac 版本4.0.4 中的卸载功能，查看(下边的是我清理之后，清理之前，Xcode占用129GB，现在是37.7GB)

我们通过下图可以得知，Xcode.app本身才7.8个G，可是下边的两个文件夹（清理之前占了120G左右）清理之后还占了30GB左右。

没有购买cleanMyMac的同学，不要担心，我既然写了文章，肯定是不为了让同学们花钱购买软件的。

1.请在电脑上 点击 “前往文件夹”功能，（快捷键：com + shift + g）
Xcode 文件目录：(不要全部删除整个文件，我们去选择删除DeviceSupport里边老旧的版本就好了)

~/Library/Developer/Xcode/iOS\ DeviceSupport

CoreSimulator 文件目录：(不要全部删除整个文件，我们去选择删除Devices里的一些文件就好了)

~/Library/Developer/CoreSimulator/Devices

当然也可以在终端输入  
open ~/Library/Developer/Xcode/iOS\ DeviceSupport

还有

open ~/Library/Developer/CoreSimulator/Devices

也是一样的；

我把12.4以下的都删除了。

想了解这些文件是什么的，可以参照这篇文章 iOS开发-Xcode清理系统内存占用过多的方法

❀

↓ ↓ ↓ ↓ ↓2020年01月08日添加 ↓ ↓ ↓ ↓
❀

感谢评论区的建议。按照建议，亲测后感觉留言里提到ncdu方便快捷，有可取之处。如果有喜欢了解的小伙伴，可以参考这篇文章一个查看MAC硬盘占用的小工具ncdu

转自：https://www.jianshu.com/p/48d8e6870a7c

接触WebSocket

最近公司的项目中有一个功能 需要服务器主动推数据到APP。
考虑到普通的HTTP 通信方式只能由客户端主动拉取，服务器不能主动推给客户端 。然后就想出的2种解决方案。

1.和后台沟通了一下 他们那里使用的是WebSocket ，所以就使用WebSocket让我们app端和服务器建立长连接。这样就可以事实接受他发过来的消息
2.使用推送，也可以实现接收后台发过来的一些消息

最后还是选择了WebSocket，找到了facebook的 SocketRocket 框架。下面是接入过程中的一些记录

WebSocket

WebSocket 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯，它建立在 TCP 之上，同 HTTP 一样通过 TCP 来传输数据，但是它和 HTTP 最大不同是：

WebSocket 是一种双向通信协议，在建立连接后，WebSocket 服务器和 Browser/Client Agent 都能主动的向对方发送或接收数据，就像 Socket 一样；

WebSocket 需要类似 TCP 的客户端和服务器端通过握手连接，连接成功后才能相互通信。

具体在这儿 WebSocket 是什么原理？为什么可以实现持久连接？

用法
我使用的是pod管理库 所以在podfile中加入
pod 'SocketRocket'

在使用命令行工具cd到当前工程 安装
pod install

如果是copy的工程中的 SocketRocket库的github地址:SocketRocket

导入库到工程中以后首先封装一个SocketRocketUtility单例

SocketRocketUtility.m文件中的写法如下:

#import "SocketRocketUtility.h"
#import <SocketRocket.h>

NSString * const kNeedPayOrderNote = @"kNeedPayOrderNote";//发送的通知名称

@interface SocketRocketUtility()<SRWebSocketDelegate>
{
    int _index;
    NSTimer * heartBeat;
    NSTimeInterval reConnectTime;
}

@property (nonatomic,strong) SRWebSocket *socket;

@end

@implementation SocketRocketUtility

+ (SocketRocketUtility *)instance {
    static SocketRocketUtility *Instance = nil;
    static dispatch_once_t predicate;
    dispatch_once(&predicate, ^{
        Instance = [[SocketRocketUtility alloc] init];
    });
    return Instance;
}

//开启连接
-(void)SRWebSocketOpenWithURLString:(NSString *)urlString {
    if (self.socket) {
        return;
    }

    if (!urlString) {
        return;
    }

    //SRWebSocketUrlString 就是websocket的地址 写入自己后台的地址
    self.socket = [[SRWebSocket alloc] initWithURLRequest:
                   [NSURLRequest requestWithURL:[NSURL URLWithString:urlString]]];
    
    self.socket.delegate = self;   //SRWebSocketDelegate 协议
    
    [self.socket open];     //开始连接
}

//关闭连接
- (void)SRWebSocketClose {
    if (self.socket){
        [self.socket close];
        self.socket = nil;
        //断开连接时销毁心跳
        [self destoryHeartBeat];
    }
}

#pragma mark - socket delegate
- (void)webSocketDidOpen:(SRWebSocket *)webSocket {
    NSLog(@"连接成功，可以与服务器交流了,同时需要开启心跳");
    //每次正常连接的时候清零重连时间
    reConnectTime = 0;
    //开启心跳 心跳是发送pong的消息 我这里根据后台的要求发送data给后台
    [self initHeartBeat];
    [[NSNotificationCenter defaultCenter] postNotificationName:kWebSocketDidOpenNote object:nil];
}

- (void)webSocket:(SRWebSocket *)webSocket didFailWithError:(NSError *)error {
    NSLog(@"连接失败，这里可以实现掉线自动重连，要注意以下几点");
    NSLog(@"1.判断当前网络环境，如果断网了就不要连了，等待网络到来，在发起重连");
    NSLog(@"2.判断调用层是否需要连接，例如用户都没在聊天界面，连接上去浪费流量");
    NSLog(@"3.连接次数限制，如果连接失败了，重试10次左右就可以了，不然就死循环了。)";
    _socket = nil;
    //连接失败就重连
    [self reConnect];
}

- (void)webSocket:(SRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean {
    NSLog(@"被关闭连接，code:%ld,reason:%@,wasClean:%d",code,reason,wasClean);
    //断开连接 同时销毁心跳
    [self SRWebSocketClose];
}

/*
 该函数是接收服务器发送的pong消息，其中最后一个是接受pong消息的，
 在这里就要提一下心跳包，一般情况下建立长连接都会建立一个心跳包，
 用于每隔一段时间通知一次服务端，客户端还是在线，这个心跳包其实就是一个ping消息，
 我的理解就是建立一个定时器，每隔十秒或者十五秒向服务端发送一个ping消息，这个消息可是是空的
 */
-(void)webSocket:(SRWebSocket *)webSocket didReceivePong:(NSData *)pongPayload{

    NSString *reply = [[NSString alloc] initWithData:pongPayload encoding:NSUTF8StringEncoding];
    NSLog(@"reply===%@",reply);
}

- (void)webSocket:(SRWebSocket *)webSocket didReceiveMessage:(id)message  {
    //收到服务器发过来的数据 这里的数据可以和后台约定一个格式 我约定的就是一个字符串 收到以后发送通知到外层 根据类型 实现不同的操作
    NSLog(@"%@",message);
    
    [[NSNotificationCenter defaultCenter] postNotificationName:kNeedPayOrderNote object:message];
}

#pragma mark - methods
//重连机制
- (void)reConnect
{
    [self SRWebSocketClose];
    //超过一分钟就不再重连 所以只会重连5次 2^5 = 64
    if (reConnectTime > 64) {
        return;
    }
  
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(reConnectTime * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        self.socket = nil;
        [self SRWebSocketOpen];
        NSLog(@"重连");
    });
    
    //重连时间2的指数级增长
    if (reConnectTime == 0) {
        reConnectTime = 2;
    }else{
        reConnectTime *= 2;
    }
}

//初始化心跳
- (void)initHeartBeat
{
    dispatch_main_async_safe(^{
        [self destoryHeartBeat];
        __weak typeof(self) weakSelf = self;
        //心跳设置为3分钟，NAT超时一般为5分钟
        heartBeat = [NSTimer scheduledTimerWithTimeInterval:3*60 repeats:YES block:^(NSTimer * _Nonnull timer) {
            NSLog(@"heart");
            //和服务端约定好发送什么作为心跳标识，尽可能的减小心跳包大小
            [weakSelf sendData:@"heart"];
        }];
        [[NSRunLoop currentRunLoop]addTimer:heartBeat forMode:NSRunLoopCommonModes];
    })
}

//取消心跳
- (void)destoryHeartBeat
{
    dispatch_main_async_safe(^{
        if (heartBeat) {
            [heartBeat invalidate];
            heartBeat = nil;
        }
    })
}

//pingPong机制
- (void)ping{
    [self.socket sendPing:nil];
}

#define WeakSelf(ws) __weak __typeof(&*self)weakSelf = self
- (void)sendData:(id)data {

    WeakSelf(ws);
    dispatch_queue_t queue =  dispatch_queue_create("zy", NULL);
    
    dispatch_async(queue, ^{
        if (weakSelf.socket != nil) {
            // 只有 SR_OPEN 开启状态才能调 send 方法，不然要崩
            if (weakSelf.socket.readyState == SR_OPEN) {
                [weakSelf.socket send:data];    // 发送数据
                
            } else if (weakSelf.socket.readyState == SR_CONNECTING) {
                NSLog(@"正在连接中，重连后其他方法会去自动同步数据");
                // 每隔2秒检测一次 socket.readyState 状态，检测 10 次左右
                // 只要有一次状态是 SR_OPEN 的就调用 [ws.socket send:data] 发送数据
                // 如果 10 次都还是没连上的，那这个发送请求就丢失了，这种情况是服务器的问题了，小概率的
                [self reConnect];
                
            } else if (weakSelf.socket.readyState == SR_CLOSING || weakSelf.socket.readyState == SR_CLOSED) {
                // websocket 断开了，调用 reConnect 方法重连
                [self reConnect];
            }
        } else {
            NSLog(@"没网络，发送失败，一旦断网 socket 会被我设置 nil 的");
        }
    });
}

-(void)dealloc{
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

然后在需要开启socket的地方调用
[[SocketRocketUtility instance] SRWebSocketOpenWithURLString:@"写入自己后台的地址"];
在需要断开连接的时候调用
[[SocketRocketUtility instance] SRWebSocketClose];

使用这个框架最后一个很重要的 需要注意的一点

这个框架给我们封装的webscoket在调用它的sendPing senddata方法之前，一定要判断当前scoket是否连接，如果不是连接状态，程序则会crash。

结语
这里简单的实现了连接和收发数据 后续看项目需求在加上后续的改进 希望能够帮助第一次写的iOSer 。 希望有更好的方法的童鞋可以有进一步的交流 : )

4月10日 更新：

/// Creates and returns a new NSTimer object initialized with the specified block object and schedules it on the current run loop in the default mode.
/// - parameter:  ti    The number of seconds between firings of the timer. If seconds is less than or equal to 0.0, this method chooses the nonnegative value of 0.1 milliseconds instead
/// - parameter:  repeats  If YES, the timer will repeatedly reschedule itself until invalidated. If NO, the timer will be invalidated after it fires.
/// - parameter:  block  The execution body of the timer; the timer itself is passed as the parameter to this block when executed to aid in avoiding cyclical references
+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)interval repeats:(BOOL)repeats block:(void (^)(NSTimer *timer))block API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0));

上面发送心跳包的方法是iOS10才可以用的 其他版本会崩溃 要适配版本 要选择 这个方法

+ (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;

8月10日 更新demo地址
demo地址
可以下载下来看看哦 ：)

注
demo中的后台地址未设置 所以很多同学直接运行就报错了 设置一个自己后台的地址就ok了 :)

转自：https://www.jianshu.com/p/821b777555d3

说明
现在已经有很多第三方平台支持解析crash日志中的系统方法了，比如bugly。但是万一遇到情况特殊或者公司要求，还是走上传崩溃日志到自己的服务器，然后自己去定期解析的话，就需要用到symbolicatecrash这个工具了。

指令操作均在终端中进行。
另外，每次打包上架提交审核的时候，把对应的.xcarchive与ipa文件一同拷贝一份，按照版本号保存下来是个好习惯。

1.前期准备工作
前期准备工作只需要在第一次尝试解析的时候进行，如果可以成功执行最终的命令行解析日志就不需要重复执行。

• 确定Xcode路径，执行如下指令

xcode-select --print-path

目的：确保Xcode路径存在。如果路径中有空格的存在，请把空格去掉。比如如果Xcode 的名字是“Xcode 9.2”请修改成“Xcode9.2”或者“Xcode”。否则后面你会遇到很多稀奇古怪的错误。
修改方法：应用程序→Xcode→重命名

• 添加Xcode路径
  如果Xcode路径已经存在，或者不需要修改，请跳过这一步。注意如果改过Xcode应用的名字也需要进行这一步操作
  执行如下指令

sudo xcode-select -s 路径

路径部分直接把Xcode应用内Developer文件夹拖拽进去会自动生成。
Developer文件夹：应用程序→Xcode→右键，显示包内容→Contents文件夹→Developer

• 确定Xcode command line tools是否安装
  执行如下指令

xcode-select --install

如果输出以下内容说明已经安装，否则根据提示安装即可。

xcode-select: error: command line tools are already installed, use "Software Update" to install updates

2.解析准备工作
解析所需文件

解析崩溃日志需要三个文件

①.崩溃日志文件（通常为.crash如果服务器上面是.txt也没关系，直接下下来把尾缀改成.crash就行）
②.产生崩溃日志的app包对应的.dSYM符号表（注意符号表和包一定要匹配。否则，堆栈方法会错乱）
③.崩溃分析工具symbolicatecrash（Xcode自带）

.dSYM符号表的获取：Xcode→window→organizer 选择Archives→选择想要解析崩溃日志的App包→右键，show in finder→右键（.xcarchive），显示包内容→dSYMs→xxx.app.dSYM
如果自己这里没有app打包文件就只有跟打包的同事要。

symbolicatecrash的获取：应用程序(Applications)→Xcode→右键，显示包内容→Contents→SharedFrameworks→DVTFoundation.framework→Versions→A→Resources→symbolicatecrash

tips：如果到了DVTFoundation.framework这里打不开下一步了，选择如下浏览方式即可。

3.解析日志

<1>将上述三个文件放在一个文件夹内
文件夹名称可以任意起，路径随意但最好不要出现中文。

<2>在终端中进入该文件夹内
直接拖拽文件夹到路径部分会自动生成

cd 路径

<3>解析日志

./symbolicatecrash ./*.crash ./*.app.dSYM>symbol.crash

这个方法一次只能解析一个日志文件，然后输出一个解析过后的symbol.crash日志文件（会覆盖之前存在的symbol.crash），这个输出的日志文件就是我们可以直接阅读的日志文件。symbol部分可以任意修改成其他名字。

如果要解析多个日志文件，需要逐一将文件夹内的日志文件替换。或者将所有需要解析的日志文件全部放在文件夹内，但是每次指定需要解析的.crash文件。

如果出现下面类似的错误，报错无法执行

Error: "DEVELOPER_DIR" is not defined at ./symbolicatecrash line xx（数字）.

执行指令

export DEVELOPER_DIR=Xcode Developer文件夹路径

像上面一样把Developer文件夹拖拽到等号后面路径部分就行，然后再执行解析指令就不会报错了。

<4>查看解析结果

<5>给Xcode添加对应固件的符号文件
①.下载对应固件符号文件
这个需要结合崩溃日志的信息来，比如这里日志中提到崩溃发生的固件是8.3（12F70）我们就要去找这个固件的符号文件，找的时候还要注意是否区分了CPU架构。下载地址放在后面

②.下载完成后添加进Xcode
打开Finder：点击菜单前往→前往文件夹→输入
~/Library/Developer/Xcode/iOS DeviceSupport→前往

将下载好的符号文件放入定位到的路径里面。

③.再次解析日志文件

<6>固件符号文件下载地址
首先感谢iOS Crash分析必备：符号化系统库方法作者的无私分享。该文章的作者收集了几乎所有固件的符号文件并分享了出来，为了尊重原作者这里就不放下载地址了。大家可以在他的文章当中找到下载地址，以及目前收集了哪些固件符号文件。

转自：https://www.jianshu.com/p/21532aef2811

WKWebView的优点这里不做过多介绍，主要说一下最近解决WKWebView的post请求丢失body问题的解决方案。
WKWebView 通过loadrequest方法加载Post请求会丢失请求体（body）中的内容，进而导致服务器拿不到body中的内容的问题的发生。这个问题的产生主要是因为WKWebView的网络请求的进程与APP不是同一个进程，所以网络请求的过程是这样的：
由APP所在的进程发起request，然后通过IPC通信(进程间通信)将请求的相关信息（请求头、请求行、请求体等）传递给webkit网络线进程接收包装，进行数据的HTTP请求，最终再进行IPC的通信回传给APP所在的进程的。这里如果发起的request请求是post请求的话，由于要进行IPC数据传递，传递的请求体body中根据系统调度，将其舍弃，最终在WKWebView网络进程接受的时候请求体body中的内容变成了空，导致此种情况下的服务器获取不到请求体，导致问题的产生。
为了能够获取POST方法请求之后的body内容，这两天整理了一些解决方案，大致分为三种：

1. 将网络请求交由Js发起，绕开系统WKWebView的网络的进程请求达到正常请求的目的

2. 改变POST请求的方法为GET方法(有风险，不一定服务器会接受GET方法)

3. 将Post请求的请求body内容放入请求的Header中，并通过URLProtocol拦截自定义协议，在拦截中通过NSConnection进行重新请求（重新包装请求body），然后通过回调Client客户端来传递数据内容

三种方法中，我采用了第三种方案，这里说一下第三种方案的实现方式，大致分为三步:

1. 注册拦截的自定义的scheme

2. 重写loadRequest()方法，根据request的method方法是否为POST进行URL的拦截替换

3. 在URLProtocol中进行request的重新包装（获取请求的body内容），使用NSURLConnection进行HTTP请求并将数据回传

这里说明一下为什么要自己去注册自定义的scheme，而不是直接拦截https/http。主要原因是：如果注册了https/http的拦截，那么所有的http(s)请求都会交由系统进程处理，那么此时系统进程会通过IPC的形式传递给实现URLProctol协议的类去处理，在通过IPC传递的过程中丢失body体（上面有讲到），所以在拦截的时候是拿不到POST方法的请求体body的。然而并不是所有的http请求都会走loadrequest（）方法（比如js中的ajax请求），所以导致一些POST请求没有被包装（将请求体body内容放到请求头header）就被拦截了，进而丢失请求体body内容，问题一样会产生。所以为了避免这样的问题，我们需要自己去定一个scheme协议，保证不过度拦截并且能够处理我们需要处理的POST请求内容。

以下是具体的实现方式：

• 注册拦截的自定义的scheme

[NSURLProtocol registerClass:NSClassFromString(@“GCURLProtocol")];
    [NSURLProtocol wk_registerScheme:@"gc"];
    [NSURLProtocol wk_registerScheme:WkCustomHttp];
    [NSURLProtocol wk_registerScheme:WkCustomHttps];

• 重写loadRequest()方法，根据request的method方法是否为POST进行URL的拦截替换

//包装请求头内容
- (WKNavigation *)loadRequest:(NSURLRequest *)request{
    NSLog(@"发起请求:%@ method:%@",request.URL.absoluteString,request.HTTPMethod);
    NSMutableURLRequest *mutableRequest = [request mutableCopy];
    NSMutableDictionary *requestHeaders = [request.allHTTPHeaderFields mutableCopy];
    //判断是否是POST请求，POST请求需要包装request中的body内容到请求头中（会有丢失body问题的产生）
    //,包装完成之后重定向到拦截的协议中自己包装处理请求数据内容，拦截协议是GCURLProtocol，请自行搜索
    if ([mutableRequest.HTTPMethod isEqualToString:@"POST"] && ([mutableRequest.URL.scheme isEqualToString:@"http"] || [mutableRequest.URL.scheme isEqualToString:@"https"])) {
        NSString *absoluteStr = mutableRequest.URL.absoluteString;
        if ([[absoluteStr substringWithRange:NSMakeRange(absoluteStr.length-1, 1)] isEqualToString:@"/"]) {
            absoluteStr = [absoluteStr stringByReplacingCharactersInRange:NSMakeRange(absoluteStr.length-1, 1) withString:@""];
        }
        
        if ([mutableRequest.URL.scheme isEqualToString:@"https"]) {
            absoluteStr = [absoluteStr stringByReplacingOccurrencesOfString:@"https" withString:WkCustomHttps];
        }else{
            absoluteStr = [absoluteStr stringByReplacingOccurrencesOfString:@"http" withString:WkCustomHttp];
        }
        
        mutableRequest.URL = [NSURL URLWithString:absoluteStr];
        NSString *bodyDataStr = [[NSString alloc]initWithData:mutableRequest.HTTPBody encoding:NSUTF8StringEncoding];
        [requestHeaders addEntriesFromDictionary:@{@"httpbody":bodyDataStr}];
        mutableRequest.allHTTPHeaderFields = requestHeaders;
        
        NSLog(@"当前请求为POST请求Header:%@",mutableRequest.allHTTPHeaderFields);
        
    }
    return [super loadRequest:mutableRequest];
}

• 在URLProtocol中进行request的重新包装（获取请求的body内容），使用NSURLConnection进行HTTP请求并将数据回传（以下是主要代码）

+ (BOOL)canInitWithRequest:(NSURLRequest *)request {
    
    NSString *scheme = request.URL.scheme;
    
    if ([scheme isEqualToString:InterceptionSchemeKey]){
        
        if ([self propertyForKey:HaveDealRequest inRequest:request]) {
            NSLog(@"已经处理，放行");
            return NO;
        }
        return YES;
    }
    
    if ([scheme isEqualToString:WkCustomHttp]){
           
           if ([self propertyForKey:HaveDealWkHttpPostBody inRequest:request]) {
               NSLog(@"已经处理，放行");
               return NO;
           }
           return YES;
       }
    
    if ([scheme isEqualToString:WkCustomHttps]){
        
        if ([self propertyForKey:HaveDealWkHttpsPostBody inRequest:request]) {
            NSLog(@"已经处理，放行");
            return NO;
        }
        return YES;
    }
        
    return NO;
    
}
- (void)startLoading {
    
    //截获 gc 链接的所有请求，替换成本地资源或者线上资源
    if ([self.request.URL.scheme isEqualToString:InterceptionSchemeKey]) {
        [self htmlCacheRequstLoad];
    }
    
    else if ([self.request.URL.scheme isEqualToString:WkCustomHttp] || [self.request.URL.scheme isEqualToString:WkCustomHttps]){
        [self postBodyAddLoad];
    }
    else{
        NSMutableURLRequest *newRequest = [self cloneRequest:self.request];
        NSString *urlString = newRequest.URL.absoluteString;
        [self addHttpPostBody:newRequest];
        [NSURLProtocol setProperty:@YES forKey:GCProtocolKey inRequest:newRequest];
        [self sendRequest:newRequest];
    }
    
   
}

- (void)addHttpPostBody:(NSMutableURLRequest *)redirectRequest{
    
    //判断当前的请求是否是Post请求
    if ([self.request.HTTPMethod isEqualToString:@"POST"]) {
        NSLog(@"post请求");
        NSMutableDictionary *headerDict = [redirectRequest.allHTTPHeaderFields mutableCopy];
        NSString *body = headerDict[@"httpbody"]?:@"";
        if (body.length) {
            redirectRequest.HTTPBody = [body dataUsingEncoding:NSUTF8StringEncoding];
            NSLog(@"body:%@",body);
        }
    }
}
- (void)postBodyAddLoad{
    
    NSMutableURLRequest *cloneRequest = [self cloneRequest:self.request];
    if ([cloneRequest.URL.scheme isEqualToString:WkCustomHttps]) {
        cloneRequest.URL = [NSURL URLWithString:[cloneRequest.URL.absoluteString stringByReplacingOccurrencesOfString:WkCustomHttps withString:@"https"]];
        [NSURLProtocol setProperty:@YES forKey:HaveDealWkHttpsPostBody inRequest:cloneRequest];
    }else if ([cloneRequest.URL.scheme isEqualToString:WkCustomHttp]){
        
        cloneRequest.URL = [NSURL URLWithString:[cloneRequest.URL.absoluteString stringByReplacingOccurrencesOfString:WkCustomHttp withString:@"http"]];
        [NSURLProtocol setProperty:@YES forKey:HaveDealWkHttpPostBody inRequest:cloneRequest];
    }
    //添加body内容
    [self addHttpPostBody:cloneRequest];
    NSLog(@"请求body添加完成:%@",[[NSString alloc]initWithData:cloneRequest.HTTPBody encoding:NSUTF8StringEncoding]);
    [self sendRequest:cloneRequest];
    
}
//复制Request对象
- (NSMutableURLRequest *)cloneRequest:(NSURLRequest *)request
{
    NSMutableURLRequest *newRequest = [NSMutableURLRequest requestWithURL:request.URL cachePolicy:request.cachePolicy timeoutInterval:request.timeoutInterval];
    
    newRequest.allHTTPHeaderFields = request.allHTTPHeaderFields;
    [newRequest setValue:@"image/webp,image/*;q=0.8" forHTTPHeaderField:@"Accept"];
    
    if (request.HTTPMethod) {
        newRequest.HTTPMethod = request.HTTPMethod;
    }
    
    if (request.HTTPBodyStream) {
        newRequest.HTTPBodyStream = request.HTTPBodyStream;
    }
    
    if (request.HTTPBody) {
        newRequest.HTTPBody = request.HTTPBody;
    }
    
    newRequest.HTTPShouldUsePipelining = request.HTTPShouldUsePipelining;
    newRequest.mainDocumentURL = request.mainDocumentURL;
    newRequest.networkServiceType = request.networkServiceType;
    
    return newRequest;
}

#pragma mark - NSURLConnectionDataDelegate
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
{
    /**
     * 收到服务器响应
     */
    NSURLResponse *returnResponse = response;
    [self.client URLProtocol:self didReceiveResponse:returnResponse cacheStoragePolicy:NSURLCacheStorageAllowed];
}
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
{
    /**
     * 接收数据
     */
    if (!self.recData) {
        self.recData = [NSMutableData new];
    }
    if (data) {
        [self.recData appendData:data];
    }
}
- (nullable NSURLRequest *)connection:(NSURLConnection *)connection willSendRequest:(NSURLRequest *)request redirectResponse:(nullable NSURLResponse *)response
{
    /**
     * 重定向
     */
    if (response) {
        [self.client URLProtocol:self wasRedirectedToRequest:request redirectResponse:response];
    }
    return request;
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
    [self.client URLProtocolDidFinishLoading:self];
}
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error
{
    /**
     * 加载失败
     */
    [self.client URLProtocol:self didFailWithError:error];
}

转自：https://www.jianshu.com/p/4dfc80ca7db2

在iOS开发中，相关联的多个项目可能会放在同一个workspace下进行开发，那习惯了一个项目在一个工作空间下的同学该怎么快速开撸呢?

只需要三步而已！

第一步，先用Xcode在目标目录下创建一个workspace文件。见图说话。

第二步，用Xcode打开workspace文件，然后在该workspace下创建多个Project文件。

在创建工程的过程中有个主意点：将新建Project添加的目标和组 都是workspace。如图：

第三步，多个工程间文件互相引用问题：多个工程间的文件引用方法：在工程A的Setting选项下的Header Search Paths 下添加“$(SRCROOT)/../B”，这个工程A中即可引用工程B的文件，不过导入文件的方式是：#import <Person.m>

如上设置，多个工程间的类就可以共享使用了。

作为 Vue 重度用户，在使用 uni-app 过程中不可避免的把 Vue 开发习惯带了过去。无论是项目目录结构，还是命名风格，甚至我还封装了一些库，如 https://zhuanlan.zhihu.com/p/141451626 提到的 _request 等。

众所周知，用 Vue 开发项目，其实就是用的 Vue 全家桶。即 Vue + Vuex + VueRouter 。在代码里的体现就是：

this + this.$store + this.$router/$route

然而由于 uni-app 为了保证跨端同时简化语法，用的是微信小程序那套 API。其中就包括路由系统。因为在 uni-app 中，没有 $router/$route。只有 uni[‘路由方法’]。讲真的，这样做确实很容易上手，但同时也是有许多问题：

1. 路由传参数只支持字符串，对象参数需要手动JSON序列化
2. 传参有长度限制
3. 传参不支持特殊符号如 url
4. 不支持路由拦截和监听

因此，需要一个工具来将现有的路由使用方式变为 vue-router 的语法，并且完美解决以上几个问题。

vue-router 的语法这里不再赘述。简单的来说就是将路由的用法由：

uni.navigateTo({

    url: `../login/login?data=${JSON.stringify({ from: 'index', time:Date.now() })}`

})

变成：

this.$router.push('/login', {

    data: {

        from: 'index',

	time: Date.now()

    }

})

同时传参通过一个 $route 对象。因此我们的需求就是事现一个 $router 和 $route 对象。并给定相应方法。比如调用：

push('/login')

其实就是执行了：

uni.navigateTo({ url:`../login/login ` })

实现起来非常简单：

push 方法接收到 '/login' 将其拼接为 `../login/login` 后调用 uni.navigateTo 就可以。

然而这样并不严谨。此时的 push 方法只能在页面内使用。而不能在 pages 文件夹以外的地方使用，因为这里用的是相对路径。只要改成 `pages/login/login` 就好。

$route 的实现就是在路由发生变化时，动态改变一个公共对象 route 的内部值。

而通过全局 mixin onShow 方法，可以实现对路由变化动态监听。

通过 require.context 预引入路由列表实现更好的错误提示。

最后通过一个页面堆栈数据列表实现 route 实时更新。

最后的代码：

import Vue from 'vue'

export const route = { // 当前路由对象所在的 path 等信息。默认为首页
	fullPath: '/pages/index/index',
	path: '/index',
	type: 'push',
	query: {}
}

let onchange = () => {} // 路由变化监听函数
const _$UNI_ACTIVED_PAGE_ROUTES = [] // 页面数据缓存
let _$UNI_ROUTER_PUSH_POP_FUN = () => {} // pushPop resolve 函数
const _c = obj => JSON.parse(JSON.stringify(obj)) // 简易克隆方法
const modulesFiles = require.context('@/pages', true, /\.vue$/) // pages 文件夹下所有的 .vue 文件

Vue.mixin({
	onShow() {
		const pages = getCurrentPages().map(e => `/${e.route}`).reverse() // 获取页面栈
		if (pages[0]) { // 当页面栈不为空时执行
			let old = _c(route)
			const back = pages[0] != route.fullPath
			const now = _$UNI_ACTIVED_PAGE_ROUTES.find(e => e.fullPath == pages[0]) // 如果路由没有被缓存就缓存
			now ? Object.assign(route, now) : _$UNI_ACTIVED_PAGE_ROUTES.push(_c(route)) // 已缓存就用已缓存的更新 route 对象
			_$UNI_ACTIVED_PAGE_ROUTES.splice(pages.length, _$UNI_ACTIVED_PAGE_ROUTES.length) // 最后清除无效缓存
			if (back) { // 当当前路由与 route 对象不符时，表示路由发生返回
				onchange(route, old)
			}
		}
	}
})

const router = new Proxy({
	route: route, // 当前路由对象所在的 path 等信息,
	afterEach: to => {}, // 全局后置守卫
	beforeEach: (to, next) => next(), // 全局前置守卫
	routes: modulesFiles.keys().map(e => e = e.replace(/^\./, '/pages')), // 路由表
	_getFullPath(route) { // 根据传进来的路由名称获取完整的路由名称
		return new Promise((resolve, reject) => {
			const fullPath = this.routes.find(e => RegExp(route + '.vue').test(e))
			fullPath ? resolve(fullPath.replace(/\.vue$/, '')) : reject(`路由 ${ route + '.vue' } 不存在于 pages 目录中`)
		})
	},
	_formatData(query) { // 序列化路由传参
		let queryString = '?'
		Object.keys(query).forEach(e => {
			if (typeof query[e] === 'object') {
				queryString += `${e}=${JSON.stringify(query[e])}&`
			} else {
				queryString += `${e}=${query[e]}&`
			}
		})
		return queryString.length === 1 ? '' : queryString.replace(/&$/, '')
	},
	_beforeEach(path, fullPath, query, type) { // 处理全局前置守卫
		return new Promise(resolve => {
			this.beforeEach({ path, fullPath, query, type }, resolve)
		})
	},
	_next(next) { // 处理全局前置守卫 next 函数传经来的方法
		return new Promise((resolve, reject) => {
			if (typeof next === 'function') { // 当 next 为函数时, 表示重定向路由, 
				reject('在全局前置守卫 next 中重定向路由')
				Promise.resolve().then(() => next(this)) // 此处一个微任务的延迟是为了先触发重定向的reject
			} else if (next === false) { // 当 next 为 false 时, 表示取消路由
				reject('在全局前置守卫 next 中取消路由')
			} else {
				resolve()
			}
		})
	},
	_routeTo(UNIAPI, type, path, query, notBeforeEach, notAfterEach) {
		return new Promise((resolve, reject) => {
			this._getFullPath(path).then((fullPath) => { // 检查路由是否存在于 pages 中
				const routeTo = url => { // 执行路由
					const temp = _c(route) // 将 route 缓存起来
					Object.assign(route, { path, fullPath, query, type }) // 在路由开始执行前就将 query 放入 route, 防止少数情况出项的 onLoad 执行时，query 还没有合并
					UNIAPI({ url }).then(([err]) => {
						if (err) { // 路由未在 pages.json 中注册
							Object.assign(route, temp) // 如果路由跳转失败，就将 route 恢复
							reject(err)
							return
						} else { // 跳转成功, 将路由信息赋值给 route
							resolve(route) // 将更新后的路由对象 resolve 出去
							onchange({ path, fullPath, query, type }, temp)
							!notAfterEach && this.afterEach(route) // 如果没有禁止全局后置守卫拦截时, 执行全局后置守卫拦截
						}
					})
				}
				if (notBeforeEach) { // notBeforeEach 当不需要被全局前置守卫拦截时
					routeTo(`${fullPath}${this._formatData(query)}`)
				} else {
					this._beforeEach(path, fullPath, query, type).then((next) => { // 执行全局前置守卫,并将参数传入
						this._next(next).then(() => { // 在全局前置守卫 next 没传参
							routeTo(`${fullPath}${this._formatData(query)}`)
						}).catch(e => reject(e)) // 在全局前置守卫 next 中取消或重定向路由
					})
				}
			}).catch(e => reject(e)) // 路由不存在于 pages 中, reject
		})
	},
	pop(data) {
		if (typeof data === 'object') {
			_$UNI_ROUTER_PUSH_POP_FUN(data)
		}
		uni.navigateBack({ delta: typeof data === 'number' ? data : 1 })
	},
	// path 路由名 //  query 路由传参 // isBeforeEach 是否要被全局前置守卫拦截 // isAfterEach 是否要被全局后置守卫拦截
	push(path, query = {}, notBeforeEach, notAfterEach) {
		return this._routeTo(uni.navigateTo, 'push', path, query, notBeforeEach, notAfterEach)
	},
	pushPop(path, query = {}, notBeforeEach, notAfterEach) {
		return new Promise(resolve => {
			_$UNI_ROUTER_PUSH_POP_FUN(null)
			_$UNI_ROUTER_PUSH_POP_FUN = resolve
			this._routeTo(uni.navigateTo, 'pushPop', path, query, notBeforeEach, notAfterEach)
		})
	},
	replace(path, query = {}, notBeforeEach, notAfterEach) {
		return this._routeTo(uni.redirectTo, 'replace', path, query, notBeforeEach, notAfterEach)
	},
	switchTab(path, query = {}, notBeforeEach, notAfterEach) {
		return this._routeTo(uni.switchTab, 'switchTab', path, query, notBeforeEach, notAfterEach)
	},
	reLaunch(path, query = {}, notBeforeEach, notAfterEach) {
		return this._routeTo(uni.reLaunch, 'reLaunch', path, query, notBeforeEach, notAfterEach)
	}
}, {
	set(target, key, value) {
		if (key == 'onchange') {
			onchange = value
		}
		return Reflect.set(target, key, value)
	}
})

Object.setPrototypeOf(route, router) // 让 route 继承 router
export default router

为了做毕设，用了下uniapp与flutter，说真的，这是两款十分优秀的产品，几乎做到了各自领域性能和跨平台的极致。那么这两款产品到底有什么不同，在选型的时候应该如何取舍，这是我写这篇文章的目的。

uniapp与flutter都是为了解决跨平台问题的框架

uniapp是从h5 app到小程序一步步发展过来的，也就是走的html的路线。

html从最早的网页套壳一步步发展至今，为了解决早期套壳的体验问题，我们尝试用js代码调用原生接口，与原生进行交互，出现了一系列如React Native，Cordova，Weex，Framework7，MUI之类的框架，这些框架的出现进一步丰富h5应用的功能。但是这些技术要求很高的优化技巧，要走很多坑，在ios的体验尚可，但是Android上由于更新维护问题，js引擎差别很大，早期Android的js引擎极差，这些框架使用体验都不好，当然也有硬件方面的原因。而且Android上webview存在性能瓶颈，复杂应用不做预加载的情况下使用体验真的不好。后来为了使体验达到h5所能做的极致，小程序出现了，为了性能，屏蔽了dom，规定了独特的规范，按照这些规范去写，编译时框架提前给你优化好，事实证明这样做确实可以提高h5应用的使用体验。

uniapp延续了小程序的思路，和vue结合，屏蔽dom，提前优化，确实很好，也做到了跨平台，这是一款极为优秀的跨各种小程序的解决方案，与它自家的h5+结合也是一个还算不错的h5+ app的前端框架。但是uniapp的定位中有一个极大的问题，就是小程序与h5 app之间的距离太大了，强跨的体验真是极差，得不偿失。举个栗子，3d渲染，多人视频，nfc写卡，这种小程序完全做不到，当然uniapp也可以调h5+ runtime，但是一个复杂的移动端应用可能会加各种各样的东西，你完全预料不到可能出现什么需求，并且这些需求越来越多的情况下，小程序端与移动端分开维护是必然的结果，强行结合只能是结构混乱，难以维护。那么如果分开维护，uniapp与前面提到的那些框架并没有明显优势。

那么接着说flutter，flutter与h5技术栈的思路完全不同，JSCore，V8再怎样优秀，也始终解决不了JavaScript本身语法缺陷和运行在浏览器的事实。

===========================

这里我之前写flutter用dart做了一个渲染引擎，有人言辞激烈的抨击了我的错误，后来我仔细看了一下资料。

官网上是这样说的

Flutter is built with C, C++, Dart, and Skia (a 2D rendering engine).See this architecture diagram for abetter picture of the main components.

确实，dart只是用来组织各种控件的一个工具，这个图形渲染是用了这个叫Skia的图形库

Skia is an open source 2D graphics library which provides common APIs that work across a variety of hardware and software platforms.

这个Skia，Google旗下，开源2D图形库，提供了多种软硬件平台的通用API。

确实是我的错，没调查清楚，但是这个方式还是令我觉得，很难受。

=================================

也就是说flutter和cocos，unity3d一样，完全可以用来写游戏，突破60fps，而且自己渲染，大大减少了与原生的通信次数，并且使用 Platform Channels 来跟系统通信大大丰富了一些偏门功能的应用，去组件库看了下tcp直连mqtt都支持了，刚好毕设会用到，开心。

所以如果你需要跨平台，技术选型时遇到问题

1.看需求

如果你的应用需求足够简单，像小程序之类的完全可以做到，选uniapp。因为说真的，像点单这种功能，谁没事愿意专门装个肯打鸡，coco之类在手机上，反正我去点单的时候，能用小程序我就不会再装app了，如果有人愿意装app，稍微改改顺便出个app版看着比较好看。

如果你的需求复杂，必然要分开维护，还是和之前一样，uniapp是一个极好的跨各种小程序的解决方案，一次编译，微信小程序，支付宝小程序，百度小程序，多端运行。那app端你可以再选择h5或者flutter。

如果你需要适配横屏，建议用flutter，横屏的交互加上material design的加持，这样和桌面端就没有太大区别了，目前flutter已经可以编译运行在Windows和linux上，虽然目前还很不完善，但是Google的野心和背书能力让我觉得flutter的野心不止于此。未来能附赠一套桌面端，意外之喜。

2.学习成本

flutter的学习成本主要在Dart，而uniapp主要在vue。说真的，我之前做Android和JavaWeb的，Java转Dart真的没有压力，有人说flutter嵌套太多，安卓xml布局嵌套不多吗，公司现在维护的ERP系统jQuery写的跟使一样，各种+ " append。

而我一个传统Java使用者刚开始遇到vue真的难受了好一阵子，这个this的真是vue里令我最难受的，使一样。推荐周围同学学uniapp，学过C++，Java的普遍反映也是vue看不懂。你们再也不是像jQuery一样好单纯好不做作的前端了。

总之前端的uniapp学习成本低，学过后端Java，C++的，flutter上手成本低。

3.社区

刚开始Google要出Fuchsia OS的时候我还嗤之以鼻，真当程序狗们都会乖乖听你话吗，那win phone坟头草都老高了。没想到啊，你们早在苹果骂安卓垃圾的时候就想着今天了吧。

Google在安卓界的背书能力感觉跟Spring在JavaWeb界的背书能力不逞多让，只要Android和Fuchsia不死，Flutter应该不会有太大问题，而且Flutter的社区是真的真的真的很活跃啊，github上问题的解决速度和出视频的速度真是令我叹为观止。

相比之下DCloud出MUI到现在不愠不火就让我不禁对uniapp有些担心，虽然微信，支付宝在后面背书，希望一群国内一线大厂们能给力点吧。而且我在uniapp提的问题一个多月了，无人问津

【报Bug】使用小程序组件，当参数为函数时，传不过去 - DCloud问答

希望你们珍惜你们的银牌赞助者。而且出视频的速度一言难尽，看B站居然没有，讲道理一个好的教学视频真的很重要，干啃API在学习时真是费力不讨好的事情，你学习的思路和文档的思路是不一样的。不过uniapp的QQ群倒是很火，不管怎样，一个国产的优秀产品，希望你们能有一个好的未来。

原文：https://zhuanlan.zhihu.com/p/55466963

[实践] uni-app 的使用总结

最近使用 uni-app 的感受。

使用体验

没用之前以为真和 Vue 一样，用了之后才知道。有点类似 Vue 和 小程序结合的感觉。写类似小程序的标签，有着小程序和 Vue 的生命周期钩子。对比 uni-app 文档和微信小程序的文档，不差多少，只是将 wx => uni，熟悉 Vue 和 小程序可以直接上手。

如果看过其他小程序的文档，可以发现，文档主要的三大章节就体现在框架、组件、API 。

uni-app 需要注意看注意事项，文档给出了和 Vue 使用的区别。例如动态的 Class 与 Style 绑定，在 H5 能用，APP 和小程序的体现就不一样。

配置项跟着文档来，开发环境也是现成的，下载 HBuilderX 导入项目就能运行，日常开发习惯了 VSCode，所以 HBuilderX 的主要作用就是用来打包 APK 和起各个端的服务，coding 的话当然还是用 VSCode。

路由

uni-app 的路由全部配置在 pages.json 文件里，就会导致多人开发的时候，路由无法拆分，如果处理的不好，就会发生冲突。

导航

导航栏需要注意的一个问题就是不同端的展示形式会不同，所以要处理兼容问题，导航栏可以自定义，用原生，框架，插件但是兼容性都不同，多端需求一定要在不同设备跑一下看效果。

例如在小程序和 APP 中，原生导航栏取消不了，就不能用自定义的导航栏，要在 pages.json 中配置原生导航栏。

兼容方法就是用 uni-app 提供的条件编译，处理各端不同的差异，我们支付的业务逻辑也是通过条件编译，区分不同端调用不同的支付方式。

生命周期

分为 应用的生命周期、页面的生命周期、组件的生命周期。写过小程序和 Vue 的很好理解，大致上和 Vue 的还是差不多的，页面生命周期针对当前的页面，应用生命周期针对小程序、APP。这些过程可能都要踩一下！

网络请求和环境配置

官方的 uni.request 虽然封装好了基本的请求，但是没有拦截，我们开始也是自己在这基础上加了层壳，简单的封装发送请求。当然也可以选择第三方库的使用，如 flyio、axios。

我们是前端自己封装了 HTTP 请求，并且统一接口的请求方式，所有的接口放到 api.js 文件中进行统一管理。这样大家在页面请求接口的时候风格才统一，包括约定好请求拦截和响应拦截，具体拦截的参数和后台约定好。

资源优化

• 暂时接触不到 Webpack 之类的资源打包优化，但是文档中有提到资源预取、预加载、treeShaking 只需要在配置文件中设置即可，或者在开发工具勾上。小程序也是勾选自动压缩混淆。
• 删除没用到文件和图片资源，因为打包的时候是会算进去的，比如 static 目录下的资源文件都会被打包，而且图片资源太大也不好。
• uni-app 运行时的框架主库 chunk-vendors.js 文件是经过处理的，部署做 gzip。

Web-View 组件

在 uni-app 中使用 Web-View，可以使用本地的资源和网络的资源，不同平台也是有差异的，小程序不支持本地 HTML，且小程序端 Web-View 组件一定有原生导航栏。

需要注意的是网页向应用 postMessage 的时候需要引入 uni.web-view.js，不然是没办法通信拿不到数据。

TODO: 这个坑后面再详细总结下！

全局状态

最开始是直接使用类似小程序的 globalData 来管理我们的全局状态，但是后面发现需求一多，加了各种东西之后，需要取这个状态的时候就很痛苦，做为程序猿嘛，都想偷懒吖，每次都得引入一下 getApp().globalData.data 这样很繁琐可不行，就替换成了 Vuex，需要取这个变量的时候，直接 this.vuex_xxxx 就能拿到这个值。

有段时间重写了 HTTP 请求部分和全局状态管理部分。

小程序中要在每一个页面中添加使用共有的数据，可以有三种方式解决。

Vue.prototype

它的作用是可以挂载到 Vue 的所有实例上，供所有的页面使用。

// main.js

Vue.prototype.$globalVar = "Hello";

然后在 pages/index/index 中使用：

<template>

  <view>{{ useGlobalVar }}</view>

</tempalte>

<script>

export default {

  data (){

    return {

      useGlobalVar: $globalVar

    }

  }

}

</script>

globalData

<!-- App.vue -->

<script>

    export default {

      globalData:{

        data:1

      }

      onShow() {



      getApp().globalData.data; // 使用



      getApp().globalData.data = 1; // 更新



  };

</script>

Vuex

Vuex 是 Vue 专用的状态管理模式。能够集中管理其数据，并且可观测其数据变化，以及流动。

之前看到一个通俗化比喻：用交通工具来比喻项目中这几种描述全局变量的方式。

下面列举这些方式通俗的理解状态：

Vue 插件 vue-bus 可以来管理一部分全局变量（叫应用状态吧），学习后发现，bus（中文意思：公交车）这名字取得挺形象的。

先罗列一下这些方式，不过这种分类并不严谨。

1、VueBus：公交车 2、Vuex：飞机 3、全局 import

• a.new Vue()：专车；
• b.Vue.use：快车；
• c.Vue.prototype：顺风车。

4、globalData：地铁

首先 VueBus，像公交车一样灵活便捷，随时都可以乘坐；表现在代码里，很轻便，召之即来，缺点就是不好维护，没有一个专门的文件去管理这些变量。想象平时等公交车的心情，知道它回来，但不知道它什么时候来，给人一种很不安的感觉。

而 Vuex，它像飞机，很庄重，塔台要协调飞机运作畅顺，飞机随时向地面报告自己的位置，适合用在大型项目。表现代码中，就是集中式管理所有状态，并且以可预测的方式发生变化。也对应着飞机绝对不能失联的特点。

第三种方式是全局 import，分三种类型，分别是：new Vue()、Vue.use()、Vue.prototype。可以用网约车来比喻，三种类型分别对应：专车、快车、顺风车。都足够灵活，表现在代码里：一处导入，处处可用。

再分别说明：

new Vue() 就像滴滴的礼橙专车，官方运营，安全可靠。表现在代码里，就是只有 Vue 官方维护的库才能使用这种方式。

Vue.use() 就像快车，必须符合滴滴的规范，才能成为专职司机。表现在代码中，就是导入的插件（或者库）必须符合 Vue 的写法（即封装了 Vue 插件写法）。

Vue.prototype 像顺风车，要求没上面两个那么严，符合一般 js 写法就行，就像顺风车的准入门槛稍稍低一点。

当然，uni-app 的项目里还有可以用 globalData 定义全局变量，非要比喻，可以用地铁，首先比 vue-bus 更好管理维护，想象地铁是不是比公交更可靠；其次比 Vuex 更简单，因为 globalData 真的就是简单的定义一些变量。

globalData 是微信小程序发明的，Vue 项目好像没有对应的概念，但是在 uni-app 中一样可用。

上面说到，这种分类方式不严谨，主要体现在原理上，并不是简单的并列关系或包含关系。

插件市场

uni-app 的主要特色也源自于它的插件市场十分丰富。

用得比较好的组件：

uView：我们用了这个库的骨架屏。这个库还是有很多技巧可以学到的。

https://www.uviewui.com/js/intro.html

ColorUI-UniApp：是个样式库，不是组件库。

https://ext.dcloud.net.cn/plugin?id=239

答题模版：左右滑答题模版，单选题、多选项，判断题，填空题，问答题。基于 ColorUI 做的。

https://ext.dcloud.net.cn/plugin?id=451

uCharts 高性能跨全端图表：

https://ext.dcloud.net.cn/plugin?id=271

最后：各端的差异性，很多东西，H5 挺好的，上真机就挂了，真机好着的，换小程序就飘了，不同小程序之间也有差异，重点是仔细阅读文档。

云打包限制，云打包(打 APK) 的每天做了限制，超出次数需要购买。

虽然可能一些原生可以实现的功能 uni-app 实现不了，不过整体开发下来还行，很多的坑还是因为多端不兼容，除了写起来麻烦一点，基本上都还是有可以解决的策略。比之前用 Weex 写 APP 开发体验好一点，比 React Native 的编译鸡肋一点（这点体验不是很好），至于 Flutter 还没有试过，有机会的话会试一下。

原文：https://zhuanlan.zhihu.com/p/153500294

先说一下提前须要会的技术

要想快速入手uniapp的话，你最好提前学会vue、微信小程序开发，因为它几乎就是这两个东西的结合体，不然，你就只有慢慢研究吧。

为什么要选择uniapp？？？

开发多个平台的时候，对，就是开发多端，其中包括安卓、IOS、H5/公众号、微信小程序、百度小程序...等其它小程序时，如果每个平台开发，人力开发成本高，后期维护也难，原生开发周期也长，那Unipp就是你的优先选择，官方是这样介绍的~哈~ 先来说一下uniapp的优点

uniapp优点

优点一，多端支持

当然是多端开发啦，uni-app是一套可以适用多端的开源框架，一套代码可以同时生成ios，Android，H5，微信小程序，支付宝小程序，百度小程序等。

优点二，更新迭代快

用了它的Hbx你就知道，经常会右下角会弹出让你更新，没错，看到它经常更新，这么努力的在先进与优化，还是选良心的了。

优点三，扩张强

你可以把轻松的把uniapp编译到你想要的端，也可以把其它端的转换成uniapp，例如微信小程序，h5等；如果开发app的时候，前端表现不够，你还可以原生嵌套开发。

优点四，开发成本、门槛低

不管你是公司也好，个人也好，如果你想开发多终端兼容的移动端，那uniapp就很适合你，不然以个人的能力要开发多端，哈哈... 洗洗睡觉吧。

优点五，组件丰富

社区还是比较成熟，生态好，组件丰富，支持npm方式安装第三方包，兼容mpvue，DCloud有大量的组件供你使用，当然付费的也不贵，你还可以发布你开发的，赚两个鸡腿钱还是可以的。

开发上的优点暂且不说，大体上的有这么一些，接下来说一下开发过程中的缺点

uniapp缺点

缺点一：爬坑

每个程序前期肯定都会有很多的坑，这里点明一下：腾讯，敢问谁没在微信开发上坑哭过，现在不也爬起来了，2年前有人提的bug，你现在去看，他依然在那，不离不弃呀。uniapp坑也有，一般的都有人解决了，没解决的，你就要慢慢的去琢磨了，官方bug的话，提交反馈，等官方修复。

缺点二：某些组件不成熟

我说的是某些官方组件，像什么地图组件，直播组件等，你要在上面开发一些特别功能的话，那真的是比较费神的。

缺点二：nvue有点蛋疼

某些组件或某些功能，官方明确说，建议用nvue开发，那么问题来了，nvue有很多的局限，特别是css，很多都不支持，什么文字只能是text，只支持class样式，很多的，要看文档来。

暂时从使用上的总结就这么一些，如果你有不同的见解，留言交流交流~~

原文：https://zhuanlan.zhihu.com/p/336773995

一、简介

• 什么是CocoaPods

CocoaPods是OS X和iOS下的一个第三类库管理工具，通过CocoaPods工具我们可以为项目添加被称为“Pods”的依赖库（这些类库必须是CocoaPods本身所支持的），并且可以轻松管理其版本。

• CocoaPods的好处

1、在引入第三方库时它可以自动为我们完成各种各样的配置，包括配置编译阶段、连接器选项、甚至是ARC环境下的-fno-objc-arc配置等。

2、使用CocoaPods可以很方便地查找新的第三方库，这些类库是比较“标准的”，而不是网上随便找到的，这样可以让我们找到真正好用的类库。

二、Cocoapods安装步骤

注意：在终端输入命令时，取$后面部分输入

1、升级Ruby环境

终端输入：$ gem update --system

此时会出现

这是因为你没有权限去升级Ruby

这时应该输入：$ sudo gem update --system

接下来输入密码，注意：输入密码的时候没有任何反应，光标也不会移动，你尽管输入就是了，输完了直接回车。
等一会如果出现

恭喜你，升级Ruby成功了。

2、更换Ruby镜像

首先移除现有的Ruby镜像

终端输入：$ gem sources --remove https://gems.ruby-china.org/

然后添加国内最新镜像源（淘宝的Ruby镜像已经不更新了）

终端输入：$ gem sources -a https://gems.ruby-china.com/

执行完毕之后输入gem sources -l来查看当前镜像

终端输入：$ gem sources -l

如果结果是

*** CURRENT SOURCES ***
https://gems.ruby-china.com/
说明添加成功，否则继续执行$ gem source -a https://gems.ruby-china.com/来添加

3、安装CocoaPods

接下来开始安装

终端输入：$ sudo gem install cocoapods

说明没有权限，需要输入

终端输入：$ sudo gem install -n /usr/local/bin cocoapods

安装成功如下：

到这之后再执行pod setup（PS：这个过程是漫长的，要有耐心）

终端输入：$ pod setup

然后你会看到出现了Setting up CocoaPods master repo，卡住不动了，说明Cocoapods在将它的信息下载到 ~/.cocoapods里。
你可以command+n新建一个终端窗口，执行cd ~/.cocoapods/进入到该文件夹下，然后执行du -sh *来查看文件大小，每隔几分钟查看一次，这个目录最终大小是900多M（我的是930M）
当出现Setup completed的时候说明已经完成了。

4、CocoaPods的使用

1、首先我们来搜索一下三方库

终端输入：$ pod search AFNetworking

这时有可能出现

这是因为之前pod search的时候生成了缓存文件search_index.json
执行rm ~/Library/Caches/CocoaPods/search_index.json来删除该文件
然后再次输入pod search AFNetworking进行搜索
这时会提示Creating search index for spec repo 'master'..
等待一会将会出现搜索结果如下：

出现这个了就说明搜索成功了，看一下上图中的这一句：
pod 'AFNetworking', '~> 3.1.0'
这句话一会我们要用到，这是CocoaPods添加三方库的关键字段
然后退出这个界面（这一步只是验证一下cocoapods有没有安装成功，能不能搜索到你想要的三方库），直接按"q"就退出去了。

2、在工程中创建一个Podfile文件

要想在你的工程中创建Podfile文件，必须先要进到该工程目录下

终端输入：$ cd /Users/liyang/Desktop/CocoaPodsTest
//这是我电脑上的路径，你输入你自己项目的路径或直接拖拽也行

进来之后就创建

终端输入：$ touch Podfile

然后你在你的工程目录下可以看到多了一个Podfile文件

3、编辑你想导入的第三方库的名称及版本

使用vim编辑Podfile文件

终端输入：$ vim Podfile

进入如下界面：

进来之后紧接着按键盘上的英文'i'键
下面的"Podsfile" 0L, 0C将变成-- INSERT --
然后就可以编辑文字了，输入以下文字

platform :ios, '7.0'
target 'MyApp' do
pod 'AFNetworking', '~> 3.1.0'
end

解释一下
platform :ios, '7.0'代表当前AFNetworking支持的iOS最低版本是iOS 7.0,
'MyApp'就是你自己的工程名字，
pod 'AFNetworking', '~> 3.1.0'代表要下载的AFNetworking版本是3.1.0及以上版本，还可以去掉后面的'~> 3.1.0'，直接写pod 'AFNetworking'，这样代表下载的AFNetworking是最新版。

编辑完之后成如下样子：

此时该退出去了，怎么退出去呢？跟着我做，先按左上角的esc键，再按：键，再输入wq，点击回车，就保存并退出去了。

这时候，你会发现你的项目目录中名字为Podfile的文件的内容就是你刚刚输入的内容。

4、把该库下载到Xcode中

终端输入：$ pod install

这就开始下载了，需要一段时间，出现如下界面就说明安装好了

这个时候关闭所有的Xcode窗口，再次打开工程目录会看到多了一个后缀名为.xcworkspace文件。

以后打开工程就双击这个文件打开了，而不再是打开.xcodeproj文件。
进入工程后引入头文件不再是#import "AFNetworking.h"，而是#import <AFNetworking.h>

原贴链接：https://www.jianshu.com/p/9e4e36ba8574

<view class="menu" :class="{active:menuFlag}">
		<image src="../../static/svg/1.svg" class="menuTrigger" @tap="clickMenu"></image>
		<image src="../../static/svg/2.svg" class="menuItem menuItem1"></image>
		<image src="../../static/svg/3.svg" class="menuItem menuItem2"></image>
		<image src="../../static/svg/4.svg" class="menuItem menuItem3"></image>
</view>

.menu{
		position: fixed;
		width: 110rpx;
		height: 110rpx;
		bottom: 120rpx;
		right: 44rpx;
		border-radius: 50%;
	}
	.menuTrigger{
	    position: absolute;
	    top: 0;
	    left: 0;
	    width: 70rpx;
	    height: 70rpx;
	    background-color: green;
	    border-radius: 50%;
	    padding: 20rpx;
	    cursor: pointer;
	    transition: .35s ease;
	}
	.menuItem{
	    position: absolute;
	    width: 50rpx;
	    height: 50rpx;
		top: 10rpx;
		left: 10rpx;
	    padding: 20rpx;
	    border-radius: 50%;
	   background-color: white;
	    border: none;
	    box-shadow: 0 0 5rpx 1rpx rgba(0,0,0,.05);
	    z-index: -1000;
	    opacity: 0;
	}
	.menuItem1{
		transition: .35s ease;
	}
	.menuItem2{
		transition: .35s ease .1s;
	}
	.menuItem3{
		transition: .35s ease .2s;
	}
	.menu.active .menuTrigger{
		transform: rotateZ(225deg);
		background-color: pink;
	}
	.menu.active .menuItem1{
		top: -106rpx;
		left: -120rpx;
		opacity: 1;
	}
	.menu.active .menuItem2{
		top: 10rpx;
		left: -164rpx;
		opacity: 1;
	}
	.menu.active .menuItem3{
		top: 126rpx;
		left: -120rpx;
		opacity: 1;
	}

data() {
         return {
				mask: false,
				menuFlag: false,
			}
		},

clickMenu(){
	this.menuFlag = !this.menuFlag;
},

原文链接：https://zhuanlan.zhihu.com/p/364244176

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

}

window.onload = async () => {

  try {

    let res = await getData(3)

    console.log(res)

  } catch (error) {

    console.log(res) //getdata error

  }

}

window.onload = async () => {

  let res = await getData(3).then(r=>r).catch(err=>err);

  console.log(res) //getdata error

}

window.onload = async () => {

  let res = await getData(3)

  .then((res) => [null, res])

  .catch((err) => [err, null])

  console.log(res) // ["getdata error",null]

}

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

TL;DR

文章篇幅有点长 ，可以先收藏再看 。要是想直接看看怎么写一个扩展，直接去第二部分 ，或者直接去github看源码 。

第一部分 --- Extension 知识点

一、扩展的启动

1. 如何保证性能 --- 扩展激活（Extension Activation） 我们会往VS Code中安装非常多的扩展，VS Code是如何保证性能的呢？ 在VS Code中有一个扩展激活（Extension Activation）的概念：VS Code会尽可能晚的加载扩展（懒加载），并且不会加载会话期间未使用的扩展，因此不会占用内存。为了完成扩展的延迟加载，VS Code定义了所谓的激活事件（activation events）。 VS Code根据特定活动触发激活事件，并且扩展可以定义需要针对哪些事件进行激活。例如，仅当用户打开Markdown文件时，才需要激活用于编辑Markdown的扩展名。
   
2. 如何保证稳定性 --- 扩展隔离（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 Code
• displayName:在左侧显示的扩展名
• icon:扩展的图标
• categories:扩展所属的分类。可以是：Languages, Snippets, Linters, Themes, Debuggers, Formatters, Keymaps, Other

第二部分 --- 自己写个扩展玩玩

我们经常使用console.log来打印日志进行调试，我们就写一个用来美化、简化console.log的扩展玩玩。最终实现的效果：

special-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

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

SDK 集成

Bugly提供两种集成方式供iOS开发者选择：

• 通过CocoaPods集成
• 手动集成

如果您是从Bugly 2.0以下版本升级过来的，请查看iOS SDK 升级指南

Bugly iOS SDK 最低兼容系统版本 iOS 7.0

通过CocoaPods集成

在工程的Podfile里面添加以下代码：

pod 'Bugly'

保存并执行pod install,然后用后缀为.xcworkspace的文件打开工程。

注意:
命令行下执行pod search Bugly,如显示的Bugly版本不是最新的，则先执行pod repo update操作更新本地repo的内容
关于CocoaPods的更多信息请查看 CocoaPods官方网站。

手动集成

• 下载 Bugly iOS SDK
• 拖拽Bugly.framework文件到Xcode工程内(请勾选Copy items if needed选项)
• 添加依赖库
  • SystemConfiguration.framework
  • Security.framework
  • libz.dylib 或 libz.tbd
  • libc++.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文件 
iOS平台中，dSYM文件是指具有调试信息的目标文件，文件名通常为：xxx.app.dSYM。

• 为了方便找回Crash对应的dSYM文件和还原堆栈，建议每次构建或者发布APP版本的时候，备份好dSYM文件。

生成后,在哪里可以找到dSYM文件?

保存log到本地,并上传到Bugly管理后台

1.遵守代理协议

@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 符号表配置

什么是符号表？

符号表是内存地址与函数名、文件名、行号的映射表。符号表元素如下所示：

<起始地址> <结束地址> <函数> [<文件名:行号>]

为什么要配置符号表？ 
为了能快速并准确地定位用户APP发生Crash的代码位置，Bugly使用符号表对APP发生Crash的程序堆栈进行解析和还原。

自动配置：XCode + sh脚本

使用文档中的方式一进行配置（默认方式）

配置Xcode编译执行脚本

• 在Xcode工程对应Target的Build Phases中新增Run Scrpit Phase

打开工具包中的dSYM_upload.sh，复制所有内容，在新增的Run Scrpit Phase中粘贴

修改新增的Run Scrpit中的 <YOUR_APP_ID> 为您的App ID，<YOUR_APP_KEY>为您的App Key，<YOUR_BUNDLE_ID> 为App的Bundle Id

脚本默认在Debug模式及模拟器编译情况下不会上传符号表，在需要上传的时候，请修改下列选项

• Debug模式编译是否上传，1＝上传 0＝不上传，默认不上传

UPLOAD_DEBUG_SYMBOLS=0

• 模拟器编译是否上传，1＝上传 0＝不上传，默认不上传

UPLOAD_SIMULATOR_SYMBOLS=0

一、前言

性能问题极大程度的会影响到用户的体验，对于我们开发者和测试同学要随时随地保证我们app的质量，避免不好的体验带来用户的流失。本篇文章我们来讲一下，性能监控的几款工具的技术实现。主要包括，帧率监控、CPU监控、内存监控、流量监控、卡顿监控和自定义监控这几个功能。

有人说帧率、CPU和内存这些信息我们都可以在Xcode中的Instruments工具进行联调的时候可以查看，为什么还要在客户端中打印出来呢？

1. 第一、很多测试同学比较关注App质量，但是他们却没有Xcode运行环境，他们对于质量数据无法很有效的查看。
2. 第二、App端实时的查看App的质量数据，不依赖IDE，方便快捷直观。
3. 第三、实时采集性能数据，为后期结合测试平台产生性能数据报表提供数据来源。

二、技术实现

3.1：帧率展示

app的流畅度是最直接影响用户体验的，如果我们app持续卡顿，会严重影响我们app的用户留存度。所以对于用户App是否流畅进行监控，能够让我们今早的发现我们app的性能问题。对于App流畅度最直观最简单的监控手段就是对我们App的帧率进行监控。

帧率（FPS）是指画面每秒传输帧数，通俗来讲就是指动画或视频的画面数。FPS是测量用于保存、显示动态视频的信息数量。每秒钟帧数愈多，所显示的动作就会越流畅。对于我们App开发来说，我们要保持FPS高于50以上，用户体验才会流畅。

在YYKit Demo工程中有一个工具类叫YYFPSLabel，它是基于CADisplayLink这个类做FPS计算的，CADisplayLink是CoreAnimation提供的另一个类似于NSTimer的类，它会在屏幕每次刷新回调一次。既然CADisplayLink可以以屏幕刷新的频率调用指定selector，而且iOS系统中正常的屏幕刷新率为60Hz（60次每秒），那只要在这个方法里面统计每秒这个方法执行的次数，通过次数/时间就可以得出当前屏幕的刷新率了。

大致实现思路如下：

- (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]];
}

值得注意的是基于CADisplayLink实现的 FPS 在生产场景中只有指导意义，不能代表真实的 FPS，因为基于CADisplayLink实现的 FPS 无法完全检测出当前 Core Animation 的性能情况，它只能检测出当前 RunLoop 的帧率。但要真正定位到准确的性能问题所在，最好还是通过Instrument来确认。

3.2：CPU展示

CPU是移动设备的运算核心和控制核心，如果我们的App的使用率长时间处于高消耗的话，我们的手机会发热，电量使用加剧，导致App产生卡顿，严重影响用户体验。所以对于CPU使用率进行实时的监控，也有利于及时的把控我们App的整体质量，阻止不合格的功能上线。

对于app使用率的获取，网上的方案还是比较统一的。

1. 使用task_threads函数，获取当前App行程中所有的线程列表。
2. 对于第一步中获取的线程列表进行遍历，通过thread_info函数获取每一个非闲置线程的cpu使用率，进行相加。
3. 使用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：内存展示

设备内存和CPU一样都是系统中最稀少的资源，也是最有可能产生竞争的资源，应用内存跟app的性能直接相关。如果一个app在前台消耗内存过多，会引起系统强杀，这种现象叫做OOM。表现跟crash一样，而且这种crash事件无法被捕获到的。

获取app消耗的内存，刚开始使用的是获取使用的物理内存大小resident_size,网上大部分也是这种方案。

//当前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：流量监控

在线下开发阶段，我们开发要和服务端联调结果，我们需要Xcode断点调试服务器返回的结果是否正确。测试阶段，测试同学会通过Charles设置代理查看结果，这些操作都需要依赖第三方工具才能实现流量监控。能不能有一个工具，能够随身携带，对流量进行监控拦截，能够方便我们很多。我们DoraemonKit就做了这件事。

对于流量监控，业界基本有以上几个方案:

• 方案1 : 腾讯GT的方案，监控系统的上行流量和下行流量。这样监控的话，力度太粗了，不能得到每一个app的流量统计，更不能的得到每一个接口的流量和统计，不符合我们的需求。

• 方案2 : 浸入业务方自己的网路库，做流量统计，这种方案可以做的非常细节，但是不是特别通用。我们公司内部omega监控平台就是这么做的，omega的流量监控代码是写在OneNetworking中的。不是特别通用。比如我们杭州团队的网路库是自研的，如果要接入omega的网络监控功能，就需要在自己的网络库中，写流量统计代码。

• 方案3 : hook系统底层网络库，这种方式比较通用，但是非常繁琐，需要hook很多个类和方法。阿里有篇文档化介绍了他们流量监控的方案，就是采用这种，下面这张图我截取过来的，看一下，还是比较复杂的。

  
  

• 方案4 : 也是DoraemonKit采用的方案，使用iOS中一个非常强大的类，叫NSURLProtocol，这个类可以拦截NSURLConnection、NSUrlSession、UIWebView中所有的网络请求，获取每一个网络请求的request和response对象。但是这个类无法拦截tcp的请求，这个是他的缺点。美团的内部监控工具赫兹就是基于该类进行处理的。

下面就是DoraemonKit中NSURLProtocol的具体实现：

@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：自定义监控

以上所有的操作都是针对于单个指标，无法提供一套全面的监控数据，自定义监控可以选择你需要监控的数据，目前包括帧率、CPU使用率、内存使用量和流量监控，这些监控没有波形图进行显示，均在后台进行监控，测试完毕，会把这些数据上传到我们后台进行分析。

因为目前后台是基于我们内部平台上开发的，暂时不提供开源。不过后续的话，我们也会考虑将后台的功能的功能对外提供，请大家拭目以待。对于开源版本的话，目前性能测试的结果保存在沙盒Library/Caches/DoraemonPerformance中，使用者可以使用沙盒浏览器功能导出来之后自己进行分析。

DoraemonKit项目地址：github.com/didi/Doraem…

摘自：https://blog.csdn.net/weixin_33847182/article/details/91472599

一、前言

一个比较成熟的App，经历了多个版本的迭代之后，为了方便调式和测试，往往会积累一些工具来应付这些场景。最近我们组就开源了一款适用于iOS App线下开发、测试、验收阶段，内置在App中的工具集合。使用DoraemonKit，你无需连接电脑，就可以对于App的信息进行快速的查看。一键接入、使用方便，提高开发、测试、视觉同学的工作效率，提高我们App上线的完整度和稳定性。

目前DoraemonKit拥有的功能大概分为以下几点：

1. 常用工具 : App信息展示，沙盒浏览、MockGPS、H5任意门、子线程UI检查、日志显示。
2. 性能工具 : 帧率监控、CPU监控、内存监控、流量监控、自定义监控。
3. 视觉工具 : 颜色吸管、组件检查、对齐标尺。
4. 业务专区 : 支持业务测试组件接入到DoraemonKit面板中。

拿我们App接入效果如下：

 上面两行是业务线自定义的工具，接入方可以自定义。除此之外都是内置工具集合

因为里面功能比较多，大概会分三篇文章介绍DoraemonKit的使用和技术实现，这是第一篇主要介绍常用工具集中的几款工具实现。

二、技术实现

2.1：App信息展示

我们要看一些手机信息或者App的一些基本信息的时候，需要到系统设置去找，比较麻烦。特别是权限信息，在我们app装的比较多的时候，我们很难快速找到我们app的权限信息。而这些信息从代码角度都是比较容易获取的。我们把我们感兴趣的信息列表出来直接查看，避免了去手机设置里查看或者查看源代码的麻烦。

获取手机型号

我们从手机设置里面是找不到我们的手机具体是哪一款的文字表述的，比如我的手机是iphone8 Pro，在手机型号里面显示的是MQ8E2CH/A。对于iPhone不熟悉的人很难从外表对iphone进行区分。而手机型号，我们从代码角度就很好获取。

+ (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"];

权限信息查看

当我们发现App运行不正常，比如无法定位，网络一直失败，无法收到推送信息等问题的时候，我们第一个反应就是去手机设置里面去看我们app相关的权限有没有打开。DoraemonKit集成了对于地理位置权限、网络权限、推送权限、相机权限、麦克风权限、相册权限、通讯录权限、日历权限、提醒事项权限的查询。

由于代码比较多，这里就不一一贴出来了。大家可以去DorameonKit/Core/Plugin/AppInfo中自己去查看。这里讲一下，权限查询结果几个值的意义。

• NotDetermined => 用户还没有选择。
• Restricted => 该权限受限，比如家长控制。
• Denied => 用户拒绝使用该权限。
• Authorized => 用户同意使用该权限。

2.2：沙盒浏览

以前如果我们要去查看App缓存、日志信息，都需要访问沙盒。由于iOS的封闭性，我们无法直接查看沙盒中的文件内容。如果我们要去访问沙盒，基本上有两种方式，第一种使用Xcode自带的工具，从Windows-->Devices进入设备管理界面，通过Download Container的方式导出整个app的沙盒。第二种方式，就是自己写代码，访问沙盒中指定文件，然后使用NSLog的方式打印出来。这两种方式都比较麻烦。

DoraemonKit给出的解决方案：就是自己做一个简单的文件浏览器，通过NSFileManager对象对沙盒文件进行遍历，同时支持对于文件和文件夹的删除操作。对于文件支持本地预览或者通过airdrop的方式或者其他分享方式发送到PC端进行更加细致的操作。

怎么用NSFileManager对象遍历文件和删除文件这里就不说了，大家可以参考DorameonKit/Core/Plugin/Sanbox中的代码。这里讲一下：如何将手机中的文件快速上传到Mac端？刚开始我们还绕了一点路，我们在手机端搭了一个微服务，mac通过浏览器去访问它。后来和同事聊天的时候知道了UIActivityViewController这个类，可以十分便捷地吊起系统分享组件或者是其他注册到系统分享组件中的分享方式，比如微信、钉钉。实现代码非常简单，如下所示：

- (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

我们有些业务会根据地理位置不同，而有不同的业务处理逻辑。而我们开发或者测试，当然不可能去每一个地址都测试一遍。这种情况下，测试同学一般会找到我们让我们手动改掉系统获取经纬度的回调，或者修改GPX文件，然后再重新打一个包。这样也非常麻烦。

DoraemonKit给出的解决方案：提供一套地图界面，支持在地图中滑动选择或者手动输入经纬度，然后自动替换掉我们App中返回的当前经纬度信息。这里的难点是如何不需要重新打包自动替换掉系统返回的当前经纬度信息？

CLLocationManager的delegate中有一个方法如下：

/*
 *  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));

我们通常是在这个函数中获取当前系统的经纬度信息。我们如果想要没有侵入式的修改这个函数的默认实现方式，想到的第一个方法就是Method Swizzling。但是真正在实现过程中，你会发现Method Swizzling需要当前实例和方法，方法是- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations 我们有了，但是实例，每一个app都有自己的实现，无法做到统一处理。我们就换了一个思路，如何能获取该实现了该定位方法的实例呢？就是使用Method Swizzling Hook住CLLocationManager的setDelegate方法，就能获取具体是哪一个实例实现了- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations 方法。

具体方法如下：

第一步： 生成一个CLLocationManager的分类CLLocationManager(Doraemon),在这个分类中，实现- (void)doraemon_swizzleLocationDelegate:(id)delegate这个方法，用来进行方法交换。

- (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];
    }
}

在这个函数中主要做了三件事情，1、将所有的定位回调统一交给[DoraemonGPSMocker shareInstance]处理 2、[DoraemonGPSMocker shareInstance]绑定了所有CLLocationManager与它的delegate的一一对应关系。3、处理[DoraemonGPSMocker shareInstance]没有实现的selector，并且给用户提示。

第二步：当有一个定位回调过来的时候，我们先传给[DoraemonGPSMocker shareInstance]，然后[DoraemonGPSMocker shareInstance]再转发给它绑定过的所有的delegate。那我们App为例，绑定关系如下：{

    "0x2800a07a0_binder" = "<CLLocationManager: 0x2800a07a0>";
    "0x2800a07a0_delegate" = "<MAMapLocationManager: 0x2800a04d0>";
    "0x2800b59a0_binder" = "<CLLocationManager: 0x2800b59a0>";
    "0x2800b59a0_delegate" = "<KDDriverLocationManager: 0x2829d3bf0>";
}

由此可见，我们App的统一定位KDDriverLocationManager和苹果地图的定位MAMapLocationManager都是使用都是CLLocationManager提供的。

具体 DoraemonGPSMocker这个类如何实现，请参考DorameonKit/Core/Plugin/GPS中的代码。

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检查

在iOS中是不允许在子线程中对UI进行操作和渲染的，不然会造成未知的错误和问题，甚至会导致crash。我们在最近几个版本中发现新增了一些crash，调查原因就是在子线程中操作UI导致的。为了对于这种情况可以提早被我们发现，我在在DorameonKit中增加了子线程UI渲染检查查询。

具体事项思路，我们hook住UIView的三个必须在主线程中操作的绘制方法。1、setNeedsLayout 2、setNeedsDisplay 3、setNeedsDisplayInRect:。然后判断他们是不是在子线程中进行操作,如果是在子线程进行操作的话，打印出当前代码调用堆栈，提供给开发进行解决。具体代码如下：

@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];
        }
    }
}
 
@end

2.6：日志显示

这个主要是方便我们查看本地日志，以前我们如果要查看日志，需要自己写代码，访问沙盒导出日志文件，然后再查看。也是比较麻烦的。

DoraemonKit的解决方案是：我们每一次触发日志的时候，都把日志内容显示到界面上，方便我们查看。 如何实现的呢？因为我们这个工具并不是一个通用性的工具，只针对于底层日志库是CocoaLumberjack的情况。稍微讲一下的CocoaLumberjack原理，所有的log都会发给DDLog对象，其运行在自己的一个GCD队列中，之后，DDLog会将log分发给其下注册的一个或者多个Logger中，这一步在多核下面是并发的，效率很高。每一个Logger处理收到的log也是在它们自己的GCD队列下做的，它们询问其下的Formatter，获取Log消息格式，然后根据Logger的逻辑，将log消息分发到不同的地方。系统自带三个Logger处理器，DDTTYLogger，主要将日志发送到Xcode控制台；DDASLLogger，主要讲日志发送到苹果的日志系统Console.app; DDFileLogger，主要将日志发送到文件中保存起来，也是我们开发用到最多的。但是自带的Logger并不满足我们的需求，我们的需求是将日志显示到UI界面中，所以我们需要新建一个类DoraemonLogger，继承于DDAbstractLogger，然后重写logMessage方法，将每一条传过来的日志打印到UI界面中。

DoraemonKit项目地址：github.com/didi/Doraem…

转自：https://blog.csdn.net/weixin_33737134/article/details/91469113

移动架构 (一) 架构第一步，学会画各种 UML 图

移动架构 (二) Android 中 Handler 架构分析，并实现自己简易版本 Handler 框架

移动架构 (三) AMS 源码分析

移动架构 (四) EventBus 3.1.1 源码分析及实现自己的轻量级 EventBus 框架，根据 TAG 发送接收事件。

移动架构 (五) 仅仅对 Java Bean 的操作，就能完成对数据持久化

移动架构 (六) 轻量级进程间通信框架设计

为什么要组件化？

随着项目不断的迭代 , 代码越来越臃肿 , 人员也越来越多 , 同时在一个 module 中共同开发 , 首先来说维护成本极高 , 不易管理扩展 , 现在就有了模块化的思想 , 把模块之间共用的代码(网络框架, 图片框架, 异步框架, 日志框架, 显示小部件 View 等)，不同的功能。抽取成单独的 core module 和多个功能 module 。这样每个人负责自己的 module 开发，便于管理，协同开发。

当 module 越来越多，这又出现了一个问题，编译时间很长，为了解决这个问题，最后把每个 module 做成可配置，支持单独调试，大大的提升了开发效率。

模块化、组件化、插件化

模块化

在项目中根据不同的功能需求，和共用的代码抽取出来，形成单独的 module , 这就是模块化。

组件化

组件化是建立在模块化思想上的一次升级，一个变种。组件化本来就是模块化的概念，只是具有可变性，在线上环境是 module lib , debug 环境是 application 。组件化的单位是 application

插件化

其实插件化也是基于模块化的思想，将一个完整的工程，按业务划分为不同的插件，来化整为零，相互配合。插件化的单位是 apk , 可以实现对 apk 的动态加载，更新，比组件化更灵活。

如何实现组件化

在实现之前我们先来看下最终效果吧

目录结构:

效果:

1. 组件支持单独调试(application , lib 切换)

1.1 项目 build.gradle 配置是否需要单独调试环境

ext {  

  	// extend 

    // false: 组件模式

    // true ：集成模式

    isModule = false

}

复制代码

1.2 module 中 build.gralde 配置

//根据isModule标签动态的切换 集成/组件模式

if (isModule){

    apply plugin: 'com.android.library'

}else{

    apply plugin: 'com.android.application'

}

复制代码

android{

...

defaultConfig {

        //资源配置

        sourceSets{

            main{

                //在组件模式下 使用不同的manifest文件

                if(!isModule){

                    manifest.srcFile 'src/main/module/AndroidManifest.xml'

                    java.srcDirs 'src/main/module/java','src/main/java'

                }else{

                    manifest.srcFile 'src/main/AndroidManifest.xml'

                }

            }

        }

		}

...

}

复制代码

切换之后就可以单独运行了。

2. 代码隔离

将不同业务代码抽离成单独的 module，然后在宿主 APP 中根据调试环境依赖。

dependencies {

    implementation fileTree(dir: 'libs', include: ['*.jar'])

    if (isModule) {

        //对代码跟资源进行隔离

        runtimeOnly project(path: ':modulea')

        runtimeOnly project(path: ':moduleb')

    }

}

复制代码

这里如果有人对依赖方式不了解的话，可以看下面这张表

3. 组件之间交互

这里用到了我的轻量级 YEventBus 通信框架，如果想详细了解怎么使用和原理的可以看下我之前写的这篇文章轻量级 EventBus 框架，根据 TAG 发送接收事件

4. UI 跳转

UI 跳转框架这里我没有自己写，用的 alibaba 开源的组件化路由框架 ARouter

总结

到这里我相信大家对组件化已经有了一定的了解, 我们已经把组件化的模型搭建好了，现在可以根据自己的业务需求搭建一套属于自己项目上的组件化框架。

文章中所有代码已上传 GitHub YKComponent

感谢

得到开源组件化框架

通过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