SpringMVC学习笔记

1、回顾MVC 1.1、什么是MVC

• MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。

• 是将业务逻辑、数据、显示分离的方法来组织代码。

• MVC主要作用是降低了视图与业务逻辑间的双向偶合。

• MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

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

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

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

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

1.2、Model1时代

• 在web早期的开发中，通常采用的都是Model1。

• Model1中，主要分为两层，视图层和模型层。
  

Model1优点：架构简单，比较适合小型项目开发；

Model1缺点：JSP职责不单一，职责过重，不便于维护；

1.3、Model2时代

Model2把一个项目分成三部分，包括视图、控制、模型。

1.用户发请求

2.Servlet接收请求数据，并调用对应的业务逻辑方法

3.业务处理完毕，返回更新后的数据给servlet

4.servlet转向到JSP，由JSP来渲染页面

5.响应给前端更新后的页面

职责分析：

Controller：控制器

取得表单数据

调用业务逻辑

转向指定的页面

Model：模型

业务逻辑

保存数据的状态

View：视图

显示页面

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

1.4 回顾Servlet

1.新建一个Maven工程当做父工程！pom依赖！

        
            junit
            junit
            4.12
            test
        
        
            org.springframework
            spring-webmvc
            5.2.1.RELEASE
        
        
            javax.servlet
            servlet-api
            2.5
        
        
        
            javax.servlet
            jstl
            1.2
        
    
    
    
    
        
            
                src/main/java
                
                    ***.json
                
            
            
                src/main/resources
                
                    ***.xml
                
                false
            
        
    

2.个Moudle：springmvc-01-servlet ， 项目右键 添加Web app的支持！

3.导入jsp的jar包支持（已导入）
4.编写一个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);
    }
}

5.编写Hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp
form.jsp

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


    



    
    

6.在web.xml中注册Servlet

    
        hello
        com.kuang.servlet.HelloServlet
    
    
        hello
        /hello
    

MVC框架要做哪些事情

• 将url映射到java类或java类的方法 .

• 封装用户提交的数据 .

• 处理请求–调用相关的业务处理–封装响应数据 .

• 将响应的数据进行渲染 . jsp / html 等表示层数据 .

说明：

常见的服务器端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框架。

Spring MVC的特点：
1.轻量级，简单易学
2.高效 , 基于请求响应的MVC框架
3.与Spring兼容性好，无缝结合
4.约定大于配置
5.功能强大：RESTful、数据验证、格式化、本地化、主题等
6.简洁灵活

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。

HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

Handler让具体的Controller执行。

Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

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

视图解析器将解析的逻辑视图名传给DispatcherServlet。

DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

最终视图呈现给用户。

第一个MVC程序

1、新建一个Moudle ， springmvc-02-hello ， 添加web的支持！
2、确定导入了SpringMVC 的依赖！
3、配置web.xml ， 注册DispatcherServlet

    
        springmvc
        org.springframework.web.servlet.DispatcherServlet

        
            contextConfigLocation
            classpath:springmvc-servlet.xml
        

        1
    
    

    
        System.out.println(user);
        return "test";
    }

后台输出 : User { id=1, name=‘李白’, age=15 }
说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

数据显示到前端
第一种 : 通过ModelAndView

public class ControllerTest1 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

第二种 : 通过ModelMap

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("name",name);
   System.out.println(name);
   return "hello";
}

第三种 : 通过Model

Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
   //1.接收前端参数----如果前端的字段命名和String后面一样，则不需要@RequestParam("username")
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("msg",name);
    //2.将返回的结果传递给前端
   System.out.println(name);
   //3.视图跳转
   return "test";

}

对比
Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 linkedMap ，除了实现了自身的一些方法，同样的继承 linkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

乱码问题

@Controller
public class Encoding {
   @RequestMapping("/e/t")
   public String test(Model model,String name){
       model.addAttribute("msg",name); //获取表单提交的值
       return "test"; //跳转到test页面显示输入的值
  }
}

自己写简单的过滤器

public class EncodingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        request.setCharacterEncoding("utf-8");
        chain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

SpringMVC给我们提供的一个过滤器 , 可以在web.xml中配置 .（修改了xml文件需要重启服务器！）

   encoding
   org.springframework.web.filter.CharacterEncodingFilter
   
       encoding
       utf-8
   


   encoding
   
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

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

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
  }

}

//自定义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 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 parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回参数的第一个值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

Json交互处理

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

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

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

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

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

• 对象表示为键值对，数据由逗号分隔

• 花括号保存对象

• 方括号保存数组

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

{"name": "libai"}
{"age": "3"}
{"sex": "男"}

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

代码测试

Jackson应该是目前比较好的json解析工具了
当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。
我们这里使用Jackson，使用它需要导入它的jar包；

   com.fasterxml.jackson.core
   jackson-databind
   2.9.8

配置SpringMVC需要的配置

web.xml

   
   
       SpringMVC
       org.springframework.web.servlet.DispatcherServlet
       
       
           contextConfigLocation
           classpath:springmvc-servlet.xml
       
       
       1
   

   
   
       SpringMVC
       /
   

   
       encoding
       org.springframework.web.filter.CharacterEncodingFilter
       
           encoding
           utf-8
       
   
   
       encoding
       /
   

配置 springmvc-servlet.xml

写一个User的实体类，然后我们去编写我们的测试Controller

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

   private String name;
   private int age;
   private String sex;
   
}

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

编写一个Controller；

//@Controller +   @ResponseBody  只走json
//或者RestController   只走json

//@Controller//只会走视图解析器
@RestController//不走视图解析器，只返回json
public class UserController {

    @RequestMapping("/j1") //produces解决json乱码问题
    //@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    @ResponseBody//他就不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //jackson,objectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("李白",20,"男");
        String str = mapper.writevalueAsString(user);
        return str;
    }

    @RequestMapping("/j2")
    @ResponseBody
    public String json2() throws JsonProcessingException {
        //jackson,objectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user1 = new User("李1白",20,"男");
        User user2 = new User("李2白",20,"男");
        User user3 = new User("李3白",20,"男");
        User user4 = new User("李4白",20,"男");
        List userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

//        String str = mapper.writevalueAsString(userList);
//        return str;
        //调用自己写的工具类
        return JsonUtils.getJson(userList);

    }

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

        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);

        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        mapper.setDateFormat(sdf);
		
		//创建时间一个对象，java.util.Date
        Date date = new Date();
        //ObjectMapper,时间解析后的默认格式为：Timetamp，时间戳   :从1970年一月一日现在的毫秒数
        //将我们的对象解析成为json格式
        return mapper.writevalueAsString(date);
    }
	//使用自己抽取的工具类，，，，JsoUtils在下边
    @RequestMapping("/j4")
    @ResponseBody
    public String json4() throws JsonProcessingException {

        Date date = new Date();
        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }

    // 使用阿里的  fastJSON  
    @RequestMapping("/j5")
    public String json5() throws JsonProcessingException {

        List userList = new ArrayList<>();
        //创建一个对象
        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);

        String string = JSON.toJSONString(userList);
        return string;

    }

}

抽取为工具类
如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

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

public class JsonUtils {
   //实现代码复用利用return的调用
   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();
       //不使用时间差的方式
       mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
       //自定义日期格式对象
       SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
       //指定日期格式
       mapper.setDateFormat(sdf);
       try {
           return mapper.writevalueAsString(object);
      } catch (JsonProcessingException e) {
           e.printStackTrace();
      }
       return null;
  }
}
我们使用工具类，代码就更加简洁了！
@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
   Date date = new Date();
   String json = JsonUtils.getJson(date);
   return json;
}

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

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

fastjson 的 pom依赖

   com.alibaba
   fastjson
   1.2.60

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字符串之间的相互转化。

代码如上边@RequestMapping("/j5") public String json5()