第七章：Springmvc中applicationContext.xml配置文件应用上下文详解

主要配置程序的总体用上下文，让容器对全局掌握来龙去脉
1.扫描所有项目的包名
2.配置项目所有的静态资源映射
3.配置请求方法的映射驱动
4.配置适配器适配@RequestMapping注解标注的Handler（HandlerMethod类型）
5.配置消息转换器决定浏览器以什么样的形式解析响应的消息
6.配置视图解析器即如何从服务器端转向具体页面解析
7.配置上传文件的大小限制

头文件

<?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"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
               
               http://www.springframework.org/schema/mvc
       		   http://www.springframework.org/schema/mvc/spring-mvc.xsd
               http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.3.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
               ">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.扫描所有项目的包名–注入容器

作用：扫描包及其子包下的所有带注解的类，注入Spring的bean。
如果有@Component(组件)、@Service（服务）、@Controller（控制器）、@Repository（数据仓库）构造型（stereotype）注解所标注的类，则将对象作为Bean注册注入到Spring IOC容器中。
举例：
在注解后加上例如@Component(value=”a”)时，注册的这个类的bean的id就是a.

#base-package指明一个包，多个包用逗号隔离开
#扫描这个包下所有项目
<context:component-scan base-package="com.test"></context:component-scan>
#扫描多个指定多个包下的所有项目，逗号隔离开
<context:component-scan base-package="com.test1.xxx,com.test2.xxx"/>
多个包逗号隔开。
1
2
3
4
5
6

2.配置项目所有的静态资源的映射（放行资源）

作用：自定义请求项目内静态资源的访问路径URL规则。
目的：为了访问或者加载项目内静态资源。
SpringMVC的配置文件中使用mvc:resource标签来设置要放行的静态资源
mvc:resources 加入后框架会创建ResourceHttpRequestHandler这个处理器对象。 让这个对象处理静态资源的访问，不依赖tomcat服务器。
注意： css，js，images文件夹放于WebContent目录下。

	<mvc:resources mapping="/jspath/**" location="/js/" />
	<mvc:resources mapping="/imgpath/**" location="/img/" />
	<mvc:resources mapping="/csspath/**" location="/css/" />
#静态资源解释：以配置的js为例
mapping和@RequestMapping区别
mapping： 访问静态资源的uri地址，使用通配符 **  意思是代表某个映射规则下所有请求形式
location：静态资源在你的项目中的目录位置。
1.mapping中定义的是访问静态资源的url，最前面的/表示的是WebContent根目录，后面的js是WebContent目录下的js文件夹或者子目录，最后的**表达多层路径（可能是一层或者多层路径）
2.location中定义的是根目录下的js文件位置
举例：比如 /js/login/login.js  如何访问login.js？？？
假设整个项目的包名为Shopping
根据mapping定义的访问规则映射访问项目中静态资源。
localhost:8080/Shopping/jspath/login.js 这个url就能访问到location=“/js/”这是项目中静态资源所在的位置
1
2
3
4
5
6
7
8
9
10
11
12
13

当然，为了方便，也可以把images、js、html等文件夹都放到一个文件夹下（创建static文件夹）

<mvc:annotation-driven />
<mvc:resources mapping = "/static/**" location = "/static/" />
<!-- static/**表示该目录下所有文件-->
1
2
3

3.配置静态资源方法的映射驱动

spring配置文件中启动mvc注解驱动
mvc:annotation-driven
静态资源乱码StringHttpMessageConverter引出的客户端服务器端之间的乱码配置两种方式
使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter

#第一种方式
<mvc:annotation-driven>
#处理静态资源请求和返回乱码问题
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
              <constructor-arg value="UTF-8" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
#第二种方式
<mvc:annotation-driven >
        <!-- 消息转换器，添加对文字编码的全局处理，解决中文返回问号的毛病 --> 
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes" value="text/html;charset=UTF-8"/>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
#第三种方式
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <!-- String 转换器 -->
               <ref bean="stringHttpMessageConverter"/>
                <!-- JSON 转换器 -->
                <ref bean="jsonHttpMessageConverter"/>
                <!-- XML 转换器 -->
            </list>
        </property>
</bean>
    
    <!-- <bean id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter"/> -->
 
<bean id="jsonHttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
        <property name = "supportedMediaTypes">
             <list>
                 <value>text/html;charset=UTF-8</value>  
                 <value>text/plain;charset=UTF-8</value>  
            </list>   
       </property>   
</bean>
<bean id="stringHttpMessageConverter"
          class="org.springframework.http.converter.StringHttpMessageConverter">
        <property name = "supportedMediaTypes">
             <list>
            	 <value>text/html;charset=UTF-8</value> 
                 <value>text/plain;charset=UTF-8</value>   
            </list>   
       </property> 
</bean>    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

如果GET方式请求页面依然出现乱码的情况，可以在view中请求的jsp页面的第一行，添加如下jsp代码：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
1
2

标签是为了解决resources标签 和@RequestMapping注解的冲突。

1

在我们设置
<url-pattern>/</url-pattern>后，
动态资源和静态资源的访问就会造成冲突，我们此时就需要配置另外静态资源
一、<mvc:default-servlet-handler />标签
在springmvc配置文件中加入
<mvc:annotation-driven />
<mvc:default-servlet-handler />
原理是：
加入<mvc:default-servlet-handler />标签后，
框架会创建控制器对象DefaultServletHttpRequestHandler（类似我们自己创建的Controller对象）。
DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给tomcat的default这个servlet。
----------------------------------------------------
<mvc:annotation-driven />标签是为了解决default-servlet-handler标签
和@RequestMapping注解的冲突。
------------------------------------------------
二、<mvc:resources />标签
mvc:resources 加入后框架会创建ResourceHttpRequestHandler这个处理器对象。
让这个对象处理静态资源的访问，不依赖tomcat服务器。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注解意义
提供Controller请求转发，json自动转换等功能

0.HttpServletResponse 对象写回数据，HttpServletRequest对象带回数据，ModelandView对象带回数据
或者@ResponseBody将字符串数据返回对象或集合@ResponseBody和<mvc:annotation-driven/>
1.提供Controller请求转发，json自动转换等功能。
2.解决了@Controller注解的使用前提配置<context:annotation-config/>是对包进行扫描，
实现注释驱动Bean定义，将bean自动注入容器中使用。即解决了@Controller标识的类的bean的注入和使用
3.自动注册RequestMappingHandlerMapping与RequestMappingHandlerAdapter两个Bean
4.提供数据绑定支持
5.@NumberFormatannotation支持，@DateTimeFormat支持,@Valid支持读写XML的支持（JAXB）和读写JSON的支持（默认Jackson）等功能。
6.处理响应ajax请求时，就使用到了对json的支持
7.写JUnit单元测试时，要从spring IOC容器中取DefaultAnnotationHandlerMapping
与AnnotationMethodHandlerAdapter 两个bean来完成测试，这是通过<mvc:annotation-driven />
注册的这两个bean
1
2
3
4
5
6
7
8
9
10
11
12

4.配置消息转换器

json消息转换器
spring默认使用的json消息转换器是MappingJackson2HttpMessageConverter，spring3是使用MappingJacksonHttpMessageConverter。
类MappingJackson2HttpMessageConverter是实现json序列化和反序列化的核心。

<!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->
	<bean	class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
		<property name="messageConverters">
			<list>
				<!--json转换器 -->
				<ref bean="testMessageConverter" />
			</list>
		</property>
	</bean>
	<bean  class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<property name="messageConverters">
			<list>
				<ref bean="testMessageConverter" />
			</list>
		</property>
	</bean> 
<bean  id="testMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
		<property name="supportedMediaTypes">
			<list>
				<bean class="org.springframework.http.MediaType">
					<constructor-arg index="0" value="text" />
					<constructor-arg index="1" value="plain" />
					<constructor-arg index="2" value="UTF-8" />
				</bean>
				<bean class="org.springframework.http.MediaType">
					<constructor-arg index="0" value="*" />
					<constructor-arg index="1" value="*" />
					<constructor-arg index="2" value="UTF-8" />
				</bean>
				<bean class="org.springframework.http.MediaType">
					<constructor-arg index="0" value="text" />
					<constructor-arg index="1" value="*" />
					<constructor-arg index="2" value="UTF-8" />
				</bean>
				<bean class="org.springframework.http.MediaType">
					<constructor-arg index="0" value="application" />
					<constructor-arg index="1" value="json" />
					<constructor-arg index="2" value="UTF-8" />
				</bean>
			</list>
		</property>
</bean>  
------------------------代码测试1---------------------------
var parameter= {
		"name":"zhangsan",
		"age": 18
	};
	$.ajax({
		url:"testurl",
		type:"post",
		data:JSON.stringify(parameter), //参数转换成json对象
		contentType:"application/json;charset=UTF-8",//告诉收件人服务器接收的数据类型
		dataType: 'json',//从接口返回的数据形式
		success: function (res) {
			
		},
		error: function (res) {
			
		}
});
@RequestMapping(value="testurl", method=RequestMethod.POST, produces="application/json;charset=UTF-8", consumes="application/json;charset=UTF-8")
@ResponseBody //将java对象转成json
public String DoFunction(User user) { 
	//...
}

------------------------代码测试2---------------------------
@Controller
@RequestMapping("/test")
public class testController {
	@Autowired
	private TestService testService;
	
	// 查询数据
	@RequestMapping("getAll")testService
	@ResponseBody
	public Map<String, Object> doSelectDfc() {
		return testService.findAll();
	}
	
	@RequestMapping("/getJson")
	@ResponseBody
	public String doGet() {
	    return testService.findAllList().toString;		
	}
	
	// 插入数据
	@RequestMapping("/InsertData")
	public boolean doInsertDfc(Data dataObject) { 
		if (testService.InsertData(dataObject)) {
			return true;
		} else {
			return false;
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

解释Content-type：application/json; charset = utf-8
$.ajax
contentType 和 dataType , contentType 主要设置你发送给服务器的格式，
dataType设置你收到服务器数据的格式。

5.配置视图解析器

配置xml前后缀如何拼接
请求接口的方法返回字符串与视图解析器的前后缀拼接后跳转。
转发:forward:/WEB-INF/views/index.jsp
重定向:redirect:/index.jsp

#第一种方式
<!--定义内部资源视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/views（文件夹名字）/"/>
		<!--资源的后缀名-->        
        <property name="suffix" value=".jsp"/>
    </bean>
#	第二种方式 这是html
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置html路径的前缀，在哪个文件下 -->
		<property name="prefix" value="/WEB-INF/Html/"/>
		<!-- 哪个文件夹下以配置html路径的后缀文件 -->
		<property name="suffix" value=".html"/>		
	</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

如果返回的视图用到jstl标签库，就是${ } 取 modelandview 对象的参数 如果视图解析器解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包
举例：

@Controller
@RequestMapping("/TestReturnView")
public class TestReturnView{
	@RequestMapping("/userLogin")
	public ModelAndView login(HttpSession session, String username, String password,HttpServletRequest request)
				throws Exception {
			ModelAndView view = new ModelAndView();
			User userinfo = userService.findUserByCondition(username,password);
			String projectPath = request.getContextPath();//从请求中获取项目的端口和项目路径
			if(login !=null){
				session.setAttribute("userinfo", userinfo);//session放用户信息
				view.addObject("projectPath", projectPath);
				view.setViewName("index");//主页面
			}			
			}else{
				//登录失败
				view.addObject("errmsg", "用户名或密码错误");
				view.setViewName("error");//错误页面
			}
			return view;
		}
}		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在index.jsp页面如何取session和view中值呢？

首先视图中携带这返回信息，信息以map形式存储在内存中

在index.jsp前端页面如何获取携带回的值？用jstl标签
1.在项目classpath下有jstl包
2.前端页面加jstl 标签
<%@ page language="java" import="java.util.*" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
#获取携带回的值
var projectPath = '${projectPath}';
var userinfo = <%=session.getAttribute("userinfo") %>;
1
2
3
4
5
6
7
8

6.配置文件上传的大小限制

CommonsMultipartResolver的作用

<!--文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设置请求编码格式，必须与JSP中的pageEncoding属性一致，默认为ISO-8859-1 -->
        <property name="defaultEncoding" value="UTF-8" />
        <!-- 设置允许上传文件的最大值单位为字节 ，比如10M= 10485760 字节=10*1024*1024  -->
        <property name="maxUploadSize" value="10485760"/>
    </bean>
    ------------------------------------
    注意：在配置CommonsMultipartResolver时必须指定该Bean的id为multipartResolver。 
	因为初始化MultipartResolver时，程序会在Spring容器中查找名称为multipartResolver的
	MultipartResolver实现类，
	如果没有查找到对应名称MultipartResolver实现类，将不提供文件解析处理
1
2
3
4
5
6
7
8
9
10
11
12

配置文件上传基础实操

项目中导入Apache Commons FileUpload组件的依赖，即commons-fileupload依赖和commons-io依赖。由于commons-fileupload依赖会自动依赖commons-io
前端页面
form表单的method属性设置为post。
form表单的enctype属性设置为multipart/form-data。
提供的文件上传输入框。

//创建一个 前端页面
<form action="uploadpath" method="post" enctype="multipart/form-data" >
这个  name=testfile   这个key 要和对接的接口形参数一致
    <input type="file" name="testfile666" multiple="multiple" />
    <input type="submit" value="文件上传" />
</form>
1
2
3
4
5
6

@Controller
@RequestMapping("/uploadtest")
uploadpath
public ModelAndView FileUpload {
    @RequestMapping("/testfileUpload")
    public String testfileUpload(MultipartFile testfile666, HttpServletRequest request) throws IOException {
    //这个 testfile参数 要与input 输入框的name 属性的值也就是name的key 相同
        String filepath = request.getServletContext().getRealPath("/") + "testfile666/";
		ModelAndView view = new ModelAndView();
        if (!testfile.isEmpty()) {
            // 保存上传的文件，filepath为保存的目标目录
            String filePath = filepath + testfile666.getOriginalFilename();
            testfile.transferTo(new File(filePath));
            //返回成功上传页面
			view.addObject("msg","成功");
			view.setViewName("success");			
		}else{
			view.setViewName("failure");
		}		
       	return view; 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7.引发思考：xml 文件中配置的信息注册类不是唯一的

根据实际情况或者项目的复杂程度进行配置

点解连接
第一章：Spring流程执行步骤
第二章：Spring核心思想和IOC和AOP依赖注入
第三章：Spring常用注解解释
第四章：Spring七大核心模块Bean、Core、Context
第五章：Spring细分一如何让mapper文件夹下的SQL语句对数据库生效，jdbc和mybatis-config.xml
第六章：Springmvc事务管理和配置文件xml详解和七大事务和注解@Transactional
第七章：Springmvc中applicationContext.xml配置文件应用上下文详解