frontcontroller.java

这是我自己开发的一个MVC框架

package dark.web.frame.controller;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import dark.web.frame.Message;
import dark.web.frame.command.AbstractCommand;
import dark.web.frame.command.UnknownCommand;
import dark.web.frame.form.AbstractForm;
import dark.web.frame.form.UnknownForm;
import dark.web.frame.page.AbstractPage;
import dark.web.frame.page.UnknownPage;

/**
 * <p>Title:            </p>
 * <p>Description:      </p>
 * <p>Copyright:        Copyright (c) 2004</p>
 * <p>Company:          DIS</p>
 * <p>Create Time:      2005-2-28 16:24:03</p>
 * @author             <a href="mailto:[e-mail]">darkhe</a>
 * @version            1.0
 */
public class FrontController extends AbstractController
{	
	/**
	 * 	
	 * @param request
	 * @param response
	 * @throws ServletException
	 * @throws IOException
	 * @see dark.web.frame.controller.AbstractController#doRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, dark.web.frame.Message)
	 */
	public void doRequest(
		HttpServletRequest request,
		HttpServletResponse response)
		throws ServletException, IOException
	{
		// 如果要求做表单验证，则处理之
		if (isValidate(request))
		{

			String input = getInput(request);

			// 如果用户没有指定请求转发路径，则指定default value
			if (input.equals(""))
			{
				input = configuration.getString("default.input");

				log.warn(
					"dont't specify parameter $INPUT, use default.input:"
						+ input);
				request.setAttribute(
					"$WARM",
					"dont't specify parameter $INPUT, use default.input"
						+ input);
			}

			AbstractForm form = getForm(request);

			// 初始化表单验证类
			form.init(getServletContext(), request, response, getMessage());

			// 设置当前表单验证的用户请求转发路径
			form.setInput(input);

			// 检证表单验证类的执行权限
			if (form.isAuthentic())
			{
				// 执行真实的验证逻辑
				Message msg = form.validate();

				if (msg == null)
				{
					// 如果msg为null，则说明form类没有返回Message实例
					input = configuration.getString("default.input");
					form.setInput(input);

					log.warn("valideate() don't return Message instance");
					request.setAttribute(
						"$WARM",
						"valideate() don't return Message instance");

					form.forward();
					return;
				}

				if (!msg.isEmpty())
				{
					// 如果msg不为空，则说明验证出表单错误，									
					form.forward();
					return;
				}
			}
		}

		String target = getTarget(request);

		// 如果用户没有指定请求转发路径，则指定default value
		if (target.equals(""))
		{
			target = configuration.getString("default.target");

			log.warn(
				"don't specify paramter $TARGER, use default.target:" + target);
			request.setAttribute(
				"$WARM",
				"don't specify paramter $TARGER, use default.target:" + target);
		}

		AbstractCommand command = getCommand(request);

		// 初始化命令类
		command.init(
			getServletContext(),
			getServletConfig(),
			request,
			response);

		// 设置当前命令的用户请求转发路径
		command.setTarget(target);

		// 检证命令类的执行权限
		if (command.isAuthentic())
		{
			// 执行真实的商业逻辑
			command.process();
		}

		// 转发请求到用户指定路径
		command.forward();
	}

	/**
	 * @param request
	 * @return
	 */
	protected boolean isValidate(HttpServletRequest request)
	{
		boolean isValidate = false;

		String validate = request.getParameter("$VALIDATE");
		if (validate == null || validate.length() == 0)
		{
			isValidate = false;
		}
		else if (
			validate.length() > 0 && validate.toLowerCase().equals("true"))
		{
			isValidate = true;
		}
		else
		{
			isValidate = false;
		}

		return isValidate;
	}

	/**
	 * @param request
	 * @return
	 */
	protected AbstractForm getForm(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractForm) getFormClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * @param request
	 */
	protected Class getFormClass(HttpServletRequest request)
	{
		Class result = null;

		String cp = configuration.getString("form.package");
		String formClassName = cp + "." + request.getParameter("$FORM");

		try
		{
			result = Class.forName(formClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.error(
				"class:"
					+ formClassName
					+ " not found, return UnKnownForm.class");
			result = UnknownForm.class;
		}

		return result;
	}

	/**
	 * @param request
	 * @return
	 */
	protected String getInput(HttpServletRequest request)
	{
		String input = request.getParameter("$INPUT");
		if (input == null || input.length() == 0)
		{
			return "";
		}
		else
		{
			return input;
		}
	}

	/**
	 * 得到用户指定的请求转发路径
	 * @param request
	 * @return 
	 */
	protected String getTarget(HttpServletRequest request)
	{
		String target = request.getParameter("$TARGET");
		if (target == null || target.length() == 0)
		{
			return "";
		}
		else
		{
			return target;
		}

	}

	/**
	 * 根据用户请求中的Command参数所设置的处理程序全类名得到请求处理程序实例
	 * @param req
	 * @return
	 */
	protected AbstractCommand getCommand(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractCommand) getCommandClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * 通过类名串值到得类对象
	 * @param req
	 */
	protected Class getCommandClass(HttpServletRequest request)
	{
		Class result = null;

		String cp = configuration.getString("command.package");
		String commandClassName = cp + "." + request.getParameter("$COMMAND");

		try
		{
			result = Class.forName(commandClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.error(
				"class:"
					+ commandClassName
					+ " not found, return UnknownCommand.class");
			result = UnknownCommand.class;
		}

		return result;
	}

	/**
	 * 得到当前请求的后缀
	 * @param request
	 * @return
	 */
	public static String getRequestPostfix(HttpServletRequest request)
	{
		String uri = request.getRequestURI();
		int index = uri.lastIndexOf('.');
		String postfix = uri.substring(index);
		return postfix;
	}

	/**
	 * 根据用户请求中的URI得到页面处理程序实例
	 * @param req
	 * @return
	 */
	protected AbstractPage getPage(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractPage) getPageClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * 通过类名串值到得类对象
	 * @param req
	 */
	protected Class getPageClass(HttpServletRequest request)
	{
		Class result = null;
	
		String cp = configuration.getString("page.package");
	
		String pageName = getPageName(request);
		String pageClassName = cp + "." + pageName;
	
		try
		{
			result = Class.forName(pageClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.info(
				"class:"
					+ pageClassName
					+ " not found, return UnknownPage.class");
			result = UnknownPage.class;
		}
	
		return result;
	}

	/**
	 * @param request
	 * @return
	 */
	protected String getPageName(HttpServletRequest request)
	{
		String uri = request.getRequestURI();
		if (uri == null || uri.length() == 0)
		{
			return null;
		}

		if (uri.startsWith("/") && uri.length() > 1)
		{
			uri = uri.substring(1, uri.length());
		}

		// 得到在配置文件中指定的需要执行页面处理程序的页面的后缀名
		String postfix = configuration.getString("page.postfix");

		if (uri.endsWith(postfix) && uri.length() > postfix.length())
		{
			uri = uri.substring(0, uri.length() - postfix.length());
		}

		// 将/替换成.，以完成请求路径到包路径的转换
		uri = uri.replaceAll("/", ".");

		return uri;
	}
}