浅谈web服务器项目中静态请求和动态请求处理

 //判断当前请求的否是静态资源
 public boolean isStaticResource(){
  return true;
 }
 //判断当前请求的否是动态资源
 public boolean isDynamicResource(){
  return true;
 }

// 判断当前请求的否是静态资源
 public boolean isStaticResource() {
  // 存在？？文件？？静态？？
  System.out.println("进入isStaticResource()方法");  
  if (requestPath != null) {
   String parent = ConfigUtils.getConfigValue("rootPath");
   File file = new File(parent, requestPath);
   return file.exists() && file.isFile();
  }
  return false;
 }

 // 判断当前请求的否是动态资源
 public boolean isDynamicResource() {
  // 存在？？文件？？动态？？
  System.out.println("进入isDynamicResource()方法");
  String path = ServletMappingUtils.getMappingValue(requestPath);
  /*
   * //使用路径判断，当时我不知道还有一个叫做isContains(key)的方法，如果知道的话 就可以使用了，请参见测试类
   * if(isContainers(requestPath())) { return *; }
   */
  System.out.println("ServletMapping中根据requestPath获取的映射：" + path);
  if (path != null) {
   return true;
  }
  return false;
 }

package com.sample.utils;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ServletMappingUtils {
	private static Properties p;
	static 
	{
		InputStream in=null;
		p=new Properties();
		try {
			//读了xx.properties文件
			in=ServletMappingUtils.class.getResourceAsStream("servlet_mapping.properties");
			//放置到p中，即放properties文件中的key,value
			p.load(in);
		} catch (IOException e) {
			e.printStackTrace();
		}
		finally
		{
			if(in!=null)
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
	}
	public static String getMappingValue(String mapping)
	{ 
		return p.getProperty(mapping);
	}
	public static boolean isContainsKey(String key) {
   return p.containsKey(key);
	}
	public static void main(String[] args) {//输出测试
	//	Properties p=new Properties();
	//	p.setProperty("rootPath","ddd");
	//	System.out.println(p.get("rootPath"));
		System.out.println(getMappingValue("/HelloWorld"));
		System.out.println(isContainsKey("/Login"));
	}
}

package com.sample.http;
//Http资源处理器
//负责处理http协议的资源请求
public interface HttpAccessProcessor {	
	//处理静态资源 页面/文件/图片等等
	public void processStaticResource(HttpRequest request,HttpResponse response);	
	//处理动态资源 java代码 浏览器通过路径发送请求可以访问调用java代码
	public void processDynamicResource(HttpRequest request,HttpResponse response);	
	//向浏览器返回错误信息及其页面
	public void sendError(int statusCode,HttpRequest request,HttpResponse response);	
}

package com.sample.http;
import com.sample.utils.ServletMappingUtils;
//Http资源处理器
//负责处理http协议的资源请求
public class HttpAccessProcessorImpl implements HttpAccessProcessor {
	//处理静态资源 页面/文件/图片等等
	public void processStaticResource(HttpRequest request,HttpResponse response)
	{
		System.out.println("进入方法processStaticResource(HttpRequest request,HttpResponse response)");
		//获取请求中资源，并处理
    String path=request.getRequestPath();
    String[] str=path.split("[.]");
    String contentType=str[str.length-1];
    System.out.println("路径的后缀："+contentType);
		response.setStatusLine(200);
		response.setContentType(MIMEUtils.getMimeValue(contentType));
		response.setCRLF();
		response.printResponseHeader();
		response.printResponseContent(request.getRequestPath());
	}
	//处理动态资源 java代码 浏览器通过路径发送请求可以访问调用java代码
	public void processDynamicResource(HttpRequest request,HttpResponse response)
	{
		System.out.println("进入processDynamicResource");
		response.setStatusLine(200);
		response.setContentType("text/HTML");
		response.setCRLF();
		response.printResponseHeader();
    Class className=null;
		try {
			String path=ServletMappingUtils.getMappingValue(request.getRequestPath());
			System.out.println("使用反射获取的servlet路径："+path);
			className = (Class.forName(path));
			//ServletImpl servlet= (ServletImpl) className.newInstance();
			Servlet servlet = (Servlet) className.newInstance();
			System.out.println(servlet);
			servlet.service(request, response);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}	
	//向浏览器返回错误信息及其页面
	public void sendError(int statusCode,HttpRequest request,HttpResponse response)
	{
		 System.out.println("进入sendError()");
			//获取请求中资源，并处理
			//response.setStatusLine("OK");
			response.setStatusLine(statusCode);
			//response.setStatusLine("OK");
			response.setContentType("text/html");
			response.setCRLF();
			response.printResponseHeader();
			//response.printResponseContent("/error/404.html");
			response.printResponseContent(ErrorPageUtils.getErrorPage(statusCode+""));
		 
	}
	
}

package com.sample.servlet;
import com.sample.http.HttpRequest;
import com.sample.http.HttpResponse;
//只有实现这个接口的类,才可以被浏览器发送请求访问到
public interface Servlet {
	//被浏览器发请求访问到的对象会调用这个指定方法service,进行处理这次浏览器的请求
	public void service(HttpRequest request,HttpResponse response);
}

package com.sample.servlet;
import java.io.PrintWriter;
import com.sample.http.HttpRequest;
import com.sample.http.HttpResponse;
//只有实现这个接口的类,才可以被浏览器发送请求访问到
public class HelloWorldServlet implements Servlet{
	//被浏览器发请求访问到的对象会调用这个指定方法service,进行处理这次浏览器的请求
	public void service(HttpRequest request,HttpResponse response)
	{
		String name=request.getParameter("name");
		System.out.println(name);
		try {
			PrintWriter pw=response.getPrintWriter();
			pw.println("<html>");
			pw.println("<body>");
			pw.println("<center>"+name+":这是我的Servlet</center>");
			pw.println("</body>");
			pw.println("</html>");
			pw.flush();
			pw.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package com.sample.http;
 
//负责创建http协议访问过程中使用到的对象
public interface HttpCreator {
	//返回创建好的request对象
	public HttpRequest getHttpRequest();
	
	//返回创建好的response对象
	public HttpResponse getHttpResponse();
	
	//返回创建好的HttpAccessProcessor对象
	public HttpAccessProcessor getHttpAccessProcessor();
}

package com.sample.http;
import java.net.Socket;
//负责创建http协议访问过程中使用到的对象
public class HttpCreatorImpl implements HttpCreator{
	private Socket s;
	HttpRequestImpl request;
	HttpResponseImpl response;
	HttpAccessProcessorImpl hapi;
	public HttpCreatorImpl(Socket s) {
			this.s=s;
	}
	//返回创建好的request对象
	public HttpRequest getHttpRequest()
	{
   return request=new HttpRequestImpl(s);
	}	
	//返回创建好的response对象
	public HttpResponse getHttpResponse()
	{
		 return response=new HttpResponseImpl(s);
	}	
	//返回创建好的HttpAccessProcessor对象
	public HttpAccessProcessor getHttpAccessProcessor()
	{
		 return hapi=new HttpAccessProcessorImpl();
	}
}

package com.sample.http;
<pre name="code" class="java">import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
	public static void main(String[] args) {
		//声明变量
    ServerSocket ss=null;
    Socket s=null;
    boolean flag=true;
    try {
    	int port=10002;
    	System.out.println("Server Port:"+port);
					ss=new ServerSocket(port);
					//while(flag)
					{
						//接受客户端发送过来的Socket
						s=ss.accept();
						HttpCreatorImpl hci=new HttpCreatorImpl(s);
						HttpRequest request=hci.getHttpRequest();
						HttpResponse response=hci.getHttpResponse();
						HttpAccessProcessor hapi=hci.getHttpAccessProcessor();
						//	用于测试收到的信息
						if(request.isStaticResource())//处理静态信息
						{
							hapi.processStaticResource(request, response);
						}
						else if(request.isDynamicResource())//处理动态请求
						{
							hapi.processDynamicResource(request, response);
						}
						else//无法处理时
						{
							System.out.println("无法处理");
							hapi.sendError(404, request, response);
						}
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
	}
}