HTTPService.java

package fr.umlv.ji.tcp.server.http;
import fr.umlv.ji.tcp.server.*;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.*;
import java.util.logging.*;
import java.util.prefs.Preferences;

public class HTTPService implements Service {
  protected int timeout;
  protected Server server;
  protected MIMEHelper mimeHelper;
  private static final Class[] ARGS_TYPES =
    new Class[] {Request.class, Response.class};
  /** Initialisation du service. */
  public HTTPService(Server s) throws IOException {
    server = s;
    timeout = s.getPreferences().getInt("socketTimeout", 10000);
    mimeHelper = new MIMEHelper(s);
  }
  /** Méthode gestion de requête. */
  public void serve(Socket socket) {
    try {
      // Affecte l'attente maximale de la socket.
      socket.setSoTimeout(timeout);
      // Construction de l'objet requête
      Request request = new Request(socket.getInputStream(), this);
      // Construction de l'objet réponse
      Response response = new Response(socket.getOutputStream());
      do {
    // Lecture des en-têtes
    request.readHeaders();
    // Lecture du contenu de la requête (POST)
    if (request.getContentLength() > 0)
      request.readContent();
    // Traitement de la requête
    treat(request, response);
    // Emission de la réponse
    response.send();
      } while(!response.isClosed());
    } catch (IOException ioe) {
    } catch (URISyntaxException e) {
      server.getLogger().log(Level.WARNING,
                 Thread.currentThread().toString(), e);
    } finally {
      if (socket != null) {
    try {socket.close();} catch (IOException e) { }
      }
    }
  }
  /** Méthode de traitement de la requête. */
  private void treat(Request request, Response response)
    throws IOException {
    response.reset(); // Réinitialiser la réponse (keep-alive)
    String s = request.getMethod();
    if (s.matches("(POST)|(GET)|(HEAD)")) {
      // Récupération du gestionnaire pour la requête
      URIHandler handler = getURIHandler(request);
      // Appel, par introspection, de la méthode du gestionnaire
      // correspondant à la méthode HTTP. 
      // GET -> get(), POST -> post() et HEAD -> head()
      try {
    Method method =
      handler.getClass().getMethod(s.toLowerCase(), ARGS_TYPES);
    method.invoke(handler, new Object[] {request, response});
    if (!request.isKeepAlive()) response.close();
      } catch (Exception exception) {
    response.setError(Response.BAD_REQUEST);
      }
    } else {
      // Le serveur ne traite que les méthodes HEAD, GET et POST
      response.setError(Response.BAD_REQUEST);
    }
  }
  /** Méthode de récupération du gestionnaire de requête.
      Par défaut le serveur retourne des documents statiques.
      Méthode à redéfinir afin de modifier le comportement du
      serveur. */
  protected URIHandler getURIHandler(Request request)
    throws IOException {
    return new FileURIHandler(this);
  }
  public Logger getLogger() {
    return server.getLogger();
  }
  public Preferences getPreferences() {
    return server.getPreferences();
  }
  public MIMEHelper getMIMEHelper() {
    return mimeHelper;
  }
}