httpserver.java

短信开发用于文件交换处理转发的类模块

package com.pub.servlet;

import java.net.Socket;
import java.net.ServerSocket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.apache.log4j.Logger;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;

//import com.pub.thread.ThreadPool;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class HttpServer
    implements Runnable {

  private boolean shutdown = false;
  private ServerSocket serverSocket = null;

  private static Logger logger = Logger.getLogger(HttpServer.class);
  private int port = 60606;
  public int SEND_BUFFER_SIZE = 4096;
  public int RECEIVER_BUFFER_SIZE = 4096;

  private HashMap classMap = null;
  private HashMap aliasMap = null;

  ThreadPoolExecutor threadpool = null;
//  public ThreadPool threadpool = null;

  public HttpServer() {
      aliasMap = new HashMap();
  }

  public HttpServer(int port, int sendbuffersize,
                    int receiverbuffersize) {
    this.port = port;
    SEND_BUFFER_SIZE = sendbuffersize;
    RECEIVER_BUFFER_SIZE = receiverbuffersize;
    aliasMap = new HashMap();
  }

  public HttpServer(int port, int sendbuffersize, int receiverbuffersize,
                    int minSize, int maxSize, long releaseDelay) {
    this.port = port;
    SEND_BUFFER_SIZE = sendbuffersize;
    RECEIVER_BUFFER_SIZE = receiverbuffersize;
//    threadpool = new ThreadPool(minSize, maxSize, releaseDelay);
    /**
     * 线程池维护线程的最少数量
     * 线程池维护线程的最大数量
     * 线程池维护线程所允许的空闲时间
     * 线程池维护线程所允许的空闲时间的单位
     * 线程池所使用的缓冲队列
     * 线程池对拒绝任务的处理策略
     *   ThreadPoolExecutor.AbortPolicy()
     *   抛出java.util.concurrent.RejectedExecutionException异常
     *   ThreadPoolExecutor.CallerRunsPolicy()
     *   重试添加当前的任务，他会自动重复调用execute()方法
     *   ThreadPoolExecutor.DiscardOldestPolicy()
     *   抛弃旧的任务
     *   ThreadPoolExecutor.DiscardPolicy()
     *   抛弃当前的任务
         */
    threadpool = new ThreadPoolExecutor(minSize, maxSize,
                                    releaseDelay, TimeUnit.SECONDS,
                                    new ArrayBlockingQueue(3),
                                        new ThreadPoolExecutor.DiscardOldestPolicy());
    aliasMap = new HashMap();
  }
  public void setAlias(String alias,String classname)
  {
      aliasMap.put(alias,classname);
  }
  public String toString() {
    StringBuffer sb = new StringBuffer();

    sb.append("ServiceFlag : ").append(!shutdown).append("\n").
        append("SEND_BUFFER_SIZE : ").append(SEND_BUFFER_SIZE).append("\n").
        append("RECEIVER_BUFFER_SIZE : ").append(RECEIVER_BUFFER_SIZE).append(
        "\n");
    if (threadpool != null) {
      sb.append(threadpool.toString());
    }
    return sb.toString();
  }

  public void run() {

    try {
      classMap = new HashMap();
      serverSocket = new ServerSocket(port);
    }
    catch (Exception e) {
      logger.error("can not listen " + port + ": " + e);
      return;
    }

    logger.info("The http server is ready. " + port);
    System.out.println("The http server is ready. " + port);

    // Loop waiting for a request
    while (!shutdown) {
      try {
        if (threadpool != null) {
          threadpool.execute(new ServletThread(serverSocket.accept()));
        }
        else {
          Thread t = new Thread(new ServletThread(serverSocket.accept()));
          t.start();
        }
      }
      catch (Throwable t) {
        logger.error("",t);
      }
    }
    if(shutdown){
        try {
            if (threadpool != null) {
                threadpool.shutdown();
            }
        } catch (Exception ex) {
        }
    }
  }

  public void stop() {
    shutdown = true;
    try {
      serverSocket.close();
    }
    catch (Exception e) {}
  }

  class ServletThread
      implements Runnable { //extends Thread {
    private Socket socket = null;

    protected ServletThread(Socket socket) {
      this.socket = socket;
    }

    public void run() {
      InputStream input = null;
      OutputStream output = null;
      try {
        input = socket.getInputStream();
        output = socket.getOutputStream();

        // create Request object and parse
        HttpRequest request = new HttpRequest(input);
        request.RECEIVER_BUFFER_SIZE = RECEIVER_BUFFER_SIZE;
        request.streamHandler();
        // create Response object
        HttpResponse response = new HttpResponse(output, request);
        response.SEND_BUFFER_SIZE = RECEIVER_BUFFER_SIZE;
//        com.ray.sms.platform.gatewayservlet.command.GatewayConfig gc = null;
        try {
          if (request.getUrl().equalsIgnoreCase("ClearClass")) {
            if (classMap.remove(request.getParameter("class")) != null) {
              response.sendResponse("clear class : " +
                                    request.getParameter("class"));
            }
            else {
              response.sendResponse("class is null : " +
                                    request.getParameter("class"));
            }
            return;
          }
          if(request.getUrl().equals("/")){
            response.sendError(200, "");
            return ;
          }
          /**
           * mahy
           * support alias
           */
          String url=request.getUrl();
          if(!aliasMap.isEmpty())
          {
              String temp = (String)aliasMap.get(url);
              if(temp!=null)
                  url = temp;
          }
//          Class clazz = Class.forName(request.getUrl());
          Class clazz = Class.forName(url);
          HttpServlet bean = (HttpServlet) clazz.newInstance();
          if (!classMap.containsKey(request.getUrl())) {
            bean.init();
            classMap.put(request.getUrl(), "");
          }

          if (request.getMethod().equalsIgnoreCase("GET")) {
            java.lang.reflect.Method m = clazz.getMethod("doGet",
                new Class[] {HttpServletRequest.class,
                HttpServletResponse.class});
            m.invoke(bean,
                     new Object[] { (HttpServletRequest) request,
                     (HttpServletResponse) response});
          }
          else if (request.getMethod().equalsIgnoreCase("POST")) {
            java.lang.reflect.Method m = clazz.getMethod("doPost",
                new Class[] {HttpServletRequest.class,
                HttpServletResponse.class});
            m.invoke(bean,
                     new Object[] { (HttpServletRequest) request,
                     (HttpServletResponse) response});
          }
          else {
            bean.service( (ServletRequest) request,
                         (ServletResponse) response);
          }
        }
        catch (ClassNotFoundException ex) {
          response.sendError(404, ex.getMessage());
          logger.error(null, ex);
        }
        catch (Throwable ex) {
          response.sendError(500, ex.getMessage());
          logger.error(null, ex);
        }
      }
      catch (Throwable t) {
        logger.error(null, t);
      }
      finally {
        try {
          socket.close();
        }
        catch (IOException e1) {}
      }
    }
  }
}