Sping MVC不使用任何注解处理（jQuery）Ajax请求（基于XML配置）

最新推荐文章于 2022-05-30 20:43:31 发布

liudahai777

最新推荐文章于 2022-05-30 20:43:31 发布

阅读量319

点赞数

本文链接：https://blog.csdn.net/li123128/article/details/102877950

版权

1. Spring
　　
　　Spring框架是一个轻量级的解决方案，是一个潜在的一站式商店，用于构建企业就绪的应用程序。Spring框架是一个Java平台，为开发Java应用程序提供全面的基础架构支持。Spring处理基础结构，因此您可以专注于应用程序。Spring使您能够从“普通的Java对象”（POJO）构建应用程序，并将企业服务非侵入性地应用于POJO。此功能适用于Java SE编程模型以及全部和部分Java EE。但是，Spring是模块化的，允许您仅使用所需的那些部分，而不必引入其余部分。您可以将IoC容器与顶部的任何Web框架一起使用，但也可以仅使用 Hibernate集成代码或JDBC抽象层。Spring框架支持声明式事务管理，通过RMI或Web服务对逻辑的远程访问以及用于持久化数据的各种选项。它提供了功能全面的MVC框架，并使您能够将AOP透明地集成到软件中。Spring被设计为非侵入式的，这意味着您的域逻辑代码通常不依赖于框架本身。在您的集成层（例如数据访问层）中，将存在对数据访问技术和Spring库的某些依赖关系。但是，将这些依赖项与其余代码库隔离起来应该很容易。Spring的两大核心特征：IoC（控制反转），AOP（面向切面编程）。IoC作用：把对象的控制权交给容器管理。AOP作用：面向切面编程（比如日志打印），底层使用动态代理实现。Spring框架包含组织为约20个模块的功能。这些模块分为核心容器，数据访问/集成，Web，AOP（面向方面的编程），检测，消息传递和测试。Spring的整个完整框架来说，其设计原则则是"对扩展开放，对修改闭合"（OOP设计原则）。当然Spring还有很多强大的功能，这里先简单介绍一下，点到为止。
　　
　　2. Spring MVC
　　
　　Spring MVC是基于Servlet API构建的原始web框架，从一开始就已经包含在就包含在Spring框架中，与Spring框架无缝对接。全称应该为Spring Web MVC，其来源于模块spring-webmvc。但是，通常我们叫它Spring MVC（习惯）。Spring MVC框架是围绕一个 DispatcherServlet （核心控制器）来设计的，这个 Servlet会把请求分发给各个处理器，并支持可配置的处理器映射、视图渲染、本地化、时区与主题渲染等，甚至还能支持文件上传。"对扩展开放"是Spring Web MVC框架一个重要的设计原则。Spring Web MVC核心类库中的一些方法被定义为 final 方法。Sp'ring MVC的数据绑定非常灵活方便，视图解析也设计的非常灵活与方便，并且提供了好多功能强大的注解机制。当然，Spring MVC的强大之处不是一两句话可以搞定的，我们应该参考其文档，并且深入学习钻研，最好研究研究源码。这里话不多说，点到为止。
　　
　　3. Spring MVC处理（jQuery）Ajax请求(前台不发送数据，后台返回普通字符串)
　　
　　开发环境：Eclipse+Tomcat+Spring MVC+Jackson+JSP+jQuery+Ajax
　　
　　本篇博客比较长，原本是一个小的demo，写这么长不值，不，我认为值，因为我感觉自己写的还可以（哈哈！装一波），这些都是笔者一字一句写的，当然有参考一些东西（本人最讨厌复制粘贴），加上自己的理解，涉及到代码完全认真实践过，自己从头到尾写一遍，也是对自己知识的积累以及经验的提升，Spring MVC文档和Spring文档等，请大家认真看下去，看完这篇，你不仅掌握了Ajax，认识了Spring的好处，还会熟知Spring MVC的执行流程，还会接触到有趣的日志打印。当然也可以免费获取jar包（有源码链接），百度都有（基本都免费）。所以普通的一些jar包都是免费的，没有必要花一些代价去活得开发包。本质来说，框架只是个模板，我们遵从框架的规范来开发就行了，毕竟使用一些框架是我们的开发变得简单高效，笔者认为还是应该了解一下底层核心的原理比较好，这样便于在我们开发的时候遇到bug的时候可以迅速做出决策和解决。写博客，我是认真的。
　　
　　（1）搭建环境
　　
　　Eclipse中新建Java Web项目，并把项目部署到Tomcat容器中。下面是项目的结构：
　　
　　项目基本结构很简单，没啥可说的。这里说一下lib里面的jar包。既然我们想使用Spring MVC进行开发，必须导入其开发包。上面说了，Spring MVC其实是集成在Spring中的，所以也是导入Spring开发包。本次使用spring-framework-4.0.0.RELEASE开发包。
　　
　　Spring开发包：spring-aop面向切面编程所用到的包。spring-aspects提供对AspectJ（面向切面的一个框架）的支持，spring-beans包含访问配置文件，创建和管理Bean以及进行控制反转和依赖注入操作相关的所有类。spring-core是Spring的核心包（核心工具类）。spring-expression是Spring的表达式语言，spring-jdbc它包含了spring 与 JDBC 数据访问时进行封装的所有类，提供使用springjdbc的最佳实现（利用jdbc template）。spring-orm是Spring对DAO特性进行扩展，支持一些ORM（对象关系映射）框架（比如MyBatis和Hibernate等）。spring-test提供了对Junit等测试框架的简单封装，这让我们在对Spring的代码进行测试时更加方便和快捷。spring-tx包为JDBC、Hibernate、JDO、JPA等提供了一致的声明式的编程式事物管理。spring-web包含web应用研发时用到Spring框架时所需要的的核心类。spring-webmvc包含了Spring webmvc框架相关的所有类。
　　
　　log4j日志信息包。不导这个包的话会报错。
　　
　　Jasckson三个包（前几篇博客说过好多遍）。这里导入Jackson包的原因说一下。1. Spring MVC内置的json与对象转换器依赖于Jackson类库。（底层通过对Jackson的一些方法进行封装实现）。2. 简单好用我感觉，效率也还可以。当然也可以实现自己的json与对象的转换器（题外话）。
　　
　　com.springsource三个jar包，主要是为了提供Spring对Apache的一些服务的支持。Tomcat就是Apache的，不导这3个包的话会报错。当然，这里只是导入了spring的一部分常用的包，还有其他的（自己百度下spring开发包，在里面找找），本次开发也没把这些spring包全部用到，主要是为了着重介绍一下。好了，jar包说完了。下面进行开发。这里不使用任何注解的目的说一下，只是基于XML配置实现。其实我们使用注解会简单方便很多（后面会有更新的），此篇文章主要是为了便于大家熟悉Spring MVC的执行流程，并使用它最最原始的一些配置以及方法。方便大家了解更深层次的东西，以及深入了解Spring MVC一些核心的东西。因为我们天天使用注解，但是估计我们都没了解过注解的机制以及原理，注解有什么用。以及注解代替了那些我们之前开发比较繁杂的操作以及方法。有时候我们研究一些东西，不能只停留在表面会使用就行了，我们深入到底层的话会有意想不到的收获及理解。
　　
　　（2）编写jsp文件
　　
　　复制代码
　　
　　<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
　　
　　<%
　　
　　String path = request.getContextPath();
　　
　　String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
　　
　　+ path + "/";
　　
　　%>
　　
　　<!DOCTYPE html>
　　
　　<html>
　　
　　<head>
　　
　　<base href="<%=basePath%>">
　　
　　<title>I LOVE YOU</title>
　　
　　<link rel="stylesheet" type="text/css" href="">
　　
　　<script type="text/javascript" src="index.js"></script>
　　
　　<script type="text/javascript" src="jquery-3.2.1.min.js"></script>
　　
　　</head>
　　
　　<body>
　　
　　<button id="mybutton1" value="springmvc处理ajax请求" οnclick="fun1()" >（jquery）ajax请求（不发送数据）</button>
　　
　　<spand id="show1" />
　　
　　<br/>
　　
　　<hr/>
　　
　　</body>
　　
　　复制代码
　　
　　很简单，定义了一个按钮。并调用js文件相关的函数进行处理，<span>标签是为了显示内容。页面引入自定义的js文件和jQeury的js文件（注意名称和路径）。
　　
　　（3）编写js文件
　　
　　复制代码
　　
　　/**
　　
　　*
　　
　　*/
　　
　　//使用jquery提交ajax请求（不携带数据）
　　
　　function fun1(){
　　
　　$.ajax({
　　
　　type:"POST", //发送方式
　　
　　url:"UserController1", //请求地址
　　
　　data:"", //数据为空
　　
　　success:function(data){ //成功后的回调函数
　　
　　$("#show1").html(data); //页面展示内容
　　
　　}
　　
　　});
　　
　　}
　　
　　复制代码
　　
　　很简单，就写了一个fun1()函数。用来响应按钮。虽然说，讨论客户端不发送数据没多大意义，这里我们还是讨论一下吧。在学习java基础的时候，我们还经常讨论"空"呢。不是吗？这里主要是为了熟悉一下代码执行的流程，毕竟我们学习的过程是由浅入深的。闲话少叙。
　　
　　（4）编写controller类
　　
　　复制代码
　　
　　package com.controller;
　　
　　import java.io.IOException;
　　
　　import javax.servlet.ServletException;
　　
　　import javax.servlet.http.HttpServletRequest;
　　
　　import javax.servlet.http.HttpServletResponse;
　　
　　import org.springframework.web.HttpRequestHandler;
　　
　　public class UserController1 implements HttpRequestHandler{
　　
　　@Override
　　
　　public void handleRequest(HttpServletRequest request, HttpServletResponse response)
　　
　　throws ServletException, IOException {
　　
　　// TODO Auto-generated method stub
　　
　　response.setCharacterEncoding("UTF-8");
　　
　　String str = "我是一个 springmvc";
　　
　　try {
　　
　　response.getWriter().print(str);
　　
　　} catch (IOException e) {
　　
　　// TODO Auto-generated catch block
　　
　　e.printStackTrace();
　　
　　}
　　
　　}
　　
　　}
　　
　　复制代码
　　
　　这里定义了一个controller类，并且实现了HttpRequestHandler接口，并实现接口中的抽象方法。方法中定义了一个字符串，利用response获取打印流进行输出即可。Spring MVC中。一般在我们编写controller(也就是一个handler，用来处理客户端的请求)，要能被Sping MVC识别它是一个controller类，因为这里没有用到注解。所以我们有2种方法。
　　
　　第一种：编写controller类，实现org.springframework.web.servlet.mvc.Controller接口，然后交给核心控制器调用相对应的处理器适配器进行处理。不过，实现了Controller，就必须实现其中的抽象方法public abstract ModelAndView handleRequest(HttpServletRequest request， HttpServletResponse response)。这个方法必须返回一个ModelAndView对象，而我们所作的是对字符串数据和json数据的处理。所以在这里我们并没有选择实现Controller接口。
　　
　　第二种：编写controller类，实现org.springframework.web.HttpRequestHandler接口，然后交给核心控制器调用相应的处理器适配器进行处理，并实现其中的抽象方法。自己可以百度一下Spring MVC的执行流程，这里不多说。
　　
　　public abstract void handleRequest(HttpServletRequest request, HttpServletResponse response) 我们注意到，这个方法是没有返回值的，所以就方便了我们对字符串数据和json数据的处理。注意到有2个参数request和response(这是Servlet的东西)。Spring MVC支持的支持的参数类型：
　　
　　HttpServletRequest 对象，HttpServletResponse 对象，HttpSession 对象，Model/ModelMap 对象。这里我们用到了其中的2个。
　　
　　（5）配置web.xml
　　
　　复制代码
　　
　　<?xml version="1.0" encoding="UTF-8"?>
　　
　　<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
　　
　　<display-name>MySpringMVCAjax</display-name>
　　
　　<welcome-file-list>
　　
　　<welcome-file>index.jsp</welcome-file>
　　
　　</welcome-file-list>
　　
　　
　　
　　<servlet>
　　
　　<servlet-name>springmvc</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>
　　
　　</servlet>
　　
　　<servlet-mapping>
　　
　　<servlet-name>springmvc</servlet-name>
　　
　　<url-pattern>/</url-pattern>
　　
　　</servlet-mapping>
　　
　　
　　
　　<servlet-mapping>
　　
　　<servlet-name>default</servlet-name>
　　
　　<url-pattern>/static/*</url-pattern>
　　
　　</servlet-mapping>
　　
　　<servlet-mapping>
　　
　　<servlet-name>default</servlet-name>
　　
　　<url-pattern>*.js</url-pattern>
　　
　　</servlet-mapping>
　　
　　<servlet-mapping>
　　
　　<servlet-name>default</servlet-name>
　　
　　<url-pattern>*.css</url-pattern>
　　
　　</servlet-mapping>
　　
　　
　　
　　<filter>
　　
　　<filter-name>SpringCharacterEncodingFilter</filter-name>
　　
　　<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
　　
　　<init-param>
　　
　　<param-name>encoding</param-name>
　　
　　<param-value>UTF-8</param-value>
　　
　　</init-param>
　　
　　<init-param>
　　
　　<param-name>forceEncoding</param-name>
　　
　　<param-value>true</param-value>
　　
　　</init-param>
　　
　　</filter>
　　
　　<filter-mapping>
　　
　　<filter-name>SpringCharacterEncodingFilter</filter-name>
　　
　　<url-pattern>/*</url-pattern>
　　
　　</filter-mapping>
　　
　　</web-app>
　　
　　复制代码
　　
　　这里我们配置了三个东西。
　　
　　第一个，配置Spring核心控制器。Sping MVC核心控制器（前端控制器或中央处理器）org.springframework.web.servlet.DispatcherServlet，DispatcherServlet 其实就是个 Servlet （它继承自 HttpServlet 基类），同样也需要在你 web应用的 web.xml 配置文件下声明。你需要在 web.xml 文件中把你希望 DispatcherServlet 处理的请求映射到对应的URL上去。这就是标准的Java EE Servlet配置。DispatcherServlet就是一个Sping MVC处理请求的一个中央处理器，负责调度处理器映射器，处理器适配器以及视图解析器。配置初始化参数来加载Sping MVC的主配置文件springmvc.xml，这里我们把它放在src目录下。
　　
　　第二个，给静态资源放行。这里注意一下。我们在核心控制器<url-pattern>标签下配置的是 / ，表示所有访问的url都交给核心控制器去处理，这样导致有可能加载不到静态资源文件（js,css,img）。解决办法：
　　
　　第一种：在springmvc.xml文件中配置<mvc:default-servlet-handler />（比较高级的方法）
　　
　　第二种：对静态资源进行放行，如我们web.xml所示。当然，也可以在spring.xml文件进行放行，语法为：
　　
　　<resources location="/js/" mapping="/js/**" />
　　
　　<resources location="/css/" mapping="/css/**" />
　　
　　<resources location="/images/" mapping="/images/**" />
　　
　　这里使用web.xml对静态资源进行放行，主要是因为这个方法简单易懂。后面我会对博客内容进行更新升级，再采取比较高级的方法。
　　
　　第三种：配置核心控制器时，把<url-pattern>标签设置为 *.do 或者 .action就好了。表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析。这种方法也可以，但是到时访问路径的时候要加上这个后缀，看起来不太舒服（有一点强迫症的人应该懂）。当然笔者估计没有吧。笔者只是采取一些简单说不上高效的方法。
　　
　　第三个，就是配置spring提供编码过滤器。web.xml配置的编码过滤器为了防止前端传入的中文数据出现乱码问题，使用Spring提供的编码过滤器来统一编码。配置为UTF-8。当然也可以使用GBK等其他编码。GBK编码方式的编码是以中国国情而创造的，在国际上的兼容性不好，这也是为什么大多数的网页是使用UTF-8编码而不是GBK。UTF-8好处：兼容ASCII，存储英文文件都是单字节，文件小。在eclipse中把项目的编码也设置为UTF-8，JSP页面中字符编码也设置为UTF-8。浏览器网页字符编码也设置为UTF-8。反正就是统统UTF-8的样子。做这么多主要是统一编码，解决中文乱码乱码问题。因为以前使用servlet和struts2的时候，经常出现中文乱码问题，让人摸不着什么头脑。所以。Spring提供的这个编码过滤器就比较方便好用了。所以说Spring是一个神奇的东西。我们研读一下Spring源码，看看Spring开发的文档，就可以汲取一些精华（精髓）。Spring提供的编码过滤器，org.springframework.web.filter.CharacterEncodingFilter类，注意把路径写正确。初始化参数（也就是编码）encoding为UTF-8。Spring里的字符过滤器CharacterEncodingFilter是针对请求的，forceEncoding=true是意思是指无论客户端请求是否包含了编码，都用过滤器里的编码来解析请求。forceEncoding默认为false。forceEncoding为true效果： request.setCharacterEncoding("UTF-8")；forceEncoding为false的效果：
　　
　　request.setCharacterEncoding("UTF-8")； response.setCharacterEncoding("UTF-8")。 <url-pattern>标签配置的/*代表过滤所有请求，从而将编码设置为UTF-8。好了。web.xml到此结束。其实有时候我们只是开发一个简单的小例子demo，看起来很简单。但是我们要了解底层到底是怎么实现的。比如Java的底层，JVM(Java虚拟机)用c/c++编写，Java类库用Java语言编写。还有比如native本地方法，其底层本质也是c/c++编写的，Java只是调用了它的接口。这也就解释了为什么native方法效率一般比较高。那么问题来了，c语言用什么编写的 ? 这个可以自行谷歌或百度，这里不多说。当然，一个项目或者工作的执行流程我们也必须熟知。这次开发看起来很简单，但是我们把涉及到的知识内容都会为大家详细讲解，并且都是本人一字一句经过推敲实践进行编写的。当然，本人也是菜鸟一枚。知识有限。但是我们可以经过学习来获取更多的知识，提升自己的能力，从而达到人生的巅峰。不多说了（跑题了，哈哈！）。
　　
　　（6）配置springmvc.xml文件
　　
　　复制代码
　　
　　<?xml version="1.0" encoding="UTF-8"?>
　　
　　<beans
　　
　　xmlns="http://www.springframework.org/schema/beans"
　　
　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　
　　xmlns:mvc="http://www.springframework.org/schema/mvc"
　　
　　xmlns:context="http://www.springframework.org/schema/context"
　　
　　xsi:schemaLocation="
　　
　　http:// www.lanboylpt.cn /schema/beans
　　
　　http://www.springframework.org/schema/beans/spring-beans.xsd
　　
　　http://www.springframework.org/schema/mvc
　　
　　http://www.LanboyLgw.com /schema/mvc/spring-mvc.xsd
　　
　　http://www.springframework.org/schema/context
　　
　　http://www.springframework.org/schema/context/spring-context.xsd">
　　
　　
　　
　　<bean id="user" class="com.pojo.User" />
　　
　　
　　
　　<bean name=www.chenghylpt.com "/UserController1" class="com.controller.UserController1" />
　　
　　<bean name="/UserController2" class="com.controller.UserController2" />
　　
　　<bean name="/UserController3" class="com.controller.UserController3" />
　　
　　
　　
　　<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
　　
　　
　　
　　<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>
　　
　　
　　
　　<bean id="myconverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
　　
　　
　　
　　<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
　　
　　<property name="prefix" value="/"></property>
　　
　　<property name="suffix" value=".jsp"></property>
　　
　　</bean>
　　
　　</beans>
　　
　　复制代码
　　
　　springmvc.xml是本次开发的主配置文件。通过观察得知，顶层标签<beans>包含了许多bean模块。Spring Bean其实就是是被实例的，组装的及被Spring 容器管理的Java对象。一个bean相当于一个实体类对象，通过IoC（控制反转，也叫依赖注入）我们可以把bean注入到容器当中，交给Spring容器管理（比如bean的实例化）。这样做的目的其实解耦合。因为软件设计的原则就是高内聚，低耦合。Spring默认的bean实例是单例的，我们可以用scope属性来设置bean的作用域。scope可以接受Singleton（单例模式，每次获取bean只有一个实例）、prototype（原型模式，每次获取bean都会产生新的实例）、request(每次HTTP request请求都会产生不同的Bean实例)、session(每次HTTP session请求都会产生不同的Bean实例)、global session (每个全局的HTTPSession对应一个Bean实例。仅在portlet Context的时候才有效。)5个值。我们常用单例模式，因为创建对象本身代价比较高，耗费资源，单例的本身也满足我们的需求了。当然我们也可以根据不同的需求设置不同的scope，这本无可厚非。还有，注意一下引入的xsd文件，Spring文件中的引用的xsd文件是用于校验xml文件的格式用的。Spring默认在启动时是要加载XSD文件来验证xml文件的。相当于是约束文件。这里我们引入了三个xsd文件，spring-beans-xsd包含对bean的解释。sprng-mvc.xsd包含了对<mvc>等标签的解释，spring-context.xsd包含对context的解释，这里我们其实只用到了spring-beans.xsd约束文件。
　　
　　我们具体看一下配置了什么东西。
　　
　　1. 把User实体类注入到容器（下面会贴User类的代码，这里暂时还没用到）。相当于是通过<bean>标签来装配一个User类，我们就可以通过获取bean来达到获取User实体对象的目的。设置bean的id(一个bean的唯一标识)和class（类的全包路径包.类）。
　　
　　2. 配置controller（也就是handler，处理客户端请求）。这里我们配置了好三个controller。我们看UserController1(对应上面的方法UserController1)的配置，配置了一个name和class。Spring MVC要识别请求的url，就是通过调用处理器映射器获取到这个name的名称，找到controller类，然后交给处理器设配器去处理controller。相当于就是映射路径。注意名称前要加上/ 不然无法识别。这里我们设置name=”/UserController1“和类名保持一致（为了方便），当然也可以起其他名字，别忘了/，前台提交的url和此处name的名称要保持一致。class为UserController1的全包类路径。
　　
　　3. 配置处理器映射器BeanNameUrlHandlerMapping。不需要指定id，只配置全类路径即可，即class。这个处理器映射器，将bean的name作为url进行查找，需要在配置Handler时指定bean的 name（url）。
　　
　　查看spring-webmvc包下面的DispatcherServlet.properties 资源文件：
　　
　　复制代码
　　
　　# Default implementation classes for DispatcherServlet's strategy interfaces.
　　
　　# Used as fallback when no matching beans are found in the DispatcherServlet context.
　　
　　# Not meant to be customized by application developers.
　　
　　org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
　　
　　org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
　　
　　org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
　　
　　org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
　　
　　org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
　　
　　org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
　　
　　org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
　　
　　org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
　　
　　org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
　　
　　org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
　　
　　org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
　　
　　org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
　　
　　org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
　　
　　复制代码
　　
　　Spring MVC的处理器映射器，常用的有2个，一个是org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping，继承了
　　
　　AbstractDetectingUrlHandlerMapping抽象类，它又向上继承了AbstractUrlHandlerMapping抽象类，它又向上继承了AbstractHandlerMapping，
　　
　　AbstractHandlerMapping抽象类实现了HandlerMapping接口。
　　
　　另一个是org.springframework.web.servlet.handler.SimpleUrlHandlerMapping，继承了AbstractUrlHandlerMapping抽象类，
　　
　　AbstractUrlHandlerMapping继承了AbstractHandlerMapping抽象类，AbstractHandlerMapping实现了org.springframework.web.servlet.HandlerMapping
　　
　　接口。观察资源文件发现，BeanNameUrlHandlerMapping是Spring MVC的默认处理器映射器，这里我们就使用这个。若要使用SimpleUrlHandlerMapping，
　　
　　我们根据它的语法来就行了。可以这样配置：
　　
　　复制代码
　　
　　bean id="UserController1" class="com.controller.UserController1" />
　　
　　
　　
　　<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
　　
　　<property name="mappings">
　　
　　<props>
　　
　　<prop key="/UserController1">UserController1</prop>
　　
　　</props>
　　
　　</property>
　　
　　</bean>
　　
　　复制代码
　　
　　当然这两种处理器映射器配置可以并存，核心控制器会正确的去判断 url 用哪个 Handler 去处理。
　　
　　注意这个上面资源文件的处理器映射器DefaultAnnotationHandlerMapping，通过查看源码，它已经被废弃了。被抛弃的感觉不好受啊。
　　
　　（估计DefaultAnnotationHandlerMapping的内心是崩溃的）。
　　
　　4. 配置处理器适配器。不需要指定id，class为全类路径。核心控制器调用处理器映射器找到了Controller类，那么谁来处理这个Controller呢。那么此时处理器适配器就闪亮登场了。什么是处理器适配器呢。且听下回分解，本章完。。。（皮一下）。通过观察以上资源文件。我们发现。Spring MVC的处理器适配器，常用的有2个。
　　
　　一个是org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter，一个是org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter
　　
　　这2个类都实现了HandlerAdapter接口。SimpleControllerHandlerAdapter处理的Handler必须实现Conreoller接口，一般返回一个ModelAndView对象。
　　
　　HttpRequestHandlerAdapter处理的Handler必须实现HttpRequestHandler接口，一般用来处理字符串或者json数据。因为其抽象方法没有返回值。AnnotationMethodHandlerAdapter已经废弃了，不多说。当然两种适配器可以共存，配置不同的映射器找到不同的controller。
　　
　　Spring MVC默认的处理器适配器是HttpRequestHandlerAdapter 。
　　
　　5. 配置视图解析器。不需要指定id，class为全类路径。我们这里用的是InternalResourceViewResolver，配置它的class路径，注意有2个属性。prefix表示返回视图页面的前缀，suffix表示返回视图页面的后缀。比如一般我们要视图解析完成后返回一个页面index.jsp时，prefix相当于配置的是其根目录（在哪儿），suffix就是.jsp，这样在我们使用注解进行开发的时候，只需要返回一个字符串"index"就行了。上面那样配置，表示在 Handler 中只需要返回在 WebContent根目录下的jsp 文件名就ok了（为了简单方便，开发比较高效）。视图解析器作用它负责将一个代表逻辑视图名的字符串（String）映射到实际的视图类型 View 上。通过以上资源文件发现。注意HandlerExceptionResolver处理器异常解析器。它负责将捕获的异常映射到不同的视图上去，此外还支持更复杂的异常处理代码。Spring MVC的视图解析器这里介绍3种：
　　
　　第一种：使用ViewResolver接口解析视图
　　
　　org.springframework.web.servlet.view.InternalResourceViewResolver类，通过连续向上继承，实现org.springframework.web.servlet.ViewResolver接口。在实际应用中InternalResourceViewResolver也是使用的最广泛的一个视图解析器。本次开发就用的是这个视图解析器。这个比较常用。InternalResourceViewResolver解析器可以解释为内部资源视图解析器。InternalResourceViewResolver会把返回的视图名称都解析为InternalResourceView对象，InternalResourceView会把Controller处理器方法返回的模型属性都存放到对应的request属性中，然后通过RequestDispatcher在服务器端把请求forword重定向到目标URL。
　　
　　接口中的方法：通过传来的参数解析视图，并返回一个View对象。注意Handler类实现Conteoller接口方法时，就返回了一个ModelAndView对象。ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model 和 View。
　　
　　public abstract interface ViewResolver
　　
　　{
　　
　　public abstract View resolveViewName(String paramString, Locale paramLocale)
　　
　　throws Exception;
　　
　　}
　　
　　第二种：使用RequestToViewNameTranslator接口解析视图。DefaultRequestToViewNameTranslator为这个接口的实现子类。
　　
　　这个接口定义了一个抽象方法
　　
　　public abstract interface RequestToViewNameTranslator
　　
　　{
　　
　　public abstract String getViewName(HttpServletRequest paramHttpServletRequest)
　　
　　throws Exception;
　　
　　}
　　
　　表示根据request请求返回一个视图名称的字符串。
　　
　　第三种：使用FlashMapManager接口解析视图。SessionFlashMapManager为这个接口的实现子类。
　　
　　FlashMap管理器。它能够存储并取回两次请求之间的 FlashMap 对象。后者可用于在请求之间传递数据，通常是在请求重定向的情境下使用。
　　
　　这个接口定义的方法：自己看看就好了，在这里不做过多介绍。
　　
　　public abstract interface FlashMapManager
　　
　　{
　　
　　public abstract FlashMap retrieveAndUpdate(HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse);
　　
　　public abstract void saveOutputFlashMap(FlashMap paramFlashMap, HttpServletRequest paramHttpServletRequest, HttpServletResponse paramHttpServletResponse);
　　
　　}
　　
　　Map肯定时用来保存数据的。RedirectView在页面跳转，数据的保存依赖于FlashMap和FlashMapManger，FlashMapManger在容器初始化时被填入，而FlashMap从Manger可以获取。
　　
　　5. 配置json与对象的转换器。这里暂时用不到。下面会解释。先跳过。其实Spring MVC内置的json与对象的转换器底层还是用Jasckson类库实现。
　　
　　（7）配置log4j.properties日志文件
　　
　　复制代码
　　
　　### set log levels ###
　　
　　log4j.rootLogger = INFO , console , D
　　
　　### console ###
　　
　　log4j.appender.console = org.apache.log4j.ConsoleAppender
　　
　　log4j.appender.console.Target = System.out
　　
　　log4j.appender.console.layout = org.apache.log4j.PatternLayout
　　
　　log4j.appender.console.layout.ConversionPattern = %-d{yyyy-MM-dd HH\:mm\:ss} [%p]-[%c] %m%n
　　
　　### log file ###
　　
　　log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
　　
　　log4j.appender.D.File =../logs/IvaDubboWeb-info.log
　　
　　log4j.appender.D.Append = true
　　
　　log4j.appender.D.Threshold = INFO
　　
　　log4j.appender.D.layout = org.apache.log4j.PatternLayout
　　
　　log4j.appender.D.layout.ConversionPattern = [%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n
　　
　　### out zhiding log file ###
　　
　　log4j.logger.haha = INFO, haha
　　
　　log4j.additivity.haha = false
　　
　　log4j.appender.haha = org.apache.log4j.DailyRollingFileAppender
　　
　　log4j.appender.haha.File =D:/logs/mylog.log
　　
　　log4j.appender.haha.Append = true
　　
　　log4j.appender.haha.Threshold = INFO
　　
　　log4j.appender.haha.layout = org.apache.log4j.PatternLayout
　　
　　log4j.appender.haha.layout.ConversionPattern = [%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n
　　
　　复制代码
　　
　　Log4j简单介绍：
　　
　　Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护线程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。Log4j有三个主要的组件：Loggers(记录器)，Appenders (输出源)和Layouts(布局)。这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松地记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。
　　
　　1. 配置根logger，日志输出级别为INFO级别。log4j的输出级别：TRACE < DEBUG < INFO < WARN < ERROR < FATAL。比INFO级别高的也会打印输出，比INFO低的不会输出。
　　
　　2. 配置console，在eclipse的控制台打印日志信息。
　　
　　3. 配置输出到文件。一个是输出到一般性文件中，另一个是输出到我们指定的文件中。很简单。(笔者对log4j还琢磨了半天，主要是了解日志打印到底是什么玩意儿)。
　　
　　对上面log4j简单测试一下（注意要导入log4j开发包和单元测试JUinit包，并把log4j.properties文件放在src目录下）。打印到控制台：
　　
　　复制代码
　　
　　package com.log4j;
　　
　　import org.apache.log4j.Logger;
　　
　　import org.junit.Test;
　　
　　public class Log4jTest {
　　
　　@Test
　　
　　public void test() {
　　
　　// BasicConfigurator.configure(); //自动快速地使用缺省Log4j环境。
　　
　　Logger logger = Logger.getLogger(Log4jTest.class);
　　
　　logger.info("log4j");
　　
　　logger.info("是");
　　
　　logger.error("什么");
　　
　　logger.debug("呢");
　　
　　}
　　
　　}
　　
　　复制代码
　　
　　运行效果：debug级别比INFO低，无输出。

liudahai777

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Sping MVC不使用任何注解处理（jQuery）Ajax请求（基于XML配置）

　　1. Spring　　　　Spring框架是一个轻量级的解决方案，是一个潜在的一站式商店，用于构建企业就绪的应用程序。Spring框架是一个Java平台，为开发Java应用程序提供全面的基础架构支持。Spring处理基础结构，因此您可以专注于应用程序。Spring使您能够从“普通的Java对象”（POJO）构建应用程序，并将企业服务非侵入性地应用于POJO。此功能适用于Java SE编程模...
复制链接

扫一扫