// Figure 17.4 : Serveur.java
// Mettre en place un serveur qui attend la connexion
// d'un client, lui envoie une chaîne et ferme la connexion.

// Packages de noyau Java.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;

// Packages d'extension Java.
import javax.swing.*;

public class Serveur extends JFrame {
   private JTextField champEntree;
   private JTextArea zoneAffichage;
   private ObjectOutputStream sortie;
   private ObjectInputStream entree;
   private ServerSocket serveur;
   private Socket connexion;
   private int compteur = 1;

   // Préparer la GUI.
   public Serveur() {
      super( "Serveur" );

      Container conteneur = getContentPane();

      // Créer le champEntree et inscrire l'écouteur.
      champEntree = new JTextField();
      champEntree.setEnabled( false );
      champEntree.addActionListener(
         new ActionListener() {
            // Envoyer message au client.
            public void actionPerformed( ActionEvent evenement ) {
               envoyerDonnees( evenement.getActionCommand() );
            }
         }
      );

      conteneur.add( champEntree, BorderLayout.NORTH );

      // Créer la zoneAffichage.
      zoneAffichage = new JTextArea();
      conteneur.add( new JScrollPane( zoneAffichage ), BorderLayout.CENTER );

      setSize( 330, 150 );
      setVisible( true );
   }

   // Préparer et lancer le serveur.
   public void lancerServeur() {
      // Préparer le serveur à recevoir des connexions;
      // traiter ces connexions.
      try {
         // Étape 1 : créer un ServerSocket.
         serveur = new ServerSocket( 5000, 100 );
         while ( true ) {
            // Étape 2 : attendre une connexion.
            attendreUneConnexion();
            // Étape 3 : obtenir les flux d'entrée et de sortie.
            obtenirLesFlux();
            // Étape 4 : traiter la connexion.
            traiterConnexion();
            // Étape 5 : fermer la connexion.
            fermerConnexion();
            ++compteur;
         }
      }
      // Traiter l'EOFException quand le client clôt la connexion.
      catch ( EOFException eofException ) {
         System.out.println( "Le client a interrompu la connexion." );
      }
      // Traiter les éventuels problèmes d'E/S.
      catch ( IOException ioException ) {
         ioException.printStackTrace();
      }
   }

   // Attendre l'arrivée d'une connexion, puis en afficher les infos.
   private void attendreUneConnexion() throws IOException {
      zoneAffichage.setText( "En attente de connexion.\n" );

      // Faire en sorte que le serveur accepte une connexion.
      connexion = serveur.accept();

      zoneAffichage.append( "Connexion " + compteur + " reçue de : " +
         connexion.getInetAddress().getHostName() );
   }

   // Obtenir les flux d'envoi et de réception de données.
   private void obtenirLesFlux() throws IOException {
      // Mettre en place le flux de sortie pour les objets.
      sortie = new ObjectOutputStream(connexion.getOutputStream() );
      // Vidanger le tampon de sortie pour envoyer les informations d'en-tête.
      sortie.flush();
      // Mettre en place le flux d'entrée pour les objets.
      entree = new ObjectInputStream(connexion.getInputStream() );
      zoneAffichage.append( "\nJ'ai reçu les flux d'E/S\n" );
   }

   // Traiter la connexion avec le client.
   private void traiterConnexion() throws IOException {
      // Envoyer le message de succès de connexion au client.
      String message = "SERVEUR>>> Connexion réussie.";
      sortie.writeObject( message );
      sortie.flush();
      // Activer champEntree pour l'utilisateur du serveur envoie des messages.
      champEntree.setEnabled( true );
      // Traiter les messages envoyés par le client.
      do {
         // Lire le message et l'afficher.
         try {
            message = ( String ) entree.readObject();
            zoneAffichage.append( "\n" + message );
            zoneAffichage.setCaretPosition(
               zoneAffichage.getText().length() );
         }
         // Capturer les problèmes de lecture du message du client.
         catch ( ClassNotFoundException classNotFoundException ) {
            zoneAffichage.append( "\nObjet reçu de type inconnu" );
         }
      } while ( !message.equals( "CLIENT>>> TERMINER" ) );
   }

   // Clore les flux et le socket.
   private void fermerConnexion() throws IOException {
      zoneAffichage.append( "\nL'utilisateur a fermé la connexion." );
      champEntree.setEnabled( false );
      sortie.close();
      entree.close();
      connexion.close();
   }

   // Envoyer message au client.
   private void envoyerDonnees( String message ) {
      // Envoyer un objet au client.
      try {
         sortie.writeObject( "SERVEUR>>> " + message );
         sortie.flush();
         zoneAffichage.append( "\nSERVEUR>>> " + message );
      }

      // Traiter les problèmes à l'envoi d'objet.
      catch ( IOException ioException ) {
         zoneAffichage.append( "\nErreur à l'écriture d'un objet" );
      }
   }

   // Exécuter l'application.
   public static void main( String args[] ) {
      Serveur application = new Serveur();

      application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );
      application.lancerServeur();
   }

}


/******************************************************************************
 * (C) Copyright 2002 par Deitel & Associates, Inc. et Prentice Hall          *
 * Tous droits réservés.                                                      *
 *                                                                            *
 * RENONCIATION: Les auteurs et l'éditeur de cet ouvrage ont fait tous        *
 * les efforts pour préparer ce livre et les programmes qu'il contient,       *
 * y compris dans l'élaboration, la recherche et les contrôles sur l'effica-  *
 * cité des théories et programmes. Les auteurs et l'éditeur n'offrent        *
 * aucune garantie de quelque ordre que ce soit, expresse ou implicite,       *
 * pour ce qui concerne ces programmes ni la documentation présentés          *
 * dans ce livre. L'auteur et l'éditeur ne pourront être tenus pour           *
 * responsables de tout dommage accessoire ou indirect, lié à ou causé        *
 * par la fourniture, la performance ou l'utilisation de ces programmes.      *
 *****************************************************************************/