fin tp

Readme.md

@@ -11,7 +11,9 @@ retournés par le côté serveur.
 <valeur> ::= <char> | <chaine> | [0-9]* | [0-9]* "." [0-9]*
 <chaine> ::= "<char>*"
 <char> ::= un charactère alphanumérique
-<reponse> ::= "resultat:" <type> "," <valeur>
+
+<exception> ::= "<char>*" | "none"
+<reponse> ::= "resultat:" <type> "," <valeur> "|" "Exception:" <exception> 
 ```
 
 ## Exemples de ce qui devra être transmis
@@ -20,4 +22,6 @@ Voici deux exemples de messages transmis par le côté client pour une
 invocation :
 
   + CALL:nombreMots:param[string,"Travail à la  chaîne"]
+  EXEMPLE: "resultat:int,4|Exception:none" 
+  
   + CALL:compteChar:param[string,"arrête ton char"]:param[char,"a"]

src/fr/ulille/iut/m4102/AccesService.java

 package fr.ulille.iut.m4102;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
 import java.util.Arrays;
 
 /**
@@ -11,18 +17,25 @@ import java.util.Arrays;
  * renverra le résultat sous forme de chaîne
  * de caractères.
  */
-public class AccesService {
+public class AccesService implements Runnable {
 	private AlaChaine alc;
+	private Socket s;
 	
-	public AccesService() {
+	public AccesService() throws IOException {
 		alc = new AlaChaine();
 	}
+	public AccesService(Socket sock) {
+		alc = new AlaChaine();
+		s = sock;
+	}
 
-	public String traiteInvocation(String invocation) {
 
+	public String traiteInvocation(String invocation) {
+		System.out.println("REQUEST: " + invocation);
 		String[] invocDivisee = invocation.replace("param[","").replace("]","").split(":");
 		String nomMethode = invocDivisee[1];
 		String[] paramTab = Arrays.copyOfRange(invocDivisee, 2, invocDivisee.length);
+		
 		String resultatFormate = "resultat:";
 
 		switch(nomMethode) {
@@ -57,8 +70,31 @@ public class AccesService {
 			break;
 		}
 		
+		System.out.println("RETURN: " + resultatFormate);
 		return resultatFormate;
 
 	}
 	
+	
+	public void traiteRequete() throws IOException {
+		BufferedReader reception = new BufferedReader(new InputStreamReader(s.getInputStream()));
+		PrintWriter envoi =  new PrintWriter(s.getOutputStream(), true);
+		String str = traiteInvocation(reception.readLine());
+		System.out.println(str);
+		envoi.println(str);
+		reception.close();
+		envoi.close();
+	}
+	
+	public void run() {
+		PrintWriter envoi = null;
+		try {
+			envoi = new PrintWriter(s.getOutputStream(), true);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		envoi.println("Salut client");
+	}
+
 }

src/fr/ulille/iut/m4102/Client.java

@@ -25,12 +25,10 @@ public class Client {
 			// Instanciation de la socket client
 			// S'il n'y a pas d'exception, la connexion est établie
 			clientSocket = new Socket(host, port);
-	}
-	catch (UnknownHostException e) {
+		} catch (UnknownHostException e) {
 			e.printStackTrace();
 			System.exit(1);
-	}
-	catch (IOException e) {
+		} catch (IOException e) {
 			e.printStackTrace();
 			System.exit(1);
 		}
@@ -40,8 +38,7 @@ public class Client {
 			envoi = new PrintWriter(clientSocket.getOutputStream(), true);
 
 			// Récupération d'un flux orienté texte pour lire dans la socket
-	    reception = new BufferedReader(
-					   new InputStreamReader(clientSocket.getInputStream()));
+			reception = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
 		} catch (IOException e) {
 			e.printStackTrace();
 			System.exit(1);
@@ -50,7 +47,6 @@ public class Client {
 
 	public String envoyer(String message) {
 		envoi.println(message);
-	
 		try {
 			return reception.readLine();
 		} catch (IOException e) {
@@ -58,4 +54,9 @@ public class Client {
 		}
 		return null;
 	}
+
+	public Socket getClientSocket() {
+		return clientSocket;
+	}
+
 }
\ No newline at end of file

src/fr/ulille/iut/m4102/Intermediaire.java

 package fr.ulille.iut.m4102;
 
+import java.io.IOException;
+
 /**
  * Cette classe introduit un intermédiaire entre la classe utilisatrice
  * et l'implémentation du traitement des chaînes.
@@ -10,22 +12,34 @@ package fr.ulille.iut.m4102;
  * appelait directement la classe AlaChaine.
  */
 public class Intermediaire implements AlaChaineInterface {
-	private AlaChaine alc;
+	
 	private AccesService aService;
-	public Intermediaire() {
+	private Client client;
+	public Intermediaire() throws IOException {
 
 		aService = new AccesService();
-		alc = new AlaChaine();
+		//alc = new AlaChaine();
 	}
 
 	public int nombreMots(String chaine) {
 		/*  System.out.println("Méthode: NombreMots ; Paramètre(String): "+chaine +" ; Resultat(int): "+alc.nombreMots(chaine));
 	return alc.nombreMots(chaine); */
 		
+		client = new Client("localhost", 8080);
+
 		String invocation = "Call:nombreMots:param[string," + chaine + "]";
 		String resInv = aService.traiteInvocation(invocation);
 		String valeur = resInv.split(":")[1].split(",")[1];
 		
+		String res = null;
+		try {
+			res = client.envoyer(resInv);
+		} catch (Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.out.println(res);
+
 		
 		return Integer.parseInt(valeur);
 
@@ -36,10 +50,22 @@ public class Intermediaire implements AlaChaineInterface {
 		/* System.out.println("Méthode: asphyxie ; Paramètre(String): "+chaine +" ; Resultat(String): "+alc.asphyxie(chaine)+" ; PasDAirException: Déjà asphyxiée");
 	return alc.asphyxie(chaine);*/
 		
+		client = new Client("localhost", 8080);
+		
 		String invocation = "Call:asphyxie:param[string," + chaine + "]";
 		String resInv = aService.traiteInvocation(invocation);
 		String valeur = resInv.split(":")[1].split(",")[1];
 		
+		String res = null;
+		try {
+			res = client.envoyer(resInv);
+		} catch (Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.out.println(res);
+
+		
 		return valeur;
 
 	}
@@ -47,18 +73,46 @@ public class Intermediaire implements AlaChaineInterface {
 	public String leetSpeak(String chaine) {
 		/* System.out.println("Méthode: leetSpeak ; Paramètre(String): "+chaine +" ; Resultat(String): "+alc.leetSpeak(chaine));
 	return alc.leetSpeak(chaine);*/
+		
+		client = new Client("localhost", 8080);
+		
 		String invocation = "Call:leetSpeak:param[string," + chaine + "]";
-		String res = aService.traiteInvocation(invocation);
-		String valeur = res.split(":")[1].split(",")[1];
+		String resInv = aService.traiteInvocation(invocation);
+		String valeur = resInv.split(":")[1].split(",")[1];
+		
+		String res = null;
+		try {
+			res = client.envoyer(resInv);
+		} catch (Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.out.println(res);
+
+		
 		return valeur;
 	}
 
 	public int compteChar(String chaine, char c) {
 		/* System.out.println("Méthode: compteChar ; Paramètre(String, char): "+chaine+", "+c+" ; Resultat(int): "+alc.compteChar(chaine, c));
 	return alc.compteChar(chaine, c);*/
+		
+		client = new Client("localhost", 8080);
+		
 		String invocation = "Call:compteChar:param[string, " + chaine + "]:param[char," + c + "]";
-		String res = aService.traiteInvocation(invocation);
-		String valeur = res.split(":")[1].split(",")[1];
+		String resInv = aService.traiteInvocation(invocation);
+		String valeur = resInv.split(":")[1].split(",")[1];
+
+		String res = null;
+		
+		try {
+			res = client.envoyer(resInv);
+		} catch (Exception e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.out.println(res);
+
 
 		return Integer.parseInt(valeur);	
 

src/fr/ulille/iut/m4102/Serveur.java

@@ -8,11 +8,11 @@ import java.io.PrintWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
 
+
 /**
- * Cette classe démarre une socket serveur et
- * attend les connexions des clients.
- * Quand un client se connecte, elle délègue
- * le travail à la classe AccesService.
+ * Cette classe démarre une socket serveur et attend les connexions des clients.
+ * Quand un client se connecte, elle délègue le travail à la classe
+ * AccesService.
  */
 public class Serveur {
 	private ServerSocket serveurSocket = null;
@@ -22,6 +22,7 @@ public class Serveur {
 			// Création de la Socket Serveur qui permettra d'attendre les connexions
 			serveurSocket = new ServerSocket(port);
 		} catch (IOException e) {
+			//System.out.println(e.getMessage());
 			e.printStackTrace();
 			System.exit(1);
 		}
@@ -45,15 +46,19 @@ public class Serveur {
 			// classe AccesService et lui demander de traiter
 			// la requête.
 
-	    //AccesService as = new AccesService(unClient);
-	    //as.traiteRequete();
+			 AccesService as = new AccesService(unClient);
+			 try {
+				as.traiteRequete();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
 		}
 	}
 
-    // La classe doit être exécutée en passant le port serveur à utiliser en paramètre
+	// La classe doit être exécutée en passant le port serveur à utiliser en
+	// paramètre
 	public static void main(String[] args) {
-	Serveur serveur = new Serveur (Integer.parseInt(args[0]));
-	
-	serveur.miseEnService();
+		Serveur serv = new Serveur(Integer.parseInt(args[0]));
+		serv.miseEnService();
 	}
 }
\ No newline at end of file

src/fr/ulille/iut/m4102/Utilisatrice.java

@@ -13,7 +13,7 @@ public class Utilisatrice {
 	// utilisation normale.
 	// On instancie la classe Intermediaire au lieu
 	// d'instancier directement AlaChaine.
-	Intermediaire i = new Intermediaire();
+	AlaChaineInterface i = new Intermediaire();
 	
 	System.out.println(i.nombreMots("Travail à la  chaîne"));