Cours CNAM par J. Laforgue

ExempleCh06_02_Provider

Retour

Télécharger

Exemple d'un provider asynchrone multi-canaux multi-producteurs multi-consommateurs
Voir § 6.4 du cours NSY102-Chapitre-06_LesModesDeCommunication.

Executions :
runProvider.bat (à exécuter qu'une fois) (à exécuter en premier)
runProducteur_Canal1.bat (exécution d'un producteur sur le canal 1) (peut être exécuter plusieurs fois)
runProducteur_Canal2.bat (exécution d'un producteur sur le canal 2) (peut être exécuter plusieurs fois)
runConsommateur_Canal1.bat (exécution d'un consommateur sur le canal 1) (peut être exécuter plusieurs fois)
runConsommateur_Canal2.bat (exécution d'un consommateur sur le canal 2) (peut être exécuter plusieurs fois)

README.txt
Consommateur.java

import fr.cnam.provider.*;

// Creation du consommateur (classe applicative)
public class Consommateur implements Consumer
{
  private ConsumerImpl consumer;

public Consommateur(String ident,int canal)throws Exception{
    this.ident=ident;
    consumer = new ConsumerImpl(canal);

// Pour que le producteur  puisse posser une information au Consommateur Applicatif
    consumer.setConsumer(this);
  }

private static int compteur=0;
  private String ident;

// Algorithme qui tire toute les secondes un objet aux producteurs
  //
  public void tirer(){
    try{
      while(true){
        System.out.println(ident+"> "+"PULL : "+consumer.pull());
        try{Thread.sleep(1000);}catch(Exception ex){};
      }
    } catch(Exception ex){};
  }

// Traitement traitement sur recepetion d'un objet
  //
  public void push(Object obj)
  {
    compteur++;
    System.out.println(ident+"> "+"PUSH  : "+obj);
    // TEST (pour tester que la communication est bien asynchrone
    // if ( (ident.equals("CONSO1")) && (compteur%5==0))try{Thread.sleep(10000);}catch(Exception ex){};
  }

// ================================================================
  // args[0] : numéro du canal sur lequel le Consommateur Applicatif veut tirer une information
  // args[1] : Identification du consommateur
  //
  public static void main(String... args) throws Exception
  {
    // Creation d'un consommateur
    Consommateur consommateur = new Consommateur(args[1],Integer.parseInt(args[0]));

// Pour tirer régulièrement un objet sur le producteur
    //
    consommateur.tirer();
  }

}

Producteur.java

import fr.cnam.provider.*;
import java.rmi.*;

// Creation du producteur (classe applicative)
public class Producteur implements Supplier
{
  private SupplierImpl supplier;

public Producteur(int canal)throws Exception{
    supplier = new SupplierImpl(canal);

// Pour que le Consommateur Applicatif puisse tirer une information au producteur
    supplier.setSupplier(this); 
  }

private int compteur; // valeur qui est tiree

// Algorithme qui pousse des objets aux consommateurs
  public void produire()
  {
    try{
      int n=0;
      while(true) 
        {
          System.out.println("MESSAGE "+n);

// On pousse un objet
          supplier.push("MESSAGE "+ n++);
          try{Thread.sleep(1000);}catch(Exception ex){ex.printStackTrace();};
        }
    }catch(Exception ex){};
  }
  
  // Traitement qui simule la création d'un évenement dans le producteur qui est tire par les consommateurs
  public Object pull()
  {
    return ">>>  "+ compteur++;
  }

// ================================================================
  // args[0] : numéro du canal sur lequel le Producteur Applicatif pousse un objet
  //
  public static void main(String... args) throws Exception
  {
    // Creation d'un producteur sur un canal
    Producteur p = new Producteur(Integer.parseInt(args[0]));

// Pour produire régulièrement des informations aux consommateurs
    p.produire();
  }
}

      compil.bat
      description.txt
      fr
         cnam
            provider
               Consumer.java
               ConsumerImpl.java

package fr.cnam.provider;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;
import java.io.*;

// Classe de définition d'un consommateur sur un canal de comunication
//
public class ConsumerImpl extends UnicastRemoteObject implements Consumer
{
  private Consumer consumer;  // L'objet utilisé par le Consommateur pour qu'on lui pousse un objet
  private Supplier supplier;  // La connexion distante au Proxy du Producteur

// Création d'un consommateur sur un canal de communication
  //  canal : le numéro (0 à 9) du canal
  //
  public ConsumerImpl(int canal)  throws Exception
  {
    consumer=null;
    supplier = ProviderImpl.getProvider().connectConsumer((Consumer)(UnicastRemoteObject.toStub(this)),canal);
  }

// Brancher l'objet utilisé par le Consommateur pour qu'on lui pousse une objet
  //
  public void setConsumer(Consumer consumer){this.consumer=consumer;}

// Pour pousser un objet
  //
  public void push(Object obj) throws RemoteException
  {
    try{
      if (consumer==null) throw new RuntimeException("push non implémenté dans le consommateur");
      consumer.push(obj);
    }catch(Exception ex){}
  }

// Pour tirer un objet
  //
  public Object pull()throws Exception{
    return supplier.pull();
  }

}

Provider.java
ProviderImpl.java

package fr.cnam.provider;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;

import fr.cnam.provider.*;

// Class principal du Provider
public class ProviderImpl extends UnicastRemoteObject implements Provider
{
  private ProxyConsumer[] canaux;  // lLes canaux du provider

private ProviderImpl() throws Exception
  {
    canaux = new ProxyConsumer[10]; // 10 canaux possibles
    for(int i=0;i<10;i++)
      canaux[i]=new ProxyConsumer();
    Naming.rebind("rmi://localhost:9100/PROVIDER",this);
  }

// Methode statique utilises par les consommateurs et les producteurs
  //  pour se connecter au provider
  static public Provider getProvider() throws Exception
  {
    return (Provider)(Naming.lookup("rmi://localhost:9100/PROVIDER"));
  }

// Un producteur se declare a un canal du provider
  public Consumer connectSupplier(Supplier supplier,int canal) throws RemoteException
  {
    System.out.println("Connexion d'un producteur sur le canal "+canal);
    canaux[canal].addSupplier(supplier);
    return((Consumer)(UnicastRemoteObject.toStub(canaux[canal])));
  }

// Un consommateur se declare a un canal du provider
  public Supplier connectConsumer(Consumer consumer,int canal)  throws RemoteException
  {
    System.out.println("Connexion d'un consommateur sur le canal "+canal);
    return (Supplier)(UnicastRemoteObject.toStub(canaux[canal].addProxySupplier(consumer)));
  }

// Execution du provider
  public static void main(String[] args) throws Exception
  {
    System.out.println("Provider in run ....");
    try{LocateRegistry.createRegistry(9100);} catch(Exception ex){};
    new ProviderImpl();
  }
}

ProxyConsumer.java

package fr.cnam.provider;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;

// 1 canal = 1 instance de ProxyConsumer
//
// Proxy utilise par les producteurs
public class ProxyConsumer extends UnicastRemoteObject implements Consumer
{
  private ArrayList<Supplier> producteurs;     // Les producteurs connectes a un des canaux du Provider
  private ArrayList<ProxySupplier> suppliers;  // Les proxy utilises pour chacun des consommateurs

public ProxyConsumer()  throws RemoteException
  {
    super(9101);
    producteurs = new ArrayList<Supplier>();
    suppliers = new ArrayList<ProxySupplier>();
  }

// Ajout d'un nouveau producteur au canal
  public void addSupplier(Supplier supplier)
  {
    producteurs.add(supplier);
  }

// Ajout d'un consommateur => creation de son proxy
  public Supplier addProxySupplier(Consumer consumer) throws RemoteException
  {
    ProxySupplier p = new ProxySupplier(consumer,this);
    suppliers.add(p);
    System.out.println("Nb proxy supplier: "+suppliers.size());
    return(p);
  }

// On demande a tous les proxys de pousser a son tour au consommateur
  public void push(Object obj) throws RemoteException
  {
    for(ProxySupplier p:suppliers)
      try{
        // Dans un thread afin d'etre asynchrone
        new Thread(new Runnable(){public void run(){try{p.push(obj);}catch(Exception ex2){}}}).start();
      }catch(Exception ex){}
  }

// On tire a chaque producteur 
  public Object pull()  throws RemoteException
  {
    ArrayList list=new ArrayList();
    for(Supplier prod:producteurs)
      {
        try{
          Object obj = prod.pull();
          list.add(obj);
        }catch(Exception ex){}
      }
    return list; // Autant d'evenement tires que de producteurs
  }
}

               ProxySupplier.java
               Supplier.java
               SupplierImpl.java

package fr.cnam.provider;

import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.util.*;
import java.io.*;

// Classe de définition d'un producteur sur un canal de communication
//
public class SupplierImpl extends UnicastRemoteObject implements Supplier
{  
  
  private Consumer consumer;  //  La connexion distante au Proxy des consommateurs  
  private Supplier supplier;  // L'objet utilisé par le Producteur pour qu'on lui tire une objet

// Création d'un producteur sur un canal de communication
  //  canal : le numéro (0 à 9) du canal
  //
  public SupplierImpl(int canal)  throws Exception
  {
    this.supplier=null;
    Supplier sup = (Supplier)(UnicastRemoteObject.toStub(this));
    consumer = ProviderImpl.getProvider().connectSupplier(sup,canal);
  }

// Brancher l'objet utilisé par le Producteur pour qu'on lui tire une objet
  //
  public void setSupplier(Supplier supplier){
    this.supplier=supplier;
  }

// Pour pousser un objet
  //
  public void push(Object o)throws Exception{
    consumer.push(o);
  }

// Pour tirer un objet
  //
  public Object pull() throws RemoteException
  {
    if (supplier==null) throw new RuntimeException("pull non implémenté dans le producteur");
    try{
      return supplier.pull();
    }catch(Exception ex){return null;}
  }

}

      runConsommateur_Canal1.bat
      runConsommateur_Canal2.bat
      runProducteur_Canal1.bat
      runProducteur_Canal2.bat
      runProvider.bat

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE