JDK1.5加入了对注解机制的支持，实际上我学习Java的时候就已经使用JDK1.6了，而且除了@Override和@SuppressWarnings(后者还是IDE给生成的&&)之外没接触过其他的。
　　进入公司前的面试，技术人员就问了我关于注解的问题，我就说可以生成chm手册&&现在想起来真囧，注释和注解被我搞得完全一样了。
　　使用注解主要是在需要使用Spring框架的时候，特别是使用SpringMVC。因为这时我们会发现它的强大之处：预处理。
　　注解实际上相当于一种标记，它允许你在运行时(源码、文档、类文件我们就不讨论了)动态地对拥有该标记的成员进行操作。
　　实现注解需要三个条件(我们讨论的是类似于Spring自动装配的高级应用)：注解声明、使用注解的元素、操作使用注解元素的代码。
　　首先是注解声明，注解也是一种类型，我们要定义的话也需要编写代码，如下：
3 import java.lang.annotation.ElementT
4 import java.lang.annotation.R
5 import java.lang.annotation.RetentionP
6 import java.lang.annotation.T
* 自定义注解，用来配置方法
* @author Johness
14 @Retention(RetentionPolicy.RUNTIME) // 表示注解在运行时依然存在
15 @Target(ElementType.METHOD) // 表示注解可以被使用于方法上
16 public @interface SayHiAnnotation {
String paramValue() default "johness"; // 表示我的注解需要一个参数 名为"paramValue" 默认值为"johness"
　　然后是使用我们注解的元素：
3 import annotation.SayHiA
* 要使用SayHiAnnotation的元素所在类
* 由于我们定义了只有方法才能使用我们的注解，我们就使用多个方法来进行测试
* @author Johness
12 public class SayHiEmlement {
// 普通的方法
public void SayHiDefault(String name){
System.out.println("Hi, " + name);
// 使用注解并传入参数的方法
@SayHiAnnotation(paramValue="Jack")
public void SayHiAnnotation(String name){
System.out.println("Hi, " + name);
// 使用注解并使用默认参数的方法
@SayHiAnnotation
public void SayHiAnnotationDefault(String name){
System.out.println("Hi, " + name);
　　最后，是我们的操作方法(值得一提的是虽然有一定的规范，但您大可不必去浪费精力，您只需要保证您的操作代码在您希望的时候执行即可)：
1 package M
3 import java.lang.reflect.InvocationTargetE
4 import java.lang.reflect.M
6 import element.SayHiE
7 import annotation.SayHiA
9 public class AnnotionOperator {
public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException {
SayHiEmlement element = new SayHiEmlement(); // 初始化一个实例，用于方法调用
Method[] methods = SayHiEmlement.class.getDeclaredMethods(); // 获得所有方法
for (Method method : methods) {
SayHiAnnotation annotationTmp = null;
if((annotationTmp = method.getAnnotation(SayHiAnnotation.class))!=null) // 检测是否使用了我们的注解
method.invoke(element,annotationTmp.paramValue()); // 如果使用了我们的注解，我们就把注解里的"paramValue"参数值作为方法参数来调用方法
method.invoke(element, "Rose"); // 如果没有使用我们的注解，我们就需要使用普通的方式来调用方法了
　　结果为：Hi, Jack　　　　　　Hi, johness　　　　　　Hi, Rose
　　可以看到，注解是进行预处理的很好方式(这里的预处理和编译原理有区别)！
　　接下来我们看看Spring是如何使用注解机制完成自动装配的：
　　　　首先是为了让Spring为我们自动装配要进行的操作，无外乎两种：继承org.springframework.web.context.support.SpringBeanAutowiringSupport类或者添加@Component/@Controller等注解并(只是使用注解方式需要)在Spring配置文件里声明context:component-scan元素。
　　　　我说说继承方式是如何实现自动装配的，我们打开Spring源代码查看SpringBeanAutowiringSupport类。我们会发现以下语句：
1 public SpringBeanAutowiringSupport() {
processInjectionBasedOnCurrentContext(this);
　　　　众所周知，Java实例构造时会调用默认父类无参构造方法，Spring正是利用了这一点，让"操作元素的代码"得以执行！(我看到第一眼就震惊了！真是奇思妙想啊。果然，高手都要善于用Java来用Java)
　　　　后面的我就不就不多说了，不过还是要纠正一些人的观点：说使用注解的自动装配来完成注入也需要setter。这明显是错误的嘛！我们看Spring注解装配(继承方式)的方法调用顺序：&org.springframework.web.context.support.SpringBeanAutowiringSupport#SpringBeanAutowiringSupport=&
　　　　&&& org.springframework.web.context.support.SpringBeanAutowiringSupport#processInjectionBasedOnCurrentContext=&
　　　　　&org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#processInjection=&
&&&&&&&&&&&&&& org.springframework.beans.factory.annotation.InjectionMetadata#Injection(继承，方法重写)。最后看看Injection方法的方法体：
* Either this or {@link #getResourceToInject} needs to be overridden.
protected void inject(Object target, String requestingBeanName, PropertyValues pvs) throws Throwable {
if (this.isField) {
Field field = (Field) this.
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));
if (checkPropertySkipping(pvs)) {
Method method = (Method) this.
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
catch (InvocationTargetException ex) {
throw ex.getTargetException();
　　　　　　虽然不完全，但可以基本判定此种自动装配是使用了java放射机制。
&欢迎您移步我们的交流群，无聊的时候大家一起打发时间：
&或者通过QQ与我联系：
&（最后编辑时间 09:52:27）
阅读(...) 评论()2016年10月 Java大版内专家分月排行榜第一2016年9月 Java大版内专家分月排行榜第一2016年8月 Java大版内专家分月排行榜第一2014年4月 Java大版内专家分月排行榜第一
2016年11月 Java大版内专家分月排行榜第二
2012年5月 Oracle大版内专家分月排行榜第三
2015年5月 Java大版内专家分月排行榜第二2013年5月 Java大版内专家分月排行榜第二
2011年5月 Java大版内专家分月排行榜第三2011年1月 Java大版内专家分月排行榜第三
2004年4月 软件工程/管理大版内专家分月排行榜第二
本帖子已过去太久远了，不再提供回复功能。> Struts,spring工作机制(小结)
Struts,spring工作机制(小结)
发布时间： & &
浏览：1 & &
回复：0 & &
悬赏：0.0希赛币
Struts,spring工作机制(总结)
　　1,Struts1 工作流程：
　　web.xml:
　　&servlet&　
&servlet-name&action&/servlet-name& 　
&servlet-class&org.apache.struts.action.ActionServlet&/servlet-class& &/servlet& &servlet-mapping& 　
&servlet-name&action&/servlet-name& 　
&url-pattern&*.do&/url-pattern& &/servlet-mapping&
　　在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息; -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法; -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功; -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
　　2,Struts2的工作机制
　　web.xml
　　&filter&　　 　
&filter-name&struts2&/filter-name&　　 　
&filter-class&　　 　
org.apache.struts2.dispatcher.FilterDispatcher　　
&/filter-class&　　 &/filter&　　
　　&filter-mapping&　　 　
&filter-name&struts2&/filter-name&　　 　
&url-pattern&/*&/url-pattern&　　 &/filter-mapping&　
　　1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；6、ActionProxy创建一个ActionInvocation的实例。7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper。
　　包名 说明 orponents 该包封装视图组件，Struts2在视图组件上有了很大加强，不仅增加了组件的属性个数，更新增了几个非常有用的组件，如updownselect、doubleselect、datetimepicker、token、tree等。 ornfig 该包定义与配置相关的接口和类。实际上，工程中的xml和properties文件的读取和解析都是由WebWork完成的，Struts只做了少量的工作。 org.apache.struts2.dispatcher Struts2的核心包，最重要的类都放在该包中。 org.apache.struts2.impl 该包只定义了3个类，他们是StrutsActionProxy、StrutsActionProxyFactory、StrutsObjectFactory，这三个类都是对xwork的扩展。 org.apache.struts2.interceptor 定义内置的截拦器。 org.apache.struts2.util 实用包。 org.apache.struts2.validators 只定义了一个类：DWRValidator。 org.apache.struts2.views 提供freemarker、jsp、velocity等不同类型的页面呈现。
　　3，Spring工作机制
　　web.xml
　　&web-app& 　 &servlet&
　　&servlet-name&Dispatcher&/servlet-name& 　　　 &servlet-class& 　　　　　 org.springframework.web.servlet.DispatcherServlet
　　　 &/servlet-class& 　　　 &init-param& 　　　　　 &param-name&contextConfigLocation&/param-name& 　　　　　 &param-value&/WEB-INF/applicationContext.xml&/param-value& 　　　
&/init-param& 　　　
&load-on-startup&1&/load-on-startup& 　
&/servlet& 　
&servlet-mapping& 　　　
&servlet-name&Dispatcher&/servlet-name& 　　　
&url-pattern&*.do&/url-pattern& 　
&/servlet-mapping& &/web-app&
　　spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.DispatcherServlet请请求提交到目标ControllerController进行业务逻辑处理后，会返回一个ModelAndViewDispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象视图对象负责渲染返回给客户端。
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&在一个工程中如果想要使用 SpringMVC的话，只需要两个步骤
在web.xml中配置一个DispatcherServlet。需要配置一个org.springframework.web.servlet.DispatcherServlet的servlet。
定义一个dispatcherServlet-servlet.xml配置文件。在这个配置文件里面我们只需要扩展一个路径映射关系，定义一个视图解析器，再定义一个业务逻辑的处理流程规则。
这样就可以搞定一个最基本的Spring MVC的应用了。
对于spring MVC框架中，有三个组件是用户必须定义和扩展的：
&&& 定义URL映射规则：handlerMapping
&&& 实现业务逻辑的handler实例对象：handlerAdapter
&&& 渲染模版资源：ViewResolver
下面是传统的配置示例：
&!-- web.xml --&
&servlet-name&countries&/servlet-name&
&servlet-class&org.springframework.web.servlet.DispatcherServlet&/servlet-class&
&load-on-startup&2&/load-on-startup&
&/servlet&
&servlet-mapping&
&servlet-name&countries&/servlet-name&
&url-pattern&*.htm&/url-pattern&
&/servlet-mapping
&!-- dispatcherServlet-servlet.xml --&
派遣器收到请求后,把不同的页面派遣到不同的控制器进行处理
Spring有两种MAPPING的机制,默认为BeanNameUrlHandlerMapping,在DispatcherServlet.properties文件中配置
我们这里采用的是SimpleUrlHandlerMapping. --&
&bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"&
&property name="mappings"&
&prop key="/home.htm"&countriesController&/prop&
&/property&
&!-- 在控制器处理前,我们可以将其拦截,进行一些特殊或通用处理;拦截器可以选用Spring已经实现的或我们自己实现的
&property name="interceptors"&
&ref local="localeChangeInterceptor"/&
&ref local="themeChangeInterceptor"/&
&ref local="copyInterceptor"/&
&/property&
&bean id="countriesController" class="cn.jephon.demo.CountriesController" /&
下面是用freemaker引擎的配置示例：
&!--web.xml 配置 spring 的DispatcherServlet--&
&servlet-name&SpringMVC&/servlet-name&
&servlet-class&org.springframework.web.servlet.DispatcherServlet&/servlet-class&
&init-param&
&param-name&contextConfigLocation&/param-name&
&!--给出框架配置文件所在的路径--&
&param-value&classpath:conf/freemarker-servlet.xml&/param-value&
&/init-param&
&/servlet&
&!--freemarker-servlet在conf/freemarker-servlet.xml文件中的参数配置如下--&
&!-- freemark --&
&bean id="freemarkerConfig"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer"&
&property name="templateLoaderPath" value="/WEB-INF/ftl/" /&
&property name="defaultEncoding" value="UTF-8" /&
&bean id="viewResolver"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver"&
&property name="cache" value="true" /&
&property name="prefix" value="" /&
&property name="suffix" value=".ftl" /&
&property name="exposeSpringMacroHelpers" value="true" /&
&property name="exposeRequestAttributes" value="true" /&
&property name="exposeSessionAttributes" value="true" /&
&property name="requestContextAttribute" value="request" /&
&property name="contentType" value="text/ charset=utf-8" /&
SpringMVC的入口是DispatchServlet，它的工作大致可以分为两个部分，一个是初始化，另外一个是请求处理。
DispatcherServlet初始化
//DispatcherServlet的初始化方法
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
// Set bean properties from init parameters.
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));
　　　　 //只有HttpServletBean覆盖了此方法，
　　　　 //所以由HttpServletBean读取配置在ServletContext中的bean属性参数，即web.xml中的context-param，然后创建和设置这些bean属性
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
catch (BeansException ex) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
//由FrameServlet执行此方法，调用FrameworkServlet的createWebApplicationContext方法，初始化spring容器。
　　//调用FrameworkServlet的onRefresh方法完成配置文件的加载，配置文件的加载是先查找servlet的init-param参数中设置的路径，如果没有，就会根据namespace+Servlet的名称来查找XML文件。
　　//Spring容器加载的时候会调用DispatcherServlet的initStrategies方法来初始化springMVC框架所需要的八个组件，　　//这八个组件对应的八个bean对应都保存在DispatcherServlet类中。
　　initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
protected void initStrategies(ApplicationContext context) {
//初始化MultipartResolver，主要是处理文件上传服务。
initMultipartResolver(context);
//用于处理应用的国际化问题
initLocaleResolver(context);
//用于定义一个主题
initThemeResolver(context);
//用于定义用户设置的请求映射关系
initHandlerMappings(context);
//用于根据Handler的类型定义不同的处理规则
initHandlerAdapters(context);
//当Handler处理错误的时候，通过这个handler来做统一的处理
initHandlerExceptionResolvers(context);
//将指定的ViewName按照定义的RequestToViewNameTranslator替换成想要的格式。
initRequestToViewNameTranslator(context);
//用于将view解析成页面
initViewResolvers(context);
//用于映射flash管理的。
initFlashMapManager(context);
要做的8件事是如下。
initMultipartResolver：初始化MultipartResolver，用于处理文件上传服务，如果有文件上传，那么会将当前的HttpServletRequest包装成DefaultMultipartHttp ServletRequest，并且将每个上传的内容封装成CommonsMultipartFile对象。
initLocaleResolver：用于处理应用的国际化问题，通过解析请求的Locale和设置响应的Locale来控制应用中的字符编码问题。
initThemeResolver：用于定义一个主题，例如，可以根据用户的喜好来设置用户访问的页面的样式，可以将这个样式作为一个Theme Name保存，用于请求的Cookie中或者保存在服务端的Session中，以后每次请求根据这个Theme Name来返回特定的内容。
initHandlerMappings：用于定义用户设置的请求映射关系，例如，前面示例中的SimpleUrlHandlerMapping把用于用户请求的URL映射成一个个Handler实例。HandlerMapping必须定义，如果没有定义，将获取DispatcherServlet.properties文件中默认的两个HandlerMapping，分别是BeanNameUrlHandlerMapping和DefaultAnnotationHandlerMapping。
initHandlerAdapters：用于根据Handler的类型定义不同的处理规则，例如，定义SimpleControllerHandlerAdapter处理所有Controller的实例对象，在HandlerMapping中将URL映射成一个Controller实例，那么Spring MVC在解析时SimpleController HandlerAdapter就会调用这个Controller实例。同样HandlerAdapters也必须定义，如果没有定义，将获取DispatcherServlet.properties文件中默认的四个Handler Adapters，分别是HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、ThrowawayControllerHandlerAdapter和AnnotationMethodHandlerAdapter。
initHandlerExceptionResolvers：当Handler处理出错时，通过这个Handler来统一做处理，默认的实现类是SimpleMappingExceptionResolver，将错误日志记录在log文件中，并且转到默认的错误页面。
initRequestToViewNameTranslator：将指定的ViewName按照定义的RequestToVie wNameTranslator替换成想要的格式，如加上前缀或者后缀等。
initViewResolvers：用于将View解析成页面，在ViewResolvers中可以设置多个解析策略，如可以根据JSP来解析，或者按照Velocity模板解析。默认的解析策略是InternalResourceViewResolver，按照JSP页面来解析。
上面的是springMVC的工作原理图：
1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.
2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找到处理请求的处理器（Handler）。
3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler（Handler将具体的处理进行封装），再由具体的HandlerAdapter对Handler进行具体的调用。
5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。
6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。
7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。
HandlerMapping初始化：
将URL与Handler的对应关系保存在HandlerMapping集合中，并将所有的interceptors对象保存在adaptedInterceptors数组中，等请求到来的时候执行所有的adaptedIntercoptors数组中的interceptor对象。所有的interceptor必须实现HandlerInterceptor接口。
HandlerAdapter初始化：
Spring MVC中提供了如下三个典型的简单HandlerAdapter实现类。
SimpleServletHandlerAdapter：可以继承HttpRequestHandler接口，所有的Handler可以实现其void handleRequest(HttpServletRequest request, HttpServletResponse response)方法，这个方法没有返回值。
SimpleControllerHandlerAdapter：可以继承Controller接口，所有的Handler可以实现其public ModelAndView handle(HttpServletRequest request, HttpServletRes ponse response, Object handler)方法，该方法会返回ModelAndView对象，用于后续的模板渲染。
SimpleServletHandlerAdapter：可以直接继承Servlet接口，可以将一个Servlet作为一个Handler来处理这个请求。
Spring MVC的HandlerAdapter机制可让Handler的实现更加灵活，不需要和其他框架那样只能和某个Handler接口绑定起来。
对于handlerAdapter的初始化没有什么特别之处，只是简单的创建一个handlerAdapter对象，将这个对象保存在DispatcherServlet的HandlerAdapters集合中。当Spring MVC将某个URL对应到某个Handler时候，在handlerAdapters集合中查询那个handlerAdapter对象supports这个Handler，handlerAdapter对象将会被返回，然后调用这个handlerAdapter接口对应的方法。如果这个handlerAdapter对象是SimpleControllerHandlerAdapter，将调用Controller接口的public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)方法。
Control的调用逻辑：
整个Spring MVC的调用是从DispatcherServlet的doService方法开始的，在doService方法中会将ApplicationContext、localeResolver、themeResolver等对象添加到request中便于在后面使用，接着就调用doDispatch方法，这个方法是主要的处理用户请求的地方。&
对于control的处理关键就是：DispatcherServlet的handlerMappings集合中根据请求的URL匹配每一个handlerMapping对象中的某个handler,匹配成功之后将会返回这个handler的处理连接handlerExecutionChain对象。而这个handlerExecutionChain对象中将会包含用户自定义的多个handlerInterceptor对象。
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
return null;
对于handlerInterceptor接口中定义的三个方法中，preHandler和postHandler分别在handler的执行前和执行后执行，afterCompletion在view渲染完成、在DispatcherServlet返回之前执行。当preHandler返回false时，当前的请求将在执行完afterCompletion后直接返回,handler也将不会执行。
在类HandlerExecutionChain中的getHandler()方法是返回object对象的；这里的handler是没有类型的，handler的类型是由handlerAdapter决定的。dispatcherServlet会根据handlerAdapters集合中第一个支持该handler对象的HandlerAdapter对象。接下来去执行handler对象的相应方法了，如果该handler对象的相应方法返回一个ModelAndView对象(SampleControllerHandlerAdapter)接下来就是去执行View渲染了。
如果handler返回了ModelAndView对象，那么说明Handler需要传一个Model实例给view去渲染模版。除了渲染页面需要model实例，在业务逻辑层通常也有Model实例。
ModelAndView对象是连接业务逻辑层与view展示层的桥梁，对spring MVC来说它也是连接Handler与view的桥梁。ModelAndView对象顾名思义会持有一个ModelMap对象和一个View对象或者View的名称(譬如hello.vm模板名字)。ModelMap对象就是执行模版渲染时候所需要的变量对应的实例，如jsp的通过request.getAttribute(String)获取的JSTL标签名对应的对象。velocity中context.get(String)获取$foo对应的变量实例。
public class ModelAndView {
/** View instance or view name String */
/** Model Map */
private ModelM
/** Indicates whether or not this instance has been cleared with a call to {@link #clear()} */
private boolean cleared = false;
ModelMap其实也是一个Map,Handler中将模版中需要的对象存在这个Map中，然后传递到view对应的ViewResolver中。
不同的ViewResolver会对这个Map中的对象有不同的处理方式；
velocity中将这个Map保存到VelocityContext中。
freemarker模板引擎来说将ModelMap包装成freemarker.template. TemplateHash Model
JSP中将每一个ModelMap中的元素分别设置到request.setAttribute(modelName,modelValue);
在spring MVC中，view模块需要两个组件来支持：RequestToViewNameTranslator和ViewResolver
public interface RequestToViewNameTranslator {
String getViewName(HttpServletRequest request) throws E
public interface ViewResolver {
View resolveViewName(String viewName, Locale locale) throws E
RequestToViewNameTranslator：主要支持用户自定义对viewName的解析，如将请求的ViewName加上前缀或者后缀，或者替换成特定的字符串等。
ViewResolver：主要是根据用户请求的viewName创建适合的模版引擎来渲染最终的页面，ViewResolver会根据viewName创建一个view对象，调用view对象的Void render方法渲染出页面。
public interface View {
void render(Map&String, ?& model, HttpServletRequest request, HttpServletResponse response) throws E
UrlBasedViewResolver类实现了AbstractCachingViewResolver抽象类，通过设置ViewClass来创建View对象。如果使用FreeMarkerViewResolver类，会将ViewClass设置为FreeMarkerView.class；使用VelocityViewResolver类，会将ViewClass设置为VelocityView.class。InternalResourceViewResolver类可以通过注入的方式设置ViewClass属性来初始化自定义的View对象。由于AbstractCachingViewResolver抽象类也继承了WebApplicationObjectSupport，所以所有的AbstractCachingViewResolver子类可以通过覆盖initApplicationContext方法在Spring MVC框架启动时完成初始化工作。如FreeMarkerViewResolver和VelocityViewResolver就是在启动调用setViewClass方法时设置ViewClass属性的。JSP的ViewResolver对应的是InternalResourceViewResolver类，当调用resolveViewName方法时会调用createView方法，将ViewClass属性对应的InternalResourceView类实例化。最后调用InternalResourceView的render方法渲染出JSP页面。
&Spring MVC解析View的逻辑：
dispatcherServlet调用getDefaultViewName（）方法；
调用RequestToViewNameTranslator的getViewName方法；
调用LocaleResolver接口的resolveLocale方法；
调用ViewResolver接口的resolveViewName方法，返回view对象
调用render方法渲染出页面
JSP的ViewResolver对应的是InternalResourceViewResolver类，当调用resolveViewName方法时会调用createView方法，将ViewClass属性对应的InternalResourceView类实例化。最后调用InternalResourceView的render方法渲染出JSP页面。
总的时序图
阅读(...) 评论()