Forums Rue-Montgallet.com
Rue-Montgallet.comRue-Hardware.comRue-Occasion.comRue-DVD.comRue-Jeuxvideo.comRue-AudioVideo.comRue-Telephone.comForums
S'inscrire | S'identifier |
| Recherche avancée | Aide
 

  FORUM


  Programmation


  Java


  connexion socket client serveur java

 
 

Il y a 86 utilisateurs connus et inconnus. Pour voir la liste des connectés connus, cliquez ici

 Mot :   Pseudo :  
 
Bas de page
Auteur
 Sujet :

connexion socket client serveur java

 
n°12955
karim48
Profil : Jeune recrue
Posté le 08-05-2005 à 15:21:44  profilanswer
 

:cry:  
bonjour
je programme sur une architecture client/serveur avec les sockets sur java,et j'ai pas pu faire une implémentation cohérente.
S.V.P envoyer moi une implémentation sur se sujet.

n°12961
ollone
Part of the 'One brothers
Profil : Vieux de la vieille
Posté le 09-05-2005 à 10:17:23  profilanswer
 

D'un coté tu as un thread "ServerSocket", de l'autre un thread "ClientSocket".
Ta socket server écoute tout le temps :

Code :
  1. import java.net.ServerSocket;
  2. import java.net.Socket;
  3. import java.net.NetworkInterface;
  4. import java.net.InetAddress;
  5. import java.io.ObjectOutputStream;
  6. import java.io.ObjectInputStream;
  7. import java.io.IOException;
  8. import java.io.NotSerializableException;
  11. public class ServerThread implements Runnable {
  13.     // Variables de classe.
  14.     private Felix app;
  15.     private int counter = 0;
  16.     private int connectionPort = 2184;
  17.     private boolean listening = true;
  18.     private ServerSocket serverSocket;
  19.     private Socket connection;
  20.     private ObjectOutputStream  output;
  21.     private ObjectInputStream  input;
  23.     /********************************/
  24.     /*        CONSTRUCTOR           */
  25.     /********************************/
  26.     public ServerThread(Felix parent) {
  27.         app = parent;
  28.         startServerThread();
  29.     }
  31.     public ServerThread(int port, Felix parent) {
  32.         if (port>0) {
  33.             connectionPort = port;
  34.         }
  35.         app = parent;
  36.         startServerThread();
  37.     }
  39.     /************************************/
  40.     /*    LANCEMENT DU THREAD SERVER    */
  41.     /************************************/
  42.     private void startServerThread() {
  43.         // On affiche quelques infos intéressantes sur le serveur
  44.         //---displayServerInfos();
  46.         try {
  47.             serverSocket = new ServerSocket(connectionPort);
  48.             System.out.println("> SERVER : Le serveur attend les connections...\n" );
  49.         } catch (IOException e) {
  50.             System.out.println("> SERVER : La socket serveur ne peut pas être lancée sur le port "+connectionPort+"." );
  51.             System.exit(-1);
  52.         }
  53.     }
  55.     /********************************/
  56.     /*             RUN              */
  57.     /********************************/
  58.     public void run() {
  60.         // Tant qu'on indique au thread de vivre.
  61.         // ----------------------------------------
  62.         while (listening) {
  63.             try {
  64.  // DO QUELQUE CHOSE !!!
  65.             }
  66.             catch (IOException e) {
  67.                 System.out.println("> SERVER : l'acceptation de la socket cliente a échouée!" );
  68.             }
  69.         }
  71.         // On a décidé de ne plus écouter les appels client; le thread va se terminer.
  72.         try {
  73.             serverSocket.close();
  74.         }
  75.         catch (IOException e) {
  76.             System.out.println("> SERVER : la tentative de fermeture du thread serveur a échouée!" );
  77.         }
  78.     }
  80.     /********************************/
  81.     /*       OTHERS METHODS         */
  82.     /********************************/
  83.     public void setListening(boolean state) {
  84.         listening = state;
  85.     }
  87.     public void displayServerInfos() {
  88.         try {
  89.             NetworkInterface nwi = NetworkInterface.getByInetAddress(InetAddress.getByName(app.getLocalHost()));
  90.             System.out.println("-------------------------------------------------" );
  91.             System.out.println("> Network interface : " + nwi.getDisplayName());
  92.             System.getProperties().list(System.out);
  93.             System.out.println("-------------------------------------------------\n" );
  94.         } catch(IOException e) {}
  95.     }
  96. }


 
 
Quant à la socket cliente :

Code :
  1. import java.io.ObjectInputStream;
  2. import java.io.IOException;
  3. import java.io.EOFException;
  4. import java.io.ObjectOutputStream;
  5. import java.net.InetAddress;
  6. import java.net.Socket;
  7. import java.net.UnknownHostException;
  10. public class ClientThread implements Runnable {
  12.     // Initialisation des variables de communication.
  13.     private InetAddress addr;
  14.     private Socket client;
  15.     private ObjectOutputStream  output;
  16.     private ObjectInputStream  input;
  18.     // Variables locales.
  19.     private int connectionPort = 2184;
  20.     private String text = null;
  21.     private boolean quitClient = false;
  23.     /********************************/
  24.     /*        CONSTRUCTORS          */
  25.     /********************************/
  27.     // Ce constructeur est voué à la destruction !!!
  28.     public ClientThread(){}
  30.     /********************************/
  31.     /*             RUN              */
  32.     /********************************/
  33.     public void run() {
  34.         System.out.println("> Client thread running" );
  35.         try {
  36.             // Création du "tuyau".
  37.             this.addr = InetAddress.getByName(destinataire.getHost());
  38.             client = new Socket(addr, connectionPort);
  39.             // Envoi du message.
  40.             sendMessage();
  41.         }
  42.         catch (UnknownHostException e) {
  43.             System.out.println("> CLIENT ("+destinataire.getName()+" ): Le client n'a pas trouvé de serveur à l'adresse "+destinataire.getHost());
  44.             System.out.println("> CLIENT ("+destinataire.getName()+" ): échec de connexion." );
  45.             // On met à jour l'état de connexion du contact.
  46.             updateContactConnectionStatus(FelixContact.CONTACT_STATUS_DISCONNECTED);
  47.         }
  48.         catch(IOException e) {
  49.             System.out.println("> CLIENT ("+destinataire.getName()+" ): Impossible d'établir la connexion avec "+destinataire.getName()+"." );
  51.             // On met à jour l'état de connexion du contact.
  52.             updateContactConnectionStatus(FelixContact.CONTACT_STATUS_DISCONNECTED);
  54.             // Si on interrogeait le contact pour tester son état de connexion.
  55.             if (messageType == FelixMessage.CHECK_CONTACT_CONNECTION) {
  56.                 System.out.println("> CLIENT ("+destinataire.getName()+" ): le contact ne semble pas être en ligne." );
  57.             }
  58.             // Si on tentait d'envoyer un message à un contact.
  59.             else if (messageType == FelixMessage.CONTACT_MESSAGE) {
  60.                 System.out.println("> CLIENT ("+destinataire.getName()+" ): le contact n'est pas joignable; impossible d'envoyer le message." );
  61.             }
  62.         }
  63.     }
  65.     // =========================================================
  66.     // Méthode de pilotage de la communication client/serveur.
  67.     // =========================================================
  68.     private void sendMessage() {
  69.         try {
  70.             // On crée les streams d'entrée / sortie.
  71.             output=new ObjectOutputStream(client.getOutputStream());
  72.             output.flush();
  73.             input=new ObjectInputStream(client.getInputStream());
  74.             // On pilote la communication et surtout son arrêt.
  75.             do{
  76.                 // Le client a la priorité d'envoi de message.
  77.                 sendData();
  79.                 try {
  80.                     // On lit le contenu de la communication.
  81.                     messageObject = (FelixMessage)input.readObject();
  83.                     // Si on cherchait à vérifier la connectivité avec le contact.
  84.                     if (messageType==FelixMessage.CHECK_CONTACT_CONNECTION && messageObject.isConnectionSuccessfull()) {
  85.                         System.out.println("> CLIENT ("+destinataire.getName()+" ): le contact distant a répondu 'connecté' =)" );
  86.                         quitClient = true;
  87.                         sendTerminate();
  88.                     }
  89.                     // La réponse nous indique que le contact nous a banni!
  90.                     else if (messageObject.isContactBanished()) {
  91.                         System.out.println("> CLIENT ("+destinataire.getName()+" ): le contact distant vous a banni de sa liste!" );
  92.                         quitClient = true;
  93.                         sendTerminate();
  94.                     }
  95.                     else if (messageObject.isConnectionTerminate()) {
  96.                         quitClient = true;
  97.                     }
  98.                 }
  99.                 catch(ClassNotFoundException e){
  100.                     System.out.println("> CLIENT ("+destinataire.getName()+" ): Le type de l'objet recu est inconnu!" );
  101.                     quitClient = true;
  102.                 }
  104.             } while(!quitClient);
  106.             // Le message a bien été envoyé.
  108.             input.close();
  109.             output.close();
  110.             client.close();
  112.         }
  113.         catch(EOFException eof){
  114.             System.out.println("> CLIENT ("+destinataire.getName()+" ): Le server a terminé la connection inopinément! Le client se ferme..." );
  115.             //app.chatTPane.addConvInfoEntry(convId, "Problème de connexion", "Le client a terminé la connection inopinément! Le message n'a peut-être pas été reçu." );
  116.         }
  117.         catch(IOException e) {
  118.             System.out.println("> CLIENT ("+destinataire.getName()+" ): communication client/serveur interrompue par une IOException." );
  119.             //app.chatTPane.addConvInfoEntry(convId, "Problème de connexion", "La communication avec le client s'est interrompue." );
  120.         }
  121.     }
  123.     /*************************************************/
  124.     /*   METHODES D'ENVOI D'UN MESSAGE A UN CONTACT  */
  125.     /*************************************************/
  126.     private void sendData() {
  127.         FelixMessage message;
  128.         if (text!=null && convId!=null && messageType==FelixMessage.CONTACT_MESSAGE) {
  129.             // On crée un message d'envoi de message.
  130.             message = new FelixMessage(app.getLocalUser(), text, convId);
  131.         }
  132.         else {
  133.             // On crée un message "de communication".
  134.             message = new FelixMessage(app.getLocalUser(), messageType);
  135.         }
  136.         try {
  137.             output.writeObject(message);
  138.             output.flush();
  139.         }
  140.         catch(IOException e) {
  141.             System.out.println("> CLIENT ("+destinataire.getName()+" ): Une erreur est apparue lors de l'écriture de l'objet a envoyé." );
  142.         }
  143.     }
  145.     private void sendTerminate() {
  146.         FelixMessage message = new FelixMessage(app.getLocalUser(), FelixMessage.CONNECTION_TERMINATE);
  147.         try {
  148.             output.writeObject(message);
  149.             output.flush();
  150.         }
  151.         catch(IOException e) {}
  152.     }
  153. }


 
 
Désolé, le code est dépouillé et donc il manque des trucs (volontairement et surtout pour la socket cliente), donc à toi de faire le travail d'analyse.
 
 
En gros, pour le principe, la socket server écoute tout le temps et ne s'arrête "jamais", la socket cliente est crée au besoin

Code :
  1. ClientThread xclientThread = new ClientThread();
  2. new Thread(xclientThread).start();


Et la socket cliente s'arrête d'elle-même lorsque le client et le server se sont mis d'accord.
 
Voilà :)


Message édité par ollone le 09-05-2005 à 10:27:01
n°12991
Syruis
Baaaaaaaaaaaaah!
Profil : Membre
Posté le 10-05-2005 à 23:31:28  profilanswer
 

rien en vaut les bons vieux sockets en C ... :)

n°12999
ollone
Part of the 'One brothers
Profil : Vieux de la vieille
Posté le 11-05-2005 à 11:56:03  profilanswer
 

Bah ouais, mais là c'est du Java :p
Et puis je sens comme une pointe d'envie, comme si Java prenait de plus en plus de poids :p ;)

n°14937
Aubinou
Profil : Jeune recrue
Posté le 14-10-2005 à 15:26:26  profilanswer
 

Slt  
oue kand meme. je pense aussi. allone pkoi ta depouillé la socket cliente ?? j'en ai besoin. please

n°14938
Aubinou
Profil : Jeune recrue
Posté le 14-10-2005 à 15:26:54  profilanswer
 

cest ollone desolé lol


Aller à :
Ajouter une réponse

  FORUM


  Programmation


  Java


  connexion socket client serveur java

 

Forum MesDiscussions.Net, Version 2007.2
(c) 2000-2007 No1Dev
Page générée en 0.464 secondes