Travailleurs de l'architecture propre et rapide

Bonjour lecteur!

Plus tôt, nous avons examiné comment le cycle VIP est organisé et comment effectuer des transitions entre les prix et le transfert de données. Vous devez maintenant comprendre comment décharger notre Interactor d'une surabondance de logique et en retirer une partie pour la réutiliser par d'autres scènes. Et les travailleurs nous y aideront. Le sujet est assez modeste en volume, mais important à mentionner.

Théorie

Les travailleurs sont des classes / structures auxiliaires (à ne pas confondre avec les services ou les aides) dont la tâche est de reprendre une partie de la logique métier d’ Interactor . Si les méthodes d' Interactor se développent, il est temps de supprimer la logique volumineuse de Worker . Dans Clean Swift, ils sont utilisés pour travailler avec la logique de stockage des données, avec le réseau, avec les couches individuelles de l'application, etc. En d'autres termes, tout est volumineux, bas niveau et non lié à la logique métier de l'application.

Les travailleurs sont divisés en deux types principaux:

1. Local utilisé uniquement à l'intérieur de la scène.
2. Global qui sont disponibles pour n'importe quelle scène.

Les travailleurs locaux sont placés directement à l'intérieur de la scène et portent son nom - SceneNameWorker . Les travailleurs globaux se trouvent dans le répertoire racine des travailleurs et sont nommés en fonction de leur sujet. Les travailleurs locaux peuvent également agir en tant que «décorateurs au niveau mondial», avec une logique étendue pour les besoins de la scène.

Si vous utilisez la séparation du projet en couches ( Présentation , Business Logic , Persistance , Logique réseau ), le rôle de pont de connexion entre la couche Présentation et Business Logic peut être attribué à Workers . Ainsi, nous allons décharger Interactor , obtenir un comportement plus prévisible et une facilité de réutilisation.

Pratique

Le travail des travailleurs que nous considérerons sur l'exemple du travail avec le réseau. Nous aurons deux écrans - sur le premier une liste d'utilisateurs est affichée, et sur le second une liste de messages de cet utilisateur. Toutes les données seront prises par l' API . Nous diviserons cette tâche en trois travailleurs , deux locaux et un mondial, qui serviront de point d'entrée pour les deux autres. Je cacherai l'implémentation des méthodes elles-mêmes dans l'article, et quiconque veut essayer en pratique, il y aura un lien vers le projet fini à la fin de l'article.



Cette structure de projet n'est pas une référence pour travailler avec un réseau et ne reflète en aucune façon comment l'utiliser avec Clean Swift . Tout cela n'est fait que pour un bon exemple du rôle des travailleurs locaux et mondiaux.

Pour commencer, créez un Worker global - NetworkWorker . Placez-le dans le répertoire Workers , au même niveau que le répertoire Scenes . Dans l'exemple ci-dessous, il existe une méthode sendRequest (to: params: complétement) , qui sera commune aux Workers locaux. Il effectue une tâche de routine - forme un lien à partir des paramètres, envoie une demande et envoie le résultat à son terme .

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) { // ... } } 

Pour la première scène, nous devons obtenir une liste d' API de tous les utilisateurs. Pour ce faire, nous créons un HomeWorker local qui configurera les paramètres de chargement des utilisateurs et appellera sendRequest (à: params: achèvement) dans NetworkWorker avec ces paramètres. Maintenant, dans l' interacteur de la scène , nous devons appeler fetchUsers (achèvement :) et envoyer les données reçues pour traitement à Presenter .

Lorsque vous cliquez sur une cellule du tableau avec le nom d'utilisateur, nous effectuons la transition et transférons l'utilisateur sélectionné vers une autre scène.

 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) { // ... } } 

Sur la page avec les publications des utilisateurs, nous créons PostsWorker , mais uniquement avec la méthode fetchPosts (userId: complete :) . Nous y transmettons l'ID de l'utilisateur dont vous souhaitez télécharger les publications. Dans la méthode, nous formons les paramètres et appelons sendRequest (à: params: achèvement) dans NetworkWorker . Et de la même manière que précédemment, nous appelons la méthode fetchPosts (userId: complete :) dans l' interacteur de la scène, en transmettant les données reçues au présentateur .

 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) { // ... } } 

Maintenant, notre implémentation entière a été déplacée vers des fichiers séparés qui peuvent être réutilisés, sans charger la logique métier dans Interactor .

Conclusion

Bien que les Workers soient très simples et ne révèlent aucune connaissance cachée de l'architecture, leur utilisation est importante dans Clean Swift . Lorsque vous écrivez Workers , n'oubliez pas les protocoles, les modèles structurels et l'ID. Sinon, vous formerez rapidement un gâchis d' ouvriers , où tout ce qui pourrait être retiré a été retiré en morceaux.

C’est tout. Merci d'avoir lu jusqu'à la fin, voici un lien vers le projet complet.

Série d'articles

1. Présentation de Clean Swift Architecture
2. Routeur et transmission de données dans une architecture propre et rapide
3. Travailleurs de l'architecture Clean Swift (vous êtes ici)
4. Tests unitaires dans l'architecture Clean Swift
5. Un exemple d'une architecture de boutique en ligne simple Clean Swift

Lien vers le projet
Aide à la rédaction d'un article: Bastien