Cours CNAM par J. Laforgue

Exemple04_ObservateurDistant

Retour

Télécharger

Exemple d'un DP Observateur distant (communication socket)

ApplicatifServeur.java

import java.io.*;
import java.net.*;
import java.util.*;

public class ApplicatifServeur
{

public static void main(String args[])
  {
    int portServeur = Integer.parseInt(args[0]);  // port du serveur
    App a = new App(portServeur);
    a.traitement();
  }
}

// ------------------------------------
class App
{
    private int etat1;
    private ObservableApp obs;

public App(int portServeur)
    {
        etat1 = 1;
        obs = new ObservableApp(portServeur);
    }

public void setEtat1(int v)
    {
        etat1 = v;
        obs.notifier(new Integer(etat1));
    }

public Observable getObservable(){return obs;}

public void traitement()
    {
        for(int i=0;i<100;i++)
            {
                setEtat1(i);
                System.out.println("setEtat avec "+i);
                System.out.println("------------");
                try{Thread.sleep(1000);}catch(Exception ex){};
            }
    }
}

// ------------------------------------
class ObservableApp extends Observable 
{
  public ObservableApp(int portObservable)
  {
    // Execution d'un thread sur un serveur de socket pour attendre les abonnements
    //  des clients
    try{
      ServerSocket sos = new ServerSocket(portObservable);
      Thread t = new Thread(){
          public void run(){
            while(true){
              try{
                Socket soc = sos.accept();
                InputStream is=soc.getInputStream();
                ObjectInputStream ois=new ObjectInputStream(is);
                String hostNameClient  = (String)(ois.readObject());
                Integer portClient = (Integer)(ois.readObject());

// Abonnement recu : création d'un observer dédié au client
                addObserver(new ObserverClient(hostNameClient,portClient.intValue()));
                System.out.println("Abonnement du client fait : "+hostNameClient+" "+portClient);
                soc.close();
              }catch(Exception ex){System.out.println(ex);ex.printStackTrace();}
            }}};
      t.start();
    }catch(Exception ex){};
  }

public void notifier(Object arg)
  {
    setChanged();
    notifyObservers(arg);
  }
}

// ------------------------------------
// L'observer d'un poste client
//
class ObserverClient implements Observer
{
  String hostNameClient;
  int portClient;

public ObserverClient(String hostNameClient,int portClient)
    {
      this.hostNameClient = hostNameClient;
      this.portClient = portClient;
    }

public void update(Observable o,Object arg)
    {
      try{
        // La notification consiste à écrire l'objet à notifier sur le socket du poste client
        //
        Socket soc = new Socket(Inet4Address.getByName(hostNameClient),portClient);
        OutputStream os=soc.getOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(os);
        oos.writeObject(arg);
      }catch(Exception ex){System.out.println(ex);ex.printStackTrace();}
    }
}

Client.java

import java.io.*;
import java.net.*;
import java.util.*;

public class Client
{
    public static void main(String[] args)
    {
      // Création d'un Observable sur le poste (JVM) client.
      // Cet obervable s'est abonné s'abonne au serveur.
      // Il reçoit les notifications du serveur.
      // Toute les vues du poste client s'abonnent à cet observable.
      //
      String hostNameServeur = args[0];                   // host du serveur
      int portServeur = Integer.parseInt(args[1]);        // port du serveur
      int portClient= Integer.parseInt(args[2]);          // port du client

ObservableClient observableDistant = new ObservableClient(hostNameServeur,
                                                                portServeur,
                                                                portClient);

// Création des vues
      Utilisateur u1 = new Utilisateur("U1",observableDistant);
      Utilisateur u2 = new Utilisateur("U2",observableDistant);
      Utilisateur u3 = new Utilisateur("U3",observableDistant);
    }
}

// ------------------------------------
class Utilisateur
{
    private ObserverApp observer;
    private String      ident;

public Utilisateur(String ident,Observable observable)
    {
        this.ident = ident;
        observer = new ObserverApp(this);  // this
        
        observable.addObserver(observer);
    }

// traitement de utilisateur appelé
    public void traitement(int v)
    {
        System.out.println(ident+" "+v);
    }
}

// ------------------------------------
class ObserverApp implements Observer
{
  Utilisateur util;

public ObserverApp(Utilisateur util)
  {
    this.util = util;
  }

public void update(Observable o,Object arg)
  {
    Integer v = (Integer)arg;
    util.traitement(v.intValue()); // APPEL AU TRAITEMENT
  }
}

// ------------------------------------
// LE NOUVEAU OBSERVABLE local qu poste client
// -----------------------------------
class  ObservableClient extends Observable 
{
  public ObservableClient(String hostNameServeur,int portServeur,int portClient)
  {
    try{
      // Abonnement au serveur
      System.out.println("Aboonnement au serveur");
      Socket soc = new Socket(Inet4Address.getByName(hostNameServeur),portServeur);
      OutputStream os=soc.getOutputStream();
      ObjectOutputStream oos=new ObjectOutputStream(os);
      oos.writeObject("localhost");
      oos.writeObject(new Integer(portClient));
      
      // Lancement d'un thread sur un serveur de scoket qui reçoit les notifications.
      // Pour chaque notification reçu, cet observable notifie les observateurs (les vues)
      //
      ServerSocket sos = new ServerSocket(portClient);
      Thread t = new Thread(){
          public void run()
          {
            while(true)
              {
                try{
                  Socket soc = sos.accept();
                  InputStream is=soc.getInputStream();
                  ObjectInputStream ois=new ObjectInputStream(is);
                  Object obj  = ois.readObject();
                  notifier(obj); // notification
                  soc.close();
                }catch(Exception ex){ System.out.println(ex);ex.printStackTrace();}
              }
          }};
      t.start();
    }catch(Exception ex2){System.out.println(ex2);ex2.printStackTrace();}
  }

public void notifier(Object arg)
  {
    setChanged();
    notifyObservers(arg);
  }
}

      compil.bat
      runClient9101.bat
      runClient9102.bat
      runServeur.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE