SpringMVC框架的使用

文章目录

        • 1.什么是MVC
          • 1.1回顾Servlet
          • 1.2分析:
        • 2.什么是SpringMVC
          • 2.1SpringMVC的优点
          • 2.2 第一个SpringMVC程序
          • 2.3中心控制器
          • 2.4SpringMVC执行原理
        • 3.注解开发SpringMVC
        • 4.@RequestMapping及RestFul风格
          • 4.1使用@RequestMapping映射请求
            • 4.1.1模拟post提交方式:
            • 4.1.2@RequestMapping注解变体
          • 4.2RestFul风格
        • 5.重定向和转发
        • 6.接收请求参数及回显参数
          • 6.1提交的域名称和处理方法的参数名一致
          • 6.2提交的域名称和处理方法的参数名不一致
          • 6.3提交的是一个对象
          • 6.4参数乱码问题
        • 7.Json交互处理
          • 7.1什么是JSON?
            • 7.1.1JSON语法
          • 7.2Jackson的使用
          • 7.3Fastjson的使用

1.什么是MVC

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

  • Model(模型):数据模型,提供要展示的数据,因此包含数据和行为,可以认为是领域模型或JavaBean组件(包含数据和行为),不过现在一般都分离开来:Value Object(数据Dao) 和 服务层(行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能,包括数据和业务。

  • View(视图):负责进行模型的展示,一般就是我们见到的用户界面,客户想看到的东西。

  • Controller(控制器):接收用户请求,委托给模型进行处理(状态改变),处理完毕后把返回的模型数据返回给视图,由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。
SpringMVC框架的使用_第1张图片

1.1回顾Servlet

第一步:导入依赖

  <dependencies>
        
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13version>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>jstlartifactId>
            <version>1.2version>
        dependency>

        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.2.6.RELEASEversion>
        dependency>

        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
            <scope>providedscope>
        dependency>

        
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>jsp-apiartifactId>
            <version>2.2version>
            <scope>providedscope>
        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>helloservlet-name>
        <servlet-class>com.li.servlet.HelloServletservlet-class>
    servlet>
    
    <servlet-mapping>
        <servlet-name>helloservlet-name>
        <url-pattern>/hellourl-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文件


    
    <servlet>
        <servlet-name>springmvcservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc-servlet.xmlparam-value>
        init-param>
        
        <load-on-startup>1load-on-startup>
    servlet>

    
    
    <servlet-mapping>
        <servlet-name>springmvcservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>

第二步:编写springmvc-servlet.xml文件


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


<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下的文件
SpringMVC框架的使用_第2张图片
配置Tomcat 修改名字、确认本地服务
SpringMVC框架的使用_第3张图片
SpringMVC框架的使用_第4张图片
问题:
一:出现的问题: Tomcat 服务器无法正常启动
原因: Tomcat 服务器找不到相关的 jar 包
解决方法: 将【lib】文件夹整个剪贴到【WEB-INF】下,并重新建立依赖:
SpringMVC框架的使用_第5张图片
二:maven资源过滤问题:
导入依赖

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

第六步:启动服务器
访问地址:http://localhost:8080/hello
SpringMVC框架的使用_第6张图片

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

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

SpringMVC框架的使用_第7张图片
前端控制器(DispatcherServlet):

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

2.4SpringMVC执行原理

SpringMVC框架的使用_第8张图片
简要分析执行流程

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的配置


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

第三步:注册HelloController类,使用@Controller
@Controller 相当于
@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>Titletitle>
head>
<body>
${msg}
body>
html>

4.@RequestMapping及RestFul风格

4.1使用@RequestMapping映射请求

@RequestMapping映射请求替代了原来 使用注解可以映射到这个类上或者方法中

@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";
    }
}

SpringMVC框架的使用_第9张图片

SpringMVC框架的使用_第10张图片

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

SpringMVC框架的使用_第11张图片
浏览器上面的请求地址 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";
    }

SpringMVC框架的使用_第12张图片

5.重定向和转发

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

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

SpringMVC框架的使用_第13张图片

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

SpringMVC框架的使用_第14张图片

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

浏览器页面:
SpringMVC框架的使用_第15张图片
控制台:

接收前端的参数李瑞

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方式会出现乱码
SpringMVC框架的使用_第16张图片
如果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框架的使用_第17张图片

以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 修改了xml文件需要重启服务器

<filter>
   <filter-name>encodingfilter-name>
   <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
   <init-param>
       <param-name>encodingparam-name>
       <param-value>utf-8param-value>
   init-param>
filter>
<filter-mapping>
   <filter-name>encodingfilter-name>
   <url-pattern>/*url-pattern>
filter-mapping>

SpringMVC框架的使用_第18张图片

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.coregroupId>
            <artifactId>jackson-databindartifactId>
            <version>2.11.0version>
dependency>

2.配置SpringMVC需要的配置 web.xml文件


<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>SpringMVCservlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
       
       <init-param>
           <param-name>contextConfigLocationparam-name>
           <param-value>classpath:springmvc-servlet.xmlparam-value>
       init-param>
       
       <load-on-startup>1load-on-startup>
   servlet>

   
   <servlet-mapping>
       <servlet-name>SpringMVCservlet-name>
       <url-pattern>/url-pattern>
   servlet-mapping>

   <filter>
       <filter-name>encodingfilter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
       <init-param>
           <param-name>encodingparam-name>
           <param-value>utf-8param-value>
       init-param>
   filter>
   <filter-mapping>
       <filter-name>encodingfilter-name>
       <url-pattern>/url-pattern>
   filter-mapping>

web-app>

3.配置springmvc-servlet.xml


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

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

SpringMVC框架的使用_第19张图片

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

解决后:
SpringMVC框架的使用_第20张图片
在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}
    }

SpringMVC框架的使用_第21张图片

时间对象输出 两种方式

方式一:

 @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;
    }

SpringMVC框架的使用_第22张图片
方式二:

 /**
     *解决:  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;
    }

SpringMVC框架的使用_第23张图片

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

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.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.60version>
        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框架的使用如果有不足的地方,谢谢留言

你可能感兴趣的:(框架部分)