Rubin's Blog

  • 首页
  • 关于作者
  • 隐私政策
享受恬静与美好~~~
分享生活的点点滴滴~~~
  1. 首页
  2. SpringMVC
  3. 正文

SpringMVC应用

2021年 6月 10日 905点热度 0人点赞 0条评论

SpringMVC简介

MVC体系结构

三层架构

我们的开发架构一版基于两种形式,一种是C/S架构,也就是客户端/服务器;一种是B/S架构,也就是浏览器/服务器架构。在JavaEE开发中,基本上都是基于B/S架构的开发。那么在B/S架构中,系统标准的三层架构包括:表现层、业务层和持久层。

三层架构中,每一层都各司其职。详情如下:

  • 表现层:也就是我们常说的web层。它负责接收客户端请求,向客户端响应结果。通常客户端使用http协议请求web层,web层接收http请求,完成http响应。表现层包括展示层和控制层:控制层负责接受请求,展示层负责结果的展示。表现层依赖业务层,接收到客户端请求一般会调用业务层进行业务处理,并将处理结果响应给客户端。
  • 业务层:也就是我们常说的service层。它负责业务逻辑的处理,和我们项目开发的需求息息相关。web层依赖业务层,业务层不依赖web层。业务层再进行业务处理的时候可能会依赖持久层。如果要对数据持久化需要保证事务一致性。
  • 持久层:也就是我们常说的dao层。负责数据持久化,包括数据层(及数据库)和数据访问层,数据库是对数据进行持久化的载体,数据访问层是业务层和持久层交互的接口,业务层需要通过数据访问层将数据持久化到数据库中。通俗来讲,持久层就是和数据库交互,对数据库表进行增删改查的。

MVC设计模式

MVC全名是Model View Controller,是模型(model)-视图(view)-控制器(controller)的缩写,是一种用于设计创建Web应用程序表现层的模式。其各个部分为:

  • Model(模型):模型包含业务模型和数据模型,数据模型用于封装数据,业务模型用于处理业务。
  • View(视图):通常指的是我们的jsp或者html。作用一般就是展示数据的。通常视图是依据模型数据创建的。
  • Controller(控制器):是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。

MVC倡导:每一层只编写自己的东西,不编写任何其他的代码。分层是为了解耦,解耦是为了维护方便和分工协作。

SpringMVC是什么

SpringMVC全名叫做Spring Web MVC,是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架,属于SpringFrameWork的后续产品。Spring的架构图如下:

SpringMVC已经成为目前最流行额MVC框架之一,并且随着Spring3.0的发布,全面超越Structs2,成为最优秀的MVC框架。

SpringMVC本质可以认为是对servlet的封装,简化了我们serlvet的开发。其处理请求流程如图所示:

SpringMVC的工作流程

SpringMVC请求处理流程

这个是我们面试中经常被问到的问题。详细来讲,一共分为十一步。我们参考下图所介绍:

详细流程如下:

  • 第一步:用户发送请求值前端控制器DispatcherServlet。
  • 第二步:DispatcherServlet收到请求调用HandlerMapping处理映射器。
  • 第三步:处理映射器根据Url找到具体的Handler(后端控制器),生成处理器对象及处理器拦截器(如果有,就生成)一并返回给DispatcherServlet。
  • 第四步:DispatcherServlet调用HandlerAdapter处理器适配器去调用Handler。
  • 第五步:处理器适配器执行Handler。
  • 第六步:Handler执行完成给处理器适配器返回ModelAndView。
  • 第七步:处理器适配器向前端控制器返回ModelAndView(ModelAndView是SpringMVC框架的一个底层对象,包括Model和View)。
  • 第八步:前端控制器请求视图解析器去进行视图解析,根据逻辑视图名来解析真正的视图。
  • 第九步:视图解析器向前端控制器返回View。
  • 第十步:前端控制器进行视图渲染,就是将模型数据(在ModelAndView对象中)填充到request域。
  • 第十一步:前端控制器向用户响应结果。

SpringMVC九大组件

SpringMVC一共包含九大组件,详情如下:

  • HandlerMapping(处理器映射器):HandlerMapping是用来查找Handler的,也就是处理器,具体的表现形式可以是类,也可以是方法。比如,标注了@RequestMapping的每个方法都可以看成是一个Handler。Handler负责具体实际的请求处理。在请求到达后,HandlerMapping的作用便是找到请求相应的处理器Handler和Interceptor。
  • HandlerAdapter(处理器适配器):HandlerAdapter是一个适配器。因为SpringMVC中Handler可以是任意形式的,只要能处理请求即可。但是把请求交给Servlet的时候,由于Servlet的方法结构都是doService(HttpServletRequest req, HttpServletResponse resp)形式的。要让固定的Servlet处理方法调用Handler来进行处理,便是HandlerAdapter的职责。
  • HandlerExceptionResolver:HandlerExceptionResolver用于处理Handler产生的异常情况。它的作用是根据异常设置ModelAndView,之后交给渲染方法进行渲染,渲染方法会将ModelAndView渲染成页面。
  • ViewResolver:ViewResolver即视图解析器,用于将String类型的视图名和Locale解析为View类型的视图,只有一个resolveViewName()方法。从方法的定义可以看出,Controller层返回的String类型视图名viewName最终会在这里被解析成View。View是用来渲染页面的,也就是说,它会将程序返回的参数和数据填入模板中,生成html文件。ViewResolver在这个过程主要完成两件事情:ViewResolver找到渲染所用的模板(第一件大事)和所用的技术(第二件大事,其实也就是找到视图的类型,如JSP)并填入参数。默认情况下,SpringMVC会自动为我们配置一个InternalResourceViewResolver,是针对JSP类型视图的。
  • RequestToViewNameTranslator:RequestToViewNameTranslator组件的作用是从请求中获取ViewName。因为ViewResolver根据ViewName查找View,但有的Handler处理完成之后,没有设置View,也没有设置ViewName,便要通过这个组件从请求中查找ViewName。
  • LocaleResolver:LocaleResolver组件的resolveViewName方法需要两个参数,一个是视图名,一个是Locale。LocaleResolver用于从请求中解析出Locale,比如中国Locale是zh-CN,用来表示一个区域。这个组件也是i18n的基础。
  • ThemeResolver:ThemeResolver组件是用来解析主题的。主题是样式、图片及它们所形成的显示效果的集合。SpringMVC中一套主题对应一个properties文件,里面存放着与当前主题相关的所有资源,如图片、CSS样式等。创建主题非常简单,只需准备好资源,然后新建一个“主题名.properties”并将资源设置进去,放在classpath下,之后便可以在页面中使用了。SpringMVC中与主题相关的类有ThemeResolver、ThemeSource和Theme。ThemeResolver负责从请求中解析出主题名,ThemeSource根据主题名找到具体的主题,其抽象也就是Theme,可以通过Theme来获取主题和具体的资源。
  • MultipartResolver:MultipartResolver用于上传请求,通过将普通的请求包装成MultipartHttpServletRequest来实现。MultipartHttpServletRequest可以通过getFile()方法直接获得文件。如果上传多个文件,好可以调用getFIleMap()方法得到Map<FileName, File>这样的结构,MultipartResolver的作用就是封装普通的请求,使其拥有文件上传的功能。
  • FlashMapManager:FlashMap用于重定向时的参数传递。主要就是避免在url上面传参导致信息泄露,我们可以使用FalshMap来传递重定向参数。

搭建SpringMVC

本节,我们来搭建一个简单的SpringMVC。使其可以实现简单的接受请求返回响应即可。首先,我们创建一个Maven工程,如下图所示:

创建好之后,加入如下的依赖坐标:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rubinchu</groupId>
    <artifactId>spring-mvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring-mvc-demo Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--引入spring webmvc的依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>spring-mvc-demo</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

接下来,配置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>
    <!--springmvc提供的针对post请求的编码过滤器-->
    <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>
    <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.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
          方式一:带后缀,比如*.action  *.do *.aaa
                 该种方式比较精确、方便,在以前和现在企业中都有很大的使用比
          方式二:/ 不会拦截 .jsp,但是会拦截.html等静态资源(静态资源:除了servlet和jsp之外的js、css、png等)
                为什么配置为/ 会拦截静态资源???
                    因为tomcat容器中有一个web.xml(父),你的项目中也有一个web.xml(子),是一个继承关系
                          父web.xml中有一个DefaultServlet,  url-pattern 是一个 /
                          此时我们自己的web.xml中也配置了一个 / ,覆写了父web.xml的配置
                为什么不拦截.jsp呢?
                    因为父web.xml中有一个JspServlet,这个servlet拦截.jsp文件,而我们并没有覆写这个配置,
                    所以springmvc此时不拦截jsp,jsp的处理交给了tomcat
                如何解决/拦截静态资源这件事?
          方式三:/* 拦截所有,包括.jsp
        -->
        <!--拦截匹配规则的url请求,进入springmvc框架处理-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

接下来,我们创建我们的源码文件夹和资源文件夹,一般的结构如下所示:

我们的spring的配置文件内容如下:

<?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
">
    <!--开启controller扫描-->
    <context:component-scan base-package="com.rubin.controller"/>
    <!--配置springmvc的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--
        自动注册最合适的处理器映射器,处理器适配器(调用handler方法)
    -->
    <mvc:annotation-driven/>

    <!--静态资源配置,方案一-->
    <!--
        原理:添加该标签配置之后,会在SpringMVC上下文中定义一个DefaultServletHttpRequestHandler对象
             这个对象如同一个检查人员,对进入DispatcherServlet的url请求进行过滤筛查,如果发现是一个静态资源请求
             那么会把请求转由web应用服务器(tomcat)默认的DefaultServlet来处理,如果不是静态资源请求,那么继续由
             SpringMVC框架处理
    -->
    <!--<mvc:default-servlet-handler/>-->

    <!--静态资源配置,方案二,SpringMVC框架自己处理静态资源
        mapping:约定的静态资源的url规则
        location:指定的静态资源的存放位置
    -->
    <mvc:resources location="classpath:/"  mapping="/resources/**"/>
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>
</beans>

我们编写一个Controller:

@Controller
@RequestMapping("test")
public class TestController {

    @RequestMapping("/")
    public String index() {
        return "index";
    }

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(String name) {
        return "hello " + name + "!";
    }

}

之后再将项目发布到Tomcat容器上面,访问自己编写的访问路径,查看响应结果是否成功即可。在此不再赘述。至此,我们的SpringMVC就搭建完成了。

SpringMVC请求参数绑定

说白了,请求参数的绑定就是SpringMVC框架如何接收参数。我们原生的Servlet接收一个整型的参数,我们要编写如下代码:

String ageStr = request.getParameter("age");
Integer age = Integer.parseInt(ageStr);

我们的SpringMVC对原生的Servlet做了进一步的封装,使得我们接收参数变得很简单。下面,我们分类进行讲解说明。

绑定原生Servlet API作为参数

也就是说,我们想要使用原生的Servlet API作为参数(比如HttpServletRequest、HttpSession等等),我们直接在Handler方法中形参声明即可:

/**
  * SpringMVC 对原生servlet api的支持 url:/demo/handle02?id=1
  *
  * 如果要在SpringMVC中使用servlet原生对象,比如HttpServletRequest、HttpServletResponse、HttpSession
  * 等,直接在Handler方法形参中声明使用即可
  */
@RequestMapping("/handle02")
public ModelAndView handle02(HttpServletRequest request, HttpServletResponse response,HttpSession session) {
    String id = request.getParameter("id");
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定简单类型参数

简单类型的参数指的是八种基本类型以及其包装类还有字符串。我们在接收参数的时候,大部分时候,null是有业务意义的,但是我们的基本类型是不支持null值的。所以,我们在做参数绑定的时候尽量使用包装类型。对于布尔类型的参数,请求参数要传true和false,或者是1和0。注意:绑定简单类型的参数值,只需要直接声明形参即可(形参的参数名和传递的参数名要保持一致,建议使用包装类型。当形参参数名称和传递的参数名称不一致的时候,可以使用@RequestParam注解进行手动映射):

/**
  * SpringMVC 接收简单数据类型参数 url:/demo/handle03?id=1
  *
  * 注意:接收简单数据类型参数,直接在handler⽅法的形参中声明即可,框架会取出参数值
然后绑定到对应参
  * 数上
  * 要求:传递的参数名和声明的形参名称保持⼀致
  */
@RequestMapping("/handle03")
public ModelAndView handle03(@RequestParam("ids") Integer id, Boolean
 flag) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定Pojo类型的参数

/**
  * SpringMVC接收pojo类型参数 url:/demo/handle04?id=1&username=zhangsan
  *
  * 接收Pojo类型参数,直接形参声明即可,类型就是Pojo的类型,形参名无所谓
  * 但是要求传递的参数名必须和Pojo的属性名保持⼀致
  */
@RequestMapping("/handle04")
public ModelAndView handle04(User user) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定Pojo包装对象参数

也就是针对我们接受的参数中包含另外一个对象的情况,我们的参数对象封装如下:

public class QueryVo {
    private String mail;
    private String phone;
    // 嵌套了另外的Pojo对象
    private User user;
    public String getMail() {
        return mail;
    }
    public void setMail(String mail) {
        this.mail = mail;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
}

Handler定义如下:

/**
  * SpringMVC接收pojo包装类型参数 url:/demo/handle05?
user.id=1&user.username=zhangsan
  * 不管包装Pojo与否,它首先是⼀个Pojo,那么就可以按照上述Pojo的要求来
  * 1、绑定时候直接形参声明即可
  * 2、传参参数名和pojo属性保持⼀致,如果不能够定位数据项,那么通过属性名 + "." 的
方式进⼀步锁定数据
  *
  */
@RequestMapping("/handle05")
public ModelAndView handle05(QueryVo queryVo) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

绑定日期类型的参数

我们的前端页面定义如下:

<fieldset>
    <p>测试用例:SpringMVC接收日期类型参数</p>
    <a href="/demo/handle06?birthday=2019-10-08">点击测试</a>
</fieldset>

我们来定义我们的Handler方法:

/**
  * 绑定日期类型参数
  * 定义⼀个SpringMVC的类型转换器接口,扩展实现接口,注册你的实现
  * @param birthday
  * @return
  */
@RequestMapping("/handle06")
public ModelAndView handle06(Date birthday) {
    Date date = new Date();
    ModelAndView modelAndView = new
 ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

定义我们的自定义日期转换器:

public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        // 完成字符串向日期的转换
        SimpleDateFormat simpleDateFormat = new
 SimpleDateFormat("yyyy-MM-dd");
        try {
            Date parse = simpleDateFormat.parse(source);
            return parse;
        } catch (ParseException e) {
             e.printStackTrace();
        }
        return null;
    }
}

注册我们的自定义类型转换器:

<!--自动注册最合适的处理器映射器,处理器适配器(调用handler方法)-->
<mvc:annotation-driven conversion-service="conversionServiceBean"/>
<!--注册自定义类型转换器-->
<bean id="conversionServiceBean"
class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <bean class="com.rubin.converter.DateConverter"></bean>
        </set>
    </property>
</bean>

SpringMVC对于Restful风格请求的支持

什么是Restful

Restful是一种web软件架构风格,它不是标准也不是协议,它倡导的是一个资源定位以及资源操作的风格。这个网上的介绍有很多,就不在此详细赘述这些概念性的东西。

SpringMVC编写Restful风格的接口

我们先来定义前端的页面:

<div>
    <h2>SpringMVC对Restful风格url的支持</h2>
    <fieldset>
        <p>测试用例:SpringMVC对Restful风格url的支持</p>
        <a href="/demo/handle/15">rest_get测试</a>
        <form method="post" action="/demo/handle">
            <input type="text" name="username"/>
            <input type="submit" value="提交rest_post请求"/>
        </form>
        <form method="post" action="/demo/handle/15/lisi">
            <input type="hidden" name="_method" value="put"/>
            <input type="submit" value="提交rest_put请求"/>
        </form>
        <form method="post" action="/demo/handle/15">
            <input type="hidden" name="_method" value="delete"/>
            <input type="submit" value="提交rest_delete请求"/>
        </form>
    </fieldset>
</div>

我们在来定义我们的Handler方法:

/*
 * restful get /demo/handle/15
 */
@RequestMapping(value = "/handle/{id}", method =
 {RequestMethod.GET})
public ModelAndView handleGet(@PathVariable("id") Integer id) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful post /demo/handle
 */
@RequestMapping(value = "/handle", method = {RequestMethod.POST})
public ModelAndView handlePost(String username) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful put /demo/handle/15/lisi
 */
@RequestMapping(value = "/handle/{id}/{name}",method =
 {RequestMethod.PUT})
public ModelAndView handlePut(@PathVariable("id") Integer
 id,@PathVariable("name") String username) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}
/*
 * restful delete /demo/handle/15
 */
@RequestMapping(value = "/handle/{id}",method =
 {RequestMethod.DELETE})
public ModelAndView handleDelete(@PathVariable("id") Integer id) {
    Date date = new Date();
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject("date", date);
    modelAndView.setViewName("success");
    return modelAndView;
}

除此之外,我么还需要定义一个过滤器来将我们的put和delete请求转化成post请求。过滤器定义如下:

<!--配置springmvc请求方式转换过滤器,会检查请求参数中是否有_method参数,如果有就
按照指定的请求方式进行转换-->
<filter>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <filter-
class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-
class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>hiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

SpringMVC与Json的交互

SpringMVC与Json的交互涉及到两个方向:

  • 前端到后端:前端发送Json字符串,后端直接接收为Pojo参数,使用@RequestBody注解。
  • 后端到前端:后端直接返回Pojo对象,前段直接接收为Json对象或字符串,使用@ResponseBody注解。

SpringMVC想要与Json交互,需要引入如下的jar包:

<!--json数据交互所需jar,start-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>
<!--json数据交互所需jar,end-->

前端代码示例如下:

<div>
    <h2>Ajax json交互</h2>
    <fieldset>
        <input type="button" id="ajaxBtn" value="ajax提交"/>
    </fieldset>
</div>
$(function () {
    $("#ajaxBtn").bind("click",function () {
        // 发送ajax请求
        $.ajax({
            url: '/demo/handle07',
            type: 'POST',
            data: '{"id":"1","name":"李四"}',
            contentType: 'application/json;charset=utf-8',
            dataType: 'json',
            success: function (data) {
                alert(data.name)
            }
        })
    })
})

后端Handler方法定义如下:

@RequestMapping("/handle07")
// 添加@ResponseBody之后,不再走视图解析器那个流程,而是等同于response直接输出
数据
public @ResponseBody User handle07(@RequestBody User user) {
    // 业务逻辑处理,修改name为张三丰
    user.setName("张三丰");
    return user;
}
本作品采用 知识共享署名 4.0 国际许可协议 进行许可
标签: SpringMVC
最后更新:2022年 6月 9日

RubinChu

一个快乐的小逗比~~~

打赏 点赞
下一篇 >

文章评论

razz evil exclaim smile redface biggrin eek confused idea lol mad twisted rolleyes wink cool arrow neutral cry mrgreen drooling persevering
取消回复
文章目录
  • SpringMVC简介
    • MVC体系结构
      • 三层架构
      • MVC设计模式
    • SpringMVC是什么
  • SpringMVC的工作流程
    • SpringMVC请求处理流程
    • SpringMVC九大组件
  • 搭建SpringMVC
  • SpringMVC请求参数绑定
    • 绑定原生Servlet API作为参数
    • 绑定简单类型参数
    • 绑定Pojo类型的参数
    • 绑定Pojo包装对象参数
    • 绑定日期类型的参数
  • SpringMVC对于Restful风格请求的支持
    • 什么是Restful
    • SpringMVC编写Restful风格的接口
  • SpringMVC与Json的交互
最新 热点 随机
最新 热点 随机
问题记录之Chrome设置屏蔽Https禁止调用Http行为 问题记录之Mac设置软链接 问题记录之JDK8连接MySQL数据库失败 面试系列之自我介绍 面试总结 算法思维
Docker之网络 Kafka高级特性之消费者 RocketMQ之集群与运维 网络编程详解 Neo4j之程序访问 java并发编程之CompletableFuture

COPYRIGHT © 2021 rubinchu.com. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang

京ICP备19039146号-1