深入剖析Spring(三)：MVC核心思想

绝地灬酷狼 2023-07-17 14:29 58阅读 0赞

> Spring框架对于java开发者来说是不可缺少的,如今我们接触到的项目几乎都不开spring,我们整天都在使用spring,例如@Controller、@Autowired、@Autowired、@RequestMapping,我相信大部分都能知道它的作用,同时我也希望能本文能帮助到你更深的了解他们。

### 前言 ###

记录文章目的及意义在于为了自己知识的巩固,当然也十分希望在此能够得到业界前辈们的指导。  
若有不正确的地方,希望能够及时批评指正。首先在此感谢

### 本篇内容 ###

本篇文章的内容,主要对于springMVC的配置阶段、初始化阶段、运行阶段做些粗浅的学习记录。围绕着@Controller、@Autowired、@Autowired、@RequestMapping来实现功能。  
方式：手写一个简单的mvc。

### 一、准备 ###

介绍一下mvc的基本实现思路，先介绍然后在编码。

#### 1.1、配置阶段 ####

我们都知道SpringMVC的本质就是从Servlet演变而来，它继承自HttpServlet，通常在使用Servlet的时候，我们都会去配置Web.xml文件，**其实所有依赖于web容器的项目，都是从读取web.xml文件开始的**。  
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">
        <display-name>MVC Web Application</display-name>
    
        <servlet>
            <servlet-name>CcMvc</servlet-name>
            
            <servlet-class>com.ccc.mvcframework.v1.setvlet.CccDispatcherServletTest</servlet-class>
            <init-param>
            
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:application.properties</param-value>
            </init-param>
            <init-param>
            
                <param-name>configFile</param-name>
                <param-value>application.properties</param-value>
            </init-param>
            
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
        	
            <servlet-name>CcMvc</servlet-name>
            <url-pattern>/*</url-pattern>
        </servlet-mapping>
    </web-app>

以上作用：  
1.指定DispathcerServlet  
2.配置ServletMapping(url路径)  
3.如果是与spring一块使用我们还会指定spring.xml配置文件.  
当然web.xml的功能远远不止于此，在这里咱就介绍几个关键的。

#### 1.2初始化阶段 ####

此阶段主要分为六个步骤:  
1.加载配置文件(web.xml中的param-value).  
2.通过配置文件扫描相关的类(.class结尾的文件)。  
3.筛选出带有注解的类并放入到IOC容器中.（控制反转,注解的类:@controller@Service等）  
4.扫描IOC容器中的实例，给没有复制的属性自动复制(DI依赖注入)  
5.初始化HandlerMapping,将url和方法对应起来。  
到此初始化过程大致完成。

#### 1.3运行阶段 ####

1.doPost()/doGet()：获取到request/response对象。  
2.从HandlerMapping匹配到request中的url，找到对应的方法。  
3.反射调用该方法。  
4.返回数据。  
**贴一张配置文件的内容：application.properties,只有一行**

> scanPackage=com.ccc.mvcframework.v1.demo

### 二、编码 ###

提醒一下，记得web.xml文件哦，由于前文介绍到了这里就不在介绍了。

#### 2.1定义注解 ####

2.1.1 Controller

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XHController { 
        String value() default "";
    }

2.1.2 Service

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XHService { 
        String value() default "";
    }

2.1.3 Autowired

@Target({ ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XHAutowired { 
        String value() default "";
    }

2.1.4 RequestMapping

@Target({ ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XHRequestMapping { 
        String value() default "";
    }

2.1.5 RequestParam

@Target({ ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface XHRequestParam { 
        String value() default "";
    }

**解释一下定义注解：**  
定义一个最基本的注解包含了两个步骤：**1、注解的名字；2、注解包含的类型。**  
如：  
1.@Target :限定某个自定义注解能够被应用在哪些Java元素上面的.是一个数组类型。它使用的是一个枚举(ElementType)类型定义.  
ElementType：

public enum ElementType { 
        /** Class, interface (including annotation type), or enum declaration */
        /** 类，接口（包括注解类型）或枚举的声明*/
        TYPE,
    
        /** Field declaration (includes enum constants) */
        /** 属性的声明 */
        FIELD,
    
        /** Method declaration */
        /** 方法的声明 */
        METHOD,
    
        /** Formal parameter declaration */
        /** 方法形式参数声明 */
        PARAMETER,
    
        /** Constructor declaration */
        /** 构造方法的声明 */
        CONSTRUCTOR,
    
        /** Local variable declaration */
        /** 局部变量声明 */
        LOCAL_VARIABLE,
    
        /** Annotation type declaration */
         /** 注解类型声明 */
        ANNOTATION_TYPE,
    
        /** Package declaration */
        /** 包的声明 */
        PACKAGE,
    
        /** * Type parameter declaration * 类型参数声明 * @since 1.8 */
        TYPE_PARAMETER,
    
        /** * Use of a type *类型的使用 * @since 1.8 */
        TYPE_USE
    }

2.@Retention声明注解在什么时候生效.同样是以枚举类型来声明。这里就不展示源码了为了节省位置。  
主要有3个：  
1.SOURCE：源文件阶段（声明为此阶段生效也就是只在源文件中生效，不参与编译与运行类似于注释效果）  
2.CLASS:编译到class文件阶段(在编译阶段生效，可以用来处理一些逻辑。不会在运行期生效)  
3.RUNTIME:运行期阶段(emmm不用解释了吧，我们用的几乎都是这个。)

#### 2.2定义DispatcherServlet ####

此处就是mvc的核心步骤了。我们将按照前文中介绍的步骤依次来完成。  
1.定义一个DispatcherServlet继承自HttpServlet并重写父类的doGet()、doPost()、init()三个方法。  
init()方法相信大家都知道此方法会在加载的时候就调用。所以我们初始化的入口就在此。  
请看代码:  
2.声明一个Properties变量存储配置文件的内容。  
3.在init方法中我们按照前文步骤依次声明方法。

public class CccDispatcherServletTest extends HttpServlet { 
    
        //存储aplication.properties的配置内容
        private Properties contextConfig = new Properties();
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            super.doGet(req, resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            super.doPost(req, resp);
        }
    
        @Override
        public void init(ServletConfig config) throws ServletException { 
            //ServletConfig 可以获取web.xml文件的属性
            //使用模板模式
            //1、加载配置文件
            doLoadConfig(config.getInitParameter("configFile"));
            //2、扫描相关的类
            doScanner(contextConfig.getProperty("scanPackage"));
            //3、初始化所有相关的类的实例，并且放入到IOC容器之中
            doInstance();
            //4、完成依赖注入
            doAutowired();
            //5、初始化HandlerMapping
            initHandlerMapping();
            System.out.println("XH Spring framework is init end.");
        }
        //5、初始化HandlerMapping
        private void initHandlerMapping() { 
        }
        //4、完成依赖注入
        private void doAutowired() { 
        }
        //2、扫描相关的类
        private void doScanner(String scanPackage) { 
        }
        //3、初始化所有相关的类的实例，并且放入到IOC容器之中
        private void doInstance() { 
        }
        //1、加载配置文件
        private void doLoadConfig(String configFile) { 
        }
    }

##### 2.2.1加载配置文件doLoadConfig() #####

这里比较简单

private void doLoadConfig(String contextConfigLocation) { 
            try(InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation)) { 
                //加载配置文件,此时配置文件已存于内存中了
                contextConfig.load(fis);
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }

#### 2.2.2 扫描相关的类doScanner() ####

首先声明一个一个集合存储扫描到的类

> `private List<String> classNames = new ArrayList<String>();`

private void doScanner(String scanPackage) { 
    		//scanPackage=com.ccc.mvcframework.v1.demo
            //包传过来包下面的所有的类全部扫描进来的,并替换成/路径
            URL url = this.getClass().getClassLoader()
                    .getResource("/" + scanPackage.replaceAll("\\.", "/"));
            //获取这个文件
            File classPath = new File(url.getFile());
            //遍历文件下的数据
            for (File file : classPath.listFiles()) { 
                //如果是一个目录,则递归查找
                if (file.isDirectory()) { 
                    doScanner(scanPackage + "." + file.getName());
                } else { 
                    //如果是一个.class文件去掉.class后缀存放到集合中,如果不是则跳过此次循环
                    if (!file.getName().endsWith(".class")) { 
                        continue;
                    }
                    String className = (scanPackage + "." + file.getName()).replace(".class", "");
                    classNames.add(className);
                }
            }
    
        }

**此方法的作用就是找到路径下所有的类文件并存储起来**。  
解释一下：  
1.**为什么要用/来替换.呢？**  
因为我们scanPackage的值是以命名包名的形式来写的，而使用File的话就得换成/的目录形式了。  
2.**为什么要去掉.class后缀在保存呢?**  
这里举个例子吧.假设类名className=Test，如果我们通过名字得到这个类对象怎么获取呢？当然是使用反射Class.fromName(className).结果是不是很明显了，我们可以通过Test来得到这个对象，但是不能通过Test.class来得到这个对象。

#### 2.2.3 控制反转doInstance() ####

1.首先声明一个IOC容器用来保存所有实例化对象

> private Map<String, Object> ioc = new HashMap<String, Object>();

2.声明一个方法用来进行类名首字母小写.

private String toLowerFirstCase(String simpleName) { 
    		//该方法将字符串转为一个char数组。
            char[] chars = simpleName.toCharArray();
            /** * 将首字母往左移32位,1<<5 相当于2<<4 等价于 2*(2^4)=32 * 而ASCII编码中,26个英文字母对应的大小写差值是32。 例如:A 97 a 65 * 这里咱们就考虑正常的命名方式,类名首字母小写。不考虑_等字符。 * */
            chars[0] += (1<<5);
            return String.valueOf(chars);
        }

3.编写doInstance()

private void doInstance() { 
            //不为空
            if (classNames.isEmpty()) { 
                return;
            }
            try { 
                //迭代,简单工厂模式
                for (String className : classNames) { 
                    //得到这个类
                    Class<?> clazz = Class.forName(className);
                    //如果类中包含了Controller注解,说明是一个控制层
                    if (clazz.isAnnotationPresent(XHController.class)) { 
                        //实例化这个类,并将类名首字母转小写
                        Object instance = clazz.newInstance();
                        String beanName = toLowerFirstCase(clazz.getSimpleName());
                        //存在ioc容器中
                        ioc.put(beanName, instance);
                    } else if (clazz.isAnnotationPresent(XHService.class)) { 
                        //如果包含了Service注解,说明是一个业务层,但是注意业务层可以自定义包名.
                        //1、默认的类名首字母小写
                        String beanName = toLowerFirstCase(clazz.getSimpleName());
                        //2、自定义命名,得到注解中的值
                        XHService service = clazz.getAnnotation(XHService.class);
                        if (!"".equals(service.value())) { 
                            //如果不为"",则使用注解中的值替换默认的名字,为什么使用""判断不用null,因为注解中default是"".
                            beanName = service.value();
                        }
                        //实例化这个类,
                        Object instance = clazz.newInstance();
                        //存入ioc容器中,key为类名\自定义得名 value是这个类对象
                        ioc.put(beanName, instance);
                        //3、根据类型注入实现类,此处是个简单的写法。
                        for (Class<?> i : clazz.getInterfaces()) { 
                            if (ioc.containsKey(i.getName())) { 
                                throw new Exception("The beanName is exists!!");
                            }
                            ioc.put(i.getName(), instance);
                        }
                    } else { 
                        continue;
                    }
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }

此方法的作用就是得到上一步扫描到的所有类名，迭代筛选出带有注解的类例如@Controoler等注解的类然后存放到IOC容器当中，等待下一步的调用。

#### 2.2.4完成依赖注入doAutowired() ####

private void doAutowired() { 
            if (ioc.isEmpty()) { 
                return;
            }
            //迭代ioc容器
            for (Map.Entry<String, Object> entry : ioc.entrySet()) { 
                //拿到实例对象中的所有属性
                Field[] fields = entry.getValue().getClass().getDeclaredFields();
                //遍历这个属性
                for (Field field : fields) { 
                    //不包含Autowired注解,不注入
                    if (!field.isAnnotationPresent(XHAutowired.class)) { 
                        continue;
                    }
                    //
                    XHAutowired autowired = field.getAnnotation(XHAutowired.class);
                    String beanName = autowired.value().trim();
                    //如果没有自定义名字,就使用默认的
                    if ("".equals(beanName)) { 
                        beanName = field.getType().getName();
                    }
                    //获取私有属性权限
                    field.setAccessible(true); //设置私有属性的访问权限
                    try { 
                        //执行注入动作
                        field.set(entry.getValue(), ioc.get(beanName));
                    } catch (Exception e) { 
                        e.printStackTrace();
                        continue;
                    }
                }
            }
        }

此方法作用将我们添加了@Autowired注解的属性注入值。

#### 2.2.5 初始化initHandlerMapping（） ####

1.首先声明一个集合保存Contrller中所有Mapping的对应关系

> `private List<HandlerMapping> handlerMapping = new ArrayList<>();`

2.声明一个内部类HandlerMapping

public class HandlerMapping { 
            private Pattern url;
            private Method method;
            private Object controller;
            private Class<?>[] paramTypes;
            //形参列表
            //参数的名字作为key，参数的顺序、位置作为值
            private Map<String, Integer> paramIndexMapping;
    
            public Pattern getUrl() { 
                return url;
            }
    
            public Method getMethod() { 
                return method;
            }
    
            public Object getController() { 
                return controller;
            }
    
            public Class<?>[] getParamTypes() { 
                return paramTypes;
            }
    
            public HandlerMapping(Pattern url, Object controller, Method method) { 
            	//把url定义成一个Pattern因为例如url /demo/query.* 此时我们需要正则匹配了。一般不会。
                this.url = url;
                this.method = method;
                this.controller = controller;
                paramTypes = method.getParameterTypes();
                paramIndexMapping = new HashMap<>();
                putParamIndexMapping(method);
            }
    
            private void putParamIndexMapping(Method method) { 
                //提起方法中加了注解的参数
                //把方法上的注解拿到，得到的是一个二维数组
                //因为一个参数可以有多个注解，而一个方法有多个参数
                Annotation[][] pa = method.getParameterAnnotations();
                //迭代
                for (int i = 0; i < pa.length; i++) { 
    
                    //嵌套迭代
                    for (Annotation a : pa[i]) { 
                        //找到RequestParam注解
                        if (a instanceof XHRequestParam) { 
                            //得到值
                            String paramName = ((XHRequestParam) a).value();
    
                            if (!"".equals(paramName.trim())) { 
                                //放到集合中,key为参数名,value为坐标
                                paramIndexMapping.put(paramName, i);
                            }
                        }
                    }
                }
                //获取方法的request和response参数
                Class<?>[] parameterTypes = method.getParameterTypes();
                for (int i = 0; i < parameterTypes.length; i++) { 
                    Class<?> type = parameterTypes[i];
                    if (type == HttpServletRequest.class ||
                            type == HttpServletResponse.class
                    ) { 
                        paramIndexMapping.put(type.getName(), i);
                    }
                }
            }
    
        }

3.完成initHandlerMapping()

private void initHandlerMapping() { 
            if (ioc.isEmpty()) { 
                return;
            }
            //迭代ioc容器
            for (Map.Entry<String, Object> entry : ioc.entrySet()) { 
                Class<?> cls = entry.getValue().getClass();
    
                //没有Controller注解跳过循环,其实此前已经做了判断
                if (!cls.isAnnotationPresent(XHController.class)) { 
                    continue;
                }
                //1.保存类上的url
                String baseUrl = "";
                if (cls.isAnnotationPresent(XHRequestMapping.class)) { 
                    XHRequestMapping requestMapping = cls.getAnnotation(XHRequestMapping.class);
                    baseUrl = requestMapping.value();
                }
                //2.保存方法上的url
                for (Method method : cls.getMethods()) { 
                    //没有方法注解的方法跳过
                    if (!method.isAnnotationPresent(XHRequestMapping.class)) { 
                        continue;
                    }
                    XHRequestMapping requestMapping = method.getAnnotation(XHRequestMapping.class);
                    //将url进行拼接
                    String url = (baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
                    //进行正则
                    Pattern pattern = Pattern.compile(url);
                    handlerMapping.add(new HandlerMapping(pattern, entry.getValue(), method));
                }
            }
        }

到此为止初始化过程完成。接下来完成运行期的逻辑

#### 2.3运行期 ####

#### 2.3.1编写doPost()和doGet()方法 ####

这里我就简单写一下Get方法

@Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            this.doPost(req, resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            try { 
                //这里我们使用委派模式,派遣，分发任务
                doDispatch(req, resp);
            } catch (Exception e) { 
                e.printStackTrace();
                resp.getWriter().write("500 Excetion Detail:" + Arrays.toString(e.getStackTrace()));
            }
        }

我们先来准备一下\*\*doDispatch()\*\*需要的方法

#### 2.3.2convert() ####

用来进行字符转换，在Spring源码中也是这样操作,有兴趣的朋友可以自行看看,这里简单处理一下数字类型的转换目的为了测试时进行加减运算。

//url传过来的参数都是String类型的，HTTP是基于字符串协议
        //只需要把String转换为任意类型就好
        private Object convert(Class<?> type, String value) { 
            if (Integer.class == type) { 
                return Integer.valueOf(value);
            } else if (Double.class == type) { 
                return Double.valueOf(value);
            }
            //这时候，我们应该想到策略模式了,Spring也是根据此模式来实现的，emmm咱们就不处理，简单处理一下。
            return value;
        }

#### 2.3.3getHandler() ####

此方法的作用主要是负责正则匹配

private HandlerMapping getHandler(HttpServletRequest req) { 
            if (handlerMapping.isEmpty()) { 
                return null;
            }
            //获取请求的uri
            String url = req.getRequestURI(); // /demo/add
            //获取ContextPath
            String contextPath = req.getContextPath();
            //将ContextPath删除.
            url = url.replaceAll(contextPath, "").replaceAll("/+", "/");
            for (HandlerMapping mapping : this.handlerMapping) { 
                //因为咱们开始把url进行了正则,所以此处要进行正则匹配,匹配成功则方法这个handlerMapping 
                //handlerMapping是我们对存储url和method对应关系的集合.
                Matcher matcher = mapping.getUrl().matcher(url);
                if (!matcher.matches()) { 
                    continue;
                }
                return mapping;
            }
            return null;
        }

#### 2.3.4doDispatch() ####

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception { 
            //如果返回的为null则说明url错误或者不存在.
            HandlerMapping handler = getHandler(req);
            if (handler == null) { 
                resp.getWriter().write("404 no fund !!");
            }
            //获得方法形参列表
            Class<?>[] paramTypes = handler.method.getParameterTypes();
            //定义Object数组长度为参数长度
            Object[] paramValues = new Object[paramTypes.length];
            //得到传递过来的参数集合
            Map<String, String[]> params = req.getParameterMap();
    
    
            for (Map.Entry<String, String[]> param : params.entrySet()) { 
                String value = Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "")
                        .replaceAll("\\s", ",");
                //如果没有此参数名,则跳过
                if (!handler.paramIndexMapping.containsKey(param.getKey())) { 
                    continue;
                }
                //获取此参数的下标
                int index = handler.paramIndexMapping.get(param.getKey());
                //如果带有数字类型则进行转换
                paramValues[index] = convert(paramTypes[index], value);
            }
            //进行HttpServletRequest和HttpServletResponse赋值
            if(handler.paramIndexMapping.containsKey(HttpServletRequest.class.getName())) { 
                int reqindex = handler.paramIndexMapping.get(HttpServletRequest.class.getName());
                paramValues[reqindex] = req;
            }
            if(handler.paramIndexMapping.containsKey(HttpServletRequest.class.getName())) { 
                int respindex = handler.paramIndexMapping.get(HttpServletResponse.class.getName());
                paramValues[respindex] = resp;
            }
            //执行此方法
            handler.method.invoke(handler.controller, paramValues);
    
        }

到此一个简单的mvc就已经完成了。  
测试Demo  
**Controller**

@XHController
    @XHRequestMapping("/demo")
    public class DemoAction { 
    
      	@XHAutowired
    	private IDemoService demoService;
    
    // @XHRequestMapping("/query.*")
    	@XHRequestMapping("/query")
    	public void query(HttpServletRequest req, HttpServletResponse resp,
    					  @XHRequestParam("name") String name){ 
    		String result = demoService.get(name);
    		try { 
    			resp.getWriter().write(result);
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    
    	@XHRequestMapping("/add")
    	public void add(HttpServletRequest req, HttpServletResponse resp,
    					@XHRequestParam("a") Integer a, @XHRequestParam("b") Integer b){ 
    		try { 
    			resp.getWriter().write(a + "+" + b + "=" + (a + b));
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    }

**Service**

public interface IDemoService { 
    	String get(String name);
    }

**Service实现类**

@XHService
    public class DemoService implements IDemoService{ 
    	public String get(String name) { 
    		return "Hi"+ name+" Welcome to your spring MVC" ;
    	}
    }

测试结果：  
![在这里插入图片描述][20200322200730958.jpg]  
在这里对于本文就部分内容做一个补充  
**1.定义的几个集合存储的是什么？**  
1.1在本文 2.2.2中定义的 private List classNames = new ArrayList();  
\----->此节中定义的方法作用是扫描到所有的类。**所以classNames存储的应该是 com.xx.Test这些集合。**  
1.2在本文2.2.3 控制反转中定义的 private Map<String, Object> ioc = new HashMap<String, Object>();  
\----->此节中定义的方法作用是将所有使用了类注解的类保存起来。**所以ioc中的key:test value:Test类对象**  
1.3在本文2.2.5 初始化initHandlerMapping（）中定义的 private List handlerMapping = new ArrayList<>()  
\----->此集合定义的是一个内部类，因为咱们servlet中的url和方法时一一对应的，咱们只需要在将url和method参数都初始化好，那么在逻辑中直接调用就行，这样的好处是显的更为直观，小编开始使用一个Map来存储这些关系的后来发现在遍历的时候会十分麻烦，然后参考了spring的源码直接使用List集合来存储。有兴趣的朋友可以多看看源码，体验一下大神的水平。  
所以此集合中的数据一个方法中的url和所有的参数列表。  
**2.多次使用String.replaceAll(contextPath, “”).replaceAll("/+", “/”)有什么用？**  
这个其实很好理解,例如类上的url是 “/demo/”,方法上的url是 “/query” ->拼接后 “/demo//query” 显然是不对的，那么这里就是将多个/ 替换成 /  
**3.为什么要将参数进行 Arrays.toString(param.getValue()).replaceAll("\\\\\[|\\\\\]", “”)**  
这里放一张截图  
![在这里插入图片描述][20200322202347870.jpg]  
因为我们得到的参数可能是一个集合,例如咱们案例中的query方法中name属性，现在咱们访问:http://localhost:8081/demo/query?name=xh&name=zs&name=ls  
这样也是可以的,如果我们不做处理的话。那么返回结果就不是很友善，例如：

> Hi\[xh, zs, ls\] Welcome to your spring MVC

关于springmvc在这就介绍这么些了，如果发现有补充的地方，我会继续添加，同时希望各位看过的伙伴们如果发现了问题能够及时批评指正，在此感谢。

下一篇:[深入剖析Spring(四):IOC核心思想(源码分析篇)][Spring_IOC]

[20200322200730958.jpg]: /images/20230528/b7f0ec8dadc14673802c7081cd43867b.png
[20200322202347870.jpg]: /images/20230528/76ec9ee4463547b29358410fbd3e121f.png
[Spring_IOC]: https://blog.csdn.net/qq_40409260/article/details/105110956