org.voovan.http.server.HttpDispatcher Maven / Gradle / Ivy

Go to download
package org.voovan.http.server;

import org.voovan.http.server.context.HttpFilterConfig;
import org.voovan.http.server.context.WebContext;
import org.voovan.http.server.context.WebServerConfig;
import org.voovan.http.server.exception.ResourceNotFound;
import org.voovan.http.server.exception.RouterNotFound;
import org.voovan.http.server.router.MimeFileRouter;
import org.voovan.tools.log.Logger;
import org.voovan.tools.*;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.net.URLDecoder;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;

/**
 *
 * 根据 Request 请求分派到处理路由
 *
 *
 * GET 请求获取Request-URI所标识的资源
 * POST 在Request-URI所标识的资源后附加新的数据
 * HEAD 请求获取由Request-URI所标识的资源的响应消息报头
 * PUT 请求服务器存储一个资源，并用Request-URI作为其标识
 * DELETE 请求服务器删除Request-URI所标识的资源
 * TRACE 请求服务器回送收到的请求信息，主要用于测试或诊断
 * CONNECT 保留将来使用
 * OPTIONS 请求查询服务器的性能，或者查询与资源相关的选项和需求
 *
 * @author helyho
 *
 * Voovan Framework.
 * WebSite: https://github.com/helyho/Voovan
 * Licence: Apache v2 License
 */
public class HttpDispatcher {

	private static Map REGEXED_ROUTER_CACHE = new ConcurrentHashMap();
	private static Map> ROUTER_INFO_CACHE = new ConcurrentHashMap>();

	/**
	 * [MainKey] = HTTP method ,[Value] = { [Value Key] = Route path, [Value value] = RouteBuiz对象 }
	 */
	private Map> methodRouters;
	private WebServerConfig webConfig;
	private SessionManager sessionManager;
	private MimeFileRouter mimeFileRouter;
	private String[] indexFiles;

	/**
	 * 构造函数
	 *
	 * @param webConfig    Web 服务配置对象
	 * @param sessionManager Session 管理器
	 */
	public HttpDispatcher(WebServerConfig webConfig, SessionManager sessionManager) {

		//清理缓存的路由正则
		REGEXED_ROUTER_CACHE.clear();
		ROUTER_INFO_CACHE.clear();

		methodRouters = new LinkedHashMap>();
		this.webConfig = webConfig;
		this.sessionManager = sessionManager;

		//拆分首页索引文件的名称
		indexFiles = webConfig.getIndexFiles();

		// 初始化所有的 HTTP 请求方法
		this.addRouteMethod("GET");
		this.addRouteMethod("POST");
		this.addRouteMethod("HEAD");
		this.addRouteMethod("PUT");
		this.addRouteMethod("DELETE");
		this.addRouteMethod("TRACE");
		this.addRouteMethod("CONNECT");
		this.addRouteMethod("OPTIONS");

		// Mime静态文件默认请求处理
		mimeFileRouter = new MimeFileRouter(webConfig.getContextPath());
	}

	/**
	 * 获取 Http 的路由配置
	 * @return 路由配置信息
	 */
	public Map> getRoutes(){
		return methodRouters;
	}

	/**
	 * 增加新的路由方法,例如:HTTP 方法 GET、POST 等等
	 *
	 * @param method HTTP 请求方法
	 */
	protected void addRouteMethod(String method) {
		if (!methodRouters.containsKey(method)) {
			Map routers = new TreeMap(new Comparator() {
				@Override
				public int compare(String o1, String o2) {
					if(o1.length() > o2.length() && !o1.equals(o2)){
						return -1;
					} else if(o1.length() < o2.length() &&!o1.equals(o2)){
						return 1;
					} else if(o1.equals(o2)){
						return 0;
					} else{
						return 1;
					}
				}
			});
			methodRouters.put(method, routers);
		}
	}


	/**
	 * 修复路由为规范的可注册的路由
	 * @param routePath  路由
	 * @return 规范的可注册的路由
	 */
	public static String fixRoutePath(String routePath){
		//对于结束符为"/"的路径,清理这个符号,以便更好完成的匹配
		if(routePath.endsWith("/")){
			routePath = TString.removePrefix(routePath);
		}

		//对于起始符不为"/"的路径,补充这个符号,以便更好完成的匹配
		if(!routePath.startsWith("/")){
			routePath = "/" + routePath;
		}

		//把连续的////替换成/
		return TString.fastReplaceAll(routePath, "\\/{2,9}", "/");
	}

	/**
	 * 增加一个路由规则
	 *
	 * @param method          Http 请求方法
	 * @param routeRegexPath  路径匹配正则
	 * @param router         请求处理句柄
	 */
	public void addRouteHandler(String method, String routeRegexPath, HttpRouter router) {
		if (methodRouters.keySet().contains(method)) {
			methodRouters.get(method).put(fixRoutePath(routeRegexPath), router);
		}
	}

	/**
	 * Http 请求响应处理函数,入口函数
	 *
	 * @param request    HTTP 请求
	 * @param response   HTTP 响应
	 */
	public void process(HttpRequest request, HttpResponse response){
		Chain filterConfigs = webConfig.getFilterConfigs().clone();

		Object filterResult = null;

		request.setSessionManager(sessionManager);

		//正向过滤器处理,请求有可能被 Redirect 所以过滤器执行放在开始
		filterResult = disposeFilter(filterConfigs,request,response);

		//如果 response 在过滤器中修改过,则不执行路由处理
		if(response.body().size()==0) {
			//调用处理路由函数
			disposeRoute(request, response);
		}

		//反向过滤器处理
		filterResult = disposeInvertedFilter(filterConfigs,request,response);

		//向 HttpResponse 中放置 Session 的 Cookie
		if(request.sessionExists()){
			HttpSession session = request.getSession();
			session.attach(request, response);
		}

		//输出访问日志
		WebContext.writeAccessLog(webConfig, request, response);
	}

	/**
	 * 判断当前的请求是否是静态文件
	 * @param request request 请求对象
	 * @return true: 存在静态文件, false: 不存在静态文件
	 */
	public boolean isStaticFile(HttpRequest request) {
		File staticFile = mimeFileRouter.getStaticFile(request);
		if(staticFile.exists() && staticFile.isFile()){
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 获取路由处理对象和注册路由
	 * @param request 请求对象
	 * @return 路由信息对象 { 路由标签, [ 匹配到的已注册路由, HttpRouter对象 ] }
	 */
	public List