MVC est un modèle de conception logicielle courant utilisé pour séparer les différentes parties d'une application afin d'obtenir un couplage lâche et une cohésion élevée. Le modèle MVC se compose de trois composants principaux :
Modèle : représente les données et la logique métier de l'application. Le modèle traite les données de l'application et exécute les actions correspondantes sur la base des instructions du contrôleur.
View : fournit une interface utilisateur pour les données du modèle. Les vues sont généralement des modèles, des pages HTML, des fichiers XML ou d'autres formats présentant les données du modèle aux utilisateurs.
Contrôleur : gère l'interaction de l'utilisateur et met à jour les modèles et les vues. Le contrôleur est chargé de recevoir les entrées de l'utilisateur à partir de la vue, d'effectuer les opérations correspondantes sur le modèle et de mettre à jour la vue pour refléter les modifications.
L'avantage du modèle MVC est qu'il peut séparer le code en trois composants indépendants, ce qui rend l'application plus facile à maintenir et à étendre. Par exemple, si vous souhaitez modifier l'apparence d'une vue, vous pouvez modifier la vue sans affecter le modèle et le contrôleur ; si vous souhaitez modifier la façon dont les données sont stockées, vous pouvez modifier le modèle sans affecter la vue et le contrôleur. Dans le même temps, le modèle MVC contribue également à réduire le couplage dans l'application, rendant chaque composant plus indépendant et réutilisable.
Dans l'architecture MVC sous le système Spring, le processus de traitement d'une requête est le suivant :
La requête est envoyée au contrôleur (contrôleur), et la réponse est renvoyée à la couche de reconnaissance après en cours de traitement par le modèle économique (modèle).
Ce que Spring MVC fait dans l'ensemble du processus :
Le cœur de l'ensemble de Spring MVC est DispatcherServlet Autour de DispatcherServlet, SpringMVC fournit un ensemble de composants pour coopérer avec DispatcherServlet pour compléter l'ensemble du flux de travail.
DispatcherServlet reçoit d'abord la demande et mappe la demande au processeur correspondant (contrôleur). Lorsqu'il est mappé au contrôleur, l'intercepteur sera déclenché une fois le processeur traité, le modèle de données est encapsulé et transmis à l'analyseur de vue ; analyser le modèle de données dans La vue correspondante est renvoyée au front-end.
Bien sûr, parfois le processus ci-dessus ne sera pas terminé. Par exemple, lors de l'utilisation de @RestController ou @ResponseBody, la réponse sera renvoyée directement et l'image ne sera pas redirigée, donc l'analyseur de vue ne sera pas utilisé. .
En raison de l'existence du mécanisme d'assemblage automatique de Spring Boot, nous n'avons généralement pas besoin de configurer Spring MVC si nous voulons effectuer une configuration personnalisée spéciale, Spring. Boot prend également en charge les fichiers de configuration ou l'écriture de code de deux manières.
# Activer Spring MVC
spring.mvc.enabled=true# Configurer le chemin des ressources statiques
spring.mvc.static-path-pattern=/static/**
spring.resources .static-locations=classpath:/static/# Configurer l'analyseur de vue
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp# Configurer le cache HTTP
spring.resources.cache.period=3600# Configurer le téléchargement de fichiers
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB# Configurer la séquence JSON
spring.jackson.serialization.indent_output=true
spring.jackson.date-format=aaaa-MM-jj HH:mm:ss# Configurer la gestion des exceptions
server.error.whitelabel.enabled=false# Configuration Interceptor
spring.mvc.interceptor.exclude-path-patterns=/login,/logout
spring.mvc.interceptor.include-path-patterns=/admin/**# Configurer la gestion de session
server.session.timeout =1800
server.session.cookie.max-age=1800
@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");
}
}Seuls @RequestMapping, @GETMapping et @ sont présentés ici. PostMapping est similaire .
@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 {};
}Les fonctions de chaque paramètre sont les suivantes :
valeur et chemin : utilisé pour spécifier le chemin URL de la requête, vous pouvez utiliser des espaces réservés et des expressions régulières.
méthode : Spécifiez la méthode de requête HTTP, qui peut être GET, POST, PUT, DELETE, etc.
params : spécifiez les conditions pour les paramètres de requête, les expressions de prise en charge, les paramètres multiples et les opérations logiques.
headers : spécifiez les conditions pour les en-têtes de requête, les expressions de support, les en-têtes multiples et les opérations logiques.
consume : Spécifiez le type MIME demandé, utilisé pour limiter le type de contenu de la requête.
produit : Spécifie le type MIME de la réponse, qui est utilisé pour limiter le type de contenu de la réponse.
name : Spécifiez le nom du paramètre de requête, utilisé pour lier automatiquement les valeurs des paramètres.
defaultValue : Spécifiez la valeur par défaut du paramètre de requête.
pathVariable : utilisé pour lier des espaces réservés dans les chemins d'URL.
required : Spécifie si les paramètres de la requête sont obligatoires.
La valeur, la méthode, les paramètres, les en-têtes, consomme et produit des attributs prennent tous en charge la forme de tableau et peuvent correspondre à plusieurs conditions.
1. Correspondance par nom de paramètre
@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
当后端接口的参数列表是对象类型时，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);
}有时候我们希望前端传过来的参数是满足一定格式的，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开启校验：
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 方法
}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;
}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
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
}
}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 {
// 在渲染视图之后执行
}
}Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Étapes de création du projet SpringBoot
Quelle est la différence entre j2ee et springboot
Win11 ignore le didacticiel pour se connecter au compte Microsoft
Touche de raccourci d'arrêt rapide
Quels sont les niveaux de notation par étoiles des utilisateurs mobiles ?
Que dois-je faire si mon iPad ne peut pas être chargé ?
Le système d'exploitation Hongmeng de Huawei est-il Android ?
commande telnet
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
