带线程池的小服务器-Java实现

前两天，利用线程池技术（ThreadPool）写了个web服务器，其性能当然无法和apache iis等相比，但基本的功能都有了，唯一欠缺的是无法解析动态页面，采用解释执行（asp模式的）效率太低，如果采用编译执行，要么自己编写一个编译器来编译整个动态页面，要么采用预编译，很复杂。。。。

现在把代码拿出来晒一晒！由于只是初步的设计所以没有考虑到很多设计模式，代码在优化上很不到位，请各位高手不吝赐教。

MainServer.java 这是主服务文件，也是提供主线程的类，主线程将请求分发给其他业务线程（workerthread）出来

package com.threadpool;

import java.net.ServerSocket;

public class MainServer
{
 
 public static int clientCount = 0;
 
 //ThreadPool threadPool = null;
 int port;
 PoolManager poolm;
 public MainServer(int port)
 {
  poolm=PoolManager.getInstance();
  poolm.creatThreadPool(100, ActionWorker.class);
  this.port = port;
 }
 public void start() throws Exception
 {
  ServerSocket ss = new ServerSocket(port);
  System.out.println("MainServer is starting.....");
  
  while(true)
  {
   clientCount++;
   poolm.doService(ss.accept());
   System.out.println(clientCount+"connections");
  }
 }
 /**
  * @param args
  * @throws Exception
  */
 public static void main(String[] args) throws Exception
 {
  // TODO Auto-generated method stub
  MainServer server = new MainServer(80);
  server.start();
 }
 
}

PoolManager.java 线程池管理器，该类负责管理线程池，如创建新线程，回收线程等等。
package com.threadpool;

import java.net.Socket;

import Pool.ThreadWorker;

public class PoolManager
{
 //singleton pattern
 private static PoolManager instance = null;
 ThreadPool threadPool = null;
 private PoolManager()
 {
  
 }
 
 public synchronized static PoolManager getInstance()
 {
  if(instance == null)
   instance = new PoolManager();
  
  return instance;
 }
 
 //create thread pool
 public void creatThreadPool(int max, Class<ActionWorker> worker)
 {
  
  try
  {
   threadPool = new ThreadPool(max, worker);
   System.out.println("create a threadpool...");
  }
  catch (Exception e)
  {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 private WorkerThread getWorker() throws Exception
 {  
    return threadPool.getWorker();  
 }
 
 public void doService(Object o)
 {  
  try
  {
   getWorker().wake((Socket)o);
   System.out.println(Thread.currentThread().getName());
  }
  catch (Exception e)
  {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }  
 }
}

WorkerThread.java 业务线程类，负责处理具体的请求。

package com.threadpool;

import java.net.Socket;

public class WorkerThread extends Thread
{
 
  private IWorker worker;
  private Socket data;
  private ThreadPool pool;
  WorkerThread(String id, IWorker worker, ThreadPool pool)
  {
   super(id);
   this.worker = worker;
   this.pool = pool;
   this.data = null;
  }
  
  public synchronized void wake(Socket data)
  {
   this.data = data;
   System.out.println("wake up..." + Thread.currentThread().getName());
   notify();
  }
  
  public synchronized void run()
  {
   //boolean stop = false;
   System.out.println("run....");
   while(true)
   {
    if(data == null)
    {
     try
     {
      wait();
      System.out.println(Thread.currentThread().getName()+"wait...");
     }
     catch (InterruptedException e)
     {
      // TODO Auto-generated catch block
      e.printStackTrace();
      continue;
     }
    }
    
    System.out.println(this.getName()+"are working"+Thread.currentThread().getName());
    worker.run(data);
    data = null;
    if(!pool.pushBack(this))
     break;
  }
  
 }
}

IWorker.java为业务逻辑接口

package com.threadpool;

public interface IWorker
{
 public void run(Object data);
}

ActionWorker.java真正干活的那个类，称为业务逻辑类，与j2ee中的javaBean对应。

package com.threadpool;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class ActionWorker implements IWorker
{
 
 public void run(Object data)
 {
  handleRequest((Socket)data);
  
 }
 
 private void handleRequest(Socket s)
 {
  try
  {
   InputStream is = s.getInputStream();
   OutputStream os = s.getOutputStream();
   Request request = new Request(is);
   request.parse();
//   // create Response object
   Response response = new Response(os);
      response.setRequest(request);
      response.sendStaticResource();
   System.out.println("worker is working..");
   MainServer.clientCount--;
   //执行完毕后关闭socket,释放线程
   s.close();
  }
  catch(IOException ex)
  {
   ex.printStackTrace();
  }
  
 }
}

Requset.java封装请求的类，主要用于提取被请求的文件

package com.threadpool;

import java.io.IOException;
import java.io.InputStream;

public class Request
{
 private InputStream input;
 private String uri;

   public Request(InputStream input)
   {
     this.input = input;
   }
   //从请求中解析出文件名
 public void parse()
 {
  StringBuffer request = new StringBuffer(2048);
     int len;
     byte[] buffer = new byte[2048];
     try
     {
       len = input.read(buffer);
     }
     catch (IOException e)
     {
       e.printStackTrace();
       len = -1;
     }
     for (int i=0; i<len; i++)
     {
       request.append((char) buffer[i]);
     }
     System.out.print(request.toString());
     uri = parseUri(request.toString());
   }
 //截取请求的文件名
   private String parseUri(String requestString)
   {
     int index1, index2;
     index1 = requestString.indexOf(' ');
     if (index1 != -1)
     {
       index2 = requestString.indexOf(' ', index1 + 1);
       if (index2 > index1)
         return requestString.substring(index1 + 1, index2);
     }
     return null;
   }

   public String getUri()
   {
     return uri;
   }
}

Response.java 封装相应流的类

package com.threadpool;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Response
{
 private static final int BUFFER_SIZE = 1024;
   public Request request;
   public OutputStream output;

   public Response(OutputStream output)
   {
     this.output = output;
   }

   public void setRequest(Request request)
   {
     this.request = request;
   }

   public void sendStaticResource() throws IOException
   {
     byte[] bytes = new byte[BUFFER_SIZE];
     FileInputStream fis = null;
     try
     {
        File file = new File(System.getProperty("user.dir")+File.separator+"webroot", request.getUri());
        if (file.exists())
        {
          fis = new FileInputStream(file);
          int ch = fis.read(bytes, 0, BUFFER_SIZE);
          while (ch!=-1)
          {
             output.write(bytes, 0, ch);
             ch = fis.read(bytes, 0, BUFFER_SIZE);
          }
        }
        else
        {
          // file not found
          String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
            "Content-Type: text/html\r\n" +
            "Content-Length: 23\r\n" +
            "\r\n" +
            "<h1>File Not Found</h1>";
          output.write(errorMessage.getBytes());
        }
     }
     catch (Exception e)
     {
        // thrown if cannot instantiate a File object
        System.out.println(e.toString() );
     }
     finally
     {
        if (fis!=null)
         fis.close();
     }
   }
}

在class文件夹下建立 webroot文件夹作为网站的根目录，把网页文件放在下面就可以通过 http://localhost/yourfilename 访问了，简单的服务器就写出来了，由于使用了池技术所以其原理更接近于真正的webserver.

 

ps: apache服务器是用纯c编写的，其实现的复杂程度的确让人难以想象。