手写springMVC

最新推荐文章于 2024-07-29 02:45:07 发布
最新推荐文章于 2024-07-29 02:45:07 发布
阅读量420 收藏 2
点赞数 1
分类专栏： 基础 文章标签： springMVC 手写springMVC springMVC底层原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aimashi620/article/details/81945957
版权

先让大家看一下我的目录结构
这里写图片描述
第一步： 先创建一个Maven项目，引入servlet-api依赖,因为springMVC底层就是用到servlet的

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>3.0-alpha-1</version>
      <!--打包时不要打包进去-->
      <scope>provided</scope>
    </dependency>

第二步： 创建注解，例如@Autwired、@Controller等注解，这里你可以自定义命名，例如我就不要叫@Autwired,我就要叫@MyAutwired也行。
@Autwired

package com.cvc.nelson.annaotation;

import java.lang.annotation.*;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:38
 * @todo
 */
//因为Autowired一般是用在类的成员变量上，这里的ElementType.FIELD的意思是这个注解用在类的成员变量上
@Target(ElementType.FIELD)
//表示在运行时可以通过反射获取相应的注解
@Retention(RetentionPolicy.RUNTIME)
//表示：当我们的注解包含在javadoc中，在public @interface EnjoyAutowired{}上声明@Inherited，EnjoyAutowired注解就可以被继承
@Documented
public @interface Autowired {
    //@Autowired有时候会带参数，例如@Autowired("orderService"),下面这一行的意思是，在使用EnjoyAutowired注解时，可以在后面带参数
    String value() default "";
}

@Controller

package com.cvc.nelson.annaotation;

import java.lang.annotation.*;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:31
 * @todo
 */
//因为Controller一般作用在类上，这里的ElementType.TYPE的意思是这个注解用在类上
@Target(ElementType.TYPE)
@Documented
//在运行时可以通过反射获取相应的注解
@Retention(RetentionPolicy.RUNTIME)

public @interface Controller {
    String value() default "";
}

@RequestMapping

package com.cvc.nelson.annaotation;

import java.lang.annotation.*;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:39
 * @todo
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {
    String value() default "";
}

@RequestParam

package com.cvc.nelson.annaotation;

import java.lang.annotation.*;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:41
 * @todo
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    String value() default "";
}

@Service

package com.cvc.nelson.annaotation;

import java.lang.annotation.*;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:36
 * @todo
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

第三步：编写Controller、service、serviceImpl、web.xml,先把这些架子搭好，架子搭好后还没有实现springMVC的功能，这里我们先把我们平时写的业务代码先写好先，第四步就开始实现springMVC的底层逻辑。
TestController.java

package com.cvc.nelson.controller;

import com.cvc.nelson.annaotation.Autowired;
import com.cvc.nelson.annaotation.Controller;
import com.cvc.nelson.annaotation.RequestMapping;
import com.cvc.nelson.annaotation.RequestParam;
import com.cvc.nelson.service.TestService;

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

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:42
 * @todo
 */
@Controller
@RequestMapping("/test")
public class TestController {

    @Autowired("TestServiceImpl")
    TestService testService;

    @RequestMapping("/query")
    public void queryData(HttpServletRequest request, HttpServletResponse response, @RequestParam("userName") String userName, @RequestParam("age") String age){

        String result = testService.query(userName,age);
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            writer.write(result);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            writer.close();
        }

    }
}

接口TestService

package com.cvc.nelson.service;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:43
 * @todo
 */
public interface TestService {

    public String query(String userName, String age);
}

TestServiceImpl.java

package com.cvc.nelson.service.impl;

import com.cvc.nelson.annaotation.Service;
import com.cvc.nelson.service.TestService;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 10:43
 * @todo
 */
@Service("TestServiceImpl")
public class TestServiceImpl implements TestService{


    public String query(String userName, String age) {
        return "模拟到数据库查询到数据： user_name = " + userName + "     age = " + age;
    }
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>com.cvc.nelson.servlet.DispatcherServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <!--这里是拦截所有的请求，都去执行DispatcherServlet的doPost方法-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

重头戏来了=======>DispatcherServlet.java
首先让DispatcherServlet这个类继承HttpServlet，然后重写它的doGet和doPost方法
然后从init这个方法开始看。

package com.cvc.nelson.servlet;

import com.cvc.nelson.annaotation.*;

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;

/**
 * @auther xiehuaxin
 * @create 2018-08-22 11:05
 * @todo
 */
public class DispatcherServlet extends HttpServlet {

    //用于存放扫描出来的所有全类名，如：com.cvc.nelson.controller.TestController.class,反射的时候需要用到
    List<String> classNames = new ArrayList<String>();
    //用于存放反射生成的bean，相当于IOC容器
    Map<String,Object> beans = new HashMap<String, Object>();
    //用于存放请求路径与方法的映射，例如请求接口http://39.108.66.150:8080/write-springmvc/test/query接口，会把它映射到对应的方法
    Map<String,Object> handlerMap = new HashMap<String, Object>();


    @Override
    public void init(ServletConfig config){

        //1.先扫描出包下的所有类名
        scanPackage("com.cvc");

        //2.根据扫描到的类名创建bean
        doInstance();

        //3.根据bean进行依赖注入
        doIoc();

        //4.请求路径与方法之间的映射
        buildUrlMapping();
    }

    /**
     * 建立请求与方法之间的对应关系
     * 例如我请求http://39.108.66.150:8080/write-springmvc/test/query 接口时，到底是执行哪个controller的哪个方法
     */
    private void buildUrlMapping() {
        if(beans.entrySet().size() <= 0) {
            System.out.println("没有一个实例化类......");
            return;
        }
        for(Map.Entry<String,Object> entity : beans.entrySet()) {
            Object obj = entity.getValue();
            Class<?> clazz = obj.getClass();
            //映射关系都在Controller中
            if(clazz.isAnnotationPresent(Controller.class)) {
                //类上的@RequestMapping
                RequestMapping classMapping = clazz.getAnnotation(RequestMapping.class);
                String classPath = classMapping.value();
                /**
                 * 一个类可能有多个方法，每个方法上都可能有@RequestMapping
                 */
                Method[] methods = clazz.getMethods();
                for(Method method : methods) {
                    //有@RequestMapping注解的方法才处理
                    if(method.isAnnotationPresent(RequestMapping.class)) {
                        RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                        String methodPath = methodMapping.value();
                        handlerMap.put(classPath + methodPath,method);
                    }else {
                        continue;
                    }
                }
            }
        }
    }

    /**
     * 根据注解进行依赖注入
     */
    private void doIoc() {
        if(beans.entrySet().size() <= 0) {
            System.out.println("没有一个实例化类......");
            return;
        }
        for(Map.Entry<String,Object> entity : beans.entrySet()) {
            Object instance = entity.getValue();
            Class<?> clazz = instance.getClass();
            //因为这里没有用的mybatis，所以只会在controller中注入service
            if(clazz.isAnnotationPresent(Controller.class)) {
                //1.@Autowired注解是用在类的成员变量上的，所以要先拿到成员变量先
                Field[] fields = clazz.getDeclaredFields();
                for(Field field : fields) {
                    //2.成员变量里又可能包含一些非bean类型的成员变量，所以要判断有@Autowired注解的才要注入
                    if(field.isAnnotationPresent(Autowired.class)) {
                        Autowired autowired = field.getAnnotation(Autowired.class);
                        //3.拿到上面定义的用于存放beans的Map的key，根据key去map中找到对应的实体
                        String key = autowired.value();
                        Object obj = beans.get(key);
                        //4.由于在被@Autowired修饰的成员变量一般是private的，所有要打开它的权限
                        field.setAccessible(true);
                        try {
                            //5.注入
                            field.set(instance,obj);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    /**
     * 为扫描到的类创建实例化对象
     */
    private void doInstance() {
        if(classNames.size() <= 0) {
            System.out.println("没有扫描到类.......");
            return;
        }
        for(String className : classNames) {
            try {
                String cn = className.replace(".class","");
                Class<?> clazz = Class.forName(cn);
                if(clazz.isAnnotationPresent(Controller.class)) {
                    //这一句要放在里面，我的包目录结构里，除了有类（class）,还有注解@Autowired等，否则会报错
                    Object instance = clazz.newInstance();
                    //这里注意不要写成Controller controller = clazz.getAnnotation(Controller.class),因为Controller的key是@RequestMapping的value
                    RequestMapping controllerRequestMapping = clazz.getAnnotation(RequestMapping.class);
                    beans.put(controllerRequestMapping.value(),instance);
                }else if (clazz.isAnnotationPresent(Service.class)) {
                    Object instance = clazz.newInstance();
                    Service service = clazz.getAnnotation(Service.class);
                    beans.put(service.value(),instance);
                }else {
                    continue;
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 扫描basePackage包，获取到这个包以及这个包的子包中的所有类
     * @param basePackage
     */
    private void scanPackage(String basePackage) {
        URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\\.","/"));
//        URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\\.","/"));
        String fileStr = url.getPath();
        File file = new File(fileStr);
        String[] files = file.list();
        for(String path : files) {
            File filePath = new File((fileStr + path));
            if(filePath.isDirectory()) {
                scanPackage(basePackage + "." + path);
            }else {
                classNames.add(basePackage + "." + filePath.getName());
            }
        }
    }

    @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 {
        //1.先获取到请求的路径,获取到的值例如：write-springmvc/test/query
        String uri = req.getRequestURI();
        /**
         * 2.截取，只留下Controller的@RequestMapping + 方法的@RequestMapping部分
         */
        //获取的的值如：write-springmvc
        String context = req.getContextPath();
        //只留下 /test/query
        String path = uri.replace(context,"");

        //3.然后以path作为key，去handlerMap中找到对应的方法对象
        Method method = (Method) handlerMap.get(path);

        //4.把参数封装到参数数组中(这一步在spingMVC中是以策略模式实现的，由于我不是很懂策略模式，所以这里用自己的方法达到相同的效果)
        Object[] args = hand(req,resp,method);

        //5.获取到Controller实例
        String pathStr = "/" + path.split("/")[1];
        Object instance = beans.get(pathStr);

        //6.调用方法
        try {
            method.invoke(instance,args);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 把参数封装到参数数组中
     * @param request
     * @param response
     * @param method
     * @return
     */
    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时为@RequestParam,需要解析
             * [@com.enjoy.nelson.annotation.EnjoyRequestParam(value=name)]
             */
            Annotation[] paramAns = method.getParameterAnnotations()[index];
            if(paramAns.length > 0) {
                for(Annotation paramAn : paramAns) {
                    if(RequestParam.class.isAssignableFrom(paramAn.getClass())) {
                        RequestParam rp = (RequestParam) paramAn;
                        //找到注解里的name和age
                        args[args_i ++] = request.getParameter(rp.value());
                    }
                }
            }
            index ++;
        }
        return args;
    }
}

最后运行结果截图
这里写图片描述

nelson620
关注
专栏目录
手写SpringMvc
qq_28275473的博客
08-30 429
一、简介 空闲之余手撕一把springMVC，以加深对spring的理解，尽可能写的全面，源码中注释也会很详细。话不多说开搞！ 二、项目搭建 在IDEA上用MAVEN创建一个webApp项目： 原来的springMVC中，最重要的一个类就是DispatchServlet即前端请求控制器，我们自定义自己的DispatchServlet，继承HttpServlet。 因为要继承HttpServlet...
手写简易 SpringMVC
weixin_44062380的博客
05-24 299
文章目录手写 SpringMVCDispatcherServletHandlerMapping枚举类型自定义注解类的关系测试 手写 SpringMVC 常规的 JavaEE 开发方式，需要对不同请求，都新建一个 Servlet，比如说登录、登出，就需要两个 Servlet ，使得开发十分的繁琐 这里，我们模仿 SpringMVC 的开发模式，去设计实现一个简易的 SpringMVC，一是为了简化我们的开发流程，二是为我们后面学习 SpringMVC 打下基础 框架的大致流程如下： Dispatcher
手写 springmvc
01-16
java spring springmvc 手写 博客位置： http://knight-black-bob.iteye.com/blog/2407872
手写 Spring MVC
热门推荐
肖朋伟
07-20 5万+
手写 Spring 不多说，简历装 X 必备。不过练好还是需要求一定的思维能力。 一、整体思路 思路要熟练背下来 1）配置阶段 配置 web.xml： XDispatchServlet 设定 init-param： contextConfigLocation = classpath:application.xml 设定 url-pattern： /* 配置 Annotation： @XContr...
Spring MVC（二）手写一个简易的Spring MVC框架
最新发布
weixin_41324710的博客
07-29 24
一、前言只实现了主线流程，因为看源码主要还是需要掌握其核心流程做了什么，所以我也希望通过这种方式来进行源码阅读后的记录和总结。工程我已经搭建好并测试过了，注释也写得比较详细，感兴趣的小伙伴可以关注私聊我给你们发工程地址~二、实现思路1、创建Maven工程2、创建控制层、业务层代码3、准备自定义注解和SpringMVC核心配...
手写实现SpringMVC
qq_43843037的博客
12-01 580
SpringMVC流程图 用户发送请求至前端控制器DispatcherServlet。 DispatcherServlet收到请求调用HandlerMapping处理器映射器。 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 DispatcherServlet调用HandlerAdapter处理器适配器。 HandlerAdapter经过适配调用具体的处理器(Controlle
手写springmvc
weixin_42304484的博客
01-01 300
手写springmvc的思路 springmvc的核心也是一个servlet即DispatcherServlet，这个servlet会配在web.xml里面，注意它的url-pattern配置的是/*，即拦截了所有请求。 其原理就是当浏览器发送请求的时候，都会被springmvc的这个servlet拦截到，然后springmvc会将这个请求的url进行一些处理，处理后去匹配对应的controller中对应的method（requestMaping中填写的请求路径）。匹配之后就通过反射调用方法，完成业务逻辑。
简易的手写springmvc
08-04
本工程模仿了简易的springMVC的实现， 包含了controller、service、requestParam、autowired、requestMapping注解类的创建 IOC容器的创建及组装原理实现 简易的request请求
手写SpringMVC
02-14
手写SpringMVC的过程可以帮助我们深入理解其内部工作原理，从而更好地运用和优化实际项目中的SpringMVC配置。在这个过程中，我们将探讨以下几个关键知识点： 1. **模型-视图-控制器（MVC）架构**： MVC是一种设计...
手写springmvc 简易版
10-28
springmvc 手写简易版,很多功能网友可以自己再完善 比如ModelAndview以及method返回值的处理 有助于更好的帮助你理解源码
手写 Spring MVC篇
@Bean
07-19 251
上面的四篇文章介绍并写完了SpringBean的生命周期，现在开始来写Spring MVC Spring MVC我们只写一层 C层 即 Controller 控制层（没有父子容器） 众所周知 Spring MVC有一个中央处理器 叫 DispatcherServlet，实现了HttpServlet 是一个Servlet 既然是一个Servlet 肯定是要遵循Servlet的规范。 我们通常知道的服务器一般有tomcat 和 jetty等等 ，这两个容器也实现了Servlet的规范。 在容器运行完.
手写实现Spring MVC
杜莱的博客
04-08 381
⼿写实现Spring MVC 框架 根据SpringMVC执⾏的⼤致原理，⼿写一个spring mvc的简易版框架 第 1 节 代码的整体结构 第 2 节 依赖文件pom.xml配置 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sc
SpringMVC1-手写mvc
growing_duck的博客
02-07 333
springmvc
手写springmvc框架
weixin_45060598的博客
12-17 688
1.Spring MVC的运行流程如下。 我们来假设一下这个场景： DispatcherServlet是MVC场景里的老大，而且亲力亲为，什么事都要他过目审批，这天他收到了一份用户请求，叫他给出一个网页页面。 他马上给他的副手HandlerMapping，说：“小刘，你看看这个活，谁来干合适？”小刘HandlerMapping一看员工花名册有一个叫小张的Controller能够胜任，小刘就对领导说：“Controller小张能干”。 这时候，领导DispatcherServlet不能直接.
手写SpringMVC框架
田维常
10-26 893
关注公众号“java后端技术全栈”回复“000”获取优质面试资料大家好，我是老田，今天给大家分享：手写SpringMVC框架本文目录写在前面 Spring 想必大家都听说过，可能现在更多流...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值