• SpringMVC之综合案例

    SpringMVC注解

    1. @Controller: 标记一个类为控制器（处理请求的类），将其作为Spring MVC的组件进行管理。

    2. @RequestMapping: 将请求URL映射到具体的处理方法上。可以用在类级别和方法级别，用于指定URL路径。

    3. @RequestParam: 用于将请求参数绑定到方法的参数上。可以指定参数名和是否必须。

    4. @PathVariable: 用于将URL中的占位符参数绑定到方法的参数上。

    5. @ResponseBody: 将方法的返回值直接写入HTTP响应体中，而不是通过视图解析器进行渲染。

    6. @RequestBody: 将HTTP请求体中的内容绑定到方法的参数上。

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

    8. @SessionAttribute: 用于将模型对象存储到会话中，在多个请求之间共享数据。

    9. @Valid: 用于验证模型对象的有效性，配合JSR-303/349标准的注解使用。

    10. @InitBinder: 用于配置WebDataBinder，用于自定义数据绑定和格式化。

    参数传递

    String类型

    基础类型 String 是一种表示文本的数据类型。在许多编程语言中，String 是用来存储和操作文本数据的常见类型。它可以包含任意字符，例如字母、数字、符号等。String 类型通常用于处理用户输入、存储文件内容、构建消息等场景。

    在大多数编程语言中，String 类型是不可变的，这意味着一旦创建了一个字符串，就不能直接修改它的内容。相反，对于字符串的修改通常会返回一个新的字符串。这种不可变性使得字符串更安全，可以避免一些潜在的错误。

    开发人员可以使用一系列的方法来操作字符串，例如连接（concatenation）、截取子串、查找和替换特定的字符等。此外，还可以比较字符串、转换大小写、格式化等。

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

    String 类型是一种常见的基础数据类型，用于处理文本数据并提供了许多相关的方法和操作。

    index.jsp
    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2.    <html>
    3.          <head>
    4.     <title>Title</title>
    5. </head>
    6.        <body>
    7.     <h1>springmvc 雷猴</h1>
    8.      </body>
    9. </html>
     paramController
    1. package com.zhnaghao.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 zhnaghao
    9.  * @site 
    10.  * @company s集团
    11.  * @create 2023-09-06-21: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. }

     

     复杂类型 
    1. @RequestMapping("/hello2")
    2.     public String toHello2(Book book,
    3.                            HttpServletRequest req,
    4.                            HttpServletResponse resp,
    5.                            HttpSession session){
    6.         System.out.println(book);
    7.         log.info(">>>> HttpServletRequest/HttpServletResponse/HttpSession等等传参：{}", req.getRequestURI());
    8.         return "index";
    9.     }
    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.     }

     

    @RequestParam 
    1. @RequestMapping("/hello4/{bid}")
    2.     public String toHello4(@PathVariable("bid") Integer bid){
    3.         log.info(">>>> 使用@PathVariable注解传递参数：{}", bid);
    4.         return "index";
    5.     }
    paramController
    1. @RequestMapping("/hello3")
    2.     public String toHello3(@RequestParam Integer bid,
    3.                            @RequestParam(required = false,value = "price") Integer bookPrice,
    4.                            @RequestParam("bookName") String bname){
    5.         log.info(">>>> 使用@RequestParam注解传递参数：{},{},{}", bid,bname,bookPrice);
    6.         return "index";
    7.     }
    @RequestBody
    1. <jackson.version>2.9.3</jackson.version>
    2.  
    3.  <dependency>
    4.       <groupId>com.fasterxml.jackson.core</groupId>
    5.       <artifactId>jackson-databind</artifactId>
    6.       <version>${jackson.version}</version>
    7.     </dependency>
    8.     <dependency>
    9.       <groupId>com.fasterxml.jackson.core</groupId>
    10.       <artifactId>jackson-core</artifactId>
    11.       <version>${jackson.version}</version>
    12.     </dependency>
    13.     <dependency>
    14.       <groupId>com.fasterxml.jackson.core</groupId>
    15.       <artifactId>jackson-annotations</artifactId>
    16.       <version>${jackson.version}</version>
    17.     </dependency>
     RequestHeader 
    1. 获取请求头中的信息。
    2.  
    3. @RequestMapping("/hello7")
    4.     public String toHello7(Book book, @RequestBody Map map, @RequestHeader("jwt") String jwt){
    5.         System.out.println(map);
    6.         System.out.println(book);
    7.         System.out.println(jwt);
    8.         return "index";
    9.     }
    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.     }
    常用请求方法 

    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.zhanghao.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.zhanghao.web;
    2.  
    3. import com.zhanghao.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 zhanghao
    17.  * @site 
    18.  * @company s集团
    19.  * @create 2023-09-06-21: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<String,Object> map = new HashMap<String,Object>();
    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<String,Object> map = new HashMap<String,Object>();
    38.         map.put("id",1);
    39.         map.put(" "," ");
    40.         map.put("1","增加成功!!!");
    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>Title</title>
    5. </head>
    6. <body>
    7. <h1>123321</h1>
    8. 上句:  ${No1}<br>
    9. 下句:  ${No2}
    10. </body>
    11. </html>

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

     

    页面跳转

    创造一个PathConterller

    1. package com.zhanghao.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 zhanghao
    13.  * @site
    14.  * @company s集团
    15.  * @create 2023-09-06-21: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. }

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

    总结

    优点：

    1. 轻量级：SpringMVC相对于其他框架来说比较轻量级，不需要依赖很多的第三方库和组件。
    2. 灵活性：SpringMVC采用了灵活、可配置的设计，能够根据项目需求进行定制化配置。
    3. 松耦合：SpringMVC通过使用控制反转（IoC）和依赖注入（DI）等技术，实现了组件之间的松耦合，提高了代码的可维护性和可测试性。
    4. 易于集成：SpringMVC与Spring框架无缝集成，可以很方便地与其他Spring生态系统中的组件进行集成。
    5. 兼容性：SpringMVC支持各种视图技术，如JSP、Freemarker、Velocity等，并且支持RESTful风格的开发。

    缺点：

    1. 学习曲线较陡：对于初学者来说，由于SpringMVC涉及到很多概念和技术，学习曲线较陡，需要一定的时间和精力去理解和掌握。
    2. 配置复杂：由于其灵活性和可配置性，SpringMVC的配置相对复杂，需要熟悉框架的各种配置选项和规则。
    3. 部分功能不完善：相比于其他一些框架，SpringMVC在某些功能方面可能存在一些不完善或者缺失，需要额外的开发工作来实现。
    4. 性能较低：相对于一些性能优化较好的框架来说，SpringMVC的性能可能相对较低，需要进行一定的优化和调整。

    以上是SpringMVC的优点和缺点，根据具体项目需求和开发团队的技术栈选择合适的框架是很重要的。

  • 相关阅读:
    【超简单-Java设计模式2】简单工厂模式
    牛视系统源码，抖音矩阵系统。抖音SEO源码。mmm
    Jenkins简要说明
    别走，这里有一份摸鱼小妙招，别人我不告诉他！
    JavaEE初阶：文件操作 和 IO
    “蔚来杯“2022牛客暑期多校训练营2，签到题GJK
    Spring Boot + BPMN流程管理引擎实践
    Docker搭建RabbitMQ集群
    Nginx源码解析--configure
    WebSocket消息推送
  • 原文地址：https://blog.csdn.net/djssubddbj/article/details/132691301