problème client-serveur (socket)

problème client-serveur (socket) - Java - Programmation

Marsh Posté le 20-01-2013 à 16:21:22    

Bonjour,
 
J'aurai aimé avoir un bout de code à pointer et dire "ici ça ne marche pas et je sais pas pourquoi", comme indiqué dans le topic des bonnes pratiques, mais malheureusement ce n'est pas le cas.
 
Je suis confronté à un comportement bizarre de mon projet de client-server java par socket, que je n'arrive pas à comprendre ou à en isoler les causes.
 
Je vous explique :
Voulant développer un petit programme perso, et ayant déjà été confronté à la difficulté de faire communiquer plusieurs personnes utilisant le même programme, je me suis dit : Tiens, je vais développer une petite librairie client-server en java, utilisant les sockets. Je tiens à dire que j'avais réussi à créer une application client-server en java par socket il y a peu, mais que le code du serveur et du client était trop lié à l'application pour être réutilisé en l'état. J'ai donc créé un nouveau projet, que j'ai nommé LibraryNetworkMango, dont le but était de proposer un petit serveur java pouvant envoyer des Object java par sérialization.
Donc j'ai développé ce projet, qui marche bien, sauf un comportement que je ne comprend pas du tout.
 
Donc le problème :
- Lorsqu'un client (MangoClient) se connecte au serveur (MangoServer), le serveur l'accepte et lui donne un ID unique (PersonnalID), du côté client, lorsque je reçois cette ID unique, je considère que c'est interne, et je n’envoie pas de notification à l'application.
- Là, c'est l'application qui gère, dans mon cas j'envoie un objet donnant l'état de l'application client au serveur après avoir lancé le client.
- Le serveur reçoit un event (MangoServerEvent), qui contient un type (EventTypeServer) état OBJECTRECEIVED.
- A ce moment-là, le serveur (de l'application) décide de faire une MAJ avec les informations reçues du client, puis de tout ré-envoyer à tous les clients (note: le serveur est aussi une instance de mon application, et donc je rafraîchis le GUI avec les nouvelles informations du client, et ça s'affiche donc c'est bon).
- Le client reçoit la MAJ et rafraîchit son GUI, ça marche.
- A partir de là, je me retrouve confronté à un cas de figure bien particulier :
  _ Toute modification du client est envoyé au serveur et affiché (la connexion dans ce sens marche).
  _ Toute modification du serveur ne s'affiche pas côté client. J'ai mis des System.out.println(); côté client et serveur afin de lire ce que j'envoie et reçoit, et il s'avère que l'objet envoyé correspond, mais que l'objet reçu est toujours la première version de l'objet reçu (le premier objet envoyé par le serveur).
 
Voici une image représentant l'arborescence de mon projet sur Netbeans :
http://data.imagup.com/12/1173359517.jpg
 
Il faut que je m'excuse pour la quantité de code qui va suivre, ne sachant pas où se trouve l'erreur...
Note : j'ai enlevé tous les commentaires afin de diminuer la quantité de code J'ai aussi enlevé la partie envoyer des String (je voulais que Mango offre la possibilité de choisir le mode de communication). J'ai aussi enlevé la partie affichant l'état au fur et à mesure.
 
Merci d'avance si vous prenez le temps de vous pencher sur mon problème, je suis bloqué dessus depuis trois jours...
 
MangoClient
Code complet (commentaire, affiche de l'état, possibilité d'envoyer des String) : 694 lignes.
Version allégé : 245 lignes.

Code :
  1. package newpackage;
  3. import CommonClass.*;
  4. import java.io.*;
  5. import java.net.InetAddress;
  6. import java.net.Socket;
  7. import java.net.SocketException;
  8. import java.net.UnknownHostException;
  9. import java.util.logging.Level;
  10. import java.util.logging.Logger;
  12. public class MangoClient implements Runnable {
  14.     private String password;
  15.     private CommunicationType communicationType;
  16.     private ObjectInputStream readerObjet;
  17.     private ObjectOutputStream writerObjet;
  18.     private BufferedReader readerString;
  19.     private BufferedWriter writerString;
  20.     public MangoClientListener mangoListener;
  21.     private Socket serverClient;
  22.     private Thread network;
  23.     private String ip;
  24.     private int port;
  25.     private static boolean afficherLogTest = true;
  26.     private int personalID;
  28.     public MangoClient(String ip, int port, String password, CommunicationType communicationType, MangoClientListener mangoListener) {
  29.         this.personalID = -1;
  30.         this.ip = ip;
  31.         this.port = port;
  32.         this.communicationType = communicationType;
  33.         this.password = password;
  34.         this.mangoListener = mangoListener;
  35.     }
  37.     public MangoClient(String ip, int port, CommunicationType communicationType, MangoClientListener mangoListener) {
  38.         this(ip, port, "", communicationType, mangoListener);
  39.     }
  41.     @Override
  42.     public void run() {
  43.         if (this.communicationType == CommunicationType.OBJECT) {
  44.             while (this.network != null && this.readerObjet != null) {
  45.                 Capsule capsule;
  46.                 try {
  47.                     if ((capsule = (Capsule) this.readerObjet.readObject()) != null) {
  48.                         if (capsule.getMangoMessage() == MangoMessage.INTERN || capsule.getMangoMessage() == MangoMessage.INTERN_PERSONALID) {
  49.                             if (capsule.getMangoMessage() == MangoMessage.INTERN) {
  50.                                 String temp = (String) capsule.getObjet();
  51.                                 this.responseIntern(temp);
  52.                             } else { // INTERN_PERSONALID
  53.                                 this.personalID = (int) capsule.getObjet();
  54.                             }
  55.                         } else {
  56.                             if (this.mangoListener != null) {
  57.                                 this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(capsule.getObjet(), this.communicationType));
  58.                             }
  59.                         }
  60.                     }
  61.                 } catch (IOException ex) {
  62.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  63.                     this.stop();
  64.                     this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  65.                 } catch (ClassNotFoundException ex) {
  66.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  67.                 }
  68.             }
  69.         }
  70.     }
  72.     private void sendINTERN(Object objet) {
  73.         switch (this.communicationType) {
  74.             case OBJECT:
  75.                 if (this.writerObjet != null) {
  76.                     Capsule capsule = new Capsule(objet, MangoMessage.INTERN);
  77.                     try {
  78.                         this.writerObjet.writeObject(capsule);
  79.                         this.writerObjet.flush();
  80.                     } catch (IOException ex) {
  81.                         Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  82.                         this.stop();
  83.                         this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  84.                     }
  85.                 }
  86.                 break;
  87.         }
  88.     }
  90.     public void send(Object objet) {
  91.         switch (this.communicationType) {
  92.             case OBJECT:
  93.                 if (this.writerObjet != null) {
  94.                     Capsule capsule = new Capsule(objet);
  95.                     try {
  96.                         this.writerObjet.writeObject(capsule);
  97.                         this.writerObjet.flush();
  98.                     } catch (IOException ex) {
  99.                         Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  100.                         this.stop();
  101.                         this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  102.                     }
  103.                 }
  104.                 break;
  105.         }
  106.     }
  108.     public void stop() {
  109.         this.network = null;
  110.         switch (this.communicationType) {
  111.             case OBJECT:
  112.                 this.readerObjet = null;
  113.                 this.writerObjet = null;
  114.                 break;
  115.         }
  116.         try {
  117.             this.serverClient.close();
  118.         } catch (IOException ex) {
  119.             Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  120.             this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  121.         }
  122.     }
  124.     public void launchMangoClient() {
  125.         boolean err = false;
  126.         try {
  127.             this.serverClient = new Socket(this.ip, this.port);
  128.             this.serverClient.setSoTimeout(2000); // we wait max 2 seconds before timeout error
  129.             if (!this.serverClient.isConnected()) {
  130.                 err = true;
  131.                 this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  132.             }
  133.         } catch (UnknownHostException ex) {
  134.             Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  135.             this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  136.         } catch (IOException ex) {
  137.             Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  138.             this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  139.         }
  140.         if (err == false) {
  141.             InputStream inputStream = null;
  142.             OutputStream outputStream = null;
  143.             try {
  144.                 inputStream = this.serverClient.getInputStream();
  145.             } catch (IOException ex) {
  146.                 err = true;
  147.                 Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  148.                 this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  149.             }
  150.             if (err == false) {
  151.                 switch (this.communicationType) {
  152.                     case OBJECT:
  153.                         try {
  154.                             this.readerObjet = new ObjectInputStream(new BufferedInputStream(inputStream));
  155.                         } catch (IOException ex) {
  156.                             err = true;
  157.                             Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  158.                             this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  159.                         }
  160.                         break;
  161.                 }
  162.                 try {
  163.                     outputStream = this.serverClient.getOutputStream();
  164.                 } catch (IOException ex) {
  165.                     err = true;
  166.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  167.                     this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  168.                 }
  169.                 switch (this.communicationType) {
  170.                     case OBJECT:
  171.                         try {
  172.                             this.writerObjet = new ObjectOutputStream(outputStream);
  173.                         } catch (IOException ex) {
  174.                             err = true;
  175.                             Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  176.                             this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  177.                         }
  178.                         break;
  179.                 }
  180.                 InetAddress url = this.serverClient.getInetAddress();
  181.                 this.personalID = this.waitingForPersonalID();
  182.                 if (this.personalID == -1) {
  183.                     this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  184.                 }
  185.                 this.network = new Thread(this);
  186.                 this.network.setName("RestoClient: Logged on: " + url.getHostAddress());
  187.                 this.network.setPriority(Thread.NORM_PRIORITY);
  188.                 this.network.start();
  189.                 try {
  190.                     this.serverClient.setSoTimeout(0);
  191.                 } catch (SocketException ex) {
  192.                     err = true;
  193.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  194.                     this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  195.                 }
  196.             } else {
  197.                 this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  198.             }
  199.         }
  200.     }
  202.     private void responseIntern(String temp) {
  203.         String stringResponse = null;
  204.         switch (temp) {
  205.             case "INTERN/askpassword":
  206.                 stringResponse = this.password;
  207.                 break;
  208.             default: // on reçoit la personalID sous la forme "INTERN/xxx"
  209.                 String id_string = temp.substring(7);
  210.                 this.personalID = Integer.parseInt(id_string);
  211.                 break;
  212.         }
  213.         if (stringResponse != null) {
  214.             if (this.communicationType == CommunicationType.OBJECT) {
  215.                 this.sendINTERN(stringResponse);
  216.             }
  217.         }
  218.     }
  220.     public int getPersonalID() {
  221.         return this.personalID;
  223.     }
  225.     private int waitingForPersonalID() {
  226.         int personalID_local = -1;
  227.         switch (this.communicationType) {
  228.             case OBJECT:
  229.                 Capsule capsule;
  230.                 try {
  231.                     if ((capsule = (Capsule) this.readerObjet.readObject()) != null) {
  232.                         personalID_local = (int) capsule.getObjet();
  233.                     }
  234.                 } catch (IOException ex) {
  235.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  236.                     this.stop();
  237.                     this.mangoListener.receiveMangoClientEvent(new MangoClientEvent(EventTypeClient.CLIENTCRASH));
  238.                 } catch (ClassNotFoundException ex) {
  239.                     Logger.getLogger(MangoClient.class.getName()).log(Level.SEVERE, null, ex);
  240.                 }
  241.                 break;
  242.         }
  243.         return personalID_local;
  244.     }
  245. }


 
MangoServer
Code complet (commentaire, affiche de l'état, possibilité d'envoyer des String) : 407 lignes.
Version allégé : 215 lignes.

Code :
  1. package newpackage;
  3. import CommonClass.*;
  4. import java.io.IOException;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. import java.util.ArrayList;
  8. import java.util.logging.Level;
  9. import java.util.logging.Logger;
  11. public class MangoServer implements Runnable, MangoServerListener {
  13.     private boolean acceptingClient;
  14.     private int serverPort;
  15.     private int maxClient;
  16.     private String password;
  17.     private CommunicationType communicationType;
  18.     private boolean isPassword;
  19.     private ArrayList<MangoSocket> clients;
  20.     private ServerSocket server;
  21.     private Thread seeker;
  22.     private MangoServerListener mangoListener;
  23.     private boolean isWaitingInternalCommand;
  24.     private static boolean afficherLogTest = false;
  25.     private boolean error;
  27.     public MangoServer(int serverPort, int maxClient, String password, CommunicationType serverType, MangoServerListener mangoListener) {
  28.         this.error = false;
  29.         this.mangoListener = mangoListener;
  30.         this.acceptingClient = true;
  31.         this.serverPort = serverPort;
  32.         this.maxClient = maxClient;
  33.         this.password = password;
  34.         this.communicationType = serverType;
  35.         this.isWaitingInternalCommand = false;
  36.         if (this.password == null) {
  37.             this.isPassword = false;
  38.         } else {
  39.             if (this.password.equals("" )) {
  40.                 this.isPassword = false;
  41.             } else {
  42.                 this.isPassword = true;
  43.             }
  44.         }
  45.         this.clients = new ArrayList<>();
  46.         try {
  47.             this.server = new ServerSocket(this.serverPort);
  48.         } catch (IOException ex) {
  49.             this.closeMangoServer();
  50.             this.mangoListener.receiveMangoServerEvent(new MangoServerEvent(EventTypeServer.SERVERCRASH));
  51.             Logger.getLogger(MangoServer.class.getName()).log(Level.SEVERE, null, ex);
  52.         }
  53.     }
  55.     public MangoServer(int serverPort, int maxClient, CommunicationType serverType, MangoServerListener mangoListener) {
  56.         this(serverPort, maxClient, "", serverType, mangoListener);
  57.     }
  59.     public void stopAcceptingClient() {
  60.         this.acceptingClient = false;
  61.         this.seeker = null;
  62.     }
  64.     public void startMangoServer() {
  65.         this.seeker = new Thread(this);
  66.         this.seeker.setName(" MangoServer: Client Seeker" );
  67.         this.seeker.setPriority(Thread.MIN_PRIORITY);
  68.         this.seeker.start();
  69.     }
  71.     public void closeMangoServer() {
  72.         this.seeker.interrupt();
  73.         this.seeker = null;
  74.         try {
  75.             this.server.close();
  76.         } catch (IOException ex) {
  77.             Logger.getLogger(MangoServer.class.getName()).log(Level.SEVERE, null, ex);
  78.         }
  79.         this.killAndRemoveAllClient();
  80.     }
  82.     @Override
  83.     public void run() {
  84.         boolean accept_new_client = true;
  85.         while (this.acceptingClient == true && this.seeker != null && accept_new_client == true && this.error == false) {
  86.             Socket client = null;
  87.             if (this.server != null) {
  88.                 try {
  89.                     client = this.server.accept();
  90.                 } catch (IOException ex) {
  91.                     this.error = true;
  92.                     Logger.getLogger(MangoServer.class.getName()).log(Level.SEVERE, null, ex);
  93.                 }
  94.                 if (this.error == false) {
  95.                     if (this.isPassword) {
  96.                         this.askPasswordFromNewClient(new MangoSocket(client, this.communicationType, this));
  97.                     } else {
  98.                         this.acceptNewClient(new MangoSocket(client, this.communicationType, this));
  99.                     }
  100.                 }
  101.             }
  102.             if (this.maxClient > 0) {
  103.                 if (this.maxClient > this.countClient()) {
  104.                     accept_new_client = true;
  105.                 } else {
  106.                     accept_new_client = false;
  107.                 }
  108.             }
  109.         }
  110.     }
  112.     private void acceptNewClient(MangoSocket mangoSocket) {
  113.         this.clients.add(mangoSocket);
  114.         this.mangoListener.receiveMangoServerEvent(new MangoServerEvent(EventTypeServer.NEWCLIENT));
  115.     }
  117.     private void askPasswordFromNewClient(MangoSocket mangoSocket) {
  118.         this.isWaitingInternalCommand = true;
  119.         switch (this.communicationType) {
  120.             case OBJECT:
  121.                 Capsule capsule = new Capsule("INTERN/askpassword", MangoMessage.INTERN);
  122.                 mangoSocket.send(capsule);
  123.                 break;
  124.         }
  125.     }
  127.     private void sendNotificationWrongPasswordToNewClient(MangoSocket mangoSocket) {
  128.         switch (this.communicationType) {
  129.             case OBJECT:
  130.                 Capsule capsule = new Capsule("/wrongpassword", MangoMessage.INTERN);
  131.                 mangoSocket.send(capsule);
  132.                 break;
  133.         }
  134.     }
  136.     public boolean respondToClient(Object objet, int personnalID) {
  137.         boolean retour = false;
  138.         MangoSocket mangoSocket = this.getMangoSocket(personnalID);
  139.         if (mangoSocket != null) {
  140.             retour = mangoSocket.send(objet);
  141.         }
  142.         return retour;
  143.     }
  145.     public boolean respondToAllClients(Object objet) {
  146.         boolean zeroErreur = true;
  147.         for (MangoSocket mangoSocket : this.clients) {
  148.             if (mangoSocket != null) {
  149.                 boolean retour = mangoSocket.send(objet);
  150.                 if (retour == false) {
  151.                     zeroErreur = false;
  152.                 }
  153.             }
  154.         }
  155.         return zeroErreur;
  156.     }
  158.     private MangoSocket getMangoSocket(int personnalID) {
  159.         MangoSocket mangoSocket = null;
  160.         for (MangoSocket r : this.clients) {
  161.             if (r.getPersonalID() == personnalID) {
  162.                 mangoSocket = r;
  163.             }
  164.         }
  165.         return mangoSocket;
  166.     }
  168.     private void killAndRemoveAllClient() {
  169.         for (MangoSocket r : this.clients) {
  170.             r.addMangoListener(null);
  171.             r.kill();
  172.         }
  173.     }
  175.     public int countClient() {
  176.         return this.clients.size();
  177.     }
  179.     @Override
  180.     public void receiveMangoServerEvent(MangoServerEvent mangoEvent) {
  181.         if (this.isWaitingInternalCommand) {
  182.             MangoSocket mangoClient;
  183.             mangoClient = this.getMangoSocket(mangoEvent.getPersonnalID());
  184.             String temp = "";
  185.             if (mangoClient != null) {
  186.                 if (temp.equals(this.password)) {
  187.                     this.acceptNewClient(mangoClient);
  188.                 } else {
  189.                     this.sendNotificationWrongPasswordToNewClient(mangoClient);
  190.                 }
  191.             }
  192.         } else {
  193.             switch (mangoEvent.getEventType()) {
  194.                 case LOSTCLIENT:
  195.                     this.removeAndKillClientByPersonnalID(mangoEvent.getPersonnalID());
  196.                     break;
  197.                 case OBJECTRECEIVED:
  198.                     mangoEvent = new MangoServerEvent(mangoEvent.getObjet(), this.communicationType);
  199.                     break;
  200.                 case STRINGRECEIVED:
  201.                     mangoEvent = new MangoServerEvent(mangoEvent.getString(), this.communicationType);
  202.                     break;
  203.             }
  204.             this.mangoListener.receiveMangoServerEvent(mangoEvent);
  205.         }
  206.     }
  208.     private void removeAndKillClientByPersonnalID(int personnalID) {
  209.         MangoSocket mangoSocketToDelete = this.getMangoSocket(personnalID);
  210.         if (mangoSocketToDelete != null) {
  211.             this.clients.remove(mangoSocketToDelete);
  212.             mangoSocketToDelete.kill();
  213.         }
  214.     }
  215. }


 
MangoSocket
Code complet (commentaire, affiche de l'état, possibilité d'envoyer des String) : 397 lignes.
Version allégé : 153 lignes.

Code :
  1. package newpackage;
  3. import CommonClass.*;
  4. import java.io.*;
  5. import java.net.Socket;
  6. import java.util.logging.Level;
  7. import java.util.logging.Logger;
  9. public class MangoSocket implements Runnable {
  11.     private static int countOfID = 1;
  12.     private int personalID;
  13.     private CommunicationType communicationType;
  14.     private Socket socketClient;
  15.     private Thread thread;
  16.     private ObjectInputStream readerObject;
  17.     private ObjectOutputStream writerObject;
  18.     private BufferedReader readerString;
  19.     private BufferedWriter writerString;
  20.     public MangoServerListener mangoListener;
  21.     private static boolean afficherLogTest = true;
  23.     public MangoSocket(Socket socketClient, CommunicationType serverType, MangoServerListener mangoListener) {
  24.         this.mangoListener = mangoListener;
  25.         this.personalID = MangoSocket.getID();
  26.         System.out.println("personalID: " + this.personalID);
  27.         this.communicationType = serverType;
  28.         this.socketClient = socketClient;
  29.         OutputStream outputStream = null;
  30.         InputStream inputStream = null;
  31.         try {
  32.             outputStream = this.socketClient.getOutputStream();
  33.         } catch (IOException ex) {
  34.             Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  35.         }
  36.         switch (this.communicationType) {
  37.             case OBJECT:
  38.                 try {
  39.                     this.writerObject = new ObjectOutputStream(outputStream);
  40.                 } catch (IOException ex) {
  41.                     Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  42.                 }
  43.                 break;
  44.         }
  45.         try {
  46.             inputStream = this.socketClient.getInputStream();
  47.         } catch (IOException ex) {
  48.             Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  49.         }
  50.         switch (this.communicationType) {
  51.             case OBJECT:
  52.                 try {
  53.                     this.readerObject = new ObjectInputStream(new BufferedInputStream(inputStream));
  54.                 } catch (IOException ex) {
  55.                     Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  56.                 }
  57.                 break;
  58.         }
  59.         if (this.communicationType == CommunicationType.OBJECT) {
  60.             this.sendCapsule(new Capsule(this.personalID, MangoMessage.INTERN_PERSONALID));
  61.         }
  62.         this.thread = new Thread(this);
  63.         this.thread.setName("MangoSocket " + this.personalID);
  64.         this.thread.setPriority(Thread.MIN_PRIORITY);
  65.         this.thread.start();
  66.     }
  68.     private static int getID() {
  69.         return MangoSocket.countOfID++;
  70.     }
  72.     public int getPersonalID() {
  73.         return personalID;
  74.     }
  76.     public void kill() {
  77.         try {
  78.             this.socketClient.close();
  79.         } catch (IOException ex) {
  80.             Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  81.         }
  82.         this.thread = null;
  83.         this.readerObject = null;
  84.         this.writerObject = null;
  85.         this.readerString = null;
  86.         this.writerString = null;
  87.         if (this.mangoListener != null) {
  88.             this.mangoListener.receiveMangoServerEvent(new MangoServerEvent(EventTypeServer.LOSTCLIENT, this.personalID));
  89.         }
  90.     }
  92.     public boolean send(Object objet) {
  93.         boolean result = false;
  94.         switch (this.communicationType) {
  95.             case OBJECT:
  96.                 result = this.sendObject(objet);
  97.                 break;
  98.         }
  99.         return result;
  100.     }
  102.     private boolean sendObject(Object objet) {
  103.         Capsule capsule = new Capsule(objet);
  104.         return this.sendCapsule(capsule);
  105.     }
  107.     private boolean sendCapsule(Capsule capsule) {
  108.         boolean result;
  109.         if (this.communicationType == CommunicationType.OBJECT) {
  110.             if (this.writerObject != null) {
  111.                 result = true;
  112.                 try {
  113.                     this.writerObject.writeObject(capsule);
  114.                     this.writerObject.flush();
  115.                 } catch (IOException ex) {
  116.                     Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  117.                 }
  118.             } else {
  119.                 result = false;
  120.             }
  121.         } else {
  122.             result = false;
  123.         }
  124.         return result;
  125.     }
  127.     @Override
  128.     public void run() {
  129.         switch (this.communicationType) {
  130.             case OBJECT:
  131.                 while (this.readerObject != null) {
  132.                     Capsule capsule;
  133.                     try {
  134.                         if ((capsule = (Capsule) this.readerObject.readObject()) != null) {
  135.                             if (this.personalID != -1) {
  136.                                 this.mangoListener.receiveMangoServerEvent(new MangoServerEvent(capsule.getObjet(), this.communicationType));
  137.                             }
  138.                         }
  139.                     } catch (IOException ex) {
  140.                         this.kill();
  141.                         Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  142.                     } catch (ClassNotFoundException ex) {
  143.                         Logger.getLogger(MangoSocket.class.getName()).log(Level.SEVERE, null, ex);
  144.                     }
  145.                 }
  146.                 break;
  147.         }
  148.     }
  150.     public void addMangoListener(MangoServerListener mangoListener) {
  151.         this.mangoListener = mangoListener;
  152.     }
  153. }

Reply

Marsh Posté le 20-01-2013 à 16:21:22   

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed