Trabalhadores da arquitetura Clean Swift

Olá leitor!

Antes, examinamos como o ciclo VIP é organizado e como fazer transições entre preços e transferência de dados. Agora você precisa descobrir como descarregar nosso Interactor de uma superabundância de lógica e retirá-lo para reutilização em outras cenas. E os trabalhadores nos ajudarão com isso. O tópico é bastante modesto em volume, mas importante para menção.

Teoria

Trabalhadores são classes / estruturas auxiliares (que não devem ser confundidas com serviços ou ajudantes) cuja tarefa é assumir parte da lógica de negócios do Interactor . Se os métodos no Interactor estão se expandindo, é hora de remover a lógica volumosa no Worker . No Clean Swift, eles são usados ​​para trabalhar com a lógica do armazenamento de dados, com a rede, com camadas individuais do aplicativo e assim por diante. Em outras palavras, tudo é volumoso, de baixo nível e não está relacionado à lógica de negócios do aplicativo.

Os trabalhadores são divididos em dois tipos principais:

1. Local usado apenas dentro da cena.
2. Global que estão disponíveis para qualquer cena.

Trabalhadores locais são colocados diretamente dentro da cena e recebem o nome dela - SceneNameWorker . Os Trabalhadores Globais estão localizados no diretório raiz dos Trabalhadores e são nomeados de acordo com o assunto. Trabalhadores locais também podem atuar como “decoradores em todo o mundo”, com lógica estendida para as necessidades da cena.

Se você usar a separação do projeto em camadas ( apresentação , lógica de negócios , persistência , lógica de rede ), a função da ponte de conexão entre a camada de apresentação e a lógica de negócios poderá ser atribuída aos trabalhadores . Assim, descarregaremos o Interactor , obteremos um comportamento mais previsível e a facilidade de reutilização.

Prática

O trabalho dos Trabalhadores que consideraremos no exemplo de trabalho com a rede. Teremos duas telas - na primeira é exibida uma lista de usuários e, na segunda, uma lista de postagens desse usuário. Todos os dados serão coletados pela API . Dividiremos essa tarefa em três trabalhadores , dois locais e um global, que atuarão como um ponto de entrada para os outros dois. Esconderei a implementação dos métodos em si no artigo, e quem quiser experimentar na prática, haverá um link para o projeto finalizado no final do artigo.



Essa estrutura do projeto não é uma referência para trabalhar com uma rede e não reflete de forma alguma como trabalhar com ela no Clean Swift . Tudo isso é feito apenas para um bom exemplo do papel dos Trabalhadores locais e globais.

Para começar, crie um Worker global - NetworkWorker . Coloque-o no diretório Trabalhadores , no mesmo nível que o diretório Cenas . No exemplo abaixo, existe um método sendRequest (para: params: conclusão) , que será comum aos Trabalhadores locais. Ele executa uma tarefa de rotina - forma um link a partir dos parâmetros, envia uma solicitação e envia o resultado para conclusão .

struct NetworkWorker { // MARK: - Private Properties private let session = URLSession.shared // MARK: - Public Methods ///  Worker.    API /// /// - Parameters: /// - to: ,     /// - params:    /// - completion:     func sendRequest(to: URL, params: [String: String], completion: @escaping (Data?, Error?) -> Void) { // ... } } 

Para a primeira cena, precisamos obter uma lista de APIs de todos os usuários. Para isso, criamos um HomeWorker local que irá configurar os parâmetros para carregar usuários e chamar sendRequest (para: params: conclusão) no NetworkWorker com esses parâmetros. Agora, no Interactor da cena , precisamos chamar fetchUsers (conclusão :) e enviar os dados recebidos para processamento ao Presenter .

Quando você clica em uma célula da tabela com o nome de usuário, faremos a transição e transferiremos o usuário selecionado para outra cena.

 struct HomeWorker { // MARK: - Private Properties private let networkWorker = NetworkWorker() private let usersURL = URL(string: "https://jsonplaceholder.typicode.com/users") // MARK: - Public Methods ///  Worker.   API     /// /// - Parameter complete:     func fetchUsers(_ complete: @escaping ([User]?) -> Void) { // ... } } 

Na página com postagens de usuários, criamos PostsWorker , mas apenas com o método fetchPosts (userId: complete :) . Nele passamos o ID do usuário cujas postagens você deseja baixar. No método, formamos os parâmetros e chamamos sendRequest (para: params: conclusão) no NetworkWorker . E da mesma maneira que antes, chamamos o método fetchPosts (userId: complete :) no Interactor da cena, passando os dados recebidos para o Presenter .

 struct PostsWorker { // MARK: - Private Properties private let networkWorker = NetworkWorker() private let postsURL = URL(string: "https://jsonplaceholder.typicode.com/posts") // MARK: - Public Methods ///   API      /// /// - Parameters: /// - userId: ID ,     /// - completed:     func fetchPosts(userId: Int, _ completed: @escaping ([Post]?) -> Void) { // ... } } 

Agora toda a nossa implementação foi movida para arquivos separados que podem ser reutilizados, sem carregar a lógica de negócios no Interactor .

Conclusão

Embora os trabalhadores sejam muito simples e não revelem nenhum conhecimento oculto sobre arquitetura, seu uso é importante no Clean Swift . Ao escrever Trabalhadores , não esqueça de protocolos, padrões estruturais e DI. Caso contrário, você rapidamente formará uma confusão de Trabalhadores , onde tudo o que poderia ser retirado foi retirado em pedaços.

Isso é tudo. Obrigado pela leitura até o final, abaixo está um link para o projeto completo.

Série de artigos

1. Visão geral da arquitetura Clean Swift
2. Roteador e transmissão de dados na arquitetura Clean Swift
3. Trabalhadores da arquitetura Clean Swift (você está aqui)
4. Teste de unidade na arquitetura Clean Swift
5. Um exemplo de uma arquitetura simples de loja online Clean Swift

Link para o projeto
Ajuda para escrever um artigo: Bastien