MVC架构探究及其源码实现(4)-前端控制器

最新推荐文章于 2021-08-08 19:11:12 发布
最新推荐文章于 2021-08-08 19:11:12 发布
阅读量688 收藏
点赞数
分类专栏： MVC架构探究及其源码实现

前端控制器是整个MVC框架中最为核心的一块，它主要用来拦截符合要求的外部请求，并把请求分发到不同的控制器去处理，根据控制器处理后的结果，生成相应的响应发送到客户端。前端控制器既可以使用Filter实现（Struts2采用这种方式），也可以使用Servlet来实现。这里我们就采用后一种方式来实现我们的MVC框架。

 ds

1.配置web.xml，使得我们的前端控制器可以拦截所有符合要求的用户请求，这里我们的前端控制器能处理所有以.do结尾的用户请求。 

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   version="2.5"> 

    <description>MVC Sample</description>
    <display-name>MVC</display-name>
    
    <servlet>
      <servlet-name>DispatcherServlet</servlet-name>
      <servlet-class>com.google.mvc.web.servlet.DispatcherServlet</servlet-class>
    </servlet>   

    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

  2.FrameworkServlet实现。
FrameworkServlet是DispatcherServlet的直接父类，继承自HttpServlet，主要用来初始话WebApplicationContext，把不同的Http请求操作委托给同一个方法去处理。 

package com.google.mvc.web.servlet;

import java.io.IOException;

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

import org.apache.log4j.Logger;
import com.google.mvc.web.context.WebApplicationContext;

public abstract class FrameworkServlet extends HttpServlet {

	private static final long serialVersionUID = 1L;
	private static final Logger LOGGER = Logger.getLogger(FrameworkServlet.class);
	private WebApplicationContext webApplicationContext;	
	
	@Override
	public void init() throws ServletException {
		
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("----------Initializing servlet '" + getServletName() + "'----------");
		}

		this.webApplicationContext = initWebApplicationContext();
		
		initServletBean();

		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("----------Servlet '" + getServletName() + "' configured successfully----------/n/n");
		}

	}	
	
	private WebApplicationContext initWebApplicationContext() {		
		WebApplicationContext wac = new WebApplicationContext(getServletContext());
		wac.init();	
		onRefresh(wac);
		return wac;		
	}

	protected void onRefresh(WebApplicationContext context) {
		// For subclasses: do nothing by default.
	}
	
	protected void initServletBean(){
		
	}
	
	protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws Exception;
	

	protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		long startTime = System.currentTimeMillis();
		Throwable failureCause = null;

		try {
			doService(request, response);
		} catch (ServletException ex) {
			failureCause = ex;
			throw ex;
		} catch (IOException ex) {
			failureCause = ex;
			throw ex;
		} catch (Throwable ex) {
			failureCause = ex;
			throw new NestedServletException("Request processing failed", ex);
		} finally {
			if (failureCause != null) {
				LOGGER.error("Could not complete request", failureCause);
			} else {
				long processingTime = System.currentTimeMillis() - startTime;
				if (LOGGER.isDebugEnabled()) {
					LOGGER.info("Successfully completed request, cost " + processingTime + " ms/n");
				}
			}
		}
	}

	@Override
	protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException,
			IOException {
		processRequest(request, response);
	}

	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		processRequest(request, response);
	}

	@Override
	protected void doHead(HttpServletRequest request, HttpServletResponse response) throws ServletException,
			IOException {
		processRequest(request, response);
	}

	@Override
	protected void doOptions(HttpServletRequest request, HttpServletResponse response) throws ServletException,
			IOException {
		processRequest(request, response);
	}

	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
			IOException {
		processRequest(request, response);
	}

	@Override
	protected void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		processRequest(request, response);
	}

	@Override
	protected void doTrace(HttpServletRequest request, HttpServletResponse response) throws ServletException,
			IOException {
		processRequest(request, response);
	}

	@Override
	public void destroy() {
		if(LOGGER.isDebugEnabled()){
			LOGGER.info("Servlet destory");
		}
		super.destroy();
	}

	public WebApplicationContext getWebApplicationContext() {
		return webApplicationContext;
	}
	
	

}

3.DispatcherServlet实现。 
package com.google.mvc.web.servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;

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

import org.apache.log4j.Logger;
import com.google.mvc.web.context.WebApplicationContext;

public class DispatcherServlet extends FrameworkServlet {

	private static final long serialVersionUID = 1L;
	private static final Logger LOGGER = Logger.getLogger(DispatcherServlet.class);
	private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
	private static final Properties defaultStrategies = new Properties();

	private List<HandlerMapping> handlerMappings;
	private List<HandlerAdapter> handlerAdapters;
	private List<ViewResolver> viewResolvers;

	static {
		try {
			defaultStrategies.load(DispatcherServlet.class.getResourceAsStream(DEFAULT_STRATEGIES_PATH));
		} catch (IOException ex) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
		}
	}

	@Override
	protected void onRefresh(WebApplicationContext wac) {
		initHandlerMappings(wac);
		initHandlerAdapters(wac);
		initViewResolvers(wac);
	}

	private void initHandlerMappings(WebApplicationContext wac) {
		Map<String, HandlerMapping> map = wac.beansOfType(HandlerMapping.class);
		if (!map.isEmpty()) {
			this.handlerMappings = new ArrayList<HandlerMapping>(map.values());
		}
		if (this.handlerMappings == null) {
			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
			}
			this.handlerMappings = getDefaultStrategies(wac, HandlerMapping.class);
		}
	}

	private void initHandlerAdapters(WebApplicationContext wac) {
		Map<String, HandlerAdapter> map = wac.beansOfType(HandlerAdapter.class);
		if (!map.isEmpty()) {
			this.handlerAdapters = new ArrayList<HandlerAdapter>(map.values());
		}
		if (this.handlerAdapters == null) {
			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
			}
			this.handlerAdapters = getDefaultStrategies(wac, HandlerAdapter.class);
		}
	}

	private void initViewResolvers(WebApplicationContext wac) {
		Map<String, ViewResolver> map = wac.beansOfType(ViewResolver.class);
		if (!map.isEmpty()) {
			this.viewResolvers = new ArrayList<ViewResolver>(map.values());
		}
		if (this.viewResolvers == null) {
			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default");
			}
			this.viewResolvers = getDefaultStrategies(wac, ViewResolver.class);
		}
	}

	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {

		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("DispatcherServlet with name '" + getServletName() + "' received request for ["
					+ request.getRequestURI() + "]");
		}
		doDispatch(request, response);
	}

	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("Bound request context to thread: " + request);
		}

		Object handler = getHandler(request);
		HandlerAdapter ha = getHandlerAdapter(handler);
		ModelAndView mv = ha.handle(request, response, handler);

		// Do we need view name translation?
		if (mv != null && !mv.hasView()) {
			mv.setViewName(getDefaultViewName(request));
		}

		// Did the handler return a view to render?
		if (mv != null && !mv.wasCleared()) {
			render(mv, request, response);
		}
	}

	protected <T> List<T> getDefaultStrategies(WebApplicationContext wac, Class<T> strategyInterface) {
		String key = strategyInterface.getName();
		List<T> strategies = new ArrayList<T>();
		String value = defaultStrategies.getProperty(key);
		if (value != null) {
			StringTokenizer token = new StringTokenizer(value, ",");
			while (token.hasMoreTokens()) {
				String className = token.nextToken();
				try {
					Class<?> clazz = this.getClass().getClassLoader().loadClass(className);
					strategies.add((T) wac.createBean(clazz));
				} catch (Exception e) {
					LOGGER.error("Can't load class " + className + "", e);
				}
			}
		} else {
			strategies = Collections.emptyList();
		}
		return strategies;
	}

	protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
		View view = null;
		if (mv.isReference()) {
			// We need to resolve the view name.
			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), request);
			if (view == null) {
				throw new ServletException("Could not resolve view with name '" + mv.getViewName()
						+ "' in servlet with name '" + getServletName() + "'");
			}
		} else {
			// No need to lookup: the ModelAndView object contains the actual
			// View object.
			view = mv.getView();
			if (view == null) {
				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a "
						+ "View object in servlet with name '" + getServletName() + "'");
			}
		}
		// Delegate to the View object for rendering.
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
		}
		view.render(mv.getModelInternal(), request, response);
	}

	protected View resolveViewName(String viewName, Map<String, Object> model, HttpServletRequest request)
			throws Exception {
		for (Iterator<ViewResolver> it = this.viewResolvers.iterator(); it.hasNext();) {
			ViewResolver viewResolver = it.next();
			View view = viewResolver.resolveViewName(viewName);
			if (view != null) {
				return view;
			}
		}
		return null;
	}

	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		Iterator<HandlerAdapter> it = this.handlerAdapters.iterator();
		while (it.hasNext()) {
			HandlerAdapter ha = it.next();
			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("Testing handler adapter [" + ha + "]");
			}
			if (ha.supports(handler)) {
				return ha;
			}
		}
		throw new ServletException("No adapter for handler [" + handler
				+ "]: Does your handler implement a supported interface like Controller?");
	}

	protected Object getHandler(HttpServletRequest request) throws Exception {
		Iterator<HandlerMapping> it = this.handlerMappings.iterator();
		while (it.hasNext()) {
			HandlerMapping hm = it.next();
			if (LOGGER.isDebugEnabled()) {
				LOGGER.debug("Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName()
						+ "'");
			}
			return hm.getHandler(request);
		}
		return null;
	}

	private String getDefaultViewName(HttpServletRequest request) {
		String url = request.getServletPath();
		url = url.replaceAll("/", "");
		url = url.replaceAll(".html", "");
		url = url.replaceAll(".htm", "");

		url = "WEB-INF/" + url + ".jsp";

		return url;
	}

}

初始化操作.

  1. 检查系统中是否已经定义HandlerMapping。如果没有定义，则使用默认配置。
  2. 检查系统中是否已经定义HandlerAdapter。如果没有定义，则使用默认配置。
  3. 检查系统中是否已经定义ViewResolover。如果没有定义，则使用默认配置。

请求处理.

  1. 根据特定的请求，使用HandlerMapping找到相应的控制器Handler。
  2. 找到支持此种handler的HandlerAdapter，handler处理完响应业务后，HandlerAdapter把它转化为ModelAndView对象。
  3. 利用ViewResolver对ModelAndView进行分析，生成相应的View对象。
  4. 生成响应。
默认配置 

com.google.mvc.web.servlet.HandlerMapping=com.google.mvc.web.servlet.handler.URLHandlerMapping
com.google.mvc.web.servlet.HandlerAdapter=com.google.mvc.web.servlet.mvc.HttpRequestHandlerAdapter,/
com.google.mvc.web.servlet.mvc.ControllerHandlerAdapter
com.google.mvc.web.servlet.ViewResolver=com.google.mvc.web.servlet.mvc.DefaultViewResolver


Mr.langal
关注
专栏目录
MVC架构探究及其源码实现(1)-理论基础
zhiqiangzhan的专栏
10-19 2万+
博学，切问，近思--詹子知 (http://blog.csdn.net/zhiqiangzhan) 　　MVC本来是存在于Desktop程序中的，M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据你可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。　　模型
MVC架构探究及其源码实现
weixin_30413739的博客
11-03 67
http://blog.csdn.net/zhiqiangzhan/archive/2009/10/19/4697443.aspx 转载于:https://www.cnblogs.com/zhangzt/archive/2010/11/03/1868232.html
springMVC前端控制器Dispatcher
pzzzzzp的博客
08-08 277
springMVC前端控制器Dispatcher 一、springMVC执行流程 首先在接收到请求时，首先获取HandlerMapping 然后根据HandlerMapping获取对应的HandlerExecutionChain，这个执行链内置了Handler(可以理解为Controller) HandlerExecutionChain除了内置Handler外，还有拦截器HandlerInterceptor，首先有一个默认的拦截器，就是ConversionServiceExposingIntercepto
TalleMecanico-MVC
02-16
3. **Controller（控制器）**：作为模型和视图之间的桥梁，处理用户的输入，并协调它们之间的通信。控制器接收来自用户的请求，调用模型进行处理，然后将结果传递给视图进行展示。在TalleMecanico-MVC项目中，控制器...
浪子Pay-码支付即时到账系统源码
07-13
- **MVC架构**：模型-视图-控制器设计模式，用于组织应用程序代码。 - **支付接口**：如对接支付宝、微信支付等第三方支付平台，实现支付流程。 - **安全机制**：如加密算法、防止SQL注入、XSS攻击等，确保交易安全...
活动APP for ThinkSAAS v0.9-源码.zip
最新发布
02-26
1. **ThinkSAAS框架**：理解ThinkSAAS的基本架构和设计模式，例如MVC（模型-视图-控制器）模式，以及如何在框架内组织和管理代码。 2. **活动管理功能**：分析源码中的活动管理模块，学习如何实现活动创建、编辑、...
source-code-springMVC:SpringMVC源码查看-查看
03-24
SpringMVC的核心组件是DispatcherServlet，它是一个前端控制器，负责接收HTTP请求，根据请求信息选择合适的处理器，然后转发到相应的控制器方法。 3. **HandlerMapping** HandlerMapping负责映射请求到对应的...
【SpringMVC框架】前端控制器源代码分析
weixin_34235135的博客
07-21 173
前端控制器源代码分析 虽然前面讲了一些springmvc的入门程序和配置文件中映射器和适配器的配置，但是我们作为编程人员，了解框架的部分源码还是有必要的，比如前端控制器，它是如何通过Servlet的web.xml配置文件实现拦截并跳转至DispatcherServlet的呢？下面我们详细探讨 众多周知我们的入门程序的web.xml是这么配置的<?...
SpringMVC——MVC思想、前端控制器、SpringMVC概述、编写第一个SpringMVC程序
Guizy
03-21 6970
目录 一、什么是MVC 二、前端控制器(中心控制器) 1、什么是前端控制器 2、前端控制器原理 三、什么是SpringMVC 1、SpringMVC简介 2、SpringMVC和Struts2 四、SpringMVC第一个程序(配置版) 五、第一个SpringMVC程序小结 一、什么是MVC 跳转到目录 这里作简单介绍 具体看我之前的一篇博客: 三层架构和MVC思想 MVC是...
SpringMVC前端控制器三种配置方式
GuXiangFly的博客
04-18 9972
配置springmvc的前端控制器需要在web.xml里面配置拦截的路径名称。 .action 与 / 与 /* 的区别
Front ConTroller(MVC) 前端控制器 (配生活实例解释)
傲宇苍穹
02-20 1685
前端控制器:客户在页面输入  通过HTTP协议 利用request将数据(请求))带入前端控制器前端控制器依据请求 指定对应的控制器 controller1/2/3控制器依据业务实际 进行处理后 调用业务逻辑产生数据,返回给前端控制器此时前端控制器再将这些业务数据分发给业务视图由业务视图将数据产生在业务页面中业务页面再将生成的页面返回到前端控制器,前端控制器再将业务页面反馈给用户界面换位思考方式:...
SpringMVC前端控制器和执行流程
caihongjianke的博客
11-19 1657
SpringMVC tomcat启动流程 初始化默认的JspServlet和DefaultServlet 初始化我们配置的前端控制器DispatcherServlet 因为我们在DispatcherServlet中配置了mvc.xml，因此也会启动Spring容器。SPring容器会帮我们创建相应的bean并管理 创建的对象包括Controller层，Service层，Mapper层，Datas...
国网配电站房智能辅控系统改造无人值守
配电房综合监控
01-26 2万+
方案背景 真正了解无人值守配电房的运行模式，必须对“无人值守”能够正确理解，“无人值守”并小是真正脱离工作人员的管理，而是借助技术设备，通过人与机器之间的合理协调来保保障配电房的正常运行。 配电站房智能辅控系统，可以完成对配电房中各重要的环境参数进行实时监控，并实现数据的存储、处理以及数据分析和预警警报等。作为重要的运维手段，可实现配电房的少人或无人值守，使用户的维护模式从“被动抢修模式”变为“主动预防模式”。 系统概述 无人值守配电站房智能辅控系统方案是一款集配电房灯光、消防、安防、门禁、视频、温
vs .net mvc基本操作
前端啥也不懂
11-18 535
NuGet包安装代码：install-package XXXXX
MVC前端控制器和后端控制器
qq_45264366的博客
08-23 1336
作为一个MVC框架，首先要解决的是：如何能够收到请求！ 所以MVC框架大都会设计一款前端控制器，选型在 Servlet 或 Filter两者之一,在框架最前沿率先工作，接收所有请求。 此控制器在接收到请求后，还会负责springMVC的核心的调度管理，所以既是前端又是核心。 <servlet> <servlet-name>mvc</servlet-name> <servlet-class>org.springframework.web.s
iOS 7：用代码解决视图控制器的View整体上移问题
热门推荐
kmyhy的专栏
03-04 3万+
如果你准备将你的老的 iOS 6 app 迁移到 iOS 7 上，那么你必须注意了。当你的老的 app 在 iOS 7 设备上运行时，所有ViewController 的视图都整体上移了，因为 iOS 7 把整个屏幕高度（包括状态栏和导航栏）都作为了视图控制器的有效高度。于是你的视图上移了，并和上层的状态栏交叠在一起。你当然可以在 Xcode 中修改每个 View,将他们下移20个像素（状态栏高度
Spring MVC系列之（五）、Spring MVC的前端控制器（DispatcherServlet）工作流程及原理
一宿君
07-25 2321
五、Spring MVC的工作流程执行图 5.1 DispatcherServlet流程中每一步的含义 用户通过浏览器向服务器发送请求。请求会被Spring MVC的DispatcherServlet(前端控制器)所拦截； DispatcherServlet拦截到请求后，会通过HandlerMapping处理器映射器； 处理器映射器根据请求URL找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet； DispatcherServlet会通过返回信息选
Spring MVC架构详解：模型-视图-控制器与解耦关键技术
Spring MVC是一种广泛应用于Java Web开发的架构模式，它遵循MVC（Model-View-Controller）设计原则，旨在将应用程序的逻辑分隔为三个主要组件，从而提高代码的可维护性和灵活性。MVC架构模式的核心在于： 1. **模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值