SpringMVC笔记

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量82 收藏 1
点赞数 2
分类专栏： Java后端 文章标签： mvc java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43279324/article/details/121230798
版权

目录

1. 第一个SpringMVC程序（原理部分）(不常用)

项目目录如下：
在这里插入图片描述

1.1 添加依赖

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

1.2 在resources中新建springmvc-servlet.xml文件

前三个bean是固定的.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--前三个bean是固定的-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    
    <!--注册bean-->
    <bean id="/hello" class="com.hui.controller.HelloController"/>
</beans>

1.3 配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
         version="4.0">
	<!--配置DispatcherServlet:这是SpringMVC的核心;请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--设置启动级别为1 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

1.4 编写HelloController文件代码

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 注意Controller是mvc包下的
public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        // 封装对象，放在ModelAndView中。
        mv.addObject("msg","HelloSpringMVC!");
        mv.setViewName("hello");
        return mv;
    }
}

1.5 编写hello.jsp文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<h1>${msg}</h1>
</body>
</html>

1.6 可能遇到的问题，访问出现404，排除步骤。

1.查看控制台输出，看一下是不是缺少了什么jar包。
2.如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖!
3.重启Tomcat即可解决!
其中第2步中添加依赖的方法如下：
在这里插入图片描述

2. 第一个SpringMVC程序（注解版）（常用）

2.1 创建maven项目，添加web模块

在这里插入图片描述
在这里插入图片描述
添加成功：
在这里插入图片描述

2.2 加入依赖，指定资源位置

加入依赖部分 如1.1部分所示。
指定资源位置：

<build> 
	<resources> 
      <resource> 
        <directory>src/main/java</directory><!--所在的目录--> 
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到--> 
          <include>**/*.properties</include> 
          <include>**/*.xml</include> 
        </includes> 
        <!--filtering选项 false不启用过滤器， *.property已经起到过滤的作用了 --> 
        <filtering>false</filtering> 
      </resource> 
    </resources> 
</build>

2.3 项目结构中添加lib目录，并添加依赖

见1.6内容所示。

2.4 配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<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_4_0.xsd"
         version="4.0">
	<!--配置DispatcherServlet:这是SpringMVC的核心;请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--指定spring配置文件位置;如果是整合ssm项目，这里要更换成总的spring配置文件：applicationContext.xml -->
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <!--设置启动级别为1 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

2.5 配置spring-mvc.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效，有IOC容器统一管理 -->
    <context:component-scan base-package="com.hui.controller"/>
    <!-- 让SpringMVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <mvc:annotation-driven/>
    
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

2.6 在WEB-INF/jsp目录下创建hello.jsp

2.7 编写HelloController代码

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

// 被@Controller注解的类中的所有方法，如果返回值是String，并且有具体的页面可以跳转，那么就会被试图解析器解析。
@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/h1")
    public String hello(Model model){
        //　封装数据
        model.addAttribute("msg","Hello, SpringMVCAnnotation");
        // 返回的结果就是视图的名字，会被视图解析器处理
        // 如果返回的想让它是一个字符串，则使用@RestController注解
        return "hello";
    }
}

3. 相关注解解释

3.1 @Controller

被@Controller注解的类中的所有方法，如果返回值是String，并且有具体的页面可以跳转，那么就会被试图解析器解析。

// 被@Controller注解的类中的所有方法，如果返回值是String，并且有具体的页面可以跳转，那么就会被试图解析器解析。
@Controller
public class HelloController {
    @RequestMapping("/h1")
    public String hello(Model model){
        model.addAttribute("msg","Hello, SpringMVCAnnotation");
        // 返回的结果就是视图的名字，会被视图解析器处理
        // 如果返回的想让它是一个字符串，则使用@RestController注解
        return "hello";
    }
}

3.2 @RequestMapping("")

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@Controller
@RequestMapping("/hello")
public class HelloController {
    @RequestMapping("/h1")
    public String hello(Model model){
        model.addAttribute("msg","Hello, SpringMVCAnnotation");
        return "hello";
    }
}

4. RESTFul风格

1.传统方式

// http://localhost:8080/add?a=1&b=2
@RequestMapping("/add")
public String test1(int a, int b, Model model){
    int res = a+b;
    model.addAttribute("msg","最后的执行结果为：" +a + "+" + b +"="+res);
    return "test";
}

2.RESTFul风格

// http://localhost:8080/add/2/5
 @RequestMapping("/add/{a}/{b}")
 public String test2(@PathVariable int a,@PathVariable int b, Model model){
     int res = a+b;
     model.addAttribute("msg","最后的执行结果为：" +a + "+" + b +"="+res);
     return "test";
 }

5. 转发和重定向

@Controller
public class ModelTest1 {
	@RequestMapping("/m1/t2")
    public String test2(Model model){
        model.addAttribute("msg","转发");
        // 方式一：默认就是转发，经过视图过滤器
        return "test";
        // 方式二：转发，不经过视图过滤器
		//return "forward:/index.jsp";
    }
    @RequestMapping("/m1/t3")
    public String test3(Model model){
        model.addAttribute("msg","重定向");
        // 重定向 不经过视图过滤器
        return "redirect:/index.jsp";
    }
}

6. 接收请求参数及数据回显

6.1 接收请求参数(基本类型)

@RequestParam("")注解的意思是：
指定url参数的名字，可以与方法参数不一致；
如果不写的时候，则url参数名必须与方法参数名一致。

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
        //接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
        model.addAttribute("msg",name);
        return "test";
    }
}

6.2 接收请求参数(对象)

假设传递的是一个对象User，匹配User对象中的字段名;如果名字一致则OK，否则，匹配不到。

@Controller
@RequestMapping("/user")
public class UserController {
 	// http://localhost:8080/user/t2?id=1&name=zhangsan&age=3
    //假设传递的是一个对象User，匹配User对象中的字段名;如果名字一致则OK，否则，匹配不到
    // 前端接收一个对象 id,name,age
    @GetMapping("/t2")
    public String test2(User user, Model model){
        // 1.接收前端参数
        int myid = user.getId();
        String myname = user.getName();
        int myage = user.getAge();
        // 2.结果传给前端
        model.addAttribute("msg",""+myid+myname+myage);
        return "test";
    }
}

6.3 数据回显

6.3.1 Model

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t")
    public String test(String name, Model model){
       
        // 2.结果传给前端
        model.addAttribute("msg",""+name);
        return "test";
    }
}

6.3.2 ModelMap(集成LinkedMap)

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t")
    public String test(String name, ModelMap model){
       
        // 2.结果传给前端
        model.addAttribute("msg",""+name);
        return "test";
    }
}

7. 乱码问题

7.1 页面乱码问题

在web.xml文件中添加过滤器

<!--配置springmvc的乱码过滤-->
<filter>
    <filter-name>encoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <!--这里如果写/是光扫描servlet文件，/*的意思是扫描包括.jsp在内的所有文件-->
    <url-pattern>/*</url-pattern>
</filter-mapping>

还不对的话，再去tomcat的server.xml文件看看编码对吗？

7.2 java转json乱码问题

7.2.1 对于使用Jackson的方式：

在resources资源目录下的springmvc-servlet.xml文件中加上

<!--解决JSON乱码问题-->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

8. JSON(重点)

8.1 JSON简介

JSON其实就是一个字符串。
js对象与json相互转换。

<script type="text/javascript">
      var user = {
          name :"辉哥",
          age:3,
          sex:"男"
      };
      console.log(user);

      // js 转到 json对象
      var json = JSON.stringify(user);
      console.log(json);
      
      // json对象 转换到js对象
      var obj = JSON.parse(json);
      console.log(obj);
  </script>

三次的输出结果：（第二次的json对象就相当于一个字符串，不能展开）
在这里插入图片描述

8.2 java生成json对象

8.2.1 Jackson方式(应该是目前较好的json解析工具了)

1.加入依赖

 <dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.13.0</version>
</dependency>

2.代码中使用ObjectMapper对象的writeValueAsString() 方法，代码如下：

    @RequestMapping("t2")
    @ResponseBody // 不去找视图解析器了，直接返回字符串
    private  String json2() throws JsonProcessingException {
        User user1 = new User(1,"辉哥1", 21);
        User user2 = new User(2,"辉哥2", 21);
        User user3 = new User(3,"辉哥3", 21);
        User user4 = new User(4,"辉哥4", 21);
        List<User> ls = new ArrayList<User>();
        ls.add(user1);
        ls.add(user2);
        ls.add(user3);
        ls.add(user4);

        // 在Jackson中有类ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        String str = mapper.writeValueAsString(ls);

        return str;
    }

3.结果如图：
在这里插入图片描述
4.可以专门写成一个工具类，方便以后使用。

public class JsonUtils {
    public static String getJson(Object object) {
        ObjectMapper mapper = new ObjectMapper();
        try{
            return mapper.writeValueAsString(object);
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

5.乱码问题，见第7.2部分。

8.2.2 Fastjson（阿里巴巴的）

1.加入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

2.编写代码
JSON.toJSONString(Object obj) ：Java对象—>json字符串
JSON.parseObject() ：json字符串—>Java对象

@RequestMapping("t3")
@ResponseBody // 不去找视图解析器了，直接返回字符串
private  String json3() {
    User user1 = new User(1,"辉哥1", 21);
    User user2 = new User(2,"辉哥2", 21);
    User user3 = new User(3,"辉哥3", 21);
    User user4 = new User(4,"辉哥4", 21);
    List<User> ls = new ArrayList<User>();
    ls.add(user1);
    ls.add(user2);
    ls.add(user3);
    ls.add(user4);

	// 关键代码在这里
    String str = JSON.toJSONString(ls);
    User jsonObject = JSON.parseObject(str,User.class);
    return str;
}

9. ajax

9.1 前端界面

  • 先引入jQuery，使用$.post({})的方式进行ajax请求（或者$.ajax等方式）
  • url就直接写自己写的后端程序的。
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!-- 使用ajax先引入jquery -->
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script>
    <script>
        $(function () {
            $("#btn").click(function () {
                $.post({
                    // 直接请求自己写的程序
                    url:"/ajax2",
                    success:function (data) {
                        var html = "";
                        for (var i=0;i< data.length;i++){
                            html+="<tr>" +
                                "<td>" + data[i].name + "</td>"+
                                "<td>" + data[i].age + "</td>"+
                                "<td>" + data[i].sex + "</td>"+
                                "</tr>"
                        }
                        $("#content").html(html)
                    }
                });
            })
        })
    </script>
</head>
<body>
    <input type="button" value="加载数据" id="btn">
    <table>
        <tr>
            <td>姓名</td>
            <td>年龄</td>
            <td>性别</td>
        </tr>
        <tbody id="content">
        </tbody>
    </table>
</body>
</html>

9.2 java代码

    @RequestMapping("/ajax2")
    @ResponseBody
    public List<User> test2(){
        List<User> userList = new ArrayList<User>();
        userList.add(new User("辉哥", 21,"男"));
        userList.add(new User("辉哥哥", 22,"男"));
        return userList;
    }
}

10. 拦截器

10.1 拦截器与过滤器

  • 过滤器
    – servlet规范中的一部分，任何java web工程都可以使用。
    – 在url-pattern中配置 /* 之后，可以对所有要访问的资源进行拦截。
  • 拦截器
    – 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用。
    – 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的。
    – 拦截器是AOP思想的具体应用

10.2 简单使用

  • 1.实现HandlerInterceptor接口(可以新建一个config包,把拦截器写里面)
public class MyInterceptor implements HandlerInterceptor {
    // return true; 执行下一个拦截器，放行
    // return false; 不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("============处理前=======");
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("============处理后=======");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("============清理=======");
    }
}
  • 2.在spring配置文件中配置：(applicationContext.xml)
    如下拦截所有请求了（可以配置多个）。
<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--包括这个请求一下的所有请求-->
        <mvc:mapping path="/**"/>
        <bean class="com.hui.config.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

10.3 未登录时拦截并跳转到登录界面实战例子

1.编写拦截器

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        // 放行：判断什么情况下登录
        // 如果是登录界面就放行
        if(request.getRequestURI().contains("goLogin")){
            return true;
        }
        // 如果是提交就放行
        if(request.getRequestURI().contains("login")){
            return true;
        }
        // 如果session有用户信息就放行
        if(session.getAttribute("userLoginInfo")!=null){
            return true;
        }
        // 没有登录转发到登录界面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return false;
    }
}

2.在spring配置文件中配置：

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--包括这个请求一下的所有请求-->
        <mvc:mapping path="/**"/>
        <bean class="com.hui.config.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

3.Controller层Java代码

@Controller
public class LoginControler {
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String password){
        // 把用户的信息存到session中
        session.setAttribute("userLoginInfo",username);
        return "main";
    }
    @RequestMapping("/logout")
    @ResponseBody
    public String loginout(HttpSession session){
        // 把用户的信息存到session中
        session.removeAttribute("userLoginInfo");
        return "main";
    }

    @RequestMapping("/gomain")
    public String main(){
        return "main";
    }
    @RequestMapping("/gologin")
    public String login(){
        return "login";
    }
}

4.jsp代码略

贴地飞行lyh
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
尚硅谷SpringMVC笔记
04-11
尚硅谷SpringMVC笔记
SpringMVC 笔记
menergy
05-20 779
SpringMVC学习笔记
尚硅谷_SpringMVC笔记
Hello_super的博客
08-07 1608
SpringMVC简介 | HellWorld入门 | @RequestMapping | 获取请求参数 | 域对象共享数据 | 视图 | RESTFul | HttpMessageConverter | 文件上传&下载 | 拦截器 | 注解配置SpringMVC | SpringMVC执行流程（源码分析）
狂神SpringMvc笔记
m0_52162006的博客
09-11 1776
SpringMvc笔记 一、什么是mvc Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。 View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。 Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变）
SpringMvc笔记（尚硅谷2021版）
vogel_im_kafig_的博客
12-10 1458
SpringMVC MVC M：model，指javabean，分为 处理业务数据的实体类和 处理业务逻辑、数据访问的类（dao和service层对象） V：视图，html、jsp页面 C：控制器，以前是servlet，是DispatcherServlet，是一个功能强大的封装servlet，又叫前端控制器 DispatcherServlet 配置servlet： <servlet> <servlet-name>SpringMVC</servlet-name&
springmvc笔记
java_lishaozhang的博客
10-17 202
SpringMVC学习笔记 ) springmvc配置文件 &lt;!-- 前端控制器 --&gt; &lt;servlet&gt; &lt;servlet-name&gt;springmvc&lt;rvlet-name&gt; &lt;servlet-class&gt;org.springframework.web.servlet.DispatcherServlet&lt;rvl...
Springmvc笔记
roods的博客
08-19 226
springmv笔记
springMVC笔记
qq_57697526的博客
07-27 858
满足以上条件，**HiddenHttpMethodFilter** 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数\_method的值才是最终的请求方式,所以我们就可以在表单当中添加，hidden属性，隐藏的，不会再页面当中显示，但是会传参。若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null。
SpringMVC笔记（尚硅谷2022.5）
qq_43368470的博客
11-25 337
自学
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 521
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 769
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 517
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 228
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 808
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 909
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值