一、简介
在springmvc 中，控制器controller 负责处理由dispatcherservlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个model ，然后再把该model 返回给对应的view 进行展示。在springmvc 中提供了一个非常简便的定义controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@controller 标记一个类是controller ，然后使用@requestmapping 和@requestparam 等一些注解用以定义url 请求和controller 方法之间的映射，这样的controller 就能被外界访问到。此外controller 不会直接依赖于httpservletrequest 和httpservletresponse 等httpservlet 对象，它们可以通过controller 的方法参数灵活的获取到。为了先对controller 有一个初步的印象，以下先定义一个简单的controller ：
例1:
我要评论
@controller
public class mycontroller {
@requestmapping ( "/showview" )
public modelandview showview() {
modelandview modelandview = new modelandview();
modelandview.setviewname( "viewname" );
modelandview.addobject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
return modelandview;
}
}
在上面的示例中，@controller 是标记在类mycontroller 上面的，所以类mycontroller 就是一个springmvc controller 对象了，然后使用@requestmapping(“/showview”) 标记在controller 方法上，表示当请求/showview.do 的时候访问的是mycontroller 的showview 方法，该方法返回了一个包括model 和view 的modelandview 对象。这些在后续都将会详细介绍。
二、使用 @controller 定义一个 controller 控制器
例1所示@controller 用于标记在一个类上，使用它标记的类就是一个springmvc controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@requestmapping 注解。@controller 只是定义了一个控制器类，而使用@requestmapping 注解的方法才是真正处理请求的处理器，这个接下来就会讲到。
单单使用@controller 标记在一个类上还不能真正意义上的说它就是springmvc 的一个控制器类，因为这个时候spring 还不认识它。那么要如何做spring 才能认识它呢？这个时候就需要我们把这个控制器类交给spring 来管理。
这个时候有两种方式可以把mycontroller 交给spring 管理，好让它能够识别我们标记的@controller 。
第一种方式是在springmvc 的配置文件中定义mycontroller 的bean 对象。
<bean class="com.host.app.web.controller.mycontroller"/>
第二种方式是在springmvc 的配置文件中告诉spring 该到哪里去找标记为@controller 的controller 控制器。
< context:component-scan base-package = "com.host.app.web.controller" >
< context:exclude-filter type = "annotation"
expression = "org.springframework.stereotype.service" />
</ context:component-scan >
注：
上面 context:exclude-filter 标注的是不扫描 @service 标注的类
三、使用 @requestmapping 来映射 request 请求与处理器
例1可以使用@requestmapping 来映射url 到控制器类，或者是到controller 控制器的处理方法上。当@requestmapping 标记在controller 类上的时候，里面使用@requestmapping 标记的方法的请求地址都是相对于类上的@requestmapping 而言的；当controller 类上没有标记@requestmapping 注解时，方法上的@requestmapping 都是绝对路径。这种绝对路径和相对路径所组合成的最终路径都是相对于根路径“/ ”而言的。
在这个控制器中，因为mycontroller 没有被@requestmapping 标记，所以当需要访问到里面使用了@requestmapping 标记的showview 方法时，就是使用的绝对路径/showview.do 请求就可以了。
例2
@controller
@requestmapping ( "/test" )
public class mycontroller {
@requestmapping ( "/showview" )
public modelandview showview() {
modelandview modelandview = new modelandview();
modelandview.setviewname( "viewname" );
modelandview.addobject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
return modelandview;
}
}
例2是在控制器上加了@requestmapping 注解，所以当需要访问到里面使用了@requestmapping 标记的方法showview() 的时候就需要使用showview 方法上@requestmapping 相对于控制器mycontroller上@requestmapping 的地址，即/test/showview.do 。
（一）使用 uri 模板
uri 模板就是在uri 中给定一个变量，然后在映射的时候动态的给该变量赋值。如uri 模板http://localhost/app/{variable1}/ ，这个模板里面包含一个变量variable1 ，那么当我们请求http://localhost/app/hello/ 的时候，该url 就跟模板相匹配，只是把模板中的variable1 用hello 来取代。在springmvc 中，这种取代模板中定义的变量的值也可以给处理器方法使用，这样我们就可以非常方便的实现url 的restful 风格。这个变量在springmvc 中是使用@pathvariable 来标记的。在springmvc 中，我们可以使用@pathvariable 来标记一个controller 的处理方法参数，表示该参数的值将使用uri 模板中对应的变量的值来赋值。
例3
@controller
@requestmapping ( "/test/{variable1}" )
public class mycontroller {
@requestmapping ( "/showview/{variable2}" )
public modelandview showview( @pathvariable string variable1, @pathvariable ( "variable2" ) int variable2) {
modelandview modelandview = new modelandview();
modelandview.setviewname( "viewname" );
modelandview.addobject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
return modelandview;
}
}
在例3的代码中我们定义了两个uri 变量，一个是控制器类上的variable1 ，一个是showview 方法上的variable2 ，然后在showview 方法的参数里面使用@pathvariable 标记使用了这两个变量。所以当我们使用/test/hello/showview/2.do 来请求的时候就可以访问到mycontroller 的showview 方法，这个时候variable1 就被赋予值hello ，variable2 就被赋予值2 ，然后我们在showview 方法参数里面标注了参数variable1 和variable2 是来自访问路径的path 变量，这样方法参数variable1 和variable2 就被分别赋予hello 和2 。方法参数variable1 是定义为string 类型，variable2 是定义为int 类型，像这种简单类型在进行赋值的时候spring 是会帮我们自动转换的，关于复杂类型该如何来转换在后续内容中将会讲到。
在上面的代码中我们可以看到在标记variable1 为path 变量的时候我们使用的是@pathvariable ，而在标记variable2 的时候使用的是@pathvariable(“variable2”) 。这两者有什么区别呢？第一种情况就默认去uri 模板中找跟参数名相同的变量，但是这种情况只有在使用debug 模式进行编译的时候才可以，而第二种情况是明确规定使用的就是uri 模板中的variable2 变量。当不是使用debug 模式进行编译，或者是所需要使用的变量名跟参数名不相同的时候，就要使用第二种方式明确指出使用的是uri 模板中的哪个变量。
除了在请求路径中使用uri 模板，定义变量之外，@requestmapping 中还支持通配符“* ”。如下面的代码我就可以使用/mytest/whatever/wildcard.do 访问到controller 的testwildcard 方法。
@controller
@requestmapping ( "/mytest" )
public class mycontroller {
@requestmapping ( "*/wildcard" )
public string testwildcard() {
system. out .println( "wildcard------------" );
return "wildcard" ;
}
}
（二）使用 @requestparam 绑定 httpservletrequest 请求参数到控制器方法参数
例4
@requestmapping ( "requestparam" )
public string testrequestparam( @requestparam(required=false) string name, @requestparam ( "age" ) int age) {
return "requestparam" ;
}
在上面代码中利用@requestparam 从httpservletrequest 中绑定了参数name 到控制器方法参数name ，绑定了参数age 到控制器方法参数age 。值得注意的是和@pathvariable 一样，当你没有明确指定从request 中取哪个参数时，spring 在代码是debug 编译的情况下会默认取更方法参数同名的参数，如果不是debug 编译的就会报错。此外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@requestparam 中明确指出是要绑定哪个参数。在上面的代码中如果我访问/requestparam.do?name=hello&age=1 则spring 将会把request请求参数name 的值hello 赋给对应的处理方法参数name ，把参数age 的值1 赋给对应的处理方法参数age 。
在@requestparam 中除了指定绑定哪个参数的属性value 之外，还有一个属性required ，它表示所指定的参数是否必须在request 属性中存在，默认是true ，表示必须存在，当不存在时就会报错。在上面代码中我们指定了参数name 的required 的属性为false ，而没有指定age 的required 属性，这时候如果我们访问/requestparam.do而没有传递参数的时候，系统就会抛出异常，因为age 参数是必须存在的，而我们没有指定。而如果我们访问/requestparam.do?age=1 的时候就可以正常访问，因为我们传递了必须的参数age ，而参数name 是非必须的，不传递也可以。
（三）使用 @cookievalue 绑定 cookie 的值到 controller 方法参数
例5
@requestmapping ( "cookievalue" )
public string testcookievalue( @cookievalue ( "hello" ) string cookievalue, @cookievalue string hello) {
system. out .println(cookievalue + "-----------" + hello);
return "cookievalue" ;
}
在上面的代码中我们使用@cookievalue 绑定了cookie 的值到方法参数上。上面一共绑定了两个参数，一个是明确指定要绑定的是名称为hello 的cookie 的值，一个是没有指定。使用没有指定的形式的规则和@pathvariable、@requestparam 的规则是一样的，即在debug 编译模式下将自动获取跟方法参数名同名的cookie 值。
（四）使用 @requestheader 注解绑定 httpservletrequest 头信息到controller 方法参数
例6
@requestmapping ( "testrequestheader" )
public string testrequestheader( @requestheader ( "host" ) string hostaddr, @requestheader string host, @requestheader string host ) {
system. out .println(hostaddr + "-----" + host + "-----" + host );
return "requestheader" ;
}
在上面的代码中我们使用了 @requestheader 绑定了 httpservletrequest 请求头 host 到controller 的方法参数。上面方法的三个参数都将会赋予同一个值，由此我们可以知道在绑定请求头参数到方法参数的时候规则和 @pathvariable 、 @requestparam 以及 @cookievalue 是一样的，即没有指定绑定哪个参数到方法参数的时候，在 debug 编译模式下将使用方法参数名作为需要绑定的参数。但是有一点 @requestheader 跟另外三种绑定方式是不一样的，那就是在使用 @requestheader 的时候是大小写不敏感的，即 @requestheader(“host”) 和 @requestheader(“host”) 绑定的都是 host 头信息。记住在 @pathvariable 、 @requestparam 和 @cookievalue 中都是大小写敏感的。
（五） @requestmapping 的一些高级应用
在requestmapping 中除了指定请求路径value 属性外，还有其他的属性可以指定，如params 、method 和headers 。这样属性都可以用于缩小请求的映射范围。
1.params属性
例7
@requestmapping (value= "testparams" , params={ "param1=value1" , "param2" , "!param3" })
public string testparams() {
system. out .println( "test params..........." );
return "testparams" ;
}
在上面的代码中我们用@requestmapping 的params 属性指定了三个参数，这些参数都是针对请求参数而言的，它们分别表示参数param1 的值必须等于value1 ，参数param2 必须存在，值无所谓，参数param3 必须不存在，只有当请求/testparams.do 并且满足指定的三个参数条件的时候才能访问到该方法。所以当请求/testparams.do?param1=value1¶m2=value2 的时候能够正确访问到该testparams 方法，当请求/testparams.do?param1=value1¶m2=value2¶m3=value3 的时候就不能够正常的访问到该方法，因为在@requestmapping 的params 参数里面指定了参数param3 是不能存在的。
2.method属性
例8
@requestmapping (value= "testmethod" , method={requestmethod. get , requestmethod. delete })
public string testmethod() {
return "method" ;
}
在上面的代码中就使用method 参数限制了以get 或delete 方法请求/testmethod.do 的时候才能访问到该controller 的testmethod 方法。
3.headers属性
例9
@requestmapping (value= "testheaders" , headers={ "host=localhost" , "accept" })
public string testheaders() {
return "headers" ;
}
headers 属性的用法和功能与params 属性相似。在上面的代码中当请求/testheaders.do 的时候只有当请求头包含accept 信息，且请求的host 为localhost 的时候才能正确的访问到testheaders 方法。
（六）以 @requestmapping 标记的处理器方法支持的方法参数和返回类型
1. 支持的方法参数类型
（1 ）httpservlet 对象，主要包括httpservletrequest 、httpservletresponse 和httpsession 对象。 这些参数spring 在调用处理器方法的时候会自动给它们赋值，所以当在处理器方法中需要使用到这些对象的时候，可以直接在方法上给定一个方法参数的申明，然后在方法体里面直接用就可以了。但是有一点需要注意的是在使用httpsession 对象的时候，如果此时httpsession 对象还没有建立起来的话就会有问题。
（2 ）spring 自己的webrequest 对象。 使用该对象可以访问到存放在httpservletrequest 和httpsession 中的属性值。
（3 ）inputstream 、outputstream 、reader 和writer 。 inputstream 和reader 是针对httpservletrequest 而言的，可以从里面取数据；outputstream 和writer 是针对httpservletresponse 而言的，可以往里面写数据。
（4 ）使用@pathvariable 、@requestparam 、@cookievalue 和@requestheader 标记的参数。
（5 ）使用@modelattribute 标记的参数。
（6 ）java.util.map 、spring 封装的model 和modelmap 。 这些都可以用来封装模型数据，用来给视图做展示。
（7 ）实体类。 可以用来接收上传的参数。
（8 ）spring 封装的multipartfile 。 用来接收上传文件的。
（9 ）spring 封装的errors 和bindingresult 对象。 这两个对象参数必须紧接在需要验证的实体对象参数之后，它里面包含了实体对象的验证结果。
2. 支持的返回类型
（1 ）一个包含模型和视图的modelandview 对象。
（2 ）一个模型对象，这主要包括spring 封装好的model 和modelmap ，以及java.util.map ，当没有视图返回的时候视图名称将由requesttoviewnametranslator 来决定。
（3 ）一个view 对象。这个时候如果在渲染视图的过程中模型的话就可以给处理器方法定义一个模型参数，然后在方法体里面往模型中添加值。
（4 ）一个string 字符串。这往往代表的是一个视图名称。这个时候如果需要在渲染视图的过程中需要模型的话就可以给处理器方法一个模型参数，然后在方法体里面往模型中添加值就可以了。
（5 ）返回值是void 。这种情况一般是我们直接把返回结果写到httpservletresponse 中了，如果没有写的话，那么spring 将会利用requesttoviewnametranslator 来返回一个对应的视图名称。如果视图中需要模型的话，处理方法与返回字符串的情况相同。
（6 ）如果处理器方法被注解@responsebody 标记的话，那么处理器方法的任何返回类型都会通过httpmessageconverters 转换之后写到httpservletresponse 中，而不会像上面的那些情况一样当做视图或者模型来处理。
（7 ）除以上几种情况之外的其他任何返回类型都会被当做模型中的一个属性来处理，而返回的视图还是由requesttoviewnametranslator 来决定，添加到模型中的属性名称可以在该方法上用@modelattribute(“attributename”) 来定义，否则将使用返回类型的类名称的首字母小写形式来表示。使用@modelattribute 标记的方法会在@requestmapping 标记的方法执行之前执行。
（七）使用 @modelattribute 和 @sessionattributes 传递和保存数据
springmvc 支持使用 @modelattribute 和 @sessionattributes 在不同的模型和控制器之间共享数据。 @modelattribute 主要有两种使用方式，一种是标注在方法上，一种是标注在 controller 方法参数上。
当 @modelattribute 标记在方法上的时候，该方法将在处理器方法执行之前执行，然后把返回的对象存放在 session 或模型属性中，属性名称可以使用 @modelattribute(“attributename”) 在标记方法的时候指定，若未指定，则使用返回类型的类名称（首字母小写）作为属性名称。关于 @modelattribute 标记在方法上时对应的属性是存放在 session 中还是存放在模型中，我们来做一个实验，看下面一段代码。
@controller
@requestmapping ( "/mytest" )
public class mycontroller {
@modelattribute ( "hello" )
public string getmodel() {
system. out .println( "-------------hello---------" );
return "world" ;
}
@modelattribute ( "intvalue" )
public int getinteger() {
system. out .println( "-------------intvalue---------------" );
return 10;
}
@requestmapping ( "sayhello" )
public void sayhello( @modelattribute ( "hello" ) string hello, @modelattribute ( "intvalue" ) int num, @modelattribute ( "user2" ) user user, writer writer, httpsession session) throws ioexception {
writer.write( "hello " + hello + " , hello " + user.getusername() + num);
writer.write( "\r" );
enumeration enume = session.getattributenames();
while (enume.hasmoreelements())
writer.write(enume.nextelement() + "\r" );
}
@modelattribute ( "user2" )
public user getuser() {
system. out .println( "---------getuser-------------" );
return new user(3, "user2" );
}
}
当我们请求 /mytest/sayhello.do 的时候使用 @modelattribute 标记的方法会先执行，然后把它们返回的对象存放到模型中。最终访问到 sayhello 方法的时候，使用 @modelattribute 标记的方法参数都能被正确的注入值。执行结果如下所示：
hello world,hello user210
由执行结果我们可以看出来，此时 session 中没有包含任何属性，也就是说上面的那些对象都是存放在模型属性中，而不是存放在 session 属性中。那要如何才能存放在 session 属性中呢？这个时候我们先引入一个新的概念 @sessionattributes ，它的用法会在讲完 @modelattribute 之后介绍，这里我们就先拿来用一下。我们在 mycontroller 类上加上 @sessionattributes 属性标记哪些是需要存放到 session 中的。看下面的代码：
@controller
@requestmapping ( "/mytest" )
@sessionattributes (value={ "intvalue" , "stringvalue" }, types={user. class })
public class mycontroller {
@modelattribute ( "hello" )
public string getmodel() {
system. out .println( "-------------hello---------" );
return "world" ;
}
@modelattribute ( "intvalue" )
public int getinteger() {
system. out .println( "-------------intvalue---------------" );
return 10;
}
@requestmapping ( "sayhello" )
public void sayhello(map<string, object> map, @modelattribute ( "hello" ) string hello, @modelattribute ( "intvalue" ) int num, @modelattribute ( "user2" ) user user, writer writer, httpservletrequest request) throws ioexception {
map.put( "stringvalue" , "string" );
writer.write( "hello " + hello + " , hello " + user.getusername() + num);
writer.write( "\r" );
httpsession session = request.getsession();
enumeration enume = session.getattributenames();
while (enume.hasmoreelements())
writer.write(enume.nextelement() + "\r" );
system. out .println(session);
}
@modelattribute ( "user2" )
public user getuser() {
system. out .println( "---------getuser-------------" );
return new user(3, "user2" );
}
}
在上面代码中我们指定了属性为 intvalue 或 stringvalue 或者类型为 user 的都会放到 session中，利用上面的代码当我们访问 /mytest/sayhello.do 的时候，结果如下：
hello world,hello user210
仍然没有打印出任何 session 属性，这是怎么回事呢？怎么定义了把模型中属性名为 intvalue 的对象和类型为 user 的对象存到 session 中，而实际上没有加进去呢？难道我们错啦？我们当然没有错，只是在第一次访问 /mytest/sayhello.do 的时候 @sessionattributes 定义了需要存放到 session 中的属性，而且这个模型中也有对应的属性，但是这个时候还没有加到 session 中，所以 session 中不会有任何属性，等处理器方法执行完成后 spring 才会把模型中对应的属性添加到 session 中。所以当请求第二次的时候就会出现如下结果：
hello world,hello user210
user2
intvalue
stringvalue
当 @modelattribute 标记在处理器方法参数上的时候，表示该参数的值将从模型或者 session 中取对应名称的属性值，该名称可以通过 @modelattribute(“attributename”) 来指定，若未指定，则使用参数类型的类名称（首字母小写）作为属性名称。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问， 点击进行留言回复！！
网友评论