Proxy java qui supporte les requêtes http

marissalille Messages postés 4 Date d'inscription mardi 29 avril 2008 Statut Membre Dernière intervention 3 février 2009 - 3 févr. 2009 à 15:05
voila25 Messages postés 4 Date d'inscription samedi 15 novembre 2008 Statut Membre Dernière intervention 8 avril 2010 - 6 févr. 2009 à 20:32
bonjour à tous , volià je débute en programmation java et je rencontre quelues difficultés.
mon travail consiste à implémenter un proxy en java. le proxy sera en deux parties: 1 partie client   et 1 partie serveur.voici en gros ce que le programme doit faire:
dans la partie serveur on définit une méthode qui a comme paramètre l'objet requête et qui renvoi un objet réponse, cette méthode doit  {
                                                   émettre le requête http via socket
                                                    attendre / recevoir le réponse http
                                                    retourner l'objet réponse
                                                   }

dans la partie client {
                               on reçoit la requête en http
                               on remplie l'objet requête
                               on appelle la méthode définie dans la partie serveur
                                et enfin on envoie le contenu de l'objet réponse via socket http
                              }

Mon programme se compile mais quand je fais le test en local je n'arrive pas à récupérer les infos, je laisse mes codes pour que vous puissiez y jeter un copu d'oeuil  et me dire ou ça cloche .

6 classes ont été défini : - start serveur ( avec le main)
                                   - proxy thread
                                   - classe réponse et classe requete
                                   - proxy client et proxy serveur
******************************************************************************************************
public class StartServer {

 
  private ProxyThread proxy; // Notre proxy

  public StartServer() {
    // Démarrage des serveurs
    System.out.println("Chargement des services en cours ...");
 
    proxy = new ProxyThread(3128);
  }

  public void stop()
  {
    // Arrêt des services -> interruption des threads
 
    if (proxy.isAlive())
      proxy.interrupt();
  }

  public static void main(String[] args) {
    StartServer server = new StartServer(); // Démarrage du serveur-proxy )
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); // Entrée clavier utilisateur
    String command; // Ligne de commande
    boolean done = false;

    try {
      while (!done){
        System.out.print("Commande : ");
        command = input.readLine();
        if (command.toUpperCase().equals("QUIT")) // On saisit 'QUIT' pour quitter !
          done = true;
      }
    }
    catch (Exception e) {
      System.out.println("Erreur MAIN : " + e);
      System.exit(1);
    }
    finally {
      server.stop();
    }
    System.exit(0);
  }
}

*****************************************************************************************
public class ProxyThread extends Thread{

  private int port;

  public ProxyThread(int port) {
    this.port = port;
    start(); // On exécute la thread;
  }

  public void run() {
    try {
      System.out.println("Serveur Proxy sur port : " + port + " démarré !");
      ServerSocket server = new ServerSocket(port);
      // On attend l'arrivé d'un client
      while (!interrupted()) {
        Socket client = server.accept();
        System.out.println("Client : " + client.getInetAddress());
        new ProxyClient(client);    // On crée un nouveau client proxy
        sleep(5);
      }
      System.out.println("Serveur Proxy sur port : " + port + " arrêté !");
    }
    catch (IOException e) {
    
    }
    catch (InterruptedException e) {
   
    }
  }
}
***********************************************************************************

public class ProxyClient extends Thread{

  private Socket socket;
  private DataInputStream clientIn;
  private DataOutputStream clientOut;
  private String get, host;
  private Requete requete;
  private int port;
  private Reponse reponse;
  static ProxyServer server = new ProxyServer();
 
  public ProxyClient(Socket socket) {
    this.socket = socket;
    port = socket.getPort();
    try {
      // création des flux pour la socket client
      clientIn = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
      clientOut = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
      start();
    }
    catch (IOException e) {
      System.out.println("Erreur IO Client Proxy Server : " + e);
    }
  }

// lecture de la requete

  public void readRequete() throws Exception {
    BufferedReader bin = new BufferedReader(new InputStreamReader(clientIn));
    String line;
    while ((line = bin.readLine()) != null) {
        System.out.println(line);
      if (line.length() == 0)
        break;
       
       if (line.trim().toUpperCase().startsWith("GET")) {
         String url = line.substring(3);
         String rest = "";
         // Obtenir http
         int posit = url.toUpperCase().lastIndexOf("HTTP");
         if (posit >= 0) {
           rest = url.substring(posit).trim();
           url = url.substring(0, posit).trim();
         } else {
           url = url.trim();
         }
         get = url;

         URL getURL = new URL(url);
         requete = new Requete("GET",url);
         System.out.println(socket.getInetAddress().getHostName() + " GET " + url);
         server.Process(requete);
         } else {
        
       }

       // HOST contient l'adresse du serveur
       if (line.trim().toUpperCase().startsWith("HOST:"))
         host = line.substring(5).trim();
    }
  }

public void run(){

reponse = server.Process(requete);
}

}

***************************************************************************************************
public class ProxyServer{

  private Socket socketServer;
  private DataInputStream  serverIn;
  private DataOutputStream  serverOut;
  private String get, host;
  private Requete requete;
  private int port;

public Reponse  Process( Requete requete ){ // méthode qui traite la requeteget host "";
 Reponse r = new Reponse();

      //requete = new Requete();

      // Obtention et transformation de la requête du client
      //readRequete();
      // Connexion avec le serveur
      try {
        URL url = new URL(requete.getUrl());
        int port = url.getPort() > 0 ? url.getPort() : 80;
        socketServer = new Socket(url.getHost(),port);
      }
      catch (Exception e) {
        // Envoi de l'erreur au client
        //PrintWriter out = new PrintWriter(new OutputStreamWriter(clientOut));
        String erreur = new String();
        erreur += ("HTTP/1.0 200 \r\n");
        erreur += ("Content-Type: text/plain \r\n\r\n");
      

        erreur +=("GET:  " + get +" \r\n");
        erreur +=("HOST : " + host+" \r\n");
        erreur +=("Erreur !+\r\n");
        erreur +=(e +"\r\n");
  

       
        try {
      
        if (socketServer != null)
          socketServer.close();
        }
        catch (Exception ex) {}
        r.setreponse(erreur);
        return r ;

      }

try {
// Création flux serveur
      serverIn = new DataInputStream(new BufferedInputStream(socketServer.getInputStream()));
      serverOut = new DataOutputStream(new BufferedOutputStream(socketServer.getOutputStream()));
      // Envoi de la requete au serveur
      new ClientToServerThread(serverOut, requete);
      byte [] reponse = new byte[4096];
      String rep = new String();
      int bytesRead;
      // Lecture des informations du serveur et envoi au client
      while ((bytesRead = serverIn.read(reponse)) != -1) {
          rep += new String(reponse, 0, bytesRead);         
        //clientOut.write(reponse, 0, bytesRead);
        //clientOut.flush();
      }
     
      r.setreponse(rep);
     
      return r;
   
    }
    catch (Exception e) {
      System.out.println("Erreur Client Thread Serveur Proxy sur port : " + port);
    }
    finally {
      try {
     
      
     
        if (socketServer != null)
          socketServer.close();
       
        if (socketServer != null)
          socketServer.close();
      }
      catch (Exception e) {
          System.out.println("Erreur Client Thread Serveur Proxy sur port " + port);
      }
     
 
   
  }     return r;
}

***************************************************************************************
 je pense personnelement que l'erreur réside au niveau de la partie cleint dans la lacture de la requete, a vous de voir .
 toutes les coorections et remarques sont les bienvenues.
Merci  bcp,
 Marie

1 réponse

voila25 Messages postés 4 Date d'inscription samedi 15 novembre 2008 Statut Membre Dernière intervention 8 avril 2010
6 févr. 2009 à 20:32
Bonsoir marissa moi aussi je me suis mis sur la programmation d'un proxy http j'espère qu'on s'entraidera mutuellement. si tu veux en gardera contact par msn ,répond moi par un message de confirmation.              
0