字符编码-原码反码与补码

java中byte转换int时为何与0xff进行与运算

在剖析该问题前请看如下代码

public static String bytes2HexString(byte[] b) {   
  String ret = "";   
  for (int i = 0; i < b.length; i++) {   
   String hex = Integer.toHexString(b[ i ] & 0xFF);   
   if (hex.length() == 1) {   
    hex = '0' + hex;   
   }   
   ret += hex.toUpperCase();   
  }   
  return ret;   
}

上面是将byte[]转化十六进制的字符串,注意这里b[ i ] & 0xFF将一个byte和 0xFF进行了与运算,然后使用Integer.toHexString取得了十六进制字符串,可以看出
b[ i ] & 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?答案是不行的.

其原因在于:
1.byte的大小为8bits而int的大小为32bits
2.java的二进制采用的是补码形式

在这里先温习下计算机基础理论

byte是一个字节保存的,有8个位,即8个0、1。
8位的第一个位是符号位,
也就是说0000 0001代表的是数字1
1000 0000代表的就是-1
所以正数最大位0111 1111,也就是数字127
负数最大为1111 1111,也就是数字-128

上面说的是二进制原码,但是在java中采用的是补码的形式,下面介绍下什么是补码

1、反码:
一个数如果是正,则它的反码与原码相同;
一个数如果是负,则符号位为1,其余各位是对原码取反;

2、补码:利用溢出,我们可以将减法变成加法
对于十进制数,从9得到5可用减法:
9-4=5    因为4+6=10,我们可以将6作为4的补数
改写为加法:
9+6=15(去掉高位1,也就是减10)得到5.

对于十六进制数,从c到5可用减法:
c-7=5    因为7+9=16 将9作为7的补数
改写为加法:
c+9=15(去掉高位1,也就是减16)得到5.

在计算机中,如果我们用1个字节表示一个数,一个字节有8位,超过8位就进1,在内存中情况为(100000000),进位1被丢弃。

⑴一个数为正,则它的原码、反码、补码相同
⑵一个数为负,刚符号位为1,其余各位是对原码取反,然后整个数加1

– 1的原码为                10000001
– 1的反码为                11111110
+ 1
– 1的补码为                11111111

0的原码为                 00000000
0的反码为                 11111111(正零和负零的反码相同)
+1
0的补码为               100000000(舍掉打头的1,正零和负零的补码相同)

Integer.toHexString的参数是int,如果不进行&0xff,那么当一个byte会转换成int时,由于int是32位,而byte只有8位这时会进行补位,
例如补码11111111的十进制数为-1转换为int时变为11111111111111111111111111111111好多1啊,呵呵!即0xffffffff但是这个数是不对的,这种补位就会造成误差。
和0xff相与后,高24比特就会被清0了,结果就对了。

—-
Java中的一个byte,其范围是-128~127的,而Integer.toHexString的参数本来是int,如果不进行&0xff,那么当一个byte会转换成int时,对于负数,会做位扩展,举例来说,一个byte的-1(即0xff),会被转换成int的-1(即0xffffffff),那么转化出的结果就不是我们想要的了。

而0xff默认是整形,所以,一个byte跟0xff相与会先将那个byte转化成整形运算,这样,结果中的高的24个比特就总会被清0,于是结果总是我们想要的。

来自:https://www.cnblogs.com/Free-Thinker/p/6529584.html

springmvc中级-HttpMessageConverter详解

一、HttpMessageConverter概述

HttpMessageConverter<T> 是 Spring3.0 新添加的一个接 口,负责将请求信息转换为一个对象(类型为 T),将对象( 类型为 T)输出为响应信息。


使用 HttpMessageConverter<T> 将请求信息转化并绑定到处理方法的入 参中或将响应结果转为对应类型的响应信息,Spring 提供了两种途径:
–使用 @RequestBody / @ResponseBody 对处理方法进行标注
–使用 HttpEntity<T> / ResponseEntity<T> 作为处理方法的入参或返回值

当控制器处理方法使用到 @RequestBody/@ResponseBody 或HttpEntity<T>/ResponseEntity<T> 时, Spring 首先根据请求头或响应头的Accept 属性选择匹配的 HttpMessageConverter,  进而根据参数类型或 泛型类型的过滤得到匹配的 HttpMessageConverter, 若找不到可用的HttpMessageConverter 将报错

  • @RequestBody@ResponseBody 不需要成对出现。

ajax发送和接收乱码问题:

因为HttpMessageConverter的几个实现类,都是先查询http请求头的编码方式,然后再解码的,如果没有指定就使用默认的编码方式。比如iso-8859-1。这样会使得中文乱码。

​碰到使用ajax调用spring mvc时出现乱码,这里写一下解决方法。​

一:ajax传入spring mvc时,@RequestBody出现乱码:

这是ajax调用时,传入data编码有误导致,通过以下方式解决(红色字体部分):

前台ajax调用代码:

$.ajax({
  url : baseUrl + “/crlandIsp/commonInfoCreate/save.do”,
  type : “POST”,
  cache : false,
  data : mdata,
  contentType : “text/html;charset=UTF-8”,
  dataType : “json”,
  success : function(result) {

  },
  error : function(xhr, ajaxOptions, thrownError) {
  

  }
 });

二:spring mvc通过@ResponseBody返回时,ajax接收到乱码结果:

修改spring mvc controller代码(添加红色部分),指定响应头编码方式

 @RequestMapping(value = “/queryDetail”,produces = “text/html;charset=UTF-8”)
   public @ResponseBody String save(@RequestBody String body) throws Exception {
       try {

。。。。

}

方法二、修改全局的默认配置编码

<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>

网上也有这种,但是你们是不是<mvc:annotation-driven>不能配置子集
这里只要把你们的spring-mvc-.xsd改成4就可以在<mvc:annotation-driven>下配置了,如下图

主要还是spring-mvc-4.0.xsd。改了之后再eclipse中按ALT+/就会出现如下提示

这边还要注意一点

<property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" />

text/plain这个还是会中文乱码,用text/html就不会


二、HttpMessageConverter应用

1、测试请求体信息

(1)测试带上传文件

utf-8编码的文件:春节.txt

good春节OK
hello

文件二进制为:

676f 6f64 e698 a5e8 8a82 4f4b 0d0a 6865
6c6c 6f

(2)测试网页:

<form action="testRequestBody" method="post" enctype="multipart/form-data" accept-charset="gb2312">
File:<input type="file" name="name-file"/>
Desc:<input type="text" name="name-desc"/>
<input type="submit" name="name-submit" value="submit" />
</form>

(2)测试请求体的控制器:

@ResponseBody
@RequestMapping("/testRequestBody")
public String testHttpMessageConverter(@RequestBody String body){
	System.out.println(body);
	return "helloworld! " + new Date();
}

浏览器fiddler2抓包结果:
(将二进制流用gb2312解码的结果,很明显文件上传时传的是原始二进制流,原始信息是utf-8编码,上传时没有在重新经过编码,于是春节,二字的utf-8编码是 E6 98 A5 E8 8A 82 的二进制流,抓包解码时,将E6 98 A5 E8 8A 82用GB2312解码,于是出现乱码   鏄ヨ妭    ,至于表单中的其他信息 ,因为都采用了gb2312编码,所以解码时就正确了,不会出现乱码 )

POST http://192.168.1.131:8080/springmvc-2/testRequestBody HTTP/1.1
Host: 192.168.1.131:8080
Connection: keep-alive
Content-Length: 410
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: http://192.168.1.131:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryrvTDZPfQOBKllDXv
Referer: http://192.168.1.131:8080/springmvc-2/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Cookie: JSESSIONID=5E065281AC2C661A0098111FB38F3745

------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-file"; filename="春节.txt"
Content-Type: text/plain

good鏄ヨ妭OK
hello
------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-desc"

春节
------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-submit"

submit
------WebKitFormBoundaryrvTDZPfQOBKllDXv--

服务器控制台输出结果:【输出的是请求体】

------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-file"; filename="´º½Ú.txt"
Content-Type: text/plain

good春节OK
hello
------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-desc"

´º½Ú
------WebKitFormBoundaryrvTDZPfQOBKllDXv
Content-Disposition: form-data; name="name-submit"

submit
------WebKitFormBoundaryrvTDZPfQOBKllDXv--

特别备注:控制台返回的请求体中:

##### 针对 filename="´º½Ú.txt" ,
##### 这个 ´º½Ú 是浏览器 用gb2312编码 春节 两字成 B4 BA BD DA 的二进制流,放入请求体中
##### 解码时 springmvc 查看http头,发现没有编码指明,于是默认用 iso-8859-1解码 造成乱码   
Content-Disposition: form-data; name="name-file"; filename="´º½Ú.txt"
##### 下面第三行 也是同样的 原因
Content-Disposition: form-data; name="name-desc"

´º½Ú
##### 总结来说,multipart/form-data 编码的表单,表单中信息都是按 表单规定的编码方式,
##### 直接编码成 二进制流。然后存放到 请求体中。而表单其他自动生成的信息,都是ASCII编码
##### 其实也可以说是按照 表单默认 的编码方式,因为http 用到的编码都是 ASCII码的扩展码,都兼容支持ASCII码
##### 当然 文件上传时 没有进行编码,直接是原始文件的二进制流加入到 请求体中 比如下面的文件信息:
Content-Type: text/plain

good春节OK
hello
------WebKitFormBoundaryrvTDZPfQOBKllDXv
##### 上面的例子中:原始文件信息 已经说过了 是用utf-8编码 成二进制流,utf-8兼容ASCII码,
##### 当 springmvc 接收请求体时,因为发现请求头中没有编码信息 ,所以采用默认的iso-8859-1解码,这个兼容ASCII码
##### 所以  英文字母能够正常解码 ,中文 春节 二字,一开始utf-8编码成 E6 98 A5 E8 8A 82 的二进制流,
##### 后来解码时 ,用ios-8859-1将这些二进制流错误的解码了,导致出现乱码  春节

=========================================================

如果将表单设置成utf-8编码,效果就不一样了。

<form action="testRequestBody" method="post" enctype="multipart/form-data" accept-charset="UTF-8">
File:<input type="file" name="name-file"/>
Desc:<input type="text" name="name-desc"/>
<input type="submit" name="name-submit" value="submit" />
</form>

用utf-8解码抓包时的二进制流:

POST http://192.168.1.131:8080/springmvc-2/testRequestBody HTTP/1.1
Host: 192.168.1.131:8080
Connection: keep-alive
Content-Length: 414
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: http://192.168.1.131:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarySIE2A85QOHmfv0rl
Referer: http://192.168.1.131:8080/springmvc-2/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Cookie: JSESSIONID=69D0B1B2F9AAE721AED15F660424C708

------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-file"; filename="春节.txt"
Content-Type: text/plain

good春节OK
hello
------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-desc"

春节
------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-submit"

submit
------WebKitFormBoundarySIE2A85QOHmfv0rl--

查看服务器控制台输出结果:
所有乱码  春节  都是因为春节的utf-8 编码成二进制流  E6 98 A5 E8 8A 82
后来用iso-8859-1 解码 E6 98 A5 E8 8A 82 时,出现乱码   æ˜¥èŠ‚

------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-file"; filename="春节.txt"
Content-Type: text/plain

good春节OK
hello
------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-desc"

春节
------WebKitFormBoundarySIE2A85QOHmfv0rl
Content-Disposition: form-data; name="name-submit"

submit
------WebKitFormBoundarySIE2A85QOHmfv0rl--

为什么,控制台打印出来的是乱码呢?

debug解析过程:

核心靠AbstractHttpMessageConverter.java 解析body
解码时,首先看请求头的编码,如果没有,则默认iso-8859-1编码。

//类方法 有删减
public class StringHttpMessageConverter extends AbstractHttpMessageConverter<String> {

	public static final Charset DEFAULT_CHARSET = Charset.forName("ISO-8859-1");


	private volatile List<Charset> availableCharsets;

	private boolean writeAcceptCharset = true;


	/**
	 * A default constructor that uses {@code "ISO-8859-1"} as the default charset.
	 * @see #StringHttpMessageConverter(Charset)
	 */
	public StringHttpMessageConverter() {
		this(DEFAULT_CHARSET);
	}

	/**
	 * A constructor accepting a default charset to use if the requested content
	 * type does not specify one.
	 */
	public StringHttpMessageConverter(Charset defaultCharset) {
		super(defaultCharset, MediaType.TEXT_PLAIN, MediaType.ALL);
	}


	/**
	 * Indicates whether the {@code Accept-Charset} should be written to any outgoing request.
	 * <p>Default is {@code true}.
	 */
	public void setWriteAcceptCharset(boolean writeAcceptCharset) {
		this.writeAcceptCharset = writeAcceptCharset;
	}



	@Override
	protected String readInternal(Class<? extends String> clazz, HttpInputMessage inputMessage) throws IOException {
		Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
		return StreamUtils.copyToString(inputMessage.getBody(), charset);
	}



	@Override
	protected void writeInternal(String str, HttpOutputMessage outputMessage) throws IOException {
		if (this.writeAcceptCharset) {
			outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets());
		}
		Charset charset = getContentTypeCharset(outputMessage.getHeaders().getContentType());
		StreamUtils.copy(str, charset, outputMessage.getBody());
	}




}

所以,解决方法也好办了:

1.客户的发送方法稍微改一下,这个方式是最好的:

connection.setRequestProperty("content-type", "text/html;charset=GBk");

2.如果发送方无论如何都没法改,只能服务器端处理的时候,要么所有接收到的数据都 new String(data.getByte(“iso-8859-1″),”GBK”),要么直接自定义StringHttpConverter,将readInternal方法中的charset获取改为不先从请求头中读取,直接硬编码为GBK(当然这样做的后果就是只能接收GBK的数据了).【好像不能自定义,不过上文提到了可以转发配置中配置,修改StringHttpConverter的默认编码值】

2、文件下载

只需要在控制器中,编辑 ResponseEntity<byte[]>就行了。

@RequestMapping("/testResponseEntity")
	public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException{
		byte [] body = null;
		ServletContext servletContext = session.getServletContext();
		InputStream in = servletContext.getResourceAsStream("/files/abc.txt");
		body = new byte[in.available()];
		in.read(body);
		
		HttpHeaders headers = new HttpHeaders();
		headers.add("Content-Disposition", "attachment;filename=abc.txt");
		
		HttpStatus statusCode = HttpStatus.OK;
		
		ResponseEntity<byte[]> response = new ResponseEntity<byte[]>(body, headers, statusCode);
		return response;
	}

 

3、返回json

添加jackson jar包,编写控制器。【如果有中文的json,】

@ResponseBody
@RequestMapping("/testJson")
public Collection<Employee> testJson(){
	return employeeDao.getAll();
}

测试链接:http://localhost:8080/springmvc-2/testJson

 

参考:

测试 request body 问题

https://www.cnblogs.com/chyu/p/5517788.html

https://blog.csdn.net/u013239111/article/details/51347949

http://blog.sina.com.cn/s/blog_b1f34f990102vcm4.html

 

springmvc踩坑-jackson与spring的版本兼容问题

一开始 springmvc  4.3.9版本中,用控制器 handler 返回 json 时,用了 2.1.5 的jackson包,发现还是报错 找不到 类方法。

Jul 15, 2018 1:31:48 PM org.apache.catalina.core.StandardContext filterStart
SEVERE: Exception starting filter HttpPutFormContentFilter
java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/util/DefaultIndenter
	at org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.init(AbstractJackson2HttpMessageConverter.java:97)
	at org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter.<init>(AbstractJackson2HttpMessageConverter.java:90)
	at org.springframework.http.converter.json.MappingJackson2HttpMessageConverter.<init>(MappingJackson2HttpMessageConverter.java:66)
	at org.springframework.http.converter.json.MappingJackson2HttpMessageConverter.<init>(MappingJackson2HttpMessageConverter.java:57)
	at org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter.<init>(AllEncompassingFormHttpMessageConverter.java:61)
	at org.springframework.web.filter.HttpPutFormContentFilter.<init>(HttpPutFormContentFilter.java:63)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at java.lang.Class.newInstance(Class.java:442)
	at org.apache.catalina.core.DefaultInstanceManager.newInstance(DefaultInstanceManager.java:119)
	at org.apache.catalina.core.ApplicationFilterConfig.getFilter(ApplicationFilterConfig.java:258)
	at org.apache.catalina.core.ApplicationFilterConfig.<init>(ApplicationFilterConfig.java:105)
	at org.apache.catalina.core.StandardContext.filterStart(StandardContext.java:4689)
	at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5329)
	at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:147)
	at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1407)
	at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1397)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Caused by: java.lang.ClassNotFoundException: com.fasterxml.jackson.core.util.DefaultIndenter
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1332)
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1166)
	... 23 more

于是改用 jackson 2.9.6的包时,发现成功了,不再报错。

原因是Spring 3.x 和4.X处理JSON的一个类不一样

spring3.x是org.springframework.http.converter.json.MappingJacksonHttpMessageConverter

spring4.x是org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

springmvc中级-返回json详解

一、测试页面

<script type="text/javascript" src="scripts/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
   //测试 json 函数
	$(function(){
		$("#testJson").click(function(){
			var url = this.href;
			var args = {};
			//这个是jQuery版的 ajax 函数 
			$.post(url, args, function(data){
				for(var i = 0; i < data.length; i++){
					var id = data[i].id;
					var lastName = data[i].lastName;
					
					alert(id + ": " + lastName);
				}
			});
			return false;
		});
	})
</script>
</head>

<body>
<a href="testJson" id="testJson">测试json</a>
</body>

二、编辑控制器

返回的是:JSON 对应的对象或集合。
然后 在方法上添加@ResponseBody 注解

@ResponseBody
@RequestMapping("/testJson")
public Collection<Employee> testJson(){
	return employeeDao.getAll();
}

三、遇到转换错误

SEVERE: Servlet.service() for servlet [dispatcherServlet] in context with path [/springmvc-2] threw exception [Request processing failed; nested exception is java.lang.IllegalArgumentException: No converter found for return value of type: class java.util.HashMap$Values] with root cause

后来我发现:缺少转换的jar包。将hashmap 转换成 json。
http://repo1.maven.org/maven2/com/fasterxml/jackson/core/
下载三个jar包:jackson-annotations;jackson-core;jackson-databind

特别强调一个bug:

一开始:下载的三个jar包 jackson-annotations;jackson-core;jackson-databind 版本号是 :2.1.5 结果还是 报错了:

nested exception is java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/util/DefaultIndenter

于是在网上下载了 三个jar包 的 最新版 :2.9.6
结果终于好了,没有再报错了。

springmvc中级-数据绑定流程-数据转化数据格式化数据校验

一、数据绑定流程

  • 1. Spring MVC 主框架将 ServletRequest 对象及目标方 法的入参实例传递给 WebDataBinderFactory 实例,以创建 DataBinder 实例对象
  • 2. DataBinder 调用装配在 Spring MVC 上下文中的 ConversionService 组件进行数据类型转换、数据格式 化工作。将 Servlet 中的请求信息填充到入参对象中
  • 3. 调用 Validator 组件对已经绑定了请求消息的入参对象 进行数据合法性校验,并最终生成数据绑定结果BindingData 对象
  • 4. Spring MVC 抽取 BindingResult 中的入参对象和校验 错误对象,将它们赋给处理方法的响应入参

Spring MVC 通过反射机制对目标处理方法进行解析,将请 求消息绑定到处理方法的入参中。数据绑定的核心部件是DataBinder,运行机制如下:

查看代码-数据绑定流程:

WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
		if (binder.getTarget() != null) {
			if (!mavContainer.isBindingDisabled(name)) {
				bindRequestParameters(binder, webRequest);
			}
			validateIfApplicable(binder, parameter);
			if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
				throw new BindException(binder.getBindingResult());
			}
		}

@InitBinder

  • @InitBinder 标识的方法,可以对 WebDataBinder 对 象进行初始化。WebDataBinder 是 DataBinder 的子类,用 于完成由表单字段到 JavaBean 属性的绑定
  • @InitBinder方法不能有返回值,它必须声明为void。
  • @InitBinder方法的参数通常是是 WebDataBinder
//在控制器中编写的代码
//对内些无法自动绑定的对象,进行特殊处理。比如 表单中的选择器上传Id值,然后这里可以改成name值 
@InitBinder
public void initBinder(WebDataBinder binder){
       //这里代表:将表单中的lastName 不赋值给 bean中的 lastName
       binder.setDisallowedFields("lastName");
}

二、自定义类型转换器

ConversionService 是 Spring 类型转换体系的核心接口。

可以利用 ConversionServiceFactoryBean 在 Spring 的 IOC容器中定义一个 ConversionService. Spring 将自动识别出IOC 容器中的 ConversionService,并在 Bean 属性配置及Spring  MVC 处理方法入参绑定等场合使用它进行数据的转换。

可通过 ConversionServiceFactoryBeanconverters 属性 注册自定义的类型转换器。

======================================================

  • Spring 定义了 3 种类型的转换器接口,实现任意一个转换器接口都可以作为自定义转换器注册到ConversionServiceFactroyBean 中:

Converter<S,T>:将 S 类型对象转为 T 类型对象

ConverterFactory:将相同系列多个 “同质” Converter 封装在一 起。如果希望将一种类型的对象转换为另一种类型及其子类的对 象(例如将 String 转换为 Number 及 Number 子类(Integer、Long、Double 等)对象)可使用该转换器工厂类

GenericConverter:会根据源类对象及目标类对象所在的宿主类中的上下文信息进行类型转换

======================================================

代码参照之前的crud:

测试页面:

<form action="testConversionServiceConverer" method="POST">
	<!-- lastname-email-gender-department.id 例如: [email protected] -->
	Employee: <input type="text" name="employee"/>
	<input type="submit" value="Submit"/>
</form>

控制器处理:

@RequestMapping("/testConversionServiceConverer")
public String testConverter(@RequestParam("employee") Employee employee){
	System.out.println("save: " + employee);
	employeeDao.save(employee);
	return "redirect:/emps";
}

自定义转换器

将表单的 字符串类型 employee  转换成 bean类型  employee;用于表单提交时,传入参数的类型转换。

package com.test.springmvc.test;

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

import com.test.springmvc.crud.entities.Department;
import com.test.springmvc.crud.entities.Employee;

@Component
public class EmployeeConverter implements Converter<String, Employee> {
//自定义转换器必须要  Converter<String, Employee>  然后再去转发配置器中注册
	@Override
	public Employee convert(String source) {
		if(source != null){
			String [] vals = source.split("-");
			//[email protected]
			if(vals != null && vals.length == 4){
				String lastName = vals[0];
				String email = vals[1];
				Integer gender = Integer.parseInt(vals[2]);
				Department department = new Department();
				department.setId(Integer.parseInt(vals[3]));
				
				Employee employee = new Employee(null, lastName, email, gender, department);
				System.out.println(source + "--convert--" + employee);
				return employee;
			}
		}
		return null;
	}

}

 编辑转发配置器

<!-- 配置 ConversionService ,注意下面是 ConversionServiceFactoryBean  -->
	<bean id="conversionService"  class="org.springframework.format.support.ConversionServiceFactoryBean">
		<property name="converters">
			<set>
				<ref bean="employeeConverter"/>
			</set>
		</property>	
	</bean>

<mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>

三、数据格式化

<mvc:annotation-driven/> 默认创建的 ConversionService 实例即为 FormattingConversionServiceFactroyBean。装配了 FormattingConversionServiceFactroyBean 后,就可 以在 Spring MVC 入参绑定及模型数据输出时使用注解驱动 了。

对属性对象的输入/输出进行格式化,从其本质上讲依然 属于 “类型转换” 的范畴。
Spring 在格式化模块中定义了一个实现ConversionService 接口的FormattingConversionService 实现类,该实现类扩展了 GenericConversionService,因此它既具有类型转换的 功能,又具有格式化的功能

FormattingConversionService 拥有一个FormattingConversionServiceFactroyBean 工厂类,  后者用于在 Spring 上下文中构造前者。

FormattingConversionServiceFactroyBean 内部已经注册了 :

–NumberFormatAnnotationFormatterFactroy:支持对数字类型的属性使用 @NumberFormat 注解
–JodaDateTimeFormatAnnotationFormatterFactroy:支持对日期类型的属性使用 @DateTimeFormat 注解

日期格式化

@DateTimeFormat 注解可对
java.util.Date、java.util.Calendar、java.long.Long 时间 类型进行标注:

pattern 属性:类型为字符串。指定解析/格式化字段数据的模式, 如:”yyyy-MM-dd hh:mm:ss”

iso 属性:类型为 DateTimeFormat.ISO。指定解析/格式化字段数据 的ISO模式,包括四种:ISO.NONE(不使用) -- 默认、ISO.DATE(yyyy-MM-dd) 、ISO.TIME(hh:mm:ss.SSSZ)、ISO.DATE_TIME(yyyy-MM-dd hh:mm:ss.SSSZ)

style 属性:字符串类型。通过样式指定日期时间的格式,由两位字 符组成,第一位表示日期的格式,第二位表示时间的格式:S:短日 期/时间格式、M:中日期/时间格式、L:长日期/时间格式、F:完整 日期/时间格式、-:忽略日期或时间格式

数值格式化

@NumberFormat 可对类似数字类型的属性进行标 注,它拥有两个互斥的属性:

style:类型为 NumberFormat.Style。用于指定样式类型,包括三种:Style.NUMBER(正常数字类型)、Style.CURRENCY(货币类型)、 Style.PERCENT(  百分数类型)

pattern:类型为 String,自定义样式, 如patter="#,###";

格式化示例-在crud项目基础上

1、编辑转发配置器

<mvc:annotation-driven></mvc:annotation-driven>

2、编辑表单

<form:form action="${pageContext.request.contextPath }/emp" method="POST" 
	modelAttribute="employee">
	
       <!-- 其他表单项已经省略,主要看对 date 和 salary 表单项的格式化  -->
      	
        <!--  
		1. 数据类型转换
		2. 数据类型格式化
		3. 数据校验. 
		1). 如何校验 ? 注解 ?
		①. 使用 JSR 303 验证标准
		②. 加入 hibernate validator 验证框架的 jar 包
		③. 在 SpringMVC 配置文件中添加 <mvc:annotation-driven />
		④. 需要在 bean 的属性上添加对应的注解
		⑤. 在目标方法 bean 类型的前面添加 @Valid 注解
		2). 验证出错转向到哪一个页面 ?
		注意: 需校验的 Bean 对象和其绑定结果对象或错误对象时成对出现的,它们之间不允许声明其他的入参
		3). 错误消息 ? 如何显示, 如何把错误消息进行国际化
	-->
	Birth: <form:input path="birth"/>
	<br>
	Salary: <form:input path="salary"/>
	<br>
	<input type="submit" value="Submit"/>
</form:form>

3、编辑entity中的employee.java

###### 属性注解 ######
	
@DateTimeFormat(pattern="yyyy-MM-dd")
private Date birth;
	
@NumberFormat(pattern="#,###,###.#")
private Float salary;

###### 属性方法 ######
public Date getBirth() {
	return birth;
}

public void setBirth(Date birth) {
	this.birth = birth;
}

public Float getSalary() {
	return salary;
}

public void setSalary(Float salary) {
	this.salary = salary;
}

4、补充说明

前面三步操作,已经可以支持数据格式化了。如果想加入自定义转换器的话,需要修改一下转发配置器:

<!-- 配置 ConversionService ,下面由原来的 ConversionServiceFactoryBean 转变成 FormattingConversionServiceFactoryBean -->
	<bean id="conversionService"  class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
		<property name="converters">
			<set>
				<ref bean="employeeConverter"/>
			</set>
		</property>	
	</bean>

<mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>

四、出错信息

数据格式类型转换出错信息

在上节的数据格式化中:
@DateTimeFormat(pattern=”yyyy-MM-dd”)
@NumberFormat(pattern=”#,###,###.#”)
这两个注解就是用来格式化的,如果表单中的数据,不符合要求格式时,校验框架会发现错误,并在请求的网页显示错误。但是控制台没有打印错误。这时我们可以在控制器添加错误解析代码就行:

@RequestMapping(value="/emp", method=RequestMethod.POST)
	public String save(Employee employee, BindingResult result, 
			Map<String, Object> map){
		System.out.println("save: " + employee);
		//验证 是否存在 错误信息
		if(result.getErrorCount() > 0){
			System.out.println("出错了!");
			
			for(FieldError error:result.getFieldErrors()){
				System.out.println(error.getField() + ":" + error.getDefaultMessage());
			}
			
			//若验证出错, 则转向定制的页面
			map.put("departments", departmentDao.getDepartments());
			return "addEmp";
		}
		
		employeeDao.save(employee);
		return "redirect:/emps";
	}
  • JSR 303 是 Java 为 Bean 数据合法性校验提供的标准, 它已经包含在 JavaEE 6.0 中 .
  • JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max、@Past 等标准的注解指定校验规则,并通过标准的验证接口对 Bean 进行验证
  • Hibernate Validator 是 JSR 303 的一个参考实现,除支持 所有标准的校验注解外,它还支持以下的扩展注解 @Email,@Length,@NotEmpty,@Range

注意:@Past 代表属性是过去式 ,比如生日;@NotEmpty 代表属性不为空;这些类似的校验注解都需要添加相应的校验jar包。比如:
validation-api-1.1.0.CR1.jar
hibernate-validator-5.0.0.CR2.jar
hibernate-validator-annotation-processor-5.0.0.CR2.jar

添加完jar包后,实际运行时遇到:

Handler dispatch failed; nested exception is java.lang.NoClassDefFoundError: com/fasterxml/classmate/Filter

异常提示缺少类,需要导入jar包:需要导入hibernate中的classmate.jar即可

=========================================================

  • Spring 4.0 拥有自己独立的数据校验框架,同时支持 JSR303 标准的校验框架。
  • Spring 在进行数据绑定时,可同时调用校验框架完成数据校 验工作。在 Spring MVC 中,可直接通过注解驱动的方式 进行数据校验
  • Spring 的 LocalValidatorFactroyBean 既实现了 Spring 的Validator 接口,也实现了 JSR 303 的 Validator 接口。只要 在 Spring 容器中定义了一个 LocalValidatorFactoryBean,即可将其注入到需要数据校 验的 Bean 中。
  • Spring 本身并没有提供 JSR303 的实现,所以必须将JSR303 的实现者的 jar 包放到类路径下。

数据校验出错信息

@DateTimeFormat(pattern=”yyyy-MM-dd”)
@NumberFormat(pattern=”#,###,###.#”)
上面两个已经在 mvc-annotation中的FormattingConversionService 注册好了。不需要额外添加什么。

如果需要在javabean中,实现其他的校验功能
第一步:需要在bean的属性添加:@NotEmpty,@Email,@Past 等注解。如:

@NotEmpty
private String lastName;

@Email
private String email;

第二步:添加jar包

validation-api-1.1.0.CR1.jar
hibernate-validator-5.0.0.CR2.jar
hibernate-validator-annotation-processor-5.0.0.CR2.jar

classmate-1.0.0.jar

第三步:编辑控制器 (关键是在 形参bean上 添加 @Valid 注解)

 //处理添加雇员请求,并重定向到 	@RequestMapping("/emps")
    @RequestMapping(value="emp", method=RequestMethod.POST)
    public String addEmp(@Valid Employee employee ,BindingResult result, 
			Map<String, Object> map){
		System.out.println("save: " + employee);
		//验证 是否存在 错误信息
		if(result.getErrorCount() > 0){
			System.out.println("出错了!");
			
			for(FieldError error:result.getFieldErrors()){
				System.out.println(error.getField() + ":" + error.getDefaultMessage());
			}
			
			//若验证出错, 则转向定制的页面
			map.put("departments", departmentDao.getDepartments());
			return "addEmp";
		}
		
    	employeeDao.save(employee);
    	return "redirect:/emps";
		
	}

结果:参考控制台 输出信息:

save: Employee [id=null, lastName=12, email=123, gender=0, department=Department [id=101, departmentName=null], birth=null, salary=null]
出错了!
birth:Failed to convert property value of type 'java.lang.String' to required type 'java.util.Date' for property 'birth'; nested exception is org.springframework.core.convert.ConversionFailedException: Failed to convert from type [java.lang.String] to type [@javax.validation.constraints.Past @org.springframework.format.annotation.DateTimeFormat java.util.Date] for value '213'; nested exception is java.lang.IllegalArgumentException: Parse attempt failed for value [213]
salary:Failed to convert property value of type 'java.lang.String' to required type 'java.lang.Float' for property 'salary'; nested exception is java.lang.NumberFormatException: multiple points
email:not a well-formed email address

补充:
<mvc:annotation-driven/> 会默认装配好一个LocalValidatorFactoryBean,通过在处理方法的入参上标 注 @valid 注解即可让 Spring MVC 在完成数据绑定后执行 数据校验的工作,并将校 验结果保存在被校验入参对象之后的 BindingResult 或 Errors 入参中。常用方法:
FieldError getFieldError(String field)
List getFieldErrors()
Object getFieldValue(String field)
Int getErrorCount()

Spring MVC 是通过对处理方法签名的规约来保存校验结果 的:前一个表单/命令对象的校验结果保存到随后的入参中,这个保存校验结果的入参必须是 BindingResultErrors 类型,这两个类都位于org.springframework.validation 包中

======================================================
需校验的 Bean 对象和其绑定结果对象或错误对象时成对出现的,它们之间不允许声明其他的入参。

//BindingResult 扩展了 Errors 接口。在控制器中,两种可以都可以用来放校验结果
//Errors 接口提供了获取错误信息的方法,如 getErrorCount() 或getFieldErrors(String field)。
public String handle 91(@Valid User user, BindingResult userBindingResult,  String sessionId,ModelMap mm, @Valid Dept dept, Errors deptErrors){

}

页面展示错误信息

  • Spring MVC 除了会将表单/命令对象的校验结果保存到对 应的 BindingResult 或 Errors 对象中外,还会将所有校验 结果保存到 隐含模型
  • 即使处理方法的签名中没有对应于表单/命令对象的结果 入参,校验结果也会保存在 “隐含对象” 中。
  • 隐含模型中的所有数据最终将通过 HttpServletRequest 的 属性列表暴露给 JSP 视图对象,因此在 JSP 中可以获取 错误信息
  • 在 JSP 页面上可通过 <form:errors path=“userName”>显示错误消息

页面展示国际化出错信息

1、新建国际化文件

i18n.properties

NotEmpty.employee.lastName=LastName\u4E0D\u80FD\u4E3A\u7A7A.
Email.employee.email=Email\u5730\u5740\u4E0D\u5408\u6CD5

###Birth不能是一个将来的时间
Past.employee.birth=Birth\u4E0D\u80FD\u662F\u4E00\u4E2A\u5C06\u6765\u7684\u65F6\u95F4. 

###########上面是数据校验 的错误信息,下面是类型转换 的错误信息############

####Birth不是一个日期
typeMismatch.employee.birth=Birth\u4E0D\u662F\u4E00\u4E2A\u65E5\u671F. 

数据校验错误key值:以校验注解类名为前缀+结合 modleAttribute+属性名属性类型名
比如key值:NotEmpty.employee.lastName
value值:LastName\u4E0D\u80FD\u4E3A\u7A7A.

类型转换错误key值:类型转换错误码+结合 modleAttribute+属性名属性类型名
比如key值:typeMismatch.employee.birth
value值:Birth\u4E0D\u662F\u4E00\u4E2A\u65E5\u671F.

类型转换错误:都会在隐含模型 中创建错误消息。其错误代码前缀说明如下:
required:必要的参数不存在。如 @RequiredParam(“param1”)标注了一个入参,但是该参数不存在
typeMismatch:在数据绑定时,发生数据类型不匹配的问题
methodInvocation:Spring MVC 在调用处理方法时发生了错误

2、在转发配置器中注册国际化资源文件:

<!-- 配置国际化资源文件 -->
<bean id="messageSource"
	class="org.springframework.context.support.ResourceBundleMessageSource">
	<property name="basename" value="i18n"></property>	
</bean>

 

 

 

springmvc中级-mvc:annotation-driven解析

一、常用场景

1、编辑转发器配置器,实现特定url直接跳转时,不需要handler处理。但是会导致其他需要handler处理的url,失效。所以用 mvc:annotation-driven  解决失效问题。

2、编辑转发器配置器,实现静态资源请求,不需要handler处理。但是会导致其他需要handler处理的url,失效。所以用 mvc:annotation-driven  解决失效问题。

3、自定义类型转换器时,需要 mvc:annotation-driven的 ConversionService 属性,来标记已自定义的类型转换器。

二、应用解析

<mvc:annotation-driven /> 会自动注册RequestMappingHandlerMappingRequestMappingHandlerAdapter 与ExceptionHandlerExceptionResolver  三个bean。

还将提供以下支持:
–支持使用 ConversionService 实例对表单参数进行类型转换
–支持使用 @NumberFormat @DateTimeFormat注解完成数据类型的格式化
–支持使用 @Valid 注解对 JavaBean 实例进行 JSR 303 验证
–支持使用 @RequestBody@ResponseBody 注解

springmvc运算-基础练手项目(5)-项目代码小结

一、项目代码概览

二、配置文件

1、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_2_5.xsd" id="WebApp_ID" version="2.5">
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <servlet>
    <servlet-name>dispatcherServlet</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>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

2、转发配置器

在web.xml中已经取了名字叫: 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: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.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

	<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.test.springmvc"></context:component-scan>

	<!-- 配置视图解析器 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>

   <!--  
		default-servlet-handler 将在 SpringMVC 上下文中定义一个 DefaultServletHttpRequestHandler,
		它会对进入 DispatcherServlet 的请求进行筛查, 如果发现是没有经过映射的请求, 就将该请求交由 WEB 应用服务器默认的 
		Servlet 处理. 如果不是静态资源的请求,才由 DispatcherServlet 继续处理

		一般 WEB 应用服务器默认的 Servlet 的名称都是 default.
		若所使用的 WEB 服务器的默认 Servlet 名称不是 default,则需要通过 default-servlet-name 属性显式指定
		
	-->
	<mvc:default-servlet-handler/>
	<!-- 前面的 mvc:default-servlet-handler 可以解决静态资源了,但是让其他经过handler的请求,又失效了,所以配置了下面的 mvc:annotation-driven 来解决问题 -->
	<mvc:annotation-driven></mvc:annotation-driven>	
	

</beans>

三、处理逻辑

1、handler

EmployeeHandler.java

package com.test.springmvc.crud.handlers;

import java.util.Map;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.Errors;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.test.springmvc.crud.dao.DepartmentDao;
import com.test.springmvc.crud.dao.EmployeeDao;
import com.test.springmvc.crud.entities.Employee;



@Controller
public class EmployeeHandler {

	@Autowired
	private EmployeeDao employeeDao;
	
	@Autowired
	private DepartmentDao departmentDao;
	
	//该控制器中,运行所有方法前的预处理
	//【这里主要是为了在修改修改雇员信息中,率先创建pojo并进行赋值,
	//避免表单因为缺少一些字段导致赋值给pojo的属性一些为空,当然pojo是同一个】
	@ModelAttribute
	public void getEmployee(@RequestParam(value="id",required=false) Integer id,
			Map<String, Object> map){
		if(id != null){
			map.put("employee", employeeDao.get(id));
		}
	}

	//利用pojo更新雇员信息
	@RequestMapping(value="/emp",method=RequestMethod.PUT)
	public String updateEmp(Employee employee){
		employeeDao.save(employee);
		return "redirect:/emps";
	}
	
	//跳转到更新雇员信息页面
	@RequestMapping(value="/emp/{id}",method=RequestMethod.GET)
	public String doUpdateEmp(@PathVariable("id") Integer id,Map<String, Object> map){
		map.put("employee", employeeDao.get(id));
		map.put("departments", departmentDao.getDepartments());
		return "updateEmp";
	}

	
	
	//在所有雇员信息页,进行删除雇员操作  //跳转部分不需要了,本身就是跳转到显示有雇员信息页
	@RequestMapping(value="/emp/{id}",method=RequestMethod.DELETE)
	public String deleteEmp(@PathVariable("id") Integer id){
        employeeDao.delete(id);	
        System.out.println("hello delete");
		return "redirect:/emps";
	}

	
	//跳转到添加雇员信息页面
    @RequestMapping("/doAddEmp")
	public String doAddEmp(Map<String, Object> map){
    	//为了提供在添加页面,部门列表
    	map.put("departments",departmentDao.getDepartments());
    	//为了提供雇员信息的回显值,添加一个空的雇员信息
    	map.put("employee", new Employee());
    	return "addEmp";
    }
	
    //处理添加雇员请求,并重定向到 	@RequestMapping("/emps")
    @RequestMapping(value="emp", method=RequestMethod.POST)
    public String addEmp(Employee employee) {
    	employeeDao.save(employee);
    	return "redirect:/emps";
		
	}
	
	//跳转到查看所有雇员信息页
    @RequestMapping("doGetEmps")
	public String doGetEmps(){
    	return "getEmps";
    }
    
	//查看所有雇员信息,采用默认的get方法,属于crud操作
	@RequestMapping("/emps")
	public String getEmps(Map<String, Object> map){
		map.put("employees", employeeDao.getAll());
		return "showGetEmps";
	}


	
}

2、bean

Employee.java

package com.test.springmvc.crud.entities;

import java.util.Date;

import javax.validation.constraints.Past;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

public class Employee {

	private Integer id;
	
	private String lastName;

	private String email;
	//1 male, 0 female
	private Integer gender;
	
	private Department department;
	

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Integer getGender() {
		return gender;
	}

	public void setGender(Integer gender) {
		this.gender = gender;
	}

	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

	
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + ", department=" + department
				+ "]";
	}

	public Employee(Integer id, String lastName, String email, Integer gender,
			Department department) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.department = department;
	}

	public Employee() {
		// TODO Auto-generated constructor stub
	}
}

Department.java

package com.test.springmvc.crud.entities;

public class Department {

	private Integer id;
	private String departmentName;

	public Department() {
		// TODO Auto-generated constructor stub
	}
	
	public Department(int i, String string) {
		this.id = i;
		this.departmentName = string;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getDepartmentName() {
		return departmentName;
	}

	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}

	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName
				+ "]";
	}
	
}

3、dao

EmployeeDao.java

package com.test.springmvc.crud.dao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.test.springmvc.crud.entities.Department;
import com.test.springmvc.crud.entities.Employee;


@Repository
public class EmployeeDao {

	private static Map<Integer, Employee> employees = null;
	
	@Autowired
	private DepartmentDao departmentDao;
	
	static{
		employees = new HashMap<Integer, Employee>();

		employees.put(1001, new Employee(1001, "E-AA", "[email protected]", 1, new Department(101, "D-AA")));
		employees.put(1002, new Employee(1002, "E-BB", "[email protected]", 1, new Department(102, "D-BB")));
		employees.put(1003, new Employee(1003, "E-CC", "[email protected]", 0, new Department(103, "D-CC")));
		employees.put(1004, new Employee(1004, "E-DD", "[email protected]", 0, new Department(104, "D-DD")));
		employees.put(1005, new Employee(1005, "E-EE", "[email protected]", 1, new Department(105, "D-EE")));
	}
	
	private static Integer initId = 1006;
	
	public void save(Employee employee){
		if(employee.getId() == null){
			employee.setId(initId++);
		}
		
		employee.setDepartment(departmentDao.getDepartment(employee.getDepartment().getId()));
		employees.put(employee.getId(), employee);
	}
	
	public Collection<Employee> getAll(){
		return employees.values();
	}
	
	public Employee get(Integer id){
		return employees.get(id);
	}
	
	public void delete(Integer id){
		employees.remove(id);
	}
}

DepartmentDao.java

package com.test.springmvc.crud.dao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Repository;

import com.test.springmvc.crud.entities.Department;


@Repository
public class DepartmentDao {

	private static Map<Integer, Department> departments = null;
	
	static{
		departments = new HashMap<Integer, Department>();
		
		departments.put(101, new Department(101, "D-AA"));
		departments.put(102, new Department(102, "D-BB"));
		departments.put(103, new Department(103, "D-CC"));
		departments.put(104, new Department(104, "D-DD"));
		departments.put(105, new Department(105, "D-EE"));
	}
	
	public Collection<Department> getDepartments(){
		return departments.values();
	}
	
	public Department getDepartment(Integer id){
		return departments.get(id);
	}
	
}

四、jsp页面

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/fmt" %>

<!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>
</head>
<body>

<a href="doGetEmps">转到请求所有雇员信息页</a>
<br>
<a href="doAddEmp">转到添加雇员信息页</a>

</body>
</html>

getEmps.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/fmt" %>

<!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>
</head>
<body>

<a href="emps">请求所有雇员信息(超链接属于get请求)</a>

</body>
</html>

showGetEmps.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!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>Get All</title>


<!--  
	SpringMVC 处理静态资源:
	1. 为什么会有这样的问题:
	优雅的 REST 风格的资源URL 不希望带 .html 或 .do 等后缀
	若将 DispatcherServlet 请求映射配置为 /, 
	则 Spring MVC 将捕获 WEB 容器的所有请求, 包括静态资源的请求, SpringMVC 会将他们当成一个普通请求处理, 
	因找不到对应处理器将导致错误。
	2. 解决: 在 SpringMVC 的配置文件中配置 <mvc:default-servlet-handler/>
-->
<script type="text/javascript" src="scripts/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
	$(function(){
		alert("hello jquery");
		$(".delete").click(function(){
			var href = $(this).attr("href");
			$("form").attr("action", href).submit();			
			return false;
		});
	})
</script>


</head>
<body>

    <form action="" method="POST">
		<input type="hidden" name="_method" value="DELETE"/>
	</form>

	<c:if test="${empty requestScope.employees}">
没有任何员工信息
</c:if>
	<c:if test="${ !empty requestScope.employees }">
		<table border="1" cellpadding="10" cellspacing="0">
			<tr>
				<th>ID</th>
				<th>LastName</th>
				<th>Email</th>
				<th>Gender</th>
				<th>Department</th>
				<th>Edit</th>
				<th>Delete</th>
			</tr>

			<c:forEach items="${requestScope.employees }" var="emp">
			<tr>
			<td>${emp.id}</td>
            <td>${emp.lastName}</td>
            <td>${emp.email}</td>	            
			<td>${emp.gender==0? "Female":"Male"}</td>					
			<td>${emp.department.departmentName}</td>			
			<td><a href="emp/${emp.id}">Edit</a></td>
			<td><a class="delete" href="emp/${emp.id}">Delete</a></td>			
			</tr>
			</c:forEach>
		</table>
	</c:if>


</body>
</html>

addEmp.jsp

<%@ page import="java.util.HashMap"%>
<%@ page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!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>
</head>
<body>

	<!--  
		1. WHY 使用 form 标签呢 ?
		可以更快速的开发出表单页面, 而且可以更方便的进行表单值的回显
		2. 注意:
		可以通过 modelAttribute 属性指定绑定的模型属性,
		若没有指定该属性,则默认从 request 域对象中读取 command 的表单 bean
		如果该属性值也不存在,则会发生错误。
		
		大白话:form:form 表单标签,在springmvc中是一定要回显的,哪怕是第一次也要支持回显。
		所以第一次请求时,form:form 表单标签会从 request域中的 关键字中查找 默认值是command(如果 form:form标签 指定modelAttribute="XXX",则按照XXX关键字来)  查看属性值,用来填充表单值。
	
	-->
	
    <!-- 表单 路径也可以是  action="emp" -->
	<form:form action="${pageContext.request.contextPath }/emp" method="post" modelAttribute="employee">
		<!-- path标签对应 html表单标签的 name属性值,支持级联 如 path="department.id" -->
       LastName:<form:input path="lastName"  />
		<br>
       Email:<form:input path="email" />
		<%
			Map<String, String> genders = new HashMap();
				genders.put("1", "Male");
				genders.put("0", "Female");
				request.setAttribute("genders", genders);
		%>
		<br>
     Gender:<form:radiobuttons path="gender" items="${genders}" />
     <br>
     Department:<form:select path="department.id" items="${departments}" itemLabel="departmentName" itemValue="id"></form:select>
     <br>
		<input type="submit" value="submit" />
	</form:form>

</body>
</html>

updateEmp.jsp

<%@ page import="java.util.HashMap"%>
<%@ page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!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>
</head>
<body>

	<!--  
		1. WHY 使用 form 标签呢 ?
		可以更快速的开发出表单页面, 而且可以更方便的进行表单值的回显
		2. 注意:
		可以通过 modelAttribute 属性指定绑定的模型属性,
		若没有指定该属性,则默认从 request 域对象中读取 command 的表单 bean
		如果该属性值也不存在,则会发生错误。
		
		大白话:form:form 表单标签,在springmvc中是一定要回显的,哪怕是第一次也要支持回显。
		所以第一次请求时,form:form 表单标签会从 request域中的 关键字中查找 默认值是command(如果 form:form标签 指定modelAttribute="XXX",则按照XXX关键字来)  查看属性值,用来填充表单值。
	
	-->
    <!-- 表单 路径不可以是  action="emp" ,因为是 相对路径 只会在最后一个 目录 替换文件
    比如 http://localhost:8080/springmvc-2/emp/1003 提交后 变成 http://localhost:8080/springmvc-2/emp/emp  -->
	<form:form action="${pageContext.request.contextPath }/emp" method="post" modelAttribute="employee">
	<!-- pageContext.request.contextPath 如果项目放在根目录,就返回 -> ""  (空字符串)   如果不是就返回-> "/项目名" -->
       
       <c:if test="${employee.id == null }">
			<!-- 这个lastName的属性是不会出现的,
			这里用 if条件是因为 updateEmp.jsp 和 addEmp.jsp 本来混在一起用if 作为判断区分的 -->
			<!-- path标签对应 html表单标签的 name属性值,支持级联 如 path="department.id" -->		
			LastName: <form:input path="lastName"/>
		</c:if>
		<br>
       
       Email:<form:input path="email" />
       
		<form:hidden path="id"/>
		<input type="hidden" name="_method" value="PUT"/>
			<%-- 对于 _method 不能使用 form:hidden 标签, 因为 modelAttribute 对应的 bean 中没有 _method 这个属性 --%>
			<%-- <form:hidden path="_method" value="PUT"/> --%>
		
		<%
			Map<String, String> genders = new HashMap <String, String>() ;
				genders.put("1", "Male");
				genders.put("0", "Female");
				request.setAttribute("genders", genders);
		%>
		<br>
     Gender:<form:radiobuttons path="gender" items="${genders}" />
     <br>
     Department:<form:select path="department.id" items="${departments}" itemLabel="departmentName" itemValue="id"></form:select>
     <br>
		<input type="submit" value="submit" />
	</form:form>

</body>
</html>

 

springmvc运算-基础练手项目(4)-更新操作

springmvc错误心得:jstl表单标签

1、在jsp页面中, 因为springmvc要求  jstl的表单标签<form:xxx>  具有回显值。

<form:form action="${pageContext.request.contextPath }/emp" method="POST" modelAttribute="employee">

<form:hidden path="id"/>
<br>
Email: <form:input path="email"/>
<br>
<input type="hidden" name="_method" value="PUT"/>
<%-- 对于 _method 不能使用 form:hidden 标签, 因为 modelAttribute 对应的 bean 中没有 _method 这个属性 --%>
<%--  <form:hidden path="_method" value="PUT"/> --%>

<input type="submit" value="Submit"/>

</form:form>

注意:<form:xxx>标签下的path
1、对应html表单标签的 name属性值,支持级联 如 path=”department.id”
2、如同<form:input path=”email”/>一样,一开始从request中的某个域的bean值映射过来,最后又将结果 pojo返回给handler控制器。如果表单中缺少了一些字段,导致pojo中的一些属性无法被映射,会导致该赋值为空。解决办法就是利用@ModelAttribute ,在表单字段映射到pojo前,控制器先预处理创建一个pojo,然后对pojo的属性赋值【这样可以避免pojo中表单无法映射的属性仍为空值】。后面表单映射到pojo时,不再新创建pojo,只用控制器预创建好的pojo进行赋值。


一、配置文件

web.xml 和 springmvc.xml 配置文件和查询所有雇员信息的配置相同。

二、请求测试页

1、在showGetEmps.jsp页面中配置   删除模块的超链接。

<td><a href="emp/${emp.id}">Edit</a></td>

2、跳转到正式编辑页  updateEmp.jsp

<%@ page import="java.util.HashMap"%>
<%@ page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!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>
</head>
<body>

	<!--  
		1. WHY 使用 form 标签呢 ?
		可以更快速的开发出表单页面, 而且可以更方便的进行表单值的回显
		2. 注意:
		可以通过 modelAttribute 属性指定绑定的模型属性,
		若没有指定该属性,则默认从 request 域对象中读取 command 的表单 bean
		如果该属性值也不存在,则会发生错误。
		
		大白话:form:form 表单标签,在springmvc中是一定要回显的,哪怕是第一次也要支持回显。
		所以第一次请求时,form:form 表单标签会从 request域中的 关键字中查找 默认值是command(如果 form:form标签 指定modelAttribute="XXX",则按照XXX关键字来)  查看属性值,用来填充表单值。
	
	-->
 <!-- 表单 路径不可以是  action="emp" ,因为是 相对路径 只会在最后一个 目录 替换文件
    比如 http://localhost:8080/springmvc-2/emp/1003 提交后 变成 http://localhost:8080/springmvc-2/emp/emp  -->
	<form:form action="${pageContext.request.contextPath }/emp" method="post" modelAttribute="employee">
	<!-- pageContext.request.contextPath 如果项目放在根目录,就返回 -> "" (空字符串)    如果不是就返回-> "/项目名" -->
       
       <c:if test="${employee.id == null }">
			<!-- 这个lastName的属性是不会出现的,
			这里用 if条件是因为 updateEmp.jsp 和 addEmp.jsp 本来混在一起用if 作为判断区分的 -->
		<!-- path标签对应 html表单标签的 name属性值,支持级联 如 path="department.id" -->			
                        LastName: <form:input path="lastName"/>
		</c:if>
		<br>
       Email:<form:input path="email" />
       
		<form:hidden path="id"/>
		<input type="hidden" name="_method" value="PUT"/>
			<%-- 对于 _method 不能使用 form:hidden 标签, 因为 modelAttribute 对应的 bean 中没有 _method 这个属性 --%>
			<%-- <form:hidden path="_method" value="PUT"/> --%>
		
		<%
			Map<String, String> genders = new HashMap <String, String>() ;
				genders.put("1", "Male");
				genders.put("0", "Female");
				request.setAttribute("genders", genders);
		%>
		<br>
     Gender:<form:radiobuttons path="gender" items="${genders}" />
     <br>
     Department:<form:select path="department.id" items="${departments}" itemLabel="departmentName" itemValue="id"></form:select>
     <br>
		<input type="submit" value="submit" />
	</form:form>

</body>
</html>

三、控制器处理

//该控制器中,运行所有方法前的预处理
	//【这里主要是为了在修改修改雇员信息中,率先创建pojo并进行赋值,
	//避免表单因为缺少一些字段导致赋值给pojo的属性一些为空,当然pojo是同一个】
	@ModelAttribute
	public void getEmployee(@RequestParam(value="id",required=false) Integer id,
			Map<String, Object> map){
		if(id != null){
			map.put("employee", employeeDao.get(id));
		}
	}

	//利用pojo更新雇员信息
	@RequestMapping(value="/emp",method=RequestMethod.PUT)
	public String updateEmp(Employee employee){
		employeeDao.save(employee);
		return "redirect:/emps";
	}
	
	//跳转到更新雇员信息页面
	@RequestMapping(value="/emp/{id}",method=RequestMethod.GET)
	public String doUpdateEmp(@PathVariable("id") Integer id,Map<String, Object> map){
		map.put("employee", employeeDao.get(id));
		map.put("departments", departmentDao.getDepartments());
		return "updateEmp";
	}

四、结果响应页

其实就是showGetEmps.jsp

 

springmvc踩坑-控制器中的根目录与路径映射

在springmvc中,@RequestMapping的值可以/xxx,也可以是xxx,效果一样

@RequestMapping(value="/emp/{id}",method=RequestMethod.DELETE)

特别注意一下,在rest风格中 请求页面如果是 “emp/${emp.id} ,那么处理器的RequestMapping值也要是 /emp/{id} 不用写错成 /emp 导致无法访问

另一方面:控制器的返回值 return “redirect:/emps”; 指明重定向和转发的都要用用绝对路径,否则路径解析就出错了。