关于java:用300行代码手写1个Spring框架麻雀虽小五脏俱全

本文节选自《Spring 5 外围原理》

1 自定义配置

1.1 配置 application.properties 文件

为了解析不便，咱们用 application.properties 来代替 application.xml 文件，具体配置内容如下：

scanPackage=com.tom.demo

1.2 配置 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.tom.mvcframework.v1.servlet.GPDispatcherServlet</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.3 自定义注解

@GPService 注解如下：

package com.tom.mvcframework.annotation;
import java.lang.annotation.*;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPService {String value() default "";
}

@GPAutowired 注解如下：

package com.tom.mvcframework.annotation;
import java.lang.annotation.*;
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPAutowired {String value() default "";
}

@GPController 注解如下：

package com.tom.mvcframework.annotation;
import java.lang.annotation.*;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPController {String value() default "";
}

@GPRequestMapping 注解如下：

package com.tom.mvcframework.annotation;
import java.lang.annotation.*;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestMapping {String value() default "";
}

@GPRequestParam 注解如下：

package com.tom.mvcframework.annotation;
import java.lang.annotation.*;
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestParam {String value() default "";
}

1.4 配置注解

配置业务实现类 DemoService：

package com.tom.demo.service.impl;
import com.tom.demo.service.IDemoService;
import com.tom.mvcframework.annotation.GPService;
/**
 * 外围业务逻辑
 */
@GPService
public class DemoService implements IDemoService{public String get(String name) {return "My name is" + name;}
}

配置申请入口类 DemoAction：

package com.tom.demo.mvc.action;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.tom.demo.service.IDemoService;
import com.tom.mvcframework.annotation.GPAutowired;
import com.tom.mvcframework.annotation.GPController;
import com.tom.mvcframework.annotation.GPRequestMapping;
import com.tom.mvcframework.annotation.GPRequestParam;
@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);
      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("/remove")
   public void remove(HttpServletRequest req,HttpServletResponse resp,
                  @GPRequestParam("id") Integer id){}}

至此，配置全副实现。

2 容器初始化 1.0 版本

所有的外围逻辑全副写在 init() 办法中，代码如下：

package com.tom.mvcframework.v1.servlet;
import com.tom.mvcframework.annotation.GPAutowired;
import com.tom.mvcframework.annotation.GPController;
import com.tom.mvcframework.annotation.GPRequestMapping;
import com.tom.mvcframework.annotation.GPService;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;

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

3 申请执行

重点实现 doGet() 和 doPost() 办法，实际上就是在 doGet() 和 doPost() 办法中调用 doDispatch() 办法，具体代码如下：

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]});
    }
    @Override
    public void init(ServletConfig config) throws ServletException {...}

}

4 优化并实现 2.0 版本

在 1.0 版本上进行优化，采纳罕用的设计模式（工厂模式、单例模式、委派模式、策略模式），将 init() 办法中的代码进行封装。依照之前的实现思路，先搭根底框架，再“填肉注血”，具体代码如下：

// 初始化阶段
@Override
public void init(ServletConfig config) throws ServletException {

    //1. 加载配置文件
    doLoadConfig(config.getInitParameter("contextConfigLocation"));

    //2. 扫描相干的类
    doScanner(contextConfig.getProperty("scanPackage"));
    
    //3. 初始化扫描到的类，并且将它们放入 IoC 容器中
    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.tom.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.tom.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{if(!file.getName().endsWith(".class")){continue;}
            String className = (scanPackage + "." + file.getName().replace(".class",""));
            classNames.add(className);
        }
    }
}

实现 doInstance() 办法，doInstance() 办法就是工厂模式的具体实现：

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 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()) {
        // 获取所有的字段，包含 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();
            }


        }

    }


}

实现 initHandlerMapping() 办法，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);
            // 优化
            String url = ("/" + baseUrl + "/" + requestMapping.value())
                        .replaceAll("/+","/");
            handlerMapping.put(url,method);
            System.out.println("Mapped :" + url + "," + method);

        }


    }


}

到这里初始化的工作实现，接下来实现运行的逻辑，来看 doGet() 和 doPost() 办法的代码：

@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 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.replaceAll(contextPath,"").replaceAll("/+","/");
    if(!this.handlerMapping.containsKey(url)){resp.getWriter().write("404 Not Found!!");
        return;
    }
    Method method = this.handlerMapping.get(url);
    // 第一个参数：办法所在的实例
    // 第二个参数：调用时所须要的实参

    Map<String,String[]> params = req.getParameterMap();
    // 投机取巧的形式
    String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
    method.invoke(ioc.get(beanName),new Object[]{req,resp,params.get("name")[0]});
    //System.out.println(method);
}

在以上代码中，doDispatch() 尽管实现了动静委派并进行了反射调用，但对 url 参数的解决还是动态的。要实现 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);
    // 第一个参数：办法所在的实例
    // 第二个参数：调用时所须要的实参
    Map<String,String[]> params = req.getParameterMap();
    // 获取办法的形参列表
    Class<?> [] parameterTypes = method.getParameterTypes();
    // 保留申请的 url 参数列表
    Map<String,String[]> parameterMap = req.getParameterMap();
    // 保留赋值参数的地位
    Object [] paramValues = new Object[parameterTypes.length];
    // 依据参数地位动静赋值
    for (int i = 0; i < parameterTypes.length; i ++){Class parameterType = parameterTypes[i];
        if(parameterType == HttpServletRequest.class){paramValues[i] = req;
            continue;
        }else if(parameterType == HttpServletResponse.class){paramValues[i] = resp;
            continue;
        }else if(parameterType == String.class){

            // 提取办法中加了注解的参数
            Annotation[] [] pa = method.getParameterAnnotations();
            for (int j = 0; j < pa.length ; j ++) {for(Annotation a : pa[i]){if(a instanceof GPRequestParam){String paramName = ((GPRequestParam) a).value();
                        if(!"".equals(paramName.trim())){String value = Arrays.toString(parameterMap.get(paramName))
                                    .replaceAll("\\[|\\]","")
                                    .replaceAll("\\s",",");
                            paramValues[i] = value;
                        }
                    }
                }
            }

        }
    }
    // 投机取巧的形式
    // 通过反射取得 Method 所在的 Class，取得 Class 之后还要取得 Class 的名称
    // 再调用 toLowerFirstCase 取得 beanName
    String beanName = toLowerFirstCase(method.getDeclaringClass().getSimpleName());
    method.invoke(ioc.get(beanName),new Object[]{req,resp,params.get("name")[0]});
}

关注微信公众号『Tom 弹架构』回复“Spring”可获取残缺源码。

本文为“Tom 弹架构”原创，转载请注明出处。技术在于分享，我分享我高兴！如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。关注微信公众号『Tom 弹架构』可获取更多技术干货！

原创不易，保持很酷，都看到这里了，小伙伴记得点赞、珍藏、在看，一键三连加关注！如果你感觉内容太干，能够分享转发给敌人滋润滋润！