开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> SpringMVC之详解 -> 正文阅读

[Java知识库]SpringMVC之详解

MVC框架

MVC是一种设计模式（设计模式就是日常开发中编写代码的一种好的方法和经验的总结）。模型（model）-视图（view）-控制器（controller），三层架构的设计模式。用于实现前端页面的展现与后端业务数据处理的分离。

mvc设计模式的好处：

分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。
有利于系统的并行开发，提升开发效率。

Spring MVC

Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视图-控制器分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
Spring MVC的优点：

可以支持各种视图技术,而不仅仅局限于JSP；
与Spring框架集成（如IoC容器、AOP等）；
清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。
支持各种请求资源的映射策略。

Spring MVC的主要组件

前端控制器 DispatcherServlet
Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理所有的HTTP请求和响应。此模块不需要程序员开发。
作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。
处理器映射器HandlerMapping
此功能不需要程序员开发。
作用：根据请求的URL来查找Handler
处理器适配器HandlerAdapter
注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。
处理器Handler
需要程序员开发。
视图解析器 ViewResolver
此功能不需要程序员开发。
作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）
视图View
需要程序员开发jsp。View是一个接口，它的实现类支持不同的视图类型（jsp，freemarker，pdf等等）

Spring MVC的工作原理

首先我们看一下Spring MVC的工作原理图：
在这里插入图片描述
解读此图：

用户发送请求至前端控制器DispatcherServlet；
DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
DispatcherServlet 调用 HandlerAdapter处理器适配器；
HandlerAdapter 经过适配调用具体处理器(Handler，也叫后端控制器)；
Handler执行完成返回ModelAndView；
HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
ViewResolver解析后返回具体View；
DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
DispatcherServlet响应用户。

Spring MVC常用注解

@RequestMapping和@PathVariable

@RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

RequestMapping注解有六个属性，下面我们把她分成三类进行说明。

value和method
value：指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；
method：指定请求的method类型， GET、POST、PUT、DELETE等；
consumes和produces
consumes：指定处理请求的提交内容类型（Content-Type），也就是说，只有当请求头中 Content-Type 的值与指定可消费的媒体类型中有相同的时候，请求才会被匹配。例如application/json, text/html
produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回。换句话说，只有当请求头中 Accept 的值与指定可生产的媒体类型中有相同的时候，请求才会被匹配。而且，使用 produces 条件可以确保用于生成响应（response）的内容与指定的可生产的媒体类型是相同的。
params和headers
params：指定request中必须包含某些参数值时，才让该方法处理。比如“myParam”，“！myParam”、“myParam=myValue”：前两个条件用于筛选存在/不存在某些请求参数的请求，第三个条件筛选具有特定参数值的请求。
headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

我们通过具体的例子来了解它的用法：

@Controller
@RequestMapping("/example")
public class ExampleController {
	//可以将多个请求映射到一个方法上，只需要添加一个带有请求路径值列表的 @RequestMapping 注解就行了
	//这个请求最终回调到一个index.jsp的页面
    @RequestMapping({"/index", "/", "inde"})
    public String index() {
        return "index";
    }

	//method指定请求的类型，此例中表示只能接受post请求
    @RequestMapping(value = "/method", method = RequestMethod.POST)
    public String testMethod() {
        return "ok";
    }
	//请求的headers中必须要有header1=value1的请求才会被匹配
    @RequestMapping(value = "/header", headers = "header1=value1")
    public String testHeaders() {
        return "ok";
    }

	// 支持Ant风格的路径模式，例如此方法能匹配地址：http://localhost:8080/SpringMVC/hello/jack/tom/cat/user/18
	//ant风格的路径是什么意思?可以理解为是一种模糊的路径
	@RequestMapping("/hello/**/user/{userId}")
	public String hello(@PathVariable String userId) {
		System.out.println(userId);
		return "/WEB-INF/views/success.jsp";
	}

    @RequestMapping(value = "/accept", produces = {"application/json", "application/xml"}, consumes = "text/html")
    public String testAccept() {
        return "ok";
    }
	//用来处理动态的URI，URI的值可以作为控制器中处理方法的参数，此时需要 @RequestMapping和@PathVariable配合
    @RequestMapping(value = "/method7/{id}")
    public String method7( @PathVariable("id") int id ) {
        return "method7 with id=" + id;
    }

    @RequestMapping(value = "/method8/{id:[\\d]+}/{name}")
    public String method8(@PathVariable("id") long id,@PathVariable("name") String name ) {
        return "method8 with id= " + id + " and name=" + name;
    }
	//处理请求参数，本例中表示：只有请求url中含有名为”id”的参数，才会被此方法处理
    @RequestMapping(value = "/id")
    String getIdByValue(@RequestParam("id") String personId) {
        System.out.println("ID is " + personId);
        return "从URI中获取id的值";
    }
}

@RequestMapping的实现原理：详见RequestMapping 原理

@RequestParam和 @PathVariable的区别

@RequestParam和 @PathVariable都使用在Spring mvc的控制层的方法的形参前面，用于获取请求中的参数，但是两者有不同的地方：

@PathVariable

@PathVariable用来获得请求url中的动态参数的。
GET模式下，这里使用了@PathVariable绑定输入参数，非常适合Restful风格。因为隐藏了参数与路径的关系，可以提升网站的安全性，静态化页面，降低恶意攻击风险。
例如：

@Controller
public class HelloWorldController {
	//方法一
	@RequestMapping("/hello/{orderId}")
	public String hello(@PathVariable String orderId) {
		System.out.println(username);
		return "/WEB-INF/views/success.jsp";
	}
	//方法二
	@RequestMapping("/hello/{name}")
	public String hello(@PathVariable("name") String username) {
		System.out.println(username);
		return "/WEB-INF/views/success.jsp";
	}

}

从上面两个例子我们可以得出一个结论：如果路径中的URI变量和方法中的参数名一样的话，不需要在@PathVariable 中显示的绑定参数，如方法一；如果路径中的URI变量和方法中的参数名不一样的话，那么需要在 @PathVariable 中显示的绑定参数，如方法二。

@RequestParam

@RequestParam用于将请求参数区数据映射到功能处理方法的参数上。@RequestParam中包含的属性：

String name：指定URL中参数的名称。
String value：和name的含义一样，指定URL中参数的名称。
boolean required：该属性用于指定某个参数是否是必须的，默认值为true，表示请求中一定要有相应的参数，否则将报404错误码。
String defaultValue：该属性用于指定参数的默认值，表示如果请求中没有同名参数的默认值。

举例说明：

@Controller
@RequestMapping("/test")
public class Test {

	 // url上必须有名称为username参数，如果没有就会报错
    @RequestMapping("/test1")
    public void test1(@RequestParam(name = "username") String name) {
        System.out.println(name);
    }
	
	// url上必须有名称为name参数，如果没有就会报错
    @RequestMapping("/test2")
    public void test2(@RequestParam String name) {
        System.out.println(name);
    }

	// 接收url上名为name参数的值，如果没有此参数也不会报错
    @RequestMapping("/test3")
    public void test3(@RequestParam(required = false) String name) {
        System.out.println(name);
    }

	 // url上没有username以及alias参数时，给它设置一个默认值为myself
    @RequestMapping("/test4")
    public void test4(@RequestParam(name = "username", defaultValue = "myself") String name) {
        System.out.println(user);
        System.out.println(a);
    }
}

@RequestBody

@RequestBody 注解则是将 HTTP 请求正文的内容插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个java对象。

@RequestMapping(value = "person/login")
@ResponseBody
public Person login(@RequestBody Person person) {  // 将请求中的 datas 写入 Person 对象中
  return person;  // 不会被解析为跳转路径，而是直接写入 HTTP 响应正文中
}

@ResponseBody

在方法上只使用@RequestMapping 注解时，返回值通常解析为跳转路径，但是加上 @Responsebody 后返回结果不会被解析为跳转路径，而是返回其它某种格式的数据（如json、xml等），然后直接写入HTTP 响应正文中。例如，异步获取 json 数据，加上 @Responsebody 注解后，就会直接返回 json 数据。也就是说，在使用@Responsebody之后不会再走视图处理器，而是直接将数据写入到输入流中，它的效果等同于通过response对象输出指定格式的数据。

使用@Responsebody的坏处是：返回之前，若前端编码格式不一致，很容易导致乱码。

//返回的是json对象
@RequestMapping(value = "person/login")
@ResponseBody
public Person login( Person person) {  
  return person;  
}

上面的方法等效于下面这个方法
@RequestMapping("/login")
public void login(User user, HttpServletResponse response){
　　response.getWriter.write(JSONObject.fromObject(user).toString());
}

使用@ResponseBody注解返回一个json对象我们很熟悉，那如何返回XML对象呢？看下面的例子：

@Data
public class Employee {  
    private String name;  
    private int salary;  
}

@XmlRootElement  
public class EmployeeX extends Employee {  
    public EmployeeX() {  
        super();  
    }  
      
    public EmployeeX(String name, int salary) {  
        super(name, salary);  
    }  
}

@Controller  
@RequestMapping("/employees")  
public class XmlOrJsonController {  
    @RequestMapping(value="/xml/{name}", method=RequestMethod.GET)  
    @ResponseBody  
    public Employee getEmployeeXml(@PathVariable String name) {  
        return new EmployeeX(name, 16000);  
    }  
}

测试结果：
在这里插入图片描述
@ResponseBody的实现原理
 @ResponseBody的实现原理

@CookieValue

@CookieValue 可以把Request header中关于cookie的值绑定到方法的参数上。例如：

@RequestMapping(“/displayHeaderInfo.do”)
public void displayHeaderInfo(@CookieValue(“JSESSIONID”) String cookie) {

}

@ModelAttribute

@ModelAttribute的使用可以分为两大类：在方法上使用和在方法参数上使用。

场景一：注解无返回值的方法

@Controller
public class HelloWorldController { 
    @ModelAttribute
    public void populateModel(@RequestParam String abc, Model model) { 
         model.addAttribute("attributeName", abc); 
      } 
 
    @RequestMapping(value = "/helloWorld") 
    public String helloWorld(Model model) { 
    
       return "helloWorld"; 
        } 
 }

当我们访问helloWorld方法时，会发现model中已经有attributeName参数了，这说明populateModel方法已经提前执行了

场景二：注解有返回值的方法

@Controller
public class HelloWorldController { 
    @ModelAttribute("initStudentInfo")
    public Student initStudent(Model model){
        Student student=new Student();
        student.setName("zhangsan");
        student.setAge(23);
        return student;
    }
    @RequestMapping(value = "/helloWorld") 
    public String helloWorld(Model model) { 
       return "helloWorld"; 
        } 
 }

当我们访问helloWorld方法时，会发现此方法中的model中已经有了initStudentInfo参数，说明被@ModelAttribute注解的initStudent方法在helloWorld方法之前执行了。另外，如果将@ModelAttribute(“initStudentInfo”)改为@ModelAttribute，在helloWorld方法执行时就会存在一个名为student的参数，这是因为当被@ModelAttribute方法有返回值且没有在@ModelAttribute上设置参数名时，会默认使用返回类型的生成一个参数名。

场景三：和@RequestMapping同时使用在方法上

@Controller
public class HelloWorldController { 
    @RequestMapping(value = "/helloWorld.do") 
    @ModelAttribute("attributeName") 
    public String helloWorld() { 
         return "hi"; 
      } 
  }

@ModelAttribute标注也可以被用在@RequestMapping方法上，这种情况下，@RequestMapping方法的返回值将会被解释为model的一个属性的值，而非一个视图名，此时视图名称由RequestToViewNameTranslator根据请求"/helloWorld.do"转换为逻辑视图helloWorld。

场景四：注解作用在参数方法上，且从视图中获取对象信息

@Controller
public class HelloWorldController { 
    @ModelAttribute("initStudentInfoReturnValue")
    public void initStudent(Model model){
        Student student=new Student();
        student.setName("zhangsan");
        student.setAge(23);
        model.addAttribute("initStudentInfo",student);
    }

    @RequestMapping("/test1")
    public String test1(@ModelAttribute("initStudentInfoReturnValue")Student student, Model model){
        System.out.println(model.asMap().get("initStudentInfoReturnValue"));
        return "/studen/info";
    }
 }

此时当我们访问test1方法时，test1方法中的student参数接收到的是initStudent方法返回的参数，而且接收到的参数还会返回给页面，以便页面中使用。

场景五：注解作用在参数方法上，且在视图中创建对象信息

@Controller
public class HelloWorldController { 
 
    @RequestMapping("/test1")
    public String test1(@ModelAttributeStudent student, Model model){
        System.out.println(model.asMap().get("initStudentInfoReturnValue"));
        return "/studen/info";
    }
 }

这种情况比较常见，比如我们在前端提交一个Student的表单，此时不单test1方法中可以通过student参数接收这个对象，同时这个还会放到model中返回到info页面以便使用。

场景六：@ModelAttribute方法也可以定义在@ControllerAdvice

@ModelAttribute方法也可以定义在@ControllerAdvice标注的类中，并且这些@ModelAttribute可以同时对许多控制器生效。

注意：一个控制器可以拥有多个@ModelAttribute方法。同个控制器内的所有这些方法，都会在@RequestMapping方法之前被调用。
总得来说，@ModelAttribute方法通常被用来填充一些公共需要的属性或数据，比如一个下拉列表所预设的几种状态，或者宠物的几种类型，或者去取得一个HTML表单渲染所需要的命令对象，比如Account等。

Spring MVC中重定向和转发

@Controller  
@RequestMapping("/employees")  
public class TetstController {  
    /**
     * 实现转发，转发后可以获取到name的值
     */
    @RequestMapping("/hello11")
    public String hello11(HttpServletRequest request){
        request.setAttribute("name", "cjj");
        return "forward:/welcome.jsp";
    }
    
    /**
     * 直接跳转到一个新的页面实现重定向，跳转后无法获取到name的值
     *
     */
    @RequestMapping("/hello12.action")
    public String hello12(HttpServletRequest request){
        request.setAttribute("name", "cjj");
        return "redirect:/welcome.jsp";
    }

/**
     * 通过调用另一个方法实现重定向，跳转后无法获取到name的值
     *
     */
    @RequestMapping("/hello12.action")
    public String hello12(HttpServletRequest request){
        request.setAttribute("name", "cjj");
        return "redirect:methed1";
    }
}

在使用redirect进行重定向时请求的URL链接地址发生了改变，并且在controller控制层中request对象传递的参数并不能成功传递到下一个请求地址。那么，如果想要在重定向时把请求参数也传递过去应该怎么做呢？这里介绍两种方式：
方法一：重定向之前把参数放进Session对象中

	@RequestMapping("/test1")
    public String test1(HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.setAttribute("name", "zhangsan");
        return "redirect:/index";
    }

方法二：使用RedirectAttributes类

	@RequestMapping("/test1")
    public String test1(RedirectAttributes attr) {
        attr.addFlashAttribute("name", "zhangsan");
        return "redirect:/index";
    }

Spring MVC与Struts2区别

相同点
都是基于mvc的表现层框架，都用于web项目的开发。

不同点

前端控制器不一样。Spring MVC的前端控制器是servlet：DispatcherServlet。struts2的前端控制器是filter：StrutsPreparedAndExcutorFilter。
请求参数的接收方式不一样。Spring MVC是使用方法的形参接收请求的参数，基于方法的开发，线程安全，可以设计为单例或者多例的开发，推荐使用单例模式的开发（执行效率更高），默认就是单例开发模式。struts2是通过类的成员变量接收请求的参数，是基于类的开发，线程不安全，只能设计为多例的开发。
Struts采用值栈存储请求和响应的数据，通过OGNL存取数据，Spring MVC通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl。
与spring整合不一样。Spring MVC是spring框架的一部分，不需要整合。在企业项目中，Spring MVC使用更多一些。

Spring MVC中常见问题

问题一：Spring MVC的控制器是不是单例模式,如果是，有什么问题,怎么解决？
答：是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。

问题二：@Controller和@RequestMapping是如何配合工作的？
答：在Spring MVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在Spring MVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。

@Controller 用于标记在一个类上，使用它标记的类就是一个Spring MVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器。单单使用@Controller 标记在一个类上还不能真正意义上的说它就是Spring MVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。有两种方式：