手写简易SpringMVC 框架

最新推荐文章于 2024-04-02 20:41:23 发布
最新推荐文章于 2024-04-02 20:41:23 发布
阅读量188 收藏
点赞数 1
分类专栏： SpringMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16183731/article/details/88785122
版权
  • 手撕简易SpringMVC框架
    mvc 整体架构
    在这里插入图片描述
    新建一个动态 Web 工程。整体机构如下：
    在这里插入图片描述
    1. 手写自己的Dispather 类，继承 HttpServlet
@PackageScann
public class MyDispather extends HttpServlet {

    private static final long serialVersionUID = -7154047248664853493L;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doget" + req.getRequestURI() + ":==:" + req.getRequestURL());
        resp.sendRedirect("/pages/index.html");
    }

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

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.err.println("dispather service()" + Thread.currentThread().getName());
        String requestURI = req.getRequestURI();
        if (requestURI.endsWith("/")) {
            requestURI = requestURI.substring(0, requestURI.length() - 1);
        }
        if (IOCUtils.getUrlMaps().containsKey(requestURI)) {
            Method method = IOCUtils.getUrlMaps().get(requestURI);
            try {
                method.invoke(IOCUtils.newInstance(method), req, resp);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            resp.getWriter().write("The URL NOT Found");
        }
    }

    @Override
    public void destroy() {
        System.err.println("dispather destory()");
    }

    /**
     * 获取所有的自定义注解类，并且实例化，并且收入BeanMap 中
     */
    @Override
    public void init() throws ServletException {
        System.out.println("dispather init()");
        // 获取扫描路径下所有的class文件,实例化注解的bean.
        IOCUtils.getBasePackage(this.getClass());
        IOCUtils.createBeanMaps();

    }

}
    1. 自定义过滤器，处理请求乱码问题
public class MyServletFilter implements Filter {

    @Override
    public void destroy() {
        System.out.println("=========过滤器销毁了=================");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;
        System.out.println("过滤器执行操作" + req.getQueryString());
        req.setCharacterEncoding("utf-8");

        // 解决浏览器中文乱码
        res.setHeader("content-type", "text/html;charset=utf-8");
        // 解决get请求乱码
        MyRequestWarp reqs = new MyRequestWarp(req);
        chain.doFilter(reqs, res);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("过滤器初始化");
    }

}
    1. 自定义增强 HttpServletRequestWrapper 类，对请求的参数进行解码
public class MyRequestWarp extends HttpServletRequestWrapper {

    private HttpServletRequest request;

    public MyRequestWarp(HttpServletRequest request) {
        super(request);
        this.request = request;
    }

    // 对请求request 对象的数据进行统一编码
    @Override
    public Map<String, String[]> getParameterMap() {
        // 获取请求方式
        String method = request.getMethod();
        if ("POST".equalsIgnoreCase(method)) {
            try {
                request.setCharacterEncoding("utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            Map<String, String[]> map = request.getParameterMap();
            return map;
        } else if ("get".equalsIgnoreCase(method)) {
            // get请求单独对请求参数单个装换
            Map<String, String[]> map = request.getParameterMap();
            System.out.println(map + ">>>>");
            if (map == null) {
                return super.getParameterMap();
            }
            Set<String> keySet = map.keySet();
            String[] value = null;
            String utf = null;
            try {
                for (String string : keySet) {
                    value = map.get(string);
                    for (int i = 0; i < value.length; i++) {
                        // 字符串转码
                        utf = new String(value[i].getBytes("iso-8859-1"), "utf-8");
                        value[i] = utf;
                    }
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return super.getParameterMap();
    }

    @Override
    public String getParameter(String name) {
        // 通过value获取值
        String[] values = getParameterValues(name);
        if (values != null) {
            return values[0];
        }
        return super.getParameter(name);
    }

    @Override
    public String[] getParameterValues(String name) {
        // 通过map 集合获取值
        Map<String, String[]> parameterMap = getParameterMap();
        if (parameterMap != null) {
            return parameterMap.get(name);
        }
        return super.getParameterValues(name);
    }
}
    1. 自定义 注解 Controller ,Service,RequestMapping,AutoWired,packScann
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) 声明注解的使用范围. TYPE: 注解可以用在类上 FIELD：注解可以用在属性上 METHOD：用在方法上 PARAMETER：用在参数声明上面 CONSTRUCTOR：用在构造方法上面 LOCAL_VARIABLE：用在本地变量上面 @Retention(RetentionPolicy.SOURCE) 声明注解的有效范围 RetentionPolicy.SOURCE: 该注解只在源码中有效！ RetentionPolicy.CLASS: 该注解在源码中，和字节码中有效！(默认) RetentionPolicy.RUNTIME： 该注解在源码中，和字节码中有效，运行字节码的时候有效！

– MyController 控制层注解

/**
 * 自定义控制层注解
 * 
 * @author Donald 2019/03/23 21:08:55
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyController {
    String value() default "";
}

– MyService 服务层注解

/**
 * 自动定义控制层
 * 
 * @author Donald 2019/03/23 21:58:49
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyService {
    String value() default "";
}

– MyRequestMapping 请求注解

/**
 * 自定义请求url 映射
 * 
 * @author Donald 2019/03/23 22:07:26
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyRequestMapping {
    String value() default "";
}

– PackageScann包扫描注解

/**
 * 包扫描注解
 * 
 * @author Donald 2019/03/23 22:38:33
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PackageScann {
    String value() default "";
}

– 参数自动注入注解

/**
 * 自定义自动注入
 * 
 * @author Donald 2019/03/23 22:07:39
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowired {

    String value() default "";
}
    1. 核心IOC 容易类 处理对bean 的管理，请求映射
public class IOCUtils {

    private IOCUtils() {}

    private static HashMap<String, Object> beanMaps = new HashMap<>();

    private static HashMap<String, Class<?>> classMaps = new HashMap<>();

    private static HashMap<String, Method> urlMaps = new HashMap<>();

    private static String basePackage = null;

    private static Class<?> clazz = null;

    public static HashMap<String, Object> getBeanMaps() {
        return beanMaps;
    }

    public static HashMap<String, Method> getUrlMaps() {
        return urlMaps;
    }

    public static HashMap<String, Class<?>> getClassMaps() {
        return classMaps;
    }

    /**
     * 获取扫描的包名。默认为dispather所在的包名
     * 
     * @return
     * @throws IOException
     */
    public static void getBasePackage(Class<?> clazz) {
        IOCUtils.clazz = clazz;
        PackageScann annotation = clazz.getAnnotation(PackageScann.class);
        if (annotation == null) {
            return;
        }
        String className = clazz.getTypeName();
        basePackage =
            "".equals(annotation.value()) ? className.substring(0, className.lastIndexOf(".")) : annotation.value();
        // 获取指定包下面的所有的class 文件
        getClassFiles();
    }

    /**
     * 获取包名及其子包下面的所有的class文件
     */
    private static void getClassFiles() {
        // 将com.feifan 转换成文件夹形式com/feifan 再类加载读取文件
        String fileString = basePackage.replaceAll("\\.", "/");
        // 得到com/feifan的绝对地址 、D:xxx/com/feifan
        String rootPath = clazz.getClassLoader().getResource(fileString).getPath();
        // 直留着com/feifan,拼接类全名
        if (rootPath != null)
            rootPath = rootPath.substring(rootPath.indexOf(fileString));
        try {
            Enumeration<URL> enumeration = clazz.getClassLoader().getResources(fileString);
            while (enumeration.hasMoreElements()) {
                URL url = (URL)enumeration.nextElement();
                if (url.getProtocol().equals("file")) {
                    // 如果是文件
                    File file = new File(url.getPath().substring(1));
                    Scanner(file, rootPath);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 封装类名，字节码 classMaps
     * 
     * @param file
     * @param rootPath
     */
    private static void Scanner(File file, String rootPath) {
        File[] files = file.listFiles();
        for (int i = 0; files != null && i < files.length; i++) {
            File file2 = files[i];
            if (file2.isDirectory()) {
                Scanner(file2, rootPath + file2.getName() + "/");
            } else {
                if (file2.getName().endsWith(".class")) {
                    String classname = (rootPath + file2.getName()).replaceAll("/", ".");
                    // 去掉.class 后缀字节码存入
                    classname = classname.substring(0, classname.lastIndexOf("."));
                    try {
                        classMaps.put(classname, Class.forName(classname));
                    } catch (ClassNotFoundException e) {
                        // TODO 获取字节码文件异常
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 生成自定义注解注解的bean
     */
    public static void createBeanMaps() {
        if (classMaps == null) {
            return;
        }
        Class<?> clazz = null;
        String pathRoot = "";
        String path = "";
        String beanKey = "";
        for (Map.Entry<String, Class<?>> entry : classMaps.entrySet()) {
            clazz = entry.getValue();
            // 控制层注解
            if (clazz.isAnnotationPresent(MyController.class)) {
                if (clazz.isAnnotationPresent(MyRequestMapping.class)) {
                    pathRoot = clazz.getAnnotation(MyRequestMapping.class).value();
                    if (!pathRoot.startsWith("/")) {
                        pathRoot = "/" + pathRoot;
                    }
                    if (!pathRoot.endsWith("/")) {
                        pathRoot = pathRoot + "/";
                    }
                }
                // url 映射路径
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(MyRequestMapping.class)) {
                        path = method.getAnnotation(MyRequestMapping.class).value();
                        if (path.startsWith("/")) {
                            if (path.length() > 1) {
                                path = path.substring(path.indexOf("/") + 1);
                            } else {
                                path = "";
                            }
                        }
                        urlMaps.put(pathRoot + path, method);
                    }
                }

                beanKey = clazz.getSimpleName();
                beanKey = beanKey.substring(0, 1).toLowerCase() + beanKey.substring(1);
                try {
                    beanMaps.put(beanKey, clazz.newInstance());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            // 服务层注解
            if (clazz.isAnnotationPresent(MyService.class)) {

                Class<?>[] classes = clazz.getInterfaces();
                try {
                    for (Class<?> class1 : classes) {
                        beanKey = class1.getSimpleName();
                        beanKey = beanKey.substring(0, 1).toLowerCase() + beanKey.substring(1);
                        beanMaps.put(beanKey, clazz.newInstance());
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }

            }
        }

        createAutowried();
    }

    /**
     * 自动注入参数
     */
    private static void createAutowried() {

        if (classMaps == null) {
            return;
        }

        Class<?> clazz = null;
        String parm = "";
        String beanName = "";
        for (Map.Entry<String, Class<?>> entry : classMaps.entrySet()) {
            clazz = entry.getValue();
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(MyAutowired.class)) {
                    parm = field.getType().toString();
                    parm = parm.substring(parm.lastIndexOf(".") + 1);
                    parm = parm.substring(0, 1).toLowerCase() + parm.substring(1);

                    beanName = clazz.getSimpleName();
                    beanName = beanName.substring(0, 1).toLowerCase() + beanName.substring(1);
                    try {
                        field.setAccessible(true);
                        field.set(beanMaps.get(beanName), beanMaps.get(parm));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 获取当前方法的主类
     * 
     * @param method
     * @return
     */
    public static Object newInstance(Method method) {
        String simpleName = method.getDeclaringClass().getSimpleName();
        simpleName = simpleName.substring(0, 1).toLowerCase() + simpleName.substring(1);
        return beanMaps.get(simpleName);
    }
}
    1. 业务逻辑实现
      – service 接口
public interface UserService {
    void printf();
}

– service 实现类

@MyService
public class UserServiceImpl implements UserService {

    @Override
    public void printf() {
        System.err.println("UserServiceImpl>>>>>>");
    }

}

– controller 类
BaseController 用来获取请求里面的requst,response

public class BaseController {

    protected HttpServletRequest request;
    protected HttpServletResponse response;

    protected void init(HttpServletRequest request, HttpServletResponse response) {
        this.request = request;
        this.response = response;
    }

    protected HttpServletRequest getRequest() {
        return request;
    }

    protected HttpServletResponse getResponse() {
        return response;
    }

}

– 控制层

@MyController
@MyRequestMapping("my")
public class UserController extends BaseController {

    @MyAutowired
    private UserService UserService;

    @MyRequestMapping("my")
    public String getMy(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        System.out.println("进来了" + req.getRequestURL());
        UserService.printf();
        // resp.setHeader("content-type", "text/html;charset=utf-8");
        resp.getWriter().write("恭喜你访问到控制层了>>>>" + req.getParameter("name"));
        return "my";
    }
}
    1. 配置Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>SmsInterface</display-name>
    <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>com.feifan.MyDispather</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
  
  <filter>
  	<filter-name>myFilter</filter-name>
  	<filter-class>com.feifan.Filter.MyServletFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>myFilter</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

启动测试：
在这里插入图片描述
**

至此一波简易的mvc 弄完

**

链接：https://pan.baidu.com/s/1SzcMIrcOSxo7-S--UO3hWQ
提取码：ujg4

码云
https://gitee.com/ming524/HandMVC.git

灬奔跑的蜗牛灬
关注
专栏目录
手写SpringMVC框架
Jack 架构师之路
11-24 480
引言 在分析springMVC框架之前，我们根据我们对整个框架的流程分析，先来手写一个简易版的springMVC框架， 这样我们在看源码的时候会更清晰，毕竟框架源码还是非常庞大的， 如果我们一行一行的看的话， 那就完蛋了，直接陷到里面出不来了。所以本篇 博客我们基于现有的servlet和spring框架来手写模拟一个springMVC框架，在这个框架中我们主要是编写主流程，也就是我们最关系的处理器和适配器等。 一、实现分析 我们在动手之前，首先需要分析一下， springmvc框架到底帮我们做了什么功
手写简易 SpringMVC
weixin_44062380的博客
05-24 310
文章目录手写 SpringMVCDispatcherServletHandlerMapping枚举类型自定义注解类的关系测试 手写 SpringMVC 常规的 JavaEE 开发方式，需要对不同请求，都新建一个 Servlet，比如说登录、登出，就需要两个 Servlet ，使得开发十分的繁琐 这里，我们模仿 SpringMVC 的开发模式，去设计实现一个简易的 SpringMVC，一是为了简化我们的开发流程，二是为我们后面学习 SpringMVC 打下基础 框架的大致流程如下： Dispatcher
想要手撕Spring MVC源码？让我带你一步一步走并手绘流程图
老男孩的架构路
07-15 223
具体我再配合图中解释一下找到了指定的web应用之后，通过请求的路径/news去web.xml中寻找是否有对应的标签，其中这个标签的子标签标签的值需要匹配到请求的路径，这个时候标签的值为/news正好匹配到了，所以我们获取了上面的标签的值然后再寻找是否有标签的子标签和这个值相等，如果有则获取到底下的对应的类并通过这个类去解析请求。为了你省力，我直接告诉你，DispatcherServlet中的doDispatch方法中进行了分发的主要流程。这样，我们就出来了两个。...
手写简易SpringMVC框架
u010173024的博客
04-02 1006
MVC 是模型（model）、视图（view）、控制器（controller）的缩写，它是一个设计模式。面向接口的编程思想，解决的是业务逻辑层和其他各层的松耦合问题。（2）Spring是什么？（1）MVC是什么？
手写简易springmvc框架
JZWen
08-10 259
代码：https://github.com/JZWen/writeSpringMvc 回顾一遍： 准备工作：先写两个注解类 controller层的类 并写上注解 自己写dispatcherServlet  写的也不是很完善 在里面完成 init()  doPost()    web.xml配置信息 只需要配置dispatcherServlet 然后就开始disp...
手写简易版SpringMVC框架
汉南最後の読書人
02-13 276
1.反射工具类 package com.weichai.util; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net.URLDecoder; impo...
手写简易springmvc
我的博客
02-11 285
为了提高自己对springmvc框架的理解，决定模仿springmvc手写一个简单demo 1.创建servlet项目 新建一个maven项目，选中webapp项目的结构 2.下载完成后添加servlet依赖 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;javax.servlet&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&a
手写简易SpringMVC
Kerwin的博客
09-06 186
手写简易SpringMVC 手写系列框架代码基于普通Maven构建，因此在手写SpringMVC的过程中，需要手动的集成Tomcat容器 必备知识： Servlet相关理解和使用，Maven，Java 反射，Java自定义注解 配置Web类型结构 结构如图所示： 注意 要设置 webapp为web moudle -> IDEA 有蓝色小圈圈为准，resource 配置为资源文件 配置...
手写实现SpringMVC
qq_43843037的博客
12-01 589
SpringMVC流程图 用户发送请求至前端控制器DispatcherServlet。 DispatcherServlet收到请求调用HandlerMapping处理器映射器。 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 DispatcherServlet调用HandlerAdapter处理器适配器。 HandlerAdapter经过适配调用具体的处理器(Controlle
SmartMvc:深入解析SpringMVC核心原理：从手写简易版MVC框架开始(SmartMvc)
05-29
所以自己想和小伙伴一起从手写简易版的SpringMVC框架出发， 理出SpringMVC的主线并深入理解SpringMVC的原理 别忘记Star哟 项目结构 SmartMvc ├── docs -- 开发文档 ├── smart-mvc -- 实现mvc功能的核心代码 ├...
手写简易版SpringMVC，探索SpringMVC原理
06-30
手写简易版SpringMVC可以帮助我们理解以下几个关键组件： 1. DispatcherServlet：作为入口点，负责接收请求、分发处理和返回响应。我们可以实现一个简单的Servlet来模拟这个角色。 2. HandlerMapping：负责根据...
阿里P7大牛一对一教你如何手写SpringMVC框架
10-10
本文将从SpringMVC框架的基本概念出发，深入解析其工作原理，并逐步指导如何实现一个简易版本的手写SpringMVC框架。 ### 一、SpringMVC框架概述 #### 1.1 SpringMVC简介 SpringMVC是Spring框架的一部分，主要用于...
SpringMVC精品资源--深入解析SpringMVC核心原理：从手写简易版MVC框架开始(SmartMvc).zip
02-18
本资源包"SpringMVC精品资源--深入解析SpringMVC核心原理：从手写简易版MVC框架开始(SmartMvc).zip"旨在帮助开发者深入理解SpringMVC的工作机制，并通过构建一个简单的SmartMvc框架来实践这一过程。 1. **MVC模式...
MATLAB公路裂缝检测系统面板GUI.zip
11-02
圣诞树
Flask-2.1.3.tar.zip
最新发布
11-02
Flask-2.1.3.tar.zip
Flask-0.12.4.tar.zip
11-02
Flask-0.12.4.tar.zip
基于LangChain的QQ邮件智能收发工具
11-02
基于LangChain的QQ邮件智能收发工具
Flask-1.0.4-py2.py3-none-any.zip
11-02
Flask-1.0.4-py2.py3-none-any.zip
江协科技0.96寸OLED驱动函数（HAL库移植）
11-02
江协科技0.96寸OLED驱动函数（HAL库移植）
SpringMVC框架源码学习与实践
描述 "mvc系统 SpringMVC基础 MVC框架项目源码 初学者学习" 揭示了该资源是针对MVC系统和SpringMVC框架的介绍。描述指出资源适合初学者，强调了其基础性。MVC是一个软件工程中对软件系统的组成部分进行分离的设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值