SpringMVC之详解

才放一花天地香

已于 2022-03-29 17:05:00 修改

阅读量918

点赞数 1

分类专栏： SpringMVC 文章标签： java 经验分享面试

于 2022-03-07 18:29:03 首次发布

本文链接：https://blog.csdn.net/qq_38571892/article/details/123253144

版权

SpringMVC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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

@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(@ModelAttribute Student 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 来管理。有两种方式：

在Spring MVC 的配置文件中定义MyController 的bean 对象。
在Spring MVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。

才放一花天地香

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
SpringMVC之详解

MVC框架MVC是一种设计模式（设计模式就是日常开发中编写代码的一种好的方法和经验的总结）。模型（model）-视图（view）-控制器（controller），三层架构的设计模式。用于实现前端页面的展现与后端业务数据处理的分离。mvc设计模式的好处：分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。有利于系统的并行开发，提升开发效率。Spring MVCSpring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把模型-视
复制链接

扫一扫