SpringMVC完整笔记

最新推荐文章于 2023-07-30 16:51:10 发布
最新推荐文章于 2023-07-30 16:51:10 发布
阅读量1.2k 收藏 41
点赞数 9
CC 4.0 BY-SA版权
分类专栏： SpringMVC学习笔记 文章标签： mvc java struts
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45974648/article/details/120832808
本文介绍了MVC设计模式及其在Servlet中的应用，详细阐述了Servlet的执行流程和职责。接着，探讨了SpringMVC框架，包括其核心组件、执行原理和项目搭建。此外，文章还讨论了使用注解开发SpringMVC的步骤，并深入浅出地解释了RestFul风格的优缺点和实现方式。最后，提到了重定向、转发在SpringMVC中的运用以及处理请求参数和数据回显的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1、回顾MVC

1.1、MVC概述
  • MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
  • 是将业务逻辑、数据、显示分离的方法来组织代码。
  • MVC主要作用是降低了视图与业务逻辑间的双向偶合。
  • MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。
  • MVC三层架构
    • Model（模型)︰数据模型，提供要展示的数据，因此包含数据和行为。可以认为是领域模型或JavaBean组件(包含数据和行为)，不过现在一般都分离开来: Value object(数据Dao）和服务层(行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
    • View(视图)︰负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
    • Controller(控制器)︰接收用户请求，委托给模型进行处理（状态改变)，处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。
  • 最典型的MVC就是JSP + servlet + javabean的模式。
1.2、执行流程
  • 用户发请求
  • Servlet接收请求数据，并调用对应的业务逻辑方法
  • 业务处理完毕，返回更新后的数据给servlet
  • servlet转向到JSP，由JSP来渲染页面
  • 响应给前端更新后的页面
1.3、职责分析
  • Controller：控制器
    • 取得表单数据
    • 调用业务逻辑
    • 向指定的页面
  • Model：模型
    • 业务逻辑
    • 保存数据的状态
  • View：视图
    • 显示页面
1.4、MVC框架做的事
  • 将url映射到java类或java类的方法
  • 封装用户提交的数据
  • 处理请求–调用相关的业务处理–封装响应数据
  • 将响应的数据进行渲染. jsp / html 等表示层数据.
1.5、说明
  • 常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF;
  • 常见前端MVC框架：vue、angularjs、react、backbone;
  • 由MVC演化出了另外一些模式如：MVP、MVVM（M；V；VM–ViewModel:双向绑定）等

2、回顾servlet

2.1、环境搭建

  • 导入依赖

    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>

  • 编写一个Servlet类HelloServlet，用来处理用户的请求

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

  • 编写jsp页面test.jsp

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

  • 配置文件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>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.ping.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

  • 部署Tomcat测试

3、SpringMVC介绍

3.1、概述
  • Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。
3.2、特点
  • 经量级，简单易学
  • 高效，基于请求响应的MVC框架
  • 与Spring兼容性好，无缝结合
  • 约定优于配置
  • 功能强大：RESTful、数据验证、格式化、本地化、主题等
  • 简洁灵活
  • 最重要的一点还是用的人多，使用的公司多
3.3、中心控制器
  • Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
  • Spring MVC框架像许多其他MVC框架一样,以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet(它继承自HttpServlet 基类)。
3.4、执行原理

  • 当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

  • 上图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现虚线表示需要开发者实现。
  • 简要分析执行流程
    • DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
      • 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
      • 如上url拆分成三部分:
      • http://localhost:8080服务器域名.
      • SpringMVC部署在服务器上的web站点
      • hello表示控制器
      • 通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
    • HandlerMapping为处理器映射。DispatcherServlet调用
      HandlerMapping,HandlerMapping根据请求url查找Handler。
    • HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为: hello。
    • HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
    • HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
    • Handler让具体的Controller执行。
    • Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView
    • HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
    • DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
    • 视图解析器将解析的逻辑视图名传给DispatcherServlet。
    • DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
    • 最终视图呈现给用户。
3.5、初步搭建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.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别：1  服务器一启动，它就启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求;(不包括.jsp ) -->
    <!--/* 匹配所有的请求;(包括.jsp ) -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

  • 配置文件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"/>

    <!--视图解析器：DisapatcherServlet给它的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--Handler-->
    <bean id="/hello" class="com.ping.controller.HelloController"/>

</beans>

  • 控制层：类HelloController

    //注意：这里导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {

        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndVie中
        mv.addObject("msg","HelloSpringMVC");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//：/WEB-INF/jsp/hello.jsp

        return mv;
    }
}

  • 视图层：hello.jsp

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

  • 部署Tomcat测试

  • 可能遇到的问题:访问出现404，排查步骤:

    • 查看控制台输出，看一下是不是缺少了什么jar包。

    • 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖

    • 重启Tomcat即可解决!

3.6、注意点

  • 使用springMVC必须配置的三大件:

    处理器映射器、处理器适配器、视图解析器

    通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

4、使用注解开发SpringMVC

4.1、环境搭建

  • 配置文件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.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别：1  服务器一启动，它就启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求;(不包括.jsp ) -->
    <!--/* 匹配所有的请求;(包括.jsp ) -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

  • 配置文件springmvc-servlet.xml

    • 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。
    <?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
          http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/mvc
          http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.ping.controller"/>
    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
    支持mvc注解驱动
        在spring中一殷采川@RequestMapping注解来完成映射关系
        要想使@RequestMapping主解生效
        必须向上下文中注册DefaultAnnotationHandLerMapping
        和一个AnnotationMethodHandLerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven/>

    <!--视图解析器：DisapatcherServlet给它的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
@RequestMapping("/hello")
public class HelloController {
    //localhost:8080/hello/h1
    @RequestMapping("/h1")
    public String hello(Model model){
        //封装数据，向模型中添加属性msg与值，可以在jsp页面中取出并渲染
        model.addAttribute("msg","Hello,SpringMVCAnnotation");

        return "hello"; //会被视图解析器处理：/WEB-INF/jsp/hello.jsp
    }
}

  • 视图层hello.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>
4.2、实现步骤
  • 新建一个web项目
  • 导入相关jar包
  • 编写web.xml，注册DispatcherServlet
  • 编写spring revc配置文件
  • 接下来就是去创建对应的控制类，controller
  • 最后完善前端视图和controller之间的对应
  • 测试运行调试
4.3、控制器Controller
  • 控制器复杂提供访问应用程序的行为，通常通过接口定义（3.5）或注解定义（4.1）两种方法实现。
  • 控制器负责解析用户的请求并将其转换为一个模型。
  • 在Spring MVC中一个控制器类可以包含多个方法
  • 在Spring MVC中，对于Controller的配置方式有很多种

5、RestFul风格

5.1、概念

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

5.2、功能
  • 资源：互联网所有的事物都可以被抽象为资源
  • 资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
  • 分别对应添加、删除、修改、查询。
5.3、传统方式操作资源
  • http://127.0.0.1/item/queryltem.action?id=1 查询,GET
  • http://127.0.0.1/item/saveltem.action 新增,POST
  • http://127.0.0.1/item/updateltem.action 更新,POST
  • http://127.0.0.1/item/deleteltem.action?id=1 删除,GET或POST
5.4、使用RestFul操作资源
  • 可以通过不同的请求方式来实现不同的效果！如下:请求地址一样，但是功能可以不同!
  • http://127.0.0.1/item/1 查询,GET
  • http://127.0.0.1/item 新增,POST
  • http://127.0.0.1/item 更新,PUT
  • http://127.0.0.1/item/1 删除,DELETE
5.5、传统方式的示例

  • 控制层：RestFulController类

    @Controller
public class RestFulController {

    //传统的url：http://localhost:8080/add?a=1&b=2
    @RequestMapping("/add")
    public String test(int a, int b, Model model){
        int res = a+b;
        model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

  • 视图层：test.jsp

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

  • 测试结果：地址栏输入传统的url：http://localhost:8080/add?a=1&b=2

    结果为3

5.6、RestFul示例

  • 控制层：RestFulController类

    • 方式一：@RequestMapping("/add2/{a}/{b}")

      //RestFul：http://localhost:8080/add2/1/2

@RequestMapping("/add2/{a}/{b}")
//@PathVariable 让方法参数的值对应绑定到一个URL模板变量
public String test1(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

    • 方式二：使用method属性指定请求类型

      @RequestMapping(value="/add2/{a}/{b}",method = RequestMethod.GET)

public String test2(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

    • 方式三：使用组合注解@GetMapping

      @GetMapping("/add2/{a}/{b}")

public String test3(@PathVariable int a,@PathVariable int b, Model model){
    int res = a+b;
    model.addAttribute("msg","结果为"+res);
    return "test";
}

  • 视图层test.jsp同上

  • 测试结果：地址栏输入RestFul风格的url：http://localhost:8080/add2/1/2

    结果为3

5.7、总结

  • 使用路径变量的好处

    • 使路径变得更加简洁;
    • 获得参数更加方便,框架会自动进行类型转换。
    • 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/add/1/2，则路径与方法不匹配，而不会是参数转换失败。

  • 使用method属性指定请求类型

    • 用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET， POST, HEAD,OPTIONS,PUT,PATCH，DELETE，TRACE等

  • 所有的地址栏请求默认都会是HTTP GET类型的

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

    @GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
    • @GetMapping是一个组合注解，它所扮演的是@RequestMapping(method =RequestMethod.GET)的一个快捷方式

6、重定向和转发

  • 重定向是客户端行为，状态吗是307！转发是服务端行为，状态码是302！
6.1、ModelAndView
  • 设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面
    • 页面：{视图解析器前缀}+viewName +{视图解析器后缀}
    • 同上3.5
6.2、ServletAPI

  • 通过设置ServletAPl，不需要视图解析器﹒

    • 通过HttpServletResponse进行输出
    • 通过HttpServletResponse实现重定向
    • 通过HttpServletRequest实现转发

  • 示例

    @Controller
public class ModelTest1 {
    @RequestMapping( "/m1/t1")
    public String test1(HttpServletRequest req,HttpServletResponse resp){
        HttpSession session = req.getSession();
        session.setAttribute("msg","test1");
        return "test";
    }
    @RequestMapping( "/m1/t2")
    public void test2(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        resp.getWriter().println("test2");
    }
    @RequestMapping( "/m1/t3")
    public void test3(HttpServletRequest req,HttpServletResponse resp) throws IOException {
        //重定向
        resp.sendRedirect("/index.jsp");
    }
    @RequestMapping( "/m1/t4")
    public void test4(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
        //转发
        req.setAttribute("msg","test4");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

    }

}
6.3、SpringMVC

  • 通过SpringMVC来实现转发和重定向

    • 重定向，不需要视图解析器，本质就是重新请求一个新地方，所以注意路径问题.
      可以重定向到另外—个请求实现

    • 示例

      @Controller
public class ModelTest2 {

    @RequestMapping("/m2/t1")
    public String test1(){
        //转发1：该情况会走视图解析器，报错：文.件[/WEB-INF/jsp/index.jsp.jsp] 未找到
        return "/index.jsp";
    }

    @RequestMapping("/m2/t2")
    public String test2(){
        //转发二：加forward:不走视图解析器，正常转发
        return "forward:/index.jsp";
    }

    @RequestMapping("/m2/t3")
    public String test3(){
        //重定向：加redirect:不走视图解析器，正常重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do 为另一个请求
    }
}

7、接收请求参数及数据回显

7.1、接收请求参数

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

    • 提交数据:http://localhost:8080/hello?name=ping

    • 处理方法︰

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

    • 后台输出: ping

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

    • 提交数据:http://localhost:8080/hello?username=ping

    • 处理方法∶

      //@RequestParam("username"):username提交的域的名称

@GetMapping("/t2")
public String test2(@RequestParam("username") String name, Model model){
    System.out.println("接收到前端的参数为："+name);
    model.addAttribute("msg",name);
    return "test";
}

    • 后台输出: ping

  • 提交的是一个对象

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

    • http://localhost:8080/user/t3?id=1&name=ping&age=20

    • 实体类

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

    • 处理方法

      /*
    1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
    2.假设传递的是一个对象User，匹配User对象中的字段名:如果名字一致则OK，否则，匹配不到
    */
@GetMapping("/t3")
public String test3(User user){
    System.out.println(user);
    return "test";
}
7.2、数据回显到前端
  • 通过ModelAndView，见3.5
    • 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。
  • 通过ModelMap，用法同Model
    • 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承LinkedNap 的方法和特性;
  • 通过Model，见4.1
    • 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解;

8、过滤器解决乱码问题

  • 以前乱码问题通过过滤器解决，而SpringMVC给我们提供了一个过滤器，可以在web.xml中配置

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

9、JSON讲解

9.1、什么是JSON

  • JSON(JavaScript Object Notation,JS对象标记)是一种轻量级的数据交换格式，目前使用特别广泛。

  • 采用完全独立于编程语言的文本格式来存储和表示数据。

  • 简洁和清晰的层次结构使得JSON成为理想的数据交换语言。

  • 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

  • 在JavaScript语言中，一切都是对象。因此，任何JavaScript支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。看看它的要求和语法格式:

    • 对象表示为键值对，数据由逗号分隔
    • 花括号保存对象
    • 方括号保存数组

  • JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，建/值对组合中的键名写在前面并用双引号""包裹，使用冒号∶分隔，然后紧接着值

  • JSON 是JavaScript对象的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。

    //这是一个对象，注意键名也是可以使用引号包裹的
var user ={
            name : "ping",
            age:3,
            sex:"男"
};
//这是一个JSON字符串，本质是一个字符串
var json = '{"name":"ping","age":3,"sex":"男"}'
9.2、JSON 和JavaScript对象互转

  • 要实现从JavaScript对象转换为JSON字符串，使用JSON.stringify()方法:

    var json = JSON.stringify(user);

  • 要实现从JSON字符串转换为JavaScript对象，使用JSON.parse()方法:

    var obj = JSON.parse(json);

  • 完整js

    <script type="text/javascript">
    //编写一个JavaScript对象
    var user ={
        name : "ping",
        age:3,
        sex:"男"
    };

    //将js对象转换为JSON字符串
    var json = JSON.stringify(user);
    console.log(json);

    //将JSON字符串转换为JavaScript对象
    var obj = JSON.parse(json);
    console.log(obj);

</script>
9.3、Controller返回JSON数据（Jackson）

  • Jackson应该是目前比较好的json解析工具；另外还有阿里巴巴的 fastjson等等。

  • 使用Jackson，需要导入它的jar包

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

  • 代码测试

    • 实体类User

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

    • UserController

      @Controller//走视图解析器
public class UserController {

    @RequestMapping("/j1")
    @ResponseBody //配合@Controller使用，不会走视图解析器，会直接返回一个字符串
   
    public String json1() throws JsonProcessingException {
        //jackson, ObjectMapoper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("小明", 20, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

    • 使用@RestController注解（相当于@Controller+ @ResponseBody）

      @RestController //以下方法不走视图解析器，只会返回JSON字符串
public class UserController {
    
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        //jackson, ObjectMapoper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("小明", 20, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

  • 将上述代码中的公共部分提到工具类中

    • JsonUtils类

      public class JsonUtils {

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

    public static String getJson(Object object,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();
        //使用ObjectMapper来格式化输出，不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);

        //自定义日期格式
        SimpleDateFormat sf = new SimpleDateFormat(dateFormat);

        mapper.setDateFormat(sf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        return null;
    }
}

    • 测试

      @RequestMapping("/j1")
public String json1() throws JsonProcessingException {
    User user = new User("小明", 20, "男");
    return JsonUtils.getJson(user);
}

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {

    List<User> userList = new ArrayList<User>();

    User user1 = new User("小明1", 20, "男");
    User user2 = new User("小明2", 20, "男");
    User user3 = new User("小明3", 20, "男");
    User user4 = new User("小明4", 20, "男");

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    return JsonUtils.getJson(userList);
}

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

    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

  • 出现了乱码问题，需要设置一下它的编码格式为utf-8，以及它返回的类型;

    • 方式一：通过@RequestMaping的produces属性来实现，修改下代码

      //prodeces:指定响应体返回类型和编码
@RequestMapping(value="/j1",produces="application/json;charset=utf-8")

    • 方式二（推荐）：可以通过Spring配置统一指定，这样就不用每次都去处理了!
      可以在springmvc的配置文件（springmvc-servlet.xml）上添加一段消息StringHttpMessageConverter转换配置

      <!--JSON乱码问题配置-->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>
9.4、Fastjson

  • 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三个主要的类:

    • JSONObject 代表json对象】
      • JSONObject实现了Map接口,猜想JSONObject底层操作是由Map实现的
      • JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()， isEmpty()等方法获取"键:值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
    • 【JSONArray 代表json对象数组】
      • 内部是有List接口中的方法来完成操作的。
    • 【JSON代表JSONObject和JSONArray的转化】
      • JSON类源码分析与使用
      • 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

  • 代码示例

    //fastjson
@RequestMapping("/j4")
public String json4(){

    User user = new User("小明", 20, "男");

    //Java对象 转 JSON字符串
    String s = JSON.toJSONString(user);

    //JSON字符串 转 Java对象
    User user1 = JSON.parseObject(s, User.class);

    //Java对象 转 JSON对象
    JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user);
    System.out.println(jsonObject1.getString("name"));

    //JSON对象 转 Java对象
    User user2 = JSON.toJavaObject(jsonObject1, User.class);

    return s;
}
Spring MVC笔记.md
04-03
将应用程序分为 Controller、Model、View 三层，Controller 接收客户端请求，调用 Model 生成业务数据，传递给 View。 Spring MVC 就是对这套流程的封装，屏蔽了很多底层代码，开放出接口，让开发者可以更加轻松、便捷地完成基于 MVC 模式的 Web 开发。
SpringMVC
weixin_43496474的博客
11-29 208
SpringMVC ssm: mybatis + Spring + SpringMVC MVC三层架构 Spring IOC 和 AOP SpringMVC : SpringMVC的执行流程 MVC 模型 (dao service) 视图(jsp) 控制器(Servlet) 是一种软件设计规范 **Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和
springmvc学习笔记(1)-框架原理和入门配置
热门推荐
brianway
03-08 1万+
本文主要介绍springmvc的框架原理，并通过一个入门程序展示环境搭建，配置以及部署调试。
SpringMVC的学习笔记（整合）
weixin_52938172的博客
06-18 2158
SpringMVC初学经历笔记
Spring-MVC笔记
m0_63475429的博客
04-01 950
SpringMVC是Spring的一个后续产品，是Spring的一个子项目 SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目表述层开发的首选方案。
springmvc完整笔记附带说明代码.pdf
12-28
3. 配置springmvc.xml文件，通常是通过开启注解驱动和组件扫描来完成的。这允许Spring MVC框架扫描指定包下的控制器类，并使用注解如@Controller来定义控制器。 4. 编写控制器类（Controller），使用@...
尚硅谷SpringMVC笔记
04-11
尚硅谷SpringMVC笔记
一、SpringMVC尚硅谷的笔记.md
08-20
springmvc 笔记
springmvc学习笔记
10-28
springmvc学习笔记
spring MVC笔记
04-12
spring MVC笔记spring MVC笔记spring MVC笔记spring MVC笔记
SpringMVC笔记.md
09-20
SpringMVC笔记，记录的比较完整，参考价值较高，大家共同进步
springmvc笔记
08-12
springmvc笔记 新建或拷贝applicationContext.xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
SpringMVC学习笔记.md
10-26
SpringMVC学习笔记.md
SpringMVC笔记
qq_49306008的博客
01-30 2243
SpringMVC笔记
SpringMVC笔记（自用）
shisannnn的博客
08-28 235
1.SpringMVC简介   SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门做web开发的。理解是servlet的一个升级   web开发底层是servlet，框架是在servlet基础上面加一些功能，让你做web开发方便。   springMVC就是一个Spring。Spring是一个容器，ioc能够管理对象，使用，@Component、@Respository、@Service、@Controller。因此，SpringMVC也能够创建对象，放入到（Sprin
SpringMVC-2-Controller和RestFul风格
baidu_38126306的博客
09-21 533
SpringMVC:Controller控制器、RestFul风格、重定向与转发、请求参数与数据回显、乱码处理
SpringMVC笔记总结
m0_73290584的博客
07-30 172
SpringMVC重点内容总结
SpringMVC狂神完整笔记精粹
资源摘要信息:"SpringMVC笔记.zip" 知识点一：SpringMVC框架概述 SpringMVC是Spring框架的一部分，用于构建web应用程序。它是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过分离模型、视图和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不懂可否

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值