Cours CNAM par J. Laforgue

ExempleCh08_03c_DynamicProxy

Retour

Télécharger

Pour le cours sur le DynamicProxy
Utilisation d'un DynamicProxy pour lier n'importe quel classe de modele applicatif avec les vues qui doivent etre notifiees suite a la modification du modele
Les classes de modele applicative sont chargees dynamiquement sans passer par le CLASSPATH de la JVM.
Ici, les classes sont dans un repertoire separe.
Le dynamic proxy de notification est generique. Il s'adapte a toute classe.

On empile plusieurs proxy :
- un proxy qui loggue les appels aux methodes de l'applicatif dans un fichier
- un proxy qui verifie l'identification (user,password) de l'utilisateur de l'applicatif

App.java

import java.util.*;

// Classe de definition de l'applicatif
//
public class App implements AppInt
{
    private int    etat1;
    private String etat2;
    private String nomApplicatif;

public App()
    {
        etat1 = 1;
        etat2 = "100";
        nomApplicatif = "APPLICATIF CNAM";
    }

public void setEtat1(int v)
    {
        etat1 = v;
    }

public void setEtat2(String v)
    {
        etat2 = v;
    }

public int getEtat1(){return etat1;}
    public String getEtat2(){return etat2;}

public String getNomApplicatif(){return nomApplicatif;}

public void configurer(Observer observer){}

public void traitement(AppInt app)
    {
        System.out.println(String.format("%-25s|%-25s","Utilisateurs","Applicatif"));
        System.out.println(String.format("%-25s|%-25s","",""));
        for(int i=0;i<4;i++)
            {
                System.out.println(String.format("%-25s|%-25s","","  setEtat1 de "+i));
                app.setEtat1(i);

int k=i*100;
                System.out.println(String.format("%-25s|%-25s","","  setEtat2 de "+k));
                app.setEtat2(""+k);
                
                try{Thread.sleep(500);}catch(Exception ex){};
            }
    }
}

App2.java

import java.util.*;

public class App2 implements AppInt2
{
    private int x;
    private int y;
    private int z;

public App2()
    {
        x = 1;
        y = 10;
        z = 100;
    }

public void setX(int x){this.x = x;}
    public void setY(int y){this.y = y;}
    public void setZ(int z){this.z = z;}

public int getX(){return x;}
    public int getY(){return y;}
    public int getZ(){return z;}

public void configurer(Observer observer){}

public void unautretraitement(AppInt2 app)
    {
        System.out.println(String.format("%-25s|%-25s","Utilisateurs","Applicatif"));
        System.out.println(String.format("%-25s|%-25s","",""));
        int i = 1;
        System.out.println(String.format("%-25s|%-25s","","  setX de "+i));
        app.setX(i);
        i=i*2;
        System.out.println(String.format("%-25s|%-25s","","  setY de "+i));
        app.setY(i);
        i=i*3;
        System.out.println(String.format("%-25s|%-25s","","  setZ de "+i));
        app.setZ(i);
    }
}

      AppInt.java
      AppInt2.java
      ChargeurDefaut.java

import java.io.*;

// Chargeur de classe qui est utilisé par défaut.
// Il est désigné dans le lancement de l'exemple
//
public class ChargeurDefaut extends ClassLoader
{

// Chargaur créé par la JVM
    public ChargeurDefaut(ClassLoader parent)
    {
        super(parent); 
    }

public Class findClass(String nom) throws ClassNotFoundException
    {
        File fic;
        FileInputStream fis;
        Class c=null;
        byte[] donnees;
     
        try{
            // Lecture du fichier de classe
            fic = new File(MyServiceHandlerInt.DIRECTORY,
                           nom+".class");
            fis = new FileInputStream(fic);
            
            donnees = new byte[(int) fic.length()];
            int octetslus=fis.read(donnees);
            fis.close();
            
            // Résolution de la classe 
            c = (Class)(defineClass(nom,
                                    donnees,
                                    0,donnees.length));

}catch(Exception ex){System.out.println("ChargeurDefaut findClass> "+ex);}
        return c;
    }
}

ExempleCh08_03c.java

// Pour le cours sur le DynamicProxy
// Utilisation d'un DynamicProxy pour lier n'importe quel classe de modele applicatif avec les vues qui doivent etre notifiees suite a la modification du modele
// Les classes de modele applicative sont chargees dynamiquement sans passer par le CLASSPATH de la JVM.
// Ici, les classes sont dans un repertoire separe.
// Le dynamic proxy de notification est generique. Il s'adapte a toute classe.
//
// On empile plusieurs proxy :
//   - un proxy qui loggue les appels aux methodes de l'applicatif dans un fichier
//   - un proxy qui verifie l'identification (user,password) de l'utilisateur de l'applicatif

import java.util.*;
import java.lang.reflect.*;

public class ExempleCh08_03c
{
    public static void main(String[] args)
    {

// Exemple de l'utilisation d'un proxy pour notifier les changements
        //  d'etat d'un applicatif
        //
        AppInt app = (AppInt) Proxy.newProxyInstance( ClassLoader.getSystemClassLoader(),
                                                      new Class[] { AppInt.class },
                                                      new MyServiceHandler("App") );
        
        System.out.println("classe_proxy : "+ app.getClass().getName() );
        
        Utilisateur u1 = new Utilisateur("U1",app);
        Utilisateur u2 = new Utilisateur("U2",app);
        
        app.traitement(app);

// Exemple de l'utilisation du meme proxy que precedemment mais
        //  applique a un autre applicatif totalement different (classe, interface)
        //
        System.out.println("==================================");

AppInt2 app2 = (AppInt2) Proxy.newProxyInstance( ClassLoader.getSystemClassLoader(),
                                                         new Class[] { AppInt2.class },
                                                         new MyServiceHandler("App2") );
        System.out.println("classe_proxy : "+ app2.getClass().getName() );

Utilisateur2 u3 = new Utilisateur2("U3",app2);
        app2.unautretraitement(app2);

// Exemple dans lequel on "empile" un autre proxy sur le 1er proxy.
        // Ce nouveau proxy journalise dans un fichier l'appel a toutes les methodes
        //  de l'applicatif
        //
        System.out.println("==================================");
        AppInt appBis = (AppInt) Proxy.newProxyInstance( ClassLoader.getSystemClassLoader(),
                                                          new Class[] { AppInt.class },
                                                          new ProxyLogHandler(app) );
        appBis.traitement(appBis);

// Exemple dans lequel on "empile" un autre proxy sur le proxy precedent
        // Ce nouveau proxy vérifie l'identite du programme client
        //  de l'applicatif
        //
        System.out.println("==================================");
        ProxyIdentification pi = new ProxyIdentification(appBis);
        AppInt appTri = (AppInt) Proxy.newProxyInstance( ClassLoader.getSystemClassLoader(),
                                                          new Class[] { AppInt.class },
                                                          pi );

System.out.println("--------------  jacques");
        pi.setIdentification("jacques","12345");
        appTri.traitement(appTri);

System.out.println("--------------  denis");
        pi.setIdentification("denis","abcdef");
        appTri.traitement(appTri);

System.out.println("--------------  robert");
        pi.setIdentification("robert","abcdef");
        appTri.traitement(appTri);
    }
}

MyServiceHandler.java

import java.util.*;
import java.lang.reflect.*;

// Classe de defintion du service qui permet la notification
//   des changements d'etat de l'applicatif
//
public class MyServiceHandler implements InvocationHandler
{
    private ObservableApp obs;
    private Object app; ///// AppInt app;

public MyServiceHandler(String nomClasseApp)
    {
        try{
            // Construction de l'applicatif dynamiquemment
            Class classe = Class.forName(nomClasseApp,true,
                                         ClassLoader.getSystemClassLoader()); 
            // On utile le loader de classe de la JVM qui a ete surcharge lors du
            // lancement de la JVM java : -Djava.system.class.loader=ChargeurDefaut

Class[] typeDesArguments = new Class[]{}; 
            Constructor cons = 
                classe.getConstructor(typeDesArguments); 
            Object[] parametres = new Object[]{}; // sans paramètre

// Creation de l'app 
            this.app = cons.newInstance(parametres);////(AppInt)cons.newInstance(parametres);

this.obs = new ObservableApp();

}catch(Exception ex){ ex.printStackTrace();}
    }

public Object invoke(Object proxy,
                         Method m,
                         Object[] args) throws Throwable
    {
        String prefixe = m.getName().substring(0,3);

if(prefixe.equals("get"))
            return m.invoke(app, args);
        else if (prefixe.equals("set"))
            {
                // Appel du setteur
                m.invoke(app,args);

// Appel du getteur
                String nomGetteur = "get"+m.getName().substring(3);
                
                Method getteur = app.getClass().getDeclaredMethod(nomGetteur);
                Object val = getteur.invoke(app);

obs.setChanged();
                obs.notifyObservers(val);

return null;
            }
        else if (m.getName().equals("configurer"))
            {
                obs.addObserver((Observer)args[0]);
                m.invoke(app, args);
                
                return null;
            }
        else 
            {
                return m.invoke(app, args);
            }
    }
}

      MyServiceHandlerInt.java
      ObservableApp.java
      ObserverApp.java
      ObserverApp2.java
      ProxyIdentification.java

import java.util.*;
import java.io.*;
import java.lang.reflect.*;

// ------------------------------------
// Un PROXY qui verifie l'identification de l'utilisateur
//  de l'applicatif
//
public class ProxyIdentification implements InvocationHandler
{
    private AppInt app;
    private String user;
    private String password;
    private Hashtable<String,String> base;

public ProxyIdentification(AppInt app)
    {
        this.app=app;
        user="";
        password="";
        // La base des users et mots de passe
        base=new Hashtable<String,String>();
        base.put("jacques","12345");
        base.put("denis","abcdef");
        base.put("robert","ABCDEF");
    }
    
    public void setIdentification(String user,String password){
        this.user=user;
        this.password=password;
    }

public Object invoke(Object proxy,
                         Method m,
                         Object[] args) throws Throwable
    {
        if ( user.equals("") || password.equals("") )
                  erreur(m);
        if (base.get(user)!=password) erreur(m);
        return m.invoke(app, args);
    }
    
    public void erreur(Method m)
    {
        throw new ProxyIdentificationException("Erreur d'identification : "+user+":"+m.getName());
    }
}

      ProxyIdentificationException.java
      ProxyLogHandler.java
      Utilisateur.java
      Utilisateur2.java
      compil.bat
      log.txt
      run.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE