SpringMVC框架的使用

最新推荐文章于 2023-08-03 08:00:00 发布

I'm sure ok!

最新推荐文章于 2023-08-03 08:00:00 发布

阅读量1.1k

点赞数 2

分类专栏： SpringMVC

本文链接：https://blog.csdn.net/lirui1212/article/details/106664194

版权

SpringMVC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。
在这里插入图片描述

1.1回顾Servlet

第一步：导入依赖

  <dependencies>
        <!-- 依赖 -->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
        
    </dependencies>

第二步：获得Web app 的支持
第三步：编写一个Servlet类，用来处理用户的请求

public class 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.视图转发或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req,resp);
    }
}

第四步：web.xml 中注册Servlet

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.li.servlet.HelloServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

第五步：WEB-INF目录下创建jsp文件夹，新建一个test.jsp

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

第六步：测试
配置Tomcat
访问：http://localhost:8080/hello?method=add
http://localhost:8080/hello?method=delete

1.2分析:

用户发请求
1.Servlet接收请求数据，并调用对应的业务逻辑方法
2.业务处理完毕，返回更新后的数据给servlet
3.servlet转向到JSP，由JSP来渲染页面
4.响应给前端更新后的页面

2.什么是SpringMVC

2.1SpringMVC的优点

Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

Springmvc的优点:

（1）可以支持各种视图技术,而不仅仅局限于JSP；

（2）与Spring框架集成（如IoC容器、AOP等）；

（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。

（4）支持各种请求资源的映射策略。

2.2 第一个SpringMVC程序

第一步:配置web.xml文件


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

第二步：编写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
        https://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>


<bean id="/hello" class="com.li.controller.HelloController"/>
</beans>

第三步：编写HelloController类

public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");// /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

第四步：WEB-INF目录下创建jsp文件夹，新建一个hello.jsp

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

第五步：部署Tomcat及相关环境
进入Run下的文件
在这里插入图片描述
配置Tomcat 修改名字、确认本地服务

问题：
一：出现的问题： Tomcat 服务器无法正常启动
原因： Tomcat 服务器找不到相关的 jar 包
解决方法：将【lib】文件夹整个剪贴到【WEB-INF】下，并重新建立依赖：
在这里插入图片描述
二：maven资源过滤问题：
导入依赖

 <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

第六步：启动服务器
访问地址:http://localhost:8080/hello
在这里插入图片描述

2.3中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

在这里插入图片描述
前端控制器（DispatcherServlet）：

客户在页面输入
通过HTTP协议利用request将数据(请求))带入前端控制器
前端控制器依据请求指定对应的控制器 controller
控制器依据业务实际进行处理后调用业务逻辑产生数据,返回给前端控制器
此时前端控制器再将这些业务数据分发给业务视图
由业务视图将数据产生在业务页面中
业务页面再将生成的页面返回到前端控制器,
前端控制器再将业务页面反馈给用户界面

2.4SpringMVC执行原理

在这里插入图片描述
简要分析执行流程

1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
如上url拆分成三部分：
http://localhost:8080服务器域名
SpringMVC部署在服务器上的web站点
hello表示控制器
通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
2.HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
3.HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
4.HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
5.HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
6.Handler让具体的Controller执行。
7.Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
8.HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
9.DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
10.视图解析器将解析的逻辑视图名传给DispatcherServlet。
11.DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
12.最终视图呈现给用户。

3.注解开发SpringMVC

前端控制器依据请求指定对应的控制器 controller 之前我们的做法是定义一个类去继承Controller类，这样一个类中只能写一个方法如果我们有很多的业务逻辑，会有controller1、controller2、3等很显然很繁琐，所以有了用注解开发。
注解的好处：
在Spring MVC中一个控制器类可以包含多个方法
在Spring MVC中，对于Controller的配置方式有很多种

第一步：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>

</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
       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">
    <!-- 扫描指定包 注解生效-->
    <context:component-scan base-package="com.li.controller"/>
    <!-- springMVC处理静态资源-->
    <mvc:default-servlet-handler/>
     <!-- 处理器映射器和处理器适配器都让注解处理了-->
    <mvc:annotation-driven/>

    <!-- 视图解析器：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>
</beans

第三步：注册HelloController类，使用@Controller
@Controller 相当于 <bean name="/hello" class="com.li.controller.HelloController"/>
@RequestMapping("/hello")映射请求

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello，springMVC！");
        return "hello";//交给视图解析器
    }
}

第四步：编写hello.jsp

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

4.@RequestMapping及RestFul风格

4.1使用@RequestMapping映射请求

@RequestMapping映射请求替代了原来 <bean name="/test" class="com.li.controller.ControllerDemo"></bean> 使用注解可以映射到这个类上或者方法中

@RequestMapping("Demo2")
@Controller
public class ControllerDemo2 {
    @RequestMapping("/t1")
    @RequestMapping(value = "/t2",method = RequestMethod.GET)
    public String test(Model model){
        //封装数据
        model.addAttribute("msg","hello,ControllerDemo2");
        return "test";
    }
}

浏览器默认的提交方式是GET!

4.1.1模拟post提交方式:

编写from.jsp文件：

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%-- 表单两种提交方式:post、method--%>
<form action="/t3" method="post">
    <input type="submit">
</form>
</body>
</html>

编写ControllerDemo2类

value与action请求的地址保持一致
@RequestMapping源码中参数name的别名分别是@AliasFor(“value”)、@AliasFor(“path”)
提交的方式是post

@Controller
public class ControllerDemo2 {
    @RequestMapping(value = "/t3",method = RequestMethod.POST)
    public String test3(Model model){
        model.addAttribute("msg","我使用的是post提交方式");
        return "test";
    }
}

在这里插入图片描述

4.1.2@RequestMapping注解变体

GET、 PUT，POST等等，因为 @RequestMapping默认情况下会映射所有HTTP方法。使用@RequestMapping(method=GET)或 @GetMapping缩小映射。

@GetMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.GET)
@PostMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.POST)
@PutMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.PUT)
@DeleteMapping替代@RequestMapping(value ="/t2",method=RequestMethod.DELETE)
@PatchMapping 替代@RequestMapping(value = “/t2”,method = RequestMethod.PATCH)

4.2RestFul风格

场景：完成两个数相加并且返回给前端页面

 @GetMapping("/t4")
    public String test4(int a,String b,Model model) {
        String result = a + b;
        model.addAttribute("msg","结果为："+result);
        return "test";
    }

在这里插入图片描述
浏览器上面的请求地址 http://localhost:8080/t4?a=2&b=3是我们之前用的方式。

缺点是不安全,为了安全起见一般都要使用@PathVariable

@GetMapping("/t4/{a}/{b}")
    public String test4(@PathVariable int a,@PathVariable String b,Model model) {
        String result = a + b;
        model.addAttribute("msg","结果为："+result);
        return "test";
    }

在这里插入图片描述

5.重定向和转发

通过SpringMVC来实现转发和重定向 - 无需视图解析器；

@Controller
public class RedirectTest {
    @GetMapping("/for")
    public String test(Model model){
        model.addAttribute("msg","RedirectTest");
        //重定向
        return "Redirect:/index.jsp";
    }
}

在这里插入图片描述

@Controller
public class ForwardTest {
    @GetMapping("/for")
    public String test(Model model){
        model.addAttribute("msg","RedirectTest");
        //转发
        return "forward:/index.jsp";
    }
}

在这里插入图片描述

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

6.1提交的域名称和处理方法的参数名一致

@Controller
@RequestMapping("/user")
public class UserController {
    // http://localhost:8080/user/u2?name=lirui
    @GetMapping("/u2")
    public String userName(String name,Model model){
        //接收前端的参数
        System.out.println("接收前端的参数"+name);
        //接收的参数返回给前端  Model
        model.addAttribute("msg","前端参数为"+name);
        return "test";
    }
}

浏览器页面：
在这里插入图片描述
控制台：

接收前端的参数李瑞

6.2提交的域名称和处理方法的参数名不一致

 /**
     * 如果前端没有按照name=xxx传参
     * 那么后台接收的前端参数为null
     * 解决：1.使用@RequestParam("username")
     */
    @GetMapping("/u3")
    public String userName2(@RequestParam("username") String name, Model model) {
        //接收前端的参数
        System.out.println("接收前端的参数" + name);
        //接收的参数返回给前端  Model
        model.addAttribute("msg", "前端参数为" + name);
        return "test";
    }

6.3提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

实体类：

public class User {
    private int id;
    private String name;
    private int age;
    public User(){

    }

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

处理方法：

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/u1")
    public String userMessage(User user, Model model){
        //接收前端的参数
       System.out.println(user);
       //接收的参数返回给前端 Model
       model.addAttribute("msg",user);
        return "test";
    }
}

6.4参数乱码问题

1.编写一个form表单

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/test" method="post">
    <input type="text" name="name"> <br>
    <input type="submit">
</form>
</body>
</html>

2.后台编写对应的处理类

@Controller
public class EncodingController {
    @RequestMapping("/test")
    public String test(String name, Model model){
        model.addAttribute("msg",name);
        return "test";
    }
}

一般情况提交form表单，post方式会出现乱码
在这里插入图片描述
如果form表单的提交方式为get

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/test" method="get">
    <input type="text" name="name"> <br>
    <input type="submit">
</form>
</body>
</html>

在这里插入图片描述

以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置修改了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>

在这里插入图片描述

7.Json交互处理

7.1什么是JSON?

JSON 是一种数据格式。它本身是一串字符串，只是它有固定格式的字符串，符合这个数据格式要求的字符串，我们称之为JSON。
JSON 常用来数据传输，因为它易于程序之前读写操作。
JSON 它其实是来自JavaScript对对象（Object）的定义。但是它作为数据格式来使用的时候，和JavaScript没有任何关系，它只是参照了JavaScript对对象定义的数据格式。
JSON 它可以服务任何语言，C、C++、Java、Objective-C、Python、Go、等，在各个语言中的字典、Map和JSON是类似的结构，所以它们之间可以相互转换。

1.JSON键值，以 “{” 开始，以 “}” 结束。中间包裹的为Key : Value的数据结构。
如:

{“name”:“小明”}

表达的意思就是 name = sojson，他们是字符串(String)，所以要以双引号引起来。

2.JSON数组，以 “[” 开始，以 “]” 结束。中间为装起来的数据，而Value可以为以下的任意数据类型。
String、number、object、array、boolean（true/false）,null 这几种数据类型。

{
    "type1": "string",
    "type2": 31,
    "type3": {"name":"张三"},
    "type4": ["张三","李四"],
    "type5": true,
    "type6": null,
}

7.1.1JSON语法

Json语法规则

数据在名称/值对中
数据由逗号分隔
花括号保存对象
方括号保存数组

JSON 名称/值对

JSON 数据的书写格式是：{Key:Value}、{Key:Array}。
{Key:Value}，前面是键，中间是英文的“:”（冒号），然后是值。但是注意的是如果是字符串，严格来说都是英文双引号引起来的

如：{“Key”:“Value”}

{“name” : “鹿晗”}

等价于这条JavaScript语句

name:“鹿晗”

Json对象

<script type="text/javascript">
        var user = {
            name:"李瑞",
            age:22,
            id:02
        }
        console.log(user);
    </script>

JSON 数组

 <script type="text/javascript">
        var star_male = [
            {
                "name": "黄晓明",
                "age": "26"
            },
            {
                "name": "陈思诚",
                "age": "29"
            },
            {
                "name": "陈赫",
                "age": "31"
            }
        ]
        //遍历数组元素
        for (var i in star_male) {
            alert("name:" + star_male[i].name);
            alert("age:" + star_male[i]['age']);
        }
        for (var i = 0;i<star_male.length;i++){
            alert("name:"+star_male[i].name)
            alert("age:"+ star_male[i].age)
        }
    </script>

Json使用

<script type="text/javascript">
  //将js对象解析为json对象
        let s = JSON.stringify(user);
        console.log(s);//{"name":"李瑞","age":22,"id":2018060160}
        //将json对象转换为js对象
        console.log("================");
        let parse = JSON.parse(s);
        console.log(parse)
</script>

为什么要用JSON？
1.其实用JSON主要是因为它轻量，各个平台语言都支持JSON交互、JSON解析和存储。

2.JSON常用于我们接口交互，前后端交互中，有解析速度快，方便的特点。

3.JSON常用于我们一些配置文件也是因为解析方便，JSON存储数据体积小等特征，而不像XML、PList（也是xml的一种）等格式，定义各种Dom节点（当然复杂的格式还是建议XML）。

用JSON的好处是什么？
1.JSON是大家公认的传输格式，所以学习成本低，程序员之间交流经常会问，您接口返回什么格式？答曰：“JSON”，其实就没啥问题了。

2.各个语言、各个框架（第三方组件）都支持JSON，所以使用上来讲，复用率更高，不用格式转来转去。

3.上面也讲了，体积小、解析速度快也是JSON的优点。

7.2Jackson的使用

1.使用Jackson导入jar包

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

2.配置SpringMVC需要的配置 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>

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

   <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
   <context:component-scan base-package="com.kuang.controller"/>

   <!-- 视图解析器 -->
   <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.编写实体类User

public class User {
    private int id;
    private String name;
    private int age;

    public User() {
    }

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

5.编写一个Controller类
1.@ResponseBody注解，这里会将str转成json格式返回；十分方便
2.ObjectMapper对象，用来解析数据

@Controller
public class JsonController {
  @RequestMapping("/j2")
  @ResponseBody
  public String json2() throws JsonProcessingException {
      //创建一个Jackson的对象映射器，用来解析数据
      ObjectMapper mapper = new ObjectMapper();
      //创建一个对象
      User user = new User(2,"小华",12);
      //将我们的对象解析成为json格式
      String str = mapper.writeValueAsString(user);
      //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
      return str;//{"id":2,"name":"??","age":12}
  }
  }

在这里插入图片描述

出现乱码的问题：要设置编码格式
//produces:指定响应体返回类型和编码 @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

解决后：
在这里插入图片描述
在springmvc中一般我们都会在springmvc-servlet.xml配置一些StringHttpMessageConverter转换配置!

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

6.返回json字符串统一解决

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用

 @RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        //创建一个Jackson对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(4,"小李",8);
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        return str;//{"id":4,"name":"小李","age":8}
    }

集合输出

 @RequestMapping("/j4")
    public String json4() throws JsonProcessingException {
        //创建一个Jackson对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(4,"小李",15);
        User user1 = new User(5, "小李", 13);
        User user2 = new User(6, "小李", 10);
        User user3 = new User(7, "小李", 8);
        List<User> userList = new ArrayList<User>();
        userList.add(user);
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(userList);
        return str;//{"id":4,"name":"小李","age":8}
    }

在这里插入图片描述

时间对象输出两种方式

方式一：

 @RequestMapping("/j6")
    public String json6() throws JsonProcessingException {
        //将时间显示在页面上
        Date date = new Date();
        String str = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
        return "现在是北京时间："+str;
    }

在这里插入图片描述
方式二：

 /**
     *解决：  ObjectMapper mapper = new ObjectMapper();
     *       return mapper.writeValueAsString(new Date());
     *       页面结果是时间戳；我们希望看到的格式：现在是北京时间："2020-06-13 17:52:00"
     */
    @RequestMapping("/j7")
    public String json7() throws JsonProcessingException {
        //运用Jackson中的方法实现时间显示
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //指定日期格式
        mapper.setDateFormat(sdf);
        Date date = new Date();
        String str = mapper.writeValueAsString(date);
        return "现在是北京时间："+str;
    }

在这里插入图片描述

为了提高代码的复用性：抽取工具类

public class JsonUtil {
    public static String getJson(User user){
        String str = null;
        //创建Jackson对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        try {
             str = mapper.writeValueAsString(user);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return str ;
    }

    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object, String format){
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        //指定日期格式
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

只需要传Date对象即可

  @RequestMapping("/j8")
    public String json8() throws JsonProcessingException {
        Date date = new Date();
        return "现在是北京时间："+JsonUtil.getJson(date);
    }

7.3Fastjson的使用

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。
fastjson 的 pom依赖！

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

fastjson 三个主要的类：

1.JSONObject 代表 json 对象

JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

2.JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。

3.JSON代表 JSONObject和JSONArray的转化

JSON类源码分析与使用
仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
测试：FastJsonDemo

public class FastJsonDemo {
    public static void main(String[] args) {
        //创建一个对象
        User user1 = new User(1,"小李",22);
        User user2 = new User(2,"小张",15);
        User user3 = new User(3,"小黄",17);
        User user4 = new User(4,"小明",26);
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>" + str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>" + str2);

        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1 = JSON.parseObject(str2, User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>" + jp_user1);

        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>" + jsonObject1.getString("name"));

        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>" + to_java_user);
    }

}

以上就是SpringMVC框架的使用如果有不足的地方，谢谢留言

I'm sure ok!

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC框架的使用

文章目录1.什么是MVC1.1回顾Servlet1.2分析:2.什么是SpringMVC2.1SpringMVC的优点2.2 第一个SpringMVC程序2.3中心控制器2.4SpringMVC执行原理1.什么是MVCMVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。是将业务逻辑、数据、显示分离的方法来组织代码。MVC主要作用是降低了视图与业务逻辑间的双向偶合。MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。Mod
复制链接

扫一扫