I. Bus logiciel ?

1. I. Bus logiciel ? Mireille Blay-Fornarino blay@essi.fr D’après Raphael.Marvie@lifl.fret Sacha Krakowiak Et (cf. références en bas des pages)

2. Objectifs de ce cours • Introduire les principes de base de l’architecture des intergiciels … • … via une démarche systématique basée sur le besoin.

3. Méthodologie suivie pour ce cours • Découvrir la structuration d’un bus logiciel réparti, en concevant un petit bus simple « from scratch ». • Construire un bus logiciel en 10 étapes : • Chaque étape est un raffinement de la précédente • Etape i + 1 = meilleure structuration de l’étape i • A chaque étape, s’il y a lieu, • Identification des principaux schémas d’architecture Raphael.Marvie@lifl.fr

4. Les Services • Service 1 : Hello world • Une méthode hello avec un paramètre de type chaîne et retourne une chaîne : ”hello, ” + paramètre • Deux méthodes lower et upper qui retournent le paramètre de type chaîne en minuscule ou majuscules • Service 2 : Nombres premiers • Calcule si un nombre est premier et retourne un booléen • Calcule le carré d’un nombre passé en paramètre • Calcule la division de deux nombres passés en paramètre

5. 1. Au début était la socket

6. Principe • Deux programmes écrits en deux classes Java • Une pour le serveur Server.java • Une pour le client Client.java • Dans chaque classe est implémenté • Le code fonctionnel : manipulation des chaînes • Le code technique : construction / analyse des messages réseau

7. Architecture version « socket » Client Serveur Réseau

8. Modélisation des Interactions

9. Côté serveur • Initialisation du réseau • Instanciation d’une socket serveur • Gestion des requêtes • Attente de connexion (accept) • Initialisation des flux d’entrée et de sortie • Evaluation des requêtes • Lecture de la requête sur le flux d’entrée • Création de la chaîne à retourner • Ecriture de la réponse sur le flux de sortie

10. Code serveur (i) package step1 ; import java.io.* ; import java.net.* ; public class Server { private ServerSocket asock ; public Server () throws Exception { this.asock = new ServerSocket (12345) ; } public static void main (String args[]) { Server s = new Server () ; s.run () ; }

11. Code serveur (ii) public void run () throws Exception { while (true) { Socket sock = this.asock.accept () ; BufferedReader in = new BufferedReader (new InputStreamReader(sock.getInputStream ())); DataOutputStream out = new DataOutputStream (sock.getOutputStream ()); String msg = in.readLine () ; String res = "Hello, " + msg + "\n" ; // fonctionnel out.writeBytes (res) ; } }

12. Côté client • Initialisation du réseau • Instanciation d’une socket de communication (connexion implicite) • Gestion de l’échange réseau • Initialisation des flux d’entrée et de sortie • Demande de service • Ecriture de la requête sur le flux de sortie • Lecture de la réponse sur le flux entrée • Affichage de la chaîne retournée • Fermeture de la connexion

13. Code client (i) package step1 ; import java.io.* ; import java.net.* ; public class Client { private Socket sock ; public Client () throws Exception { this.sock = new Socket ("localhost", 12345) ; } public static void main (String args[]) throws Exception { Client c = new Client () ; c.run (args[0]) ; }

14. Code client (ii) public void run (String msg) throws Exception { BufferedReader in = new BufferedReader (new InputStreamReader(this.sock.getInputStream ())); DataOutputStream out = new DataOutputStream (this.sock.getOutputStream ()); out.writeBytes (msg + "\n") ; String res = in.readLine () ; System.out.println ("Server replied: " + res) ; this.sock.close(); } }

15. Bénéfices et limitations • Bénéfices • Invocation d’un service distant (hello world) • Permet de réaliser des applications client / serveur • Limitations • Une seule connexion cliente à la fois • Beaucoup de code très technique / peu de code métier (40 lignes de code technique pour une ligne de code métier) • Un beau plat de spaghettis, difficilement évolutif

16. 2. Gestionnaire de connexions

17. Principe • Du côté serveur • Etablissement de la connexion par le serveur (accept) • La gestion de la connexion est déléguée à un objet Manager qui gère une connexion • Du côté client • Rien ne change pour le moment • Réutilisation du client de l’étape 1

18. Architecture version 2 Client Manager Réseau

19. Interactions version 2

20. Côté serveur (Serveur) • Initialisation • De la socket d’administration / serveur • Création d’un manager de connexions • Gestion des requêtes • Attente de connexion • Délégation au manager

21. Côté serveur (Manager) • Initialisation • Rien de spécial • Gestion des requêtes • Initialisation du flux d’entrée et de sortie • Evaluation de la requête • Lecture de la requête sur le flux entrée • Création de la chaîne à retourner • Ecriture de la réponse sur le flux de sortie

22. Code Serveur (i) package step2 ; import java.io.*; import java.net.*; public class Server { private ServerSocket asock ; private Manager mgr ; public Server () throws Exception { this.asock = new ServerSocket (12345) ; this.mgr = new Manager () ; }

23. Code Serveur (ii) public void run () throws Exception { while (true) { Socket sock = this.asock.accept () ; this.mgr.process (sock) ; } } public static void main(String argv[]) throws Exception { Server s = new Server () ; s.run () ; } }

24. Code Manager package step2 ; import java.io.* ; import java.net.* ; public class Manager { public Manager () throws Exception {} public void process (Socket sock) throws Exception { BufferedReader in = ... DataOutputStream out = ... String msg = in.readLine () ; String res = "Hello, " + msg + "\n" ; out.writeBytes (res) ; } }

25. Bénéfices et limitations • Bénéfices • Ebauche de structuration • Distinction entre établir une connexion et la gérer • Limitations • Le manager ne sait répondre qu’à une invocation • Le code n’est pas encore objet (i.e. le service)

26. 3. Décodage des requêtes

27. Principe • Côté serveur • Le manager propose plusieurs services • Le manager gère plusieurs requêtes par connexion • Côté client • Utilise les services séquentiellement • Réalise plusieurs invocations avec la même connexion

28. Architecture version 3 Client Manager Réseau

29. Interactions version 3

30. Côté serveur • Gestion des requêtes par le Manager • Initialisation des flux d’entrée et de sortie • Evaluation de la requête • Lecture de la requête sur flux d’entrée • Décodage de la requête (quel service ?) requête = numéro de service + arguments • Evaluation du service demandé • Ecriture de la réponse sur flux de sortie

31. Code Manager (i) public void process (Socket sock) throws Exception { BufferedReader in = ... DataOutputStream out = ... while (true) { String msg = in.readLine () ; if (msg == null) // end of client connexion break ; String res ; switch (msg.charAt (0)) {

32. Code Manager (ii) case ’0’: res = "hello, " + msg.substring (1) + "\n" ; break ; case ’1’: Res = msg.substring (1) .toLowerCase () + "\n" ; break ; case ’2’: res = msg.substring (1) .toUpperCase () + "\n" ; break ; default: res = "Unknow operation requested" ; } out.writeBytes (res) ; } }

33. Côté client • Initialisation du réseau • Instanciation de la socket de communication • Gestion des échanges réseaux • Initialisation des flux d’entrée et de sortie • Demande de service (x3) • Requête réseau = numéro de service + arguments • Ecriture requête, lecture réponse et affichage • Fermeture de la connexion

34. Code Client (i) public void run (String msg) throws Exception { BufferedReader in = ... DataOutputStream out = ... String res ; out.writeBytes ("0" + msg + "\n") ; res = in.readLine () ; System.out.println ("Server replied (hello): " + res) ;

35. Code Client (ii) out.writeBytes ("1" + msg + "\n") ; res = in.readLine () ; System.out.println ("Server replied (lower): " + res) ; out.writeBytes ("2" + msg + "\n") ; res = in.readLine () ; System.out.println ("Server replied (upper): " + res) ; this.sock.close(); }

36. Bénéfices et limitations • Bénéfices • Un seul serveur propose plusieurs services • Utilisation d’une seule connexion par client • Limitations • Le code du service n’est toujours pas objet • Le code client est toujours un plat de spaghetti

37. 4. Passage à un service objet

38. Principe • Côté serveur • Le service est implémenté comme un objet : le Servant • Le manager est dédié au réseau • décode les requêtes • invoque le Servant • Côté client • Rien ne change

39. Architecture version 4 Servant Client Manager Réseau

40. Interactions version 4

41. Côté serveur • Initialisation du Manager dans le serveur • Passage du Servant comme paramètre • Gestion des requêtes par le Manager • Initialisation des flux • Evaluation des requêtes • lecture et décodage de la requête • invocation du Servant • écriture de la réponse

42. Code Server public class Server { private ServerSocket asock ; private Manager mgr ; public Server () throws Exception { this.asock = new ServerSocket (12345) ; this.mgr = new Manager (new Servant ()) ; } // unchanged }

43. Code Servant public class Servant { public String hello (String msg) { return "hello, " + msg ; } public String lower (String msg) { return msg.toLowerCase () ; } public String upper (String msg) { return msg.toUpperCase () ; } }

44. Code Manager (i) public class Manager { private Servant ref ; public Manager (Servant s) throws Exception { this.ref = s ; } public void process (Socket sock) throws Exception { BufferedReader in = ... DataOutputStream out = ... while (true) { String msg = in.readLine () ; if (msg == null) // no more to be read break ; String res ; switch (msg.charAt (0)) {

45. Code Manager (i) case ’0’: res = this.ref.hello (msg.substring (1)) + "\n" ; break ; case ’1’: res = this.ref.lower (msg.substring (1)) + "\n" ; break ; case ’2’: res = this.ref.upper (msg.substring (1)) + "\n" ; break ; default: res = "Unknow operation requested" ; } out.writeBytes (res) ; }

46. Bénéfices et limitations • Bénéfices • Découplage complet entre code technique et code métier (côté serveur) • Les services sont implantés comme des objets (Servant) • Limitations • L’interface du service n’est pas connue comme telle du client • Le code client n’est toujours pas objet

47. 5. Passage à l’objet du côté client

48. Principe • Côté serveur • Définition d’un contrat à partager avec le client • Le servant implémente le contrat commun • Côté client • Utilisation d’un objet représentant le service : Proxy • Même interface que le service • Encapsule le code technique de gestion du réseau

49. Architecture version 5 Client Servant Contrat Proxy Manager Réseau

50. Interactions version 5