Spring学习之——手写Spring源码V2.0(实现IOC、D、MVC、AOP)

前言

在上一篇《Spring学习之——手写Spring源码(V1.0)》中，我实现了一个Mini版本的Spring框架，在这几天，博主又看了不少关于Spring源码解析的视频，受益匪浅，也对Spring的各组件有了自己的理解和认识，于是乎，在空闲时间把之前手写Spring的代码重构了一遍，遵循了单一职责的原则，使结构更清晰，并且实现了AOP，这次还是只引用一个servlet包，其他全部手写实现。

全部源码照旧放在文章末尾~

开发工具

环境：jdk8 + IDEA + maven

jar包：javax.servlet-2.5

项目结构

具体实现

配置文件

web.xml 与之前一样  并无改变

application.properties   增加了html页面路径和AOP的相关配置

#扫描路径#
scanPackage=com.wqfrw
 
#模板引擎路径#
templateRoot=template
 
#切面表达式#
pointCut=public .* com.wqfrw.service.impl..*ServiceImpl..*(.*)
#切面类#
aspectClass=com.wqfrw.aspect.LogAspect
#切面前置通知#
aspectBefore=before
#切面后置通知#
aspectAfter=after
#切面异常通知#
aspectAfterThrowing=afterThrowing
#切面异常类型#
aspectAfterThrowingName=java.lang.Exception

IOC与DI实现

1.在DispatcherServlet的init方法中初始化ApplicationContent；

2.ApplicationContent是Spring容器的主入口，通过创建BeanDefintionReader对象加载配置文件；

3.在BeanDefintionReader中将扫描到的类解析成BeanDefintion返回；

4.ApplicationContent中通过BeanDefintionMap这个缓存来关联BeanName与BeanDefintion对象之间的关系；

5.通过getBean方法，进行Bean的创建并封装为BeanWrapper对象，进行依赖注入，缓存到IoC容器中

　　/**
    * 功能描述: 初始化MyApplicationContext
    *
    * @创建人: 我恰芙蓉王
    * @创建时间: 2020年08月03日 18:54:01
    * @param configLocations
    * @return:
    **/
    public MyApplicationContext(String... configLocations) {
        this.configLocations = configLocations;
 
        try {
            //1.读取配置文件并解析BeanDefinition对象
            beanDefinitionReader = new MyBeanDefinitionReader(configLocations);
            List<MyBeanDefinition> beanDefinitionList = beanDefinitionReader.loadBeanDefinitions();
 
            //2.将解析后的BeanDefinition对象注册到beanDefinitionMap中
            doRegisterBeanDefinition(beanDefinitionList);
 
            //3.触发创建对象的动作,调用getBean()方法(Spring默认是延时加载)
            doCreateBean();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 功能描述: 真正触发IoC和DI的动作  1.创建Bean  2.依赖注入
     *
     * @param beanName
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月03日 19:48:58
     * @return: java.lang.Object
     **/
    public Object getBean(String beanName) {
        //============ 创建实例 ============
 
        //1.获取配置信息,只要拿到beanDefinition对象即可
        MyBeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
 
        //用反射创建实例  这个实例有可能是代理对象 也有可能是原生对象   封装成BeanWrapper统一处理
        Object instance = instantiateBean(beanName, beanDefinition);
        MyBeanWrapper beanWrapper = new MyBeanWrapper(instance);
 
        factoryBeanInstanceCache.put(beanName, beanWrapper);
 
        //============ 依赖注入 ============
        populateBean(beanName, beanDefinition, beanWrapper);
 
        return beanWrapper.getWrapperInstance();
    }

　　/**
     * 功能描述: 依赖注入
     *
     * @param beanName
     * @param beanDefinition
     * @param beanWrapper
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月03日 20:09:01
     * @return: void
     **/
    private void populateBean(String beanName, MyBeanDefinition beanDefinition, MyBeanWrapper beanWrapper) {
        Object instance = beanWrapper.getWrapperInstance();
        Class<?> clazz = beanWrapper.getWrapperClass();
 
        //只有加了注解的类才需要依赖注入
        if (!(clazz.isAnnotationPresent(MyController.class) || clazz.isAnnotationPresent(MyService.class))) {
            return;
        }
 
        //拿到bean所有的字段 包括private、public、protected、default
        for (Field field : clazz.getDeclaredFields()) {
 
            //如果没加MyAutowired注解的属性则直接跳过
            if (!field.isAnnotationPresent(MyAutowired.class)) {
                continue;
            }
 
            MyAutowired annotation = field.getAnnotation(MyAutowired.class);
            String autowiredBeanName = annotation.value().trim();
            if ("".equals(autowiredBeanName)) {
                autowiredBeanName = field.getType().getName();
            }
            //强制访问
            field.setAccessible(true);
            try {
                if (factoryBeanInstanceCache.get(autowiredBeanName) == null) { continue; }
                //赋值
                field.set(instance, this.factoryBeanInstanceCache.get(autowiredBeanName).getWrapperInstance());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

MVC实现

1.在DispatcherServlet的init方法中调用initStrategies方法初始化九大核心组件；

2.通过循环BeanDefintionMap拿到每个接口的url、实例对象、对应方法封装成一个HandlerMapping对象的集合，并建立HandlerMapping与HandlerAdapter(参数适配器)的关联；

3.初始化ViewResolver(视图解析器)，解析配置文件中模板文件路径(即html文件的路径，其作用类似于BeanDefintionReader)；

4.在运行阶段，调用doDispatch方法，根据请求的url找到对应的HandlerMapping；

5.在HandlerMapping对应的HandlerAdapter中，调用handle方法，进行参数动态赋值，反射调用接口方法，拿到返回值与返回页面封装成一个MyModelAndView对象返回；

6.通过ViewResolver拿到View(模板页面文件)，在View中通过render方法，通过正则将返回值与页面取值符号进行适配替换，渲染成html页面返回

　　/**
     * 功能描述: 初始化核心组件 在Spring中有九大核心组件，这里只实现三种
     *
     * @param context
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月04日 11:51:55
     * @return: void
     **/
    protected void initStrategies(MyApplicationContext context) {
        //多文件上传组件
        //initMultipartResolver(context);
        //初始化本地语言环境
        //initLocaleResolver(context);
        //初始化模板处理器
        //initThemeResolver(context);
        //初始化请求分发处理器
        initHandlerMappings(context);
        //初始化参数适配器
        initHandlerAdapters(context);
        //初始化异常拦截器
        //initHandlerExceptionResolvers(context);
        //初始化视图预处理器
        //initRequestToViewNameTranslator(context);
        //初始化视图转换器
        initViewResolvers(context);
        //缓存管理器(值栈)
        //initFlashMapManager(context);
    }

　　/**
     * 功能描述: 进行参数适配
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 19:41:38
     * @param req
     * @param resp
     * @param mappedHandler
     * @return: com.framework.webmvc.servlet.MyModelAndView
     **/
    public MyModelAndView handle(HttpServletRequest req, HttpServletResponse resp, MyHandlerMapping mappedHandler) throws Exception {
 
        //保存参数的名称和位置
        Map<String, Integer> paramIndexMapping = new HashMap<>();
 
        //获取这个方法所有形参的注解   因一个参数可以添加多个注解  所以是一个二维数组
        Annotation[][] pa = mappedHandler.getMethod().getParameterAnnotations();
 
        /**
         * 获取加了MyRequestParam注解的参数名和位置   放入到paramIndexMapping中
         */
        for (int i = 0; i < pa.length; i++) {
            for (Annotation annotation : pa[i]) {
                if (!(annotation instanceof MyRequestParam)) {
                    continue;
                }
                String paramName = ((MyRequestParam) annotation).value();
                if (!"".equals(paramName.trim())) {
                    paramIndexMapping.put(paramName, i);
                }
            }
        }
 
        //方法的形参列表
        Class<?>[] parameterTypes = mappedHandler.getMethod().getParameterTypes();
 
        /**
         * 获取request和response的位置(如果有的话)   放入到paramIndexMapping中
         */
        for (int i = 0; i < parameterTypes.length; i++) {
            Class<?> parameterType = parameterTypes[i];
            if (parameterType == HttpServletRequest.class || parameterType == HttpServletResponse.class) {
                paramIndexMapping.put(parameterType.getName(), i);
            }
        }
 
        //拿到一个请求所有传入的实际实参  因为一个url上可以多个相同的name,所以此Map的结构为一个name对应一个value[]
        //例如：request中的参数t1=1&t1=2&t2=3形成的map结构：
        //key=t1;value[0]=1,value[1]=2
        //key=t2;value[0]=3
        Map<String, String[]> paramsMap = req.getParameterMap();
 
        //自定义初始实参列表(反射调用Controller方法时使用)
        Object[] paramValues = new Object[parameterTypes.length];
 
        /**
         * 从paramIndexMapping中取出参数名与位置   动态赋值
         */
        for (Map.Entry<String, String[]> entry : paramsMap.entrySet()) {
            //拿到请求传入的实参
            String value = entry.getValue()[0];
 
            //如果包含url参数上的key 则动态转型赋值
            if (paramIndexMapping.containsKey(entry.getKey())) {
                //获取这个实参的位置
                int index = paramIndexMapping.get(entry.getKey());
                //动态转型并赋值
                paramValues[index] = caseStringValue(value, parameterTypes[index]);
            }
        }
 
        /**
         * request和response单独赋值
         */
        if (paramIndexMapping.containsKey(HttpServletRequest.class.getName())) {
            int index = paramIndexMapping.get(HttpServletRequest.class.getName());
            paramValues[index] = req;
        }
        if (paramIndexMapping.containsKey(HttpServletResponse.class.getName())) {
            int index = paramIndexMapping.get(HttpServletResponse.class.getName());
            paramValues[index] = resp;
        }
 
        //方法调用 拿到返回结果
        Object result = mappedHandler.getMethod().invoke(mappedHandler.getController(), paramValues);
        if (result == null || result instanceof Void) {
            return null;
        } else if (mappedHandler.getMethod().getReturnType() == MyModelAndView.class) {
            return (MyModelAndView) result;
        }
        return null;
    }
 
    /**
     * 功能描述: 动态转型
     *
     * @param value String类型的value
     * @param clazz 实际对象的class
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月04日 16:34:40
     * @return: java.lang.Object  实际对象的实例
     **/
    private Object caseStringValue(String value, Class<?> clazz) throws Exception {
        //通过class对象获取一个入参为String的构造方法  没有此方法则抛出异常
        Constructor constructor = clazz.getConstructor(new Class[]{String.class});
        //通过构造方法new一个实例返回
        return constructor.newInstance(value);
    }

    /**
     * 功能描述: 对页面内容进行渲染
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月04日 17:54:40
     * @param model
     * @param req
     * @param resp
     * @return: void
     **/
    public void render(Map<String, ?> model, HttpServletRequest req, HttpServletResponse resp) throws Exception {
        StringBuilder sb = new StringBuilder();
        //只读模式 读取文件
        RandomAccessFile ra = new RandomAccessFile(this.viewFile, "r");
 
        String line = null;
        while ((line = ra.readLine()) != null) {
            line = new String(line.getBytes("ISO-8859-1"), "utf-8");
 
            //%{name}
            Pattern pattern = Pattern.compile("%\\{[^\\}]+\\}", Pattern.CASE_INSENSITIVE);
            Matcher matcher = pattern.matcher(line);
 
            while (matcher.find()) {
                String paramName = matcher.group();
 
                paramName = paramName.replaceAll("%\\{|\\}", "");
                Object paramValue = model.get(paramName);
                line = matcher.replaceFirst(makeStringForRegExp(paramValue.toString()));
                matcher = pattern.matcher(line);
            }
            sb.append(line);
        }
 
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().write(sb.toString());
    }

html页面

404.html

<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="UTF-8">
    <title>页面没有找到</title>
</head>
<body>
    <font size="25" color="red">Exception Code : 404  Not Found</font>
    <br><br><br>
    @我恰芙蓉王
</body>
</html>

500.html

<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="UTF-8">
    <title>服务器崩溃</title>
</head>
<body>
    <font size="25" color="red">Exception Code : 500 <br/> 服务器崩溃了~</font>
    <br/>
    <br/>
    <b>Message:%{message}</b>
    <br/>
    <b>StackTrace:%{stackTrace}</b>
    <br/>
    <br><br><br>
    @我恰芙蓉王
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="UTF-8">
    <title>自定义SpringMVC模板引擎Demo</title>
</head>
<center>
    <h1>大家好,我是%{name}</h1>
    <h2>我爱%{food}</h2>
    <font color="red">
        <h2>时间:%{date}</h2>
    </font>
    <br><br><br>
    @我恰芙蓉王
</center>
</html>

测试接口调用返回页面

404.html  接口未找到

500.html  服务器错误

index.html   正常返回页面

AOP实现

1.参照IOC与DI实现第五点，在对象实例化之后，依赖注入之前，将配置文件中AOP的配置解析至AopConfig中；

2.通过配置的pointCut参数，正则匹配此实例对象的类名与方法名，如果匹配上，将配置的三个通知方法(Advice)与此方法建立联系，生成一个  Map<Method, Map<String, MyAdvice>> methodCache  的缓存；

3.将原生对象、原生对象class、原生对象方法与通知方法的映射关系封装成AdviceSupport对象；

4.如果需要代理，则使用JdkDynamicAopProxy中getProxy方法，获得一个此原生对象的代理对象，并将原生对象覆盖；

5.JdkDynamicAopProxy实现了InvocationHandler接口(使用JDK的动态代理)，重写invoke方法，在此方法中执行切面方法与原生对象方法。

　　/**
     * 功能描述: 反射实例化对象
     *
     * @param beanName
     * @param beanDefinition
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月03日 20:08:50
     * @return: java.lang.Object
     **/
    private Object instantiateBean(String beanName, MyBeanDefinition beanDefinition) {
        String className = beanDefinition.getBeanClassName();
 
        Object instance = null;
        try {
            Class<?> clazz = Class.forName(className);
            instance = clazz.newInstance();
 
            /**
             *  ===========接入AOP begin===========
             */
            MyAdviceSupport support = instantiateAopConfig(beanDefinition);
            support.setTargetClass(clazz);
            support.setTarget(instance);
            //如果需要代理  则用代理对象覆盖目标对象
            if (support.pointCutMatch()) {
                instance = new MyJdkDynamicAopProxy(support).getProxy();
            }
            /**
             * ===========接入AOP end===========
             */
 
            factoryBeanObjectCache.put(beanName, instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;
    }

　　/**
     * 功能描述: 解析配置  pointCut
     *
     * @param
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 11:20:21
     * @return: void
     **/
    private void parse() {
        String pointCut = aopConfig.getPointCut()
                .replaceAll("\\.", "\\\\.")
                .replaceAll("\\\\.\\*", ".*")
                .replaceAll("\\(", "\\\\(")
                .replaceAll("\\)", "\\\\)");
 
        //public .*.com.wqfrw.service..*impl..*(.*)
        String pointCutForClassRegex = pointCut.substring(0, pointCut.lastIndexOf("\\(") - 4);
        this.pointCutClassPattern = Pattern.compile(pointCutForClassRegex.substring(pointCutForClassRegex.lastIndexOf(" ") + 1));
 
        methodCache = new HashMap<>();
        //匹配方法的正则
        Pattern pointCutPattern = Pattern.compile(pointCut);
 
        //1.对回调通知进行缓存
        Map<String, Method> aspectMethods = new HashMap<>();
        try {
            //拿到切面类的class  com.wqfrw.aspect.LogAspect
            Class<?> aspectClass = Class.forName(this.aopConfig.getAspectClass());
            //将切面类的通知方法缓存到aspectMethods
            Stream.of(aspectClass.getMethods()).forEach(v -> aspectMethods.put(v.getName(), v));
 
            //2.扫描目标类的方法，去循环匹配
            for (Method method : targetClass.getMethods()) {
                String methodString = method.toString();
                //如果目标方法有抛出异常  则截取
                if (methodString.contains("throws")) {
                    methodString = methodString.substring(0, methodString.lastIndexOf("throws")).trim();
                }
                /**
                 * 匹配目标类方法   如果匹配上,就将缓存好的通知与它建立联系  如果没匹配上,则忽略
                 */
                Matcher matcher = pointCutPattern.matcher(methodString);
                if (matcher.matches()) {
                    Map<String, MyAdvice> adviceMap = new HashMap<>();
                    //前置通知
                    if (!(null == aopConfig.getAspectBefore() || "".equals(aopConfig.getAspectBefore()))) {
                        adviceMap.put("before", new MyAdvice(aspectClass.newInstance(), aspectMethods.get(aopConfig.getAspectBefore())));
                    }
 
                    //后置通知
                    if (!(null == aopConfig.getAspectAfter() || "".equals(aopConfig.getAspectAfter()))) {
                        adviceMap.put("after", new MyAdvice(aspectClass.newInstance(), aspectMethods.get(aopConfig.getAspectAfter())));
                    }
 
                    //异常通知
                    if (!(null == aopConfig.getAspectAfterThrowing() || "".equals(aopConfig.getAspectAfterThrowing()))) {
                        MyAdvice advice = new MyAdvice(aspectClass.newInstance(), aspectMethods.get(aopConfig.getAspectAfterThrowing()));
                        advice.setThrowingName(aopConfig.getAspectAfterThrowingName());
                        adviceMap.put("afterThrowing", advice);
                    }
                    //建立关联
                    methodCache.put(method, adviceMap);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

　　/**
     * 功能描述: 返回一个代理对象
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 14:17:22
     * @param
     * @return: java.lang.Object
     **/
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), this.support.getTargetClass().getInterfaces(), this);
    }
 
    /**
     * 功能描述: 重写invoke
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 20:29:19
     * @param proxy
     * @param method
     * @param args
     * @return: java.lang.Object
     **/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 
        Map<String, MyAdvice> advices = support.getAdvices(method, support.getTargetClass());
 
        Object result = null;
        try {
            //调用前置通知
            invokeAdvice(advices.get("before"));
 
            //执行原生目标方法
            result = method.invoke(support.getTarget(), args);
 
            //调用后置通知
            invokeAdvice(advices.get("after"));
        } catch (Exception e) {
            //调用异常通知
            invokeAdvice(advices.get("afterThrowing"));
            throw e;
        }
 
        return result;
    }
 
    /**
     * 功能描述: 执行切面方法
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 11:09:32
     * @param advice
     * @return: void
     **/
    private void invokeAdvice(MyAdvice advice) {
        try {
            advice.getAdviceMethod().invoke(advice.getAspect());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

/**
 * @ClassName LogAspect
 * @Description TODO(切面类)
 * @Author 我恰芙蓉王
 * @Date 2020年08月05日 10:03
 * @Version 2.0.0
 **/
 
public class LogAspect {
 
    /**
     * 功能描述: 前置通知
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 17:24:30
     * @param
     * @return: void
     **/
    public void before(){
        System.err.println("=======前置通知=======");
    }
 
    /**
     * 功能描述: 后置通知
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 17:24:40
     * @param
     * @return: void
     **/
    public void after(){
        System.err.println("=======后置通知=======\n");
    }
 
    /**
     * 功能描述: 异常通知
     *
     * @创建人: 我恰芙蓉王
     * @创建时间: 2020年08月05日 17:24:47
     * @param
     * @return: void
     **/
    public void afterThrowing(){
        System.err.println("=======出现异常=======");
    }
}

执行结果

总结

以上只贴出了部分核心实现代码，有兴趣的童鞋可以下载源码调试，具体的注释我都在代码中写得很清楚。

代码已经提交至Git : https://github.com/wqfrw/HandWritingSpringV2.0