从头开始实现一个小型spring框架——控制器controller实现mvc请求拦截和响应

最新推荐文章于 2024-04-12 17:15:33 发布

置顶 Kevin_Lyz

最新推荐文章于 2024-04-12 17:15:33 发布

阅读量2.7k

点赞数 4

分类专栏： JavaWeb 手写Spring 文章标签：手写Spring Spring 实现SpringMvc SpringMVC

本文链接：https://blog.csdn.net/qq_31749835/article/details/91038594

版权

JavaWeb 同时被 2 个专栏收录

7 篇文章 1 订阅

订阅专栏

手写Spring

4 篇文章 2 订阅

订阅专栏

手写Spring之控制器controller实现mvc控制

写在前面

最近学习了一下spring的相关内容，所以也就想要照猫画虎地记录和实现一下spring的框架，通过阅读这些也希望能够消除对Spring框架的恐惧，其实细心阅读框架也很容易理解。
mini-spring尽量实现spring的核心功能。文章写得很仓促，可能不是很全面，在全部完成之后我们再来完善表达吧，见谅~

项目的源码我放在了github上：源码地址

我会在这里整理文章的系列目录：

一、容器内对请求的处理过程

我们在上一篇博客里讲了，容器内具体请求的处理流程对于容器是一个黑盒，根据具体的实现而有所不同。下面我们就对典型的容器内部的处理流程进行简单的总结和叙述。

1.1 请求典型流程

先看这么一张图片：

熟悉Servlet开发流程的都知道，我们需要在web.xml中配置我们的Servlet路径和请求路径，或者使用注解进行配置，才可以完成URL和Servlet之间的映射。

我们把URI到Servlet的映射配置到Xml里，当一个http请求到达服务器时，服务器会获取这个请求的URI，然后去Web.xml中查找，通过映射表找到对应的Servlet，并把这个请求转发到对应的Servlet，Servlet处理完后，再把结响应回去。这就是整个业务的处理流程了。

1.2 存在的问题

服务器调度的问题
配置集中，大而且杂乱，维护成本高
需要多次实现Servlet接口

1.3 Spring的改进

Spring对这个问题的改进，是引入的一个总管一样的方式进行管理，也就是我们非常熟悉的DispatcherServlet，用来受理所有的业务。

其中的差异可以对比下面这张图片

tomcat统一将请求发送给DispatcherServlet，再由DispatcherServlet将这些请求派发给具体的Mapping Handler，处理完毕后返回。其中Servlet接口仅实现了一次。并且通过注解的方式进行配置，更简化了我们的实现流程，分散配置，业务逻辑也就变得清晰明确。

二、mvc实现

2.1 变化后的包结构

本次实现新增加了

framework模块

core包中增加ClassScanner实现包扫描
增加handler包实现反射获取类信息
mvc包增加注解
- Controller注解标志类
- RequestMapping注解方法
- RequestParam注解参数
修改servlet包实现全局 / 路径下的uri拦截

test模块

增加controller实现测试请求

2.2 framework模块实现DispatcherServlet和反射获取类信息

core包下的ClassScanner类


package com.qcby.core;

import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * @author kevinlyz
 * @ClassName ClassScanner
 * @Description 通过类加载器获取目录下的类列表
 * @Date 2019-06-08 17:26
 **/
public class ClassScanner {

    public static List<Class<?>> scannClasses(String packageName) throws IOException, ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<>();
        String path = packageName.replace(".","/");
        //获取类加载器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Enumeration<URL> resources = classLoader.getResources(path);
        while (resources.hasMoreElements()){
            URL resource = resources.nextElement();
            //处理资源类型是jar包的情况
            if (resource.getProtocol().contains("jar")){
                JarURLConnection jarURLConnection =
                        (JarURLConnection) resource.openConnection();
                String jarFilePath = jarURLConnection.getJarFile().getName();
                classes.addAll(getClassFromJar(jarFilePath,path));
            }else{
                // TODO: 处理jar包以外的情况
            }
        }
        return classes;
    }

    /**
     * @Author kevinlyz
     * @Description 从jar包中获取资源
     * @Date 17:37 2019-06-08
     * @Param
     * @return List<Class<?>>
     **/
    public static List<Class<?>> getClassFromJar(String jarFilePath,String path) throws IOException, ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<>();
        //获取jar实例
        JarFile jarFile = new JarFile(jarFilePath);
        Enumeration<JarEntry> jarEntrys = jarFile.entries();
        while (jarEntrys.hasMoreElements()){
            JarEntry jarEntry = jarEntrys.nextElement();
            //获取类路径名  如  com/qcby/test/Test.class
            String entryName = jarEntry.getName();
            //获取的
            if (entryName.startsWith(path)&&entryName.endsWith(".class")){
                //路径替换
                String classFullName = entryName.replace("/",".").substring(0,entryName.length()-6);
                //反射获取类信息并添加至list
                classes.add(Class.forName(classFullName));
            }
        }
        return classes;
    }
}

scannClasses之后会在MiniApplication中被调用，用于获取类列表。

MiniApplication类，添加获取类列表和反射调用。

package com.qcby.starter;

import com.qcby.core.ClassScanner;
import com.qcby.web.handler.HandlerManagger;
import com.qcby.web.server.TomcatServer;

import java.util.List;

/**
 * @author kevinlyz
 * @ClassName MiniApplication
 * @Description 框架的入口类
 * @Date 2019-06-04 19:21
 **/
public class MiniApplication {
    public static void run(Class<?> cls,String[] args){
        System.out.println("Hello mini-spring application！");
        TomcatServer tomcatServer = new TomcatServer(args);
        try {
            tomcatServer.startServer();
            List<Class<?>> classList = ClassScanner.scannClasses(cls.getPackage().getName());
            classList.forEach(it->System.out.println(it.getName()));
            HandlerManagger.resolveMappingHandler(classList);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

HandlerManager类

package com.qcby.web.handler;

import com.qcby.web.mvc.Controller;
import com.qcby.web.mvc.RequestMapping;
import com.qcby.web.mvc.RequestParam;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;

/**
 * @author kevinlyz
 * @ClassName HandlerManagger
 * @Description 反射获取类信息
 * @Date 2019-06-08 18:34
 **/
public class HandlerManagger {

    public static List<MappingHandler> mappingHandlerList = new ArrayList<>();

    public static void resolveMappingHandler(List<Class<?>>  classList){
        for (Class<?> cls : classList){
            if (cls.isAnnotationPresent(Controller.class)){
                presentHandlerFromController(cls);
            }
        }
    }

    private static void presentHandlerFromController(Class<?> cls) {
        //获取方法
        Method[] methods= cls.getDeclaredMethods();
        for (Method method : methods){
           if(!method.isAnnotationPresent(RequestMapping.class))
               continue;
           //获取uri路径
           String uri = method.getDeclaredAnnotation(RequestMapping.class).value();
           List<String> paramList = new ArrayList<>();
           //获取参数值
           for (Parameter parameter : method.getParameters()){
               if (parameter.isAnnotationPresent(RequestParam.class)){
                   paramList.add(parameter.getDeclaredAnnotation(RequestParam.class).value());
               }
           }
           String[] params= paramList.toArray(new String[paramList.size()]);
           MappingHandler mappingHandler = new MappingHandler(uri,method,cls,params);
           HandlerManagger.mappingHandlerList.add(mappingHandler);
        }

    }

}

MappingHandler

package com.qcby.web.handler;


import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author kevinlyz
 * @ClassName MappingHandler
 * @Description 包含uri，类的方法信息，类信息和参数
 * @Date 2019-06-08 18:32
 **/
public class MappingHandler {

    private String uri;
    private Method method;
    private Class<?> controller;
    private String[] args;

    public MappingHandler(String uri, Method method, Class<?> controller, String[] args) {
        this.uri = uri;
        this.method = method;
        this.controller = controller;
        this.args = args;
    }

    public boolean handle(ServletRequest req, ServletResponse res) throws IllegalAccessException, InstantiationException, InvocationTargetException, IOException {
        String reqUri = ((HttpServletRequest)req).getRequestURI();
        if (!this.uri.equals(reqUri))
            return false;

        //相等则调用Handler的resolveMappingHandler方法,实例化并返回
        Object[] parameters = new Object[args.length];
        for(int i=0;i<args.length;i++){
            parameters[i] = req.getParameter(args[i]);
        }

        Object ctl = controller.newInstance();
        Object response = method.invoke(ctl,parameters);
        res.getWriter().println(response.toString());
        return true;
    }
}

mvc包下

Controller自定义注解

package com.qcby.web.mvc;


import java.lang.annotation.*;


/**
 * @Author kevinlyz
 * @Description 控制器注解，添加在Controller上
 * @Date 17:10 2019-06-08
 **/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Controller {

}

RequestMapping自定义注解

package com.qcby.web.mvc;


import java.lang.annotation.*;

/**
 * @Author kevinlyz
 * @Description 映射注解，添加在方法上
 * @Date 17:11 2019-06-08

 **/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequestMapping {
    String value();
}

RequestParam自定义注解

package com.qcby.web.mvc;

import java.lang.annotation.*;

/**
 * @Author kevinlyz
 * @Description 参数注解，添加在方法参数上
 * @Date 17:10 2019-06-08
 **/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface RequestParam {
    String value();
}

server包下的TomcatServer（修改拦截uri为 /，并将请求转发至DispatcherServlet）

package com.qcby.web.server;

import com.qcby.web.servlet.DispatcherServlet;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.startup.Tomcat;

/**
 * @author kevinlyz
 * @ClassName TomcatServer
 * @Description 集成Tomcat服务器，将请求转发至DispatcherServlet
 * @Date 2019-06-05 13:10
 **/
public class TomcatServer {
    private Tomcat tomcat;
    private String[] agrs;

    public TomcatServer(String[] agrs) {
        this.agrs = agrs;
    }

    public void startServer() throws LifecycleException {
        //实例化tomcat
        tomcat = new Tomcat();
        tomcat.setPort(9999);
        tomcat.start();
        //实例化context容器
        Context context = new StandardContext();
        context.setPath("");
        context.addLifecycleListener(new Tomcat.FixContextListener());
        DispatcherServlet servlet = new DispatcherServlet();
        Tomcat.addServlet(context,"dispatcherServlet",servlet).setAsyncSupported(true);
        //添加映射
        context.addServletMappingDecoded("/","dispatcherServlet");
        tomcat.getHost().addChild(context);

        //设置常驻线程防止tomcat中途退出
        Thread awaitThread = new Thread("tomcat_await_thread."){
            @Override
            public void run() {
                TomcatServer.this.tomcat.getServer().await();
            }
        };
        //设置为非守护线程
        awaitThread.setDaemon(false);
        awaitThread.start();
    }
}

servlet包：

package com.qcby.web.servlet;

import com.qcby.web.handler.HandlerManagger;
import com.qcby.web.handler.MappingHandler;

import javax.servlet.*;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

/**
 * @author kevinlyz
 * @ClassName TestServlet
 * @Description 处理请求，请求拦截和匹配，若不存在对应uri则直接返回
 * @Date 2019-06-05 13:28
 **/
public class DispatcherServlet implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        for (MappingHandler mappingHandler : HandlerManagger.mappingHandlerList){
            try {
                if (mappingHandler.handle(req,res)){
                    return;
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

至此，framework核心的请求拦截就处理完成了

2.3 test模块测试

我们在test模块下新建一个UserController类用于测试我们的请求过程。

package com.qcby.controller;

import com.qcby.web.mvc.Controller;
import com.qcby.web.mvc.RequestMapping;
import com.qcby.web.mvc.RequestParam;

import java.lang.annotation.Retention;

/**
 * @author kevinlyz
 * @ClassName UserController
 * @Description 测试请求
 * @Date 2019-06-08 17:14
 **/
@Controller
public class UserController {

    @RequestMapping("/test")
    public String test(@RequestParam("name") String name,@RequestParam("desc") String desc){
        System.out.println("test访问了！");
        return "hello controller!";
    }
}

同样gradle build

java -jar test/build/libs/test-1.0-SNAPSHOT.jar

打开我们的浏览器，输入http://localhost:9999/test
看到输出的hello controller！

深藏功与名！！！

三、小结

今天我们对SpringMvc的核心功能进行了实现，通过使用包扫描和反射机制获取到注解的信息，并进行实例化，最终实现请求的拦截和相应。
（写的不是很详细，改日再补）
test的Application向framework模块的MiniApplication传递类信息，MiniApplication调用ClassScanner进行包扫描，通过类加载器扫描包中的类路径（其中对jar包的信息做了进一步处理），并返回classList类列表至MiniApplication；进而使用HandlerManagger获取类信息，并通过HandlerManager进行组装。
TomcatServer则更改其拦截的请求uri路径为/，以拦截所有通过tomcat的请求，并转发至DispatcherServlet，DispatcherServlet的service方法进行uri匹配，匹配成功则调用Handler的resolveMappingHandler方法,实例化并返回响应信息。
然后我们又通过test模块书写了UserController进行测试，成功返回hello controller的字符串。至此我们的mvc的请求控制功能就完全实现了，仔细想想是不是很简单呢~~