手写springMVC

╰+攻爆jí腚メ 2022-11-16 00:59 181阅读 0赞

# 参考视频：[https://www.bilibili.com/video/BV18K4y1v7f7][https_www.bilibili.com_video_BV18K4y1v7f7] #

# 代码可以参考本博客，具体编写还是参考视频 #

# 本文最后有本人手写springMVC后的代码下载 #

# 编写springmvc的目的： #

*  对springMVC原理有进一步的了解
 *  深化java se的高级知识点（注解，反射，xml解析）
 *  通过自定义框架来深化java内功，提高面试通过率
 *  养成规范化，标准化的代码编写习惯和良好的技术文档习惯

# 一，整备工作 #

### 1，Tomcat启动时加载SpringMVC开发的流程是什么？ ###

启动阶段：

*  Tomcatxx加载xxx.war (springmvc: com.xx.xxx.OrderService.class)
 *  创建容器：创建Map iocMap = new HashMap();
 *  ScanbasePackage:：扫描war下的@Controller,@Service注解的类
 *  实例化：将扫描到的类通过反射实例化，并存入到iocMap容器中
 *  依赖注入：将存在依赖的bean进入注入
 *  UrlMapping ：http请求路径与Method建立映射关系

运行阶段：

*  发送http请求，调用servlet的doGet/doPost方法
 *  找到从UrlMapping中找到对应的Method方法对象;
 *  找到Method方法对象后，直接调用
 *  响应返回结果

### 2，mvc模式回顾： ###

MVC( 模型-视图-控制器)设计创建 Web 应用程序的模式:：

*  **Model(模型)**是应用程序中用于处理应用程序数据逻辑的部分（dao和service层），通常模型对象负责在数据库中存取数据。
 *  **View(视图)**是应用程序中处理数据显示的部分（jsp和HTML页面），通常视图是依据模型数据创建的。
 *  **Controller(控制器)**是应用程序中处理用户交互的部分（controller层），通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

优点：

*  MVC 分层有助于管理复杂的应用程序，因为您可以在一个时间内专门关注一个方面。例如，您可以在不依赖业务逻辑的情况下专注于视图设计。同时也让应用程序的测试更加容易。
 *  MVC 分层同时也简化了分组开发。不同的开发人员可同时开发视图、控制器逻辑和业务逻辑。

### 3，SpringMVC执行的流程 ###

1.  ### 一个请求匹配前端控制器 DispatcherServlet 的请求映射路径(在 web.xml中指定), WEB 容器将该请求转交给 DispatcherServlet 处理 ###
2.  ### DispatcherServlet 接收到请求后, 将根据 请求信息 交给 处理器映射器 （HandlerMapping） ###
3.  ### HandlerMapping 根据用户的url请求 查找匹配该url的 Handler，并返回一个执行链 ###
4.  ### DispatcherServlet 再请求 处理器适配器(HandlerAdapter) 调用相应的 Handler（controller） 进行处理并返回 ModelAndView 给 DispatcherServlet ###
5.  ### DispatcherServlet 将 ModelAndView 请求 ViewReslover（视图解析器）解析，返回具体 View ###
6.  ### DispatcherServlet 对 View 进行渲染视图（即将模型数据填充至视图中） ###
7.  ### DispatcherServlet 将页面响应给用户 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70][]

# 二，开始编写 #

# 1，创建一个maven工程。导入依赖 #

<?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>SpringMVC</groupId>
      <artifactId>SpringMVC</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>SpringMVC Maven Webapp</name>
      
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>10.0.1</maven.compiler.source>
        <maven.compiler.target>10.0.1</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>
          <scope>provided</scope>
        </dependency>
    
        <dependency>
          <groupId>dom4j</groupId>
          <artifactId>dom4j</artifactId>
          <version>1.6.1</version>
        </dependency>
    
        <dependency>
          <groupId>org.apache.commons</groupId>
          <artifactId>commons-lang3</artifactId>
          <version>3.5</version>
        </dependency>
    
        <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.18.18</version>
          <scope>provided</scope>
        </dependency>
    
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-databind</artifactId>
          <version>2.8.1</version>
        </dependency>
    
      </dependencies>
    
    
    
      <build>
        <finalName>SpringMVC</finalName>
        <pluginManagement>
          <plugins>
            <plugin>
              <artifactId>maven-clean-plugin</artifactId>
              <version>3.1.0</version>
            </plugin>
            
            <plugin>
              <artifactId>maven-resources-plugin</artifactId>
              <version>3.0.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.0</version>
            </plugin>
            <plugin>
              <artifactId>maven-surefire-plugin</artifactId>
              <version>2.22.1</version>
            </plugin>
            <plugin>
              <artifactId>maven-war-plugin</artifactId>
              <version>3.2.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-install-plugin</artifactId>
              <version>2.5.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-deploy-plugin</artifactId>
              <version>2.8.2</version>
            </plugin>
    
          </plugins>
        </pluginManagement>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
              <source>10.0.1</source>
              <target>10.0.1</target>
              <compilerArgs>
                <arg>-parameters</arg>
              </compilerArgs>
              <encoding>UTF-8</encoding>
            </configuration>
          </plugin>
        </plugins>
    
      </build>
    </project>

# 2，完善目录结构， #

1.  web.xml文件//用来告诉tomcat服务器，启动服务器时要调用前端控制器的位置，和springmvc.xml文件的位置，一些初始化操作，所有访问tomcat的请求都要经过前端控制器
2.  springmvc.xml文件//配置前端控制器要扫描的包，该包下的对象要注入到spring的ioc容器中
3.  pojo层：user类  //用来存放数据
4.  service层：UserService接口    UserServiceImpl实现类 //用来写业务功能
5.  controller层：UserController类  //用来处理请求
6.  注解接口：@service    @controller  @RequestMapping   @RequestParam   @AutoWired//这些注解只是一个标记的作用，存储value参数的作用
7.  前端控制器：DispatcherServlet类
8.  Spring容器：WebApplicationContext类
9.  处理器类：MyHandler类  //用来存放  (请求url，对应控制器对象controller，处理url请求的方法method)
10. xml文件解析类：XMLParse类//用来对springmvc.xml文件进行解析，得到要扫描的包
11. 自定义异常：ContextException类//包扫描不到自定义抛出自定义异常提醒自己

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2][]

# 3，具体代码的编写和解释 #

### 1，web.xml文件：用来告诉tomcat服务器，启动服务器时要调用前端控制器的位置，和springmvc.xml文件的位置，一些初始化操作，所有访问tomcat的请求都要经过前端控制器 ###

<!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>DispatcherServlet</servlet-name>
        <servlet-class>com.springMVC.servlet.DispatcherServlet</servlet-class>
    
        <init-param>
    
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    
        <load-on-startup>1</load-on-startup>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
        
      
    </web-app>

### 2，springmvc.xml文件：配置前端控制器要扫描的包，该包下的对象要注入到spring的ioc容器中 ###

<?xml version="1.0" encoding="utf-8" ?>
    
    <beans>
    
        <component-scan base-package="com.bruce.service,com.bruce.controller"></component-scan>
    </beans>

### 3，pojo层：user类，用来存放数据 ###

package com.bruce.POJO;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        private Integer id;
        private String name;
        private String password;
    }

### 4，service层：UserService接口    UserServiceImpl实现类 //用来写业务功能 ###

### UserService接口： ###

package com.bruce.service;
    import com.bruce.POJO.User;
    import java.util.List;
    public interface UserService {
        List<User> findUser(String name);
        String getUserMassage(String name);
    }

### UserServiceImpl实现类： ###

package com.bruce.service;
    import com.bruce.POJO.User;
    import com.springMVC.annotation.Service;
    import java.util.ArrayList;
    import java.util.List;
    @Service
    public class UserServiceImpl implements UserService {
        @Override
        public List<User> findUser(String name) {
            System.out.println("查询的参数是:"+name);
            //模拟一些数据
            List<User> users=new ArrayList<User>();
            users.add(new User(1,"建江","123"));
            users.add(new User(2,"小米","111"));
            return users;
        }
        @Override
        public String getUserMassage(String name) {
            return "我是getUserMassage方法:  "+name;
        }
    }

### 5，controller层：UserController类  //用来处理请求 ###

package com.bruce.controller;
    
    import com.bruce.POJO.User;
    import com.bruce.service.UserService;
    import com.bruce.service.UserServiceImpl;
    import com.springMVC.annotation.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    @Controller
    public class UserController {
        @AutoWired
        private UserServiceImpl userServiceImpl;
        @RequestMapping("/user/query")
        public void findUser(HttpServletRequest request, HttpServletResponse response,
                             String name){
            System.out.println(userServiceImpl);
            response.setContentType("text/html;charset=utf-8");//处理响应的中文乱码
            List<User> users = userServiceImpl.findUser(name);
            try {
                PrintWriter out = response.getWriter();
                out.print("<h1>SpringMVC容器"+name+"</h1>");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                System.out.println("我执行了");
            }
    
        }
    
        /**
         * 返回到一个新的页面
         * @param request
         * @param response
         * @param name
         * @return
         */
        @RequestMapping("/user/query1")
        public String findUser1(HttpServletRequest request, HttpServletResponse response, String name){
            response.setContentType("text/html;charset=utf-8");//处理响应的中文乱码
            String userMassage = userServiceImpl.getUserMassage(name);
            request.setAttribute("userMassage",userMassage);
            //转发到user.jsp
            return "forward:/user.jsp";
        }
    
        /**
         * 返回一个json数据
         */
        @RequestMapping("/user/query2")
        @RequestBody
        public List<User> findUser2(HttpServletRequest request, HttpServletResponse response, String name){
            List<User> user = userServiceImpl.findUser(name);
            return user;
        }
    }

### 6，注解接口：@service    @controller  @RequestMapping   @RequestParam   @AutoWired//这些注解只是一个标记的作用，存储value参数的作用 ###

### @service：（创建过程和从句接口过程类似，选择创建注解Annotation） ###

package com.springMVC.annotation;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.*;
    /**
     * 自定义注解
     */
    @Target(ElementType.TYPE)//元注解。TYPE表示该这个自定义注解的作用范围是在类上
    @Retention(RetentionPolicy.RUNTIME)//表示运行时这个注解起作用
    @Documented//生成文档注释，可以不用加
    public @interface Service{
        String value() default "";//添加service注解的参数value
    }

### @controller： ###

package com.springMVC.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * 自定义注解
     */
    @Target(ElementType.TYPE)//元注解。TYPE表示该这个自定义注解的作用范围是在类上
    @Retention(RetentionPolicy.RUNTIME)//表示运行时这个注解起作用
    @Documented//生成文档注释，可以不用加
    public @interface Controller {
        String value() default "";//添加service注解的参数value
    }

### @RequestMapping： ###

package com.springMVC.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * 自定义注解
     */
    @Target(ElementType.METHOD)//元注解。METHOD表示该这个自定义注解的作用范围是在方法上
    @Retention(RetentionPolicy.RUNTIME)//表示运行时这个注解起作用
    @Documented//生成文档注释，可以不用加
    public @interface RequestMapping {
        String value() default "";//添加service注解的参数value
    }

### @RequestParam： ###

package com.springMVC.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * 自定义注解
     */
    @Target(ElementType.PARAMETER)//元注解。PARAMETER表示该这个自定义注解的作用范围是在参数上
    @Retention(RetentionPolicy.RUNTIME)//表示运行时这个注解起作用
    @Documented//生成文档注释，可以不用加
    public @interface RequestParam {
        String value() default "";//添加service注解的参数value
    }

###  @AutoWired ###

package com.springMVC.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * 自定义注解
     */
    @Target(ElementType.FIELD)//元注解。FIELD表示该这个自定义注解的作用范围是在字段上
    @Retention(RetentionPolicy.RUNTIME)//表示运行时这个注解起作用
    @Documented//生成文档注释，可以不用加
    public @interface AutoWired {
        String value() default "";//添加service注解的参数value
    }

### 7，前端控制器：DispatcherServlet类：这个类功能比较复杂（做好准备） ###

### 注解：执行的流程 ###

/**
         * 初始化：
         * 去web.xml文件中得到springmvc.xml配置文件的名字，传给spring容器，进行初始化
         * spring容器初始化过程：
         * spring容器会调用xml解析器，对springmvc.xml文件进行解析，得到要扫描的包，把包下面的java文件名存到classNameList中
         * 遍历classNameList中的每个类，判断他们是否有@controller和@Service注解，如果有，就把它们的该类的名字，和实例化对象存到iocMap中
         * 遍历IocMap集合中的实例化对象，得到它的属性集合，遍历属性，判断属性上是否有@AutoWired注解，如果有就获取它的类型名
         * 根据类型名去IOCMap容器找到对应的实例化对象，进行赋值（对象的注入）
         *
         * 初始化请求映射：
         * 如IOCMap容器中得到实例化的Controller类
         * 获取到这个类的所有方法，遍历方法集合
         * 判断方法上是否有RequestMapping注解，如果有就得到它的value值也就是请求路径url
         * 把url，method，controller三个传给Handler进行初始化（记录三者的关系，由此可以根据请求路径定位到该方法）
         * 把Handler存到handlerList
         *
         * 处理请求：
         * 根据url来获取对应的处理器类，判断它是否为空，为空报404
         * 不为空，根据Handler找到该url要调用的方法，遍历方法的参数，把参数存到数组Params中，
         * 存储参数时需要进行判断，是HttpServletRequest类型的还是HttpServletResponse类型的，存放在对应位置
         * 如果是String类型的，进需要判断请求参数，与方法参数是否一样，如果一样才能调用方法，还需要找到有RequestParam注解
         * 判断它的value值是否与请求参数的名称一致，不一致不能调用处理请求的方法。
         * 
         * 判断返回值类型是不是String类型的
         * 如果是String类型，可能要跳转的jsp页面
         * 如果该方法上有RequestBody注解，返回的是json集合
         * 需要使用Jackson工具类，对bean对象进行转化成json类型后，以输出流的形式发送到浏览器
         *
         * @throws ServletException
         */

package com.springMVC.servlet;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.springMVC.annotation.Controller;
    import com.springMVC.annotation.RequestBody;
    import com.springMVC.annotation.RequestMapping;
    import com.springMVC.annotation.RequestParam;
    import com.springMVC.context.WebApplicationContext;
    import com.springMVC.exception.ContextException;
    import com.springMVC.handler.MyHandler;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Parameter;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    
    /**
     * DispatcherServlet是SpringMVC的核心控制器
     */
    public class DispatcherServlet extends HttpServlet {
        private WebApplicationContext webApplicationContext;
        //存储url和对象方法的映射关系
        List<MyHandler> handlerList=new ArrayList<MyHandler>();
    
    //需要重写HttpServlet的两个方法
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //super.doGet(req, resp);
            this.doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //super.doPost(req, resp);
            //请求的分发处理
            executeDispatch(req,resp);
    
        }
    
        /**
         * 初始化
         * @throws ServletException
         */
        @Override
        public void init() throws ServletException {
            //1,Servlet初始化的时候，去web.xml文件读取初始化的参数contextConfigLocation的值：classpath:springmvc.xml
            String contextConfigLocation = this.getServletConfig().getInitParameter("contextConfigLocation");
            //2,创建spring容器：将值classpath:springmvc.xml传进去，创建spring的容器
            webApplicationContext=new WebApplicationContext(contextConfigLocation);
            //初始化spring容器
            webApplicationContext.refresh();
            //4，初始化请求映射：/user/query------》Controller----->method-----param
            initHandlerMapping();
            System.out.println("请求地址和控制器方法的映射关系："+handlerList);
            //super.init();
        }
    
        /**
         * 初始化请求映射
         */
        void  initHandlerMapping(){
            //判断iocMap中是否有bean对象
            if(webApplicationContext.iocMap.isEmpty()){
                throw new ContextException("spring容器为空");
            }
            for (Map.Entry<String,Object> entry:webApplicationContext.iocMap.entrySet()){
                Class<?> clazz =entry.getValue().getClass();
                if (clazz.isAnnotationPresent(Controller.class)){
                    Method[] methods = clazz.getDeclaredMethods();
                    for (Method method:methods){
                        if (method.isAnnotationPresent(RequestMapping.class)){
                            RequestMapping requestMappingAnnotation = method.getAnnotation(RequestMapping.class);
                            String url = requestMappingAnnotation.value();
                            MyHandler myHandler=new MyHandler(url,entry.getValue(),method);
                            handlerList.add(myHandler);
                        }
                    }
                }
            }
        }
    
        /**
         * 请求分发
         */
        void executeDispatch(HttpServletRequest req, HttpServletResponse resp){
            MyHandler handler = getHandler(req);
                try {
                    if (handler==null){
                    resp.getWriter().print("<h1>  404  not found</h1>");
                    }else {
                        Class<?>[] parameterTypes = handler.getMethod().getParameterTypes();
                        Object []params=new Object[parameterTypes.length];//定义一个参数数组,来存放请求的参数
                        for (int i=0;i<parameterTypes.length;i++){
                            Class<?> parameterType=parameterTypes[i];
                            if ("HttpServletRequest".equals(parameterType.getSimpleName())){
                                params[i]=req;
                            }else if ("HttpServletResponse".equals(parameterType.getSimpleName())){
                                params[i]=resp;
                            }
                        }
    
                        //获取请求中的参数集合
                        Map<String,String[]> parameterMap = req.getParameterMap();
                        for (Map.Entry<String,String []> entry:parameterMap.entrySet()){
                            String value = entry.getValue()[0];
                            String name = entry.getKey();
                            //写死了，默认第三个参数是name
                            System.out.println("请求的参数是："+name+"---->"+value);
                            int index = hasRequestParam(handler.getMethod(), name);//把该处理器的方法，和参数key传进去
                            if (index!=-1){//如果找到下标
                                params[index]=value;
                            }else {
                                List<String> names = getParameterNames(handler.getMethod());
                                System.out.println(names);//[request, response, name]
                                for(int i=0;i<names.size();i++){
                                    if (name.equals(names.get(i))){//如果请求中的参数和方法中参数列表中的名字相同就进行赋值
                                        params[i]=value;
                                        break;
                                    }
                                }
                            }
                            //params[2] =value;
                        }
    
                        //调用控制器中的方法,得到它的返回值用来转发到对应的页面
                        Object result = handler.getMethod().invoke(handler.getController(), params);
                        if (result instanceof String){
                            //跳转到jsp页面
                            String viewName=(String)result;
                            if (viewName.contains(":")){//说明是forward:/user.jsp语法
                                String viewType=viewName.split(":")[0];
                                String viewPage=viewName.split(":")[1];
                                if (viewType.equals("forward")){
                                    //转发
                                    req.getRequestDispatcher(viewPage).forward(req,resp);
                                }else {
                                    //重定向
                                    resp.sendRedirect(viewPage);
                                }
                            }else {
                                //默认是转发
                                req.getRequestDispatcher(viewName).forward(req,resp);
                            }
                        }
                        else {
                            //返回json数据
                            Method method=handler.getMethod();
                            if (method.isAnnotationPresent(RequestBody.class)){
                                //调用返回值用Json转化的工具类，把它转化成json字符串
                                ObjectMapper objectMapper=new ObjectMapper();
                                String json = objectMapper.writeValueAsString(result);
                                resp.setContentType("text/html;charset=utf-8");//返回数据解决中文乱码
                                PrintWriter out = resp.getWriter();//把response请求写入输出流
                                out.print(json);//将json数据显示在浏览器
                                out.flush();//情况流中的数据
                                out.close();//关闭输出流
                            }
                        }
                    }
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
        }
    
        /**
         * 获取请求对应的控制器Handler
         */
        MyHandler getHandler(HttpServletRequest req){
            //  /user/query路径
            String requestURI = req.getRequestURI();
            for (MyHandler handler:handlerList){//遍历处理器列表，对比有没有相同url的处理器，有就返回
                if (handler.getUrl().equals(requestURI)){
                    return handler;
                }
            }
            return null;
        }
    
        /**
         * 判断控制器的参数是否有，RequestMapping注解，并且比较对应的value值是否相等，如果相等返回下标
         */
        public  int hasRequestParam(Method method,String name){
            Parameter[] parameters = method.getParameters();
            for (int i=0;i<parameters.length;i++){
                Parameter parameter=parameters[i];
                boolean b = parameter.isAnnotationPresent(RequestParam.class);//参数是否有RequestParam注解
                if (b){
                    RequestParam requestParam = parameter.getAnnotation(RequestParam.class);//得到RequestParam注解，判断value值
                    String value = requestParam.value();
                    if (name.equals(value)){//如果传入的参数name和value值相同就返回参数的下标位置
                        return i;
                    }
                }
            }
            return -1;//没有找到
        }
    
        /**
         * 获取参数的名字列表，需要在pom.xml文件配置maven编译插件，依赖于jdk1.8
         */
        public List<String> getParameterNames(Method method){
            List<String> list=new ArrayList<String>();//存放参数
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter:parameters){
                list.add(parameter.getName());
            }
            return list;
        }
    
    
    }

### 8，Spring容器：WebApplicationContext类 ###

package com.springMVC.context;
    
    import com.springMVC.annotation.AutoWired;
    import com.springMVC.annotation.Controller;
    import com.springMVC.annotation.Service;
    import com.springMVC.exception.ContextException;
    import com.xml.XmlParser;
    
    
    import java.io.File;
    import java.lang.reflect.Field;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * spring容器
     */
    public class WebApplicationContext {
        private String contextConfigLocation;//内容是classpath:springmvc.xml
        List<String> classNameList=new ArrayList<String>();//存放要扫描的包
        //spring的ioc容器，用来存放bean对象
        public Map<String,Object> iocMap=new ConcurrentHashMap<String,Object>();
    
        public WebApplicationContext(String contextConfigLocation) {
            this.contextConfigLocation = contextConfigLocation;
        }
    
        /**
         * 初始化spring容器
         */
        public void refresh(){
            //1,解析spring.xml文件，使用dom4j
            //把springmvc.xml传到getBasePackage方法中，该方法会实例化springmvc.xml对象，把对应要扫描包的值取出来
            //使用basePackage的值是com.bruce.service,com.bruce.controller
            String basePackage = XmlParser.getBasePackage(contextConfigLocation.split(":")[1]);
            String []basePackages=basePackage.split(",");//把它们分割开来
            if (basePackage.length()>0){//如果有值，分割里面的报，进行初始化
                for (String pack:basePackages){
                    executeScanPackage(pack);//这个方法在下面，获取包的路径存到list中
                }
            }
            System.out.println("扫描后内容是："+classNameList);
            //实例化spring容器中的bean
            executeInstance();
            System.out.println("IOCMap容器中的对象"+iocMap);
    
            //实现spring容器中对象的注入
            executeAutoWired();
    
        }
    
        /**
         * 根据配置文件中的路径信息，扫描对应的包，把这些包的路径存到list集合中
         */
        public void executeScanPackage(String pack){
            URL url = this.getClass().getClassLoader().getResource("/" + pack.replaceAll("\\.", "/"));
            String path=url.getFile();
            File dir=new File(path);
            for (File f:dir.listFiles()){
                if (f.isDirectory()){
                    //是一个文件目录
                    executeScanPackage(pack+"."+f.getName());//继续进入这个文件夹中寻找文件
                }
                else {
                    //是一个文件，获取它的全路径，把它存到list集合中
                    String className=pack+"."+f.getName().replaceAll(".class","");
                    classNameList.add(className);
    
                }
            }
        }
    
        /**
         * 实例化spring容器中的bean对象
         * 主要是service层和controller层的类
         */
        public void executeInstance(){
            if(classNameList.size()==0){
                //没有扫描到要实例化的类，抛出自定义的异常
                throw  new ContextException("没有实例化的class");
            }
            for (String className:classNameList){
                try {
                    Class<?> clazz=Class.forName(className);
                    if (clazz.isAnnotationPresent(Controller.class)){
                        //判断该类是否有@Controller 注解，如果有说明他是控制层的类
                        //得到这个类的名字，第一个字母转小写。作为这个类对象的名字
                        String beanName=clazz.getSimpleName().substring(0,1).toLowerCase()+ clazz.getSimpleName().substring(1);
                        iocMap.put(beanName,clazz.newInstance());//把该对象的名字和实例存到ioc容器中
                    }
                    else if (clazz.isAnnotationPresent(Service.class)){
                        //如果有@Controller 注解，说明他是业务层的类
                        Service serviceAnnotation=clazz.getAnnotation(Service.class);//得到@Service
                        String beanName =serviceAnnotation.value();//得到里面的value值
                        if("".equals(beanName)){//如果我们没有使用value值去设置对象的名字
                            Class<?> []interfaces= clazz.getInterfaces();//就得到该类实现接口的名字
                            for (Class<?> c1:interfaces){//遍历接口，把接口名作为该类对象的名字，和该类的实例一起存到ioc容器中
                                String beanName1=clazz.getSimpleName().substring(0,1).toLowerCase()+ clazz.getSimpleName().substring(1);
                                iocMap.put(beanName1,clazz.newInstance());
                            }
                        }else {
                            iocMap.put(beanName,clazz.newInstance());//把value作为对象名字，与对象实例存入ioc集合
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         *实现spring容器中的对象的依赖注入：userService
         */
        public  void executeAutoWired(){
            try {
                if(iocMap.isEmpty()){//如果容器为空
                    throw new ContextException("没有找到初始化的bean对象");
                }
                for (Map.Entry<String,Object> entry:iocMap.entrySet()){
                    String key = entry.getKey();
                    Object bean = entry.getValue();//对象
                    Field[] declaredFields = bean.getClass().getDeclaredFields();//获取bean对象上的所有字段
                    for (Field declaredField:declaredFields){//遍历所有字段
                        if (declaredField.isAnnotationPresent(AutoWired.class)){//判断该字段上是否有AutoWired注解
                            AutoWired autoWiredAnnotation = declaredField.getAnnotation(AutoWired.class);//把这个AutoWired注解取出来
                            String beanName=autoWiredAnnotation.value();//看看该注解上的value值有没有被赋值
                            if ("".equals(beanName)){//如果value没有被赋值
                                Class<?> type=declaredField.getType();//得到type的名称：UserService
                                //把第一个字母变小写后赋值给beanName
                                beanName=type.getSimpleName().substring(0,1).toLowerCase()+ type.getSimpleName().substring(1);
                            }
                            System.out.println("bean:"+bean);
                            System.out.println("beanName："+iocMap.get(beanName));
                            declaredField.setAccessible(true);//暴力反射，如果该对象是私有的，就需要开启它的访问权限
                            //属性注入,调用反射给属性注入值
                            //注入失败，接口名，与实现类对象名不一致（因为存在IOCMap中的key是实现类的名，不是接口名）
                            declaredField.set(bean,iocMap.get(beanName));
                        }
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
    
        }
    
    
    
    
    
    
    }

### 9，处理器类：MyHandler类  //用来存放  (请求url，对应控制器对象controller，处理url请求的方法method) ###

package com.springMVC.handler;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.lang.reflect.Method;
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class MyHandler {
        private String url;
        private Object controller;
        private Method method;
    }

### 10，xml文件解析类：XMLParse类//用来对springmvc.xml文件进行解析，得到要扫描的包 ###

package com.xml;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import java.io.InputStream;
    
    /**
     * 解析springMVC.xml
     */
    public class XmlParser {
        public static String getBasePackage(String xml){
            SAXReader saxReader=new SAXReader();
            InputStream inputStream = XmlParser.class.getClassLoader().getResourceAsStream(xml);
            //xml文档对象
            try {
                Document document = saxReader.read(inputStream);
                //获取到根节点
                Element rootElement = document.getRootElement();
                //找到扫描包的配置节点component-scan
                Element componentScan = rootElement.element("component-scan");
                //去取出来属性为base-package的值
                Attribute attribute = componentScan.attribute("base-package");
                String basePackage = attribute.getText();
                return basePackage;//包得到的com.bruce.service返回
            } catch (DocumentException e) {
    
            }
            return "";
        }
    
    
    
    }

### 11，自定义异常：ContextException类//包扫描不到自定义抛出自定义异常提醒自己 ###

package com.springMVC.exception;
    
    public class ContextException extends RuntimeException {
        public ContextException(String message) {
            super(message);
        }
    
        public ContextException(Throwable cause) {
            super(cause);
        }
    
    
        @Override
        public String getMessage() {
            return super.getMessage();
        }
    }

### 12，跳转后的页面user.jsp ###

<%--
      Created by IntelliJ IDEA.
      User: jianjiang
      Date: 2021/4/4
      Time: 11:12
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    <html>
    <head>
        <title>跳转页面</title>
    </head>
    <body>
    <h1>我是user.jsp页面</h1>
    <h1>${requestScope.userMassage}</h1>
    </body>
    </html>

### 手写springmvc下载地址： ###

### 链接：https://pan.baidu.com/s/1OaRKjBIRhZrK2IjVVS8yRg    提取码：110b    复制这段内容后打开百度网盘手机App，操作更方便哦 ###

[https_www.bilibili.com_video_BV18K4y1v7f7]: https://www.bilibili.com/video/BV18K4y1v7f7
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70]: /images/20221022/9c59461fdbad4170a4ce059a8432264e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1]: /images/20221022/83dd26f2d21f4946bf8baa537a7184cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2]: /images/20221022/b7f0be99f2db4574b1f882a15f7b5151.png