LG

Cela consiste à décrire les besoins d'un point de vue exclusivement métier sans aborder la partie technique du logiciel.

On peut déjà imaginer les briques logicielles avec leurs fonctions et leurs interactions mais toujours exclusivement du point de vue métier.

Un logiciel est composé de sous-systèmes (facultatif), eux-mêmes composés de composants logiciels.

Un composant peut être :

• un logiciel développé spécifiquement durant le projet de développement;
• un logiciel réutilisé depuis un autre projet,
• un progiciel sur étagère que l’on intègre,
• un logiciel dont on utilise simplement les services mais qui reste extérieur au système,
• un ou plusieurs fichiers / bases de données.

Un composant possède :

• un aspect visible (interface),
• des fonctionnalités,
• des propriétés (ou contraintes ou exigences non fonctionnelles). Cela peut-être la volumétrie de la base de données, les besoins en bande passante, le délai maximum en temps d'exécution d'une fonction.

• Global : scénarios d'exécution, coopération entre composants (ordre d'exécution des constituants, constituants en parallèle),
• Constituant : contrainte d'exécution (parallélisation autorisée des fonctions, imposer un ordre d'exécution des fonctions).

Spécifier les contraintes de déploiement et la description de l'infrastructure : machine, OS, plateforme (java, …)

L'architecture logicielle est la partie de l'architecture système qui détaille la description des éléments applicatifs.

Une architecture système regroupe :

• l'architecture logicielle : liste des composants à développer avec leurs interfaces (de programmation),
• l'architecture technique : choix du langage de programmation et des briques logiciels (par exemple : quelle librairie gérera la persistance des données),
• l'architecture physique : ordinateur ou tablette ? Choix des OS supportés ?

Les composants sont visibles des autres composants exclusivement à travers des interfaces.

• service : pour obtenir un service ou une information,
• réalisation : implémentation par héritage,
• manifestation : nécessite un artefact pour s'exécuter / s'implémenter.

Il est préférable mais pas obligatoire qu'un composant ne supporte qu'un rôle à la fois, sauf pour les deux premiers qui sont les fondamentaux de la programmation orientée objet et le troisième qui gère les besoins en concurrence.

• Stocker des données (composant de type Entité),
• Fournir des traitements (composant de type Service),
• Contrôle interne (composent de type Contrôleur) : aucun, exécution possible en concurrence par file d'attente ou vraiment en parallèle, vérification des paramètres,
• Maintenir un contexte : gérer des informations de sessions, garder un fichier ouvert, système de cache,
• Interface graphique,
• Gestion d'un matériel physique,
• Proxy,
• Machine abstraite.

Une interface est attachée à un port de communication du composant. Il existe deux types d'interface : le cercle représente l'interface offerte (les différentes méthodes à disposition) et le demi cercle l'interface requise (le prototype des méthodes doit correspondre à l'interface offerte).

Une interface est attachée à un port du composant, noté par un carré. Cela peut être l'exécution de la méthode en local ou via une API distante ou la possibilité d'avoir les deux à la fois.

Les composants interagissent donc sur des ports, par le biais de connecteurs, et via des interfaces. Ils fournissent des services de :

• Communication : appel local ou distante,
• Coordination :
  • appel synchrone : on attend le retour,
  • événement simple : on envoie un évènement, on attend pas le retour. Si le destinataire n'est pas prêt à recevoir le message, il est perdu,
  • événement bufferisé : idem qu'un événement simple sauf que le destinataire stocke le message en attente s'il n'est pas prêt à le traiter tout de suite,
  • flots de données : envoie de données en continu peu importe si le destinataire manque quelques messages,
  • Appel asynchrone : A envoie la demande à B, le retour arrivera plus tard de B vers A,
  • Pub/Sub : A envoie un message à B avec un «topic», le retour arrivera à tous les composants qui se sont inscrites au «topic»,
• Conversion de données entre les deux ports,
• Facilitation : régulation de charge, appel concurrent

La manifestation concrète d’un composant est appelée artefact. C’est une instance concrète du composant déployée dans l’environnement d’exécution. Voir UML