首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >3 手写实现SpringMVC,第三节:通过反射给属性和参数注入值

3 手写实现SpringMVC,第三节:通过反射给属性和参数注入值

作者头像
天涯泪小武
发布2019-01-17 11:27:21
6730
发布2019-01-17 11:27:21
举报
文章被收录于专栏:SpringCloud专栏SpringCloud专栏

在上一篇已经完成了读取beanName->Object映射关系的功能,这一篇就是把读取到的映射注入到属性中。

在WebController里定义了需要被Autowired的两个Service,myQueryService和modifyService,下面来给他们赋值。

通过反射给属性赋值

/**
     * 给被AutoWired注解的属性注入值
     */
    private void doAutoWired() {
        if (instanceMapping.isEmpty()) {
            return;
        }
        //遍历所有被托管的对象
        for (Map.Entry<String, Object> entry : instanceMapping.entrySet()) {
            //查找所有被Autowired注解的属性
            // getFields()获得某个类的所有的公共(public)的字段,包括父类;
            // getDeclaredFields()获得某个类的所有申明的字段,即包括public、private和proteced,但是不包括父类的申明字段。
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                //没加autowired的不需要注值
                if (!field.isAnnotationPresent(Autowired.class)) {
                    continue;
                }
                String beanName;
                //获取AutoWired上面写的值,譬如@Autowired("abc")
                Autowired autowired = field.getAnnotation(Autowired.class);
                if ("".equals(autowired.value())) {
                    //例 searchService。注意,此处是获取属性的类名的首字母小写,与属性名无关,可以定义@Autowired SearchService abc都可以。
                    beanName = lowerFirstChar(field.getType().getSimpleName());
                } else {
                    beanName = autowired.value();
                }
                //将私有化的属性设为true,不然访问不到
                field.setAccessible(true);
                //去映射中找是否存在该beanName对应的实例对象
                if (instanceMapping.get(beanName) != null) {
                    try {
                        field.set(entry.getValue(), instanceMapping.get(beanName));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

在init方法里,instance下面加上doAutowired方法。

重启,查看注入情况。

可以看到webController里的属性,queryService和modifyService都已经被成功注入了正确的实现类。

建立Url到方法的映射

当Controller里的属性被注入值后,Service是可以使用了,但是访问Url时,系统依旧不知道该调用哪个方法来处理请求。

所以当我们请求某个url,如/web/add时,我们需要建立一个Url到Method的映射,这样才能访问到该方法并处理。这个地方也是SpringMVC区别于Struts2的巨大地方,Struts2是建立url到Controller类的映射,类里的成员变量是所有方法共享的,无论具体哪个方法都可以访问成员变量,这样会无形中浪费内存空间。而SpringMVC是建立的请求到方法的映射,与成员变量无关。

那么如何建立Url到方法的映射呢?这里就需要用上@RequestMapping注解了,由它来决定映射。

创建个map

private Map<String, Method> handlerMapping = new HashMap<>();

创建方法

/**
     * 建立url到方法的映射
     */
    private void doHandlerMapping() {
        if (instanceMapping.isEmpty()) {
            return;
        }
        //遍历托管的对象,寻找Controller
        for (Map.Entry<String, Object> entry : instanceMapping.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            //只处理Controller的,只有Controller有RequestMapping
            if (!clazz.isAnnotationPresent(Controller.class)) {
                continue;
            }

            //定义url
            String url = "/";
            //取到Controller上的RequestMapping值
            if (clazz.isAnnotationPresent(RequestMapping.class)) {
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                url += requestMapping.value();
            }

            //获取方法上的RequestMapping
            Method[] methods = clazz.getMethods();
            //只处理带RequestMapping的方法
            for (Method method : methods) {
                if (!method.isAnnotationPresent(RequestMapping.class)) {
                    continue;
                }
                RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                //requestMapping.value()即是在requestMapping上注解的请求地址,不管用户写不写"/",我们都给他补上
                String realUrl = url + "/" + methodMapping.value();
                //替换掉多余的"/",因为有的用户在RequestMapping上写"/xxx/xx",有的不写,所以我们处理掉多余的"/"
                realUrl = realUrl.replaceAll("/+", "/");
                handlerMapping.put(realUrl, method);

            }
        }

    }

通过这个方法就能得到一个HashMap,key为RequestMapping上配置的url地址,value为Method对象。

重启看效果:

理论上来说我们能根据请求的Url,找到对应的需要执行的Method,就已经可以执行method.invoke去调用该方法了。

在doPost方法中,我们通过遍历HandlerMapping,寻找key等于req.getRequestURI()的Method,然后invoke。

但是在实际操作中,发现了一个问题,就是method.invoke(Object object, Object... args)方法,它需要两个参数,第一个Object是该Method所在的类实例,也就是我们的WebController类的实例,目前是存放在instanceMapping中key为webController的值。至于Object...参数则是该方法的所有参数,也就是@RequestParam("name") String name, HttpServletRequest request, HttpServletResponse response这几个。

但是在我们的上一步操作中,我们的HandlerMapping里只保存了method对象,没有保存Controller对象和所有的参数,所有这一步是执行不下去的。

那么就需要对HandlerMapping进行改造,把需要的值也放进去。

新建一个javaBean,来装载Method需要的所有属性

private class HandlerModel {
        Method method;
        Object controller;
        Map<String, Integer> paramMap;

        public HandlerModel(Method method, Object controller, Map<String, Integer> paramMap) {
            this.method = method;
            this.controller = controller;
            this.paramMap = paramMap;
        }
    }

添加doHandlerMapping方法,来完成Url到方法的映射

/**
     * 建立url到方法的映射
     */
    private void doHandlerMapping() {
        if (instanceMapping.isEmpty()) {
            return;
        }
        //遍历托管的对象,寻找Controller
        for (Map.Entry<String, Object> entry : instanceMapping.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            //只处理Controller的,只有Controller有RequestMapping
            if (!clazz.isAnnotationPresent(Controller.class)) {
                continue;
            }

            //定义url
            String url = "/";
            //取到Controller上的RequestMapping值
            if (clazz.isAnnotationPresent(RequestMapping.class)) {
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                url += requestMapping.value();
            }

            //获取方法上的RequestMapping
            Method[] methods = clazz.getMethods();
            //只处理带RequestMapping的方法
            for (Method method : methods) {
                if (!method.isAnnotationPresent(RequestMapping.class)) {
                    continue;
                }

                RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                //requestMapping.value()即是在requestMapping上注解的请求地址,不管用户写不写"/",我们都给他补上
                String realUrl = url + "/" + methodMapping.value();
                //替换掉多余的"/",因为有的用户在RequestMapping上写"/xxx/xx",有的不写,所以我们处理掉多余的"/"
                realUrl = realUrl.replaceAll("/+", "/");

                //获取所有的参数的注解,有几个参数就有几个annotation[],为毛是数组呢,因为一个参数可以有多个注解……
                Annotation[][] annotations = method.getParameterAnnotations();
                //由于后面的Method的invoke时,需要传入所有参数的值的数组,所以需要保存各参数的位置
                /*以Search方法的这几个参数为例 @RequestParam("name") String name, HttpServletRequest request, HttpServletResponse response
                    未来在invoke时,需要传入类似这样的一个数组["abc", request, response]。"abc"即是在Post方法中通过request.getParameter("name")来获取
                    Request和response这个简单,在post方法中直接就有。
                    所以我们需要保存@RequestParam上的value值,和它的位置。譬如 name->0,只有拿到了这两个值,
                    才能将post中通过request.getParameter("name")得到的值放在参数数组的第0个位置。
                    同理,也需要保存request的位置1,response的位置2
                 */
                Map<String, Integer> paramMap = new HashMap<>();

                //获取方法里的所有参数的参数名(注意:此处使用了ASM.jar 版本为asm-3.3.1,需要在web-inf下建lib文件夹,引入asm-3.3.1.jar,自行下载)
                //如Controller的add方法,将得到如下数组["name", "addr", "request", "response"]
                String[] paramNames = Play.getMethodParameterNamesByAsm4(clazz, method);

                //获取所有参数的类型,提取Request和Response的索引
                Class<?>[] paramTypes = method.getParameterTypes();

                for (int i = 0; i < annotations.length; i++) {
                    //获取每个参数上的所有注解
                    Annotation[] anns = annotations[i];
                    if (anns.length == 0) {
                        //如果没有注解,则是如String abc,Request request这种,没写注解的
                        //如果没被RequestParam注解
                        // 如果是Request或者Response,就直接用类名作key;如果是普通属性,就用属性名
                        Class<?> type = paramTypes[i];
                        if (type == HttpServletRequest.class || type == HttpServletResponse.class) {
                            paramMap.put(type.getName(), i);
                        } else {
                            //参数没写@RequestParam注解,只写了String name,那么通过java是无法获取到name这个属性名的
                            //通过上面asm获取的paramNames来映射
                            paramMap.put(paramNames[i], i);
                        }
                        continue;
                    }

                    //有注解,就遍历每个参数上的所有注解
                    for (Annotation ans : anns) {
                        //找到被RequestParam注解的参数,并取value值
                        if (ans.annotationType() == RequestParam.class) {
                            //也就是@RequestParam("name")上的"name"
                            String paramName = ((RequestParam) ans).value();
                            //如果@RequestParam("name")这里面
                            if (!"".equals(paramName.trim())) {
                                paramMap.put(paramName, i);
                            }
                        }
                    }

                }
                HandlerModel model = new HandlerModel(method, entry.getValue(), paramMap);


                handlerMapping.put(realUrl, model);

            }
        }

    }

还有一个asm取方法名的工具类:

package com.tianyalei.mvc.util;

import org.objectweb.asm.*;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * Created by wuwf on 17/6/30.
 */
public class Play {
    /**
     * 获取指定类指定方法的参数名
     *
     * @param method 要获取参数名的方法
     * @return 按参数顺序排列的参数名列表,如果没有参数,则返回null
     */
    public static String[] getMethodParameterNamesByAsm4(final Class clazz, final Method method) {
        final String methodName = method.getName();
        final Class<?>[] methodParameterTypes = method.getParameterTypes();
        final int methodParameterCount = methodParameterTypes.length;
        String className = method.getDeclaringClass().getName();
        final boolean isStatic = Modifier.isStatic(method.getModifiers());
        final String[] methodParametersNames = new String[methodParameterCount];
        int lastDotIndex = className.lastIndexOf(".");
        className = className.substring(lastDotIndex + 1) + ".class";
        InputStream is = clazz.getResourceAsStream(className);
        try {
            ClassReader cr = new ClassReader(is);
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            cr.accept(new ClassAdapter(cw) {
                public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {

                    MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);

                    final Type[] argTypes = Type.getArgumentTypes(desc);

                    //参数类型不一致
                    if (!methodName.equals(name) || !matchTypes(argTypes, methodParameterTypes)) {
                        return mv;
                    }
                    return new MethodAdapter(mv) {
                        public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) {
                            //如果是静态方法,第一个参数就是方法参数,非静态方法,则第一个参数是 this ,然后才是方法的参数
                            int methodParameterIndex = isStatic ? index : index - 1;
                            if (0 <= methodParameterIndex && methodParameterIndex < methodParameterCount) {
                                methodParametersNames[methodParameterIndex] = name;
                            }
                            super.visitLocalVariable(name, desc, signature, start, end, index);
                        }
                    };
                }
            }, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return methodParametersNames;
    }

    /**
     * 比较参数是否一致
     */
    private static boolean matchTypes(Type[] types, Class<?>[] parameterTypes) {
        if (types.length != parameterTypes.length) {
            return false;
        }
        for (int i = 0; i < types.length; i++) {
            if (!Type.getType(parameterTypes[i]).equals(types[i])) {
                return false;
            }
        }
        return true;
    }

}

完成这一步后,重启看看映射的结果:

发现已经正确建立了映射关系。再下一步就可以根据doPost里取到的用户传来的参数找到对应的方法,并invoke方法了。

下面放一个DispatcherServlet的代码,下一篇我们就来完成整个请求处理链。

package com.tianyalei.mvc;

import com.tianyalei.mvc.annotation.*;
import com.tianyalei.mvc.util.Play;

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.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by wuwf on 17/6/28.
 * 入口Sevlet
 */
public class DispatcherServlet extends HttpServlet {
    private List<String> classNames = new ArrayList<>();

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

    private Map<String, HandlerModel> handlerMapping = new HashMap<>();

    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("我是初始化方法");
        scanPackage(config.getInitParameter("scanPackage"));

        doInstance();

        //注入值
        doAutoWired();

        doHandlerMapping();

        System.out.println(instanceMapping);
    }

    /**
     * 扫描包下的所有类
     */
    private void scanPackage(String pkgName) {
        //获取指定的包的实际路径url,将com.tianyalei.mvc变成目录结构com/tianyalei/mvc
        URL url = getClass().getClassLoader().getResource("/" + pkgName.replaceAll("\\.", "/"));
        //转化成file对象
        File dir = new File(url.getFile());
        //递归查询所有的class文件
        for (File file : dir.listFiles()) {
            //如果是目录,就递归目录的下一层,如com.tianyalei.mvc.controller
            if (file.isDirectory()) {
                scanPackage(pkgName + "." + file.getName());
            } else {
                //如果是class文件,并且是需要被spring托管的
                if (!file.getName().endsWith(".class")) {
                    continue;
                }
                //举例,className = com.tianyalei.mvc.controller.WebController
                String className = pkgName + "." + file.getName().replace(".class", "");
                //判断是否被Controller或者Service注解了,如果没注解,那么我们就不管它,譬如annotation包和DispatcherServlet类我们就不处理
                try {
                    Class<?> clazz = Class.forName(className);
                    if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)) {
                        classNames.add(className);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }

            }
        }
    }

    /**
     * 实例化
     */
    private void doInstance() {
        if (classNames.size() == 0) {
            return;
        }
        //遍历所有的被托管的类,并且实例化
        for (String className : classNames) {
            try {
                Class<?> clazz = Class.forName(className);
                //如果是Controller
                if (clazz.isAnnotationPresent(Controller.class)) {
                    //举例:webController -> new WebController
                    instanceMapping.put(lowerFirstChar(clazz.getSimpleName()), clazz.newInstance());
                } else if (clazz.isAnnotationPresent(Service.class)) {
                    //获取注解上的值
                    Service service = clazz.getAnnotation(Service.class);
                    //举例:QueryServiceImpl上的@Service("myQueryService")
                    String value = service.value();
                    //如果有值,就以该值为key
                    if (!"".equals(value.trim())) {
                        instanceMapping.put(value.trim(), clazz.newInstance());
                    } else {//没值时就用接口的名字首字母小写
                        //获取它的接口
                        Class[] inters = clazz.getInterfaces();
                        //此处简单处理了,假定ServiceImpl只实现了一个接口
                        for (Class c : inters) {
                            //举例 modifyService->new ModifyServiceImpl()
                            instanceMapping.put(lowerFirstChar(c.getSimpleName()), clazz.newInstance());
                            break;
                        }
                    }
                }

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

    /**
     * 给被AutoWired注解的属性注入值
     */
    private void doAutoWired() {
        if (instanceMapping.isEmpty()) {
            return;
        }
        //遍历所有被托管的对象
        for (Map.Entry<String, Object> entry : instanceMapping.entrySet()) {
            //查找所有被Autowired注解的属性
            // getFields()获得某个类的所有的公共(public)的字段,包括父类;
            // getDeclaredFields()获得某个类的所有申明的字段,即包括public、private和proteced,但是不包括父类的申明字段。
            Field[] fields = entry.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                //没加autowired的不需要注值
                if (!field.isAnnotationPresent(Autowired.class)) {
                    continue;
                }
                String beanName;
                //获取AutoWired上面写的值,譬如@Autowired("abc")
                Autowired autowired = field.getAnnotation(Autowired.class);
                if ("".equals(autowired.value())) {
                    //例 searchService。注意,此处是获取属性的类名的首字母小写,与属性名无关,可以定义@Autowired SearchService abc都可以。
                    beanName = lowerFirstChar(field.getType().getSimpleName());
                } else {
                    beanName = autowired.value();
                }
                //将私有化的属性设为true,不然访问不到
                field.setAccessible(true);
                //去映射中找是否存在该beanName对应的实例对象
                if (instanceMapping.get(beanName) != null) {
                    try {
                        field.set(entry.getValue(), instanceMapping.get(beanName));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 建立url到方法的映射
     */
    private void doHandlerMapping() {
        if (instanceMapping.isEmpty()) {
            return;
        }
        //遍历托管的对象,寻找Controller
        for (Map.Entry<String, Object> entry : instanceMapping.entrySet()) {
            Class<?> clazz = entry.getValue().getClass();
            //只处理Controller的,只有Controller有RequestMapping
            if (!clazz.isAnnotationPresent(Controller.class)) {
                continue;
            }

            //定义url
            String url = "/";
            //取到Controller上的RequestMapping值
            if (clazz.isAnnotationPresent(RequestMapping.class)) {
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                url += requestMapping.value();
            }

            //获取方法上的RequestMapping
            Method[] methods = clazz.getMethods();
            //只处理带RequestMapping的方法
            for (Method method : methods) {
                if (!method.isAnnotationPresent(RequestMapping.class)) {
                    continue;
                }

                RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                //requestMapping.value()即是在requestMapping上注解的请求地址,不管用户写不写"/",我们都给他补上
                String realUrl = url + "/" + methodMapping.value();
                //替换掉多余的"/",因为有的用户在RequestMapping上写"/xxx/xx",有的不写,所以我们处理掉多余的"/"
                realUrl = realUrl.replaceAll("/+", "/");

                //获取所有的参数的注解,有几个参数就有几个annotation[],为毛是数组呢,因为一个参数可以有多个注解……
                Annotation[][] annotations = method.getParameterAnnotations();
                //由于后面的Method的invoke时,需要传入所有参数的值的数组,所以需要保存各参数的位置
                /*以Search方法的这几个参数为例 @RequestParam("name") String name, HttpServletRequest request, HttpServletResponse response
                    未来在invoke时,需要传入类似这样的一个数组["abc", request, response]。"abc"即是在Post方法中通过request.getParameter("name")来获取
                    Request和response这个简单,在post方法中直接就有。
                    所以我们需要保存@RequestParam上的value值,和它的位置。譬如 name->0,只有拿到了这两个值,
                    才能将post中通过request.getParameter("name")得到的值放在参数数组的第0个位置。
                    同理,也需要保存request的位置1,response的位置2
                 */
                Map<String, Integer> paramMap = new HashMap<>();

                //获取方法里的所有参数的参数名(注意:此处使用了ASM.jar 版本为asm-3.3.1,需要在web-inf下建lib文件夹,引入asm-3.3.1.jar,自行下载)
                //如Controller的add方法,将得到如下数组["name", "addr", "request", "response"]
                String[] paramNames = Play.getMethodParameterNamesByAsm4(clazz, method);

                //获取所有参数的类型,提取Request和Response的索引
                Class<?>[] paramTypes = method.getParameterTypes();

                for (int i = 0; i < annotations.length; i++) {
                    //获取每个参数上的所有注解
                    Annotation[] anns = annotations[i];
                    if (anns.length == 0) {
                        //如果没有注解,则是如String abc,Request request这种,没写注解的
                        //如果没被RequestParam注解
                        // 如果是Request或者Response,就直接用类名作key;如果是普通属性,就用属性名
                        Class<?> type = paramTypes[i];
                        if (type == HttpServletRequest.class || type == HttpServletResponse.class) {
                            paramMap.put(type.getName(), i);
                        } else {
                            //参数没写@RequestParam注解,只写了String name,那么通过java是无法获取到name这个属性名的
                            //通过上面asm获取的paramNames来映射
                            paramMap.put(paramNames[i], i);
                        }
                        continue;
                    }

                    //有注解,就遍历每个参数上的所有注解
                    for (Annotation ans : anns) {
                        //找到被RequestParam注解的参数,并取value值
                        if (ans.annotationType() == RequestParam.class) {
                            //也就是@RequestParam("name")上的"name"
                            String paramName = ((RequestParam) ans).value();
                            //如果@RequestParam("name")这里面
                            if (!"".equals(paramName.trim())) {
                                paramMap.put(paramName, i);
                            }
                        }
                    }

                }
                HandlerModel model = new HandlerModel(method, entry.getValue(), paramMap);


                handlerMapping.put(realUrl, model);

            }
        }

    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        out(resp, "请求到我啦");
//        doInvoke(req, resp);
    }

//    private void doInvoke(HttpServletRequest req, HttpServletResponse resp) {
//        String url = req.getRequestURI();
//        try {
//            if (handlerMapping.get(url) == null) {
//                resp.getWriter().write("404 not found");
//                return;
//            }
//            Method method = handlerMapping.get(url);
//            method.invoke(null,null);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }

    private void out(HttpServletResponse response, String str) {
        try {
            response.setContentType("application/json;charset=utf-8");
            response.getWriter().print(str);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private class HandlerModel {
        Method method;
        Object controller;
        Map<String, Integer> paramMap;

        public HandlerModel(Method method, Object controller, Map<String, Integer> paramMap) {
            this.method = method;
            this.controller = controller;
            this.paramMap = paramMap;
        }
    }

    private String lowerFirstChar(String className) {
        char[] chars = className.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

}
本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2017年06月30日,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 通过反射给属性赋值
  • 建立Url到方法的映射
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档