聊一个自己写的MVC框架

Posted jolivan

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了聊一个自己写的MVC框架相关的知识,希望对你有一定的参考价值。

  也有个一周没有更新博客了,其实我没有偷懒,因为之前一直在看Spring源码,所以想着去写一个类Spring的框架,也没有给自己定什么高的要求,简单实现MVC、AOP、IOC等功能就行。现在这个框架基本上已经成型了,自己也测试过了,因此拿出来和大家分享一下。

  我本文就不写标题了,因为自己的思路是跟着代码走的,所以可能说着说着MVC就跳到DI那一块了。首先我在开始的时候,也是跟随着大部分人的思路,先从DispatcherServlet入手。因为为DispatcherServlet是和用户交互的。和DispatcherServlet交互的有四个模块,分别是:HandlerMapping、HandlerAdapter、ViewResolver、ModelAndView,我定义了四个类分别对应着这四个模块,先不说他们是怎么工作的,先聊一下DispatcherServlet。

 

  它和HandlerMapping先进行交互,然后HandlerMapping处理拿到对象。

private void initHandlerMappings(LusheApplicationContext context) {
        //按照我们通常的理解应该是一个Map,Map<String,Method> map;map.put(url,Method)
        //首先从容器中取到所有的实例
        String [] beanNames = context.getBeanDefinitionNames();
        try {
            for (String beanName : beanNames) {
                //到了MVC层,对外提供的方法只有一个getBean方法
                Object proxy = context.getBean(beanName);
                Object originObject = LusheAopProxyUtils.getOriginObject(proxy);

                Class<?> clazz = originObject.getClass();

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

                String baseUrl = "";

                if (clazz.isAnnotationPresent(RequestMapping.class)) {
                    RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                    baseUrl = requestMapping.value();
                }

                //扫描所有的public方法
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (!method.isAnnotationPresent(RequestMapping.class)) {
                        continue;
                    }

                    RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                    String regex = ("/" + baseUrl + requestMapping.value().replaceAll("\\\\*", ".*")).replaceAll("/+", "/");
                    Pattern pattern = Pattern.compile(regex);
                    this.handlerMappings.add(new LusheHandlerMapping(pattern, originObject, method));
                    System.out.println("Mapping: " + regex + " , " + method);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

  我是这么处理的,我只给Servlet获得实例的接口,然后再让它来解析这些实例,放到定义好的HandlerMapping数组中。那么这里就要考虑给getBean的类了,之前在Spring中他们是在一个终极父类里定义到了这个方法,我的处理是简化,直接定义一个ApplicationContext,把它当做BeanFactory,所有的处理都在这里面进行,对外给出getBean方法。那么来看一下ApplicationContext这个类。按照Spring的思想,首先是定义一个refresh方法,它的作用就是:根据XML文件定义的属性来进行IOC容器的初始化。

public void refresh(){
        //定位
        this.reader = new BeanDefinitionReader(configureLocations);
        //加载
        List<String> beanDefinitions = this.reader.loadBeanDefinitions();
        //注册
        doRegisty(beanDefinitions);
        //依赖注入(lazy-init = false),自动调用getBean方法
        doDependencyInjection();
    }

  我按照定位、加载、注册和依赖注入四部分来处理。首先是定位,就是对配置文件进行定位读取解析,这里自己定义了一个BeanDefinitionReader的类,把配置文件存放在它内部一个Properties变量中。并且把配置文件中划好的包中的类给拿出来,

private void doScanner(String packName) {
        URL url = this.getClass().getClassLoader().getResource("/" + packName.replaceAll("\\\\.","/"));

        File classDir = new File(url.getFile());

        for(File file : classDir.listFiles()) {
            if(file.isDirectory()) {
                doScanner(packName + "." + file.getName());
            } else {
                registyBeanClasses.add(packName + "." + file.getName().replace(".class",""));
            }
        }
    }

  然后是加载,在BeanDefinitionReader里,我将属性和类名做成一个Map,存放起来。之后就是注册,还是在BeanDefinitionReader中,因为我之前已经将属性和名称做成了一个Map,这样我可以通过类名就能得到它对应的BeanDefinition。

public LusheBeanDefinition registerBean(String className) {
        if(this.registyBeanClasses.contains(className)) {
            LusheBeanDefinition lusheBeanDefinition = new LusheBeanDefinition();
            lusheBeanDefinition.setBeanClassName(className);
            lusheBeanDefinition.setFactoryBeanName(StringUtils.lowerFirstCase(className.substring(className.lastIndexOf(".") + 1)));
            return lusheBeanDefinition;
        }
        return null;
    }

  回到ApplicationContext的refresh方法,把我们所有定义好的BeanDefinition放到BeanDefinitionMap中,也就是Spring的Cache里。因为之前只是将所有的BeanDefinition放进去,还没有做进一步的处理,因此就在这一块进行处理了。

private void doRegisty(List<String> beanDefinitions){
        try {
            for(String className : beanDefinitions) {
                Class<?> beanClass = Class.forName(className);

                //判断是不是接口,如果是接口,则用其实现类来实现
                if(beanClass.isInterface()) {
                    continue;
                }
                //beanName 为类名首字母小写
                //自定义beanName
                LusheBeanDefinition lusheBeanDefinition = this.reader.registerBean(className);
                if(lusheBeanDefinition != null) {
                    beanDefinitionMap.put(lusheBeanDefinition.getFactoryBeanName(), lusheBeanDefinition);
                }
                //接口注入
                Class<?>[] interfaces = beanClass.getInterfaces();
                for(Class<?> interf : interfaces) {
                    //多个接口功能相同
                    //如果多个属性类只能覆盖,因为Spring没有那么智能
                    this.beanDefinitionMap.put(interf.getName(), lusheBeanDefinition);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

  首先看看是不是个接口,如果是,就直接跳过,因为我会在后面给每个类的每个接口赋予相同的BeanDefinition,这里的确有一点瑕疵,但是我也在思考更好地处理办法。最后我得到的BeanDefinitionMap,这里注册的功能就完成了。

  然后就是依赖注入这块,我是这么做的:

private void populateBean(String beanName, Object instance) {
        Class clazz = instance.getClass();
        if(clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)) {

            //读取所有字段
            Field[] fields = clazz.getDeclaredFields();
            for(Field field : fields) {
                if(field.isAnnotationPresent(AutoWried.class)) {
                    AutoWried autoWried = field.getAnnotation(AutoWried.class);
                    String autoWriedBeanName = autoWried.value().trim();

                    if(autoWriedBeanName.equals("")) {
                        autoWriedBeanName = field.getType().getName();
                    }

                    field.setAccessible(true);

                    try {
                        field.set(instance,this.beanWrapperMap.get(autoWriedBeanName).getWrapperInstance());
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                } else {
                    continue;
                }
            }
        } else {
            return;
        }
    }

  先不说这个,因为这里我们还没有得到Instance,我是通过反射获得的这个实例

private Object instantionBean(LusheBeanDefinition lusheBeanDefinition) {
        String className = lusheBeanDefinition.getBeanClassName();
        Object beanInstance = null;
        try {
            synchronized (this) {
                if (!beanCacheMap.containsKey(className)) {
                    Class<?> clazz = Class.forName(className);
                    beanInstance = clazz.newInstance();
                    beanCacheMap.put(className, beanInstance);
                } else {
                    beanInstance = beanCacheMap.get(className);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return beanInstance;
    }

   然后再看一下依赖注入这一块,也就是populateBean,会传入一个bean的实例并拿到它的类,如果这个类已经声明为Controller或者Service类,那么就把它所有的字段拿出来,如果某个字段被标注为AutoWried,那么就从包装Map中把实例给拿出来,具体的实现就是这样的。

  上面提到包装类BeanWrapper,它的作用就是方便对其进行功能拓展,比如说增加AOP切点之类的。我是这么构造一个包装类实例的:

public LusheBeanWrapper(Object Instance) {
        //添加动态代理
        this.wrapperInstance = aopProxy.getProxy(Instance);

        //原始对象
        this.originalInstance = Instance;
    }

我包装类的构造函数是传入一个原始类实例,然后并将这个实例保存起来,然后通过AOP模块的动态代理拿到包装类实例。

//这里传入原始对象,Spring中传入的事ClassLoader
    public Object getProxy(Object object) {
        this.target = object;
        Class<?> clazz = this.target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(), this);
    }

  Spring中在Aop动态代理创建的时候传入的是ClassLoader,而我这里为了简便直观,传入的是原始类实例,然后拿到这个实例的类,并调用Proxy的newProxyInstance方法获得这个被代理对象。接下来就是讨论AOP是如何实现的,也就是如何对原始方法进行增强的。下面是我AopProxy类中invoke方法,它的作用就是对被代理对象切入点方法进行增强。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //之前
        if(aopConfigure.contains(method)) {
            //对于某个方法,看看是不是切入点
            LusheAopConfigure.LusheAspect aspect = aopConfigure.get(method);

            aspect.getPoints()[0].invoke(aspect.getAspect(),args);
        }

        //反射调用原始方法
        Object obj = method.invoke(this.target, args);

        //之后
        if(aopConfigure.contains(method)) {
            LusheAopConfigure.LusheAspect aspect = aopConfigure.get(method);

            aspect.getPoints()[1].invoke(aspect.getAspect(),args);
        }

        //可以考虑一下为什么这么写
        //这里面用到了循环
        return obj;
    }

  首先来解释一下AopConfigure这个类的作用,它是对ApplicationContext中expression的封装,对目标代理对象的一个方法增强,增强的方法就是自己定义逻辑。配置文件告诉我们哪些类哪些方法需要增强和需要增强的内容,我用一个Map去存放这些信息,key是目标对象的方法名,value是我自己定义的一个实体Bean,存放的用来增强的类和它的方法(这里我只是简单的定义了两个:before和after)。之后再回到上面的那个invoke方法,这里是这么处理的,首先看一下这个方法是不是一个需要增强的方法,如果是,那么先搞定before方法增强,然后这个方法的执行,最后执行方法后增强。

  最后再回到getBean,当我们使用到这个方法的时候,默认已经完成了IOC容器的初始化和AOP切面方法增强,最后getBean返回给DispatcherServlet的,并不是原始的BeanInstance,而是一个BeanWrapper的实例,换句话说,getBean的作用就是传入一个Bean的类名,然后读取BeanDefinition的信息,通过反射机制创建实例并返回。在这个框架中,用到了Spring中用到的思想,它用BeanMapper把原始Bean包装起来(具体怎么包装我在上面已经说了),然后作用是不仅保存了之前的OP关系,而且方便了之后的拓展和增强。

public Object getBean(String beanName) {
        LusheBeanPostProcessor lusheBeanPostProcessor = new LusheBeanPostProcessor();

        LusheBeanDefinition lusheBeanDefinition = beanDefinitionMap.get(beanName);
        Object beanInstance = instantionBean(lusheBeanDefinition);
        lusheBeanPostProcessor.postProcessBeforeInitialization(beanInstance,beanName);

        if(beanInstance == null) {
            return null;
        }
        LusheBeanWrapper lusheBeanWrapper = new LusheBeanWrapper(beanInstance);

        //生成通知事件

        try {
            lusheBeanWrapper.setAopConfigure(instantionAopConfigure(lusheBeanDefinition));
        } catch (Exception e) {
            e.printStackTrace();
        }

        lusheBeanWrapper.setLusheBeanPostProcessor(lusheBeanPostProcessor);

        beanWrapperMap.put(beanName, lusheBeanWrapper);

        lusheBeanPostProcessor.postProcessAfterInitialization(beanInstance,beanName);

        //populateBean(beanName,beanInstance);

        return beanWrapperMap.get(beanName).getWrapperInstance();
    }

  首先从已经初始化好的BeanDefinitionMap中拿到BeanDefinition,然后调用instantionBean方法拿到实例Bean(这个方法的介绍在上面),如果这个实例存在,那我们就对它进行包装并进行AOP方法切入点的增强(前提是有),并将生成的包装实例放在Map中保存,并返回包装器中的包装实例,可以肯定的说,实例的类不是原始类,而是一个动态代理生成的类,类似以$Proxy0这种。

  回到DispatcherServlet的initHandlerMapping方法:

private void initHandlerMappings(LusheApplicationContext context) {
        //按照我们通常的理解应该是一个Map,Map<String,Method> map;map.put(url,Method)
        //首先从容器中取到所有的实例
        String [] beanNames = context.getBeanDefinitionNames();
        try {
            for (String beanName : beanNames) {
                //到了MVC层,对外提供的方法只有一个getBean方法
                Object proxy = context.getBean(beanName);
                Object originObject = LusheAopProxyUtils.getOriginObject(proxy);

                Class<?> clazz = originObject.getClass();

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

                String baseUrl = "";

                if (clazz.isAnnotationPresent(RequestMapping.class)) {
                    RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                    baseUrl = requestMapping.value();
                }

                //扫描所有的public方法
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (!method.isAnnotationPresent(RequestMapping.class)) {
                        continue;
                    }

                    RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                    String regex = ("/" + baseUrl + requestMapping.value().replaceAll("\\\\*", ".*")).replaceAll("/+", "/");
                    Pattern pattern = Pattern.compile(regex);
                    this.handlerMappings.add(new LusheHandlerMapping(pattern, originObject, method));
                    System.out.println("Mapping: " + regex + " , " + method);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

  我们通过getBean拿到实例,然后拿到他的原始类实例,我是这么处理的:

 /**
     * 找到代理对象的原始对象
     * @param proxy
     * @return
     * @throws Exception
     */
    public static Object getOriginObject(Object proxy) throws Exception {
        //不是代理对象
        if(!isProxy(proxy)) {
            return proxy;
        } else {
            return getProxyTargetObject(proxy);
        }
    }

    private static boolean isProxy(Object object) {
        return Proxy.isProxyClass(object.getClass());
    }

    private static Object getProxyTargetObject(Object proxy) throws Exception {

        //在代理模式中看到过,原始类的信息就被存放在类型为InvocationHandler的变量中,名字就叫h
        Field h = proxy.getClass().getSuperclass().getDeclaredField("h");
        h.setAccessible(true);
        LusheAopProxy  aopProxy = (LusheAopProxy)h.get(proxy);
        Field target = aopProxy.getClass().getDeclaredField("target");
        target.setAccessible(true);
        return target.get(proxy);
    }

  因为在动态代理的过程中,原始类的信息就已经被存放在InvocationHandler中了,所以就很方便的拿到了。

  再回来,我首先判断一下这个类是不是Controller,不是就走了,是的话,再看一下它的方法中,哪个是RequestMapping方法,将他存放起来。

  然后是调用initHandlerAdapters方法,完成存放的方法的参数的处理。

  最后再说一下类是怎么和AOP配置匹配起来的,这里我建立了一个instantionAopConfigure方法,在建立BeanWrapper的时候调用:

private LusheAopConfigure instantionAopConfigure(LusheBeanDefinition beanDefinition) throws Exception{
        LusheAopConfigure aopConfigure = new LusheAopConfigure();
        String expression = reader.getConfigure().getProperty("pointCut");

        String[] before = reader.getConfigure().getProperty("aspectBefore").split("\\\\#");
        String[] after = reader.getConfigure().getProperty("aspectAfter").split("\\\\#");

        String className = beanDefinition.getBeanClassName();

        Class<?> clazz = Class.forName(className);

        //解析成正则去匹配
        Pattern pattern = Pattern.compile(expression);

        //指出切面类,因为我们在上面已经将切面方法的位置分成了两部分,第一部分是包类名,第二部分是方法名
        //因此我们这里就取第一部分就可以了,然后因为两个切面方法属于一个类,为了方便,就拿第一个就可以了。
        Class<?> aspectClass = Class.forName(before[0]);

        //拿出被代理类的所有方法
        //举例:com.spring.test.LusheMVC.framework.context.LusheApplication.getBean(java.lang.String)
        //而我们的正则是:
             //public.* com\\.spring\\.test\\.LusheMVC\\.demo\\.service\\..*ServiceImpl\\..*\\(.*\\)
        //这个肯定匹配不上 而
             //com.spring.test.LusheMVC.demo.service.impl.DemoServiceImpl.get(java.lang.String)
        //这个就匹配上了
        for(Method method : clazz.getMethods()) {
            Matcher matcher = pattern.matcher(method.toString());

            //如果匹配上了
            if(matcher.matches()) {
                //把能满足切面规则的类添加到AOP配置中
                aopConfigure.put(method,clazz.newInstance()
                        ,new Method[]{aspectClass.getMethod(before[1]),aspectClass.getMethod(after[1])});
            }
        }

        return aopConfigure;
    }

  首先拿到切点类的定义,用来做正则判断,格式类似于public.* com\\.spring\\.test\\.LusheMVC\\.demo\\.service\\..*ServiceImpl\\..*\\(.*\\),然后拿出增强内容方法的信息(就是before和after的信息),并将它们处理到String数组里,第一个位置放的是类名,第二个是方法名。然后将BeanDefinition中存放的类名拿出来生成这个类的Class,将起所有方法拿出来进行正则匹配,如果匹配到了,说明这个方法是个切入点,需要被增强,那么就将这个信息存起来,处理完所有的之后,将这些内容给BeanWrapper,它会在AOP的时候用到。

  差不多就说这些吧,如果有补充我会更新的。

 

以上是关于聊一个自己写的MVC框架的主要内容,如果未能解决你的问题,请参考以下文章

聊一聊耳熟能详的MVC设计模式与三层架构

手写一个迷你版Spring MVC框架

关于java mvc设计模式

ThinkPHP项目笔记之MVC篇

写的Android代码不能复用?从MVC开始重新学习

写的Android代码不能复用?从MVC开始重新学习