如何在Spring Boot中使用Spring MVC

女爷i 2023-09-25 23:32 81阅读 0赞

**目录**

1.MVC

2.Spring MVC

3.Spring Boot中使用Spring MVC

3.1.配置

3.1.1.文件配置

3.1.2.代码配置

3.2.使用

3.2.1.映射处理器

3.2.2.传参

3.2.3.参数转换

3.2.4.数据校验

3.2.5.数据模型

3.2.6.视图和解析器

3.2.7.拦截器

--------------------

## 1.MVC ##

MVC 是一种常见的软件设计模式，用于分离应用程序的不同部分以实现松散耦合和高内聚性。MVC 模式由三个核心组件组成：

*  模型（Model）：表示应用程序的数据和业务逻辑。模型处理应用程序的数据，并根据控制器的指令执行相应的操作。
 *  视图（View）：提供模型数据的用户界面。视图通常是模板、HTML 页面、XML 文件或其他格式，可以呈现模型数据给用户。
 *  控制器（Controller）：处理用户交互并更新模型和视图。控制器负责接收来自视图的用户输入，对模型进行相应的操作，并更新视图以反映更改。

MVC 模式的优点是可以将代码分离成三个独立的组件，使得应用程序更易于维护和扩展。例如，如果要更改视图的外观，可以修改视图而不影响模型和控制器；如果要更改数据存储方式，可以修改模型而不影响视图和控制器。同时，MVC 模式还有助于降低应用程序中的耦合度，使得各组件更加独立和可重用。

## 2.Spring MVC ##

在Spring体系下的MVC架构中一次请求处理的流程如下：

请求到控制器（controller），经过业务模型（model）处理后返回响应给识图层。

![57401261ee654acdadd4dd9a38f74da2.png][]

整个流程里面Spring MVC干了些啥：

整个Spring MVC的核心是DispatcherServlet，围绕DispatcherServlet SpringMVC提供了一套组件配合DispatcherServlet完成整个工作流程。

DispatcherServlet 首先收到请求，将请求映射到对应的处理器（controller）上，映射到controller的时候会触发拦截器；处理器处理完后封装数据模型，交给视图解析器将数据模型解析为对应的视图返回给前端。

![2536228bd0094949819bcba97c821f9b.png][]

当然有时候以上流程不会全部走完，比如使用@RestController或者@ResponseBody的时候由于直接返回响应了，不会转跳识图，所以不会走视图解析器。

## 3.Spring Boot中使用Spring MVC ##

### 3.1.配置 ###

因为Spring Boot自动装配机制的存在，一般来说我们不需要对Spring MVC进行配置，如果要进行特别定制化的配置，Spring Boot也支持配置文件或者编写代码的两种方式来进行配置。

#### 3.1.1.文件配置 ####

> \# 启用Spring MVC  
> spring.mvc.enabled=true
> 
> \# 配置静态资源路径  
> spring.mvc.static-path-pattern=/static/\*\*  
> spring.resources.static-locations=classpath:/static/
> 
> \# 配置视图解析器  
> spring.mvc.view.prefix=/WEB-INF/views/  
> spring.mvc.view.suffix=.jsp
> 
> \# 配置HTTP缓存  
> spring.resources.cache.period=3600
> 
> \# 配置文件上传  
> spring.servlet.multipart.max-file-size=10MB  
> spring.servlet.multipart.max-request-size=10MB
> 
> \# 配置JSON序列化  
> spring.jackson.serialization.indent\_output=true  
> spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
> 
> \# 配置异常处理  
> server.error.whitelabel.enabled=false
> 
> \# 配置拦截器  
> spring.mvc.interceptor.exclude-path-patterns=/login,/logout  
> spring.mvc.interceptor.include-path-patterns=/admin/\*\*
> 
> \# 配置会话管理  
> server.session.timeout=1800  
> server.session.cookie.max-age=1800

#### 3.1.2.代码配置 ####

@Configuration
    public class MyWebMvcConfig implements WebMvcConfigurer {
    
        // 配置视图解析器
        @Override
        public void configureViewResolvers(ViewResolverRegistry registry) {
            InternalResourceViewResolver resolver = new InternalResourceViewResolver();
            resolver.setPrefix("/WEB-INF/views/");
            resolver.setSuffix(".jsp");
            registry.viewResolver(resolver);
        }
    
        // 配置静态资源
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/static/**").addResourceLocations("/static/");
        }
    
        // 配置拦截器
        @Autowired
        private MyInterceptor myInterceptor;
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(myInterceptor).addPathPatterns("/**");
        }
    
        // 配置消息转换器
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
            List<MediaType> supportedMediaTypes = new ArrayList<MediaType>();
            supportedMediaTypes.add(MediaType.APPLICATION_JSON);
            converter.setSupportedMediaTypes(supportedMediaTypes);
            converters.add(converter);
        }
    
        // 配置异常处理器
        @ControllerAdvice
        public class GlobalExceptionHandler {
            @ExceptionHandler(value = Exception.class)
            public ModelAndView handleException(HttpServletRequest req, Exception e) {
                ModelAndView mav = new ModelAndView();
                mav.addObject("exception", e);
                mav.addObject("url", req.getRequestURL());
                mav.setViewName("error");
                return mav;
            }
        }
    
        // 配置跨域资源共享（CORS）
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/api/**").allowedOrigins("http://localhost:8080");
        }
    
        // 配置文件上传
        @Bean
        public MultipartResolver multipartResolver() {
            CommonsMultipartResolver resolver = new CommonsMultipartResolver();
            resolver.setMaxUploadSize(10485760);
            resolver.setMaxInMemorySize(4096);
            return resolver;
        }
    
        // 配置请求缓存
        @Bean
        public KeyGenerator keyGenerator() {
            return new DefaultKeyGenerator();
        }
    
        @Bean
        public RequestCache requestCache() {
            return new HttpSessionRequestCache();
        }
    
        // 配置视图控制器
        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/").setViewName("index");
            registry.addViewController("/login").setViewName("login");
        }
    }

### 3.2.使用 ###

#### 3.2.1.映射处理器 ####

这里只介绍@RequestMapping，@GETMapping和@PostMapping类似。

@Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping {
    	
        String name() default "";
        
        @AliasFor("path")
        String[] value() default {};
    	
        @AliasFor("value")
        String[] path() default {};
    
        RequestMethod[] method() default {};
    
        String[] params() default {};
    
        String[] headers() default {};
    
        String[] consumes() default {};
    
        String[] produces() default {};
    }

各参数的作用如下：

1.  value和path：用于指定请求的URL路径，可以使用占位符和正则表达式。
2.  method：指定HTTP请求方法，可以是GET、POST、PUT、DELETE等。
3.  params：指定请求参数的条件，支持表达式、多个参数和逻辑运算。
4.  headers：指定请求头的条件，支持表达式、多个头和逻辑运算。
5.  consumes：指定请求的MIME类型，用于限制请求内容类型。
6.  produces：指定响应的MIME类型，用于限制响应内容类型。
7.  name：指定请求参数的名称，用于自动绑定参数值。
8.  defaultValue：指定请求参数的默认值。
9.  pathVariable：用于绑定URL路径中的占位符。
10. required：指定请求参数是否为必须的。
11. value、method、params、headers、consumes和produces属性都支持数组形式，可以匹配多个条件。

#### 3.2.2.传参 ####

**1.按参数名匹配**

@Controller
    @RequestMapping("/user")
    public class UserController {
        
        @RequestMapping("/info")
        public String getUserInfo(Integer userId, Model model) {
            // 根据用户ID查询用户信息并返回
            User user = userService.getUserById(userId);
            model.addAttribute("user", user);
            return "user_info";
        }
    }

URL:

ip:port/info?userId=1

**2.@RequestParam**

通过@RequestParam注解可以指定匹配的参数.

@Controller
    @RequestMapping("/user")
    public class UserController {
        
        @RequestMapping(value = "/search", method = RequestMethod.GET, params = "keyword")
        public String searchUser(@RequestParam("keyword") String keyword, Model model) {
            // 根据关键词查询用户信息并返回
            List<User> userList = userService.searchUser(keyword);
            model.addAttribute("userList", userList);
            return "user_list";
        }
    }

**3.传数组**

@RequestMapping("/delete")
    public String deleteUsers(int[] userIds, Model model) {
        // 根据用户ID数组删除多个用户，并返回用户列表页面
        userService.deleteUsers(userIds);
        List<User> userList = userService.getUserList();
        model.addAttribute("userList", userList);
        return "user_list";
    }

**4.传JSON**

传JSON只能用POST方法，使用@ResponseBody注解参数列表中的参数，就可以用来接收JSON，如果被注解的参数是个对象那么会将JSON自动转化为改对象。

@RequestMapping(value = "/save", method = RequestMethod.POST)
    @ResponseBody
    public Map<String, Object> saveUser(@RequestBody User user) {
        // 保存用户信息，并返回成功的响应
        userService.saveUser(user);
        return Collections.singletonMap("success", true);
    }

注意传参的时候要将设置好contentType: "application/json"

**5.Restful**

@Controller
    @RequestMapping("/user")
    public class UserController {
        
        @RequestMapping("/info/{id}")
        public String getUserInfo(@PathVariable("id") Integer userId, Model model) {
            // 根据用户ID查询用户信息并返回
            User user = userService.getUserById(userId);
            model.addAttribute("user", user);
            return "user_info";
        }
    }

前端URL为：

ip:port/info/1

#### 3.2.3.参数转换 ####

当后端接口的参数列表是对象类型时，Spring MVC会自动按照参数名完成参数的转换和填充，当然这种转化规则也可以由我们自己定义，Spring MVC为我们准备了转换接口，以下是一个完整示例：

实体对象：

public class User {
        private Long id;
        private String name;
        private Integer age;
        private String email;
        // 省略 getter 和 setter 方法
    }

参数转换器：

public class UserConverter implements Converter<String, User> {
    
        @Override
        public User convert(String source) {
            // 将请求参数解析为User对象
            String[] values = source.split(",");
            User user = new User();
            user.setId(Long.parseLong(values[0]));
            user.setName(values[1]);
            user.setAge(Integer.parseInt(values[2]));
            user.setEmail(values[3]);
            return user;
        }
    }

注册参数转换器：

@Configuration
    public class WebConfig implements WebMvcConfigurer {
    
        @Override
        public void addFormatters(FormatterRegistry registry) {
            registry.addConverter(new UserConverter());
        }
    }

以后再传对应类型的参数时，会用我们自定义的转换规则来进行转换：

@RequestMapping(value = "/save", method = RequestMethod.POST)
    @ResponseBody
    public Map<String, Object> saveUser(User user) {
        // 保存用户信息，并返回成功的响应
        userService.saveUser(user);
        return Collections.singletonMap("success", true);
    }

#### 3.2.4.数据校验 ####

有时候我们希望前端传过来的参数是满足一定格式的，Spring MVC也考虑到了这一点，为我们提供了基于注解的参数校验功能。

public class User {
        @NotNull(message = "id不能为空")
        private Long id;
    
        @NotBlank(message = "name不能为空")
        private String name;
    
        @Min(value = 0, message = "age不能小于0")
        @Max(value = 150, message = "age不能大于150")
        private Integer age;
    
        @Email(message = "email格式不正确")
        private String email;
    
        // 省略 getter 和 setter 方法
    }

只是使用了注解，校验并不会生效，还需要在想要进行校验的地方配上@Validated开启校验：

@RestController
    @RequestMapping("/user")
    public class UserController {
    
        @PostMapping("/save")
        public Map<String, Object> saveUser(@Validated @RequestBody User user, BindingResult bindingResult) {
            if (bindingResult.hasErrors()) {
                // 参数校验失败，返回错误信息
                List<ObjectError> errors = bindingResult.getAllErrors();
                List<String> errorMessages = new ArrayList<>();
                for (ObjectError error : errors) {
                    errorMessages.add(error.getDefaultMessage());
                }
                return Collections.singletonMap("success", false, "errors", errorMessages);
            }
    
            // 保存用户信息，并返回成功的响应
            userService.saveUser(user);
            return Collections.singletonMap("success", true);
        }
    }

#### 3.2.5.数据模型 ####

Spring MVC 中的数据模型用于在处理器方法（Controller）和视图之间传递数，有三种：

*  Model
 *  ModelMap
 *  ModelAndView

**Model：**

只能承载参数

@GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, world!");
        return "hello";
    }

**ModelMap:**

和Model功能相似。

@GetMapping("/hello")
    public String hello(ModelMap model) {
        model.put("message", "Hello, world!");
        return "hello";
    }

**ModelAndView:**

既能承载参数也能承载视图名。

@GetMapping("/hello")
    public ModelAndView hello() {
        ModelAndView mav = new ModelAndView("hello");
        mav.addObject("message", "Hello, world!");
        return mav;
    }

#### 3.2.6.视图和解析器 ####

**1.视图**

Spring MVC的视图可以理解为最终返给前端的东西，分为两类：

*  逻辑视图
 *  非逻辑视图

**逻辑视图：**

逻辑视图是指一个字符串，它代表了一个视图的逻辑名称，与实际的视图实现解耦合，而是通过视图解析器将其映射为实际的视图。在 Spring MVC 中，处理器方法可以返回逻辑视图名，由 DispatcherServlet 根据视图解析器的配置，将其映射为实际的视图。

常用的逻辑视图包括：

*  JSP 视图：使用 InternalResourceViewResolver 视图解析器，将逻辑视图名映射为 JSP 文件名。
 *  Velocity 视图：使用 VelocityViewResolver 视图解析器，将逻辑视图名映射为 Velocity 模板文件名。
 *  Thymeleaf 视图：使用 ThymeleafViewResolver 视图解析器，将逻辑视图名映射为 Thymeleaf 模板文件名。

**非逻辑视图：**

非逻辑视图是指一个具体的视图实现，通常是一个视图类或者一个 RESTful Web Service。在处理器方法中，可以直接返回一个非逻辑视图，它会被直接渲染，而不需要通过视图解析器进行转换。

常用的非逻辑视图包括：

*  JSON 视图：使用 MappingJackson2JsonView 视图实现，将模型数据转换为 JSON 格式返回给客户端。
 *  XML 视图：使用 MappingJackson2XmlView 视图实现，将模型数据转换为 XML 格式返回给客户端。
 *  PDF 视图：使用 iText PDF 库和 AbstractPdfView 视图实现，将模型数据转换为 PDF 格式返回给客户端。

需要注意的是，非逻辑视图通常需要进行额外的配置和处理，比如 JSON 视图需要添加 Jackson 依赖库，并在 Spring 配置文件中配置 MappingJackson2JsonView 视图解析器。

**2.视图解析器**

视图解析器决定@Controller的return具体映射到什么类型的视图上，默认是使用InternalResourceViewResolver视图解析器，也就是JSP视图解析器，当我们配置好前缀、后缀后，它会自动将@Controller的return映射到对应的jsp上去。

> spring.mvc.view.prefix=/WEB-INF/views/  
> spring.mvc.view.suffix=.jsp

当然在Spring Boot中也支持我们切换视图解析器，以下是切换为JSON视图解析器的示例，切换为JSON视图解析器后return会直接返回JSON给前端：

@Configuration
    public class WebConfig implements WebMvcConfigurer {
        // 重写configureViewResolvers方法，配置视图解析器
        @Override
        public void configureViewResolvers(ViewResolverRegistry registry) {
            // 使用视图解析器注册表启用内容协商，并指定MappingJackson2JsonView作为视图实现类
            registry.enableContentNegotiation(new MappingJackson2JsonView());
        }
    }

#### 3.2.7.拦截器 ####

Spring Boot中使用自定义Spring MVC拦截器链的代码如下：

@Configuration
    public class WebConfig implements WebMvcConfigurer {
        
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(new FirstInterceptor());
            registry.addInterceptor(new SecondInterceptor());
        }
    }
    
    public class FirstInterceptor implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            // 在处理器处理请求之前执行
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
            // 在处理器处理请求之后，渲染视图之前执行
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                Exception ex) throws Exception {
            // 在渲染视图之后执行
        }
    }
    
    public class SecondInterceptor implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            // 在处理器处理请求之前执行
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
            // 在处理器处理请求之后，渲染视图之前执行
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                Exception ex) throws Exception {
            // 在渲染视图之后执行
        }
    }

[57401261ee654acdadd4dd9a38f74da2.png]: https://img-blog.csdnimg.cn/57401261ee654acdadd4dd9a38f74da2.png
[2536228bd0094949819bcba97c821f9b.png]: https://img-blog.csdnimg.cn/2536228bd0094949819bcba97c821f9b.png