• SpringMVC综合案例

    目录

    一、SpringMVC常用注解

    二、传递参数

    2.1 基础类型+String

    2.2 复杂类型

    2.3 @RequestParam

    2.4 @PathVariable

    2.5 @RequestBody

    2.6 RequestHeader 

    2.7 请求方法

    三、返回值

    3.1 void

    3.2 String

    3.3 String+Model

    3.4 ModelAndView

    四、页面跳转

     4.1 转发

    4.2 重定向

    五、SpringMVC总结优点与缺点

    一、SpringMVC常用注解

    1. @Controller：用于声明一个控制器类。

    2. @RequestMapping：用于映射请求 URL 到控制器类或处理方法上。

    3. @RequestParam：用于获取请求参数的值。

    4. @PathVariable：用于获取 URL 中的参数值。

    5. @ResponseBody：用于将返回值转化为 JSON 格式或其他格式的数据。

    6. @ModelAttribute：用于将请求参数绑定到模型对象上。

    7. @Valid：用于验证请求参数。

    8. @InitBinder：用于定义数据类型转换和格式化规则。

    9. @SessionAttributes：用于将模型对象存储到会话中。

    10. @ExceptionHandler：用于处理控制器方法中抛出的异常。

    11. @RequestMapping(value=“”, method=RequestMethod.GET) 用于处理 GET 请求。

    12. @RequestMapping(value=“”, method=RequestMethod.POST) 用于处理 POST 请求。

    13. @RequestMapping(value=“”, method=RequestMethod.PUT) 用于处理 PUT 请求。

    14. @RequestMapping(value=“”, method=RequestMethod.DELETE) 用于处理 DELETE 请求。

    二、传递参数

    2.1 基础类型+String

    @RequestMapping("/hello1")
        public String toHello1(Integer bid,String bname){
            log.info(">>>> 基础类型+String传参：{},{}",bid,bname);
            return "index";
        }

    新建一个paramController类：

    1. package com.Kissship.web;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6.  
    7. /**
    8.  * @author Kissship
    9.  * @site www.Kissship.com
    10.  * @company xxx公司
    11.  * @create 2023-09-05-14:44
    12.  */
    13. @Slf4j
    14. @Controller
    15. @RequestMapping("/param")
    16. public class ParamController {
    17.     @RequestMapping("/hello1")
    18.     public String index(String bname,Integer bid){
    19. //        System.out.println("刘三金去拿奶茶喽。。。");
    20.         log.info("简单类型参数：bname:{},bid:{}",bname,bid);
    21.         return "index";
    22.     }
    23. }

     index.jsp：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7. <h1>无需多言h1>
    8. body>
    9. html>

     效果演示：

    2.2 复杂类型

    @RequestMapping("/hello2")
        public String toHello2(Book book,
                               HttpServletRequest req,
                               HttpServletResponse resp,
                               HttpSession session){
            System.out.println(book);
            log.info(">>>> HttpServletRequest/HttpServletResponse/HttpSession等等传参：{}", req.getRequestURI());
            return "index";
        } 

    在paramController类中添加以下方法：

    1. @RequestMapping("/hello2")
    2.     public String hello2(Book book, HttpServletRequest request){
    3. //        System.out.println("刘三金去拿奶茶喽。。。");
    4.         //servlet参数获取方式
    5.         log.info("复杂类型参数：bname:{},bid:{}",
    6.                 request.getParameter("bname"),
    7.                 request.getParameter("bid"));
    8.         //复杂传参
    9.         log.info("复杂类型参数：book:{}",
    10.                 book.toString());
    11. //      fail..error warning info debug
    12.         return "index";
    13.     }

     主页代码不变。

    效果演示：

    2.3 @RequestParam

    @RequestMapping("/hello3")
        public String toHello3(@RequestParam Integer bid,
                               @RequestParam(required = false,value = "price") Integer bookPrice,
                               @RequestParam("bookName") String bname){
            log.info(">>>> 使用@RequestParam注解传递参数：{},{},{}", bid,bname,bookPrice);
            return "index";
        }

    在paramController类中添加以下方法：

    1. @RequestMapping("/hello3")
    2.         public String hello3(
    3.                @RequestParam String bname,
    4.                @RequestParam(required = false) Integer bid){
    5. //        System.out.println("刘三金去拿奶茶喽。。。");
    6.             log.info("@requestParam参数：bname:{},bid:{}",bname,bid);
    7. //      fail..error warning info debug
    8.             return "index";
    9.         }

    注：

    未加入判断则在域名中必须携带此属性。

    主页代码不变。

    演示效果：

    控制台传参效果：

    2.4 @PathVariable

     @RequestMapping("/hello4/{bid}")
        public String toHello4(@PathVariable("bid") Integer bid){
            log.info(">>>> 使用@PathVariable注解传递参数：{}", bid);
            return "index";
        }

    在paramController类中添加以下方法：

    1. @RequestMapping("/hello4/{bid}")
    2.     public String hello4(@PathVariable("bid") Integer bid){
    3. //        System.out.println("刘三金去拿奶茶喽。。。");
    4.         log.info("@requestParam参数：bid:{}",bid);
    5. //      fail..error warning info debug
    6.         return "index";
    7.     }

    主页代码不变。

    页面演示效果如下：

    控制台传参效果：

    2.5 @RequestBody

    在进行@RequestBody传参前先要在pom.xml传入依赖，如下：

    1. <jackson.version>2.9.3jackson.version>
    2.  
    3.  <dependency>
    4.       <groupId>com.fasterxml.jackson.coregroupId>
    5.       <artifactId>jackson-databindartifactId>
    6.       <version>${jackson.version}version>
    7.     dependency>
    8.     <dependency>
    9.       <groupId>com.fasterxml.jackson.coregroupId>
    10.       <artifactId>jackson-coreartifactId>
    11.       <version>${jackson.version}version>
    12.     dependency>
    13.     <dependency>
    14.       <groupId>com.fasterxml.jackson.coregroupId>
    15.       <artifactId>jackson-annotationsartifactId>
    16.       <version>${jackson.version}version>
    17.     dependency>

    在导入依赖后我们还需要postman或者apipost/eolink等工具发送请求数据。 因为浏览器发送不了JSON数据请求。所以我们需要安装Eolink等第三方工具进行测试。

    安装好后，按照以下步骤把参数填写好，query参数是往域名链接添加属性，如下：

    然后介绍完Query参数后就开始添加我们的请求体参数，如下：

    输入请求参数后，我们先测试hello5，看能否传过去，如下：

    通过方法五跟方法六的对比，可得出@RequestBody适用于专门接受Json数据形式串。

    2.6 RequestHeader 

    获取请求头中的信息。

    @RequestMapping("/hello7")
        public String toHello7(Book book, @RequestBody Map map, @RequestHeader("jwt") String jwt){
            System.out.println(map);
            System.out.println(book);
            System.out.println(jwt);
            return "index";
        }

    方法代码如下：

    1.  @RequestMapping("/hello7")
    2.     public String hello7(@RequestHeader("jwt") String jwt){
    3. //        System.out.println("刘三金去拿奶茶喽。。。");
    4.         log.info("@RequestHeader参数：jwt:{}",jwt);
    5. //      fail..error warning info debug
    6.         return "index";
    7.     }
    8.  
    9.     @RequestMapping("/hello8")
    10.     public String hello8(Book book,
    11.             @RequestBody Map map,
    12.             @RequestHeader("jwt") String jwt){
    13. //        System.out.println("刘三金去拿奶茶喽。。。");
    14.         log.info("Book：Book:{}",book.toString());
    15.         log.info("@RequestBody参数：Map:{}",map);
    16.         log.info("@RequestHeader参数：jwt:{}",jwt);
    17. //      fail..error warning info debug
    18.         return "index";
    19.     }

    代码完成之后我们需要在Eolink中进行头部请求参数配置，如下： 

    然后进行测试（方法七）结果如下：

    最后我们再来测试以下方法八，个人配置如下：

     

    2.7 请求方法

    请求方法有：

    RequestMapping与GetMapping、PostMapping、PutMapping、DeleteMapping

    他们之间的关系为：

    RequestMapping=GetMapping+PostMapping+PutMapping+DeleteMapping

    为什么企业中不用RequestMapping请求方法而用其他四种？

    RequestMapping与GetMapping、PostMapping、PutMapping、DeleteMapping的区别：

    RequestMapping不安全，且不具备标识意义。

    测试方法如下：

    1. //查询的请求
    2.     @GetMapping
    3.     public String type1(){
    4.         System.out.println("@GetMapping：对应查询请求");
    5.         return "index";
    6.     }
    7.  
    8.     //新增的请求
    9.     @PostMapping
    10.     public String type2(){
    11.         System.out.println("@PostMapping：对应新增请求");
    12.         return "index";
    13.     }
    14.  
    15.     //修改的请求
    16.     @PutMapping
    17.     public String type3(){
    18.         System.out.println("@PutMapping：对应修改请求");
    19.         return "index";
    20.     }
    21.  
    22.     //删除的请求
    23.     @DeleteMapping
    24.     public String type4(){
    25.         System.out.println("@DeleteMapping：对应删除请求");
    26.         return "index";
    27.     }
    28.  
    29.     //RequestMapping=GetMapping+PostMapping+PutMapping+DeleteMapping
    30.     //RequestMapping不安全，且不具备标识意义

     依次进行请求，请求的方式不同会进行不同的请求注解，具体操作与效果如下：

    三、返回值

    创建一个ResponseUtil工具类，辅助完成测试代码，如下：

    1. package com.Kissship.utils;
    2.  
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4.  
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.PrintWriter;
    7.  
    8. public class ResponseUtil {
    9.  
    10. 	public static void write(HttpServletResponse response,Object o)throws Exception{
    11. 		response.setContentType("text/html;charset=utf-8");
    12. 		PrintWriter out=response.getWriter();
    13. 		out.println(o.toString());
    14. 		out.flush();
    15. 		out.close();
    16. 	}
    17. 	
    18. 	public static void writeJson(HttpServletResponse response,Object o)throws Exception{
    19. 		ObjectMapper om = new ObjectMapper();
    20. //		om.writeValueAsString(o)代表了json串
    21. 		write(response, om.writeValueAsString(o));
    22. 	}
    23. }

    创建一个ReturnController类，来进行方法的请求测试(包含关于返回值的所以方法)。如下： 

    1. package com.Kissship.web;
    2.  
    3. import com.Kissship.utils.ResponseUtil;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.ui.Model;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8. import org.springframework.web.servlet.ModelAndView;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.util.HashMap;
    13. import java.util.Map;
    14.  
    15. /**
    16.  * @author Kissship
    17.  * @site www.Kissship.com
    18.  * @company xxx公司
    19.  * @create 2023-09-05-14:44
    20.  */
    21. @Controller
    22. @RequestMapping("/rs")
    23. public class ReturnController {
    24.  
    25.     @RequestMapping("/test01")
    26.     public void Test01(HttpServletResponse response) throws Exception {
    27.         Map map = new HashMap();
    28.         map.put("id",1);
    29.         map.put("午夜","塞尔维亚的舞者");
    30.         map.put("舞者","增加成功!!!");
    31.         ResponseUtil.writeJson(response,map);
    32.     }
    33.  
    34.     @ResponseBody
    35.     @RequestMapping("/test02")
    36.     public Map Test02(HttpServletResponse response) throws Exception {
    37.         Map map = new HashMap();
    38.         map.put("id",1);
    39.         map.put("午夜","塞尔维亚的舞者");
    40.         map.put("舞者","增加成功!!!");
    41.         return map;
    42.     }
    43.  
    44.     @RequestMapping("/test03")
    45.     public String Test03() {
    46.         return "index02";
    47.     }
    48.  
    49.     @RequestMapping("/test04")
    50.     public String Test04(
    51.             Model model,
    52.             HttpServletRequest request) {
    53.         model.addAttribute("No1","冷雨飘向我,点点纷飞");
    54.         request.setAttribute("No2","千里高温波涛,由你涌起");
    55.         return "index02";
    56.     }
    57.  
    58.     @RequestMapping("/test05")
    59.     public ModelAndView Test05() {
    60.         ModelAndView modelAndView = new ModelAndView();
    61.         modelAndView.addObject("No1","冷雨飘向我,点点纷飞");
    62.         modelAndView.addObject("No2","各个笑我太狂,笑我不羁");
    63.         modelAndView.setViewName("index02");
    64.         return modelAndView;
    65.     }
    66.  
    67. }

     创建一个index.jsp页面进行显示测试，如下：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>Titletitle>
    5. head>
    6. <body>
    7. <h1>敢爱敢做h1>
    8. 歌词上句:  ${No1}<br>
    9. 歌词下句:  ${No2}
    10. body>
    11. html>

    3.1 void

    处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void。

    3.2 String

    3.3 String+Model

    打开浏览器输入相对应地址，结果如下：

    Model测试：

    将test03换成test04接着输出即可：

    3.4 ModelAndView

    打开浏览器输入相应请求地址，结果如下：

    四、页面跳转

    创建一个PathConterller测试类，进行页面跳转的各种方法测试，代码如下: 

    1. package com.Kissship.web;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6.  
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.util.HashMap;
    9. import java.util.Map;
    10.  
    11. /**
    12.  * @author Kissship
    13.  * @site www.Kissship.com
    14.  * @company xxx公司
    15.  * @create 2023-09-06-16:19
    16.  */@Controller
    17. @RequestMapping("/ts")
    18. public class PathConterller {
    19.  
    20.     @ResponseBody
    21.     @RequestMapping("/test02")
    22.     public Map Test02(HttpServletResponse response) throws Exception {
    23.         Map map = new HashMap();
    24.         map.put("id",1);
    25.         map.put("午夜","塞尔维亚的舞者");
    26.         map.put("舞者","增加成功!!!");
    27.         return map;
    28.     }
    29.  
    30.     //返回值中有转发（forward）和重定向（redirect）这两种跳转方式将会绕开视图解析器的前缀和后缀
    31.  
    32.     //转发到(当前类)的某一个方法
    33.     @RequestMapping("/Demo01")
    34.     public String Demo01(){
    35.         System.out.println("请求地址:Demo01");
    36.         System.out.println("转发到(当前类)的某一个方法");
    37.         return "forward:test02";
    38.     }
    39.  
    40.     //转发到(其他类)的某一个方法
    41.     @RequestMapping("/Demo02")
    42.     public String Demo02(){
    43.         System.out.println("请求地址:Demo02");
    44.         System.out.println("转发到(其他类)的某一个方法");
    45.         return "forward:/rs/test04";
    46.     }
    47.  
    48.     //重定向到(其他类)的某一个方法
    49.     @RequestMapping("/Demo03")
    50.     public String Demo03(){
    51.         System.out.println("请求地址:Demo03");
    52.         System.out.println("重定向到(其他类)的某一个方法");
    53.         return "redirect:test02";
    54.     }
    55.  
    56.     //重定向到(其他类)的某一个方法
    57.     @RequestMapping("/Demo04")
    58.     public String Demo04(){
    59.         System.out.println("请求地址:Demo04");
    60.         System.out.println("重定向到(其他类)的某一个方法");
    61.         return "redirect:/rs/test04";
    62.     }
    63.  
    64.  
    65. }

     4.1 转发

    它相当于“request.getRequestDispatcher("url").forward(request,response)”。使用转发，既可以转发到jsp， 也可以转发到其他的控制器方法。

    打开服务器 ，在浏览器上方输入对应请求地址此处输入Demo02，结果如下：

    4.2 重定向

    打开服务器 ，在浏览器上方输入对应请求地址此处输入Demo04，结果如下：

    五、SpringMVC总结优点与缺点

    优点：

    • 简化配置：注解可以替代繁琐的XML配置，使配置更加简洁和直观。注解使用注解处理器进行解析，可以自动完成配置和初始化的工作，减少了手动配置的工作量。
    • 提高可读性：通过使用注解，开发人员可以更清晰地了解代码的作用和意图。注解的语义明确，可以提高代码的可读性和可维护性。
    • 提高开发效率：注解简化了很多重复性的工作，如依赖注入、请求映射等。开发人员可以专注于核心业务逻辑而不必关注繁琐的配置细节，从而提高开发效率。
    • 提供丰富的功能扩展：Spring框架提供了多种注解，可以应用于不同的场景和功能需求，如控制器的请求映射、数据验证、事务管理等。这些注解提供了灵活的扩展机制，使得开发人员可以根据具体需求进行定制化的开发。
    • 支持AOP：Spring框架通过注解提供了对面向切面编程（AOP）的支持。使用注解修饰目标方法或类，可以方便地定义切点、切面和通知，提供横切关注点的解耦和重用能力。

    缺点：

    • 隐式依赖：注解的使用可能导致隐式依赖，不像显式配置那样清晰可见。有时候可能会造成代码的可读性和维护性下降，特别是在大型项目中。
    • 学习成本：使用注解需要对注解的语法和规范有一定的了解和掌握。不熟悉注解的开发人员可能需要花费一些时间学习和适应。
    • 自定义性受限：某些注解的功能和行为是固定的，如果需要自定义一些特定的逻辑，可能需要编写额外的代码或使用其他方式实现。
    • 过度使用：过度使用注解可能导致代码变得难以理解和维护。在使用注解时，应该遵循适度使用的原则，确保注解的使用符合代码的整体设计思路和架构。

    最后SpringMVC综合案例就到这里，祝大家在敲代码的路上一路通畅!

    感谢大家的观看 !

  • 相关阅读:
    JMeter 如何实现 Elasticsearch 8.X 性能测试？
    架构：应用架构的演进以及微服务架构的落地实践
    关于在本地启动跨域非nodejs的前后端分离项目
    C++信息学奥赛1170：计算2的N次方
    centOS 7 离线安装 MySQL 5.6 完美安装
    华为奔赴“空间智能”，全屋智能的逻辑变了吗？
    HTML入门教程23：HTML脚本
    05在IDEA中配置Maven的基本信息
    音视频开发—FFmpeg打开麦克风，采集音频数据
    【Transformer系列】深入浅出理解Embedding（词嵌入）
  • 原文地址：https://blog.csdn.net/weixin_74263417/article/details/132693590