Cómo importar ReactiveCocoa

1. ReactiveCocoa

ReactiveCocoa (RAC para abreviar) es un nuevo marco de código abierto de Github para el desarrollo de iOS y OS. Cocoa es la abreviatura de todo el marco de trabajo de Apple, por lo que muchos marcos de Apple. Me gustaría terminar con Cocoa.

2. El papel de ReactiveCocoa

En nuestro proceso de desarrollo de iOS, a menudo respondemos a ciertos eventos para procesar cierta lógica empresarial, como clics en botones, actualizaciones desplegables y red. solicitudes Cambios en atributos (a través de KVO) o cambios en la ubicación del usuario (a través de CoreLocation). Pero estos eventos se manejan de diferentes maneras, como acción, delegado, KVO, devolución de llamada, etc.

De hecho, estos eventos se pueden procesar a través de RAC. ReactiveCocoa proporciona muchos métodos de procesamiento para eventos, y es muy conveniente usar RAC para procesar eventos. Puede colocar el código de las cosas a procesar y el. cosas para monitorear juntas, lo cual es muy conveniente para nosotros de administrar y no es necesario saltar al método correspondiente. Es muy consistente con nuestras ideas de alta agregación y bajo acoplamiento en el desarrollo.

3. Ideas de programación

No podemos confiar demasiado en un determinado marco durante el desarrollo; de lo contrario, el marco no se actualizará, lo que no permitirá mantener el proyecto más adelante, como por ejemplo. Lo que Facebook proporcionaba antes del marco Three20 también era un artefacto en ese momento, pero ya no se actualizaba y nadie lo usaba. Por lo tanto, creo que para aprender un marco, todavía es necesario comprender sus ideas de programación.

Primero, introduzcamos brevemente las ideas de programación que conocemos actualmente.

3.1 Orientado a procesos: procesar cosas toma el proceso como núcleo y se implementa paso a paso.

3.2 Orientado a objetos: todo es un objeto

3.3 Idea de programación en cadena: múltiples operaciones (múltiples líneas de código) se vinculan entre sí mediante un punto (.) para formar una oración de código.Hacer el código más legible. a(1).b(2).c(3)

Características de la programación en cadena: el valor de retorno del método es bloque, el bloque debe tener un valor de retorno (su propio objeto) y parámetros de bloque (valores que necesitan ser operados) )

Representa: marco de mampostería.

Imita mampostería, escribe una calculadora de sumas y practica ideas de programación en cadena.

Snip20150925_2.png

Snip20150925_1.png

Paste_Image.png

3.4 Ideas de programación responsiva: no es necesario considerar la llamada orden, solo necesita conocer y considerar los resultados, que es similar al efecto mariposa. Cuando ocurre un evento, afectará muchas cosas. Estos eventos se propagan como flujos y luego afectan los resultados. , todo es un flujo.

Representante: aplicación KVO.

3.5 Idea de programación funcional: intente escribir operaciones como una serie de llamadas a métodos o funciones anidadas.

Características de la programación funcional: cada método debe tener un valor de retorno (su propio objeto), usar funciones o bloques como parámetros, bloquear parámetros (valores que deben operarse), bloquear valores de retorno (resultados de la operación)

Representante: ReactiveCocoa.

Utilice programación funcional para implementar, escriba una calculadora de suma, y ​​la calculadora de suma tiene su propio criterio sobre si es igual a un determinado valor.

Paste_Image.png

Paste_Image .png

4. Ideas de programación de ReactiveCocoa

ReactiveCocoa combina varios estilos de programación:

Programación funcional (Programación funcional)

Programación reactiva

Es posible que hayas oído describir a ReactiveCocoa como un marco de programación reactiva funcional (FRP).

Cuando utilice RAC para resolver problemas en el futuro, no es necesario considerar la secuencia de llamadas, sino considerar directamente los resultados. Cada operación se escribe en una serie de métodos anidados, de modo que el código sea altamente. agregado y fácil de gestionar.

5. Cómo importar el framework ReactiveCocoa

CocoaPods (complemento para administrar frameworks de terceros) se suele utilizar para ayudarnos a importar.

PD: Tutorial de CocoaPods

Nota:

Si el archivo pod solo describe el pod 'ReactiveCocoa', '~gt; lo hará La importación no tuvo éxito.

Snip20150926_1.png

Mensaje de error

Snip20150926_2.png

Debes agregar use_frameworks al podfile y volver a instalar el pod en importar con éxito.

Snip20150926_3.png

6.Clases comunes de ReactiveCocoa.

Lo primero que debe aprender sobre el marco: personalmente, creo que primero debe comprender las clases más utilizadas en el marco. La clase principal en RAC es RACSiganl. Una vez que obtenga esta clase, podrá desarrollarla. con Cacao Reactivo.

6.1RACSiganl: Clase de señal, generalmente indica que habrá transmisión de datos en el futuro. Siempre que los datos cambien, la señal enviará los datos inmediatamente después de recibirlos internamente.

Nota:

La clase de señal (RACSiganl) solo significa que cuando los datos cambian, la señal enviará datos internamente. No tiene la capacidad de enviar señales por sí misma, pero. se lo entrega a un suscriptor interno para que lo envíe.

De forma predeterminada, una señal es una señal fría, es decir, no se activará si el valor cambia. Solo al suscribirse a esta señal, la señal se convertirá en una señal activa y se activará. si el valor cambia.

Cómo suscribirse a la señal: Puedes suscribirte llamando a subscribeNext de la señal RACSignal.

RACSiganl es fácil de usar:

// Pasos de uso de RACSignal:

// 1. Crear señal (RACSignal *)createSignal: (RACDisposable * (^ )( idlt; ​​​​RACSubscribergt; suscriptor))didSubscribe

// 2. Suscríbete a la señal para activar la señal - (RACDisposable *)subscribeNext: (void (^)(id x))nextBlock.

// 3. Enviar señal - (void)sendNext: (id)value

// La implementación subyacente de RACSignal:

// 1. Crear una señal, primero guarde suscribirse a la señal, aún no se activará.

// 2. Cuando la señal está suscrita, es decir, llamar al subscribeNext: nextBlock de la señal

// 2.2 subscribeNext creará un suscriptor internamente y guardará el nextBlock para el suscriptor.

// 2.1 SubscribeNext llama internamente a didSubscribe de siganl

// 3. Llamadas didSubscribe de siganl [subscriber sendNext: @1]

// 3.1 La capa inferior; de sendNext es en realidad el nextBlock que ejecuta el suscriptor

// 1. Crear señal

RACSignal *siganl = [RACSignal createSignal: ^RACDisposable *(idlt; ​​​​RACSubscribergt; suscriptor) {

p>

//Bloquear tiempo de llamada: Siempre que un suscriptor se suscriba a la señal, se llamará al bloqueo.

// 2. Enviar señal

[subscriber sendNext: @1];

// Si no estás enviando datos, lo mejor es enviar el señal para completar, y el interno Llama automáticamente a [RACDisposable desechable] para cancelar la suscripción a la señal.

[subscriber sendCompleted];

return [RACDisposable desechableWithBlock:^{

// tiempo de llamada del bloque: cuando se envía la señal o se envía un error, Automáticamente ejecutará este bloque para darse de baja de la señal.

// Después de ejecutar el bloque, la señal actual ya no está suscrita.

NSLog(@"La señal fue destruida");

}];

}]

// 3. Suscríbete a la señal, la señal se activará.

[siganl subscribeNext: ^(id x) {

//Tiempo de llamada del bloque: cada vez que una señal envía datos, se llamará al bloque.

NSLog(@"Datos recibidos: @", x);

}];

6.2 RACSubscriber: Indica el significado del suscriptor, utilizado para enviar. señales, este es un protocolo, no una clase. Siempre que cumpla con este protocolo e implemente el método, puede convertirse en suscriptor. La señal creada a través de create tiene un suscriptor que le ayuda a enviar datos.

6.3 RACDisposable: Se utiliza para cancelar la suscripción o limpiar recursos. Se activará automáticamente cuando se envíe la señal o se envíe un error.

Escenario de uso: Cuando no quieras escuchar una señal, puedes usarlo para darte de baja activamente de la señal.

6.4 RACSubject: RACSubject: proveedor de señal, que puede actuar como señal y enviar señales.

Escenarios de uso: Generalmente se usa para reemplazar agentes. Con él, no es necesario definir agentes.

6.5 RACReplaySubject: Proveedor de señales repetidas, una subclase de RACSubject.

Escenarios de uso: si es necesario enviar una señal repetidamente cada vez que se suscribe, utilice la repetición para proporcionar la clase de señal.

RACSubject y RACReplaySubject son fáciles de usar:

// Pasos de uso de RACSubject

// 1. Cree una señal [Asunto RACSubject], que sea diferente de RACSiganl. Crea una señal cuando no hay ningún bloque.

// 2. Suscríbete a la señal - (RACDisposable *)subscribeNext: (void (^)(id x))nextBlock

// 3. Envía la señal sendNext: ( id)value

// RACSubject: La implementación subyacente es diferente de RACSignal.

//// 1. Llame a subscribeNext para suscribirse a la señal, que solo guarda al suscriptor, y al nextBlock del suscriptor se le ha asignado un valor.

// 2. Llame a sendNext para enviar una señal, recorra todos los suscriptores que acaba de guardar y llame al siguiente bloque del suscriptor uno por uno.

// 1. Crear señal

RACSubject *subject = [RACSubject sujeto]

// 2. Suscríbete a la señal

[ asunto subscribeNext: ^(id x) {

// tiempo de llamada del bloque: cuando la señal emite un nuevo valor, se llamará.

NSLog(@"Primer suscriptor@ " , x);

}];

[subject subscribeNext: ^(id x) {

// tiempo de llamada en bloque: cuando la señal emite un se llamará al nuevo valor.

NSLog(@"Segundo suscriptor@", x);

}];

// 3. Enviar señal

[subject sendNext:@"1"];

// Pasos para usar RACReplaySubject:

// 1. Cree la señal [RACSubject asunto], que es diferente de RACSiganl Asimismo, no hay ningún bloqueo al crear una señal.

// 2. Puedes suscribirte a la señal primero o enviar la señal primero.

// 2.1 Suscribirse a la señal - (RACDisposable *)subscribeNext: (void (^)(id x))nextBlock

// 2.2 Enviar la señal sendNext: (id) valor

// RACReplaySubject: la implementación subyacente es diferente de RACSubject.

// 1. Llame a sendNext para enviar la señal, guarde el valor, luego recorra todos los suscriptores que acaba de guardar y llame al nextBlock del suscriptor uno por uno.

// 2. Llame a subscribeNext para suscribirse a la señal, repita todos los valores guardados y llame al nextBlock del suscriptor uno por uno

// Si desea que una señal sea suscrito, repita la reproducción anterior. Todos los valores deben enviar la señal primero y luego suscribirse a la señal.

// Es decir, guarde el valor primero y luego suscríbase al valor.

// 1. Crear señal

RACReplaySubject *replaySubject = [RACReplaySubject sujeto]

// 2. Enviar señal

[ replaySubject sendNext: @1];

[replaySubject sendNext: @2];

// 3. Señal de suscripción

[replaySubject subscribeNext: ^(id x ) {

NSLog(@"Datos recibidos por el primer suscriptor@", x

}]

//Señal de suscripción

[replaySubject subscribeNext: ^(id x) {

NSLog(@"Datos recibidos por el segundo suscriptor@", x);

} ];

Agente de reemplazo RACSubject // 1. Crear comando

RACCommand *command = [[RACCommand alloc] initWithSignalBlock: ^RACSignal *(entrada de id) {

NSLog(@"Ejecutar comando");

// Crea una señal vacía y debe devolver la señal

// return [RACSignal vacía];

// 2. Crea una señal para transmitir datos

return [RACSignal createSignal: ^RACDisposable *(idlt; ​​​​RACSubscribergt; suscriptor) {

[suscriptor sendNext: @"solicitar datos"]

// Nota: Después de transferir los datos, es mejor llamar a sendCompleted, luego se ejecutará el comando.

[envío del suscriptorCompleted];

retorno nulo

}]; / Comando de referencia fuerte, no lo destruya, de lo contrario no se recibirán datos

_conmmand = comando;

// 3. Suscríbase a la señal en RACCommand

[comando .executionSignals subscribeNext: ^(id x) {

[x subscribeNext: ^(id x) {

NSLog(@"@",x);

}];

}];

//Uso avanzado de RAC

// switchToLatest: utilizado para señal de señales para obtener la última versión. información enviada por señal de señales Señal, es decir, puede obtener la señal directamente en RACCommand

[command.executionSignals.switchToLatest subscribeNext: ^(id x) {

NSLog(@ "@", x);

}];

// 4. Supervise si el comando se ha ejecutado. De forma predeterminada, aparecerá una vez. Saltar significa saltarse la primera señal.

[[command.executing skip: 1] subscribeNext: ^(id x) {

if ([x boolValue] == SÍ) {

/ / Ejecutando

NSLog(@"Ejecutando");

}else{

// Ejecución completada

NSLog(@ "Ejecución completado");

}

}];

// 5. Ejecutar comando

[self.conmmand ejecutar: @1 ];

6.9RACMulticastConnection: se utiliza cuando una señal se suscribe varias veces para garantizar que el bloque en la señal se cree sin múltiples llamadas al bloque en la creación de la señal, lo que causa efectos secundarios. se puede utilizar para manejarlo.

Nota de uso: RACMulticastConnection se crea mediante el método -publish o -muticast: de RACSignal.

RACMulticastConnection es fácil de usar:

// Pasos de uso de RACMulticastConnection:

// 1. Crear señal (RACSignal *)createSignal: (RACDisposable * (^)(idlt; ​​​​RACSubscriberwww.DDTSOFT.COM?subscriber))didSubscribe

// 2. Crear conexión RACMulticastConnection * connect = [publicar señal]

// 3. Suscríbete a la señal Nota: Lo que te suscribes no es la señal anterior, sino la señal conectada. [connect.signal subscribeNext: nextBlock]

// 4. Conectar [connect connect]

// El principio subyacente de RACMulticastConnection:

// 1. Crear connect, connect.sourceSignal -gt; RACSignal (señal original) connect.signal -gt; RACSubject

// 2. La suscripción a connect.signal llamará a subscribeNext de RACSubject, creará un suscriptor y guardará el suscriptor Arriba, el bloqueo no se ejecutará.

// 3.[connect connect] se suscribirá a RACSignal (señal original) internamente, y el suscriptor es RACSubject

// La suscripción a la señal original llamará a la original. señal didSubscribe

// 3.2 didSubscribe, obtiene el suscriptor y llama a sendNext, que en realidad llama a sendNext de RACSubject

// 4. SendNext de RACSubject atravesará todos los suscriptores de RACSubject para enviar señales.

// 4.1 Debido a que en el segundo paso, todos se suscriben a RACSubject, obtendrá todos los suscriptores en el segundo paso y llamará a su nextBlock

// Requisitos: Supuesto Al enviar la solicitud en una señal, se enviará la solicitud una vez por suscripción, lo que generará múltiples solicitudes.

// Solución: use RACMulticastConnection para resolverlo.

// 1. Crear señal de solicitud

RACSignal *signal = [RACSignal createSignal: ^RACDisposable *( idlt; ​​RACSubscribert; suscriptor) {

NSLog(@"Enviar solicitud");

devolución nula

}]; p> // 2. Suscríbete a la señal

[signal subscribeNext: ^(id x) {

NSLog(@"Recibir datos");

} ];

// 2. Suscríbete a la señal

[signal subscribeNext: ^(id x) {

NSLog(@"Recibir datos");

}];

// 3. Como resultado de la operación, la solicitud se enviará dos veces, es decir, se enviará una solicitud por cada suscripción

// RACMulticastConnection: Resuelve el problema de solicitudes repetidas

// 1. Crear señal

RACSignal *signal = [RACSignal createSignal: ^RACDisposable *(idlt; ​​​​RACSubscribergt; suscriptor) {

NSLog(@" Enviar solicitud");

[suscriptor enviarNext:@1];

devolver nil;

}];

// 2 .Crea una conexión

RACMulticastConnection *connect = [señal de publicación];

// 3. Suscríbete a la señal,

// Nota: La suscripción a la señal no se puede activar. La señal simplemente guarda los suscriptores en la matriz y debe pasar la conexión. Cuando se llama a la conexión, se llamará a sendNext de todos los suscriptores a la vez:

[connect.signal subscribeNext: ^(id x) {

NSLog(@"Señal de suscriptor"

}]; p>[connect.signal subscribeNext: ^(id x) {

NSLog(@"Suscriptor dos señales");

}];

// 4. Conectar, activar señal

[connect connect];

6.10 RACScheduler: Cola en RAC, encapsulada por GCD.

6.11 RACUnit: La tabla?stream no contiene valores significativos, es decir, cuando ve esto, puede entenderse directamente como nulo.

6.12 RACEvent: Empaqueta los datos en eventos de señal (evento de señal). Se utiliza principalmente a través de -materialize de RACSignal, pero no está disponible.

7. Uso común en el desarrollo de ReactiveCocoa.

7.1 Proxy alternativo:

rac_signalForSelector: se utiliza en sustitución del proxy.

7.2 Reemplazar KVO:

rac_valuesAndChangesForKeyPath: Se utiliza para monitorear los cambios de atributos de un objeto.

7.3 Escucha de eventos:

rac_signalForControlEvents: se utiliza para escuchar un evento.

7.4 En lugar de notificación:

rac_addObserverForName: usado para escuchar una notificación.

7.5 Monitorear cambios de texto en el cuadro de texto:

rac_textSignal: Esta señal se emitirá mientras el cuadro de texto cambie.

7.6 Procesamiento Cuando la interfaz tiene múltiples solicitudes, es necesario obtener la interfaz antes de poder mostrarla

rac_liftSelector: withSignalsFromArray: Signals: Cuando las señales entrantes (matriz de señales), Cada señal ha enviadoNext al menos una vez y se activará el método del primer parámetro selector.

Nota de uso: Para varias señales, el método de parámetro uno solo tiene varios parámetros, y cada parámetro corresponde a los datos enviados por la señal.

Demostración de código 7.7

// 1. Reemplazar el proxy

// Requisito: personalizar redView y monitorear los clics en los botones en la vista roja

// Anteriormente, era necesario escuchar a través del proxy, agregar un atributo de proxy a la Vista roja y, cuando se hace clic en el botón, notificar al proxy para que haga algo

// rac_signalForSelector: convierte el información sobre cómo llamar al método de un objeto Para señalar, debe llamar a este método y se enviará la señal.

// Esto significa que mientras redV llame a btnClick:, enviará una señal y simplemente se suscribirá.

[[redV rac_signalForSelector:@selector(btnClick:)] subscribeNext:^(id x) {

NSLog(@"Haga clic en el botón rojo");

}];

// 2.KVO

// Convierta el cambio del atributo central de monitoreo de redV en una señal, y la señal se enviará siempre que el cambios de valor

// observador: se puede pasar nil

[[redV rac_valuesAndChangesForKeyPath: @"center" opciones: NSKeyValueObservingOptionNew observador: nil] subscribeNext: ^(id x) {

NSLog(@" @", Se enviará una señal

[[self.btn rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(id x) {

NSLog (@"Se hizo clic en el botón");

}];