iOS - Block 代码块

2016-08-13 400

1、Block

Block 是一段预先准备好的代码，可以在需要的时候执行，可以当作参数传递。Block 可以作为函数参数或者函数的返回值，而其本身又可以带输入参数或返回值。Block 是 C 语言的，类似于一个匿名函数，它和传统的函数指针很类似，但是 Block 是 inline（内联函数）的，并且默认情况下它对局部变量是只读的。
苹果官方建议尽量多用 Block。在多线程、异步任务、集合遍历、集合排序、动画转场用的很多。

Block 语法

    // Block as a local variable
    returnType (^blockName)(parameterTypes) = ^returnType(parameters) {...};

    // Block as a property
    @property (nonatomic, copy) returnType (^blockName)(parameterTypes);

    // Block as a method parameter
    - (void)someMethodThatTakesABlock:(returnType (^)(parameterTypes))blockName;

    // Block as an argument to a method call
    [someObject someMethodThatTakesABlock: ^returnType (parameters) {...}];

    // Block as typedef
    typedef returnType (^TypeName)(parameterTypes);
    TypeName blockName = ^returnType(parameters) {...};

2、Block 的使用

2.1 Block 的定义

Block 的简单定义

    // 定义 Block
    /*
        定义了一个名叫 MySum 的 Block 对象，它带有两个 int 型参数，返回 int 型。等式右边就是 Block 的具体实现，大括号后需加分号
    */
    int (^MySum)(int, int) = ^(int a, int b){

        return a + b;
    };

    // 调用 Block
    int sum = MySum(10, 12);

Block 数据类型的定义

    // 定义 block 数据类型 MyBlock
    typedef int (^MyBlock)(int, int);

    // 定义 MyBlock 的变量
    MyBlock myblock;

    // 实现 MyBlock 的变量 1
    myblock = ^(int a, int b){

        return a + b;
    };

    // 调用 MyBlock 的变量 1
    int sum = myblock(10, 12);

    // 实现 MyBlock 的变量 2
    myblock = ^(int a, int b){

        return a - b;
    };

    // 调用 MyBlock 的变量 2
    int minus = myblock(13, 2);

2.2 Block 访问局部变量

Block 可以访问局部变量，但是不能修改，如果要修改需加关键字 __block（双下划线）。

    // 这样定义时，局部变量 sum 只能读取值不能修改，编译时会报错
    // int sum = 10;

    // 这样定义时，局部变量 sum 既可以读取值又能修改
    __block int sum = 10;

    int (^MyBlock)(int) = ^(int a){

        // 对局部变量值修改
        sum ++;

        // 读取局部变量的值
        return a * sum;
    };

    int result = MyBlock(5);

3、Block 的回调

3.1 Block 回调使用

    // Block1.h
    
        // block 属性变量定义
        /*
            要使用 copy 类型，格式：@property (nonatomic, copy) 返回值类型 (^变量名) (参数类型列表);
        */
        @property (nonatomic, copy) void (^completion) (NSString *);
        
        // 调用 block 代码段声明
        - (void)useBlock;

    // Block1.m

        // 调用 block 代码段
        - (void)useBlock {
                
            // 设置 block 的回调值
                
            // 判断是否设置了 block
            if (self.completion != nil) {
            
                // 设置回调值
                self.completion(@"hello world");
            }
        }

    // Block.m
        
        #import "Block1.h"
        
        Block1 *block = [[Block1 alloc] init];
            
        // 设置 block 代码段
        block.completion = ^(NSString *str) {
            
            // 结果：string = @"hello world"
            NSString *string = str;
        };
            
        // 调用 block 代码段
        [block useBlock];

3.2 Block 回调封装

    // Block2.h
    
        // block 方法参数定义
        
        // 类方法定义
        + (Block2 *)blockWithCompletion:(void (^) (NSString *)) completion;
        
        // 调用 block 代码段声明
        - (void)useBlock;

    // Block2.m

        // block 属性变量定义
        
        // 要使用 copy 类型，格式：@property (nonatomic, copy) 返回值类型 (^变量名) (参数类型列表);
        @property (nonatomic, copy) void (^completion) (NSString *);
        
        // 调用 block 代码段
        - (void)useBlock {
                
            // 设置 block 的回调值
                
            // 判断是否设置了 block
            if (self.completion != nil) {
            
                // 设置回调值
                self.completion(@"hello world");
            }
        }
        
        // 类方法实现
        + (Block2 *)blockWithCompletion:(void (^)(NSString *))completion {
                
            Block2 *bl = [[Block2 alloc] init];
                
            // 设置属性的值
            bl.completion = completion;
                
            return bl;
        }

    // Block.m
        
        #import "Block2.h”
        
        // 设置 block 代码段
        Block2 *block = [Block2 blockWithCompletion:^(NSString *str) {
                
            // 结果：string = @"hello world"
            NSString *string = str;
        }];
            
        // 调用 block 代码段
        [block useBlock];

4、Block 属性定义中为什么使用 copy 修饰

ARC 开发的时候，编译器底层对 block 做过一些优化，使用 copy 修饰可以防止出现内存泄漏。
从内存管理的角度而言，程序员需要管理的内存只有堆区的。如果用 strong 修饰，相当于强引用了一个栈区的变量。

而使用 copy 修饰，在设置数值的时候，可以把局部变量从栈区复制到堆区。

    // 用 copy 修饰定义属性
    @property (nonatomic, copy) void (^myTask)();

    // 定义，myBlock 是保存在栈区的，出了作用域，就应该被销毁
    void (^myBlock)() = ^ {

        NSLog(@"hello");
    };

    // 用属性记录
    self.myTask = myBlock;

    // 执行
    self.myTask();

5、循环引用

1、在 Block 中调用 self 容易产生循环引用，一旦出现循环引用的话内存就得不到释放，因此一定要小心内存管理问题。
```
    @implementation ViewController

    // 在 Block 中调用 self 容易产生循环引用
    [[QWebImageManager sharedManager] downloadImage:self.urlStr completion:^(UIImage *image) {
        self.image = image;
    }];

    @end
```
- 1) 查询内存管理问题解决办法：
  - 1> 打印法
    - 最好在基类 controller 下重写 dealloc，加一句打印日志，表示类可以得到释放。如果出现无打印信息，说明这个类一直得不到释放，表明很有可能是使用 block 的地方出现循环引用了。对于 block 中需要引用外部 controller 的属性或者成员变量时，一定要使用弱引用，特别是成员变量像 _testId 这样的，很多人都没有使用弱引用，导致内存得不到释放。
```
    // 判断是否存在循环引用，无法释放时即存在循环引用
    - (void)dealloc {
        NSLog(@"成功退出");
    }
```
  - 2> 利用 instrument 检测内存泄露
    - 在 Xcode 的 instrument 工具集可以很方便的检测循环引用。Product => profile => 选择 Leaks，之后点击运行，如果出现红色，点击 Details => Cycles&Roots
- 2) 解决循环引用方法
  - 可以使用关键字 __weak 声明一个弱变量，或者为属性指定 weak 特性。如：
```
    @implementation ViewController

    // 弱引用 self，typeof(self) 等价于 ViewController
    __weak typeof(self) weakSelf = self;

    [[QWebImageManager sharedManager] downloadImage:self.urlStr completion:^(UIImage *image) {
        weakSelf.image = image;
    }];

    @end
```
2、当 block 本身不被 self 持有，而被别的对象持有，同时不产生循环引用的时候，就不需要使用 weak self 了。最常见的代码就是 UIView 的动画代码，我们在使用 UIView 的 animateWithDuration:animations 方法做动画的时候，并不需要使用 weak self，因为引用持有关系是：
- UIView 的某个负责动画的对象持有了 block
- block 持有了 self
- 因为 self 并不持有 block，所以就没有循环引用产生，所以就不需要使用 weak self 了。
```
    [UIView animateWithDuration:0.2 animations:^{
        self.alpha = 1;
    }];
```
- 当动画结束时，UIView 会结束持有这个 block，如果没有别的对象持有 block 的话，block 对象就会释放掉，从而 block 会释放掉对于 self 的持有。整个内存引用关系被解除。
3、为什么 weakSelf 需要配合 strong self 使用
- 我们知道，在使用 block 的时候，为了避免产生循环引用，通常需要使用 weakSelf 与 strongSelf，写下面这样的代码。那么请问：为什么 block 里面还需要写一个 strong self。
```
    __weak typeof(self) weakSelf = self;
    [self doSomeBackgroundJob:^{

        __strong typeof(weakSelf) strongSelf = weakSelf;
        if (strongSelf) {
            ...
        }
    }];
```
- 在 block 中先写一个 strong self，其实是为了避免在 block 的执行过程中，突然出现 self 被释放的尴尬情况。通常情况下，如果不这么做的话，还是很容易出现一些奇怪的逻辑，甚至闪退。我们以 AFNetworking 中 AFNetworkReachabilityManager.m 的一段代码举例：
```
    __weak __typeof(self)weakSelf = self;
    AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {

        __strong __typeof(weakSelf)strongSelf = weakSelf;

        strongSelf.networkReachabilityStatus = status;
        if (strongSelf.networkReachabilityStatusBlock) {
            strongSelf.networkReachabilityStatusBlock(status);
        }
    };
```
  - 如果没有 strongSelf 的那行代码，那么后面的每一行代码执行时，self 都可能被释放掉了，这样很可能造成逻辑异常。特别是当我们正在执行 strongSelf.networkReachabilityStatusBlock(status); 这个 block 闭包时，如果这个 block 执行到一半时 self 释放，那么多半情况下会 Crash。
  - 这里有一篇文章详细解释了这个问题：https://dhoerl.wordpress.com/2013/04/23/i-finally-figured-out-weakself-and-strongself/

6、多个异步 Block 按照顺序执行

异步 Block 的执行顺序一般为先执行 Block 前的代码，再执行 Block 之后的代码，最后执行 Block 中的代码，如下代码。

创建

    @property (nonatomic, copy) void (^completion) (NSString *);

    - (void)dlownloadCompletion:(void (^)(NSString *str))completion {

        self.completion = completion;

        if (self.completion) {
            dispatch_async(dispatch_get_global_queue(0, 0), ^{

                [NSThread sleepForTimeInterval:2];

                self.completion(@"Hello World");
            });
        }
    }

使用

    NSLog(@"Hello World 1");

    [self dlownloadCompletion:^(NSString *str) {

        NSLog(@"%@ 2, %@", str, [NSThread currentThread]);
    }];

    NSLog(@"Hello World 3");

执行效果

    22:07:12.520 OCTest[79089:3232021] Hello World 1
    22:07:12.521 OCTest[79089:3232021] Hello World 3
    22:07:14.521 OCTest[79089:3232160] Hello World 2, <NSThread: 0x60000006a500>{number = 3, name = (null)}

那么如何实现先执行 Block 中的代码，再执行 Block 之后的代码呢？使用线程阻塞的方式。

6.1 单个异步 Block

使用

    NSLog(@"Hello World 1");

    // 需要在子线程中执行，否则会阻塞主线程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        NSLog(@"Hello World 2");

        // 创建 semaphore
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        [self dlownloadCompletion:^(NSString *str) {

            NSLog(@"%@ 3, %@", str, [NSThread currentThread]);

            // 发出已完成的信号
            dispatch_semaphore_signal(semaphore);
        }];

        // 等待执行，阻塞线程
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"Hello World 4");
    });

    NSLog(@"Hello World 5");

执行效果

    22:13:40.457 OCTest[63696:2154201] Hello World 1
    22:13:40.458 OCTest[63696:2154201] Hello World 5
    22:13:40.458 OCTest[63696:2154254] Hello World 2
    22:13:42.460 OCTest[63696:2154404] Hello World 3, <NSThread: 0x60000007b840>{number = 3, name = (null)}
    22:13:42.461 OCTest[63696:2154254] Hello World 4

6.2 多个异步 Block

使用

    NSLog(@"Hello World 1");

    // 需要在子线程中执行，否则会阻塞主线程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        NSLog(@"Hello World 2");

        // 创建 semaphore
        dispatch_semaphore_t semaphore1 = dispatch_semaphore_create(0);

        [self dlownloadCompletion:^(NSString *str) {

            NSLog(@"%@ 3, %@", str, [NSThread currentThread]);

            // 发出已完成的信号
            dispatch_semaphore_signal(semaphore1);
        }];

        // 等待执行，阻塞线程
        dispatch_semaphore_wait(semaphore1, DISPATCH_TIME_FOREVER);

        // 创建 semaphore
        dispatch_semaphore_t semaphore2 = dispatch_semaphore_create(0);

        [self dlownloadCompletion:^(NSString *str) {

            NSLog(@"%@ 4, %@", str, [NSThread currentThread]);

            // 发出已完成的信号
            dispatch_semaphore_signal(semaphore2);
        }];

        // 等待执行，阻塞线程
        dispatch_semaphore_wait(semaphore2, DISPATCH_TIME_FOREVER);

        NSLog(@"Hello World 5");
    });

    NSLog(@"Hello World 6");

执行效果

    22:15:24.288 OCTest[63748:2156048] Hello World 1
    22:15:24.289 OCTest[63748:2156048] Hello World 6
    22:15:24.289 OCTest[63748:2156165] Hello World 2
    22:15:26.361 OCTest[63748:2156450] Hello World 3, <NSThread: 0x608000266700>{number = 3, name = (null)}
    22:15:28.429 OCTest[63748:2156450] Hello World 4, <NSThread: 0x608000266700>{number = 3, name = (null)}
    22:15:28.429 OCTest[63748:2156165] Hello World 5

6.3 单 for 循环中异步 Block

使用

    NSLog(@"Hello World 1");

    // 需要在子线程中执行，否则会阻塞主线程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        NSLog(@"Hello World 2");

        // 创建 semaphore
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        // block 完成回调计数
        __block NSInteger count = 0;

        __weak typeof(self) weakSelf = self;

        int loopCount = 10;
        for (int i = 0; i < loopCount; i++) {

            [self dlownloadCompletion:^(NSString *str) {

                NSLog(@"%@ 3 -  %li, %@", str, count, [NSThread currentThread]);

                @synchronized (weakSelf) {

                    // 完成回调计数加 1
                    count++;

                    if (count == loopCount) {

                        [NSThread sleepForTimeInterval:5];

                        // 发出已完成的信号
                        dispatch_semaphore_signal(semaphore);
                    }
                }
            }];
        }

        // 等待执行，阻塞线程
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"Hello World 4");
    });

    NSLog(@"Hello World 6");

执行效果

    22:54:27.550 OCTest[64721:2187151] Hello World 1
    22:54:27.551 OCTest[64721:2187151] Hello World 6
    22:54:27.551 OCTest[64721:2187249] Hello World 2
    22:54:29.615 OCTest[64721:2187248] Hello World 3 -  2, <NSThread: 0x60000026e600>{number = 4, name = (null)}
    22:54:29.615 OCTest[64721:2187276] Hello World 3 -  4, <NSThread: 0x608000266980>{number = 6, name = (null)}
    22:54:29.615 OCTest[64721:2187280] Hello World 3 -  7, <NSThread: 0x608000265c80>{number = 8, name = (null)}
    22:54:29.615 OCTest[64721:2187278] Hello World 3 -  5, <NSThread: 0x608000266740>{number = 7, name = (null)}
    22:54:29.615 OCTest[64721:2187251] Hello World 3 -  1, <NSThread: 0x60000007e200>{number = 3, name = (null)}
    22:54:29.615 OCTest[64721:2187277] Hello World 3 -  3, <NSThread: 0x608000266800>{number = 5, name = (null)}
    22:54:29.615 OCTest[64721:2187281] Hello World 3 -  8, <NSThread: 0x60000026e540>{number = 9, name = (null)}
    22:54:29.615 OCTest[64721:2187279] Hello World 3 -  6, <NSThread: 0x608000266a40>{number = 10, name = (null)}
    22:54:29.615 OCTest[64721:2187282] Hello World 3 -  9, <NSThread: 0x608000266bc0>{number = 11, name = (null)}
    22:54:29.615 OCTest[64721:2187283] Hello World 3 -  10, <NSThread: 0x60000026e800>{number = 12, name = (null)}
    22:54:34.676 OCTest[64721:2187249] Hello World 4

6.4 嵌套 for 循环中异步 Block

使用

    NSLog(@"Hello World 1");

    // 需要在子线程中执行，否则会阻塞主线程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        NSLog(@"Hello World 2");

        // 创建 semaphore
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        // block 完成回调计数
        __block NSInteger count = 0;

        __weak typeof(self) weakSelf = self;

        int loopCount1 = 4;
        int loopCount2 = 5;
        for (int i = 0; i < loopCount1; i++) {

            for (int j = 0; j < loopCount2; j++) {

                [self dlownloadCompletion:^(NSString *str) {

                    NSLog(@"%@ 3 - %li, %@", str, count, [NSThread currentThread]);

                    @synchronized (weakSelf) {

                        // 完成回调计数加 1
                        count++;

                        if (count == loopCount1 * loopCount2) {

                            [NSThread sleepForTimeInterval:5];

                            // 发出已完成的信号
                            dispatch_semaphore_signal(semaphore);
                        }
                    }
                }];
            }
        }

        // 等待执行，阻塞线程
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"Hello World 4");
    });

    NSLog(@"Hello World 6");

执行效果

    23:01:09.926 OCTest[64907:2192862] Hello World 1
    23:01:09.928 OCTest[64907:2192862] Hello World 6
    23:01:09.928 OCTest[64907:2193485] Hello World 2
    23:01:11.931 OCTest[64907:2192981] Hello World 3 - 1, <NSThread: 0x608000260680>{number = 3, name = (null)}
    23:01:11.931 OCTest[64907:2193486] Hello World 3 - 2, <NSThread: 0x600000073080>{number = 23, name = (null)}
    23:01:11.932 OCTest[64907:2193487] Hello World 3 - 3, <NSThread: 0x60000007c880>{number = 24, name = (null)}
    23:01:11.932 OCTest[64907:2193488] Hello World 3 - 4, <NSThread: 0x60000007c8c0>{number = 25, name = (null)}
    23:01:11.933 OCTest[64907:2193489] Hello World 3 - 5, <NSThread: 0x60000007c900>{number = 26, name = (null)}
    23:01:11.933 OCTest[64907:2193490] Hello World 3 - 6, <NSThread: 0x60000007c940>{number = 27, name = (null)}
    23:01:11.933 OCTest[64907:2193491] Hello World 3 - 7, <NSThread: 0x60000007c980>{number = 28, name = (null)}
    23:01:11.933 OCTest[64907:2193492] Hello World 3 - 8, <NSThread: 0x60000007c9c0>{number = 29, name = (null)}
    23:01:11.934 OCTest[64907:2193493] Hello World 3 - 9, <NSThread: 0x60000007ca00>{number = 30, name = (null)}
    23:01:11.934 OCTest[64907:2193494] Hello World 3 - 10, <NSThread: 0x60000007ca40>{number = 31, name = (null)}
    23:01:11.935 OCTest[64907:2193495] Hello World 3 - 11, <NSThread: 0x60000007ca80>{number = 32, name = (null)}
    23:01:11.936 OCTest[64907:2193496] Hello World 3 - 12, <NSThread: 0x608000073f80>{number = 33, name = (null)}
    23:01:11.937 OCTest[64907:2193497] Hello World 3 - 13, <NSThread: 0x60000007cac0>{number = 34, name = (null)}
    23:01:11.938 OCTest[64907:2193498] Hello World 3 - 14, <NSThread: 0x60000007cb00>{number = 35, name = (null)}
    23:01:11.938 OCTest[64907:2193499] Hello World 3 - 15, <NSThread: 0x60000007cb40>{number = 36, name = (null)}
    23:01:11.938 OCTest[64907:2193500] Hello World 3 - 16, <NSThread: 0x60000007cb80>{number = 37, name = (null)}
    23:01:11.939 OCTest[64907:2193501] Hello World 3 - 17, <NSThread: 0x60000007cbc0>{number = 38, name = (null)}
    23:01:11.939 OCTest[64907:2193502] Hello World 3 - 18, <NSThread: 0x60000007cc00>{number = 39, name = (null)}
    23:01:11.940 OCTest[64907:2193503] Hello World 3 - 19, <NSThread: 0x60000007cc40>{number = 40, name = (null)}
    23:01:11.940 OCTest[64907:2193504] Hello World 3 - 20, <NSThread: 0x60000007cc80>{number = 41, name = (null)}
    23:01:17.006 OCTest[64907:2193485] Hello World 4

微信关注我们

原文链接：https://yq.aliyun.com/articles/312200

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

iOS - Delegate 代理

1、Delegate 1.1 协议协议：是多个类共享的一个方法列表。协议中列出的方法没有相应的实现，计划由其他人来实现。协议中列出的方法，有些是可以选择实现，有些是必须实现。 1>、如果你定义了自己的协议，那么不必由自己实现它。但是，这就告诉其他程序员，如果要采用这项协议，则必须实现这些方法。这些方法可以从超类继承。协议不引用任何类，它是无类的。分类也可以采用一项协议。 2>、定义一个协议很简单：只要使用 @protocol 指令，后面跟上你给出的协议名称。定义一项协议时，可以扩展现有协议的定义。 @protocol PlayerDelegate <NSObject> - (void)end; @end 3>、协议的修饰 @optional：该指令之后列出的所有方法都是可选的。 @required：该指令之后列出的所有方都是必须实现的，默认。由于 OC 是弱语法，虽然字面上是必须，但编译器并没有强求实现。 4>、协议的声明 @protocol protocol-name 5>、协议的检查 // 检查一个对象是否遵守某项协议。 - (BOO...

2016-08-14

647

1、Notification 通知中心实际上是在程序内部提供了消息广播的一种机制，它允许我们在低程度耦合的情况下，满足控制器与一个任意的对象进行通信的目的。每一个 iOS 程序（即每一个进程）都有一个自己的通知中心，即 NSNotificationCenter 对象，该对象采用单例设计模式，可以通过类方法 defaultCenter 获得当前进程唯一的通知中心对象。一个 NSNotificationCenter 可以有许多的通知消息 NSNotification，对于每一个 NSNotification 可以有很多的观察者 Observer 来接收通知。NSNotificationCenter 是 iOS 中通知中心的灵魂，由该类实现了观察者模式，并给开发者提供了诸如注册、删除观察者的接口。通知中心以同步的方法将消息转发到所有的观察者中，换言之 NSNotificationCenter 在发送消息后，会一直等待被调用的方法执行完毕，然后返回控制权到主函数中，再接着执行后面的功能，即这是一个同步阻塞的操作。如果我们需要异步的处理消息，直接返回控制权，则应该使用通知队列 NSNotifi...

2016-08-14

641

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

iOS - Block 代码块

1、Block

2、Block 的使用

2.1 Block 的定义

2.2 Block 访问局部变量

3、Block 的回调

3.1 Block 回调使用

3.2 Block 回调封装

4、Block 属性定义中为什么使用 copy 修饰

5、循环引用

6、多个异步 Block 按照顺序执行

6.1 单个异步 Block

6.2 多个异步 Block

6.3 单 for 循环中异步 Block

6.4 嵌套 for 循环中异步 Block

iOS - Delegate 代理

iOS - Notification 通知

相关文章

发表评论

资源下载

腾讯云软件源

Nacos

Spring

Rocky Linux

欢迎您来访！