写一个自己的springMVC？

最新推荐文章于 2022-06-28 09:13:51 发布

world6

最新推荐文章于 2022-06-28 09:13:51 发布

阅读量1.5k

点赞数 1

分类专栏：架构 springMVC spring JavaEE 文章标签： springmvc实现原理如何写web框架

本文链接：https://blog.csdn.net/world6/article/details/78118220

版权

架构同时被 3 个专栏收录

22 篇文章 0 订阅

订阅专栏

JavaEE

6 篇文章 0 订阅

订阅专栏

spring

2 篇文章 0 订阅

订阅专栏

今天我们来实现一个简单的springMVC框架，可以理解为 springMVC1.0这个版本，只是功能比较简单而已；

废话不多说，进入正题；先看看springMVC的简单流程；

我们请求的地址会被dispatchservlet这个springMVC的核心拦截器拦截，然后dispatchservlet会找到我们想要的那个controller里的那个方法，并调用。但是dispatchServlet不是人，它没那么智能，看到url就知道是谁了，但是我们可以让它变得智能起来，我们可以利用handlerMapping来告诉

dispatchServlet，它应该调用哪个方法；

为了让这个框架不那么笨，我借用了spring的IOC 思想，实现一个容器来管理我的bean; 这个框架和你印象中使用springmvc 很相似，你应该能回想起

springMVC的零零点点，然后看看这个简单的框架是如何实现这些功能的；

首先看下项目工程：

首先，我们先看maven 依赖，没错，自己实现的框架当然不用spring的jar包了；

并为了方便大家理解，我的取名和spring原来的风格多少有些类似；

首先看到annotation包，@Autowired、@Controller、@RequestMapping、@service这些注解大家应该再熟悉不过了吧！

然后是 servlet包，模仿的springMVC的核心拦截器 dispatchServlet；

demo包的 controller service 不必解释啦~

这里我们模仿springMVC的调用规则，MyDispatcherServlet负责处理框架的逻辑，调用Controller,Controller调用service；

先看看自定义注解是如何定义的，这里挑选了几个代表；

开始编写核心拦截器 dispatchServilet

我们第一步模仿spring 的思想，先找到我们要扫描哪些类，下面是 spring的做法，

这是我的做法：

为什么我通过 String scanPackage = config.getInitParameter("scanPackage"); 就能找到xml中的配置呢？请参考这里的初始化细节；

servlet 对象在初始化的时候，容器会给它提供一个 ServletConfig 对象去读取 web.xml中的配置；

我们得到要扫描的路径后，可以就需要实现spring的IOC了；

我们为了得到所有bean；在拿到项目的包路径后，可以转换为文件路径，然后再从文件路径中得到所有的类名；

得到类名后，就可以通过反射进行实例化了，然后将这些需要管理的东西放到一个容器中管理，要用的时候从容器里拿就可以了；

我这里使用的容器是 Hashmap<String, Object> 类的简称（SimpleName）为key ,类的实例对象为value。

得到了所有的类名后，开始实例化的工作

[java]view plaincopy 
   
 private void instance(){  
         //利用反射机制将扫描到的类名全部实例化  
         if(classNames.size() == 0){ return; }  
         try{  
             for (String className : classNames) {  
                   
                     Class<?> clazz = Class.forName(className);  
                     //没有@Controller、@Service注解标识的类不需要实例化  
                     if(clazz.isAnnotationPresent(LANController.class)){  
                         //getSimpleName() 除去包名,获取类名的简称  例如: MyAction  
                         String beanName = lowerFirstChar(clazz.getSimpleName());  
                         instanceMapping.put(beanName, clazz.newInstance());  
                     }else if(clazz.isAnnotationPresent(LANService.class)){  
                         LANService service = clazz.getAnnotation(LANService.class);  
                         String beanName = service.value();  
                         if(!"".equals(beanName.trim())){  
                             //beanName 这里就是aa  
                             instanceMapping.put(beanName, clazz.newInstance());  
                             continue;  
                         }  
                         //如果自己没有起名字,后面会通过接口自动注入  
                         Class<?> [] interfaces = clazz.getInterfaces();  
                         for (Class<?> i : interfaces) {  
                             instanceMapping.put(i.getName(), clazz.newInstance());  
                         }  
                     }else{  
                         continue;  
                     }  
             }  
         }catch(Exception e){  
             e.getStackTrace();  
         }  
     }  

实例化以后，就要准备注入了；

[java]view plaincopy 
   
 private void autowired(){  
         if(instanceMapping.isEmpty()){ return; }  
         for (Entry<String, Object> entry : instanceMapping.entrySet()) {  
             //getDeclaredFields()获取自己声明的所有字段  
             Field [] fields = entry.getValue().getClass().getDeclaredFields();  
             for (Field field : fields) {  
                 if(!field.isAnnotationPresent(LANAutowired.class)){ continue; }  
                 LANAutowired autowired = field.getAnnotation(LANAutowired.class);  
                 //如果是私有属性，设置可以访问的权限  
                 field.setAccessible(true);  
                 //自己取的名字   获取注解的值  
                 String beanName = autowired.value().trim();  
                 System.out.println("beanName=="+beanName);  
                 //如果没有自己取名字  
                 if("".equals(beanName)){  
                     //getType()获取该字段声明时的     类型对象   根据类型注入  
                     beanName = field.getType().getName();  
                 }  
                 try {  
                     System.out.println("field.getName()***"+field.getName());  
                      // 注入接口的实现类,    
                      System.out.println("entry.getValue()======"+entry.getValue());  
                      System.out.println("instanceMapping.get(beanName)---------"+instanceMapping.get(beanName));  
                      //将Action 这个 类的 IModifyService 字段设置成为   aa 代表的实现类  ModifyServiceImpl  
                     field.set(entry.getValue(),instanceMapping.get(beanName));  
                 } catch (Exception e) {  
                     e.printStackTrace();  
                     continue;  
                 }  
             }  
         }  
     }  

[java]view plaincopy 
   
 field.set(entry.getValue(),instanceMapping.get(beanName));  

这一行代码是关键，这就是为什么我们在注入接口，就能找到实现类的根本所在。

这里的field,就是我们注入的那个接口， entry.getValue（）得到的是接口所在的类，instanceMapping.get(beanName)是这个接口对应的

那个实现类，意思就是：在运行阶段，将 controller中的某个service接口字段替换成这个service的实现类；

这样我们在编写代码的时候是用使用接口调用方法，但实际运行时，就是它的实现类在调用这个方法了；

不得不感叹，反射的强大。

完成注入后，开始处理handlermapping上的value与之对应的method 的映射关系了

[java]view plaincopy 
   
 public void handlerMapping(){  
         if(instanceMapping.isEmpty()){ return; }  
         for (Entry<String, Object> entry : instanceMapping.entrySet()) {  
             Class<?> clazz = entry.getValue().getClass();  
             //RequestMapping只在 Controller中  
             if(!clazz.isAnnotationPresent(LANController.class)){ continue; }  
             String url = "";  
             if(clazz.isAnnotationPresent(LANRequestMapping.class)){  
                 LANRequestMapping requstMapping = clazz.getAnnotation(LANRequestMapping.class);  
                 //得到RequstMapping的value(/web)准备与 方法上的 RequstMapping(search/add/remove)进行拼接;  
                 url = requstMapping.value();//(/web)  
             }  
             Method [] methods = clazz.getMethods();  
             for (Method method : methods) {  
                 if(!method.isAnnotationPresent(LANRequestMapping.class)){ continue; }  
                 LANRequestMapping requstMapping = method.getAnnotation(LANRequestMapping.class);  
                 String regex =  url + requstMapping.value();  
              // regex = /web/add.json  
                 regex = regex.replaceAll("/+", "/").replaceAll("\\*", ".*");  
                 System.out.println("regex: "+regex);  
                 Map<String,Integer> pm = new HashMap<String,Integer>();  
                 //因为每个参数可能有多个注解，所以会是个二维数组  
                 Annotation [] [] pa = method.getParameterAnnotations();  
                 for(int i = 0; i < pa.length; i ++){  
                     for (Annotation a : pa[i]){  
                         if(a instanceof LANRequestParam){  
                             String paramName = ((LANRequestParam) a).value();  
                             if(!"".equals(paramName.trim())){  
                       //方法参数的名字(值)  name/addr,下标  
                                 pm.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){  
                           
                         pm.put(type.getName(), i);  
                     }  
                 }  
                 handlerMapping.add(new Handler(Pattern.compile(regex),entry.getValue(),method, pm));  
             }  
         }  
     }  

完成所有的初始化工作后，当然就等着用户发过来的请求咯。

那自然是调用servlet的 doPost 和 doGet方法了，

为了简单点，我在doGet中调用doPost

[java]view plaincopy 
   
 @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 {  
         //System.out.println(req.getRequestURI());  
         try{  
             //从上面已经初始化的信息中匹配  
             //拿着用户请求url去找到其对应的Method  
             boolean isMatcher = pattern(req,resp);  
         if(!isMatcher){  
             resp.getWriter().write("对不起,你遇到了  404 Not Found");  
         }  
         }catch(Exception e){  
             resp.getWriter().write("500 Exception,Details:\r\n" +   
             e.getMessage() + "\r\n" +  
             Arrays.toString(e.getStackTrace()).replaceAll("\\[\\]", "")  
             .replaceAll(",\\s", "\r\n"));  
         }  
     }  

如果如果没有匹配成功就返回404，说明用户的路径输错了，

发送异常就报500；

如果匹配成功怎么办？当然是调用controller里的方法咯；

怎么调用？还是通过反射~通过方法的反射~

[java]view plaincopy 
   
 public boolean pattern(HttpServletRequest req, HttpServletResponse resp) throws Exception{  
         if(handlerMapping.isEmpty()){  return false; }  
         //获取请求的url  
         String url = req.getRequestURI();  
         //获取容器路径  
         String contextPath = req.getContextPath();  
         url = url.replace(contextPath, "").replaceAll("/+", "/");     
         for (Handler handler : handlerMapping) {  
             try{  
                 Matcher matcher = handler.pattern.matcher(url);  
                 //如果没匹配上就跳出  
                 if(!matcher.matches()){ continue ;}  
                 //按照声明顺序返回  Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。  
                 Class<?> [] paramTypes = handler.method.getParameterTypes();  
                 //里面存放 反射是需要的具体参数  
                 Object [] paramValues = new Object[paramTypes.length];  
                 //获取前端请求参数和请求参数值的映射关系  
                 Map<String,String[]> params = req.getParameterMap();  
                 for (Entry<String, String []> param : params.entrySet()) {  
                     String value = Arrays.toString(param.getValue()).replaceAll("\\]|\\[", "").replaceAll(",\\s", ",");  
                     if(!handler.paramMapping.containsKey(param.getKey())){ continue;}  
                     //如果匹配,则获取该参数在方法中的下标;  
                     int index = handler.paramMapping.get(param.getKey());  
                     //涉及到类型转换  
                     paramValues[index] = castStringValue(value,paramTypes[index]);  
                 }  
                 //  
                 int reqIndex = handler.paramMapping.get(HttpServletRequest.class.getName());  
                 paramValues[reqIndex] = req;  
                 int respIndex = handler.paramMapping.get(HttpServletResponse.class.getName());  
                 paramValues[respIndex] = resp;  
                 //方法的反射   需要对象.方法  
                 handler.method.invoke(handler.controller, paramValues);  
                 return true;  
             }catch(Exception e){  
                 throw e;  
             }  
         }  
         return false;  
     }  

我们来看看controller的代码，准备测试：

[java]view plaincopy 
   
 public class MyController {  
       
     public  MyController() {  
         System.out.println("初始化了"+this);  
     }  
       
     @LANAutowired   
     private searchService searchService;  
       
     @LANAutowired("aa")   
     private modifyService modifyService;  
       
     @LANRequestMapping("/search/*.json")  
     public void search(HttpServletRequest request,HttpServletResponse response,  
             @LANRequestParam("name") String name){  
         String result = searchService.search(name);  
         System.out.println("查询成功");  
         out(response,result);  
     }  
       
       
     @LANRequestMapping("/add.json")  
     public void add(HttpServletRequest request,HttpServletResponse response,  
             @LANRequestParam("name") String name,  
             @LANRequestParam("addr") String addr){  
         System.out.println("添加成功");  
         String result = modifyService.add(name,addr);  
         out(response,result);  
     }  
       
       
     @LANRequestMapping("/delete.json")  
     public void remove(HttpServletRequest request,HttpServletResponse response,  
             @LANRequestParam("id") Integer id){  
         System.out.println("删除成功");  
         String result = modifyService.remove(id);  
         out(response,result);  
     }  

是不是和你刚学springMVC时的一致？

赶紧启动项目在地址栏输入：http://localhost:8080/LanSpringMVC/web/add.json?name=witt&addr=shenzhen

出现：

[java]view plaincopy 
   
 add name = witt,addr=shenzhen  

说明大工告成~

想要源码的小伙伴点这里：源码

world6

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录