springmvc的简单配置
1.首先需要在web.xml中配置DispatcherServlet，这个类是springmvc的核心类，所以的操作都是由这里开始，并且大部分都是在这里面实现的，比如各种视图的解析，视图的
映射等等。配置文件：
<servlet>
<servlet-name>springServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup></load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
既然是和spring一套的，那肯定是有配置文件的，但是我们却没有配置文件路径，文件的默认路径是可以修改的，如果我们的这个文件没有配置路径的话，默认的路径是
/WEB-INF/springServlet-servlet.xml // 默认的路径就是：/WEB-INF/[servlet的名称]-servlet.xml
但是我们是可以自己设置属性的，除了文件路径，还可以设置一下的几个属性：
contextClass：实现WebApplicationContext接口的类，当前的servlet用它来创建上下文。如果这个参数没有指定， 默认使用XmlWebApplicationContext。
contextConfigLocation：传给上下文实例（由contextClass指定）的字符串，用来指定上下文的位置。这个字符串可以被分成多个字符串（使用逗号作为分隔符） 来支持多个上下文（在多上下文的情况下，如果同一个bean被定义两次，后面一个优先）。
namespace：WebApplicationContext命名空间。默认值是[server-name]-servlet。
文件既可以放在WEB-INF下面，也可以放在classpath下面，比如：
<servlet>
<servlet-name>springServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup></load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
注意一点的是，这个classpath指的是编译后的位置，刚开始学习框架的时候，总会犯这样的错误，找不到配置文件，就是因为classpath的问题。
对于web项目，还有一种通用的写法，就是放在ContextLoaderListener下面：
restful风格的
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:/spring-context*.xml</param-value>
</context-param>
支持多文件的：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:spring-common-config.xml,
classpath:spring-budget-config.xml
</param-value>
</context-param>
这样子，springmvc基本上是配置好了，这里没有讲spring的配置。
上面配置好了简单的web.xml以后，我们来讲一下DispatcherServlet.
从上面我们应该就明白了，其实它就是一个servlet，既然是servlet，那么理解起来就简单多了。
DispathcherServlet最主要的就是下面几个方法，下面一一来简单看看：
/**
* Initialize the strategy objects that this servlet uses.
* <p>May be overridden in subclasses in order to initialize further strategy objects.
*/
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
这个方法是初始化各种解析器，适配等等的方法，这个方法是在其父类的初始化方法中调用的，没记错的话，其实就是相当于Servlet的init方法执行时调用。首先一起了解下上面每一个方法初始化的都是什么：
1.MultipartResolver指的是文件上传解析类，对于文件上传的时候，需要使用到，我们看他的方法：
private void initMultipartResolver(ApplicationContext context) {
try {
//这里获取bean 注意这个常量在前面的是定义的：MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
//所以我们配置的时候 bean的名称必须是上面的这个 不然是不能识别的哦 注意咯
this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// Default is no multipart resolver.
this.multipartResolver = null;
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
"': no multipart request handling provided");
}
}
}
如果没有配置 那么默认就是没有文件上传解析的。这个时候，如果上传，那么会出一些问题的。
2.LocaleResolver这个是本地化解析，也就是做国际化的，如果没有设置，那么会默认为我们设置一个
3.ThemeResolver 看名字也知道，就是风格和主题解析类，默认也会有为我们设置一个
4.HandlerMappings ：请求到处理器的映射，如果映射成功返回一个HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象；如BeanNameUrlHandlerMapping将URL与Bean名字映射，映射成功的Bean就是此处的处理器；从下面的代码中可以看出
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//请求到处理器的映射，如果映射成功返回一个HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器对象）；
//如BeanNameUrlHandlerMapping将URL与Bean名字映射，映射成功的Bean就是此处的处理器，注意这里处理器值得是handler，而不是handlerMapping，形象的将
//就是handlerMapping是一个模板，处理器handler就是根据你的bean刻出的成型产品。
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 handler;
}
}
return null;
}
5.HandlerAdapters：看到适配器了吧，对各种处理器包装成适配器，这样就能支持多种类型的处理器了。
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());//将处理器进行包装，后面的操作都是都是由适配器进行工作
6HandlerExceptionResolvers：一场解析器，就比如出现错误的时候，可能统一调到某一个页面。默认也有实现，这个需求有太多中解决方案了，没什么好讲
7.RequestToViewNameTranslator：当处理器没有返回逻辑视图名等相关信息时，自动将请求URL映射为逻辑视图名；
8ViewResolvers：视图解析器。我们的配置中都会一般都会配置一个视图，就像这样：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="suffix" value=".jsp"></property>
<property name="prefix" value="/WEB-INF/views/module/"></property>
</bean>
视图解析器就是将上面的进行解析。超类只有一个方法
View resolveViewName(String viewName, Locale locale) throws Exception;
9.FlashMapManager值得是redirect的时候保存数据的一个相当于map分装的一个容器吧，但是官方是说在程序中一般不会使用的，比如在controller，就经常是用RedirectAttributes 来传输数据
讲完了几个比较重要的属性，然后将主要的几个放大，既然是servlet，那么我们就来看看service方法吧，这里的service是这样的：
protected void doService(HttpServletRequest request, HttpServletResponse response)
里面有一个这样的依据代码需要引起重视，其他的代码都是配置一些属性什么的
try {
doDispatch(request, response);
}
这个方法其实就是DispatchServlet的核心，我们前面讲到的解析器，适配器等等都是在这里操作的：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;//前面讲过。handlerMapping映射成功，都会返回这个东西，其中包括处理器和拦截器
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
//查看请求是否是Multipart（如文件上传）
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// Determine handler for the current request.
//映射
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
//进行适配器的包装
// Determine handler adapter for the current request.
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (logger.isDebugEnabled()) {
logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//
applyDefaultViewName(request, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
//解析视图 最终会调用view.render(mv.getModelInternal(), request, response);将model传进去
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
//后面都是编译以后的一些操作了
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Error err) {
triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
上面也就简单的了解了一下springmvc的入口，接下来几天在研究一下springmvc其他的一些功能。好多东西都是自己理解的，不知道对不对==。