手动实现一个简易版SpringMvc

版权声明:本篇博客大部分代码引用于公众号：java团长，我只是在作者基础上稍微修改一些内容，内容仅供学习与参考

前言：目前mvc框架经过大浪淘沙，由最初的struts1到struts2,到目前的主流框架SpringMvc,并逐渐区域占领市场主流稳定状态，由于其背后强大的Spring家族提供了一系列高可用的组件和服务，SpringMvc在短时间内肯定是无法被超越的。公司里开发的项目第一首先框架就是SpringMvc，在市场上如火如荼，甚嚣尘上。今天我们就来自己手动实现一个简历的阉割版SpringMvc，主要的目的就是体会SpringMvc的设计思路和理念，了解其幕后工作流程，当然需要注意的是本次实现的是简易版，代码不超过500行，所以本篇博客姑且只可领会设计思路，抛砖引玉，不可陷入细枝末节、吹毛求疵的死胡同里

本篇博客的目录

一：springMvc的使用方法

二：项目开发结构

三：简易版springmvc的实现

四：总结

一：springMvc的使用方法

1.1：开发基本过程

springmvc开发过程是典型的mvc模式，首先在xml里配置dispatcherServlet（假如没有用到springboot的话）,然后再配置扫描包,注解驱动配置，在代码层面又用Controller上注解@RequestMapping映射请求，请求进入后，方法中用各种注解比如@pathvarible获得url请求参数，再到业务方法中的调用service，service再调用dao层，实现数据库的增删改查的业务性操作，之后再返回视图或者用@responseBoby修饰的返回数据，这已经成为一种典型的调用和开发模式！

1.2：基本原理

首先是xml配置，springmvc需要读取xml里面的配置，然后放在简单的一个集合数据模型里（Map）,再然后就是装载用户的配置，扫描基准包，获取用户添加的注解，获取注解信息和配置的参数，再用spring的IOC初始化配置的Bean实例，自动注入类实例（比如contoller的依赖service、dao层mappeer等,等容器启动起来，如果有请求进来，就会按照路径映射对应的controller,再选择方法进行处理完成一系列操作后返回给客户端。

二：项目开发结构

2.1：项目基本结构

这是一个简易版的springmvc，其中包含了基本的使用注解自己实现，和后台的默认控制器DispatcherServlet，还有解析xml的工具，和默认xml配置资源,我们使用的serlvet是3.1版本，采用了对基本servlet进行了二次封装，以下是基本的代码：

2.2：具体的开发过程示例

@MyRequestMapping(name = "/orderApi")
@MyController(name = "order")
public class OrderController {
 
    @MyQualifer(name = "orderServiceImpl")
    private OrderServiceImpl orderServiceImPl;
 
    @MyRequestMapping(name = "/create")
    public void create() {
        orderServiceImPl.createOrder();
    }
}

@MyRepository(name = "orderDao")
public class OrderDao {
 
    public void insert() {
        System.out.println("数据库中插入一条记录");
    }
}

public interface OrderServiceEx {
 
    public void createOrder();
}

@MyService(name = "orderServiceImpl")
public class OrderServiceImpl implements OrderServiceEx {
 
    @MyQualifer(name = "orderDao")
    private OrderDao orderDao;
 
    public void createOrder() {
 
    }
}

三：简易版springmvc的实现

3.1：读取xml配置

解析xml采用的是dom4j的1.6.1版本，目的是模仿springmvc解析用户的配置文件，读取用户配置的扫描包，以下是xmlUtil的源码：

public class XmlUtil {
 
    public static String getNodeValue(String nodeName, String xmlPath) {
        try {
            // 将字符串转为xml
            Document document = DocumentHelper.parseText(xmlPath);
            // 查找节点
            Element element = (Element) document.selectSingleNode(nodeName);
            if (element != null) {
                return element.getStringValue();
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return "";
    }
}

3.2：定义注解

3.2.1:模拟Reposity注解

作用就是告诉spring容器将依赖实例化注入到需要的调用类里面，其中用了name这个属性，就是让spring根据名字去寻找对应的bean进行依赖注入。并标识其运行在类上面（无法放在方法上）

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRepository {
    public String name();
}

3.2.2：模拟controller注解

作用就是告诉spring容器这是一个控制器，并交给spring去实例化，可以运行在类和方法上

@Documented
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyController {
    public String name();
}

3.2.3：模拟Quanlifer注解

作用于成员变量上，主要的作用是让spring根据配置的bean的名字进行注入：

@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyQualifer {
    public String name();
}

3.2.4：模拟@service注解

作用于类或者接口上，主要的作用就是标识一个类为service层，并交给spring去初始化！

@Documented
@Target(ElementType.Type)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyService {
    public String name();
}

3.2.5：MyDispatcherServlet

模拟DispatcherServlet，主要的作用就是作为请求控制器，处理客户端请求,继承自HttpServlet,我使用的版本是3.1.0,因此可以用注解来取得一些参数：

@WebServlet(name = "dispatherServlet", urlPatterns = "/", loadOnStartup = 1)
public class MyDispatcherServlet extends HttpServlet {
 
    /**
     * 扫描的基准包
     */
    private String basePackage = "";
    /**
     * 包名
     */
    private List<String> packageNames = new ArrayList<>();
    /**
     * 注解名和类实例
     */
    private Map<String, Object> instanceMap = new HashMap<String, Object>();
    /**
     * 包名和注解名
     */
    private Map<String, String> nameMap = new HashMap<>();
    /**
     * url和方法
     */
    private Map<String, Method> urlMethodMap = new HashMap<>();
    /**
     * Method和包名
     */
    private Map<Method, String> methodPackageMap = new HashMap<>();
    @Override
    public void init(ServletConfig config) {
        try {
            getBasePackageFromConfigXml();
            scanBasePackage(basePackage);
            instance(packageNames);
            springIoc();
            handleUrlMethodMap();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

这里是一个流程处理类，第一步从xml里面获取用户配置的信息，这里的主要作用就是扫描出配置的包名，第二步就是扫描基准包的路径然后放在一个List中，保存起来。第三步：根据扫描出来的包，获取包里面的类class，然后利用反射获取类上的class信息（不包含方法），然后把注解名和对应的类实例保存在map中，再把包名和注解的参数（这里主要是controller、service等在类上的）保存起来。第四步：模拟spring的IOC注入实例的过程，遍历第三步中的注解名和类实例map，然后利用反射实例化字段!第五步：遍历整个包下的类，然后获取类中的所有方法，再取得MyRequestMapping的注解上的配置的参数，把它存在urlMethodMap中，这里的作用就是把类上的MyRequestingMapping的配置的参数和方法上的注解配置的参数组装起来！最终在dopost方法中处理：

3.2.6：getBasePackFromConfig方法

整个方法的目的就是解析xml，获取基准包，这是我们继续往下的基础，因为只有获取包路径，我们才能扫描到注解，才能知道自己要开发的类在哪个目录

    /**
     * 从xml中获取basePackage
     * @return
     */
    private void getBasePackageFromConfigXml() {
        final String basePackageName = XmlUtil.getNodeValue("scan-package-path", "springmvcConfig.xml");
        basePackage=basePackageName;
   }

3.2.7：scanBasePackage

扫描基础包：这是一个递归的方法，主要是解析路径，获取目录下的文件，然后添加文件名到packageNames这个list,保存了我们扫描的路径下的所有文件，接下来就是循环遍历这个list，取出其中的class再进一步的处理

    /**
     * 扫描基础包，保存类路径到list中
     * @param basePackage
     */
    private void scanBasePackage(String basePackage) {
        final URL url = this.getClass().getClassLoader().getResource(basePackage.replaceAll("\\.", "/"));
        final File basePackageFile = new File(url.getPath());
        System.out.println("扫描到的文件是:" + basePackageFile.getName());
        final File[] files = basePackageFile.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                scanBasePackage(basePackage + "." + file.getName());
            } else if (file.isFile()) {
                packageNames.add(basePackage + "." + file.getName().split("\\.")[0]);
            }
        }
    }

3.2.8：instance(packageNames)

该方法的主要目的就是遍历包下面的类，扫描类上面的注解，主要是@MyController、@MyService、@MyRepository，然后利用反射获取类上的注解，取得注解上配置的参数（就是name上的值，在下面的实例中，比如:instanceMap将会存放("order",OrderController.class),nameMap将会存放（"test.java.com.wyq","order"）

/**
     * 初始化
     *
     * @param packageNames
     */
    private void instance(List<String> packageNames) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
 
        if (packageNames.size() < 1) {
            return;
        }
        for (String packageName : packageNames) {
            Class<?> fileClass = Class.forName(packageName);
            if (fileClass.isAnnotationPresent(MyController.class)) {
                MyController myController = fileClass.getAnnotation(MyController.class);
                final String controllerName = myController.name();
                instanceMap.put(controllerName, fileClass.newInstance());
                nameMap.put(packageName, controllerName);
                System.out.println("Controller:" + packageName + "name" + controllerName);
            } else if (fileClass.isAnnotationPresent(MyService.class)) {
                final MyService service = fileClass.getAnnotation(MyService.class);
                final String serviceName = service.name();
                instanceMap.put(serviceName, fileClass.newInstance());
                nameMap.put(packageName, serviceName);
            } else if (fileClass.isAnnotationPresent(MyRepository.class)) {
                final MyRepository repository = fileClass.getAnnotation(MyRepository.class);
                final String repositoryName = repository.name();
                instanceMap.put(repositoryName, fileClass.newInstance());
                nameMap.put(packageName, repositoryName);
            }
        }
    }

3.2.9:springIoc

springIoc的注入：该方法的目的主要是遍历instanceMap,找到有@MyController、@MyService、@MyRepository中的成员字段上有@Myqualifer的注解，（注：Myqualifer的作用类似于@AutoWired自动注入）然后获取这个注解，利用反射机制，实例化这个成员变量。

    /**
     * springIOC的注入
     *
     * @throws IllegalAccessException
     */
    private void springIoc() throws IllegalAccessException {
        for (Map.Entry<String, Object> annotationNameAndInstance : instanceMap.entrySet()) {
            final Field[] fields = annotationNameAndInstance.getValue().getClass().getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(MyQualifer.class)) {
                    final String myQualiferName = field.getAnnotation(MyQualifer.class).name();
                    field.setAccessible(true);
                    field.set(annotationNameAndInstance.getValue(), instanceMap.get(myQualiferName));
                }
            }
        }
    }

3.3.0：handleUrlMethodMap

这个方法的主要作用就是获取@MyRequestMapping中配置的url链接，然后将他们封装到一个methodPackageMap的map中，其首先是取类上面的@MyRequestMapping配置的url，然后再取方法上的@MyRequestMapping配置的url,拼接在一起，作为键，映射其对应的方法，这样当请求进来时，就可以直接根据url匹配到对应的处理的方法。向下面的实例：methodPackageMap将会存放的数据是（"/orderApi/create",create(method)),而methodPackageMap将会存放的是（create,"com.wyq"）

/**
     * 处理请求的url和method
     * @throws ClassNotFoundException
     */
    private void handleUrlMethodMap() throws ClassNotFoundException {
 
        if (packageNames.size() < 1) {
            return;
        }
 
        for (String packageName : packageNames) {
 
            final Class<?> fileClass = Class.forName(packageName);
 
            final Method[] methods = fileClass.getMethods();
 
            final StringBuffer baseUrl = new StringBuffer();
 
            if (fileClass.isAnnotationPresent(MyRequestMapping.class)) {
 
                MyRequestMapping myRequest = (MyRequestMapping) fileClass.getAnnotation(MyRequestMapping.class);
                baseUrl.append(myRequest.name());
            }
 
            for (Method method : methods) {
                if (method.isAnnotationPresent(MyRequestMapping.class)) {
                    final MyRequestMapping myrequest = method.getAnnotation(MyRequestMapping.class);
                    baseUrl.append(myrequest.name());
 
                    urlMethodMap.put(baseUrl.toString(), method);
                    methodPackageMap.put(method, packageName);
                }
            }
        }
    }

3.3.1:doPost方法

这个方法的主要的思路就是把上面组装的map数据然后再反向解析，首先就是获取请求的url，然后获取contextPath（项目的地址),比如请求http://172.123.344.122:8080/order/create,那么最终的path就是order/create,再根据请求的url获取对应的处理方法，这里会找到create方法，再根据方法名找到类所在的包路径，再根据包路径获取Controller的名字，再根据Controller的名字获取具体的Controller（用户写的），再利用反射机制调用具体的Controller里的方法，这样从请求进入到解析处理就完成了！

/**
     * 具体的处理请求的方法
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        final String requestURI = req.getRequestURI();
        final String contextPath = req.getContextPath();
        final String path = requestURI.replaceAll(contextPath, "");
        //根据请求的路径反向获取方法
        final Method method = urlMethodMap.get(path);
        if (null != method) {
            //获取包名
            final String packageName = methodPackageMap.get(method);
            //根据包名获取到Controller的名字
            final String controllerName = nameMap.get(packageName);
            //根据controller的名字得到控制器
            Object orderController =  instanceMap.get(controllerName);
            try {
                method.setAccessible(true);
                method.invoke(orderController);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

四:总结

本篇博客主要是讲解了简易版SpringMvc的实现，其中主要包括了基本注解定义，还有springmv的具体处理模式，当然真实的springmvc实现很复杂，这里只是冰山一角的简单实现一个功能，不过举一反三，基本思路我们要思考，虽然没有搭建一个完成版springmvc的能力，不过从最简单的实现开始，一步步的走，对我们的编程能力有推波助澜的功效！加油