狂神-SpringMVC

最新推荐文章于 2024-01-08 19:10:10 发布

仙女本人yo

最新推荐文章于 2024-01-08 19:10:10 发布

阅读量368

点赞数 2

分类专栏： java 文章标签： mvc spring java

本文链接：https://blog.csdn.net/weixin_43988143/article/details/120045273

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文档：https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/web.html
狂神：https://blog.csdn.net/qq_33369905/article/details/106647313?spm=1001.2014.3001.5501
重点：

spring执行流程

ssm整合

MVC:模型(dao service) 视图(jsp) 控制器(Servlet)

1.回忆servlet

项目搭建：

1.新建项目，删除src目录。
2.在pom.xml中导入依赖。

 <!--导入依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

3.新建子工程springmvc-01-servlet(普通maven项目)
右击子工程–>Add FrameWork Support–>勾选web Application–>点击ok(此时项目目录会多出web文件夹)
4.子工程中导入依赖

<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>

5.编写servlet
- ①需要编写个页面test.jsp：在WEB-INF路径下比较安全(用户不可见)，在web路径下用户可以看(公共页面可)
- 在body里写 ${msg}

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class com.kuang.servlet.HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取前端参数
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层
        //3.视图转发or重定向 req转发 resp重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

6.启动tomcat测试
/hello?method=add /hello?method=delete

全栈:后台前端数据库运维
前端：后台前端
MVVM： M V VM ViewModel：双向绑定
maven springmvc 都是约定优于配置

2.HelloMVC

2.1配置版HelloMVC

0.先在WEB-INF下新建jsp文件夹写一个跳转页面test.jsp

<%--
  Created by IntelliJ IDEA.
  User: LXN
  Date: 2021/9/1
  Time: 8:59
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}

</body>
</html>

1.web.xml中配置servlet

<?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>

        <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>


    <!--在springmvc中，/和/*
    / ：只匹配所有请求，不会去匹配.jsp页面
    /*： 匹配所有请求，包括.jsp页面-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

2.在资源文件夹下建立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"/>
    <!--视图解析器 模板引擎TymeLeaf Freemarker-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--BeanNameUrlHandlerMapping会根据bean的名字来找-->
    <bean id="/hello" class="com.kuang.controller.HelloController"/>


</beans>

3.控制器

package com.kuang.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 httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        //业务代码
        String result = "HelloSpringMVC!";
        mv.addObject("msg", result);
        //视图跳转
        mv.setViewName("test");
        return mv;
    }
}

在这里插入图片描述

1.新建Module，添加web支持！
2.导入mvc依赖
3.配置XML，注册DispatcherServlet

问题

在这里插入图片描述

执行流程

在这里插入图片描述

只有虚线部分我们自己做

1.用户发起请求，进入dispatcherservlet，然后找到配置文件，
2.首先找到处理器映射器，映射器根据名字找到/hello了
3.处理器适配器找到HelloController来处理
4.然后Controller处理业务层
5.调完之后返回一个modelview交给视图解析器去做

2.2注解版SpringMVC

第0步，在WEB-INF下建立文件夹jsp，写跳转页面hello.jsp

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

第一步，配置web.xml（同时记得artifact打包时候lib目录记得加进去）

<?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">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

第二步，配置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">

    <!--<添加处理映射器-->
    <!-- <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
     &lt;!&ndash;<添加处理适配器&ndash;&gt;
     <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>-->
    <!--视图解析器:DispatcherServlet给他的ModelAndView
    1，获得了modelandView的数据
    2，解析modelandView的视图的名字
    3，拼接视图的名字，找到对应的试图：/WEB-INF/jsp/hello.jsp
    4，将数据渲染到这个视图上
    -->
    <!--开启扫描注解包-->
    <context:component-scan base-package="com.kuang.controller"/>
    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <!-- 让Spring MVC不处理静态资源 .css  .js .html  -->
    <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>
    <!--开启注解就不用配置这个bean了-->
    <!--<bean id="/hello" class="com.kuang.controller.HelloController"/>-->
</beans>

第三步，控制类

package com.kuang.controller;

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

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","helloSpringMVC innovation");
        return "hello";// 会被视图解析器处理
    }
}

@Controller

@RestController 返回json格式

总结：

springMVC必须配置三大件：处理器映射器、处理器适配器、视图解析器
通常，只需手动配置视图解析器
处理器映射器、处理器适配器只需开启注解驱动即可

@Controller

@Controller//代表这个类会被spring接管
//被注解的类中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析，

@RequestMapping("/hello")

可以写在类上也可以写在方法上。

3.RestFul风格

原来的方式：

新建控制类

@Controller
public class RestFulController {
    @RequestMapping("/add")
    //这里参数的名字就是前端要传的名字
    public String test(int a, int b, Model model){
        int res = a + b;
        model.addAttribute("msg","结果为"+res  );

        return "hello";
    }
}

运行结果：
http://localhost:8080/add?a=1&b=2
在这里插入图片描述

RestFul风格方式：

http://localhost:8080/add/a/b
http://localhost:8080/add/1/2
在这里插入图片描述

@Controller
public class RestFulController {
    @RequestMapping("/add/{a}/{b}")
    public String test(@PathVariable int a, @PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg","结果为"+res  );

        return "hello";
    }

@RequestMapping(name = "/add/{a}/{b}",method = {RequestMethod.GET})
//等于
@GetMapping("/add/{a}/{b}")

RestFul简洁高效安全

4.数据处理

转发与重定向：

 @GetMapping("/add/{a}/{b}")
    public String test(@PathVariable int a, @PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg","结果为"+res);
        //return "hello";默认是转发
        //return "hello";
        return "redirect:/index.jsp";
    }

接收请求参数及数据回显

servlet处理前端的数据以前request.getparameters();

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端的参数为"+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hello";

    }

在这里插入图片描述

2.参数前加注解

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端的参数为"+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hello";
    }
}

访问http://localhost:8080/user/t1?username=qinjiang 页面将显示qinjiang

3.参数是对象
写一个实体类User

package com.kuang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private int age;
}

//1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
    //2.假设传递的是一个对象User，匹配User对象中的字段名；如果名字一致则ok 否则匹配不到
    //前端接受的是一个对象 id name age
    @GetMapping("/t2")
    public String test2(User user){
        System.out.println(user);
        return "hello";
    }

访问http://localhost:8080/user/t2?id=1&name=qinjiang&age=18后台即可输出User(id=1, name=qinjiang, age=18)

在这里插入图片描述

5.乱码问题

写web逃不过乱码问题

方式一：自己写一个过滤器EncodingFilter

package com.kuang.Filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest,servletResponse);

    }

    @Override
    public void destroy() {

    }
}

web.xml中配置：

 <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>com.kuang.Filter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

方式二：SpringMVC自带过滤器

 <!--配置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>
        <url-pattern>/*</url-pattern>

    </filter-mapping>

方式三：修改Tomcat配置文件 server.xml

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

方式四：大神自己写了个过滤器

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() {
        System.out.println("=================================");
        // 先获得请求方式
        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中配置：

<filter>
        <filter-name>GenericEncodingFilter</filter-name>
        <filter-class>com.kuang.Filter.GenericEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>GenericEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

6.Json

前后端分离时代：

后端部署后端，提供接口；

  中间json

前端独立部署，负责渲染后端的数据。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!--script标签不能单闭合-->
    <script type="text/javascript">
        /*编写一个JavaScript对象*/
        var user={
            name:"秦疆",
            age:18,
            sex:"男"
        };
        /*将js对象转换为json对象*/
        var json = JSON.stringify(user);
        console.log(json);
       // console.log(user);
        //将json对象转换为javascript对象
        var obj = JSON.parse(json);
        console.log(obj);

    </script>
</head>
<body>

</body>
</html>

步骤

1.Jackson应该是比较好的解析工具，首先导入依赖

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

2.配置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">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置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>
        <url-pattern>/*</url-pattern>

    </filter-mapping>
</web-app>

3.写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">

    <!--开启扫描注解包-->
    <context:component-scan base-package="com.kuang.controller"/>
    <!--l乱码问题-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <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>



    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

4.写实体类

package com.kuang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

5.controller

package com.kuang.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kuang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {

   // @RequestMapping(value ="/j1" ,produces = "application/json;charset=utf-8")
    @RequestMapping("/j1")
    @ResponseBody//加了此注解就不会走视图解析器，会直接返回字符串
    public String json1() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("秦",3,"男");
        String str = mapper.writeValueAsString(user);
        return str;//{"name":"?","age":3,"sex":"?"}   解决乱码之后{"name":"秦","age":3,"sex":"男"}
        // return user.toString();
    }
}

@ResponseBody//加了此注解就不会走视图解析器，会直接返回字符串（配合@Controller使用）

也可以直接在类上把@Controller换成@RestController 直接不走视图解析器，直接返回字符串

5.1集合

 @RequestMapping("/j2")
    @ResponseBody//加了此注解就不会走视图解析器，会直接返回字符串
    public String json2() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        List<User> userList = new ArrayList<>();
        User user1 = new User("秦1",3,"男");
        User user2 = new User("秦2",3,"男");
        User user3 = new User("秦3",3,"男");
        User user4 = new User("秦4",3,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        String str = mapper.writeValueAsString(userList);
        return str;
        /*结果
        [{"name":"秦1","age":3,"sex":"男"},
         {"name":"秦2","age":3,"sex":"男"},
         {"name":"秦3","age":3,"sex":"男"},
         {"name":"秦4","age":3,"sex":"男"}]
         []代表集合*/
    }

5.2时间

@RequestMapping("/j3")
    @ResponseBody//加了此注解就不会走视图解析器，会直接返回字符串
    public String json3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        //使用ObjectMapper来格式化输出 不用使用时间戳方式
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
       // Date date = new Date();
        //自定义日期格式
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //ObjectMapper时间解析后默认是Timestamp时间戳
        mapper.setDateFormat(sdf);
        Date date = new Date();
        //return mapper.writeValueAsString( sdf.format(date));
        return mapper.writeValueAsString(date);
    }

发现好多重复代码提取成公共工具类

package com.kuang.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

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

public class JsonUtils {
    public  static String getJson(Object object){
        return getJson(object,"yy-MM-dd HH:mm:ss");
    }//复用

    public  static String getJson(Object object,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;


    }
}

再看UserController就简单了

package com.kuang.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.kuang.pojo.User;
import com.kuang.utils.JsonUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

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

@Controller

public class UserController {
    
    @RequestMapping("/j1")
    @ResponseBody
    public String json1() throws JsonProcessingException {
        User user = new User("秦",3,"男");
        return JsonUtils.getJson(user);
    }
    
    @RequestMapping("/j2")
    @ResponseBody
    public String json2() throws JsonProcessingException {

        List<User> userList = new ArrayList<>();
        User user1 = new User("秦1",3,"男");
        User user2 = new User("秦2",3,"男");
        User user3 = new User("秦3",3,"男");
        User user4 = new User("秦4",3,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        return JsonUtils.getJson(userList);

    }
    
    @RequestMapping("/j3")
    @ResponseBody
    public String json3() throws JsonProcessingException {

        Date date = new Date();

        return JsonUtils.getJson(date);
    }
}

7.FastJson

第一步：导入依赖

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

@RequestMapping("/j4")
    @ResponseBody
    public String json4(){
        List<User> userList = new ArrayList<>();
        User user1 = new User("秦1",3,"男");
        User user2 = new User("秦2",3,"男");
        User user3 = new User("秦3",3,"男");
        User user4 = new User("秦4",3,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        String str = JSON.toJSONString(userList);
        return str;
    }

在这里插入图片描述

Tomcat 小tips

如果改了java代码，就要redeploy一下，
如果改了配置文件，就重启tomcat，
如果只改了前端页面，刷新一下。
405 请求方式不支持get post …

-在springmvc中，/和/*
/ ：只匹配所有请求，不会去匹配.jsp页面
/*：匹配所有请求，包括.jsp页面–>

仙女本人yo

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
狂神-SpringMVC

文档：https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/web.html狂神：https://blog.csdn.net/qq_33369905/article/details/106647313?spm=1001.2014.3001.5501重点：spring执行流程ssm整合MVC:模型(dao service) 视图(jsp) 控制器(Servlet)1.回忆servl
复制链接

扫一扫