httpserver.java

21天学通java的示例程序源代码

// HTTPServer.java

package com.wrox.httpserver;

import java.io.*;
import java.net.*;
import java.util.*;
import java.security.KeyStore;
import javax.net.*;
import javax.net.ssl.*;
import com.sun.net.ssl.*;   // remove if you're using JDK 1.4
import javax.security.cert.X509Certificate;

/**
 * The HTTPServer main application. It starts the server as a user
 * thread and presents a console to allow graceful shutdown.
 */

public class HTTPServer extends HTTPConstants implements Runnable {

  // Localized messages and the application itself
  private static HTTPLocalizedResources resources;






  // Check if we run with the right VM and read resources
  static {
    String vers = System.getProperty("java.version");
    if (vers.compareTo("1.3.0") < 0) {
      System.err.println(VMVERSION_ERROR);

      // Exit the VM
      System.exit(1);
    } 

    try {

      // Load locale-specific messages
      resources = new HTTPLocalizedResources("msg.httpserver");
    } catch (MissingResourceException mre) {
      System.err.println(RESOURCE_ERROR);
      System.exit(1);
    } 
  } 

  /**
   * Constructs an HTTPServer object, checks the parameters and constructs the
   * utility and configuration objects.
   */
  public HTTPServer(String[] args) {

    // Check if the correct application parameters have been provided, we
    // expect the name of the properties file
    if (args != null && args.length == 1) {
      try {
        HTTPConfig.initializeConfig(args[0]);
      } catch (ConfigFileException e) {

        // An error occurred while reading the information
        // A locale-specific error message is retrieved and displayed
        System.err.println(resources.getResourceString("ERROR_HTTP_CONFIG") 
                           + e.getMessage());
        exit(ABNORMAL_TERMINATION);
      } 
    } else {

      // Write usage information and terminate
      System.err
        .println(resources.getResourceString("ERROR_INVALID_ARGUMENT"));
      exit(ABNORMAL_TERMINATION);
    } 

    // Initialize MIME converter
    try {
      MimeConverter.initializeConverter(MIME_TYPES_FILES);
    } catch (ConfigFileException e) {

      // An error occurred while reading the mime types
      System.err.println(resources.getResourceString("ERROR_MIME_CONFIG") 
                         + e.getMessage());
      exit(ABNORMAL_TERMINATION);
    } 

    // The configuration has been read, now we can initialize the logger
    try {
      HTTPLog.initializeLogger(HTTPConfig.config.getLogfile());
    } catch (IOException e) {

      // An error occurred while reading the mime types
      System.err.println(resources.getResourceString("ERROR_OPEN_LOGFILE") 
                         + e.getMessage());
      exit(ABNORMAL_TERMINATION);
    } 
  }

  /**
   * Exits the VM with a success return code.
   */
  private void exit() {
    exit(NORMAL_TERMINATION);
  } 

  /**
   * Exits the VM with a specified exit code.
   */
  private void exit(int status) {
    System.exit(status);
  } 



  /**
   * Starts the application, creates the HTTPServer and starts it as a thread
   * and executes the server console.
   */
  public static void main(String[] args) {

    // Create an application instance
    HTTPServer theApp = new HTTPServer(args);

    // Start the server
    Thread server = new Thread(theApp);
    server.setDaemon(true);
    server.start();

    // Display console to allow the user to gracefully shut down the server
    BufferedReader br = 
      new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw = 
      new BufferedWriter(new OutputStreamWriter(System.out));

    while (true) {
      try {
        bw.write(resources.getResourceString("CONSOLE_PROMPT"));
        bw.flush();
        String input = br.readLine();

        if (input != null && input
                .compareToIgnoreCase(resources
                  .getResourceString("CONSOLE_QUIT_COMMAND")) == 0) {

          // The user requests to shut down the server
          theApp.shutdown();
          theApp.exit();
        } 
      } catch (Exception e) {

        // Shutdown when a console exception occurs
        theApp.shutdown();
        theApp.exit(ABNORMAL_TERMINATION);
      } 
    } 
  } 

  /**
   * Returns a server socket factory for either secure or non-secure
   * connections.
   */
  private ServerSocketFactory getServerSocketFactory(boolean secure) {
    if (secure) {
      SSLServerSocketFactory ssf = null;
      try {

        // Set up a key manager to do server authentication
        SSLContext ctx;
        KeyManagerFactory kmf;
        KeyStore ks;
        char[] passphrase = "secret".toCharArray();

        ctx = SSLContext.getInstance("TLS");
        kmf = KeyManagerFactory.getInstance("SunX509");
        ks = KeyStore.getInstance("JKS");

        ks.load(new FileInputStream("httpd.keystore"), passphrase);
        kmf.init(ks, passphrase);
        ctx.init(kmf.getKeyManagers(), null, null);

        ssf = ctx.getServerSocketFactory();
        return ssf;
      } catch (Exception e) {

        // Ignore the exception and return null
        return null;
      } 
    } else {
      return ServerSocketFactory.getDefault();
    }
  } 

  /**
   * Runs the server.
   */
  public void run() {
    ServerSocket server = null;

    try {

      // Get port to listen at for incoming requests
      int port = HTTPConfig.config.getPort();

      // Create socket and listen for incoming connections
      // Request a server socket factory that constructs secure sockets
      ServerSocketFactory ssf = getServerSocketFactory(true);

      if (HTTPConfig.config.getBindAddress() == null) {
        server = ssf.createServerSocket(port);
      } else {
        server = ssf.createServerSocket(port, DEFAULT_BACKLOG, 
                                        HTTPConfig.config.getBindAddress());
      }

      // Set an infinite timeout
      server.setSoTimeout(0);

      while (true) {
        Socket socket = server.accept();

        Thread request = new Thread(new HTTPRequest(socket));
        request.setDaemon(true);
        request.start();
      } 
    } catch (Exception e) {
      System.err.println(resources.getResourceString("ERROR_HTTP_SERVER") 
                         + e.getMessage());
      exit(ABNORMAL_TERMINATION);
    } 
    finally {
      try {
        if (server != null) {
          server.close();
        } 
      } catch (IOException e) {

        // Ignore this exception
      } 
    } 
  } 

  /**
   * Shuts down the server.
   */
  public void shutdown() {

    // Closes the log
    HTTPLog.logger.close();
  } 

  private static final int ABNORMAL_TERMINATION = 1;
  private static final int DEFAULT_BACKLOG = 50;

  // Class constants
  private static final String MIME_TYPES_FILES = "mime";
  private static final int NORMAL_TERMINATION = 0;
}