Start from the principle of MVC and knock on an MVC framework to bring you the pleasure of being a great God

Every programmer , I learned it at the beginning of my career The first framework should be ssm 了 , Other learning frameworks are in the later stage of work , As the business becomes more and more complex , stay Work and bug Growing up in , But the most classic should still be at the beginning ssm frame Well

I was just learning this time , I think , What a cow , In this way, a website can be realized , How did these great gods do it , Hey, hey, hey , I wonder if you had such a problem at that time , So today I'll take you to build a ordinary mvc frame , from principle Speak up , It can also help you better Understand the underlying source code

Okay , Don't talk much , Let's take a look

Springmvc Basic principle flow

SpringMvc In essence, it's right Servlet Encapsulation .

Because creating a Maven project , And then in pom Add a dependency to the file ：

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <!--  When deployed on the server , Don't use this servlet-api  While using tomcat Of -->
  <scope>provided</scope>
</dependency>

---

2, establish DispatcherServlet, And register to the web.xml in

package com.dxh.edu.mvcframework.servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class DxhDispatcherServlet extends HttpServlet {
    /**
     *   Receive processing request 
     */
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
    }
}

web.xml：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>dxhmvc</servlet-name>
    <servlet-class>com.dxh.edu.mvcframework.servlet.DxhDispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>springmvc.properties</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dxhmvc</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>

---

2, Annotation development

Because to use annotations , So first of all, you have to customize a few annotations ：

I won't elaborate on how to customize annotations here , Details please see ：
https://www.cnblogs.com/peida/archive/2013/04/24/3036689.html

Controller annotation ：

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhController {
    String value() default "";
}

Service annotation ：

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhService {
    String value() default "";
}

RequestMapping annotation ：

@Documented
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhRequestMapping {
    String value() default "";
}

Autowired annotation ：

@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DxhAutowired {
    String value() default "";
}

Write test code ：

Test code we put in the same project com.dxh.demo In bag ：

package com.dxh.demo.controller;
import com.dxh.demo.service.IDemoService;
import com.dxh.edu.mvcframework.annotations.DxhAutowired;
import com.dxh.edu.mvcframework.annotations.DxhController;
import com.dxh.edu.mvcframework.annotations.DxhRequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@DxhController
@DxhRequestMapping("/demo")
public class DemoController {
    @DxhAutowired
    private IDemoService demoService;
    /**
     * URL:/demo/query
     */
    @DxhRequestMapping("/query")
    public String query(HttpServletRequest request, HttpServletResponse response, String name){
        return demoService.get(name);
    }
}

package com.dxh.demo.service;
public interface IDemoService {
    String get(String name);
}

package com.dxh.demo.service.impl;
import com.dxh.demo.service.IDemoService;
import com.dxh.edu.mvcframework.annotations.DxhService;
@DxhService("demoService")
public class IDemoServiceImpl implements IDemoService {
    @Override
    public String get(String name) {
        System.out.println("Service Implement... In the class Name："+ name);
        return name;
    }
}

Directory structure ：

---

3, Write custom DispatcherServlet Initialization process in ：

After creating the DxhDispatcherServlet Rewriting in init（） Method , And in init Method to do initialization configuration ：

1. Load profile springmvc.properties
2. Scan related classes —— Scan the annotation
3. initialization Bean object （ Realization IOC Containers , Based on annotations ）
4. Implement dependency injection
5. Construct a handleMapping Processor mapper , Will be configured url and method Establish a mapping relationship

@Override
public void init(ServletConfig config) throws ServletException {
    //1.  Load profile   springmvc.properties
    String contextConfigLocation = config.getInitParameter("contextConfigLocation");
    doLoadConfig(contextConfigLocation);
    //2.  Scan related classes —— Scan the annotation 
    doScan("");
    //3.  initialization Bean object （ Realization IOC Containers , Based on annotations ）
    doInstance();
    //4.  Implement dependency injection 
    doAutoWired();
    //5.  Construct a handleMapping Processor mapper , Will be configured url and method Establish a mapping relationship 
    initHandleMapping();
    System.out.println("MVC  Initialization complete ");
    //6.  Wait for the request to enter and process the request 
}

as well as 5 An empty method , This article customizes MVC The framework is really about this 5 How to write these steps .

//TODO 5, Construct a mapper 
private void initHandleMapping() {
}
//TODO 4, Implement dependency injection 
private void doAutoWired() {
}
//TODO 3,IOC Containers 
private void doInstance() {
}
//TODO 2, Scanning class 
private void doScan(String scanPackage) {
}
//TODO 1, Load profile 
private void doLoadConfig(String contextConfigLocation) {
}

3.1 Load profile

1. First, in the resource Create a configuration file in the directory ——springmvc.properties
   Means to scan com.dxh.demo All the notes below .
2. And then in web.xml To configure ：

such , You can go through config.getInitParameter("contextConfigLocation") Get this path .

1. stay DxhDispatcherServlet Define a property in , We put the information in the loaded configuration file , Stored in Properties in

private Properties properties = new Properties();;

//1, Load profile 
private void doLoadConfig(String contextConfigLocation) {
    // Load the stream according to the specified path ：
    InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
    try {
        properties.load(resourceAsStream);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3.2 Scan related classes , Scan the annotation

1. Last step , We already have the packages that need to be scanned Properties in , So we need to take it out here ：

//2.  Scan related classes —— Scan the annotation 
doScan(properties.getProperty("scanPackage"));

1. The full class name of the scanned type exists in a List In the cache , Waiting to use , stay DxhDispatcherServlet Define a list：

// The full class name of the class scanned by cache 
private List<String> classNames = new ArrayList<>();

1. From the configuration file, we get a package name to scan （com.dxh.demo）, We need to classPath+ Package name , Come on, it's actually The path stored on the disk , then recursive , Until you get all the bags （ Including subpackages ...） be-all Class file （.class ending ）. then It exists in List classNames in .

//2, Scanning class 
//scanPackage :com.dxh.demo    package---> Disk folder （File）
private void doScan(String scanPackage) {
    //1. get classPath route 
    String clasPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
    //2. Splicing , obtain scanPackage Path on disk 
    String  scanPackagePath= clasPath + scanPackage.replaceAll("\\.","/");
    File pack = new File(scanPackagePath);
    File[] files = pack.listFiles();
    for (File file : files) {
        if (file.isDirectory()){ // Son  package
            // recursive 
            doScan(scanPackage+"."+file.getName());  //com.dxh.demo.controller
        }else if(file.getName().endsWith(".class")){
            String className = scanPackage + "." + file.getName().replace(".class", "");
            classNames.add(className);
        }
    }
}

3.3 initialization Bean object （ Realization IOC Containers , Based on annotations ）

In the last step, we scanned the class of Full class name Put it in ,list in , So this step needs to traverse the whole list：

1. Traverse List, Get all the full class names in turn
2. Get the class object by reflection
3. Judge whether there are annotations according to the class object , And distinguish controller and servicecontroller, its id Don't do too much here , No value 了 , Use the first letter of a class in lowercase id, Save to IOC In the container .service,service Layers often have interfaces , The interface name is id Deposit another copy of bean To ioc, It is convenient for later injection according to the interface type
4. complete

Code implementation ：

//IOC Containers 
private Map<String,Object> ioc = new HashMap<>();

//3,IOC Containers 
// be based on classNames The fully qualified class name of the cached class , And Reflection Technology , Complete object creation and management 
private void doInstance()  {
    if (classNames.size()==0) return;
    try{
        for (int i = 0; i < classNames.size(); i++) {
            String className = classNames.get(i);  //com.dxh.demo.controller.DemoController
            // Reflection 
            Class<?> aClass = Class.forName(className);
            // distinguish controller , distinguish service
            if (aClass.isAnnotationPresent(DxhController.class)){
                //controller Of id Don't do too much here , No value 了 , Use the first letter of a class in lowercase id, Save to IOC In the container 
                String simpleName = aClass.getSimpleName();//DemoController
                String lowerFirstSimpleName = lowerFirst(simpleName); //demoController
                Object bean = aClass.newInstance();
                ioc.put(lowerFirstSimpleName,bean);
            }else if (aClass.isAnnotationPresent(DxhService.class)){
                DxhService annotation = aClass.getAnnotation(DxhService.class);
                // Get the value of the annotation 
                String beanName = annotation.value();
                // It specifies id In the name of id Subject to 
                if (!"".equals(beanName.trim())){
                    ioc.put(beanName,aClass.newInstance());
                }else{
                    // Is not specified id , Initial lowercase 
                    String lowerFirstSimpleName = lowerFirst(aClass.getSimpleName());
                    ioc.put(lowerFirstSimpleName,aClass.newInstance());
                }
                //service Layers often have interfaces , The interface name is id One more point bean To ioc, It is convenient for later injection according to the interface type 
                Class<?>[] interfaces = aClass.getInterfaces();
                for (Class<?> anInterface : interfaces) {
                    // Take the class name of the interface as id Put in .
                    ioc.put(anInterface.getName(),aClass.newInstance());
                }
            }else {
                continue;
            }
        }
    }catch (Exception e){
        e.printStackTrace();
    }
}

3.4 Implement dependency injection ：

In the previous step, you need to load all the bean, Put in ioc Map in , here , We need to traverse this map And then we get each one in turn bean object , Then judge whether the object has been @****DxhAutowired Decorated attributes .

1. Traverse ioc This map, Get each object
2. Get the field of the object （ attribute ） Information
3. Determine whether the field is @DxhAutowired modification
4. Judge @DxhAutowired Is there any setting value value Yes , Directly from ioc Take out of container , Then set the properties . nothing , It needs to be injected according to the type of the current field （ Interface injection ）

Code implementation ：

//4, Implement dependency injection 
private void doAutoWired() {
    if (ioc.isEmpty()){return;}
    //1, Determine if there is any in the container that has been @DxhAutowried Properties of annotations , If you need to maintain dependency injection relationships 
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        // obtain bean Field information in object 
        Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if (!declaredField.isAnnotationPresent(DxhAutowired.class)){
                continue;
            }
            // There should be a note ：
            DxhAutowired annotation = declaredField.getAnnotation(DxhAutowired.class);
            String beanName = annotation.value(); // Need to inject bean Of Id
            if ("".equals(beanName.trim())){
                // There is no specific configuration beanId, It needs to be injected according to the type of the current field （ Interface injection ）  IDemoService
                beanName = declaredField.getType().getName();
            }
            // Turn on assignment 
            declaredField.setAccessible(true);
            try {
                // Field call , Two parameters ：( Which object's field , What's coming in )
                declaredField.set(entry.getValue(),ioc.get(beanName));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

3.5 Construct a handleMapping Processor mapper

Construct a handleMapping Processor mapper , Will be configured url and method Establish a mapping relationship ****.

Handwriting MVC The most critical part of the framework

Let's say I have a ：

So how to get through /demo/query Locate the DemoController Class query This method ？

Before that, we were all @DxhController（ Customize Controller annotation ） Class , It's all there ioc This map in .
We can traverse this map, Get each bean object
And then judge whether it was @DxhController Modified （ exclude @DxhService The modified bean）
And then judge whether it was @DxhRequestMapping Modified , Some words , Take it value value , As baseUrl
And then traverse the bean All methods in the object , Get to be @DxhRequestMapping The method of decoration . Get it value value , As methodUrl.
baseUrl + methodUrl = url
We put url And the current method Bind up , There is map in , That is to establish url and method Establish a mapping relationship .
Code implementation ：

//handleMapping , Storage url and method Direct mapping 
private Map<String,Object> handleMapping = new HashMap<>();

//5, Construct a mapper , take url and method Association 
private void initHandleMapping() {
    if (ioc.isEmpty()){return;}
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        // obtain ioc Of the object currently traversed in class type 
        Class<?> aClass = entry.getValue().getClass();
        // Exclude non controller Class of layer 
        if (!aClass.isAnnotationPresent(DxhController.class)){
            continue;
        }
        String baseUrl = "";
        if (aClass.isAnnotationPresent(DxhRequestMapping.class)){
            //Controller layer   Class   annotation @DxhRequestMapping Medium value value 
            baseUrl = aClass.getAnnotation(DxhRequestMapping.class).value();
        }
        // Access method 
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            // Exclude no @DxhRequestMapping Method of annotation 
            if (!method.isAnnotationPresent(DxhRequestMapping.class)){continue;}
            //Controller layer   Methods in the class   annotation @DxhRequestMapping Medium value value 
            String methodUrl = method.getAnnotation(DxhRequestMapping.class).value();
            String url = baseUrl+methodUrl;
            // establish url and method Mapping between , use map cached 
            handleMapping.put(url,method);
        }
    }
}

4, Test it ：

To present position , It's not finished yet , But let's test it to see if there is any problem with the part we just wrote ：

complete pom file ：

<?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:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.dxh.edu</groupId>
  <artifactId>mvc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>mvc Maven Webapp</name>
  <url>http://www.example.com</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <!--  When deployed on the server , Don't use this servlet-api  While using tomcat Of -->
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugins>
  <!--  The compiler plug-in defines the compilation details -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>11</source>
          <target>11</target>
          <encoding>utf-8</encoding>
          <!--  Tell compiler , When compiling, record the real name of the parameter -->
          <compilerArgs>
            <arg>-parameters</arg>
          </compilerArgs>
        </configuration>
      </plugin>    
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8080</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

pom A... Has been added to the document tomcat plug-in unit , And set the port to 8080, So we passed tomcat Start project ：

After startup , Open the browser url Input in ：

http://localhost:8080/demo/query

Nothing in the browser returns （ Our code is not really finished yet , The processing request steps have not been written ）, At the same time, the console printed MVC Initialization complete , It can be said that , There are no obvious flaws in the current code . We continue ~~~~~

---

5, reform initHandleMapping()

5.1 Why transform ？

DxhDispatcherServlet This class inherits HttpServlet, Rewrite the doGet and doPost Method , stay doGet Called in doPost Method , When we call methods with reflection (method.invoke(......)) Some parameters are missing ：

So we need to transform initHandleMapping(), modify url and method The mapping relation of （ It's not a simple deposit map in ）.

5.2 newly build Handler class

package com.dxh.edu.mvcframework.pojo;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
public class Handler {
    //method.invoke(obj,) need 
    private Object controller;
    private Method method;
    //spring in url Support regular 
    private Pattern pattern;
    // The order of the parameters , For parameter binding   ,Key  Parameter name , Value  Represents the number of parameters 
    private Map<String,Integer> paramIndexMapping;
    public Handler(Object controller, Method method, Pattern pattern) {
        this.controller = controller;
        this.method = method;
        this.pattern = pattern;
        this.paramIndexMapping = new HashMap<>();
    }
    //getset The method is omitted here , The actual code needs ...
}

stay Handler Class 4 Attributes ：

• private Object controller：method.invoke(obj,) need
• private Method method： And url Binding method
• private Pattern pattern： Can be matched by regular , You can also write directly String url.
• private Map<String,Integer> paramIndexMapping： The order of the parameters , For parameter binding ,Key Parameter name , Value Represents the number of parameters

5.3 modify initHandleMapping()

First , You can't go straight through Map<url,Method> It's a way to map relationships , Use one list, Generics are just created Handler.

    //handleMapping , Storage url and method Direct mapping 
//    private Map<String,Method> handleMapping = new HashMap<>();
    private List<Handler> handlerMapping = new ArrayList<>();

Before modification , Code comparison after the change ：

After modification initHandleMapping()：

//5, Construct a mapper , take url and method Association 
private void initHandleMapping() {
    if (ioc.isEmpty()){return;}
    for (Map.Entry<String,Object> entry: ioc.entrySet()){
        // obtain ioc Of the object currently traversed in class type 
        Class<?> aClass = entry.getValue().getClass();
        // Exclude non controller Class of layer 
        if (!aClass.isAnnotationPresent(DxhController.class)){
            continue;
        }
        String baseUrl = "";
        if (aClass.isAnnotationPresent(DxhRequestMapping.class)){
            //Controller layer   Class   annotation @DxhRequestMapping Medium value value 
            baseUrl = aClass.getAnnotation(DxhRequestMapping.class).value();
        }
        // Access method 
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            // Exclude no @DxhRequestMapping Method of annotation 
            if (!method.isAnnotationPresent(DxhRequestMapping.class)){continue;}
            //Controller layer   Methods in the class   annotation @DxhRequestMapping Medium value value 
            String methodUrl = method.getAnnotation(DxhRequestMapping.class).value();
            String url = baseUrl+methodUrl;
            // hold method All the information and url Encapsulated in the Handler
            Handler handler = new Handler(entry.getValue(),method, Pattern.compile(url));
            // Process the parameter position information of calculation method 
            Parameter[] parameters = method.getParameters();
            for (int i = 0; i < parameters.length; i++) {
                Parameter parameter = parameters[i];
                // Don't do too much parameter type judgment , Only do ：HttpServletRequest request, HttpServletResponse response And basic type parameters 
                if (parameter.getType()==HttpServletRequest.class||parameter.getType()==HttpServletResponse.class){
                    // If the time is request and response object , Then the parameter name is stored in  HttpServletRequest  and  HttpServletResponse
                    handler.getParamIndexMapping().put(parameter.getType().getSimpleName(),i);
                }else{
                    handler.getParamIndexMapping().put(parameter.getName(),i);
                }
            }
            handlerMapping.add(handler);
        }
    }
}

6, Request processing development doPost()：

Last step , We've configured uri and method The mapping relation of , And packaged to Handler Deposit in list, So next , Will be through HttpServletRequest, Take out uri, And then find the specific Handler：

1. adopt HttpServletRequest Take out uri Find specific Handler
2. Get an array of parameters that will call the method
3. Create a new array based on the above array length （ Parameters of the array , Pass in the reflection call ）
4. adopt req.getParameterMap() Get the parameters from the front desk parameterMap
5. Traverse parameterMap
6. adopt StringUtils.join Method to name=1&name=2 The parameters of the format change to name[1,2] （ need commons-lang rely on ）
7. Parameter matching and setting

private Handler getHandler(HttpServletRequest req) {
    if (handlerMapping.isEmpty()){return null;}
    String url = req.getRequestURI();
    // Traverse  handlerMapping
    for (Handler handler : handlerMapping) {
        Matcher matcher = handler.getPattern().matcher(url);
        if (!matcher.matches()){continue;}
        return handler;
    }
    return null;
}

 @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws  IOException {
        // according to uri Get the... That can handle the current request Handler（ from handlerMapping in （list））
        Handler handler = getHandler(req);
        if (handler==null){
            resp.getWriter().write("404 not found");
            return;
        }
        // Parameter binding 
        // The type array of all parameters of this method 
        Class<?>[] parameterTypes = handler.getMethod().getParameterTypes();
        // Create a new array based on the above array length （ Parameters of the array , Pass in the reflection call ）
        Object[] paramValues = new Object[parameterTypes.length];
        // The following is to set values to the parameter array , Moreover, the order of parameters must be consistent with the order of formal parameters in the method .
        Map<String,String[]> parameterMap = req.getParameterMap();
        // Traverse request All the parameters in  ,（ Fill in except request、response External parameter ）
        for (Map.Entry<String,String[]> entry: parameterMap.entrySet()){
            //name=1&name=2 name[1,2]
            String value = StringUtils.join(entry.getValue(), ",");//  Like  1,2
            // If the parameter matches the parameter in the method , Fill in the data 
            if (!handler.getParamIndexMapping().containsKey(entry.getKey())){continue;}
            // Method parameters do have this parameter , Find its index position , Put the parameter value into paramValues
            Integer index = handler.getParamIndexMapping().get(entry.getKey());
            // Pass the parameter values from the foreground , Fill in the corresponding position 
            paramValues[index] = value;
        }
        Integer requestIndex = handler.getParamIndexMapping().get(HttpServletRequest.class.getSimpleName());
        paramValues[requestIndex] = req;
        Integer responseIndex = handler.getParamIndexMapping().get(HttpServletResponse.class.getSimpleName());
        paramValues[responseIndex] = resp;
        // The final call handler have to method attribute 
        try {
            Object invoke = handler.getMethod().invoke(handler.getController(), paramValues);
// Simple operation , Write the data returned by the method in the form of string 
resp.getWriter().write(invoke.toString());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

7, test ：

Open the browser ,url Input in ：
http://localhost:8080/demo/query?name=lisi

return ：

The console prints out ：

OK complete ~