开发者学堂课程【高校精品课-上海交通大学 -互联网应用开发技术：MVC 1】学习笔记，与课程紧密联系，让用户快速学习知识。
课程地址：https://developer.aliyun.com/learning/course/76/detail/15766
MVC 2
内容介绍
一、Struts框架的模型
二、spring框架模型
一、Struts框架的模型
1.前端输入原理
上节课讲的MVC ，从知识的完整性的角度来说肯定要讲MVC ，现在讲的前后端是隔离的，前端是一个React分层，后端是引用spring或者是用其他的框架，spring加Hibernate加Struts框架，所以现在所讲的框架里头MVC的M可以用在后端，vue可以用在前端，中间通过ajax测试的请求抓取数据回来然后在前端直观的，但是至少有一点就是这个Controller，无论怎么写在后台还是有的，就是上节课讲的Struts里面的action，vue就是controller，它们就是之前说的Serllet封装，真正让下面所有开发者看不到所有的后台，看到的controller，既然看到的MVC架构里面，C是保留的，M是在后端，V是在前端，V是拿到后端的数据之后重建的，所以确实如果用MVC架构就意味着前端没有这样的分层，但要从知识的完整性的角度来说还是要说一说这个内容，Struts上次已经讲了，可以去注册这个用户，查询到personBean，personBean在后台有一个注册的action里面有一个user的属性，因为它是在just as not里面把它配置的，让它在register这个动作的时候进行，前端发布请求之后进行register的action的处理，然后它跳转到thankyou.jsp页面成功之后返回到SUCCESS，从前端跳到register的注册页面，也就是看到register.jsp页面，它可以还原到后台这里，也就是说对着register发送请求，会被后台的action去处理，后台的action在拿到之后，它就要去处理场外的请求，要求指向personBean里面的内容，分别来自于前台输入的这个页面，如下所示：
它输入的信息就会被组装到personBean里面，才会说拿到personBean的内容，会做相应的处理，不但把personBean给它区别化了，并且把它对应的e-mail区分到一个对应的表里。
2.后端运行原理
而后端的User类跟之前讲的Hibernate所看到的的person类是一样的，就是一部分的数据来自person的那张表，还有一个是来自email的那张表，这是后端的内容，那它和之前的Hibernate代码是类似的，注册成功后就会跳转到前端返回的success，会跳转到thankyou.jsp的页面，thankyou.jsp的页面是从前端的action过来，后端action过来的也是后端的personBean的内容，Struts的s:property标签的意思是把这个对象里面的内容用一个小技巧。
3.前端返回input原理
前端返回的input是从哪里来的呢？
@Override
public String execute() throws Exception {
Session session=
HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
personBean.getEmailAddresses().add(personBean.getEmail());
session.save(personBean);
session.getTransaction().commit();
return SUCCESS;
}
从上面的代码可以看到这个action的execute只是在返回的except，并没有看到input的内容，这是正常输入之后我们来查询到personBean返回的内容：
Input是在Register.java里面加了一个validate()的方法，这个方法可以根据自己写的逻辑去强制对前台的一些东西做较量，比如personBean的长度等于0，就是说它还没有出内容，它会通过addFieldError提前封装好的一个方法，它会报一个异常：“First name is required”，意思是“First name是必须的”，同样的道理，email的长度，还有getAge必须要大于18，意思就是在点击提交这个动作的时候，进来到达action进行处理，action写了validate()方法，就会拿validate()的方法去检查前台做的操作，比如去检查personBean里面前面的三个属性是不是满足要求，在做了这样的处理之后会看到如果是有一条不满足，就是说确实是0，就会调用这个方法，如下代码所示：
public void validate(){
if(personBean.getFirstName().length()==0){
addFieldError( "personBean.firstName",
"First name is required." );
}
调用这个方法之后就会返回input，它的返回因素就是input，返回input是跟之前的对应的，如图所示：
只要返回input，就可以跳转到register.jsp的页面，而register.jsp页面是之前的页面：
也就是说，当输入不合法的时候，还是会停留在注册的页面，如下：
并且会把指定的这个域用红色标识，并且后面出现一个警告语也是红色，效果如上图所示，所表示的是First name is required，然后这里的First name是红色的，然后Email is required，Email也是红色，然后Age is required and must be 18 or older，Age也是红色，一开始什么都没写，就点了Submit所以Age显示的是0，会有上面的提示，这一块如果用Struts，这种输入的校验就非常的方便，很容易的就告诉用户这些东西满足什么条件，在这里写了很简单的条件，就会自动地去做这个提示，这是看到的Struts的内容，就是怎么去做相应的校验。
4.Session处理方法
无论任何一种框架，之前也有说过，Session是一个很重要的东西，尤其这个Session是讲的用户和这个PC端在进行会话的时候，是会话状态很重要的东西，Session该怎么去处理呢？在action里面如果重启action Object类，可以自己去定义一个userSession类型对象，之前有说过session类型的内容实际上就是里面就放一些键值对，本质上来说，键值是看类型，比如拥有的类型，命名为Object，放的一些键值对都是一些键值对就是由Object键值对构成的一个数组，或者一个集合，用Map存储效率比较高，存储效率和这个原始的设置无关，它是唯一的，所以用Map，这里定义好一个session，这里可以划未来认为应该把它放的一些图片，对它就会有set方法，就是在action如果实现SessionAware这个接口，当Session被激活的时候，这个方法就会被调用，每一次都是把用户关联的HttpSession关联起来，要做什么呢？
在execute（）里头执行了一个方法，这个方法是从userSession里面get一个helloCount，知道用户当前的一个会话里面它的一个输出值，这个值可以看到这个Map是Object类型，返回的是一个包装类的，就是一个int，第一次上来不可能什么都没有，得到的就是一个空，空就是helloCount就是等于1，就和之前看到的http不太一样，要去写hs.SetAttribute(“helloCount”，1)，是用get去包装，要get（“helloCount”）的时候就知道应该写这个指键，如果是空就直接设为1，就会把指键放到userSession，所以这里的键值为1，如果说第一次来的时候有，就能得到不为空，不为空就能实现helloCount++，
这个动作跟上面所写的“hs.SetAttribute(“helloCount”，1)”动作一样，就是把“helloCount”设置到userSession当中，这是在一个Session里面出现的作用，但是现在可以看到，在一个session里Browser一个浏览器，在访问一个页面的时候，页面写着你的APP，怎么操作都是一个session，如果再有一个浏览器再去访问，就是两个session，所以如果在那个页面里面添加一个“我已经添加过多少次了”，
代码如下：
还有一个“我已经对你说过多少次了”，代码如下：
区别就是helloCount相当于一个总数，#session.helloCount就相当关于当前的浏览器所写的，如果搞两个浏览器来看，当这个浏览器访问它，就会显示它已经被访问过5次，在当前的浏览器里面说了3次，再开一个浏览器，就显示在这个浏览器里面只说了5次，但是总共已经在刚才的5次上又说了一次，所以是6次，
效果如图所示：
在这个地方看到的加上的约束就在看到的action里面有一个helloCount的变量，这个变量就是全局变量，如果是在前端说这个是跟session相关的helloCount，这个helloCount就是在做如下代码的处理：
HelloWorldAction.java
public String execute() throws Exception {
increaseHelloCount();
}
private void increaseHelloCount() {
Integer helloCount = (Integer) userSession.get("helloCount");
if (helloCount z= =null) {
helloCount =1;
}else{
helloCount++;
}
userSession.put("helloCount" , helloCount);
就会去找在session里面去取helloCount，就会去显示当前页面已经被访问了多少次，这是全局变量和它的区别，这个全局变量是哪来的呢？就是在代码里的action里面定义一个helloCount，如下：
HelloWorldAction.java
private Map<String,Object>userSession;
Public void setSession(
Map<String, Object> session){
userSession = session;
}
上图就是跟session相关的helloCount，它们是不一样的。下面是Struts的有关学习资料，大家可以去看一下：
在MVC的架构里面体现的是“C”，“V”放到了前台，给React去处理，“M”就退化成了通过ajax去传递的那些JSON，这是Struts框架的模型。
二、spring框架模型
1.理解spring的MVC架构
接下来看一下spring，在最后的代码出现的那些都是一些Controller的东西，在这里解释一下，看看spring的MVC如下图：
了解Struts的MVC的架构之后，spring的MVC就非常容易理解，跟Struts一样，前端一定要有一个东西拦截所有请求，像Struts有一个Dispatcher一样，它会拦截所有请求，全部被它接管，它本身不做什么业务上的处理，但是请求来了必须经过它，这是在Struts里面讲的ajel.xml里面配的一个Dispatcher，跟它的道理一样，Dispatcher来了是干什么呢？显示看一下查找相关的文件，比如XML文件或者education它去看一看这个请求，比如说是一个完整路径来的hello，就会去问这个东西应该给谁处理，意思就是写的那些annotation或者是XML，annotation怎么写呢？
就要看spring是怎么规定的，要写controller，不管怎么样就知道谁可以来处理了，于是就交给了一个controller，controller就去处理了，于是在之前写的代码里已经看到了这种关系，之前写的代码里controller就直接返回来的一个了内容，返回来一个JAVA的对象，JAVA对象因为controller用的是Rest的controller，它会自动把这个JAVA对象转成一个JSON的对象，JSON就返回到客户端，客户端直接拿到了JSON的情况，就是之前看到的东西，完整的MVC架构会少一个ModelAndView，根据系统配置的ViewResolver里面去解析这个Model的数据把它组装到View里面去，于是View就返回到Request里面，这个过程可以看到它和Struts没有什么太大的差异，把Dispatcher Servlet看成Struts里面的Dispatcher，controller就是Struts里面的action，然后Handler Mapping就是Struts里面的Struts.xml，底下的这个View就是Struts里面的Jsp，ViewResolver就相当于Struts里面有s开头的代码，大致的关系就是这样的，没什么别的东西，ModelAndView就是之前看到的action里面的message或者personBean，这就是对应的关系，可以看到的大致就是这样。
2.了解spring的后台组成
按照这样的类比，其实就知道MVC的spring框架里头，是怎么一回事的，写的代码的话写的也是比较简单的，用的是XML的方式来开发一个spring的后台是怎么写的，如果用XML就意味着我在代码里不写任何的annotation，是用XML文件来描述，在编写的时候要写的controller，就是MVC里面的那个“C”，那个controller要实现mcv的controller的接口，它里面有一个handleRequest方法要进行处理，这个东西就类似于servlet，它里面有do port和do that等等，它里面是一样的，它是用XML来描述的，后面再讲XML，也会很有handleRequest的方法，包一个HttpServletRequest和HttpServletResponse，这两个东西在servlet里面在do that和do port里面的参数是一样的，就是把用户的request给封装了一下，所以里面带有参数，就是给了一个空的response，到时候要往里面写东西，要实现一个返回的动作，ModelAndView的东西，就是上图所看到的的，里面有什么呢？
往这个里面添加这个信息，里面就会有类似于message和personBean这样的内容，
如下图所示：
放了一个message就是key，“Hello Spring MVC”就是键值对，就是Model的部分，View就是让它跳到index.jsp，跳转到那里就直接拿到message的对象，内容就是“Hello Spring MVC”。
前端就是这个index.jsp，直接就去拿message的参数，参数从哪来呢？
就是从View和Model组合的ModelAndView，它们都在mav里面，所以index.jsp就可以拿到message，于是就显示了“Hello Spring MVC”这样的信息。
3.spring的配置文件
这个配置该怎么写呢？可以看一下这个web.xml的文件：
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
这里写的是所有的请求全部被这个dispatcher拦截，dispatcher是spring框架里面的DispatcherServlet，就跟上一个xml的用意是一样的，就是由它接管，它就会去处理，由于在编写的时候可能还会有一个配置参数，比如说applicationContext.xml，它要被spring加载，所以上面要有一个监听器，
监听器要去加载凡是在context-param里面设定配置的文件在哪里，就回去加载，跟response没有什么本质区别，在一个默认的地方去找这个xml，需要把它写在applicationContext.xml里头然后告诉它在spring里面加载就可以了。
dispatcher-servlet.xml在之前已经说过，全部请求被DispatcherServlet拦截，拦截之后的分发逻辑在哪里，就在dispatcher-servlet.xml里，
如下代码所示：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmIns="http://www.springframework.org/schema/beans"
xmIns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http: //www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="simpleUrlHandlerMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/hello">helloController</prop></props>
</property></bean>
<bean id=
"helloController" class="hello.controller.HelloController">
</bean>
</beans>
这里写的是说，写个内容随便起个名字，对应的是刚才xml默认的，需要有一个Handler Mapping，在哪里呢？就用一个最简单的simpleUrlHandlerMapping，来维护谁呢？就是哪一些请求要对它去映射呢？如果前端有一个“/hello”的内容，就是路径如果包含它，这种内容要被mappings处理器处理，它会映射到helloController，所以底下定义了一个helloController，就对应了刚刚写的类“helloController”，所以在这个前端运营里面如果写hello，它就会映射到helloController上，helloController就是刚才写的那个类，就会返回到index.jsp，返回相应的对象里面，就是返回ModelAndView类型的对象，AndView就是返回到index.jsp，Model就是message的对象，就是“Hello Spring MVC”，显示的就是这个index.jsp的页面，这个页面就是${message}，意思就是显示“Hello Spring MVC”，这个文件非常像Struts.xml，它在讲大家是怎么去映射的，这个例子就是用xml去做的MVC的例子，刚才看到这个hello会被拦截，拦截之后就会到controller上，这就是它的这个结果，如下图所示：
输入hello之后就会返回这样的结果，结果从哪里来的呢？如下文件所示：
就是看到的配置文件，配置文件里面说的对hello的请求，会显示出helloController，Controller就会说到hello.jsp的页面上，给它放的一个对象，这个对象就是“Hello Spring MVC”，它的名字叫做message，到hello.jsp的文件上就可以看到：
直接要去显示这个message的内容，这里定义是红颜色的，把样式什么颜色的要把它分离开，最后显示的就是红色的“Hello Spring MVC”，结果如下图所示：
这是看到的页面，跟之前稍微有点差异，把这个逻辑放到了这个hello.jsp的页面，而这个index.jsp大家看到的，没有去映射它应该怎么跳转到相应的页面，就没有写，直接这样返回，如果要是说让它直接返回，就可以把这个名字改一下，把hello.jsp改成index.jsp，两个的差异就是index.jsp只是在显示message，没有显示红色的，hello.jsp是红色的，然后显示message，重启应用，再把它刷新一下，结果是没有红色显示的，如下图：
也就是说，如果更改这个页面的View，Model不动的话，仍然能抓取到里面的内容，还是希望Model和View之间能够实现结合，但是使用的personNone是这样的：如果在里面写param，如果send一下，它就会返回一个结果，如下图：
开发的时候用personNone也可以。
4.spring的MVC逻辑分析
这就是看到的例子，无论怎么样，希望MVC互相之间是结合的，也就是Model和View不要直接绑定，它们之间是通过controller把它们关联到一起，就是这样的一个逻辑。如果写另外一个页面，在controller里面去改写页面跳转的地方，就会跳转到新的页面上，但是Model就是message并没有发生任何的变化，这是看到的一个在spring里面去实现的一个例子，写一个同样类型的例子，但是不是用XML文件来描述的，也就是说用XML文件来描述的话，代码是不会出现任何annotation的，有关这些映射文件首先是出现在web.xml里面，去声明一下，applicationContext.xml在这个例子没有作用，但是在以后的例子里面比如说上次说到的DateSuccess里面的配置，可以有多种写法，然后在dispatcher-servlet.xml里面要去说清除，url和controller之间是什么关系，controller具体编译类型是什么，代码里一概不出现annotation。
刚才比较习惯于去创建一个spring不同类型的应用，在里面做开发，springBoot里面一般是用application去描述，要开发一个应用，它完全是一个application，它就没有xml，同样的东西用spring application去实现刚才的逻辑，就可以用springBoot开发的一个系统，就如下代码所示，
是完全没有动过的：
SpringBootApplication
public class MvcsampleApplication {
public static void main(String[] args){
SpringApplication.run(MvcsampleApplication.class, args);
}
}
把工程架构编译上去，它就会自动创建这样的一个类，而且会用application稍微处理一下，里面有一个main函数一运行它就会运行出main Tomcat，然后把当前写的应用部署，而且它访问的端口是http://local/host:8080/，这是springBoot的例子，这个例子没有去改写它，因为这里的目标就是main Tomcat把应用部署，看看刚才写的内容，在写controller，刚才其实要明确声明它实现的controller的接口，那现在用@来描述，直接写@Controller来描述，就是意味着它会映射到，会在处理的时候会知道要实现controller的接口，什么时候处理呢？所以这时候就要对annotation稍微做一点解释，annotation是Java的一种数据，把所有的annotation全部删掉，这个类编译出来的本身不会发生任何变化，换句话说，加上了annotation，Java类也不会有什么功能上的变化，annotation有什么用处呢？
Annotation是给不同的框架是给它们自己编译的，spring才会说如果想让GreetingController类取到controller的作用，其实有很多种能写，比如说怎么去封装，跟servlet一样怎么去封装request、response等等，把内容返回的具体逻辑都没有做，只需要关注业务逻辑，怎么做呢？
Spring就会告诉去写annotation，然后对着Java文件编译之后成了class文件，包含了annotation，注意它是自编码加上这个annotation，跟标记一样，不是说本身有没有annotation编译出来是一样的，这个框架会再加载class文件，去对这些保留在里的annotation去做处理，会生成一些自编码，或者是生成一些新的类，具体的逻辑不同的框架有不同的编译，会把这些东西和自己写的自编码完合在一起，这才是完整的功能，换句话说就是annotation实际上是Java的一种机制，它可以告诉可以在编译好在哪里保留一些内容，这些内容可以对自己需要的工具，可以编写它的工具去处理，所以说annotation不是给Java编译器看的，也不是给Java看的，是给那些工具区分看的，不同的工具就会根据自己实现的这个功能实现的方式，它会定义自己的一组annotation，做一个框架到底能用哪些呢？要去看它的说明书，spring有自己的，必须要写controller，如果这个类能出现controller，是spring自己规定的，在Struts才能看到的，也是用annotation来进行描述，但是使用的annotation也是Struts自己来规定和定义的，所以它们本身不是说Java有一个什么样的约定说必须要写什么样的annotation，工具就是说写了就能处理，就是说这些框架认为想给用户提供什么支撑，很多东西不需要写了，帮用户分层，但是要告诉该怎么去帮用户分层，所以应该按照用户要求写一个什么样的annotation。从这些地方来说所有annotation的变量和XML是一样的，XML的地方前面可以看到，加载XML之后就知道请求URL由controller来处理，现在的道理是一样的，所以annotation和XML二选一都可以。
5.在spring的架构里controller实现监听的功能
现在来看这个controller在spring的世界里，想实现一个监听前台发过来的请求，然后进行处理的这样一个功能：
@Controller
public class GreetingController {
@GetMapping("/greeting")
public String greeting(@RequestParam(name="name",
required=false, defaultValue="World") String name, Model model) {
model.addAttribute("name" , name);
return "greeting";
}
就是在spring的世界写一个controller，先写一个普通的JAVA类，不用实现任何接口或者是扩展任何类，在前面加一个@controller就知道有一些东西需要spring来托管，再去查里面的东西，在一个方法上面写了一个叫做GetMapping的东西，知道这个东西是在映射http的get方法，在当前的应用里面如果有“/greeting”，凡是这种请求，通过get方法发过来的就是这个URL发过来的请求就会被greeting这个方法处理，接下来处理的时候这个get就自带参数，也就是说有一个参数，叫做name来自于RequestParam参数，所以表明这个信息就用了一个RequestParam来描述，就是在greeting里头如果有一个参数叫做name，greeting的这个方法的参数name就来自于RequestParam的参数name，但是不是必须的，如果URL后面是没有name这个参数的话是不要紧的，就给它赋person值就是“World”，然后就会说所谓的greeting发一个请求过来，它返回的内容可以看到是greeting，会在这个model里头设置了一个属性，属性的名字叫做name，其实就是刚才看到的这个参数的值，对于参数可能是从Request里面来的，也有可能Request没在，有一个值叫做“World”，看来就是一个人名放到这个内容，反正就是model里头有内容了，这个model很显然它就像被包装之后的request或者response，往里面写进去的内容，但实际上两者也有差异，就是返回的是是model就像看到的message或者personBean这样的内容，就是写进去的一个对象，然后return greeting，return greeting的环境是什么呢？有一个页面叫做View，在这里来看，首先是有一个叫做index.html的页面，代码如下所示：
index.html
<!DOCTYPE HTML><html>
<head>
<title>Getting Started: Serving Web Content</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<p>Get your greeting
<a href="/greeting">here</a></p></body>
</html>
里面有一个超链接会发出这个greeting的请求，就会到达了之前的controller来处理，为什么会到达controller呢？把这个过程看一下，在前台有一个请求链接发了出来，发出来之后，虽然用了annotation但是道理都一样，就是所有的请求全部被DispatcherServlet给拦截掉，拦截掉之后就会到再用spring启动的时候会去做整个应用的这个共同包的扫描，会去扫描所有像这种@Controller、@getMapping这些信息，
扫描完了就组了一个类似于之前讲的dispatcher-servlet.xml的配置文件的信息在内存里面，其实刚才写的写getMapping这些东西已经有greeting操作，比如说是哪个方法来调用，它在启动这个spring的这个工程的时候，扫描了前包之后就知道了信息greeting是Controller方法来处理的，所以当在最终点击了之后会被DispatcherServle给拦截，被拦截掉之后就会去扫描这个配置文件的信息，映射信息之后就知道了要被这个方法处理，于是这个方法就被激活，然后就跳转到请求里面有没有name，如果直接点击是没有的，但它就会出现一个person就是hello，hello往model里面添加了一个名字为name的途径，它的途径就是“World”，就返回到greeting，
如下图所示：
greeting.html
<!DOCTYPE HTML>
<html xmlns:th="http:// " >www.thymeleaf.org">
<head>
<title>Getting Started: Serving Web Content</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p th:text=""Hello, ' + ${name}+'!""/>
</body>
</html>
就会跳转到greeting.html的页面，就会显示“Hello，加上这个name的值”，会出现Hello World，对于这个text标签来自于th的名称签是上图所示的“http://www.thymeleaf.org”工程，可以在开发项目的时候必须要存在这个项目，当然这里只是举个例子，如果不是跳转到这个页面，因为现在都是在React里面，可以把“Hello World”的途径里面变成一个直接返回前端，就是说这就是在服务器端加了一个模板引擎：
<table>
<thead>
<tr>
<th th:text=”#{masg.headers.name}”>Name</th>
<th th:text=”#{masg.headers.price}”>Name</th>
</tr>
</thead>
<tbody>
<tr th:each=”prod:${allProducts}”>
<td th:text=${prod.name)>Oranges</td>
<td th:text=”${#number.formatDecimal(prod.price,1,2)}”>0.99
</td>
</tr>
<tbody>
</table>
所谓的模板引擎就是看到的地方文本将来要拿后端的某一个地方里面的内容去替换掉它，就是这样的一个内容，看到的s开头的界面，这个例子运行起来的话就会看到它是这样的：
点击here之后就会产生这样的请求：
产生这样的信息，这是完全由annotation来实现的，因为它用springBoot，用的是内置的文档这个contact，我们运行一下，就可以看到这样的首页：
首页有一个here，点击之后跳转到greeting，显示结果如下图：
为什么会显示“Hello，World！”呢？是因为这个代码稍微改了一下，这个代码写的是跳转到greetingred，
文件中是有两个页面，一个是叫greetingred，一个是叫greeting，greeting是直接显示“Hello，World！”，greetingred是用红颜色去显示“Hello，World！”，这是两者的差异，如果把greetingred改写回来变成greeting，然后执行，结果如下：
大家可以看到的是没有红颜色显示，所以相当于model和view，model和view无论是greeting还是greetingred都可以拿到这个model里面的内容，model没有说它的内容一定对每一个页面去改变，然后用personal来试一下，刚才是greeting，还有另一个是greetingred，刚才发的都没有任何的name值，所以name用的是赋值“World”，所以看到的是“Hello，World！”，现在用一个greeting，看到的它把name对应的是RequestParam的参数，所以在personal里面参数这个地方选择的键值对是name，它的值就是Tom，然后send一下，现在返回的内容大家可以看一下：
就是“Hello，Tom”，也就是说确实取到了这个参数值，然后把它的值放进来返回，是这样的一个内容，这是看到的spring的MVC，在这里主要强调的是也许不会写页面，但是后台肯定会有很多的Controller，这个Controller要去映射前端发过来的请求，就是用GetMapping方法来映射，通过它的映射大家可以看到，后台的方法不必用do that和do port做任何处理的，因为它的方法名叫做require，它是在这种annotation，也就是这一个springBoot类加载之后它在扫描前包的时候他扫描到这样的信息之后知道greeting方法，这种方法不是映射的内容之一，是靠annotation来连接的，所以就比较灵活一些，同样可以去取一些request的参数，也可以让这个返回式的信息里面，也就是model里面说明然后跳转到哪个页面也是可以去控制的，model和这个页面之间是部署就可以了，所以它的本质上跟Struts的MVC几乎是一样的。
如果再换个页面，这个页面加了一个样式颜色，然后返回到greetingred，就会产生不同的效果。
使用这个controller的时候，大家看到controller在图中的位置：
在相应前端的3个ID口，就会看见已经接触过这些。
