我们都知道 Spring MVC 下，给类加一个 @Controller，给方法加一个 @RequestMapping，就可以完成客户端调用，访问资源，我们可以模拟一下 MVC 的实现

设计思路

  1. 写一个 Servlet 加载配置文件，也就是读取 Spring 的 xml
  2. 根据配置文件给定的目录扫描包，扫描加了 @Controller 注解的类，
  3. 当扫描到 @Controller 注解的类后，扫描类下面的所有方法，并判断上面是否加了 @RequestMapping 注解
  4. 底层定义一个集合，把符合要求的方法保存起来 Map

POM 文件

  1. <dependencies>
  3.   <dependency>
  4.     <groupId>javax.servlet</groupId>
  5.     <artifactId>javax.servlet-api</artifactId>
  6.     <version>3.1.0</version>
  7.     <scope>provided</scope>
  8.   </dependency>
  10.   <dependency>
  11.     <groupId>dom4j</groupId>
  12.     <artifactId>dom4j</artifactId>
  13.     <version>1.6.1</version>
  14.   </dependency>
  16.   <dependency>
  17.     <groupId>com.alibaba</groupId>
  18.     <artifactId>fastjson</artifactId>
  19.     <version>1.2.70</version>
  20.   </dependency>
  22. </dependencies>
  24. <build>
  25.   <finalName>web-mvc</finalName>
  26.   <plugins>
  28.     <plugin>
  29.       <groupId>org.apache.tomcat.maven</groupId>
  30.       <artifactId>tomcat7-maven-plugin</artifactId>
  31.       <version>2.2</version>
  32.       <configuration>
  33.         <port>8080</port>
  34.         <path>/</path>
  35.       </configuration>
  36.     </plugin>
  38.     <plugin>
  39.       <groupId>org.apache.maven.plugins</groupId>
  40.       <artifactId>maven-compiler-plugin</artifactId>
  41.       <version>3.3</version>
  42.       <configuration>
  43.         <source>1.8</source>
  44.         <target>1.8</target>
  45.         <compilerArgs>
  46.           <arg>-parameters</arg>
  47.         </compilerArgs>
  48.       </configuration>
  49.     </plugin>
  51.   </plugins>
  52. </build>

核心类 DispathServlet

  1. public class DispatcherServlet extends HttpServlet {
  3.     private static Map<String, Method> methodMap = new LinkedHashMap<String, Method>();
  5.     private static String prefix = "";
  6.     private static String suffix = "";
  8.     /** 项目根路径 */
  9.     // /D:/Documents/Java/Spring/spring/web-mvc/target/classes/
  10.     private static String PROJECT_ROOT_PATH;
  12.     static {
  13.         try {
  14.             PROJECT_ROOT_PATH = URLDecoder.decode(DispatcherServlet.class.getResource("/").getPath(), "UTF-8");
  15.         } catch (UnsupportedEncodingException e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  21.     private static final String XML_COMPONENT_SCAN_ELEMENT = "componentScan";
  22.     private static final String XML_COMPONENT_SCAN_ELEMENT_PACKAGE_ATTR = "package";
  23.     private static final String XML_VIEW_ELEMENT = "view";
  24.     private static final String XML_VIEW_ELEMENT_PREFIX_ATTR = "prefix";
  25.     private static final String XML_VIEW_ELEMENT_SUFFIX_ATTR = "suffix";
  27.     @Override
  28.     public void init(ServletConfig config) throws ServletException {
  29.         // 解析 web.xml, mvc.xml
  30.         String xmlPath = config.getInitParameter("xmlPath");
  31.         Document document = parseXML(new File(PROJECT_ROOT_PATH + "//" + xmlPath));
  33.         Element beans = document.getRootElement();
  34.         Element componentScanEle = beans.element(XML_COMPONENT_SCAN_ELEMENT);
  35.         String packageValue = componentScanEle.attribute(XML_COMPONENT_SCAN_ELEMENT_PACKAGE_ATTR).getValue();
  37.         Element viewEle = beans.element(XML_VIEW_ELEMENT);
  38.         prefix = viewEle.attribute(XML_VIEW_ELEMENT_PREFIX_ATTR).getValue();
  39.         suffix = viewEle.attribute(XML_VIEW_ELEMENT_SUFFIX_ATTR).getValue();
  41.         // 扫描文件
  42.         doScan(new File(PROJECT_ROOT_PATH + packageValue.replace(".", File.separator)));
  44.         super.init(config);
  45.     }
  47.     @Override
  48.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  49.         doPost(req, resp);
  50.     }
  52.     @Override
  53.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  54.         String requestURI = req.getRequestURI();
  55.         Method method = methodMap.get(requestURI);
  56.         if (method != null) {
  57.             Parameter[] parameters = method.getParameters();
  58.             Object[] objects = new Object[parameters.length];
  59.             for (int i = 0; i < parameters.length; i++) {
  60.                 Parameter parameter = parameters[i];
  61.                 String name = parameter.getName();
  62.                 Class<?> type = parameter.getType();
  63.                 if (type.equals(String.class)) {
  64.                     objects[i] = req.getParameter(name);
  65.                 } else if (type.equals(HttpServletRequest.class)) {
  66.                     objects[i] = req;
  67.                 } else if (type.equals(HttpServletResponse.class)) {
  68.                     objects[i] = resp;
  69.                 } else if (type.getInterfaces()[0].equals(Entity.class)) {
  70.                     try {
  71.                         Object entity = type.newInstance();
  72.                         for (Field field : type.getDeclaredFields()) {
  73.                             field.setAccessible(true);
  74.                             String fieldName = field.getName();
  75.                             field.set(entity, req.getParameter(fieldName));
  76.                         }
  77.                         objects[i] = entity;
  78.                     } catch (Exception e) {
  79.                         e.printStackTrace();
  80.                     }
  81.                 }
  82.             }
  84.             try {
  85.                 Object controllerClass = method.getDeclaringClass().newInstance();
  86.                 Object ret = method.invoke(controllerClass, objects);
  87.                 Class<?> returnType = method.getReturnType();
  88.                 if (!returnType.equals(Void.class)) {
  89.                     ResponseBody responseBody = method.getAnnotation(ResponseBody.class);
  90.                     if (responseBody != null) {
  91.                         resp.setContentType("text/json;charset=UTF-8");
  92.                         resp.setCharacterEncoding("UTF-8");
  93.                         resp.getWriter().write(JSONObject.toJSONString(ret));
  94.                     } else {
  95.                         req.getRequestDispatcher(prefix + "/" + String.valueOf(ret) + suffix).forward(req, resp);
  96.                     }
  97.                 }
  98.             } catch (Exception e) {
  99.                 e.printStackTrace();
  100.             }
  103.         } else {
  104.             resp.setStatus(404);
  105.         }
  106.     }
  108.     private void doScan(File file) {
  109.         if (file.isDirectory()) {
  110.             for (File _file : file.listFiles()) {
  111.                 doScan(_file);
  112.             }
  113.         } else {
  114.             String filePath = file.getPath();
  115.             String suffix = filePath.substring(filePath.lastIndexOf("."));
  116.             if (suffix.equals(".class")) {
  117.                 String classPath = filePath.replace(new File(PROJECT_ROOT_PATH).getPath() + File.separator, "");
  118.                 classPath = classPath.replace(File.separator, ".");
  119.                 String className = classPath.substring(0, classPath.lastIndexOf("."));
  120.                 try {
  121.                     Class<?> clazz = Class.forName(className);
  122.                     if (clazz.isAnnotationPresent(Controller.class)) {
  123.                         RequestMapping classRequestMapping = clazz.getAnnotation(RequestMapping.class);
  124.                         String classRequestMappingUrl = "";
  125.                         if (classRequestMapping != null) {
  126.                             classRequestMappingUrl = classRequestMapping.value();
  127.                         }
  128.                         for (Method method : clazz.getDeclaredMethods()) {
  129.                             RequestMapping methodAnnotation = method.getAnnotation(RequestMapping.class);
  130.                             if (methodAnnotation != null) {
  131.                                 String methodRequestMappingUrl = "";
  132.                                 methodRequestMappingUrl = methodAnnotation.value();
  133.                                 String url = classRequestMappingUrl + methodRequestMappingUrl;
  134.                                 System.out.println(clazz.getName() + " => " + method.getName() + " => " + url);
  135.                                 methodMap.put(url, method);
  136.                             }
  137.                         }
  138.                     }
  139.                 } catch (ClassNotFoundException e) {
  140.                     e.printStackTrace();
  141.                 }
  142.             }
  143.         }
  144.     }
  146.     /**
  147.      * 解析 XML 文件对象
  148.      *
  149.      * @param file XML 文件
  150.      */
  151.     private Document parseXML(File file) {
  152.         SAXReader reader = new SAXReader();
  153.         Document document = null;
  154.         try {
  155.             document = reader.read(file);
  156.         } catch (DocumentException e) {
  157.             e.printStackTrace();
  158.         }
  159.         return document;
  160.     }
  161. }

注解类

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface Controller {
  4. }
  6. @Target({ElementType.TYPE, ElementType.METHOD})
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface RequestMapping {
  9.     String value() default "";
  10. }
  12. @Target(ElementType.METHOD)
  13. @Retention(RetentionPolicy.RUNTIME)
  14. public @interface ResponseBody {
  15. }

测试类

  1. @Controller
  2. @RequestMapping("/test")
  3. public class TestController {
  5.     @ResponseBody
  6.     @RequestMapping("/test.do")
  7.     public Object test(String name, UserEntity userEntity, HttpServletRequest request, HttpServletResponse resp) {
  8.         System.out.println(name);
  9.         System.out.println(request);
  10.         System.out.println(resp);
  11.         System.out.println(userEntity);
  12.         return userEntity;
  13.     }
  15.     @RequestMapping("/index.do")
  16.     public Object view(HttpServletRequest request, HttpServletResponse resp) {
  17.         return "index";
  18.     }
  20. }

返回 JSON：
image.png
返回页面：
image.png