17.用300行代码手写初体验Spring V1.0版本

1.1.课程目标

1、了解看源码最有效的方式，先猜测后验证，不要一开始就去调试代码。

2、浓缩就是精华，用 300行最简洁的代码

提炼Spring的基本设计思想。

3、掌握Spring框架的基本脉络。

1.2.内容定位

1、具有1年以上的SpringMVC使用经验。

2、希望深入了解Spring源码的人群，对 Spring有一个整体的宏观感受。

3、全程手写实现SpringMVC的核心功能，从最简单的V1版本一步一步优化为V2版本，最后到V3版本。

1.3.实现思路

先来介绍一下Mini版本的Spring基本实现思路,如下图所示:

1.4.自定义配置 application.properties 文件

为了解析方便,我们用application.properties来代替application.xml文件，具体配置内容如下:

scanPackage=com.gupaoedu.demo

1.5.配置web.xml文件

大家都知道,所有依赖于web容器的项目,都是从读取web.xml文件开始的。我们先配置好web.xml 中的内容。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:javaee="http://java.sun.com/xml/ns/javaee"
	xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	version="2.4">
	<display-name>Gupao Web Application</display-name>
	<servlet>
		<servlet-name>gpmvc</servlet-name>
		<servlet-class>com.gupaoedu.mvcframework.v2.servlet.GPDispatchServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>application.properties</param-value>
		</init-param>

		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>gpmvc</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>
</web-app>

其中GPDispatcherServlet是有自己模拟Spring实现的核心功能类。

1.6.自定义 Annotation

@GPService 注解:

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

@GPAutowired 注解：

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

@GPController 注解：

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

@GPRequestMapping 注解：

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

@GPRequestParam 注解：

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

1.7.配置 Annotation

配置业务实现类DemoService :

/**
 * 核心业务逻辑
 */
@GPService
public class DemoService implements IDemoService{

   public String get(String name) {
      return "My name is " + name + ",from service.";
   }

}

配置请求入口类DemoAction :

//虽然，用法一样，但是没有功能
@GPController
@GPRequestMapping("/demo")
public class DemoAction {

  	@GPAutowired private IDemoService demoService;

	@GPRequestMapping("/query")
	public void query(HttpServletRequest req, HttpServletResponse resp,
					  @GPRequestParam("name") String name){
		String result = demoService.get(name);
		// String result = "My name is " + name;
		try {
			resp.getWriter().write(result);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@GPRequestMapping("/add")
	public void add(HttpServletRequest req, HttpServletResponse resp,
					@GPRequestParam("a") Integer a, @GPRequestParam("b") Integer b){
		try {
			resp.getWriter().write(a + "+" + b + "=" + (a + b));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@GPRequestMapping("/sub")
	public void add(HttpServletRequest req, HttpServletResponse resp,
					@GPRequestParam("a") Double a, @GPRequestParam("b") Double b){
		try {
			resp.getWriter().write(a + "-" + b + "=" + (a - b));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@GPRequestMapping("/remove")
	public String  remove(@GPRequestParam("id") Integer id){
		return "" + id;
	}

}

至此，配置阶段就已经完成。

1.8.容器初始化实现V1版本

所有的核心逻辑全部写在一个init()方法中。

public class GPDispatcherServlet extends HttpServlet {
    private Map<String,Object> mapping = new HashMap<String, Object>();
    @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) {
            resp.getWriter().write("500 Exception " + Arrays.toString(e.getStackTrace()));
        }
    }
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        String url = req.getRequestURI();
        String contextPath = req.getContextPath();
        url = url.replace(contextPath, "").replaceAll("/+", "/");
        if(!this.mapping.containsKey(url)){resp.getWriter().write("404 Not Found!!");return;}
        Method method = (Method) this.mapping.get(url);
        Map<String,String[]> params = req.getParameterMap();
        method.invoke(this.mapping.get(method.getDeclaringClass().getName()),new Object[]{req,resp,params.get("name")[0]});
    }

    //init方法肯定干得的初始化的工作
    //inti首先我得初始化所有的相关的类，IOC容器、servletBean
    @Override
    public void init(ServletConfig config) throws ServletException {
        InputStream is = null;
        try{
            Properties configContext = new Properties();
            is = this.getClass().getClassLoader().getResourceAsStream(config.getInitParameter("contextConfigLocation"));
            configContext.load(is);
            String scanPackage = configContext.getProperty("scanPackage");
            doScanner(scanPackage);
            for (String className : mapping.keySet()) {
                if(!className.contains(".")){continue;}
                Class<?> clazz = Class.forName(className);
                if(clazz.isAnnotationPresent(GPController.class)){
                    mapping.put(className,clazz.newInstance());
                    String baseUrl = "";
                    if (clazz.isAnnotationPresent(GPRequestMapping.class)) {
                        GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);
                        baseUrl = requestMapping.value();
                    }
                    Method[] methods = clazz.getMethods();
                    for (Method method : methods) {
                        if (!method.isAnnotationPresent(GPRequestMapping.class)) {  continue; }
                        GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);
                        String url = (baseUrl + "/" + requestMapping.value()).replaceAll("/+", "/");
                        mapping.put(url, method);
                        System.out.println("Mapped " + url + "," + method);
                    }
                }else if(clazz.isAnnotationPresent(GPService.class)){
                        GPService service = clazz.getAnnotation(GPService.class);
                        String beanName = service.value();
                        if("".equals(beanName)){beanName = clazz.getName();}
                        Object instance = clazz.newInstance();
                        mapping.put(beanName,instance);
                        for (Class<?> i : clazz.getInterfaces()) {
                            mapping.put(i.getName(),instance);
                        }
                }else {continue;}
            }
            for (Object object : mapping.values()) {
                if(object == null){continue;}
                Class clazz = object.getClass();
                if(clazz.isAnnotationPresent(GPController.class)){
                    Field [] fields = clazz.getDeclaredFields();
                    for (Field field : fields) {
                        if(!field.isAnnotationPresent(GPAutowired.class)){continue; }
                        GPAutowired autowired = field.getAnnotation(GPAutowired.class);
                        String beanName = autowired.value();
                        if("".equals(beanName)){beanName = field.getType().getName();}
                        field.setAccessible(true);
                        try {
                            field.set(mapping.get(clazz.getName()),mapping.get(beanName));
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        } catch (Exception e) {
        }finally {
            if(is != null){
                try {is.close();} catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.print("GP MVC Framework is init");
    }
    private void doScanner(String scanPackage) {
        URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll("\.","/"));
        File classDir = new File(url.getFile());
        for (File file : classDir.listFiles()) {
            if(file.isDirectory()){ doScanner(scanPackage + "." +  file.getName());}else {
                if(!file.getName().endsWith(".class")){continue;}
                String clazzName = (scanPackage + "." + file.getName().replace(".class",""));
                mapping.put(clazzName,null);
            }
        }
    }
}

1.9.实现V2版本

在 V1版本上进了优化，采用了常用的设计模式（工厂模式、单例模式、委派模式、策略模式），将 inito方法中的代码进行封装。按照之前的实现思路，先搭基础框架,再填肉注血,具体代码如下:

//初始化阶段
@Override
public void init(ServletConfig config) throws ServletException {
    //1、加载配置文件
    doLoadConfig(config.getInitParameter("contextConfigLocation"));

    //2、扫描相关的类
    doScanner(contextConfig.getProperty("scanPackage"));
    
    //3、初始化扫描到的类，并且将它们放入到ICO容器之中
    doInstance();
    
    //4、完成依赖注入
    doAutowired();

    //5、初始化HandlerMapping
    initHandlerMapping();

    System.out.println("GP Spring framework is init.");
}

声明全局的成员变量，其中IOC容器就是注册时单例的具体案例：

//保存application.properties配置文件中的内容
private Properties contextConfig = new Properties();

//保存扫描的所有的类名
private List<String> classNames = new ArrayList<String>();

//传说中的IOC容器，我们来揭开它的神秘面纱
//为了简化程序，暂时不考虑ConcurrentHashMap
// 主要还是关注设计思想和原理
private Map<String,Object> ioc = new HashMap<String,Object>();

//保存url和Method的对应关系
private Map<String,Method> handlerMapping = new HashMap<String,Method>();

实现 doLoadConfig方法:

//加载配置文件
private void doLoadConfig(String contextConfigLocation) {
    //直接从类路径下找到Spring主配置文件所在的路径
    //并且将其读取出来放到Properties对象中
    //相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
    InputStream fis = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
    try {
        contextConfig.load(fis);
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(null != fis){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

实现doScanner()方法：

//扫描出相关的类
private void doScanner(String scanPackage) {
    //scanPackage = com.gupaoedu.demo ，存储的是包路径
    //转换为文件路径，实际上就是把.替换为/就OK了
    //classpath
    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{
            if(!file.getName().endsWith(".class")){ continue;}
            String className = (scanPackage + "." + file.getName().replace(".class",""));
            classNames.add(className);
        }
    }
}

实现dolnstance()方法，dolnstance。方法就是工厂模式的具体实现：

private void doInstance() {
    //初始化，为DI做准备
    if(classNames.isEmpty()){return;}

    try {
        for (String className : classNames) {
            Class<?> clazz = Class.forName(className);

            //什么样的类才需要初始化呢？
            //加了注解的类，才初始化，怎么判断？
            //为了简化代码逻辑，主要体会设计思想，只举例 @Controller和@Service,
            // @Componment...就一一举例了
            if(clazz.isAnnotationPresent(GPController.class)){
                Object instance = clazz.newInstance();
                //Spring默认类名首字母小写
                String beanName = toLowerFirstCase(clazz.getSimpleName());
                ioc.put(beanName,instance);
            }else if(clazz.isAnnotationPresent(GPService.class)){
                //1、自定义的beanName
                GPService service = clazz.getAnnotation(GPService.class);
                String beanName = service.value();
                //2、默认类名首字母小写
                if("".equals(beanName.trim())){
                    beanName = toLowerFirstCase(clazz.getSimpleName());
                }

                Object instance = clazz.newInstance();
                ioc.put(beanName,instance);
                //3、根据类型自动赋值,投机取巧的方式
                for (Class<?> i : clazz.getInterfaces()) {
                    if(ioc.containsKey(i.getName())){
                        throw new Exception("The “" + i.getName() + "” is exists!!");
                    }
                    //把接口的类型直接当成key了
                    ioc.put(i.getName(),instance);
                }
            }else {
                continue;
            }

        }
    }catch (Exception e){
        e.printStackTrace();
    }

}

为了处理方便,自己实现了 toLowerFirstCase方法,来实现类名首字母小写,具体代码如下：

//如果类名本身是小写字母，确实会出问题
//但是我要说明的是：这个方法是我自己用，private的
//传值也是自己传，类也都遵循了驼峰命名法
//默认传入的值，存在首字母小写的情况，也不可能出现非字母的情况

//为了简化程序逻辑，就不做其他判断了，大家了解就OK
//其实用写注释的时间都能够把逻辑写完了
private String toLowerFirstCase(String simpleName) {
    char [] chars = simpleName.toCharArray();
    //之所以加，是因为大小写字母的ASCII码相差32，
    // 而且大写字母的ASCII码要小于小写字母的ASCII码
    //在Java中，对char做算学运算，实际上就是对ASCII码做算学运算
    chars[0] += 32;
    return String.valueOf(chars);
}

实现 doAutowired方法：

//自动依赖注入
private void doAutowired() {
    if(ioc.isEmpty()){return;}

    for (Map.Entry<String, Object> entry : ioc.entrySet()) {
        //Declared 所有的，特定的 字段，包括private/protected/default
        //正常来说，普通的OOP编程只能拿到public的属性
        Field[] fields = entry.getValue().getClass().getDeclaredFields();
        for (Field field : fields) {
            if(!field.isAnnotationPresent(GPAutowired.class)){continue;}
            GPAutowired autowired = field.getAnnotation(GPAutowired.class);

            //如果用户没有自定义beanName，默认就根据类型注入
            //这个地方省去了对类名首字母小写的情况的判断，这个作为课后作业
            //小伙伴们自己去完善
            String beanName = autowired.value().trim();
            if("".equals(beanName)){
                //获得接口的类型，作为key待会拿这个key到ioc容器中去取值
                beanName = field.getType().getName();
            }

            //如果是public以外的修饰符，只要加了@Autowired注解，都要强制赋值
            //反射中叫做暴力访问， 强吻
            field.setAccessible(true);

            try {
                //用反射机制，动态给字段赋值
                field.set(entry.getValue(),ioc.get(beanName));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

实现dolnitHandlerMapping方法，handlerMapping就是策略模式的应用案例：

//初始化url和Method的一对一对应关系
private void initHandlerMapping() {
    if(ioc.isEmpty()){ return; }

    for (Map.Entry<String, Object> entry : ioc.entrySet()) {
        Class<?> clazz = entry.getValue().getClass();

        if(!clazz.isAnnotationPresent(GPController.class)){continue;}

        //保存写在类上面的@GPRequestMapping("/demo")
        String baseUrl = "";
        if(clazz.isAnnotationPresent(GPRequestMapping.class)){
            GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);
            baseUrl = requestMapping.value();
        }

        //默认获取所有的public方法
        for (Method method : clazz.getMethods()) {
            if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}

            GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);
            //优化
            // //demo///query
            String url = ("/" + baseUrl + "/" + requestMapping.value())
                        .replaceAll("/+","/");
            handlerMapping.put(url,method);
            System.out.println("Mapped :" + url + "," + method);
        }
    }
}

到这里位置初始化阶段就已经完成，接下实现运行阶段的逻辑，来看doPost/doGet的代码:

@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 {

    //6、调用，运行阶段
    try {
        doDispatch(req,resp);
    } catch (Exception e) {
        e.printStackTrace();
        resp.getWriter().write("500 Exection,Detail : " + Arrays.toString(e.getStackTrace()));
    }


}

doPost()方法中，用了委派模式，委派模式的具体逻辑在doDispatch方法中：

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    String url = req.getRequestURI();
    String contextPath = req.getContextPath();
    url = url.replace(contextPath, "").replaceAll("/+", "/");
    if(!this.mapping.containsKey(url)){resp.getWriter().write("404 Not Found!!");return;}
    Method method = (Method) this.mapping.get(url);
    Map<String,String[]> params = req.getParameterMap();
    method.invoke(this.mapping.get(method.getDeclaringClass().getName()),new Object[]{req,resp,params.get("name")[0]});
}

在以上代码中，doDispatch。虽然完成了动态委派并反射调用，但对url参数处理还是静态代码。的动态获E 要实现url参数 ,其实还稍微有些复杂。我们可以优化doDispatch方法的实现逻辑，代码如下:

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    //绝对路径
    String url = req.getRequestURI();
    //处理成相对路径
    String contextPath = req.getContextPath();
    url = url.replaceAll(contextPath,"").replaceAll("/+","/");

    if(!this.handlerMapping.containsKey(url)){
        resp.getWriter().write("404 Not Found!!!");
        return;
    }

    Method method = this.handlerMapping.get(url);

    //从reqest中拿到url传过来的参数
    Map<String,String[]> params = req.getParameterMap();

    //获取方法的形参列表
    Class<?> [] parameterTypes = method.getParameterTypes();

    Object [] paramValues = new Object[parameterTypes.length];

    for (int i = 0; i < parameterTypes.length; i ++) {
        Class parameterType = parameterTypes[i];
        //不能用instanceof，parameterType它不是实参，而是形参
        if(parameterType == HttpServletRequest.class){
            paramValues[i] = req;
            continue;
        }else if(parameterType == HttpServletResponse.class){
            paramValues[i] = resp;
            continue;
        }else if(parameterType == String.class){
            GPRequestParam requestParam = (GPRequestParam)parameterType.getAnnotation(GPRequestParam.class);
            if(params.containsKey(requestParam.value())) {
                for (Map.Entry<String,String[]> param : params.entrySet()){
                    String value = Arrays.toString(param.getValue())
                            .replaceAll("\[|\]","")
                            .replaceAll("\s",",");
                    paramValues[i] = value;
                }
            }
        }
    }

    //投机取巧的方式
    //通过反射拿到method所在class，拿到class之后还是拿到class的名称
    //再调用toLowerFirstCase获得beanName
    String beanName  = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
    method.invoke(ioc.get(beanName),paramValues);
}

1.10.实现V3版本

在 V2版本中，基本功能以及完全实现，但代码的优雅程度还不如人意。譬如HandlerMapping还不能像SpringMVC 一样支持正则,url参数还不支持强制类型转换,在反射调用前还需要重新获取beanName ,在V3版本中,下面我们继续优化。

首先，改造HandlerMapping , 在真实的Spring源码中，HandlerMapping其实是一个List而非Mapo List中的元素是一个自定义的类型。现在我们来仿真写一段代码，先定义一个内部类Handler类 :

//保存一个url和一个Method的关系
private class Handler {
    //必须把url放到HandlerMapping才好理解吧
    private Pattern pattern;  //正则
    private Method method;
    private Object controller;
    private Class<?> [] paramTypes;

    public Pattern getPattern() {
        return pattern;
    }

    public Method getMethod() {
        return method;
    }

    public Object getController() {
        return controller;
    }

    public Class<?>[] getParamTypes() {
        return paramTypes;
    }

    //形参列表
    //参数的名字作为key,参数的顺序，位置作为值
    private Map<String,Integer> paramIndexMapping;

    public Handler(Pattern pattern, Object controller, Method method) {
        this.pattern = pattern;
        this.method = method;
        this.controller = controller;

        paramTypes = method.getParameterTypes();

        paramIndexMapping = new HashMap<String, Integer>();
        putParamIndexMapping(method);
    }

    private void putParamIndexMapping(Method method){

        //提取方法中加了注解的参数
        //把方法上的注解拿到，得到的是一个二维数组
        //因为一个参数可以有多个注解，而一个方法又有多个参数
        Annotation [] [] pa = method.getParameterAnnotations();
        for (int i = 0; i < pa.length ; i ++) {
            for(Annotation a : pa[i]){
                if(a instanceof GPRequestParam){
                    String paramName = ((GPRequestParam) a).value();
                    if(!"".equals(paramName.trim())){
                        paramIndexMapping.put(paramName, i);
                    }
                }
            }
        }

        //提取方法中的request和response参数
        Class<?> [] paramsTypes = method.getParameterTypes();
        for (int i = 0; i < paramsTypes.length ; i ++) {
            Class<?> type = paramsTypes[i];
            if(type == HttpServletRequest.class ||
               type == HttpServletResponse.class){
                paramIndexMapping.put(type.getName(),i);
            }
        }
    }
}

然后，优化HandlerMapping的结构，代码如下：

//保存所有的URL和方法的映射关系
private List<Handler> handlerMapping = new ArrayList<Handler>();

修改 dolnitHandlerMapping方法：

//初始化url和Method的一对一对应关系
private void initHandlerMapping() {
    if(ioc.isEmpty()){ return; }

    for (Map.Entry<String, Object> entry : ioc.entrySet()) {
        Class<?> clazz = entry.getValue().getClass();

        if(!clazz.isAnnotationPresent(GPController.class)){continue;}


        //保存写在类上面的@GPRequestMapping("/demo")
        String baseUrl = "";
        if(clazz.isAnnotationPresent(GPRequestMapping.class)){
            GPRequestMapping requestMapping = clazz.getAnnotation(GPRequestMapping.class);
            baseUrl = requestMapping.value();
        }

        //默认获取所有的public方法
        for (Method method : clazz.getMethods()) {
            if(!method.isAnnotationPresent(GPRequestMapping.class)){continue;}

            GPRequestMapping requestMapping = method.getAnnotation(GPRequestMapping.class);
            //优化
            // //demo///query
            String regex = ("/" + baseUrl + "/" + requestMapping.value())
                .replaceAll("/+","/");
            Pattern pattern = Pattern.compile(regex);
            this.handlerMapping.add(new Handler(pattern,entry.getValue(),method));
            System.out.println("Mapped :" + pattern + "," + method);
        }
    }
}

修改 doDispatch()方法:

private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {

    Handler handler = getHandler(req);
    if (handler == null) {
        resp.getWriter().write("404 Not Found!!!");
        return;
    }

    //获得方法的形参列表
    Class<?>[] paramTypes = handler.getParamTypes();

    Object[] paramValues = new Object[paramTypes.length];

    Map<String, String[]> params = req.getParameterMap();
    for (Map.Entry<String, String[]> parm : params.entrySet()) {
        String value = Arrays.toString(parm.getValue()).replaceAll("\[|\]", "")
            .replaceAll("\s", ",");

        if (!handler.paramIndexMapping.containsKey(parm.getKey())) {
            continue;
        }

        int index = handler.paramIndexMapping.get(parm.getKey());
        paramValues[index] = convert(paramTypes[index], value);
    }

    if (handler.paramIndexMapping.containsKey(HttpServletRequest.class.getName())) {
        int reqIndex = handler.paramIndexMapping.get(HttpServletRequest.class.getName());
        paramValues[reqIndex] = req;
    }

    if (handler.paramIndexMapping.containsKey(HttpServletResponse.class.getName())) {
        int respIndex = handler.paramIndexMapping.get(HttpServletResponse.class.getName());
        paramValues[respIndex] = resp;
    }

    Object returnValue = handler.method.invoke(handler.controller, paramValues);
    if (returnValue == null || returnValue instanceof Void) {
        return;
    }
    resp.getWriter().write(returnValue.toString());
}

private Handler getHandler(HttpServletRequest req) {
    if (handlerMapping.isEmpty()) {
        return null;
    }
    //绝对路径
    String url = req.getRequestURI();
    //处理成相对路径
    String contextPath = req.getContextPath();
    url = url.replaceAll(contextPath, "").replaceAll("/+", "/");


    for (Handler handler : this.handlerMapping) {
        Matcher matcher = handler.getPattern().matcher(url);
        if (!matcher.matches()) {
            continue;
        }
        return handler;
    }
    return null;
}

//url传过来的参数都是String类型的，HTTP是基于字符串协议
//只需要把String转换为任意类型就好
private Object convert(Class<?> type, String value) {
    //如果是int
    if (Integer.class == type) {
        return Integer.valueOf(value);
    } else if (Double.class == type) {
        return Double.valueOf(value);
    }
    //如果还有double或者其他类型，继续加if
    //这时候，我们应该想到策略模式了
    //在这里暂时不实现，希望小伙伴自己来实现
    return value;
}

在以上代码中,增加了两个方法，一个是getHandler。方法,主要负责处理url的正则匹配;一个是 convert()方法，主要负责url参数的强制类型转换。

至此,手写Mini版 SpringMVC框架就已全部完成。

1.11.运行效果演示

在浏览器输入：http://localhost:8080/demo/query.json?name=Tom , 就会得到下面的结果：

当然，真正的Spring要复杂很多，本课中主要通过手写的形式，了解Spring的基本设计思路以及设计模式如何应用，在以后的课程中，我们还会继续手写更加高仿真版本的Spring2.0。

1.12.作业

1、请用自己的语言描述Spring IOC、DI、MVC的基本执行原理。

IOC：调用init()方法加载配置文件。IOC容器初始化，Map<String, Object>。扫描相关的类，scan-package = “com.gupaoedu”。创建实例化并保存至容器，通过反射机制将类实例化放入IOC容器中。

DI：进行DI操作，扫描IOC容器中的实例，给没有赋值的属性自动赋值。

MVC：初始化HandlerMapping，将一个URL和一个Method进行一对一的关系映射到Map<String, Method>。

2、Spring中的Bean是线程安全的吗？为什么？

Spring框架并没有对单例的bean进行多线程的封装处理，线程安全问题和并发问题，需要我们开发者自己考虑。
但实际上，大部分的Spring bean并没有可变的状态（比如：service类和dao类），所有在某种程度上来说Spring单例bean是线程安全的。如果bean有多种状态的话（比如：View Model对象），就需要自行考虑线程安全问题。

参考资料：

1.《spring 5核心原理与30个类手写实战》谭勇德著