【精选】SpringMVC处理响应及注解开发

最新推荐文章于 2024-07-20 23:55:03 发布
最新推荐文章于 2024-07-20 23:55:03 发布
阅读量1.3k 收藏 20
点赞数 28
分类专栏： Spring框架 文章标签： java intellij-idea idea spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guojiaqi_/article/details/135051565
版权

SpringMVC处理响应

在这里插入图片描述

配置视图解析器

在这里插入图片描述

SpringMVC默认情况下会在控制器执行完成后跳转到视图页面，视图解析器能找到相应的视图，之前的404异常就是由于没有配置视图解析器导致找不到视图。

在SpringMVC中提供了13个视图解析器，用于支持不同的视图技术。InternalResourceViewResolver是SpringMVC的默认视图解析器，用来解析JSP视图。

<!-- 视图解析器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <!-- 视图前缀 -->
  <property name="prefix" value="/" />
  <!-- 视图后缀 -->
  <property name="suffix" value=".jsp" />
</bean>

控制器方法的返回值

我们可以通过控制器方法的返回值设置跳转的视图，控制器方法支持以下返回值类型：

返回值为void

此时会跳转到名字是 前缀+方法路径名+后缀 的jsp页面

  1. 编写控制器方法

    // 路径是helloMVC，方法执行完后会跳转到/helloMVC.jsp
@RequestMapping("/helloMVC")
public void helloMVC(){
  System.out.println("hello SpringMVC！");
}

  2. 编写helloMVC.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>MVC</title>
  </head>
  <body>
    <h1>欢迎来到SpringMVC</h1>
  </body>
</html>
返回值为String

此时会跳转到名字是 前缀+返回值+后缀 的jsp页面

编写控制器方法

// 返回值为String
@RequestMapping("/c2/hello1")
public String helloMVC1(){
  System.out.println("hello SpringMVC！");
  // 方法执行完后会跳转到/helloMVC.jsp
  return "helloMVC";
}
返回值为ModelAndView

这是SpringMVC提供的对象，该对象可以向request域设置数据并指定跳转的页面。该对象中包含Model对象和View对象。

  • Model：向request域中设置数据。
  • View：指定跳转的页面。

  1. 编写控制器方法

    // 返回值为ModelAndView
@RequestMapping("/c2/hello2")
public ModelAndView useMAV(){
  System.out.println("返回值类型为ModelAndView");
  // 1.创建ModelAndView对象
  ModelAndView modelAndView = new ModelAndView();
  // 2.获取Model对象，本质是一个Map
  Map<String, Object> model = modelAndView.getModel();
  // 3.使用Model对象向request域设置数据
  model.put("name","李四");
  // 4.使用View对象设置跳转的路径为/baizhan.jsp
  modelAndView.setViewName("baizhan");
  return modelAndView;
}

  2. 编写jsp页面

    <%@ page contentType="text/html;charset=UTF-8" language="java"%>
<html>
  <head>
    <title>hello</title>
  </head>
  <body>
    <h1>你好！${requestScope.name}</h1>
  </body>
</html>

  3. 修改web.xml命名空间，让jsp页面默认支持el表达式

    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
               http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
     version="3.1">
</web-app>

request域设置数据

当控制器返回值为ModelAndView时我们可以向request域设置数据，我们还有以下方法可以向request域设置数据：

使用原生的HttpServletRequest
@RequestMapping("/c2/hello3")
public String setRequestModel(HttpServletRequest request){
  request.setAttribute("username","张三");
  return "baizhan";
}
使用Model、ModelMap

SpringMVC提供了Model接口和ModelMap类，控制器方法添加这两个类型的参数，使用该参数设置数据，该数据就会存到request域中。

@RequestMapping("/c2/hello4")
public String setRequestModel2(Model model, ModelMap modelMap){
  // 使用Model将数据存入request域
  // model.addAttribute("username","张三");
  // 使用ModelMap将数据存入request域
  modelMap.addAttribute("username","张三");
  return "baizhan";
}
使用Map集合

Model接口底层就是一个Map集合，我们可以给控制器方法设置Map类型的参数，向Map中添加键值对，数据也会存到request域中。

@RequestMapping("/c2/hello5")
public String setRequestModel3(Map map){
  map.put("username","张三");
  return "baizhan";
}

session域设置数据

Session作用域表示在当前会话中有效。在SpringMVC中对于Session作用域传值，只能使用HttpSession对象来实现。

  1. 编写控制器方法

    @RequestMapping("/c2/hello6")
public String setSeesionModel(HttpSession session){
  session.setAttribute("address","北京");
  return "baizhan";
}

  2. 编写jsp页面

    <%@ page contentType="text/html;charset=UTF-8" language="java"%>
<html>
  <head>
    <title>hello</title>
  </head>
  <body>
     <h1>你好！${requestScope.name}</h1>
        <h1>地址是！${sessionScope.address}</h1>
  </body>
</html>

context域设置数据

context作用域表示在整个应用范围都有效。在SpringMVC中对context作用域传值，只能使用ServletContext对象来实现。但是该对象不能直接注入到方法参数中，需要通过HttpSession对象获取。

  1. 编写控制器方法

    @RequestMapping("/c2/hello7")
public String setContextModel(HttpSession session){
  ServletContext servletContext = session.getServletContext();
  servletContext.setAttribute("age",10);
  return "baizhan";
}

  2. 编写jsp页面

    <%@ page contentType="text/html;charset=UTF-8" language="java"%>
<html>
  <head>
    <title>hello</title>
  </head>
  <body>
    <h1>你好！${requestScope.name}</h1>
    <h1>地址是！${sessionScope.address}</h1>
    <h1>年纪是！${applicationScope.age}</h1>
  </body>
</html>

请求转发&重定向

之前的案例，我们发现request域中的值可以传到jsp页面中，也就是通过视图解析器跳转到视图的底层是请求转发。

如果我们跳转时不想使用视图解析器，可以使用原生HttpServletRequest进行请求转发或HttpServletResponse进行重定向：

@RequestMapping("/c2/hello8")
public void myForward1(HttpServletRequest request, HttpServletResponse response) throws Exception{
  request.setAttribute("name","张三");
  // 请求转发
  //     request.getRequestDispatcher("/c2/hello9").forward(request,response);
  // 原生重定向
  response.sendRedirect("/c2/hello9");
}


@RequestMapping("/c2/hello9")
public void myForward2(HttpServletRequest request){
  System.out.println("hello");
  System.out.println(request.getAttribute("name"));
}

SpringMVC还提供了一种更简单的请求转发和重定向的写法：

@RequestMapping("/c2/hello10")
public String myForward3(HttpServletRequest request){
  request.setAttribute("name","张三");
  // 请求转发
  return "forward:/c2/hello9";
  // 重定向
  return "redirect:/c2/hello9";
}

SpringMVC通过注解来实现控制器的功能，接下来我们详细学习SpringMVC的常用注解：

SpringMVC注解

在这里插入图片描述

@Controller

作用：标记控制器，将控制器交给Spring容器管理。

位置：类上方

@RequestMapping

作用：给控制器方法设置请求路径

位置：方法或类上方。用于类上，表示类中的所有控制器方法都是以该地址作为父路径。

属性：

  • value/path:请求路径
  • method:指定请求方式
  • params:规定必须发送的请求参数
  • headers:规定请求必须包含的请求头
@Controller
@RequestMapping("/c3")
public class MyController3 {
   /*
    访问路径为 /c3/annotation1
    支持post和get请求
    请求时必须带有age参数
    请求时必须带有User-agent请求头
   */
  @RequestMapping(path = "/annotation1",method = {RequestMethod.GET,RequestMethod.POST},params = {"age"},headers = {"User-agent"})
  public String annotation1(String username){
    System.out.println(username);
    return "baizhan";
   }
}

@RequestParam

作用：在控制器方法中获取请求参数

位置：方法参数前

属性：

  • name：指定请求参数名称
  • defaultValue： 为参数设置默认值
  • required：设置是否是必须要传入的参数
/*
  定义请求的参数名为username，默认值为lisi，不是必须的参数
 */
@RequestMapping("/annotation2")
public String annotation2(@RequestParam(name = "username",defaultValue = "lisi",required = false) String name){
  System.out.println(name);
  return "baizhan";
}

请求URL的写法：http://localhost:8080/c3/annotation2?username=bz

@RequestHeader、@CookieValue

@RequestHeader

作用：在控制器方法中获取请求头数据

位置：方法参数前

@CookieValue

作用：在控制器方法中获取Cookie数据

位置：方法参数前

/*
    获取User-Agent请求头
    获取JSESSIONID的Cookie值
   */
@RequestMapping("/annotation3")
public String annotation3(@RequestHeader("User-Agent") String userAgent, @CookieValue("JSESSIONID") String jSessionId){
  System.out.println(userAgent);
  System.out.println(jSessionId);
  return "baizhan";
}

@SessionAttributes

作用：将Model模型中的数据存到session域中

位置：类上方

@Controller
@RequestMapping("/c4")
// 将模型中的name数据保存到session中
@SessionAttributes("name")
public class MyController4 {
  @RequestMapping("/t1")
  public String t1(Model model){
    // model中保存name数据
    model.addAttribute("name","张三");
    return "baizhan";
   }


  @RequestMapping("/t2")
  public String t2(HttpSession session){
    // 从session中获取name数据
    System.out.println(session.getAttribute("name"));
    return "baizhan";
   }
}

@ModelAttribute

作用1：设置指定方法在控制器其他方法前执行

位置：方法上方

@Controller
@RequestMapping("/c5")
public class MyController5 {
  @ModelAttribute
  public void before(){
    System.out.println("前置方法");
   }


  @RequestMapping("/t1")
  public String t1(){
    System.out.println("t1");
    return "baizhan";
   }
}

作用2：从Model模型中获取数据给参数赋值

位置：方法参数前

@Controller
@RequestMapping("/c6")
public class MyController6 {
  // 前置方法向Model中设置数据
  @ModelAttribute
  public void before(Model model){
    model.addAttribute("name","张三");
   }


  // 该参数不是从请求中获取，而是从Model中获取
  @RequestMapping("/t1")
  public String t1(@ModelAttribute("name") String name){
    System.out.println(name);
    return "baizhan";
   }
}

RESTful风格支持

RESTful风格介绍

RESTful风格是一种URL路径的设计风格。在RESTful风格的URL路径中，网络上的任意数据都可以看成一个资源，它可以是一段文本、一张图片，也可以是一个Java对象。而每个资源都会占据一个网络路径，无论对该资源进行增删改查，访问的路径是一致的。

传统URL：

  • 查找id为1的学生：

    http://localhost:8080/student/findById?id=30

  • 删除id为1的学生：

    http://localhost:8080/student/deleteById?id=30

RESTful风格URL：

  • 查找id为30的学生：

    http://localhost:8080/student/30

  • 删除id为30的学生：

    http://localhost:8080/student/30

那么如何区分对该资源是哪一种操作？通过请求方式不同，判断进行的是什么操作。

之前我们学过两种请求方式，GET请求和POST请求，而访问RESTful风格的URL一共有四种请求方式：

  • GET请求：查询操作
  • POST请求：新增操作
  • DELETE请求：删除操作
  • PUT请求：修改操作

RESTful风格URL：

  • 查找id为30的学生：

    http://localhost:8080/student/30 GET方式请求

  • 删除id为30的学生：

    http://localhost:8080/student/30 DELETE方式请求

RESTful风格的优点:

结构清晰、符合标准、易于理解、扩展方便。

Postman使用

默认情况下浏览器是无法发送DELETE请求和PUT请求的，我们可以使用Postman工具发送这些请求。

  1. 双击安装包安装Postman

  2. 点击new-collection创建请求集合

  3. 添加请求

  4. 保存请求到集合，以后可以随时发送该请求

@PathVariable

作用：在RESTful风格的URL中获取占位符的值

位置：方法参数前

属性：

  • value：获取哪个占位符的值作为参数值，如果占位符和参数名相同，可以省略该属性。
@Controller
@RequestMapping("/student")
// 模拟学生的增删改查控制器
public class StudentController {
  // 路径中的{id}表示占位符，最后会封装到方法的参数中使用
  // 删除学生
  @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
  public String deleteStudent(@PathVariable("id") int id){
    System.out.println("删除id为"+id+"的学生");
    return "baizhan";
   }


  // 如果占位符和参数名相同，可以省略@PathVariable的value属性
  // 根据id查询学生
  @RequestMapping(value = "/{id}",method = RequestMethod.GET)
  public String findStudentById(@PathVariable int id){
    System.out.println(id);
    System.out.println("根据id查询学生");
    return "baizhan";
   }


    // 新增学生
  @RequestMapping(value = "/{id}",method = RequestMethod.POST)
  public String addStudent(@PathVariable int id, Student student){
    System.out.println(id);
    System.out.println(student);
    System.out.println("新增学生");
    return "baizhan";
   }


  // 修改学生
  @RequestMapping(value = "/{id}",method = RequestMethod.PUT)
  public String updateStudent(@PathVariable int id, Student student){
    System.out.println(id);
    System.out.println(student);
    System.out.println("修改学生");
    return "baizhan";
   }
}

访问方式：

  • 新增学生：POST http://localhost:8080/student/1?name=张三&sex=男
  • 修改学生：PUT http://localhost:8080/student/1?name=张三&sex=男
  • 删除学生：DELETE http://localhost:8080/student/1
  • 查询学生：GET http://localhost:8080/student/1

@PostMapping、@GetMapping、@PutMapping、@DeleteMapping

作用：简化设置请求方式的@RequestMapping写法

位置：方法上方。

@Controller
@RequestMapping("/student")
public class StudentController {
  // 删除学生
  @DeleteMapping("/{id}")
  public String deleteStudent(@PathVariable("id") int id){
    System.out.println("删除id为"+id+"的学生");
    return "baizhan";
   }


  // 根据id查询学生
  @GetMapping("/{id}")
  public String findStudentById(@PathVariable int id){
    System.out.println(id);
    System.out.println("根据id查询学生");
    return "baizhan";
   }


  // 新增学生
  @PostMapping("/{id}")
  public String addStudent(@PathVariable int id, Student student){
    System.out.println(id);
    System.out.println(student);
    System.out.println("新增学生");
    return "baizhan";
   }


  // 修改学生
  @PutMapping("/{id}")
  public String updateStudent(@PathVariable int id, Student student){
    System.out.println(id);
    System.out.println(student);
    System.out.println("修改学生");
    return "baizhan";
   }
}

HiddentHttpMethodFilter

由于浏览器form表单只支持GET与POST请求，而DELETE、PUT请求并不支持，SpringMVC有一个过滤器，可以将浏览器的POST请求改为指定的请求方式，发送给的控制器方法。

用法如下：

  1. 在web.xml中配置过滤器

    <!-- 请求方式过滤器 -->
<filter>
  <filter-name>httpMethodFilter</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>httpMethodFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

  2. 编写控制器方法

    @Controller
@RequestMapping("/c7")
public class MyController7 {
  @DeleteMapping("/delete")
  public String testDelete(){
    System.out.println("删除方法");
    return "baizhan";
   }


  @PutMapping("/put")
  public String testPut(){
    System.out.println("修改方法");
    return "baizhan";
   }
}

  3. 在jsp中编写表单

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>DELETE、PUT提交</title>
  </head>
  <body>
    <!-- 删除 -->
     <%-- 提交DELETE、PUT请求，表单必须提交方式为post --%>
     <%-- 表单中有一个隐藏域，name值为_method，value值为提交方式 --%>
    <form action="/c7/delete" method="post">
      <input type="hidden" name="_method" value="DELETE">
      <input type="submit" value="删除">
    </form>
    <hr/>
    <!-- 修改 -->
    <form action="/c7/put" method="post">
      <input type="hidden" name="_method" value="PUT">
      <input type="submit" value="修改">
    </form>
  </body>
</html>

@ResponseBody

在这里插入图片描述

作用：方法返回的对象转换为JSON格式，并将JSON数据直接写入到输出流中，使用此注解后不会再经过视图解析器。使用该注解可以处理Ajax请求。

位置：方法上方或方法返回值前

  1. 编写jsp页面，发送ajax请求

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>ajax请求</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script>
      $(function () {
        $("#btn").click(function () {
          var name = $("#name").val();
          var sex = $("#sex").val();
          $.get("/c8/addStudent",{"name":name,"sex":sex},function (data){
            console.log(data);
           });
         });
       });
    </script>
  </head>
  <body>
     姓名：<input id="name"/><br/>
     性别：<input id="sex"/><br/>
    <input type="button" value="提交" id="btn"/>
  </body>
</html>

  2. 由于jsp页面中引入jQuery的js文件，而SpringMVC会拦截所有资源，造成jquery.js失效，需要在SpringMVC核心配置文件中放行静态资源。

    <!-- 放行静态资源 -->
<mvc:default-servlet-handler />

  3. 编写结果实体类，该实体类会封装一个请求的结果

    // 请求的结果对象
public class Result {  
  private boolean flag; // 请求是否成功  
  private String message; // 请求提示信息   
  // 省略getter/setter/构造方法
}

  4. 编写控制器

    @PostMapping("/addStudent")
@ResponseBody
public Result addStudent(String name, String sex) {
  // 输出接受到的参数，模拟添加学生
  System.out.println(name+":"+sex);
  // 返回添加结果
  Result result = new Result(true, "添加学生成功！");
  return result;
}

  5. SpringMVC会将Result对象转为JSON格式写入输出流，而SpringMVC默认使用的JSON转换器是jackson，需要在pom中添加jackson依赖。

    <!-- jackson -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.0</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.0</version>
</dependency>

@RestController

如果一个控制器类下的所有控制器方法都返回JSON格式数据且不进行跳转，可以使用@RestController代替@Controller，此时每个方法上的@ResponseBody都可以省略。

@RestController
@RequestMapping("/c8")
public class MyController8 {  
  @PostMapping("/addStudent")  
  public Result addStudent(String name, String sex) { 
    // 输出接受到的参数，模拟添加学生   
    System.out.println(name+":"+sex);    
    // 返回结果    
    Result result = new Result(true, "添加学生成功！"); 
    return result;  
   }
}

静态资源映射

当在DispatcherServlet的<url-pattern>中配置拦截 “/” 时，除了jsp文件不会拦截以外，其他所有的请求都会经过前端控制器进行匹配。此时静态资源例如css、js、jpg等就会被前端控制器拦截，导致不能访问，出现404问题。想要正常映射静态资源共有三种方案：

配置静态资源筛查器

在SpringMVC的配置文件中配置<mvc:default-servlet-handler />后，会在Spring容器中创建一个资源检查器，它对进入DispatcherServlet的URL进行筛查，如果不是静态资源，才由DispatcherServlet处理。

修改SpringMVC核心配置文件：

<mvc:default-servlet-handler/>
配置静态资源映射器

SpringMVC模块提供了静态资源映射器组件，通过<mvc:resources>标签配置静态资源映射器，配置后的路径不会由DispatcherServlet处理。

修改SpringMVC核心配置文件：

<!--配置静态资源映射器-->
<!-- mapping:配置请求的URL location:资源路径-->
<mvc:resources mapping="/img/" location="/img/"/>
<mvc:resources mapping="/js/" location="/js/"/>
配置默认Servlet处理静态资源

在web.xml可以配置默认Servlet处理静态资源，该Servlet由tomcat提供，它会直接访问静态资源不进行其他操作。这样就避免了使用DispatcherServlet对静态资源的拦截：

修改web.xml:

<servlet-mapping>  
  <servlet-name>default</servlet-name>  
  <url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>  
  <servlet-name>default</servlet-name> 
  <url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>  
  <servlet-name>default</servlet-name>  
  <url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>  
  <servlet-name>default</servlet-name>  
  <url-pattern>*.png</url-pattern>
</servlet-mapping>

@RequestBody

作用：将请求中JSON格式的字符串参数转为JAVA对象

位置：写在方法参数前

  1. AJAX请求发送JSON格式的参数

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>ajax请求</title>
    <script src="/js/jquery-2.1.1.min.js"></script>
    <script>
      $(function (){
        $("#btn").click(function (){
          var name=$("#name").val();
          var sex=$("#sex").val();
          var param = JSON.stringify({"name":name,"sex":sex});
          $.ajax({
            url:"/c8/addStudent2",
            contentType:"application/json",
            type:"post",
            data:param,
            success:function (data){
              console.log(data);
             }
           })
         })
       })
    </script>
  </head>
  <br>
   姓名：<input id="name"><br />
   性别：<input id="sex"><br />
  <input type="button" value="提交" id="btn">
  </body>
</html>

  2. 编写控制器

    @PostMapping("/addStudent2")
@ResponseBody
public Result addStudent2(@RequestBody Student student) {
  System.out.println(student);
  // 返回添加结果
  Result result = new Result(true, "添加学生成功！");
  return result;
}
OldGj_
关注
  • 28
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springmvc学习笔记-springmvc注解开发.zip
05-10
在"springmvc学习笔记--springmvc注解开发.zip"这个压缩包中，我们可以深入探讨Spring MVC的注解驱动开发方式，这是一种简洁且高效的开发模式。 1. **Spring MVC基础**： Spring MVC的核心组件包括...
springMVC注解开发代码
09-10
通过这个"springMVC注解开发代码"项目，开发者可以学习到如何使用注解进行 Spring MVC 应用的完整开发，包括控制器、模型绑定、视图解析、异常处理等多个核心概念。同时，结合 `pom.xml` 文件管理和依赖，可以更好地...
深入探究Spring MVC如何处理请求报文和响应报文
weixin_41998947的博客
12-02 563
创建一个Controller然后定义一个方法，方法上面添加@RequestMapping定义url，然后在方法参数中添加@RequestBody注解，在方法上添加@ResponseBody注解，这样在通过url调用这个接口的时候就会自动将参数转换成对象，并且将响应报文也变成对象。而且在调用接口的时候传的String类型的对象，处理请求的handler方法中参数类型却是Integer，这些都是如何实现的呢。其实这些都是通过Spring的参数装换器实现的，接下来我们就通过源码的形式看一下这种参数装换的细节。
学会SpringMVC之自定义注解各种场景应用，提高开发效率及代码质量
SAME_LOVE的博客
09-15 504
在Spring MVC中，自定义注解是一种用于标记和定义特定功能的注解。通过自定义注解，可以在控制器方法、参数、类等地方添加注解，从而实现特定的功能或行为。Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。通过自定义注解，可以提高代码的可读性和可维护性，同时也可以减少重复的代码编写。在Spring MVC中，自定义注解可以应用于控制器方法的映射、参数校验、数据绑定、AOP切面等方面，从而实现特定的功能。
SpringMVC之自定义注解
weixin_74268571的博客
09-16 448
自定义注解的介绍，它的好处及应用场景等，如何去定义并使用自定义注解，也详细讲解了三种使用案例，最后是Aop自定义注解的应用
Spring MVC的常用注解（设置响应篇）
q322359的博客
10-30 683
Spring MVC的常用注解（设置响应篇）
SpringMVC----自定义注解
m0_74934282的博客
09-15 802
SpringMVC自定义注解是指开发者根据自己的需求，在SpringMVC框架中自定义的注解。通过自定义注解，可以实现对请求参数、方法、类等进行自定义的标记和处理。开发者可以通过自定义注解来简化代码，提高代码的可读性和可维护性。例如，可以自定义一个注解来标记某个方法需要进行权限验证，然后在拦截器中根据该注解进行相应的处理；或者可以自定义一个注解来标记某个方法需要进行日志记录，然后在切面中根据该注解进行相应的处理。
SpringMVC注解开发的详解.doc
01-21
SpringMVC注解开发是Java Web开发中一种高效的方式，它极大地简化了控制器的定义和请求处理。在SpringMVC框架中，`@Controller`注解用于标识一个类作为处理HTTP请求的控制器。这个注解使得类中的方法可以被SpringMVC...
springmvc常用注解标签详解
08-13
SpringMVC 中常用的注解标签详解 在 SpringMVC 框架中，注解标签扮演着非常重要的角色，它们使得...在 SpringMVC 中，理解和正确使用这些注解标签非常重要，它们可以使得开发者更方便地开发和维护 Web 应用程序。
Spring注解驱动开发实战-springMVC
02-16
本文将深入探讨在Spring MVC中如何利用注解进行实战开发，包括ServletContext注册三大组件、自定义与接管Spring MVC、以及异步请求的处理方式。 首先，让我们了解一下ServletContext注册三大组件。在Spring MVC中，...
Java内存模型
weixin_44267758的博客
07-19 563
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 482
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 987
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 169
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1038
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 534
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 794
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 457
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 272
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
SpringMVC高级教程：注解开发与DispatcherServlet详解
"SpringMVC是Java企业级开发中的一个重要框架，用于处理HTTP请求和响应，本文档记录了第二天课堂的高级知识点。首先，我们回顾了SpringMVC的基本结构： 1. **DispatcherServlet**：作为前端控制器，它负责接收...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值