springMVC中输入验证、springMVC文件上传、国际化、拦截器

最新推荐文章于 2021-08-09 16:27:01 发布

IT_CREATE

最新推荐文章于 2021-08-09 16:27:01 发布

阅读量466

点赞数

分类专栏： spring-mvc框架文章标签：输入验证文件上传国际化拦截器

本文链接：https://blog.csdn.net/IT_CREATE/article/details/86572377

版权

spring-mvc框架专栏收录该内容

8 篇文章 0 订阅

订阅专栏

输入验证（引入hibernate-validator JAR包）

在spring-mvc框架中，如果要在后台进行输入验证的话，我们就可以用到后面我要讲的hibernate提供的输入验证框架了。

1、要使用这个验证框架，首先必须在我们的spring-mvc.xml的配置文件中进行注册

<!-- 配置spring框架提供的验证工厂，并告知我们验证框架使用的是Hibernate 提供的验证框架 -->
<bean id="localValidatorFactoryBean" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
	<property name="providerClass" value="org.hibernate.validator.HibernateValidator"></property>
</bean>

2、在控制器中需要添加@Valid注解，表示该类开启验证支持，@ModelAttribute("errs")表示将错误返回到前端页面，BindingResult可以的得到错误。

@Valid注解解释（遵循的规范）：https://blog.csdn.net/qq_27680317/article/details/79970590

/**
 * @Valid 该注解，一定要写在对象的前面
 * @ModelAttribute("errs")  === request.setAttribute("errs",br.getFieldErrors())
 * === model.addObject("errs",br.getFieldErrors());
 * 
 * @param user
 * @return
 */
@RequestMapping(value="/validator")
public String validator(@ModelAttribute("errs") @Valid UserBean user,BindingResult br) {
	if(br.hasErrors()) {
		log.info("ValidatorController-----validator()----errors",Arrays.toString(br.getAllErrors().toArray()));
		return "/validator";
	}
		
	log.info("ValidatorController-----validator()", user);
	return "/index";
}

3、在jsp页面中要显示错误信息的话，得这样写

引入spring的标签库

<%@ taglib uri="http://www.springframework.org/tags" prefix="s" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="sf" %>

使用spring中form标签库中的表单标签

<sf:form action="users/validator" method="post" modelAttribute="errs"> </sf:form>

modelAttribute表示去得到传上来的一系列错误，需绑定了前面控制器@ModelAttribute("errs")设置的属性的值，所以参数名称必须一致

使用错误打印标签

<sf:errors path="loginName" delimiter=","></sf:errors>

path表示打印的是对象中哪个属性的错误，delimiter表示这个属性的一系列错误用什么隔开

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<% String path = request.getContextPath();%>

<%@ taglib uri="http://www.springframework.org/tags" prefix="s"%>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="sf"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册页面</title>
<base href="<%=path%>/" >

</head>
<body>

<sf:form action="users/validator" method="post" modelAttribute="errs">
      <input type="text" name="userName" value="<%=request.getParameter("userName") %>"/>
      <sf:errors path="userName" delimiter=","></sf:errors>

      <input type="text" name="loginName" />
      <sf:errors path="loginName" delimiter=","></sf:errors>

      <input type="submit" value="注册" />
</sf:form>

</body>
</html>

4、关于需要验证的类的内部的写法（属性的get、set方法就不贴出来了）

如果要查看JSR 303验证规范，请点击如下官网：https://docs.jboss.org/hibernate/validator/5.4/reference/en-US/html_single/#validator-defineconstraints-spec
并直接进入到 2.3.1. Bean Validation constraints

@NotNull() 值不能为null
@NotBlank() 不能没有内容

@Pattern() 使用正则表达式进行验证

@Past() 判断是否是未来的一个时间

@Max() 限定的最大值
@Min() 限定的最小值

@Digits() 限定数值的有效位数，及小数位数

@Size() 限定数组最大空间和最小空间

@Valid 放在对象中的对象属性上，表示该对象开启嵌套验证，意思就是这个对象属性值得对象中的的验证也得到支持

public class UserBean implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -7297708120160895351L;

	private Long id;
	
	@NotNull(message="登录名不能为null！")
	@NotBlank(message="登录名必须有内容！")
	private String loginName;
	
	@NotNull(message="用户名不能为空！")
	@Pattern(regexp="\\w{6,20}",message="用户名必须是6-20位之间的内容！")
	private String userName;
	
	@NotNull(message="密码不能为空！")
	private String password;
	
	@Past(message="你不能出生在未来！")
	private Date birthday;
	
	@Max(value=80,message="年龄过于偏大，身体要紧，请走开！")
	@Min(value=18,message="未成年人，请走开！")
	private int age;
	
	private int gender;
	
	@Digits(integer=6,fraction=2,message="请输入整数位不超过6位，小数位不超过2位的数值！")
	private double income;
	
	
	private boolean marry;
	
	@Size(min=1,max=10,message="至少需要选择1种个人爱好！")
	private int[] hobby;
	
	private List<String> adds = new ArrayList<String>();
	private Set<ChildrenBean> childs = new HashSet<ChildrenBean>();
	private Map<String,String> map = new HashMap<>();
	
	@Valid
	private RoleBean role;
}

springMVC文件上传（引入commons-io和 commons-fileupload JAR包）

1、要使用这个文件上传，首先必须在我们的spring-mvc.xml的配置文件中进行注册（springMVC的jar包尽量选择高一点的版本，低版本有些没有为 preserveFilename 提供get、set方法）

<!-- 配置文件上传解析器，ID固定为：multipartResolver -->
<bean id="multipartResolver"
	class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
	<!-- 设置每次最大允许上传100M的内容，单位是：byte -->
	<property name="maxUploadSize" value="104857600"></property>
	<!-- 设置每次单个文件，最大允许上传10M的内容，单位是：byte -->
	<property name="maxUploadSizePerFile" value="10485760"></property>
	<!-- 设置解析文件时，采用utf-8的字符集进行编码 -->
	<property name="defaultEncoding" value="utf-8"></property>
	<!-- 保留源文件的名称 -->
	<property name="preserveFilename" value="true"></property>
</bean>

2、在前端页面中呢，分为单文件上传，和多文件上传，下面进行说明

单文件上传

页面代码：（页面上传下去两个提交项，一个是userName文本提交项；一个就是这次的主角file01文件提交项）

<!-- 文件上传注意事项： 
     1、method必须是post 
     2、enctype="multipart/form-data" 代表指定表单数据为：二进制文件数据
-->
<form action="<%=path %>/files/upload" method="post" enctype="multipart/form-data">
 	用户名：<input type="text" name="userName"/><br/>
 	文件：<input type="file" name="file01"/>
 		 <input type="submit" value="上传"/>
 	
</form>

控制器代码：（在控制器这里，为了要接收到文件数据，我们用@RequestParam注解绑定文件对象

CommonsMultipartFile类就是接收文件的）

/**
 * 
 * @param file 代表的是临时文件对象
 * @param userName
 * @return
 */
@RequestMapping(value="/upload",method=RequestMethod.POST)
public String fileUpload(@RequestParam("file01") CommonsMultipartFile file, String userName) {
	String fileName = file.getOriginalFilename();//得到文件的原始名称
	System.out.println(fileName);
		
	String path = "d:\\files";
	File dir = new File(path);
	if(!dir.exists()) {
		dir.mkdir();
	}
		
		
	//写内容到files文件夹下（File.separator表示不同系统对应的分割符，比如windows就是“\”）
	path = path + File.separator + fileName;
	try {
		file.getFileItem().write(new File(path));
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return "index";
}

多文件上传

页面代码：（页面上传下去两个提交项，一个是userName文本提交项；一个就是这次的主角file文件提交项，多个file的name属性的值必须一样，以对象数组的形式传到后台）

<!-- 文件上传注意事项： 
     1、method必须是post 
     2、enctype="multipart/form-data" 代表指定表单数据为：二进制文件数据
-->
<form action="<%=path %>/files/multiupload" method="post" enctype="multipart/form-data">
	 	用户名：<input type="text" name="userName"/>
	 	<br/>
	 	文件1：<input type="file" name="file"/>
		<br /> 
		文件2：<input type="file" name="file"/>
		<br /> 
		文件3：<input type="file" name="file"/>
		<br /> 
		文件4：<input type="file" name="file"/>
		<br /> 
	 	<input type="submit" value="上传"/>
	 	
</form>

控制器代码：（在控制器这里，为了要接收到文件数据，我们用@RequestParam注解绑定文件对象，就是和上面提交项的name对应； CommonsMultipartFile数组就是接收多个文件对象的）

/**
 * 
 * @param file 代表的是临时文件对象
 * @param userName
 * @return
 */
@RequestMapping(value="/multiupload",method=RequestMethod.POST)
public String fileMultiUpload(@RequestParam("file") CommonsMultipartFile[] files, String userName) {
		
	if(files.length > 0) {
			
		for (CommonsMultipartFile file : files) {
				
			//判断文件内容是否为空，如果为空，直接忽略
			if(!file.isEmpty()) {

				String fileName = file.getOriginalFilename();//得到文件的原始名称
				System.out.println(fileName);
					
				String path = "d:\\files";
				File dir = new File(path);
				if(!dir.exists()) {
					dir.mkdir();
				}
					
				//写内容到files文件夹下
				path = path + File.separator + fileName;
					
				System.out.println("path------" + path);
					
				try {
					file.getFileItem().write(new File(path));
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
					
					
			}
		}
	}
		
	return "index";
}

国际化

1、首先我们要去定义语言包来支持国际化（文件保存在\src\main\resources下）

定义语言母包：（取名为 message.properties）用后缀是properties的文件来写语言包配置

语言母包 message.properties ：

validator.page.title=\u7528\u6237\u6CE8\u518C
validator.page.userName=\u7528\u6237\u540D\uFF1A
validator.page.loginName=\u767B\u5F55\u540D\uFF1A
validator.page.password=\u5BC6\u7801\uFF1A
validator.page.age=\u5E74\u9F84\uFF1A

在文件中配置需要显示的文字是什么，键值对的形式，通过键值就可以取出内容，母包默认是中文，中文在properties文件中会自动转换成ASCII码

定义一系列子包（子包的命名规范：母包_语言种类_国家OR地区编码）

简体中文 message_zh_CN.properties ：

validator.page.title=\u7528\u6237\u6CE8\u518C
validator.page.userName=\u7528\u6237\u540D\uFF1A
validator.page.loginName=\u767B\u5F55\u540D\uFF1A
validator.page.password=\u5BC6\u7801\uFF1A
validator.page.age=\u5E74\u9F84\uFF1A

美式英语 message_en_US.properties ：

validator.page.title=The page of users registration
validator.page.userName=UserName\uFF1A
validator.page.loginName=LoginName\uFF1A
validator.page.password=Password\uFF1A
validator.page.age=Age\uFF1A

台湾地区繁体中文 message_zh_TW.properties ：

validator.page.title=\u7528\u6236\u8A3B\u518A
validator.page.userName=\u7528\u6236\u540D\uFF1A
validator.page.loginName=\u767B\u9304\u540D\uFF1A
validator.page.password=\u5BC6\u78BC\uFF1A
validator.page.age=\u5E74\u9F61\uFF1A

2、向spring-mvc.xml配置文件进行注册

<!-- 定义将Locale数据存放入Session中，locale中就包含了各种属性，比如所在地区，所用语言 -->
<bean id="localeResolver"
class="org.springframework.web.servlet.i18n.SessionLocaleResolver"></bean>



<!-- 定义国际化支持类，ID固定为：messageSource -->
<!-- basename属性是定义母包的文件，value就是语言母包，默认以母包内容显示，切换语言会自动去找子包 -->
<bean id="messageSource"
	class="org.springframework.context.support.ResourceBundleMessageSource">
	<property name="basename" value="message"></property>
</bean>

3、前端页面的书写

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<% String path = request.getContextPath(); %>

<%@ taglib uri="http://www.springframework.org/tags" prefix="s"%>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="sf"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册页面</title>
<base href="<%=path%>/" >


</head>
<body>
    <a href="users/i18n?locale=zh_CN">中文大陆</a>|<a href="users/i18n?locale=en_US">America</a>

    <s:message code="validator.page.title"></s:message>
    <sf:form action="users/validator" method="post">
         <s:message code="validator.page.userName"></s:message>
         <input type="text" name="userName" value="<%=request.getParameter("userName") %>"/>

         <s:message code="validator.page.loginName"></s:message>
         <input type="text" name="loginName" />

         <s:message code="validator.page.password"></s:message>
         <input type="password" name="password" />

         <s:message code="validator.page.age"></s:message>
         <input type="text" name="age" value="<%=request.getParameter("age") %>"/>

         <input type="submit" value="注册" />
    </sf:form>
</body>
</html>

可以看到以上代码中有下面这段：（通过a标签来发起切换语言的请求，我们在请求路径后面要追加一个参数 locale=，参数就要写你要切换的语言种类，也就是我们前面定义的子包取 “语言种类_国家OR地区编码” 为值）

<a href="users/i18n?locale=zh_CN">中文大陆</a>|<a href="users/i18n?locale=en_US">America</a>

在上述代码中我们可以看到要去获取语言包中的数据，我们就用这段代码（<s:message> 标签，code就是子包中对应的键值，通过键值，它会去获取相应的值出来）：

<s:message code="validator.page.title"></s:message>

同时可以注意到上面的这两串代码，作用就是会给请求自动添加请求的项目路径，如果不写的话，会找不到请求：

<% String path = request.getContextPath(); %>

<base href="<%=path%>/" >

4、控制器的书写

@RequestMapping("/users")
@Controller
public class ValidatorController {
	
	@RequestMapping("/i18n")
	public String changeI18n() {
        //返回的就是发送切换语言请求的当前页面，不做页面跳转
		return "validator";
	}
}

拦截器

拦截器的应用场景：登录日志，运行日志，登录权限认知，执行方法的时间统计……

1、首先我们要自己先写一个拦截器类（实现 HandlerInterceptor 接口，同时实现接口的三个方法）

/**
 * 定义登录拦截器
 * @author Administrator
 * 
 * 应用场景：登录日志，运行日志，登录权限认知，执行方法的时间统计……
 * 
 */
public class LoginInterceptor implements HandlerInterceptor {

	/**
	 * 请求进入到Controller之前，需要执行的方法
	 */
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		// TODO Auto-generated method stub
		System.out.println("LoginInterceptor-----preHandle()");
		
//		return true; 代表该请求，正常进入Controller
		
//		return false; 代表该请求，无法正常进入Controller，一般需要请求转发，或者重定向
		
		return true;
	}
	/**
	 * 请求进入到Controller之后，需要执行的方法
	 */
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		// TODO Auto-generated method stub
		System.out.println("LoginInterceptor-----postHandle()");
		System.out.println("LoginInterceptor-----postHandle()" + handler);
		System.out.println("LoginInterceptor-----postHandle()" + modelAndView);
		//此处可以记录"登录日志"
		
	}
	/**
	 * 所有拦截器的方法都执行完毕，需要执行的方法
	 * 收尾的方法
	 */
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		// TODO Auto-generated method stub
		System.out.println("LoginInterceptor-----afterCompletion()");
	}

}

2、向spring-mvc.xml配置文件进行注册

<!-- 配置拦截器链 -->
<mvc:interceptors>
	<!-- 所有的请求，都需要经过该拦截器 -->
	<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"></bean>

	<bean class="com.ge.springmvcanno.interceptor.MyInterceptor"></bean>

	<!-- 针对 /sys/login04 开启一个拦截器 -->
	<mvc:interceptor>
		<mvc:mapping path="/sys/login04" />
		<bean class="com.ge.springmvcanno.interceptor.LoginInterceptor"></bean>
	</mvc:interceptor>

	<mvc:interceptor>
		<mvc:mapping path="/*/*" />
		<bean class="com.ge.springmvcanno.interceptor.LogInterceptor"></bean>
	</mvc:interceptor>

</mvc:interceptors>

从上面我们可以看出：

<mvc:interceptors>标签配置拦截器

<bean>标签可以指定全局的拦截器，也就是整个程序有效

<mvc:interceptor>标签去指定特定的请求执行拦截器

class属性就是拦截器的全路径

因为拦截器中有三个方法，对应不同时间进行拦截；那么在拦截时，执行第一个方法时，拦截器的执行顺序是我们配置文件中配置拦截器从上之下的顺序；其余两次方法的执行，拦截器的执行顺序是从下至上。

涉中到的配置文件

spring-mvc.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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
						http://www.springframework.org/schema/context
        				http://www.springframework.org/schema/context/spring-context.xsd
        				http://www.springframework.org/schema/mvc
        				http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 开启spring容器的自动扫描功能 -->
	<context:component-scan base-package="com.gezhi.springmvcanno"></context:component-scan>

	<!-- 开启springmvc的注解支持 -->
	<!-- conversion-service="conversionService" 告知springmvc使用conversionService里面的转换规则 -->
	<!-- validator="localValidatorFactoryBean" 告知springmvc使用hibernate的验证框架，完成对对象的后台验证 -->
	<mvc:annotation-driven conversion-service="conversionService"
		validator="localValidatorFactoryBean" />


	<!-- 指定静态资源文件的位置 -->
	<mvc:resources location="/static/" mapping="/static/**"></mvc:resources>

	<!-- 定义将Locale数据存放入Session中 -->
	<bean id="localeResolver"
		class="org.springframework.web.servlet.i18n.SessionLocaleResolver"></bean>

	<!-- 配置拦截器链 -->
	<mvc:interceptors>
		<!-- 所有的请求，都需要经过该拦截器 -->
		<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"></bean>

		<bean class="com.gezhi.springmvcanno.interceptor.MyInterceptor"></bean>

		<!-- 针对 /sys/login04 开启一个拦截器 -->
		<mvc:interceptor>
			<mvc:mapping path="/sys/login04" />
			<bean class="com.gezhi.springmvcanno.interceptor.LoginInterceptor"></bean>
		</mvc:interceptor>

		<mvc:interceptor>
			<mvc:mapping path="/*/*" />
			<bean class="com.gezhi.springmvcanno.interceptor.LogInterceptor"></bean>
		</mvc:interceptor>

	</mvc:interceptors>


	<!-- 定义国际化支持类，ID固定为：messageSource -->
	<!-- basename属性是定义母包的文件，value就是语言母包，默认以母包内容显示，切换语言会自动去找子包 -->
	<bean id="messageSource"
		class="org.springframework.context.support.ResourceBundleMessageSource">
		<property name="basename" value="message"></property>
	</bean>

	<!-- 定义spring框架的转换工厂，并且向转换工厂中注册"自定义的转换器" -->
	<bean id="conversionService"
		class="org.springframework.context.support.ConversionServiceFactoryBean">
		<property name="converters">
			<set>
				<bean class="com.gezhi.springmvcanno.converter.StringToDateConverter"></bean>
			</set>
		</property>
	</bean>

	<!-- 配置spring框架提供的验证工厂，并告知我们验证框架使用的是Hibernate 提供的验证框架 -->
	<bean id="localValidatorFactoryBean"
		class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
		<property name="providerClass" value="org.hibernate.validator.HibernateValidator"></property>
	</bean>


	<!-- 不再需要配置处理映射器，因为框架会自动使用 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping 
		去根据我们定义的@RequestMapping该注解，完成"请求路径"到"处理该请求方法"之间的映射关系 -->

	<!-- 不再需要配置处理适配器，因为框架会自动使用 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter 
		去根据我们定义的@RequestMapping该注解，完成"Servlet数据"到"Controller数据"之间的数据适配 -->


	<!-- 配置文件上传解析器，ID固定为：multipartResolver -->
	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<!-- 设置每次最大允许上传100M的内容，单位是：byte -->
		<property name="maxUploadSize" value="104857600"></property>
		<!-- 设置每次单个文件，最大允许上传10M的内容，单位是：byte -->
		<property name="maxUploadSizePerFile" value="10485760"></property>
		<!-- 设置解析文件时，采用utf-8的字符集进行编码 -->
		<property name="defaultEncoding" value="utf-8"></property>
		<!-- 保留源文件的名称 -->
		<property name="preserveFilename" value="true"></property>
	</bean>



	<!-- 配置视图解析器 -->
	<bean id="internalResourceViewResolver"
		class="org.springframework.web.servlet.view.UrlBasedViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView"></property>
		<!-- 前缀 -->
		<property name="prefix" value="/"></property>
		<!-- 后缀 -->
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>

web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>

  	<!-- 这是将spring-mvc.xml文件交给spring容器 -->
  	<context-param>
  		<param-name>contextConfigLocation</param-name>
  		<param-value>classpath:spring-mvc.xml</param-value>
  	</context-param>
  
  	<!-- 定义处理POST请求中文乱码过滤器 -->
  	<filter>
  		<filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
  		<url-pattern>/*</url-pattern>
  	</filter-mapping>
  
  	<!-- 监听tomcat容器是否启动，并开启spring容器 -->
  	<listener>
  		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  	</listener>
 
  <!-- 配置前端控制器:
  	1、接收用户的请求，并完成请求的派发
  	2、实例容器，并且完成配置文件转交给spring容器 -->
  	<servlet>
  		<servlet-name>mvc</servlet-name>
  		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  		<init-param>
  			<param-name>contextConfigLocation</param-name>
  			<param-value>classpath:spring-mvc.xml</param-value>
  		</init-param>
  	</servlet>
  	<servlet-mapping>
  		<servlet-name>mvc</servlet-name>
  		<url-pattern>/</url-pattern>
  	</servlet-mapping>
  
</web-app>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.gezhi</groupId>
	<artifactId>springmvcanno</artifactId>
	<packaging>war</packaging>
	<version>1.0</version>
	<name>springmvcanno Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<junit.version>4.12</junit.version>
		<log4j.version>1.2.17</log4j.version>
		<spring.version>4.3.14.RELEASE</spring.version>
		<jstl.version>1.2</jstl.version>
		<hibernate.validator.version>5.4.1.Final</hibernate.validator.version>
		<slf4j.version>1.7.25</slf4j.version>
	</properties>

	<dependencies>
		
		<!-- 引入文件上传需要的JAR包 -->
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.4</version>
		</dependency>

		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.1</version>
		</dependency>


		<!-- 引入slf4j日志标准，作用：适配其他具体的日志框架，如：log4j,logback…… -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>


		<!-- 引入hibernate的验证框架 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<version>${hibernate.validator.version}</version>
		</dependency>

		<!-- 引入jstl，spring-mvc才能识别jsp的标准标签库 -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>

		<!-- 引入springmvc框架的相关JAR包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<!-- 导入junit单元测试框架JAR包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>


		<!-- 导入LOG4J日志框架JAR包 -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>

	</dependencies>
	
	<build>
		<finalName>springmvcanno</finalName>
		<pluginManagement>
			<!-- 配置maven 在构建项目时，采用相关插件 -->
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>3.8.0</version>
					<configuration>
						<source>1.8</source>
						<target>1.8</target>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
	
</project>

IT_CREATE

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springMVC中输入验证、springMVC文件上传、国际化、拦截器

输入验证（引入hibernate-validator JAR包）在spring-mvc框架中，如果要在后台进行输入验证的话，我们就可以用到后面我要讲的hibernate提供的输入验证框架了。 1、要使用这个验证框架，首先必须在我们的spring-mvc.xml的配置文件中进行注册&lt;!-- 配置spring框架提供的验证工厂，并告知我们验证框架使用的是Hibernate 提...
复制链接

扫一扫

专栏目录