手写一个SprigMVC

最新推荐文章于 2022-07-07 20:50:15 发布
置顶 最新推荐文章于 2022-07-07 20:50:15 发布
阅读量192 收藏
点赞数 3
分类专栏： SpringMVC 手写SpringMVC 源码 SpringMVC工作原理 DispatcherServlet 文章标签： SpringMVC Spring SpringMVC工作原理 DispatcherServlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43548264/article/details/92585097
版权

简单手写一个SpringMVC，了解SpringMVC源码。
首先让我们了解一下一个SpringMVC项目的工作流程，以及所用到的方法。
在这里插入图片描述
在这里插入图片描述
下来我们进入实战。

  1. 创建一个maven的Web项目，在pom.xml引入Servlet依赖。
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
</dependency>
  1. 项目的目录是这样的。在这里插入图片描述
  2. Service接口
package com.enjoy.service;

public interface JamesService {
    String query(String name,String age);
}

实现类

package com.enjoy.service.impl;

import com.enjoy.annotation.EnjoyService;
import com.enjoy.service.JamesService;

//tomcat启动
//spring底层 扫描找到特殊注解的类JamesService ==创建对象jamesServiceImpl
//默认首字母小写 但是可以自己定义
//map.put("jamesServiceImpl",jamesServiceImpl)
//
@EnjoyService("JamesServiceImpl")
public class JamesServiceImpl implements JamesService {
    @Override
    public String query(String name, String age) {
        return "{name="+name+",age="+age+"}";
    }
}
  1. controller类
package com.enjoy.controller;

import com.enjoy.annotation.EnjoyAutowired;
import com.enjoy.annotation.EnjoyController;
import com.enjoy.annotation.EnjoyRequestMapping;
import com.enjoy.annotation.EnjoyRequestParam;
import com.enjoy.service.JamesService;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@EnjoyController
@EnjoyRequestMapping("/james")
public class lcController {

    @EnjoyAutowired("JamesServiceImpl")
    private JamesService jamesService;

    @EnjoyRequestMapping("/query")
    public void query(HttpServletRequest request, HttpServletResponse response,
                      @EnjoyRequestParam("name") String name,
                      @EnjoyRequestParam("age") String age){
        try {
            PrintWriter  pw = response.getWriter();
            String result=jamesService.query(name,age);
            pw.write(result);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}
  1. 在这里的注解肯定会报错所以我们要自定义注解。
package com.enjoy.annotation;

import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)      //表示在运行时通过反射获取 载体
@Documented  //javadoc
public @interface EnjoyAutowired {
    String value() default "";
}


package com.enjoy.annotation;

import java.lang.annotation.*;

@Target(ElementType.TYPE)    //只能在类上使用
@Retention(RetentionPolicy.RUNTIME)      //表示在运行时通过反射获取 载体
@Documented  //javadoc
public @interface EnjoyController {
    String value() default "";
}


package com.enjoy.annotation;

import java.lang.annotation.*;
@Target({ElementType.TYPE,ElementType.METHOD})    //只能在类上使用
@Retention(RetentionPolicy.RUNTIME)      //表示在运行时通过反射获取 载体
@Documented  //javadoc
public @interface EnjoyRequestMapping {
    String value() default "";
}


package com.enjoy.annotation;

import java.lang.annotation.*;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)      //表示在运行时通过反射获取 载体
@Documented  //javadoc
public @interface EnjoyRequestParam {
    String value() default "";
}


package com.enjoy.annotation;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)      //表示在运行时通过反射获取 载体
@Documented  //javadoc
public @interface EnjoyService {
    String value() default "";
}
  1. 自己动定义Servlet这里我命名为DisptcherServlet
package com.enjoy.servlet;

import com.enjoy.annotation.*;
import com.enjoy.controller.lcController;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
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.InvocationTargetException;
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;

public class DispatcherServlet extends HttpServlet {

    List<String> classNames = new ArrayList<String>();
    Map<String, Object> beans = new HashMap<String, Object>();
    Map<String, Object> handerMap = new HashMap<String, Object>();

    //扫描路径service.impl.JamesServiceImpl.class
    //创建对象，实列化(反射)
    //autowired
    //urlhandmapping 路径映射
    public void init(ServletConfig config) throws ServletException {
        System.out.println("hehe");
        doBasePackage("com.enjoy");
        doInstance();
        doAutowired();
        UrlHanding();
    }

    public void UrlHanding() {
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(EnjoyController.class)) {
                EnjoyRequestMapping map1 = clazz.getAnnotation(EnjoyRequestMapping.class);
                String classPath = map1.value();
                Method[] methods = clazz.getMethods();
                System.out.println("urlHanding");
                for (Method method : methods) {
                    if (method.isAnnotationPresent(EnjoyRequestMapping.class)) {
                        EnjoyRequestMapping map2 = method.getAnnotation(EnjoyRequestMapping.class);
                        String methodPath = map2.value();   //query
                        handerMap.put(classPath + methodPath, method);
                    } else {
                        continue;
                    }
                }
            }
        }
    }

    public void doAutowired() {
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(EnjoyController.class)) {
                Field[] fields = clazz.getDeclaredFields();
                System.out.println("autowired");
                for (Field field : fields) {
                    if (field.isAnnotationPresent(EnjoyAutowired.class)) {
                        EnjoyAutowired ea = field.getAnnotation(EnjoyAutowired.class);
                        String key = ea.value();
                        Object ins = beans.get(key);
                        field.setAccessible(true);
                        try {
                            field.set(instance, ins);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    } else {
                        continue;
                    }
                }
            }
        }
    }

    public void doInstance() {
        for (String className : classNames) {
            //className=com.enjoy...Service.class
            String cn = className.replace(".class", "");
            //cn=com.emjoy...Service
            try {
                Class<?> clazz = Class.forName(cn);
                System.out.println("doInstance");
                //判断一下 是不是引用了@Controller service
                if (clazz.isAnnotationPresent(EnjoyController.class)) {
                    //控制类 实列化 map put key value
                    Object instance = clazz.newInstance();
                    //key 拿类上边的注解
                    EnjoyRequestMapping map1 = clazz.getAnnotation(EnjoyRequestMapping.class);
                    String key = map1.value();
                    //key value IOC容器==MAP
                    beans.put(key, instance);
                } else if (clazz.isAnnotationPresent(EnjoyService.class)) {
                    //控制类 实列化 map put key value
                    Object instance = clazz.newInstance();
                    //key
                    EnjoyService map1 = clazz.getAnnotation(EnjoyService.class);
                    String key = map1.value();
                    //key value IOC容器==MAP
                    beans.put(key, instance);
                } else {
                    continue;
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }
    }
     //递归
    public void doBasePackage(String basePackage) {
        //e:/workspace/pro/enjoy
        URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\\.", "/"));
        String fileStr = url.getFile();  //fileStr=e:/workspace/pro/enjoy

        File file = new File(fileStr);

        String[] fileStrs = file.list();

        for (String path : fileStrs) {
            System.out.println("package");
            File filePath = new File(fileStr + path);
            if (filePath.isDirectory()) {
                doBasePackage(basePackage + "." + path);
            } else {
                //.class结束的文件？1 2
                //.class 保存下来
                //com.enjoy.xxx.JamesService.class?
                classNames.add(basePackage + "." + filePath.getName());
            }
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String uri = request.getRequestURI();   //pro /james/query
        String context = request.getContextPath();          //pro
        String path = uri.replace(context, "");
        Method method = (Method) handerMap.get(path);
        System.out.println("外边");
        lcController instance = (lcController) beans.get("/" + path.split("/")[1]);
        Object args[]=hand(request,response,method);
        System.out.println("aaa");
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
        try {
            method.invoke(instance,args);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    private static Object[] hand(HttpServletRequest request, HttpServletResponse response, Method method) {
        //拿到当前待执行的方法有那些参数
        Class<?>[] paramClazzs = method.getParameterTypes();
        //根据参数的个数，new 一个参数的数组，将方法里的所有参数赋值到args来
        Object[] args = new Object[paramClazzs.length];
        int args_i = 0;
        int index = 0;
        for (Class<?> paramClazz : paramClazzs) {
            if (ServletRequest.class.isAssignableFrom(paramClazz)) {
                args[args_i++] = request;
            }
            if (ServletResponse.class.isAssignableFrom(paramClazz)) {
                args[args_i++] = response;
            }
            //从0-3判断有没有Requestparam注解，很明显paramClazz为0和1时，不是
            //当为2和3时为@RequesyParam需要解析
            //{@com.enjoy.annotation.EnjoyRequestparam()[index];
            Annotation[] paramAns = method.getParameterAnnotations()[index];
            if (paramAns.length > 0) {
                for (Annotation paramAn : paramAns) {
                    if (EnjoyRequestParam.class.isAssignableFrom(paramAn.getClass())) {
                        EnjoyRequestParam rp = (EnjoyRequestParam) paramAn;
                        //找到注解里的name和age
                        args[args_i++] = request.getParameter(rp.value());
                    }
                }
            }
            index++;
        }
        return args;
    }
}
  1. 在web.xml配置
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>commvc</display-name>
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>com.enjoy.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>
  1. 启动项目，访问
    在这里插入图片描述
    完美运行，不理解的可以博客下评论。求关注一下或者?一个，感谢！！！！
扶&苏
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写一个python迭代器过程详解
09-18
主要介绍了手写一个python迭代器过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
如何手写一个简易的 Vuex
10-14
主要介绍了如何手写一个简易的 Vuex，帮助大家更好的理解和学习vue，感兴趣的朋友可以了解下
手写一个ajax请求
yesir_mao的博客
06-21 5340
1.需求：手动封装一个ajax请求 2.实现如下： 2.1获取异步请求对象 // 获取异步请求对象 function getXhr(){ var xhr=null; if(window.XMLHttpRequest){ xhr=new XMLHttprequest(); }else{ // 如果浏览器版本是IE8以下浏览器 xhr=new ActiveXObject('Micro...
如何手写一个ArrayList
Kerwin的博客
09-17 5466
写完HashMap，觉得手痒痒，所以隔了一天再来实现一下简单的ArrayList，ArrayList相比而言就非常的简单，主要的核心点有以下几个方面： 1.ArrayList的底层是由数组构成的 2.添加时需要考虑扩容问题 3.对于index索引的操作，需要考虑到下标不合法的异常 4.remove操作的时候，需要一点数学知识进行一下逻辑操作 下面贴出我的代码: MyList接口: ...
手写一个ArrayList
苏法迪的专栏
03-11 3310
1. 手写一个MyArrayList ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是支持动态扩容，即没有固定大小的限制，我们可以添加或删除元素。 ArrayList 本质是数组，故具有查询快，增删慢的特点 add()：新增时需要考虑扩容的因素。这个是区别数组的核心方法 get(): 非常好地体现出下标查找的优势，故查询快 remove()：体现出数组的缺点,删除一个元素，后面的元素需整体前移，故删除慢 优点： 1、根据下标遍历元素效率较高。 2、根据下标访问元素效率较高。 3
Vue手写一个进度条
weixin_45389051的博客
05-27 2160
虽然现在ui框架和插件都很多，但是可能与我们需要的需求不一样，或者样式不好调，所以我们就来手写一个吧 先看一下要实现的效果 实际开发这些肯定都是后台传的数据对吧，进度条变化的同时，上面的数字和中间的圆点也随着动，不可能定死对吧 一.先写外面那个颜色浅的盒子 <div class="progressContainer"></div> .progressContainer{ margin-left: .3rem; margin-top: 0.9
手写实现一个深拷贝
yue200403的博客
07-07 2471
手写实现一个深拷贝属于数据结构的知识点，数据类型包含基本类型和引用类型，基本类型存储在栈中；引用数据类型存储在堆中；基本数据类型没有浅拷贝和深拷贝的区分，浅拷贝和深拷贝的问题存在于引用数据类型中。...
手写一个自旋锁
热门推荐
诗水人间
11-07 5万+
开始之前需要掌握CAS原理、类AtomicReference的使用 CAS的全称可以是CompareAndSet或者CompareAndSwap 总的来说就是再更新值得时候需要判断一些原先值是否是预期值，是则更新，不是则更新失败 我们都知道jdk的java.util.concurrent.atomic包下提供了以下原子变量类，例如AtomicBoolean、AtomicInteger、AtomicLong等一系列基本类型的原子变量类，但是有些时候我们希望有一个自定义的来也使用CAS操做，例如自定义User类
教你如何手写一个Promise
ose_huang的博客
02-25 9444
promise的进阶，手写一个自己的promise
手写一个Swiper滑动组件
小朱的专栏
03-17 1989
github地址：react-swiper NPM安装： npm install react-swiper-lite 1.工作原理 通过touchstart，touchmove和touchend实现拖动监听： touchstart记录第一次触摸点位置； touchmove记录当前移动到的位置并更新元素移动位置； touchend根据移动距离判断需要切换到哪个索引，并更新数据 点击单个元素可以切...
手写一个简易的闭包
lovexiaoqiu的博客
06-17 4451
闭包的主要表现有两种 ，一个作为 函数返回值，一个作为 参数。 作为函数返回值 function demo(){ let a = 100 return function(){ console.log(a) } } let a = 200 demo() 作为参数 function fn1(fn){ const a = 100 fn() } const a = 200 function fn(){ console.log(a) } fn1(fn) 闭包的简单应用
手写一个简单的分页器
qq_18824403的博客
03-13 3165
封装分页器 1. 前言 分页器基本上是任何网站必须要有的一个组件，为什么需要分页器，当后台传入了大量的数据，那么在前端拿到数据，如果直接展示很有可能或造成卡顿，同时消耗过多的内存，给用户带来的浏览效果就不好。所以，分页器的使用可以一次性只展示部分数据，用户可以非常方便的跳转不同的页面来访问内容。虽然现在很多的UI库都有这个组件，使用也非常的方便，但是我们也应该要知道，怎么手写一个分页器。 2. 准备 先搭建一个静态的分页器。效果如下图。 <template> <div cl
手写一个SpringIoc容器
04-12
仿照Spring写的一个Ioc容器，注释很详细！
springboot手写一个自己的starter
08-25
在本篇文章里小编给大家整理了关于springboot手写一个自己的starter源码的全部知识点内容，需要的朋友们学习下。
Python_ChatGLM3 series Open Bilingual Chat LLMs 开源双语对话语言模型.zip
05-24
Python_ChatGLM3 series Open Bilingual Chat LLMs 开源双语对话语言模型
附件1：1名男大学生的一日食谱.xlsx
05-24
附件1：1名男大学生的一日食谱.xlsx
用“假定成功”思路做爆品.pdf
05-24
用“假定成功”思路做爆品
STC89C51单片机读取DS18B20的64位序列码并显示在1602液晶上KEIL工程文件+开发板硬件原理图.zip
最新发布
05-24
STC89C51单片机读取DS18B20的64位序列码并显示在1602液晶上KEIL工程文件+开发板硬件原理图 /*读取DS18B20的64位序列码并显示在1602液晶上，如果读取正确结果，则在 液晶第一行显示DS18B20 OK，第二行显示序列码，如果读取失败，则在液晶上 显示DS18B20 ERR0R PLEASE CHECK ，用户可通过更改18B20接口自己外接。 */ #include <reg51.h> #include <intrins.h> #define uchar unsigned char #define uint unsigned int sbit DQ = P2^2; //定义DS18B20端口DQ sbit BEEP=P2^3 ; //蜂鸣器驱动线 bit presence ; sbit LCD_RS = P3^5; sbit LCD_RW = P3^6; sbit LCD_EN = P3^4; uchar code cdis1[ ] = {" DS18B20 OK "}; uchar code c
手写一个计算器
05-24
好的，我可以帮你手写一个简单的计算器。这个计算器可以进行加、减、乘、除的基本运算。 ``` #include using namespace std; int main() { char op; // 运算符 double num1, num2; // 两个运算数 cout 请输入一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值