SpringMVC配置式开发

最新推荐文章于 2024-10-01 18:51:18 发布

编程小白AA

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量106

点赞数

分类专栏： SpringMVC 文章标签： java

本文链接：https://blog.csdn.net/China_I_Love_You/article/details/108856271

版权

SpringMVC 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

HandlerMapping处理器映射器

简介: 处理器映射器，负责根据用户请求找到相应的将要执行的 Handler，即处理器。即用于完成将用户请求映射为要处理该请求的处理器，并将处理器封装为处理器执行链传给中央调度器。

HandlerMapping的执行流程

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //request请求
		HttpServletRequest processedRequest = request;
		//处理器执行链
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
					//通过request请求获取处理器执行链
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
				}
					....
    	}
	}
}

    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //如果处理器映射器集合(List)不为null
		if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();
			//遍历list集合
            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
				//通过request获取HandlerExecutionChain
                HandlerExecutionChain handler = mapping.getHandler(request);
                //如果handler不为null,返回handler
				if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }

BeanNameUrlHandlerMapping

处理器

public class MyController implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) 
			throws Exception {
		// TODO Auto-generated method stub
		ModelAndView mv = new ModelAndView();
		mv.addObject("message", "Hello SpringMVC");
		//mv.setViewName("welcome");	//这样写是利用spring.xml的视图解析器进行字符串拼接，不好用
		mv.setViewName("/WEB-INF/jsp/welcome.jsp");

		return mv;
	}

}

以BeanNameUrlHandlerMapping的方式注册处理器

<!-- 以BeanNameUrlHandlerMapping的方式注册处理器,id为请求-->
	<bean id="/my.do" class="com.chuangmei.handler.MyController"/>
	<bean id="/hello.do" class="com.chuangmei.handler.MyController"/>

SimpleUrlHandlerMapping

处理器

public class MyController implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) 
			throws Exception {
		// TODO Auto-generated method stub
		ModelAndView mv = new ModelAndView();
		mv.addObject("message", "Hello SpringMVC");
		//mv.setViewName("welcome");	//这样写是利用spring.xml的视图解析器进行字符串拼接，不好用
		mv.setViewName("/WEB-INF/jsp/welcome.jsp");

		return mv;
	}

}

以SimpleUrlHandlerMapping方式注册处理器

 <!-- 注册处理器映射器 -->
		<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
			<property name="mappings">
				<props>
					<prop key="/hello.do">myController</prop>
					<prop key="/aaa.do">myController</prop>
				</props>
			</property>
			<!--         	
			<property name="urlMap">
				<map>
					<entry key="/hello.do" value="myController"/>
					<entry key="/aaa.do" value="myController"/>
				</map>
			</property> 
			-->
		</bean>
		<!-- 创建处理器 -->
		<bean id="myController" class="com.chuangmei.simpleUrlHandlerMapping.myController"/>

HandlerAdapter处理器适配器

通过调用getHandlerAdapter(Object handler)方法,遍历所有的HandlerAdapter,调用HandlerAdapter的supports(handler)方法,supports底层通过处理器实现的接口进行instanceof

	//通过处理器执行链HandlerExecutionChain mappedHandler中的处理器获得HandlerAdapter
	HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
    
	//遍历所有的HandlerAdapter
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        Iterator var2 = this.handlerAdapters.iterator();

        while(var2.hasNext()) {
            HandlerAdapter adapter = (HandlerAdapter)var2.next();
            //调用supports(handler)底层通过instanceof进行判断
			if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
}

adapter的supports(handler)方法

	//SimpleControllerHandlerAdapter适配器
	public class SimpleControllerHandlerAdapter implements HandlerAdapter {
	//如果处理器实现Controller接口返回true
		public boolean supports(Object handler) {
			return handler instanceof Controller;
	}
}

	//HttpRequestHandlerAdapter适配器
	public class HttpRequestHandlerAdapter implements HandlerAdapter {
		public boolean supports(Object handler) {
		//如果处理器实现HttpRequestHandler接口返回true
			return handler instanceof HttpRequestHandler;
	}
}
.......

通过以上的程序找到HandlerAdapter之后,会调用HandlerAdapter的handle(processedRequest, response, mappedHandler.getHandler())方法,返回一个ModelAndView对象,底层调用那个handle方法取决于supports()方法返回的ha是谁
```
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
```

handle(processedRequest, response, mappedHandler.getHandler())底层实现

	//如果我们的处理器实现的是HttpRequestHandler接口,那么此时的HandlerAdapter就是HttpRequestHandlerAdapter
 	@Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
	//因为经过以上instanceof后,直接将handler强转为HttpRequestHandler去执行handleRequest()方法,也就是我们写的处理器实现的方法
		((HttpRequestHandler)handler).handleRequest(request, response);
		return null;
	}

	//如果我们的处理器实现的是Controller接口,那么此时的HandlerAdapter就是SimpleControllerHandlerAdapter
	 @Nullable
	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {\
		//因为经过以上instanceof后,直接将handler强转为Controller去执行handleRequest()方法,也就是我们写的处理器实现的方法
			return ((Controller)handler).handleRequest(request, response);
		}
........