SpringMVC完整版详解(springmvc简单介绍)

  本篇文章为你整理了SpringMVC完整版详解(springmvc简单介绍)的详细内容,包含有讲一下springmvc springmvc简单介绍 spring springmvc spring mvc详解 SpringMVC完整版详解,希望能帮助你了解 SpringMVC完整版详解。

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

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

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

  最典型的MVC就是JSP + servlet + javabean的模式。

  1.2Model1时代

  
Model2这样不仅提高的代码的复用率与项目的扩展性,且大大降低了项目的维护成本。Model 1模式的实现比较简单,适用于快速开发小规模项目,Model1中JSP页面身兼View和Controller两种角色,将控制逻辑和表现逻辑混杂在一起,从而导致代码的重用性非常低,增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。

  1.4回顾Servlet

  1.4.1新建Maven导入依赖

  

 dependencies 

 

   dependency

   groupId junit /groupId

   artifactId junit /artifactId

   version 4.13.1 /version

   /dependency

   dependency

   groupId org.springframework /groupId

   artifactId spring-webmvc /artifactId

   version 5.3.22 /version

   /dependency

   dependency

   groupId javax.servlet /groupId

   artifactId servlet-api /artifactId

   version 2.5 /version

   /dependency

   dependency

   groupId javax.servlet.jsp.jstl /groupId

   artifactId jstl /artifactId

   version 1.2 /version

   /dependency

   /dependencies

  

 

  1.4.2 建子项目

  为子项目添加Web

  1.4.3 编写一个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);

  

 

  1.4.4 编写Hello.jsp

  在WEB-INF目录下新建一个jsp的文件夹,新建test.jsp

  

 %@ page contentType="text/html;charset=UTF-8" language="java" % 

 

   html

   head

   title Kuangshen /title

   /head

   body

  ${msg}

   /body

   /html

  

 

  1.4.5 web.xml中注册Servlet

  

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

 

   web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

   version="4.0"

   servlet

   servlet-name hello /servlet-name

   servlet-class com.tang.servlet.HelloServlet /servlet-class

   /servlet

   servlet-mapping

   servlet-name hello /servlet-name

   url-pattern /hello /url-pattern

   /servlet-mapping

  
1.4.5编写form.jsp

  

 %@ page contentType="text/html;charset=UTF-8" language="java" % 

 

   html

   head

   title Title /title

   /head

   body

   form action="/hello" method="post"

   input type="text" name="method"

   input type="submit" name="method"

   /form

   /body

   /html

  

 

  1.4.6配置Tomcat,并启动测试

  
说明:

  常见的服务器端MVC框架有:Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF;常见前端MVC框架:vue、angularjs、react、backbone;由MVC演化出了另外一些模式如:MVP、MVVM 等等....

  2.什么是SpringMVC

  2.1、概述

  Spring MVC是Spring Framework的一部分,是基于Java实现MVC的轻量级Web框架。

  查看官方文档:https://docs.spring.io/spring-framework/docs/4.3.24.RELEASE/spring-framework-reference/html/

  我们为什么要学习SpringMVC呢?

  Spring MVC的特点:

  
Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

  DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解形式进行开发,十分简洁;

  正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等......所以我们要学习 .

  最重要的一点还是用的人多 , 使用的公司多 .

  2.2、中心控制器

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

  

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

 

  

 

  SpringMVC的原理如下图所示:

  

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

 

  

 

  2.3、SpringMVC执行原理

  
 

  图为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。

  
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

  
在这里先听一遍原理,不理解没有关系,我们马上来写一个对应的代码实现大家就明白了,如果不明白,那就写10遍,没有笨人,只有懒人!

  3.第一个MVC程序

  3.1、配置版

  


 ?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 的 配置文件!名称: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"

   /beans

  

 

  在springmvc-servlet.xml 添加 处理映射器

  

 bean / 

 

  

 

  继续添加添加 处理器适配器

  

 

 

   bean /

  

 

  继续添加 视图解析器

  

 

 

   !--视图解析器:DispatcherServlet给他的ModelAndView--

   bean id="InternalResourceViewResolver"

   !--前缀--

   property name="prefix" value="/WEB-INF/jsp/"/

   !--后缀--

   property name="suffix" value=".jsp"/

   /bean

  

 

  编写我们要操作业务Controller ,要么实现Controller接口,要么增加注解;需要返回一个ModelAndView,装数据,封视图;

  

//注意:这里我们先导入Controller接口

 

  public class HelloController implements Controller {

   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

   //ModelAndView 模型和视图

   ModelAndView mv = new ModelAndView();

   //封装对象,放在ModelAndView中。Model

   mv.addObject("msg", "HelloSpringMVC!");

   //封装要跳转的视图,放在ModelAndView中

   mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp

   return mv;

  

 

  将自己的类交给SpringIOC容器,注册bean

  

 !--Handler-- 

 

   bean id="/hello" /

  

 

  写要跳转的jsp页面,显示ModelandView存放的数据,以及我们的正常页面;

  

 %@ page contentType="text/html;charset=UTF-8" language="java" % 

 

   html

   head

   title Title /title

   /head

   body

  ${msg}

   /body

   /html

  

 

  配置Tomcat 启动测试!

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

  
小结:看这个估计大部分同学都能理解其中的原理了,但是我们实际开发才不会这么写,不然就疯了,还学这个玩意干嘛!我们来看个注解版实现,这才是SpringMVC的精髓,到底有多么简单,看这个图就知道了

  3.2、注解版

  
?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

   /web-app

  

 

  
?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.tang.controller"/

   !-- 让Spring MVC不处理静态资源 --

   mvc:default-servlet-handler /

   支持mvc注解驱动

   在spring中一般采用@RequestMapping注解来完成映射关系

   要想使@RequestMapping注解生效

   必须向上下文中注册DefaultAnnotationHandlerMapping

   和一个AnnotationMethodHandlerAdapter实例

   这两个实例分别在类级别和方法级别处理。

   而annotation-driven配置帮助我们自动完成上述两个实例的注入。

   mvc:annotation-driven /

   !-- 视图解析器 --

   bean id="internalResourceViewResolver"

   !-- 前缀 --

   property name="prefix" value="/WEB-INF/jsp/" /

   !-- 后缀 --

   property name="suffix" value=".jsp" /

   /bean

   /beans

  

 

 

  
创建Controller
 

  编写一个Java控制类:com.kuang.controller.HelloController , 注意编码规范

  

@Controller

 

  public class HelloController {

   //真实访问地址 : 项目名/h1

   @RequestMapping("/h1")

   public String sayHello(Model model){

   //向模型中添加属性msg与值,可以在JSP页面中取出并渲染

   model.addAttribute("msg","hello,SpringMVC");

   //web-inf/jsp/hello.jsp

   return "hello";

  

 

  
@RequestMapping是为了映射请求路径,这里因为类与方法上都有映射所以访问时应该是/HelloController/hello;

  
方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

  
创建视图层
 

  在WEB-INF/ jsp目录中创建hello.jsp , 视图可以直接取出并展示从Controller带回的信息;

  可以通过EL表示取出Model中存放的值,或者对象;

  

 

 

   %@ page contentType="text/html;charset=UTF-8" language="java" %

   html

   head

   title SpringMVC /title

   /head

   body

  ${msg}

   /body

   /html

  

 

  测试结果图

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

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

  
4.1实现Controller接口

  Controller是一个接口,在org.springframework.web.servlet.mvc包下,接口中只有一个方法;

  新建一个Moudle,SpringMVC-04-controller 。将刚才的03 拷贝一份, 我们进行操作!

  
编写一个Controller类,ControllerTest1

  

public class ControllerTest1 implements Controller {

 

   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

   ModelAndView mv = new ModelAndView();

   mv.addObject("msg","ControllerTest1");

   mv.setViewName("test");

   return mv;

  

 

  编写完毕后,去Spring配置文件中注册请求的bean;name对应请求路径,class对应处理请求的类

  

 bean name="/t1" /bean 

 

  

 

  编写前端test.jsp,注意在WEB-INF/jsp目录下编写,对应我们的视图解析器

  

 %@ page contentType="text/html;charset=UTF-8" language="java" % 

 

   html

   head

   title Title /title

   /head

   body

  ${msg}

   /body

   /html

  

 

  配置Tomcat运行测试,我这里没有项目发布名配置的就是一个 / ,所以请求不用加项目名,OK!

  4.2使用注解@Controller

  
@Controller注解类型用于声明Spring类的实例是一个控制器(在讲IOC时还提到了另外3个注解);

  
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类,为了保证Spring能找到你的控制器,需要在配置文件中声明组件扫描。

  


 !-- 自动扫描包,让指定包下的注解生效,由IOC容器统一管理 -- 

 

   context:component-scan base-package="com.tang.controller"/

  

 

  增加一个ControllerTest2类,使用注解实现;

  

@Controller

 

  public class ControllerTest2 {

   //映射访问路径

   @RequestMapping("/t2")

   public String test(Model model){

   //Spring MVC会自动实例化一个Model对象用于向视图中传值

   model.addAttribute("msg","ControllerTest2");

   //返回视图位置

   return "test";

  

 

  运行tomcat测试

  
 

  可以发现,我们的两个请求都可以指向一个视图,但是页面结果的结果是不一样的,从这里可以看出视图是被复用的,而控制器与视图之间是弱偶合关系。

  注解方式是平时使用的最多的方式!

  4.3RestFul风格

  概念

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

  功能

  资源:互联网所有的事物都可以被抽象为资源

  资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作。

  分别对应 添加、 删除、修改、查询。

  传统方式操作资源 :通过不同的参数来实现不同的效果!方法单一,post 和 get

  

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

 

  http://127.0.0.1/item/saveItem.action 新增,POST

  http://127.0.0.1/item/updateItem.action 更新,POST

  http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

  

 

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

  

 

  学习测试

  在新建一个类 RestFulController

  4.4结果跳转方式

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

  测试前,需要将视图解析器注释掉

  

@Controller

 

  public class ResultSpringMVC {

   @RequestMapping("/rsm/t1")

   public String test1(){

   //转发

   return "/index.jsp";

   @RequestMapping("/rsm/t2")

   public String test2(){

   //转发二

   return "forward:/index.jsp";

   @RequestMapping("/rsm/t3")

   public String test3(){

   //重定向

   return "redirect:/index.jsp";

  

 

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

  重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.

  可以重定向到另外一个请求实现 .

  

@Controller

 

  public class ResultSpringMVC2 {

   @RequestMapping("/rsm2/t1")

   public String test1(){

   //转发

   return "test";

   @RequestMapping("/rsm2/t2")

   public String test2(){

   //重定向

   return "redirect:/index.jsp";

   //return "redirect:hello.do"; //hello.do为另一个请求/

  

 

  4.5数据处理

  处理提交数据

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

  提交数据 : http://localhost:8080/SpringMVC_04_controller_war_exploded/user/t1?name=Twq

  处理方法 :

  

@RequestMapping("/user")

 

  public class UserController {

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

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

  

@Controller

 

  @RequestMapping("/user")

  public class UserController {

  
@GetMapping("/t1")

   public String test1(@RequestParam("username") String name, Model model){

   //1.接收前端参数

   System.out.println("接收到的前端的参数为:" +name);

   //2.返回的结果传递给前端

   model.addAttribute("msg",name);

   //3.视图跳转

   return "test";

  

 

  4.5.4提交的是一个对象

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

  

@Data

 

  @AllArgsConstructor

  @NoArgsConstructor

  public class User {

   private int id;

   private String name;

   private int age;

  

 

  测试代码

  

//前端接受的是一个对象:id,name,age

 

   1.接收前端用户传的参数,判断参数的名字,假设名字直接在方法上,可以直接使用

   2.假设出阿尼的是一个对象User,匹配User对象中的字段名:如果名字一致则OK,否则,匹配不到

   @GetMapping("/t2")

   public String test2(User user){

   System.out.println(user);

   return "test";

  

 

  4.6乱码问题解决

  

@Controller

 

  public class EncodingController {

   @PostMapping("e1/t1")

   public String test(String name,Model model){

   model.addAttribute("msg",name);

   return "test";

  

 

  提交界面

  

 body 

 

   form action="e1/t1" method="post"

   用户名 input type="text" name="name"

   input type="submit"

   /form

   /body

  

 

  测试结果

  
 

  解决方法
 

  在web.xml中配置SpringMVC的乱码的过滤

  

 !--配置SpringMVC的乱码过滤 -- 

 

   filter

   filter-name encoding /filter-name

   filter-class org.springframework.web.filter.CharacterEncodingFilter /filter-class

   init-param

   param-name encoding /param-name

   param-value utf-8 /param-value

   /init-param

   /filter

   filter-mapping

   filter-name encoding /filter-name

   url-pattern /* /url-pattern

   /filter-mapping

  

 

  在启动Tomcat测试

  
 

  如果以上方法还是解决不了,可以自定义以下过滤器,以下代码建议全部复制,如果让IDEA自动导包的话可能会倒错包,以下代码为网上大牛写的,实在不行的情况下建议使用

  

package com.tang.filter;//这一行除外,根据自己的包名写

 

  import javax.servlet.*;

  import javax.servlet.http.HttpServletRequest;

  import javax.servlet.http.HttpServletRequestWrapper;

  import javax.servlet.http.HttpServletResponse;

  import java.io.IOException;

  import java.io.UnsupportedEncodingException;

  import java.util.Map;

   * 解决get和post请求 全部乱码的过滤器

  public class GenericEncodingFilter implements Filter {

  
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

   //处理response的字符编码

   HttpServletResponse myResponse=(HttpServletResponse) response;

   myResponse.setContentType("text/html;charset=UTF-8");

   // 转型为与协议相关对象

   HttpServletRequest httpServletRequest = (HttpServletRequest) request;

   // 对request包装增强

   HttpServletRequest myrequest = new MyRequest(httpServletRequest);

   chain.doFilter(myrequest, response);

  
//自定义request对象,HttpServletRequest的包装类

  class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;

   //是否编码的标记

   private boolean hasEncode;

   //定义一个可以传入HttpServletRequest对象的构造函数,以便对其进行装饰

   public MyRequest(HttpServletRequest request) {

   super(request);// super必须写

   this.request = request;

   // 对需要增强方法 进行覆盖

   @Override

   public Map getParameterMap() {

   // 先获得请求方式

   String method = request.getMethod();

   if (method.equalsIgnoreCase("post")) {

   // post请求

   try {

   // 处理post乱码

   request.setCharacterEncoding("utf-8");

   return request.getParameterMap();

   } catch (UnsupportedEncodingException e) {

   e.printStackTrace();

   } else if (method.equalsIgnoreCase("get")) {

   // get请求

   Map String, String[] parameterMap = request.getParameterMap();

   if (!hasEncode) { // 确保get手动编码逻辑只运行一次

   for (String parameterName : parameterMap.keySet()) {

   String[] values = parameterMap.get(parameterName);

   if (values != null) {

   for (int i = 0; i values.length; i++) {

   try {

   // 处理get乱码

   values[i] = new String(values[i]

   .getBytes("ISO-8859-1"), "utf-8");

   } catch (UnsupportedEncodingException e) {

   e.printStackTrace();

   hasEncode = true;

   return parameterMap;

   return super.getParameterMap();

   //取一个值

   @Override

   public String getParameter(String name) {

   Map String, String[] parameterMap = getParameterMap();

   String[] values = parameterMap.get(name);

   if (values == null) {

   return null;

   return values[0]; // 取回参数的第一个值

   //取所有值

   @Override

   public String[] getParameterValues(String name) {

   Map String, String[] parameterMap = getParameterMap();

   String[] values = parameterMap.get(name);

   return values;

  

 

  web.xml注册该过滤器

  

 filter 

 

   filter-name encoding /filter-name

   filter-class com.tang.filter.GenericEncodingFilter /filter-class

   /filter

   filter-mapping

   filter-name encoding /filter-name

   url-pattern /* /url-pattern

   /filter-mapping

  

 

  6.JSON

  6.1什么是JSON

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

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

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

  

{"name": "QinJiang"}

 

  {"age": "3"}

  {"sex": "男"}

  

 

  很多人搞不清楚 JSON 和 JavaScript 对象的关系,甚至连谁是谁都不清楚。其实,可以这么理解:

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

  

var obj = {a: Hello,

 

   b: World}; //这是一个对象,注意键名也是可以使用引号包裹的

  var json = {"a": "Hello",

  "b": "World"}; //这是一个 JSON 字符串,本质是一个字符串

  

 

  JSON 和 JavaScript 对象互转
 

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

  

var obj = JSON.parse({"a": "Hello", "b": "World"});

 

  //结果是 {a: Hello, b: World}

  

 

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

  

var json = JSON.stringify({a: Hello, b: World});

 

  //结果是 {"a": "Hello", "b": "World"}

  

 

  代码测试

  
 

 

  6.2Jackson使用

  Jackson应该是目前比较好的json解析工具了

  当然工具不止这一个,比如还有阿里巴巴的 fastjson 等等。

  我们这里使用Jackson,使用它需要导入它的jar包;

  

 dependency 

 

   groupId com.fasterxml.jackson.core /groupId

   artifactId jackson-databind /artifactId

   version 2.13.3 /version

   /dependency

  

 

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

  

 

  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.tang.controller"/

   context:annotation-config /

   mvc:annotation-driven /

   !-- 视图解析器 --

   bean id="internalResourceViewResolver"

   !-- 前缀 --

   property name="prefix" value="/WEB-INF/jsp/" /

   !-- 后缀 --

   property name="suffix" value=".jsp" /

   /bean

   /beans

  

 

  这里我们需要两个新东西,一个是@ResponseBody,一个是ObjectMapper对象,我们看下具体的用法

  编写一个Controller;

  

package com.tang.controller;

 

  import com.fasterxml.jackson.core.JsonProcessingException;

  import com.fasterxml.jackson.databind.ObjectMapper;

  import com.tang.pojo.User;

  import org.springframework.stereotype.Controller;

  import org.springframework.web.bind.annotation.RequestMapping;

  import org.springframework.web.bind.annotation.ResponseBody;

  @Controller

  public class UserController {

   @RequestMapping("/j1")

   @ResponseBody

   public String test() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   User user = new User("唐三", 2, "女");

   String str = mapper.writeValueAsString(user);

   return str;

  
 

 

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

  通过@RequestMaping的produces属性来实现,修改下代码

  

//produces:指定响应体返回类型和编码

 

  @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

  

 

  再次测试发现乱码问题解决

  乱码统一解决

  上一种方法比较麻烦,如果项目中有许多请求则每一个都要添加,可以通过Spring配置统一指定,这样就不用每次都去处理了!

  我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置!

  

 mvc:annotation-driven 

 

   mvc:message-converters register-defaults="true"

   bean

   constructor-arg value="UTF-8"/

   /bean

   bean

   property name="objectMapper"

   bean

   property name="failOnEmptyBeans" value="false"/

   /bean

   /property

   /bean

   /mvc:message-converters

   /mvc:annotation-driven

  

 

  返回json字符串统一解决

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

  

@RestController

 

  public class UserController {

   //produces:指定响应体返回类型和编码

   @RequestMapping(value = "/json1")

   public String json1() throws JsonProcessingException {

   //创建一个jackson的对象映射器,用来解析数据

   ObjectMapper mapper = new ObjectMapper();

   //创建一个对象

   User user = new User("秦疆1号", 3, "男");

   //将我们的对象解析成为json格式

   String str = mapper.writeValueAsString(user);

   //由于@ResponseBody注解,这里会将str转成json格式返回;十分方便

   return str;

  

 

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

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

  
仔细观察这些方法,主要是实现json对象,json对象数组,javabean对。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: