纯手写SpringMVC框架，常用注解实现springMvc过程

最新推荐文章于 2024-08-12 18:33:16 发布
最新推荐文章于 2024-08-12 18:33:16 发布
阅读量448 收藏 4
点赞数 1
分类专栏： java 文章标签： springMvc 手写springMvc mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010199866/article/details/81636259
版权

当你迷茫不知道学什么技术的时候，你是否想到将时间花在研究分析经典的开源框架上，springMvc这么经典的成熟框架里面用到了大量的设计模式，优雅的代码很值得你深入去学习，学习大师的编码思想和设计模式，学习源码是提高自己代码编写的最佳方式。

废话不多说，我们现在开始手写一个做java开发人人皆知的springMvc框架。

 

博客原代码地址:

https://gitee.com/nanjunyu/ssm-example.git

 

 

具体的业务执行步骤如下:

⑴ 用户发送请求至前端控制器DispatcherServlet

⑵ DispatcherServlet收到请求调用HandlerMapping处理器映射器。

⑶ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

⑷ DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

⑸ 执行处理器(Controller，也叫后端控制器)。

⑹ Controller执行完成返回ModelAndView

⑺ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

⑻ DispatcherServlet将ModelAndView传给ViewReslover视图解析器

⑼ ViewReslover解析后返回具体View

⑽ DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

⑾ DispatcherServlet响应用户。

 

 

所以我们知道了springMvc最底层的DispatcherServlet 其实就是个servlet，在这个servlet里用反射，对不同的注解，进行了大量的装载操作，进行了大量的ioc依赖处理，建立了一些映射关系。

ok 我们知道了庐山真面目，所有发现实现几个简单的注解其实没啥难度，现在我们开始码代码。

首先我们新建一个普通的maven项目，如下是我的代码结构。

 

1.pom文件添加servlet依赖，这个必须用到的。

  <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
    </dependencies>

 

2.我们建好4个springMvc常见注解

 @Autowired 

package com.ssm.example.annotation;

import java.lang.annotation.*;

/**
 * @Author: nanJunYu
 * @Description:自动装配
 * @Date: Create in  2018/8/13 11:08
 */
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    String value() default "";
}

  @Controller

package com.ssm.example.annotation;

import java.lang.annotation.*;

/**
 * @Author: nanJunYu
 * @Description: 标示为控制层
 * @Date: Create in  2018/8/13 11:06
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {
}

@RequestMapping

package com.ssm.example.annotation;

import java.lang.annotation.*;

/**
 * @Author: nanJunYu
 * @Description:访问记录映射 作用范围内和方法
 * @Date: Create in  2018/8/13 11:08
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {
    String value() default "";

}

@Service

package com.ssm.example.annotation;

import java.lang.annotation.*;

/**
 * @Author: nanJunYu
 * @Description: 启动时将自动注册到容器
 * @Date: Create in  2018/8/13 14:33
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

3.我们建好测试测试接口和实现类

package com.ssm.example.service;

/**
 * @Author: nanJunYu
 * @Description:
 * @Date: Create in  2018/8/13 14:39
 */
public interface FrankService {
    String query(String name,String job);
}

package com.ssm.example.service.impl;

import com.ssm.example.annotation.Service;
import com.ssm.example.service.FrankService;

/**
 * @Author: nanJunYu
 * @Description:
 * @Date: Create in  2018/8/13 14:40
 */
@Service(value = "FrankServiceImpl")
public class FrankServiceImpl implements FrankService {
    public String query(String name, String job) {
        return "name:=" + name + "    job:=" + job;
    }
}

4.我们建好测试的controller

package com.ssm.example.controller;

import com.ssm.example.annotation.Autowired;
import com.ssm.example.annotation.Controller;
import com.ssm.example.annotation.RequestMapping;
import com.ssm.example.service.FrankService;

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

/**
 * @Author: nanJunYu
 * @Description: ssm Controller 控制层
 * @Date: Create in  2018/8/13 14:38
 */
@Controller
@RequestMapping(value = "/ssm")
public class FrankController {

    @Autowired("FrankServiceImpl")
    FrankService frankService;

    @RequestMapping(value = "/test")
    public void queryParam(HttpServletResponse response) {
        try {
            PrintWriter printWriter = response.getWriter();
            String result = frankService.query("Frank", "java");
            printWriter.write(result);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.我们建好最核心的类DispatcherServlet

 这里提一下整体思路

/** 第一步:把所有的bean扫描出来  扫描所有的class文件
 *  第二步:根据集合里的class类创建对象
 *  第三步:根据bean进行关系依赖处理
 *  第四步:建立完整映射关系
 *  第五步:根据客户端请求，在doPost方法里获取到客户端请求的路径，然后在我们装载好的容器中进行获取对应实例对象。
 */
package com.ssm.example.servlet;

import com.ssm.example.annotation.Autowired;
import com.ssm.example.annotation.Controller;
import com.ssm.example.annotation.RequestMapping;
import com.ssm.example.annotation.Service;
import com.ssm.example.controller.FrankController;

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.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;

/**
 * @Author: nanJunYu
 * @Description: 所有的bean使用之前得先被创建，放到mapping里面，
 * 所以启动的时候就应该创建，在init方法里做处理
 * <p>
 * 将所有的依赖关系进行扫描建立好
 * @Date: Create in  2018/8/13 11:11
 */
public class DispatcherServlet extends HttpServlet {

    List<String> classNames = new ArrayList();

    Map<String, Object> beans = new HashMap<>();
    Map<String, Object> handlerMap = new HashMap<>();

    private static final long serialVersionUID = 1L;

    @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 {
        //获取请求路径
        String url = req.getRequestURI();
        String context = req.getContextPath();
        String path = url.replace(context, "");
        Method method= (Method) handlerMap.get(path);
        //根据key去拿实例
        FrankController frankController= (FrankController) beans.get("/"+path.split("/")[1]);
        try {
            method.invoke(frankController, new Object[] { req, resp});
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void init() throws ServletException {
        /** 第一步:把所有的bean扫描出来  扫描所有的class文件
         *  第二步:根据集合里的class类创建对象
         *  第三步:根据bean进行关系依赖处理
         *  第四步:建立完整映射关系
         */
        scanPackage("com.ssm");
        doInstance();
        doIoc();
        buildUrlMapping();
    }

    /**
     * @Author: nanJunYu
     * @Description:把所有的bean扫描出来 扫描所有的class文件
     * @Date: Create in  2018/8/13 15:10
     * @params: basePackage:项目的包根路径
     * @return:
     */
    private void scanPackage(String basePackage) {
        //拿到项目的路径开始扫描所有的class
        URL url = this.getClass().getClassLoader().getResource("/" + basePackage.replaceAll("\\.", "/"));
        String fileStr = url.getFile();
        File file = new File(fileStr);
        String fileArray[] = file.list();
        for (String path : fileArray) {
            File filePath = new File(fileStr + path);
            //代表是文件夹 继续递归
            if (filePath.isDirectory()) {
                scanPackage(basePackage + "." + path);
            } else {
                //代表是class文件目录 将完整的class物理文件路径地址 放入到集合里
                classNames.add(basePackage + "." + filePath.getName());
            }

        }
    }

    /**
     * @Author: nanJunYu
     * @Description:根据集合里的class类创建实例化对象
     * @Date: Create in  2018/8/13 15:34
     * @params:
     * @return:
     */
    private void doInstance() {
        if (classNames.isEmpty()) {
            System.out.println("class扫描失败.......");
        }
        for (String className : classNames) {
            //去除多余的后缀名
            String cName = className.replace(".class", "");
            try {
                Class<?> clazz = Class.forName(cName);
                if (clazz.isAnnotationPresent(Controller.class)) {
                    //如果是控制类 反射创建控制类
                    Object instance = clazz.newInstance();
                    RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                    String value = requestMapping.value();
                    //获取到@RequestMapping上配置的地址 当key放到map容器里  将实例以value的形式存放
                    beans.put(value, instance);
                } else if (clazz.isAnnotationPresent(Service.class)) {
                    Service service = clazz.getAnnotation(Service.class);
                    Object instance = clazz.newInstance();
                    //获取到@Service上配置的地址 当key放到map容器里  将实例以value的形式存放
                    beans.put(service.value(), instance);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @Author: nanJunYu
     * @Description:把Service注入到控制层
     * @Date: Create in  2018/8/13 15:53
     * @params:
     * @return:
     */
    private void doIoc() {
        if (beans.entrySet().size() <= 0) {
            System.out.println("没有一个实例类");
        }
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(Controller.class)) {
                //获得所有声明的参数 得到参数数组
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(Autowired.class)) {
                        Autowired autowired = field.getAnnotation(Autowired.class);
                        String key = autowired.value();
                        //打开私有属性的权限修改
                        field.setAccessible(true);
                        try {
                            //给变量重新设值
                            field.set(instance, beans.get(key));
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    } else {
                        continue;
                    }
                }
            } else {
                continue;
            }
        }
    }

    /**
     * @Author: nanJunYu
     * @Description:根据扫描到的类上的RequestMapping注解和方法上的RequestMapping建立完整映射关系。
     * @Date: Create in  2018/8/13 15:53
     * @params:
     * @return:
     */
    private void buildUrlMapping() {
        if (beans.entrySet().size() <= 0) {
            System.out.println("没有类的实例化......");
            return;
        }
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object instance = entry.getValue();
            Class<?> clazz = instance.getClass();
            if (clazz.isAnnotationPresent(Controller.class)) {
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                String classPath = requestMapping.value();
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(RequestMapping.class)) {
                        RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                        String methodPath = methodMapping.value();
                        //完整的映射路径
                        handlerMap.put(classPath + methodPath, method);
                    } else {
                        continue;
                    }
                }
            } else {
                continue;
            }
        }
    }
}

6.建立项目入口web.xml，并且配置我们编写好的servlet

<?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"
         version="3.0">
    <display-name>frank-ssm</display-name>
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>com.ssm.example.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>

7.到这里我们代码就完成了，很简单吧，我们现在配置tomcat跑一下。

  这里设置一下web项目的web.xml，不然idea不知道

 

这里我们创建一个打包方式

 

 

 

 

下面我们启动一下tomcat

 

nice启动没有报任何错误，我们打开浏览器见证奇迹了。

 

完美！！！，哈哈，有意思吧 。。。下期我们再手写个mybatis玩玩，感谢观看！

 

博客原代码地址:

https://gitee.com/nanjunyu/ssm-example.git

Collin Nam
关注
专栏目录
纯手写SpringMVC框架
weixin_45017862的博客
07-11 668
通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（ JSP）技术、Velocity、Tiles、iText 和 POI。Spring MVC 框架并不知道使用的视图，所以不会强迫您只使用 JSP 技术。Spring MVC 分离了 控制器、模型 对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。 Lifecycle fo...
手写SpringMVC框架（简易版）
yaluoshan的专栏
06-22 1万+
SpringMVC简介 SpringMVC是当前最优秀的MVC框架，自从Spring 2.5版本发布后，由于支持注解配置，易用性有了大幅度的提高。Spring 3.0更加完善，实现了对Struts 2的超越。现在越来越多的开发团队选择了Spring MVC。 - Spring为展现层提供的基于MVC设计理念的优秀的Web框架，是目前最主流的MVC框架之一 - Spring3.0后全面超越St...
Spring常用注解
03-22
spring常用的注解，测试环境myeclipse 版本Version: 10.0 jdk 1.8 junit4
spring框架常用注解
weixin_45438625的博客
06-15 289
spring框架的常用注解 1.声明bean的注解 @Component：声明类为组件，没有明确的角色 @Service：在业务逻辑层使用（service层） @Repository：在数据访问层使用（dao层） @Controller：在控制层使用，控制器的声明（Controller）返回视图 @RestController: 在控制层使用,控制器的声明,返回对象 2.注入bean的注解 @Autowired：由Spring提供，按类型注入，如果一个接口有多个实现，需要和@Qualifier配合使用 3、
Spring框架常用注解详解
最新发布
lucky_fd的博客
08-12 772
Spring 框架作为 Java 开发中最受欢迎的开源框架之一，其强大的功能很大程度上得益于其丰富的注解（Annotation）支持。本文对Spring框架中常用的注解进行详细解析，并通过示例来展示它们的用法和效果。
一篇非常经典的springMVC注解实现方式详解
weixin_30826761的博客
05-31 142
今天公司让搭建个springMVC的注解框架，研究了好半天，网络搜罗了半天，好不容易找到篇，拿来分享下： 原文出处：http://itxxz.com/a/kuangjia/2014/0531/4.html 大家好，我是IT学习者的螃蟹，前两天写了一个spring MVC的注解实例，目前看来下载使用的人数已有不少，使用过程中也有不少人对...
spring 框架常用注解
zxy199288的博客
09-13 152
Java5.0过后开始支持注解，Spring作为java中的领军框架，在Spring2.5过后也开始放弃xml配置文件了，更多的推荐注解来使用Spring框架。 Spring中那么多的注解，其中很多可能在工作中很少能遇见，也就用不上。下面就给大家总结一些常用的注解。 @Required 该注解用于bean的setter方法上。表示这个属性是必须的，在配置阶段必须注入，否则会抛出异常。 @Autowired 该注解用于bean的属性，set方法以及和构造器上，通过type来声明bean依赖，从而自动
Spring框架之常用注解
weixin_55026035的博客
04-14 217
在Spring中我们常用注解及作用 @Configuration 标识当前类是配置类 @ComponentScan 包扫描注解 扫描注解 @Bean 标识该方法的返回值交给Spring容器管理 @Scope 控制多例和单例 @Lazy 懒加载 @PostConstruct 初始化方法 @PreDestroy 销毁方法 @Component 将当前类未来的对象交给容器管理 @Autowired 按照类型进行注入 @Qualifier 按照名称进行注入 @Repository 标识持久层注解 @Service
java 手写SpringMVC框架
12-18
手写SpringMVC框架有助于深入理解其内部机制，同时锻炼了我们对Java反射、注解以及设计模式的应用能力。这个过程不仅有趣，而且对提升个人技能大有裨益。在实践中，我们还可以不断优化和扩展框架，使其满足特定项目...
java手写SpringMvc框架
11-02
本篇文章将深入解析如何手写Spring MVC框架，以及在这个过程中理解包扫描过程和Spring MVC的运行机制。 首先，我们需要了解Spring MVC的基本架构。它主要包括DispatcherServlet、HandlerMapping、Controller、...
手写 springmvc
01-16
手写SpringMVC意味着从零开始创建一个类似SpringMVC的框架，这个过程涵盖了核心组件的设计和实现，如DispatcherServlet、HandlerMapping、HandlerAdapter、ViewResolver等。通过这个实践，开发者可以深入学习...
手写的springmvc框架
10-26
在本项目中，我们看到的是一个由个人手写实现的 Spring MVC 框架的尝试。虽然这个实现可能还存在一些瑕疵，但其核心概念和设计思想与官方的 Spring MVC 框架是一致的，这为我们提供了一个学习和理解 MVC 模式的绝佳...
Spring框架常用的注解
zhx__的博客
08-08 2459
@Spring框架的注解 Spring框架的注解 @EnableAutoConfiguration //交给spring管理 @ComponentScan("com.zzrd.service")//扫描service层组件 @MapperScan("com.zzrd.dao")// @RestController @RequestMapping("book") @RestController//表示Spring 控制层组件，默认所包含的方法都是为了处理Ajax请求(不用在每个方法上单独在写@Respons
Spring框架的常用注解
qq_46030254的博客
05-18 1038
Service(“userService”)注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫"userService"的变量来接收由Spring注入的"userService"即可。
Spring框架常用注解
热门推荐
CJW的博客
07-19 1万+
Spring常用注解 @Controller @Controller 用来响应页面，表示当前的类为控制器。 在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Contro
spring框架中常用的注解
marvin
10-29 783
@SpringBootApplication //申明springBoot启动器 @EnableEurekaServer //申明该springBoot服务为注册机 @EnableEurekaClient //申明springBoot为客户服务机 @Bean //执行一个方法返回类型为bean 加上此注解交给SpringBoot处理 @LoadBalanced //负载均衡，交给@Bean时在下...
简述springmvc框架常用注解及用途
05-16
SpringMVC框架是一种基于Java的Web框架，常用注解及其用途如下： 1. @Controller：标记该类为SpringMVC的Controller，处理HTTP请求和响应。 2. @RequestMapping：用于映射请求URL和处理方法，可以设置请求URL的路径、请求方式、请求参数、响应数据格式等属性。 3. @RequestParam：用于将请求参数绑定到方法参数上。 4. @PathVariable：用于将URL中的参数绑定到方法参数上。 5. @ResponseBody：将方法返回值转换成指定的格式（如JSON、XML）并返回给客户端。 6. @ModelAttribute：用于将请求参数绑定到模型对象上，并将模型对象添加到视图中。 7. @SessionAttribute：用于将模型对象存储到会话中，在多个请求之间共享数据。 8. @InitBinder：用于初始化数据绑定器，可以对表单数据进行格式化、类型转换等操作。 相关问题: 1. 什么是SpringMVC框架？ 2. SpringMVC框架中常用的注解有哪些？ 3. @RequestMapping注解有哪些常用属性？ 4. @ResponseBody注解的作用是什么？ 5. @SessionAttribute和@ModelAttribute的区别是什么？
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值