Programmation par composants (1/3)

(1)

Licence Informatique 3e année – Programmation objet avancée 1

Programmation par composants (1/3)



La programmation par composant

vise le développement de logiciel par aggrégation de briques logicielles existantes

est indépendante de la POO



La programmation par composant fait évoluer la POO

Réutilisabilité accrue du code

Persistance des objets

Distribution du code et des objets (des objets peuvent être partagés par des applications différentes tournant sur des machines différentes)

Sécurité au niveau de l'exécution concurrente

Programmation par composants (2/3)



Un composant est une brique logicielle

Taille variable (d'une classe à une application entière)

Granularité variable (ossature logicielle, élément d'interface, classe métier, ...)

Fonctions variées

• Composants techniques : ossature du code, éléments d'interfaces graphiques, utilitaires pour manipuler des données, ...

• Composants métiers : représentent des entités du domaine (client, produit, ...)

• Composants applicatifs : dédiés aux traitements internes d'une application (peu réutilisables)



Un composant doit offrir

Robustesse : le comportement doit être celui attendu (et sans bug!)

Généricité : le composant doit pouvoir être adapté à l'application (sans le modifier!)

Abstraction : le composant doit offrir une interface claire et être utilisable sans consulter son code (son implémentation doit être autonome)

(2)

Programmation par composants (3/3)



Programmation par composants

Sélection des composants dans un catalogue

Eventuellement développement de nouveaux composants

Adaptation des composants à l'application

Assemblage des composants, avec ajout éventuel de code



Modèles de programmation par composants

EJB (Enterprise Java Beans) : programmation distribuée et interopérabilité

Java Beans : assemblage visuel (interfaces en particulier)

CORBA de l'OGM (Object Management Group)

OLE/ActiveX, COM et .NET dans le monde Microsoft

JavaBean (1/2)



Java propose un modèle de composant : Java Bean (grain de café)



Caractéristiques d'un JavaBean :

Règles de dénomination : permettent de normaliser le nommage des membres des bean et donc d'automatiser leur manipulation

Réflexion : les beans (comme tous les objets Java) peuvent donner des informations sur eux-mêmes, non seulement sur leur état mais aussi sur leur constitution interne

Persistance : un bean peut être sauvegardé en l'état (avec les valeurs des attributs) et réactivé plus tard par sérialisation

Communication : les beans communiquent via le modèle événementiel et le pattern d'écouteur (Listener)

(3)

JavaBean (2/2)



Les JavaBeans sont toutes les classes Java qui respectent un certains nombre de règles :

ils doivent posséder un constructeur sans paramètre. Celui ci devra initialiser l'état du bean avec des valeurs par défauts.

ils peuvent définir des propriétés : celles ci sont identifiées par des attributs et méthodes dont le nom et la signature sont normalisés

ils doivent implémenter l'interface Serializable : ceci est obligatoire pour les beans qui possèdent une partie graphique pour permettre la sauvegarde de leur état

ils définissent des méthodes utilisables par les composants extérieurs : elles doivent être publiques et prévoir une gestion des accès concurrents

 ils peuvent émettre des événements en gérant une liste d'écouteurs qui s'y abonnent via des méthodes dont les noms sont normalisés



Les classes des API graphiques de Java (AWT et Swing) sont des JavaBeans

Propriétés dans un JavaBean



L'accès aux attributs (propriétés) est contrôlé

Attributs toujours privés (ou à la rigueur protégés)

Les attributs peuvent n'avoir qu'un accesseur (ils sont en lecture seule), qu'un modifieur (ils sont en écriture seule)



Accesseurs et modifieurs sont normalisés

Accesseur : <type_attribut> get<nom_attribut>() (is<nom_attribut> si l'attribut est booléen)

Modifieur : void set<nom_attribut>(<type_attribut>

<nom_variable>)

Le nom de l'attribut n'est pas forcément celui de la variable qui le contient!

public class GrainDeCafe{

private int poids;

private boolean truc;

...

public int getPoids(){return this.poids;}

public void setPoids(int a){this.poids = a;}

public void getArabica(){ return this.truc;}

}

(4)

Propriétés indexées



Quand les attributs sont des tableaux, les accesseurs et modifieurs ont un indice en paramètre supplémentaire

private float[] dimensions = new float[3];

public GrainDeCafe(){

dimensions[0] = 0.5;

truc = a;

}

public float getDimension(int axe){return this.dimensions[axe];}

public void setDimension(float a, int axe){this.dimensions[axe] = a;}

public void getArabica(){ return this.truc;}

}

Propriétés liées (1/3)



Un JavaBean peut observer une propriété d'un autre JavaBean via un mécanisme implémentant le pattern Observer. La propriété est alors dite liée (bound property)



Le JavaBean observé intègre par composition un objet PropertyChangeSupport

PropertyChangeSupport gère une liste d'écouteurs de type PropertyChangeListener qui jouent le rôle d'observateurs

PropertyChangeSupport permet de notifier aux écouteurs les changements intervenant sur une propriété liée



Les JavaBeans observateurs implémentent l'interface PropertyChangeListener qui ne contient qu'une méthode

void propertyChange(PropertyChangeEvent evt)

La classe d'événements PropertyChangeEvent encapsule les données qui décrivent le changement de valeur de la propriété (nom de la propriété, ancienne valeur, nouvelle valeur, ...)

(5)

Propriétés liées (2/3)

private int poids;

private PropertyChangeSupport pcs;

public GrainDeCafe(){

...

pcs = new PropertyChangeSupport();

}

public void addPropertyChangeListener(PropertyChangeListener pcl){

pcs.addPropertyChangeListener(pcl);

}

public void removePropertyChangeListener(PropertyChangeListener pcl){

pcs.removePropertyChangeListener(pcl);

}

public void setPoids(int a){

int temp = poids; this.poids = a;

pcs.firePropertyChange("poids",new Integer(temp),new Integer(a));

} ...

}

Propriétés liées (3/3)

public class Torrefacteur implements PropertyChangeListener{

private MachineATorrefier mat;

public Torrefacteur(){...}

public void propertyChange(PropertyChangeEvent pce){

if(pce.getPropertyName().equals("poids"))

if(((Integer) pce.getNewValue()).intValue() > 3) //changer la machine à torréfier

}

public class VendeurDeCafe implements PropertyChangeListener{

public VendeurDeCafe(){...}

public void propertyChange(PropertyChangeEvent pce){

if(pce.getPropertyName().equals("poids")) if(((Integer) pce.getNewValue()).intValue()

- ((Integer) pce.getOldValue()).intValue()) //changer le prix de vente

}

(6)

Propriétés contraintes (1/2)



Un JavaBean qui écoute une propriété d'un autre composant peut mettre son veto à un changement de valeur en créant une PropertyVetoException



Les propriétés contraintes sont gérées par des VetoableChangeSupport et écoutées par des VetoableChangeListener



Au cas où un composant écouteur de la propriété met son veto au changement de valeur, le changement doit être annulé

public class USA implements VetoableChangeListener{

...

public void vetoableChange(PropertyChangeEvent e) throws PropertyVetoException { Resolution r = ((Resolution) e.getNewValue());

if(!this.accepts(r)) throw new PropertyVetoException("resolution inacceptable!",e);

} }

Propriétés contraintes (2/2)

public class ConseilSecuriteONU{

private LinkedList resolutions = new LinkedList();

private VetoableChangeSupport vcs;

public void addVetoableChangeListener(VetoableChangeListener vcl) { vcs.addVetoableChangeListener(vcl);

}

public void removeVetoableChangeListener(VetoableChangeListener vcl) { vcs.removeVetoableChangeListener(vcl);

}

public void addResolution(Resolution r){

resolutions.add(r);

try{

vcs.fireVetoableChange("resolution",null,r);

}

catch(PropertyVetoException e){

System.out.println("un veto est emis : "+e.getMessage());

resolutions.remove(r);

} } }

(7)

Réflexivité



En programmation objet, la réflexivité consiste à offrir la possibilité d'interroger un objet sur :

sa constitution interne (attributs avec leurs types)

son état (valeurs des attributs)

son comportement (méthodes)

sa classe



Intérêts de la réflexivité :

Dans le cadre de la programmation par composants (JavaBeans) il faut que les composants puissent être interrogés dynamiquement sur leur constitution pour être utilisés par une application à l'exécution

Accès aux classes dans les outils de développement (debuggers, browsers de classe, ...) ou les applications réparties utilisant la sérialisation



Tous les langages objets n'offrent pas la réflexivité (C++ n'est pas réflexif)

API Reflexion de Java



java.lang.reflect est un paquetage Java dédié à l'introspection

la classe Field représente les attributs des classes (cette classe offre des méthodes de classe pour récupérer les valeurs des attributs d'un objet)

la classe Method représente les méthodes des classes

la classe Constructor représente les constructeurs des classes

La classe Modifier représente les modifieurs des classes et membres

La classe Array représente les tableaux



La classe java.lang.Class offre des méthodes permettant de récupérer les instances des classes précédentes

Class est instanciée chaque fois que le java.lang.ClassLoader charge une classe dans la JVM

La méthode getClass de la classe Object permet de récupérer la classe d'un objet (on peut aussi utiliser Class.forName(String nom_classe))

Class permet de récupérer des informations sur les classes (et indirectement sur les objets)

(8)

BeanInfo



java.beans.BeanInfo est une interface permettant de compléter les mécanismes d'introspection de java.lang.reflect



BeanInfo offre des méthodes permettant de récupérer des descripteurs sur un JavaBean

BeanDescriptor : description générale du composant (classe)

PropertyDescriptor : description des propriétés (attributs)

MethodDescriptor : description des méthodes

EventSetDescriptor : description des événements gérés et des écouteurs



La classe java.beans.Introspector permet de récupérer un BeanInfo

Introspector cherche une classe <nom_du_bean>BeanInfo qui doit être une implémentation de BeanInfo ou une classe qui hérite de l'adapteur SimpleBeanInfo. S'il trouve cette classe, il l'instancie et retourne l'instance

Sinon il utilise les mécanismes d'introspection classiques et construit le BeanInfo à partir des infos récupérées

Jar et fichier manifest



Un JavaBean est souvent implémenté par plusieurs classes qui sont fournies dans une archive Java (JAR : Java Archive)



Une archive JAR est générée ou ouverte avec l'utilitaire jar



Un fichier manifest peut être ajouté à l'archive pour ajouter des informations

Informations générales sur l'archive (version, ...)

Des informations sur chaque fichier de l'archive