学习笔记（狂神SpringMVC P1-P16）

最新推荐文章于 2024-07-29 14:22:26 发布

广而不精zhu小白

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量508

点赞数

分类专栏： Spring 文章标签： java maven idea

本文链接：https://blog.csdn.net/qq_43003203/article/details/121346129

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Spring学习地址

1、什么是MVC

同步学习笔记源码

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
最典型的MVC就是JSP + servlet + javabean的模式。
职责分析：

Controller：控制器

取得表单数据
调用业务逻辑
转向指定的页面

Model：模型

业务逻辑
保存数据的状态

View：视图

显示页面

MVC框架要做哪些事情

将url映射到java类或java类的方法 .
封装用户提交的数据
处理请求–调用相关的业务处理–封装响应数据
将响应的数据进行渲染
jsp / html 等表示层数据

说明：

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend
Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM
等等…

2、什么是Spring MVC

Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。
官网
 狂神详解

3、第一个MVC程序

（注意）idea2021版使用maven创建webapp项目才能使用

- 配置版
1、新建一个模块
2、添加Web框架支持
3、确定导入了maven相关依赖
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">
    <absolute-ordering/>

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <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>


    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>

5、编写Spring配置文件springmvc-servlet.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--    处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--    处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--Handler-->
    <bean id="/hello" class="Controller.HelloController"/>
</beans>

6、编写HelloController类

package Controller;

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

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

public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg", "HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

7、编写要跳转的jsp页面

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

- 注解版(重点)

1、新建一个模块
2、添加Web框架支持
3、确定导入了maven相关依赖
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">
 
 
   <!--1.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!-- 启动顺序，数字越小，启动越早 -->
       <load-on-startup>1</load-on-startup>
   </servlet>
    <!--所有请求都会被springmvc拦截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
 </web-app>

5、编写Spring配置文件springmvc-servlet.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
       http://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.kuang.controller"/>
   <!-- 让Spring MVC不处理静态资源 -->
   <mvc:default-servlet-handler />
   <!--
   支持mvc注解驱动
       在spring中一般采用@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效
       必须向上下文中注册DefaultAnnotationHandlerMapping
       和一个AnnotationMethodHandlerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
   <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>

6、编写HelloController类

package controller;
 
 
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
 
 
@Controller
@RequestMapping("/HelloController")
public class HelloController {
  
   //真实访问地址 : 项目名/HelloController/hello
   @RequestMapping("/hello")
   public String sayHello(Model model){
       //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
       model.addAttribute("msg","hello,SpringMVC");
       //web-inf/jsp/hello.jsp
       return "hello";
  }
}

7、编写要跳转的jsp页面

4、RestFul 风格

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

学习步骤：

新建RestFulController类

@Controller
public class RestFulController {
    //映射访问路径
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable int p2, Model model){
        int result = p1+p2;
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "结果："+result);
        //返回视图位置
        return "hello";
    }
}

@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

同上配置Spring的xml和web.xml
然后测试http://localhost:8080/commit/1/1得出两个数为int算出传的参数结果

再更改为String后

//映射访问路径
@RequestMapping("/commit/{p1}/{p2}")
public String index(@PathVariable int p1, @PathVariable String p2, Model model){
 
    String result = p1+p2;
    //Spring MVC会自动实例化一个Model对象用于向视图中传值
    model.addAttribute("msg", "结果："+result);
    //返回视图位置
    return "hello";
}

测试http://localhost:8080/commit/1/asdasdsa为连接字符串

使用method属性指定请求类型

//映射访问路径,必须是Get请求
@RequestMapping(value = "/hello",method = {RequestMethod.GET})
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "hello";
}

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

例如：

@Controller
public class RestFulController {
    //映射访问路径,必须是Get请求
    @RequestMapping(value = "/hello", method = {RequestMethod.GET})
    public String index2(Model model) {
        model.addAttribute("msg", "hello!");
        return "hello";
    }

    //映射访问路径,必须是Post请求
    @PostMapping("/hello")
    public String index1(Model model) {
        model.addAttribute("msg", "hello!");
        return "hello";
    }
}

5、重定向和转发

无需视图解析器；

@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        return "/index.jsp";
    }
 
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二
        return "forward:/index.jsp";
    }
 
    @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/index.jsp";
    }
}

有视图解析器；

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发
        return "test";
    }
 
    @RequestMapping("/rsm2/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do为另一个请求/
    }
 
}

6、数据处理

package controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import pojo.User;

@Controller
public class TestController {

    //提交的域名称和处理方法的参数名一致
    
    //http://localhost:8080/hello1?name=kuangshen
    @RequestMapping("/hello1")
    public String Test1(String name) {
        System.out.println(name);
        return "hello";
    }

    //提交的域名称和处理方法的参数名不一致
    
    //@RequestParam("username") : username提交的域的名称 .
    //http://localhost:8080/hello2?username=kuangshen
    @RequestMapping("/hello2")
    public String Test2(@RequestParam("username") String name) {
        System.out.println(name);
        return "hello";
    }

    //提交的是一个对象
    
    //http://localhost:8080/user?name=kuangshen&id=1&age=15
    @RequestMapping("/user")
    public String Test3(User user) {
        System.out.println(user);
        return "hello";
    }

		//数据显示到前端ModelMap
    // http://localhost:8080/hello3?username=kuangshen
    @RequestMapping("/hello3")
    public String Test4(@RequestParam("username") String name, ModelMap model) {
        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        model.addAttribute("name", name);
        System.out.println(name);
        return "hello";
    }
}

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

7、乱码问题

1、我们可以在首页编写一个提交的表单

<form action="/e/t" method="post">
  <input type="text" name="name">
  <input type="submit">
</form>

2、对应的处理类

@Controller
public class Encoding {
    @RequestMapping("/e/t")
    public String test(Model model,String name){
        model.addAttribute("msg",name); //获取表单提交的值
        return "test"; //跳转到test页面显示输入的值
    }
}

3、SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置

<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>
    <url-pattern>/*</url-pattern>
</filter-mapping>

这个过滤器对get的支持不好 .

如果还不行的话用以下两种方法
1、修改tomcat配置文件：设置编码！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

2、自定义过滤器

package com.kuang.filter;
 
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
 
/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
 
    @Override
    public void destroy() {
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
 
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
}
 
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
 
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }
 
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
 
    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
 
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

然后在web.xml中配置这个过滤器即可！

8、JSON

前端展示两者数据，学会js和json互相转换

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>json</title>
    <script type="text/javascript">
        //user是一个js对象
        var user = {
            name: "张三",
            age: 18,
            sex: "男"
        };
        //后端传的json其实是一个字符串，前端将后端传的json转换成js对象渲染在页面上
        //jsonUser:模拟后端传的json数据
        //js转换成json
        var jsonUser = JSON.stringify(user);
        console.log(jsonUser);
        //jsUser：js是一个对象
        //json转换成js
        var jsUser = JSON.parse(jsonUser);
        console.log(jsUser)
    </script>
</head>
<body>
</body>
</html>

使用 Jackson Databind可以快速生成json数据

导入依赖

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

springmvc.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="controller"/>
    <!--让SpringMvc不处理静态资源。让.css,.js等不进视图解析器-->
    <mvc:default-servlet-handler/>

    <!--注解加载映射器、适配器，解决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>

    <!--配置视图解析器，明确json数据不走数据解析器，直接传给前端-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

配置web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>



  <!--1.注册servlet-->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!-- 启动顺序，数字越小，启动越早 -->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <!--所有请求都会被springmvc拦截 -->
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

编写Controller

package controller;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import org.junit.jupiter.api.Test;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import pojo.User;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@RestController
public class UserController {
    /*  概念：前后端分离的项目，后端代码不走视图解析器，后端传给前端的是json数据
        方法上：注解@ResponseBody指定该方法不走视图解析器，会直接返回一个String=json数据就是一个字符串
        类上：注解@RestController指定该类下的所有方法都不走视图解析器
        Json返回一个对象
     */
    @RequestMapping("/t1")
    public String json1() throws JsonProcessingException {
        User user = new User(1, "张三", 20);
        ObjectMapper jacksonMapper = new ObjectMapper();
        String s = jacksonMapper.writeValueAsString(user);
        //user.toString()是自己指定的String但是公司通常是允许的，通常是使用第三方工具来返回String
        //str_user有中文乱码问题，springMvc可以统一配置
        return s;
    }

    /**
     * Json返回一个List
     */
    @RequestMapping("/t2")
    public String json2() throws JsonProcessingException {
        User user1 = new User(1, "张三", 20);
        User user2 = new User(2, "张三", 21);
        User user3 = new User(3, "张三", 22);
        User user4 = new User(4, "张三", 23);
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        return new ObjectMapper().writeValueAsString(list);
    }

    /**
     * json返回一个日期格式
     */
    @RequestMapping("/t3")
    public String json3() throws JsonProcessingException {
        //方式一：原始纯java日期转换：推荐使用
        // String date = new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss").format(new Date());
        ObjectMapper objectMapper = new ObjectMapper();
        //方式二：使用mapper来制定日期格式，先关闭时间戳表示
        objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd:HH:mm:ss"));
        Date date = new Date();
        return objectMapper.writeValueAsString(date);
    }

    @Test
    public void DateTest1() {
        //传统的java日期格式转换
        String date = new SimpleDateFormat("yyyy-MM-dd:HH:mm:ss").format(new Date());
        System.out.println(date);
    }


    @RequestMapping("/t4")
    public String json4() throws JsonProcessingException {
        User user1 = new User(1, "张三", 20);
        User user2 = new User(2, "张三", 21);
        User user3 = new User(3, "张三", 22);
        User user4 = new User(4, "张三", 23);
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        String jsonString = JSON.toJSONString(list);
        return jsonString;
    }

}

阿里巴巴官方提供的，实现Json数据的另一个工具，比JackSon Databind更方便

导包

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

Controller

package controller;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import org.springframework.web.bind.annotation.RequestMapping;
import pojo.User;

import java.util.ArrayList;
import java.util.List;

public class UserController1 {
    @RequestMapping("/t5")
    public String json4() throws JsonProcessingException {
        User user1 = new User(1, "张三", 20);
        User user2 = new User(2, "张三", 21);
        User user3 = new User(3, "张三", 22);
        User user4 = new User(4, "张三", 23);
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        String jsonString = JSON.toJSONString(list);
        return jsonString;
    }
}

广而不精zhu小白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记（狂神SpringMVC P1-P16）

1、什么是MVCMVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。最典型的MVC就是JSP + servlet + javabean的模式。职责分析：Controller：控制器取得表单数据调用业务逻辑转向指定的页面Model：模型业务逻辑保存数据的状态View：视图显示页面MVC框架要做哪些事情将url映射到java类或java类的方法 .封装用户提交的数据处理请求–调用相关的业务处理–封装响应数据将
复制链接

扫一扫

专栏目录