菜鸟的成长之路——springmvc的数据

最新推荐文章于 2024-05-15 20:33:46 发布

一个在努力变强的二狗子

最新推荐文章于 2024-05-15 20:33:46 发布

阅读量594

点赞数

分类专栏： springmvc 文章标签： springmvc json xml

本文链接：https://blog.csdn.net/madman_donghui/article/details/79397105

版权

springmvc 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

现在企业基本都在使用html5+js+css作为前端开发，发送过来的数据往往需要我们做各种处理，来满足数据的一致，哪怕使用jsp开发页面也会存在这些问题。或者我们的数据不能以程序的形式展示给用户浏览，不然没有编程基础的用户看的很难甚至看不懂，也有时候同一个页面在不同的国家显示不同的语言等等问题，这些问题我们这节课来研究一下。

1、springmvc怎么进行json信息的转换呢？

json是在开发中经常使用的一种数据类型，在springmvc中转换json数据，我们加入jackson和fastjson两种依赖，我们看一下pom.xml。
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.test</groupId>
	<artifactId>Test</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>Test Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.44</version>
		</dependency>
	</dependencies>
	<build>
		<finalName>Test</finalName>
	</build>
</project>

我们在jsp中使用js的ajax发送json给控制器，控制器通过注解@RequestBody接收并解析json给一个对象，这样一个json的数据就解析到一个java对象中了，我们看一下代码。
springmvc的配置文件

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<!-- 让springmvc扫描controller的包 -->
	<context:component-scan base-package="com.springmvc.controller"></context:component-scan>
		<!-- 默认使用RequestMappingHandlerMapping映射器和RequestMappingHandlerAdapter适配器 -->
		<mvc:annotation-driven>
			<!-- 配置使用阿里的第三方包作为json转换接口 -->
			 <mvc:message-converters>
	        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter"></bean>
	    </mvc:message-converters>
	</mvc:annotation-driven>
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
<script type="text/javascript">
var user = {name:"caixiaobai",address:"Beijing",age:18};
var jsonUser = JSON.stringify(user);

$.ajax({  
    type: "POST",  
    url:"/Test/test.do",
    contentType: "application/json;",
    data: jsonUser,
    success: function (data) {  
    		alert("发送成功")
    },
    error: function (data) {  
    		alert("发送失败")
    }  
});
</script>
</body>
</html>

People.java（接收json数据的对象）

package com.springmvc.pojo;

public class People{
	private String name;
	private String address;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "name==>"+name+"\naddress==>"+address+"\nage"+age;
	}

}

ControllerTest.java

package com.springmvc.controller;

import java.io.IOException;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import com.springmvc.pojo.People;

@Controller
public class ControllerTest {
	@RequestMapping("/test.do")
	public void ViewTest(@RequestBody People peo) throws IOException {
		System.out.println(peo.toString());
	}
}

jsp里代码不多加累述了，我们看一下springmvc的配置文件，在<mvc:annotation-driven>标签中配置fastjson的信息转换支持类，然后使用@RequestBody注解将json信息解析到People类中，这样我们就可以直接操作peo对象了。
上面研究了springmvc将json数据转换成java对象，下面我们再来研究一下springmvc如何使用fastjson将java对象转换成json，并发送给jsp,springmvc配置文件不变，我们看一下处理器和jsp页面
index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
<script type="text/javascript">
var user = {name:"caixiaobai",address:"Beijing",age:18};
var jsonUser = JSON.stringify(user);

$.ajax({  
    type: "POST",  
    url:"/Test/test.do",
    contentType: "application/json;",
    data: jsonUser,
    dataType:"json",
    success: function (data) {  
            alert("接收服务器数据的地址："+data.address)
    },
    error: function (data) {  
            alert("发送失败")
    }  
});
</script>
</body>
</html>

ControllerTest.java

package com.springmvc.controller;

import java.io.IOException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.springmvc.pojo.People;

@Controller
public class ControllerTest {
    @RequestMapping("/test.do")
    @ResponseBody
    public People ViewTest(@RequestBody People peo) throws IOException {
        peo.setAddress("Beijing Chaoyang");
        return peo;
    }
}

我们发现测试的页面上弹出对话框显示修改后的json数据，至此转变json并发送的代码研究完成。

2、springmvc如何解析xml的？

我们来看一下xml在前后端数据传输过程中如何操作的，需要我们添加jaxb的依赖，pom文件如下：
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.test</groupId>
	<artifactId>Test</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>Test Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/javax.xml.bind/jaxb-api -->
		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
			<version>2.2.12</version>
		</dependency>


	</dependencies>
	<build>
		<finalName>Test</finalName>
	</build>
</project>

首先来看一下前端给后端发送xml数据，后端将xml数据解析到java对象上。
springmvc-config.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<!-- 让springmvc扫描controller的包 -->
	<context:component-scan base-package="com.springmvc.controller,com.springmvc.pojo"></context:component-scan>
		<!-- 默认使用RequestMappingHandlerMapping映射器和RequestMappingHandlerAdapter适配器 -->
		<mvc:annotation-driven>
			<!-- annotation-driven标签会默认执行下列注释掉的配置 -->
			 <!-- <mvc:message-converters>
	        		<bean class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter"></bean>
	   		 </mvc:message-converters> -->
		</mvc:annotation-driven>
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
<script type="text/javascript">
var user = "<people><name>caixiaobai</name><address>Beijing</address><age>18</age></people>";

$.ajax({  
    type: "POST",  
    url:"/Test/test.do",
    contentType: "application/xml;",
    data: user,
    success: function (data) {  
    		alert("服务器发送数据："+data)
    },
    error: function (data) {  
    		alert("发送失败")
    }  
});
</script>
</body>
</html>

People.java

package com.springmvc.pojo;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class People{
	private String name;
	private String address;
	private int age;
	public String getName() {
		return name;
	}
	@XmlElement
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	@XmlElement
	public void setAddress(String address) {
		this.address = address;
	}
	public int getAge() {
		return age;
	}
	@XmlElement
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "name==>"+name+"\naddress==>"+address+"\nage"+age;
	}

}

ControllerTest.java

package com.springmvc.controller;

import java.io.IOException;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import com.springmvc.pojo.People;

@Controller
public class ControllerTest {
	@RequestMapping("/test.do")
	public void ViewTest(@RequestBody People peo) throws IOException {
		System.out.println(peo.getAddress());
	}
}

测试发现，处理器已经正常的将xml解析成People的对象，但是不要忽略People已经不是个普通的pojo，它在类级别有了@XmlRootElement注解，在相应的setter方法上有了@XmlElement注解。我们再来看一下springmvc如何将java对象解析成xml并发送出去吧。
springmvc-config.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 让springmvc扫描controller的包 -->
    <context:component-scan base-package="com.springmvc.controller,com.springmvc.pojo"></context:component-scan>
        <!-- 默认使用RequestMappingHandlerMapping映射器和RequestMappingHandlerAdapter适配器 -->
        <mvc:annotation-driven>
            <!-- annotation-driven标签会默认执行下列注释掉的配置 -->
             <!-- <mvc:message-converters>
                    <bean class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter"></bean>
             </mvc:message-converters> -->
        </mvc:annotation-driven>
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
<script type="text/javascript">
var user = "<people><name>caixiaobai</name><address>Beijing</address><age>18</age></people>";

$.ajax({  
    type: "POST",  
    url:"/Test/test.do",
    contentType: "application/xml;",
    data: user,
    success: function (data) {  
            alert("接收服务器数据的地址："+$("address",data).text())
    },
    error: function (data) {  
            alert("发送失败")
    }  
});
</script>
</body>
</html>

People.java

package com.springmvc.pojo;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class People{
    private String name;
    private String address;
    private int age;
    public String getName() {
        return name;
    }
    @XmlElement
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    @XmlElement
    public void setAddress(String address) {
        this.address = address;
    }
    public int getAge() {
        return age;
    }
    @XmlElement
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "name==>"+name+"\naddress==>"+address+"\nage"+age;
    }

}

ControllerTest.java

package com.springmvc.controller;

import java.io.IOException;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.springmvc.pojo.People;

@Controller
public class ControllerTest {
    @RequestMapping("/test.do")
    @ResponseBody
    public People ViewTest(@RequestBody People peo) throws IOException {
    		peo.setAddress("Beijing Chaoyang");
    		return peo;
    }
}

测试后发现，前端正常接收到xml数据，证明springmvc已经将java对象转成xml并发送给前端了。

3、springmvc接收的字符串如何转换成java对象？

如果前端使用表单提交了用户信息，信息中有一条是生日，前端传给后端是字符串形式，往往我们后端需要一个Date类型的，这一点是前端做不到的，于是springmvc提供了类型转换的扩展，我们使用字符串转Date来举个例子。

StringToDateConverter.java

package com.springmvc.pojo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.core.convert.converter.Converter;

public class StringToDateConverter implements Converter<String, Date>{

	public Date convert(String source) {
		// TODO Auto-generated method stub
		SimpleDateFormat format = new SimpleDateFormat("Y-M-d");
		Date date = new Date();
		try {
			date = format.parse(source);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return date;
	}

}

这个类实现了Converter接口，他可以检测前端发送数据和后端接收数据类型不同的时候，将前端类型转成后端类型。例如Converter<S,T>，可以将前端发送过来的S类型转化成T类型或者T类型的子类型，转换过程就是通过执行接口的convert()方法完成的，例如上面的类。
springmvc-config.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 让springmvc扫描controller的包 -->
    <context:component-scan base-package="com.springmvc.controller"></context:component-scan>
    <!-- mvc:annotation-driven加载默认映射器和适配器，并且制定conversionService的bean -->
    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
		<property name="converters">
			<!-- 在conversionService中指定自己写的converter -->
			<list>
				<bean class="com.springmvc.pojo.StringToDateConverter"></bean>
			</list>
		</property>
	</bean>
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
	<form action="/Test/test.do" method="post">
		<input type="text" name="birthday" value=""/>
		<input type="text" name="account" value=""/>
		<input type="submit" value="submit"></input>
	</form>
</body>
</html>

ControllerTest.java

package com.springmvc.controller;

import java.util.Date;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class ControllerTest {
    @RequestMapping("/test.do")
    public String ViewTest(@RequestParam Date birthday,@RequestParam String account){
    		System.out.println(birthday);
    		System.out.println(account);
//    	随意跳转一个界面
    		return "index.jsp";
    }
}

前端发送过来的birthday是字符串的形式，而后端使用Date类型接收，这时候就会执行Converter接口实现类的convert()方法，然后将此方法返回的对象重新赋值给birthday参数。
Converter接口可以将任意Object转换成任意的Object，适用于项目中的各个层次需要类型转换的地方。

4、如何将springmvc接收的数据格式化？

上面我们提到Converter接口，springmvc也提供了Formatter接口，这个接口只能在String和java对象之间进行转换，我们通常用在前后端交互上，也就是格式化，我们来看一下格式化的代码：
DateFormat.java

package com.springmvc.pojo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

import org.springframework.format.Formatter;

public class DateFormat implements Formatter<Date>{
	
	private SimpleDateFormat dateFormat = new SimpleDateFormat("Y-M-D");
	
	public String print(Date date, Locale locale) {
		// TODO Auto-generated method stub
		return null;
	}

	public Date parse(String text, Locale locale) throws ParseException {
		// TODO Auto-generated method stub
		System.out.println("bbbbbb");
		return dateFormat.parse(text);
	}

}

格式化实现类实现了Formatter接口，重写了两个方法，其中parse()方法是格式化的方法，在这个方法中我们对接收到的字符串进行处理。
springmvc-config.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 让springmvc扫描controller的包 -->
    <context:component-scan base-package="com.springmvc.controller"></context:component-scan>
	<mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
	<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
		<!-- formatters属性配置格式化实现类 -->
		<property name="formatters">
			<list>
				<bean class="com.springmvc.pojo.DateFormat"></bean>
			</list>
		</property>
	</bean>
</beans>

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>Insert title here</title>
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.8.0.js"></script>
</head>
<body>
	<form action="/Test/test.do" method="post">
		<input type="text" name="birthday" value=""/>
		<input type="text" name="account" value=""/>
		<input type="submit" value="submit"></input>
	</form>
</body>
</html>

ControllerTest.java

package com.springmvc.controller;

import java.util.Date;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class ControllerTest {
    @RequestMapping("/test.do")
    public String ViewTest(@RequestParam Date birthday,@RequestParam String account){
    		System.out.println(birthday);
//    	随意跳转一个界面
    		return "index.jsp";
    }
}

运行处理器，可以正常接收到birthday参数，并且是Date类型，证明前端发送过来的参数已经格式化了。

一个在努力变强的二狗子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
菜鸟的成长之路——springmvc的数据

现在企业基本都在使用html5+js+css作为前端开发，发送过来的数据往往需要我们做各种处理，来满足数据的一致，哪怕使用jsp开发页面也会存在这些问题。或者我们的数据不能以程序的形式展示给用户浏览，不然没有编程基础的用户看的很难甚至看不懂，也有时候同一个页面在不同的国家显示不同的语言等等问题，这些问题我们这节课来研究一下。
复制链接

扫一扫