springMVC各种注解及解释和使用

3、@RequestMapping 注解

Spring MVC 使用 @RequestMapping 注解为控制器指定可以处理哪些 URL 请求，@RequestMapping把请求与处理请求的方法映射在一起。

4、窄化请求映射

（1）@RequestMapping可以修饰控制器类和方法上

类定义处：提供初步的请求映射信息,相对于WEB 应用的根目录。

方法处：提供进一步的细分映射信息，相对于类定义处的 URL。

若类定义处未标注 @RequestMapping，则方法处标记的 URL 相对于WEB 应用的根目录DispatcherServlet 截获请求后，就通过控制器上@RequestMapping 提供的映射信息确定请求所对应的处理方法。

package com.offcn.mvc.controller;/**
* Created by Administrator on 2019/9/19 0019.
*/

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
* @author Administrator
* @date 2019/9/19 0019 15:33
* @description
*/
@Controller
@RequestMapping("/dept")
public class DeptController {
    /**
     * 处理器方法
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @RequestMapping("/add")
    public ModelAndView addDept() throws Exception {
        //创建模型视图对象
        ModelAndView mav=new ModelAndView();
        //把数据绑定到模型对象
        mav.addObject("name","add dept");
        //设置跳转视图名称
        mav.setViewName("success");
        return mav;
    }
}

package com.offcn.mvc.controller;/**
* Created by Administrator on 2019/9/19 0019.
*/

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* 页面处理器
* @author Administrator
* @date 2019/9/19 0019 14:15
* @description
*/
@Controller
@RequestMapping("/user")
public class UserController{
    /**
     * 处理器方法
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @RequestMapping("/login")
    public ModelAndView login() throws Exception {
        //创建模型视图对象
        ModelAndView mav=new ModelAndView();
        //把数据绑定到模型对象
        mav.addObject("name","admin");
        //设置跳转视图名称
        mav.setViewName("success");
        return mav;
    }
    @RequestMapping(value = {"/logout","/exit"})
    public ModelAndView logout() throws Exception {
        //创建模型视图对象
        ModelAndView mav=new ModelAndView();
        //把数据绑定到模型对象
        mav.addObject("name","logout");
        //设置跳转视图名称
        mav.setViewName("success");
        return mav;
    }
}

访问路径：

http://localhost:9091/mvc/user/login

（2）组合使用是“或”的关系

package com.offcn.mvc.controller;/**
* Created by Administrator on 2019/9/19 0019.
*/

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

http://localhost:9091/mvc/user/exit或

http://localhost:9091/mvc/user/logout

@RequestMapping中的method属性

method：用于限制请求方法，如果没有定义该属性则意味着get和post同时支持。

@RequestMapping(value="/login",method = RequestMethod.GET)

@RequestMapping(value = {"/logout","/exit"},method = RequestMethod.POST)

@RequestMapping(value = {"/delete"},method = {RequestMethod.POST,RequestMethod.GET})

@RequestMapping中的params属性(了解)

@RequestMapping(value="/update",params="id")

请求中必须有一个参数叫id

http://localhost:9091/mvc/user/delete?id=100

@RequestMapping(value="/update",params="id=100")

请求中必须有一个参数叫id，值必须是100

@RequestMapping(value="/update",params="!id")

请求中必须不能有参数叫id

@RequestMapping(value="/update",params="id=!100")

请求中必须有一个参数叫id，值必须不是100

处理方法支持的参数类型（重点）

//同时接受get或post请求
@RequestMapping(value = {"/request"},method = {RequestMethod.POST,RequestMethod.GET})
public String request(HttpServletRequest request, HttpSession session) throws Exception {
    request.setAttribute("reqKey","reqValue");
    session.setAttribute("sessKey","sessValue");
    return "success";//只返回视图名称
}

//接受一个参数
@RequestMapping(value = {"/addVal"},method = {RequestMethod.POST,RequestMethod.GET})
public String addUserVal(String name) throws Exception {

System.out.println(name);
return "success";//只返回视图名称
}
//接受多个参数，并把参数封装到java对象中
@RequestMapping(value = {"/addObj"},method = {RequestMethod.POST,RequestMethod.GET})
public String addUserVal(UserModel userModel) throws Exception {

System.out.println(userModel);
return "success";//只返回视图名称
}

8、模型Model、Map、ModelMap

Spring Web MVC 提供Model、Map或ModelMap让我们能去暴露渲染视图需要的模型数据。

虽然此处注入的是三个不同的类型（Model model, Map model2, ModelMap model3），但三者是同一个对象,页面取值都在request中。

//测试Model Map ModelMap
@RequestMapping("/testModel")
public String testModel(Model model, Map map, ModelMap modelMap){
    model.addAttribute("m","mModel");
    //
    String mapVal=(String)map.get("m");
    System.out.println("mapVal:"+mapVal);
    String modelMapVal =(String)modelMap.get("m");
    System.out.println("modelMapVal:"+modelMapVal);
    System.out.println(model==map);
    System.out.println(map==modelMap);
    return "success";//只返回视图名称
}

9、@RequestParam绑定单个请求参数值

@RequestParam用于将请求参数区数据映射到功能处理方法的参数上。

public String requestparam(@RequestParam String username)

请求中包含username 参数（如/requestparam?username=zhang），则自动传入。

指定入参名称：

public String requestparam2(@RequestParam("username") String username)

@RequestParam注解主要有哪些参数：

value：参数名字，即入参的请求参数名字，如username表示请求的参数区中的名字为username的参数的值将传入；

required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报400错误码；

defaultValue：默认值，表示如果请求中没有同名参数时的默认值

public String requestparam5(@RequestParam(value="username", required=true, defaultValue="zhang") String username)

//测试@RequestParam
@RequestMapping(value = {"/trp"})
public String testRequestParam(@RequestParam(value="name",required=false,defaultValue = "scott") String username) throws Exception {

System.out.println(username);
return "success";//只返回视图名称
}

10、@PathVariable 绑定URI 模板变量值

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。

@RequestMapping(value="/users/{userId}/topics/{topicId}")

public String test(

@PathVariable(value="userId") int userId,

@PathVariable(value="topicId") int topicId){

......

}

如请求的 URL 为“控制器URL/users/123/topics/456”，则自动将URL 中模板变量{userId}和{topicId}绑定到通过@PathVariable注解的同名参数上，即入参后userId=123、topicId=456。

//测试 @PathVariable
@RequestMapping(value="/document/{userId}/topics/{topicId}")
public String testPathVariable(
         @PathVariable(value="userId") int userId,
         @PathVariable(value="topicId") int topicId){
     System.out.println(userId);
     System.out.println(topicId);
     return "success";//只返回视图名称
}

测试url:

http://localhost:9091/mvc/user/document/100/topics/1001

Cookie

Creates a cookie, a small amount of information sent by a servlet to a Web browser, saved by the browser, and later sent back to the server. A cookie's value can uniquely identify a client, so cookies are commonly used for session management.

A cookie has a name, a single value, and optional attributes such as a comment, path and domain qualifiers, a maximum age, and a version number. Some Web browsers have bugs in how they handle the optional attributes, so use them sparingly to improve the interoperability of your servlets.

The servlet sends cookies to the browser by using the HttpServletResponse.addCookie(javax.servlet.http.Cookie) method, which adds fields to HTTP response headers to send cookies to the browser, one at a time. The browser is expected to support 20 cookies for each Web server, 300 cookies total, and may limit cookie size to 4 KB each.

@CookieValue 绑定Cookie数据值

@CookieValue用于将请求的Cookie数据映射到功能处理方法的参数上。

public String test(@CookieValue(value="JSESSIONID", defaultValue="") String sessionId){

......

}

如上配置将自动将JSESSIONID 值入参到sessionId参数上，defaultValue 表示Cookie 中没有JSESSIONID 时默认为空。

传入参数类型也可以是javax.servlet.http.Cookie类型:

public String test2(@CookieValue(value="JSESSIONID", defaultValue="") Cookie sessionId){

......

}

//测试发送cookie
@RequestMapping(value = {"/sc"})
public String sendCookie(HttpServletResponse response) throws Exception {
            //创建Cookie
    Cookie user=new Cookie("name","admin");
    user.setMaxAge(1000*60*60*24*7);
    response.addCookie(user);
    System.out.println("保存cookie成功");
    return "success";//只返回视图名称
}

//测试获取cookie
@RequestMapping(value = {"/gc"})
public String getCookie(@CookieValue(value="name",defaultValue = "") String name) throws Exception {
    //获取Cookie
    System.out.println("name:"+name);
    return "success";//只返回视图名称
}

Win7系统中Cookie位置：

C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Cookies

maven环境下，控制台中文乱码

File -->setting --> maven --> runner 里面的 VM Options 添加 -Dfile.encoding=GB2312

13、@RequestHeader 绑定请求头数据

@RequestHeader 用于将请求的头信息区数据映射到功能处理方法的参数上。

@RequestMapping(value="/header")

public String test(@RequestHeader("User-Agent")

String userAgent,@RequestHeader(value="Accept") String[] accepts){

......

}

如上配置将自动将请求头“User-Agent”值入参到userAgent 参数上，并将“Accept”请求头值入参到accepts参数上。

//测试获取header
@RequestMapping(value = {"/gh"})
public String getHeader(@RequestHeader("User-Agent") String userAgent) throws Exception {
    //获取Cookie
    System.out.println("userAgent:"+userAgent);
    return "success";//只返回视图名称
}

14、命令对象入参

@RequestMapping(value = { "/dept" })

//参数为对象类型，可直接接收请求中的参数

public ModelAndView dept(DeptEntity dept) {

System.out.println("dept:" + dept);

// 模型试图对象

ModelAndView mav = new ModelAndView();

mav.setViewName("update");

return mav;

}

15、@ModelAttribute

1.绑定请求参数到命令对象：放在功能处理方法的入参上时，用于将多个请求参数绑定到一个命令对象，从而简化绑定流程，而且自动暴露为模型数据用于视图页面展示时使用；

//测试@ModelAttribute
@RequestMapping(value = {"/ma1"})
public String testMA1(@ModelAttribute("user") UserModel userModel) throws Exception {

return "ma";//只返回视图名称
}

@ModelAttribute它的作用是将该绑定的命令对象以“user”为名称添加到模型对象中供视图页面展示使用。我们此时可以在视图页面使用${user.uname}来获取绑定的命令对象的属性。

对应页面:

<body>
Hello World

${user.uid} 
${user.uname} 
${user.upass} 
${user.uage} 
</body>

暴露表单引用对象为模型数据：放在处理器的一般方法（非功能处理方法）上时，是为表单准备要展示的表单引用对象，该方法在执行功能处理方法（@RequestMapping 注解的方法）之前，自动添加到模型对象中，用于视图页面展示时使用或在处理方法中使用；

//测试@ModelAttribute
@RequestMapping(value = {"/ma2"})
public String testMA2(Integer uid) throws Exception {
System.out.println("testMA2:"+uid);
return "ma";//只返回视图名称
}

@ModelAttribute("user")
public UserModel preQueryUser(Integer uid){
    System.out.println("preQueryUser:"+uid);
    UserModel userModel=new UserModel();
    userModel.setUname("testMa2");
    return userModel;
}

如上代码会在执行功能处理方法之前执行，并将其自动添加到模型对象中。

1、先于处理方法执行

2、把方法的返回值放入model中

3、可以通过参数接收表单对象

暴露@RequestMapping 方法返回值为模型数据：放在功能处理方法的返回值上时，是暴露功能处理方法的返回值为模型数据，用于视图页面展示时使用。

//测试@ModelAttribute,此时处理方法没有指定view信息，使用RequestMapping的value值作为跳转路径信息
@RequestMapping(value = {"/ma3"})
public @ModelAttribute("user") UserModel testMA3() throws Exception {

System.out.println("testMA3");

UserModel userModel=new UserModel();
    userModel.setUname("testMa2");
    userModel.setUage(200);
    userModel.setUpass("111111");
    userModel.setUid(456);

return userModel;//只返回视图名称
}

未指定view的信息，该如何跳转？

没有设置viewname，该如何跳转？

RequestToViewNameTranslator类：

用于直接将请求转换为逻辑视图名。默认实现为DefaultRequestToViewNameTranslator。

DefaultRequestToViewNameTranslator：将请求URL转换为逻辑视图名，默认规则如下：

http://localhost:9080/web 上下文/list -------> 逻辑视图名为list

http://localhost:9080/web 上下文/list.html -------> 逻辑视图名为list(默认删除扩展名)

http://localhost:9080/web 上下文/user/list.html -------> 逻辑视图名为user/list

1.把处理方法中的命令对象，放到model中。

2.把非处理方法的返回值，放到model中，必须注意该方法先于处理方法执行，同时其参数可以封装表单参数。

3.把处理方法的返回值，放入model中。

17、@SessionAttributes 绑定命令对象到session（了解）

@SessionAttributes注解的作用是把与@ModelAttribute中的相同属性的数据绑定到session作用域中。

//1、在控制器类头上添加@SessionAttributes注解

@Controller
@RequestMapping("/user")
@SessionAttributes(value={"user"})
public class UserController{

......

}

//2、@ModelAttribute注解的方法进行表单引用对象的创建

//3、@RequestMapping注解方法的@ModelAttribute注解的参数进行命令对象的绑定

对@SessionAttribute注解启用的session管理

通过SessionStatus的setComplete()方法清除@SessionAttributes指定的会话数据

@RequestMapping("/logout") //

public String logout(SessionStatus status) {

if(true) { //④

status.setComplete();

}

return "success";

}

18、重定向与转发

SpringMVC默认情况下是服务器端跳转，向jsp页面中跳转，一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理；如果返回的字符串中带 forward: 或 redirect:前缀时，SpringMVC 会对他们进行特殊处理：

将 forward: 和redirect: 当成指示符，其后的字符串作为 URL 来处理。

redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作，不经过试图解析器处理。

forward:success.jsp：会完成一个到 success.jsp 的转发操作。

@RequestMapping(value= {"/jumpOne"})

public String jumpOne() {

return "forward:one.jsp";

}

@RequestMapping(value= {"/jumpTwo"})

public String jumpTwo() {

return "redirect:two.jsp";

}

总结：

1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据
redirect:不能共享数据
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等
4.从效率来说
forward:高
redirect:低

19、mvc:annotation-driven注解

<mvc:annotation-driven/>注解简介

<mvc:annotation-driven/>注解的作用？

<mvc:annotation-driven /> 注解会自动注册

RequestMappingHandlerMapping、RequestMappingHandlerAdapter 与

ExceptionHandlerExceptionResolver 三个bean。

还将提供以下支持：

支持使用 ConversionService 实例对表单参数进行类型转换

支持使用 @NumberFormat annotation、@DateTimeFormat注解完成数据类型的格式化

支持使用 @Valid 注解对 JavaBean 实例进行 JSR 303 验证

支持使用 @RequestBody 和 @ResponseBody 注解。

比如直接使用@ResponseBody时，报Description The origin server did not find a current representation for the target resource or is not willing to disclose that one exists.

导入mvc命名空间:

<?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:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-4.3.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-4.3.xsd

http://www.springframework.org/schema/mvc

" >http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">

@ResponseBody注解使用

导入jackson依赖：

<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 <version>2.9.0</version>
</dependency>

<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-core</artifactId>
 <version>2.9.0</version>
</dependency>

<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-annotations</artifactId>
 <version>2.9.0</version>
</dependency>

代码实现：

@RequestMapping("/queryUser")
@ResponseBody //该注解将导致无法跳转
public UserModel queryUser() throws Exception {
    System.out.println("queryUser()");
    UserModel userModel=new UserModel();
    userModel.setUname("testMa2");
    userModel.setUage(200);
    userModel.setUpass("111111");
    userModel.setUid(456);
    return userModel;
}

@RequestMapping("/queryUsers")
@ResponseBody //该注解将导致无法跳转
public List<UserModel> queryUsers() throws Exception {
 System.out.println("queryUsers()");
 UserModel userModel1=new UserModel();
 userModel1.setUname("testMa1");
 userModel1.setUage(200);
 userModel1.setUpass("111111");
 userModel1.setUid(456);
 UserModel userModel2=new UserModel();
 userModel2.setUname("testMa2");
 userModel2.setUage(200);
 userModel2.setUpass("111111");
 userModel2.setUid(456);
 List<UserModel> list=new ArrayList<>();
 list.add(userModel1);
 list.add(userModel2);
 return list;
}

@RequestMapping("/queryUserMap")
@ResponseBody //该注解将导致无法跳转
public Map<String,List<UserModel>> queryUserMap() throws Exception {
System.out.println("queryUserMap()");

UserModel userModel1=new UserModel();
    userModel1.setUname("testMa1");
    userModel1.setUage(200);
    userModel1.setUpass("111111");
    userModel1.setUid(456);

UserModel userModel2=new UserModel();
    userModel2.setUname("testMa2");
    userModel2.setUage(200);
    userModel2.setUpass("111111");
    userModel2.setUid(456);

List<UserModel> list=new ArrayList<>();
list.add(userModel1);
list.add(userModel2);

Map<String,List<UserModel>> map=new HashMap<>();
map.put("userMap",list);
return map;
}

@RequestMapping("/queryHello")
@ResponseBody //该注解将导致无法跳转
public String queryHello() throws Exception {
System.out.println("queryHello()");

return "Hello World";
}

@RequestBody注解

@RequestMapping("/addUser")
@ResponseBody //该注解将导致无法跳转
public String addUser(@RequestBody UserModel userModel) throws Exception {
System.out.println("queryUser():"+userModel);
return "success";
}