SpringMVC

ssm: mybatis + Spring + SpringMVC MVC三层架构

JavaSE:认真学习，老师带，入门快

JAVAWeb：认真学习，老师带，入门快

框架：研究官方文档，锻炼自学能力，锻炼笔记能力，锻炼项目能力

SpringMVC + Vue + SpringBoot +SpringCloud +Linux

SSM = JavaWeb做项目；

Spring : IOC 和 AOP

SpringMVC: SpringMVC的执行流程！

SpringMVC:SSM框架整合！

MVC:模型（dao,service）视图（jsp）控制器（Servlet）

dao

service

servlet:转发，重定向

jsp/html

前端 数据传输 实体类

实体类：用户名，密码，生日，爱好......20个

前端：用户名 密码

pojo:User

vo:UserVo

dto

JSP:本质就是一个Servlet

假设：你的项目的架构，是设计好的，还是演进的？

• Alibaba PHP
• 随着用户大，Java
• 王坚 去 IOE MySQL
• MySQL: MySQL--->AliSQL、AliRedis
• All in one --->微服务

1、回顾Servlet

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

    
        
            junit
            junit
            4.12
        
        
            org.springframework
            spring-webmvc
            5.3.19
        
        
            javax.servlet
            servlet-api
            2.5
        
        
            javax.servlet.jsp
            jsp-api
            2.2
        
        
            javax.servlet
            jstl
            1.2
        
    

2.新建一个Moudle:springmvc-01-servlet,添加Web app的支持！（通过Maven创建，会出现版本不一致的问题，需要改，麻烦）

 

 

 3.导入servlet和jsp的jar依赖

        
            javax.servlet
            servlet-api
            2.5
        
        
            javax.servlet.jsp
            jsp-api
            2.2
        
 

4.编写一个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").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

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


    


    ${msg}

6.在web.xml中注册Servlet

    
        hello
        com.kuang.servlet.HelloServlet
    
    
        hello
        /hello
    

7.配置Tomcat,并启动测试

MVC框架要做哪些事

1. 将url映射到java类或java类的方法
2. 封装用户提交的数据
3. 处理请求--调用相关的业务处理--封装响应数据
4. 将响应的数据进行渲染.jsp/.html等表示层数据

说明 ：

常见的服务器端MVC框架有: Struts、Spring MVC、ASP.NET MVC、Zend Framework,JSF;

常见前端MVC框架: vue、angularjs、react, backbone; 由MVC演化出了另外一些模式如: MVP、MVVM等等...

全栈：后台+前端+数据库+运维

前端：后台+前端

Python != 人工智能

MVC:

MVVM : M V VM ViewModel 双向绑定

2、什么是SpringMVC

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

官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/web.html

2.1、我们为什么要学习SpringMVC呢？

Spring MVC的特点：

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

Spring:大杂烩，我们可以将SpringMVC中所有要用到的bean,注册到Spring中！ 

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

2.2、中心控制器

Spring的web框架围绕DispatcherServlet！【调度Servlet】设计。DispatcherServlet的作用是将请求分发到不同的处理器（不同的方法和类）。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

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

 

SpringMVC的原理如下图所示：

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

图为SpringMVC的一个较完整地流程图，实现表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程 

1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

• 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello。
• 如上url拆分成三部分:
• http://localhost:8080服务器域名. SpringMVC部署在服务器上的web站点
• hello表示控制器（Handler）
• 通过分析，如上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.Hello SpringMVC 3.1、配置版

1.新建一个Moudle,添加web的支持！

2.确定导入了SpringMVC的依赖！

3.配置web.xml，注册DispatcherServlet

在SpringMVC中，/：只匹配所有的请求，不会去匹配jsp页面 *.properties ***.properties **/*.xml false

3、在pom.xml文件引入相关的依赖：主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！

4、配置web.xml

注意点：

• 注意web.xml版本问题，要最新版！

• 注册DispatcherServlet

• 关联SpringMVC的配置文件

• 启动级别为1

• 映射路径为 / 【不要用/*，会404】

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

   
   
       SpringMVC
       /
   

5、添加Spring MVC配置文件

在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：

• 让IOC的注解生效

• 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 .....

• MVC的注解驱动

• 配置视图解析器

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

真实开发中，不需要显示定义处理器映射器和处理器适配器，这里只是为了看原理而显示定义了

6、创建Controller

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

package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/HelloController")
public class HelloController {

   //真实访问地址 : 项目名/HelloController/hello
   @RequestMapping("/hello")
   public String sayHello(Model model){
       //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
       model.addAttribute("msg","hello,SpringMVC");
       //web-inf/jsp/hello.jsp
       return "hello";
  }
}

7、创建视图层

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

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

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


   


${msg}

 
8、配置Tomcat运行
 
配置Tomcat ，  开启服务器 ， 访问 对应的请求路径！
 
 
OK，运行成功！ 
 
可能遇到的问题：启动Tomcat，报错：“Java:不支持发行版本5”解决方案：
 
 
小结 
实现步骤其实非常的简单：
 
 
新建一个web项目
 
 
导入相关jar包
 
 
编写web.xml , 注册DispatcherServlet
 
 
编写springmvc配置文件
 
 
接下来就是去创建对应的控制类 , controller
 
 
最后完善前端视图和controller之间的对应
 
 
测试运行调试.
 
使用springMVC必须配置的三大件：
 
处理器映射器、处理器适配器、视图解析器
 
通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置
 
4、Controller及RestFul风格 
控制器Controller 
 
控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
 
 
控制器负责解析用户的请求并将其转换为一个模型。
 
 
在Spring MVC中一个控制器类可以包含多个方法
 
 
在Spring MVC中，对于Controller的配置方式有很多种
 
4.1、实现Controller接口 
Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法
 
//实现该接口的类获得控制器功能
public interface Controller {
   //处理请求且返回一个模型与视图对象
   ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}
 
测试
 
1.新建一个Moudle，springmvc-04-controller 。将刚才的03 拷贝一份, 我们进行操作！
 
删掉HelloController
mvc的配置文件只留下 视图解析器！
2.编写一个Controller类，ControllerTest1
 
//定义控制器
//注意点：不要导错包，实现Controller接口，重写方法；
public class ControllerTest1 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","Test1Controller");
       mv.setViewName("test");
       return mv;
  }
}
 
3.编写完毕后，去Spring配置文件中注册请求的bean；name对应请求路径，class对应处理请求的类
 
 
 4.编写前端test.jsp，注意在WEB-INF/jsp目录下编写，对应我们的视图解析器
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


   


${msg}

 
 5.配置Tomcat运行测试，我这里没有项目发布名配置的就是一个 / ，所以请求不用加项目名，OK！
 
 
说明：
 
 
实现接口Controller定义控制器是较老的办法
 
 
缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；
 
4.2、使用注解@Controller 
 
@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解@Component 组件@Service service@Controller controller@Repository dao）；
 
 
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。
 

 
 增加一个ControllerTest2类，使用注解实现
@Controller//代表这个类会被Spring接管，被这个注解的类中的所有方法，如果返回值是String,并且有具体页面可以跳转，那么就会被视图解析器解析；
public class ControllerTest2  {
    @RequestMapping("/t2")
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest2");
        return "test";//WEB-INF/jsp/test.jsp
    }
}
 
运行tomcat测试
 
 
视图复用： 
 
@Controller//代表这个类会被Spring接管，被这个注解的类中的所有方法，如果返回值是String,并且有具体页面可以跳转，那么就会被视图解析器解析；
public class ControllerTest2  {
    @RequestMapping("/t2")
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest2");
        return "test";//WEB-INF/jsp/test.jsp
    }

    @RequestMapping("/t3")
    public String test2(Model model){
        model.addAttribute("msg","ControllerTest3");
        return "test";//WEB-INF/jsp/test.jsp
    }
}
 
可以发现，我们的两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。
 
注解方式是平时使用的最多的方式！
 
4.3、RequestMapping 
@RequestMapping
 
 
@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
 
 
为了测试结论更加准确，我们可以加上一个项目名测试 myweb
 
 
只注解在方法上面
 
@Controller
public class TestController {
   @RequestMapping("/h1")
   public String test(){
       return "test";
  }
}
 
 
访问路径：http://localhost:8080 / 项目名 / h1
 
 
同时注解类与方法
 
@Controller
@RequestMapping("/admin")
public class TestController {
   @RequestMapping("/h1")
   public String test(){
       return "test";
  }
}
 
访问路径：http://localhost:8080 / 项目名/ admin /h1  , 需要先指定类的路径再指定方法的路径
 
4.4、RestFul 风格 
概念
 
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
 
学习测试 
 
1.原来的方式:http://localhost:8080/add?a=1&b=2
 
@Controller
public class RestfulController {
    //原来的：http://localhost:8080/add?a=1&b=2
    @RequestMapping("/add")
    public String test1(int a, int b, Model model){
        int res = a + b;
        model.addAttribute("msg","结果为" + res);
        return "test";
    }
}
 
2.RestFul:http://localhost:8080/add/1/2
 
@Controller
public class RestfulController {
    //RestFul: http://localhost:8080/add/1/2
    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a + b;
        model.addAttribute("msg","结果为" + res);
        return "test";
    }
}
 
3.我们来测试请求查看下 
 
 
 
4.思考：使用路径变量的好处？
 
使路径变得更加简洁，更安全！
获得参数更加方便，框架会自动进行类型转换。
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/add/1/a，则路径与方法不匹配，而不会是参数转换失败。
 
5.我们来修改下对应的参数类型，再次测试 
 
 
 
使用method属性指定请求类型
 
用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等
 
我们来测试一下：
 
 
增加一个方法
 
//映射访问路径,必须是POST请求
@RequestMapping(value = "/hello",method = {RequestMethod.POST})
public String index2(Model model){
   model.addAttribute("msg", "hello!");
   return "test";
}
 
 
我们使用浏览器地址栏进行访问默认是Get请求，会报错405：
 
 
 
如果将POST修改为GET则正常了；
 
//映射访问路径,必须是Get请求
@RequestMapping(value = "/hello",method = {RequestMethod.GET})
public String index2(Model model){
   model.addAttribute("msg", "hello!");
   return "test";
}
 
 
小结：
 
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。
 
所有的地址栏请求默认都会是 HTTP GET 类型的。
 
方法级别的注解变体有如下几个：组合注解
 
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
 
@GetMapping 是一个组合注解，平时使用的会比较多！
 
它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
 
如果是这样：
 
@Controller
public class RestfulController {
    //原来的：http://localhost:8080/add?a=1&b=2
    //RestFul: http://localhost:8080/add/1/2
//    @RequestMapping(name = "/add/{a}/{b}",method = RequestMethod.DELETE)
    @PostMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable String b, Model model){
        String res = a + b;
        model.addAttribute("msg","结果1为" + res);
        return "test";
    }
    @GetMapping ("/add/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable String b, Model model){
        String res = a + b;
        model.addAttribute("msg","结果2为" + res);
        return "test";
    }
}
 
 
post方式提交数据 
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


 

     
     
     
 

 
 
 
如果是这样：
 
@Controller
public class RestfulController {
    @RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
    public String test1(@PathVariable int a,@PathVariable String b, Model model){
        String res = a + b;
        model.addAttribute("msg","结果1为" + res);
        return "test";
    }
    @GetMapping ("/add/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable String b, Model model){
        String res = a + b;
        model.addAttribute("msg","结果2为" + res);
        return "test";
    }
}
 
就会报错：无法抉择的问题，一个GET请求，后台有两个处理办法，不知道走哪一个，就会报错
 
 
扩展：小黄鸭调试法 
 
场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。
 
场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候就想出答案走了，留下一脸茫然的你。
 
其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它是我们软件工程中最常使用调试方法之一。
 
 
此概念据说来自《程序员修炼之道》书中的一个故事，传说程序大师随身携带一只小黄鸭，在调试代码的时候会在桌上放上这只小黄鸭，然后详细地向鸭子解释每行代码，然后很快就将问题定位修复了。
 
5、结果跳转方式 
5.1、ModelAndView 
设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .
 
页面 : {视图解析器前缀} + viewName +{视图解析器后缀}
 


   
   
   
   
 
对应的controller类
 
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;
  }
}
 
5.2、ServletAPI 
通过设置ServletAPI , 不需要视图解析器。
 
1、通过HttpServletResponse进行输出
 
2、通过HttpServletResponse实现重定向
 
3、通过HttpServletResponse实现转发
 
@Controller
public class ResultGo {

   @RequestMapping("/result/t1")
   public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.getWriter().println("Hello,Spring BY servlet API");
  }

   @RequestMapping("/result/t2")
   public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.sendRedirect("/index.jsp");
  }

   @RequestMapping("/result/t3")
   public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
       //转发
       req.setAttribute("msg","/result/t3");
       req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
  }

}
 
 5.3、SpringMVC 
通过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为另一个请求/
  }

}
 
6、数据处理 
6.1、处理提交数据 
1、提交的域名称和处理方法的参数名一致 
提交数据 : http://localhost:8080/hello?name=kuangshen
 
处理方法 :
 
@RequestMapping("/hello")
public String hello(String name){
   System.out.println(name);
   return "hello";
}
 
后台输出 : kuangshen
 
2、提交的域名称和处理方法的参数名不一致 
提交数据 : http://localhost:8080/hello?username=kuangshen
 
处理方法 :
 
//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
   System.out.println(name);
   return "hello";
}
 
后台输出 : kuangshen
 
养成好习惯，不管域名称和处理方法的参数名一不一致，都把@RequestParam加上，表示这是前端会用到的参数！
 
3、提交的是一个对象 
要求提交的表单域和对象的属性名一致  , 参数使用对象即可
 
1、实体类
 
public class User {
   private int id;
   private String name;
   private int age;
   //构造
   //get/set
   //tostring()
}
 
2、提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15
 
3、处理方法 :
 
@RequestMapping("/user")
public String user(User user){
   System.out.println(user);
   return "hello";
}
 
后台输出 : User { id=1, name='kuangshen', age=15 }
 
说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null
 
总结：
 
1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用。
 
2.假设传递的是一个对象User，匹配User对象中的字段名：如果名字一致则OK，否则，匹配不到。
 
7、数据显示到前端 
7.1、 通过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;
  }
}
 
 7.2、 通过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";
}
 
  7.3、 通过Model 
Model
 
@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("msg",name);
   System.out.println(name);
   return "test";
}
 
对比 
就对于新手而言简单来说使用区别就是：
 
Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。
 
 当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。
 
请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程