Behavior Subject | RxDart

• Behavior Subject | RxDart

O BehaviorSubject é um tipo específico de Subject encontrado no pacote rxdart, amplamente utilizado em aplicações Flutter/Dart para gerenciar fluxos de dados (streams). Ele faz parte da Programação Reativa e, em resumo, é uma ferramenta de emissão de eventos que pode emitir e ouvir eventos de dados de forma assíncrona, sendo especialmente útil em arquiteturas reativas, como o padrão BLoC (Business Logic Component), que é muito popular no Flutter.

Diferença do BehaviorSubject para outros Subjects

O BehaviorSubject tem uma característica que o diferencia de outros tipos de Subject: ele armazena o último valor emitido e o disponibiliza automaticamente para qualquer novo ouvinte (subscriber). Isso significa que, se um novo ouvinte se inscrever após alguns eventos já terem sido emitidos, ele ainda assim terá acesso ao último valor que foi transmitido, mesmo antes de sua inscrição.

Características principais do BehaviorSubject

1. Armazena o último valor: Quando você assina (subscribe) o BehaviorSubject, ele imediatamente emite o último valor que foi armazenado.

2. Emite novos valores: Continuará a emitir novos valores sempre que houver novos dados inseridos no stream.

3. Gerenciamento de estado reativo: É útil em cenários onde o estado precisa ser compartilhado e atualizado de forma reativa entre diferentes partes da interface (UI) da aplicação Flutter.

Uso comum

Na arquitetura BLoC, por exemplo, você pode usar o BehaviorSubject para controlar o estado de uma tela. Imagine um formulário que atualiza sua interface com base em mudanças de valores. Usando um BehaviorSubject, qualquer campo ou widget que assine este subject será automaticamente atualizado sempre que um novo dado for emitido.

Exemplo básico

Aqui está um exemplo simples de como o BehaviorSubject pode ser usado:

import 'package:rxdart/rxdart.dart';

class CounterBloc {
  // Inicializa o BehaviorSubject com um valor inicial de 0
  final BehaviorSubject<int> _counterSubject = BehaviorSubject<int>.seeded(0);

  // Stream para expor os dados
  Stream<int> get counterStream => _counterSubject.stream;

  // Função para incrementar o contador
  void increment() {
    _counterSubject.add(_counterSubject.value + 1);
  }

  // Fechar o BehaviorSubject para liberar os recursos
  void dispose() {
    _counterSubject.close();
  }
}

Neste exemplo:

• O BehaviorSubject<int>.seeded(0) inicia o subject com o valor inicial 0.
• A função increment adiciona um novo valor ao BehaviorSubject, que incrementa o valor atual.
• A Stream<int> get counterStream expõe a stream para ser escutada em widgets de UI.

No lado da interface, você pode conectar esse stream a um widget Flutter, como o StreamBuilder, que vai atualizar automaticamente a interface quando um novo valor for emitido:

class CounterWidget extends StatelessWidget {
  final CounterBloc bloc = CounterBloc();

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<int>(
      stream: bloc.counterStream,
      builder: (context, snapshot) {
        return Column(
          children: [
            Text('Contador: ${snapshot.data}'),
            ElevatedButton(
              onPressed: () => bloc.increment(),
              child: Text('Incrementar'),
            ),
          ],
        );
      },
    );
  }
}

Quando usar BehaviorSubject?

• Gerenciamento de estado: Quando você precisa manter o estado da aplicação e garantir que novos ouvintes obtenham o valor mais recente.
• Formulários reativos: Ao gerenciar formulários em que os campos de entrada precisam refletir o estado atual e onde mudanças no estado precisam atualizar a interface do usuário instantaneamente.
• Arquitetura BLoC: Um uso comum é no padrão BLoC, onde ele ajuda a manter o estado e propagar mudanças para a interface de maneira eficiente e reativa.

Cuidados

• Gerenciamento de recursos: É importante lembrar de chamar o método close() no BehaviorSubject quando ele não for mais necessário, para evitar memory leaks (vazamento de memória).
• Sobrecarga de armazenamento: Embora útil, o armazenamento do último valor pode ser desnecessário em certos cenários, especialmente se o histórico não for relevante para a aplicação.