SpringMVC學習筆記

手寫架構篇
- 需求分析
- 自定義SpringMVC架構V1版本
- - 定義處理器
  - 定義處理器映射器
  - 定義處理器擴充卡
  - 定義前端控制器
  - 配置web.xml
- 自定義SpringMVC架構V2版本
- - 修改自定義Spring架構整合
  - 修改處理器映射器
  - 修改前端控制器
  - 測試
- 自定義SpringMVC架構V3版本
- - 自定義注解
  - 定義RequestMappingHandlerMapping
  - 定義RequestMappingHandlerAdapter
  - DispatcherServlet.properties新增配置
  - 測試
- 代碼實作github位址

手寫架構篇

需求分析

需求：

* 查詢使用者：請求URL http://localhost/queryUser
* 添加使用者：請求URL http://localhost/savaUser

問題：如果按照正常Servlet開發習慣，一個類隻會處理一個請求。
解決方案：自定義Servlet extends BaseServlet（公共的Servlet）

BaseServlet{
     doPost(){
         // url中必須帶有method參數
         // method參數的值就是對應要調用的方法名稱
         // 通過反射調用制定方法
     }
}

MyServlet extends BaseServlet{
   query(){
   }
   save(){
   }
}

隻需要一個Servlet進行請求分發即可，處理請求的類隻是一個普通類（不需要實作Servlet相關的類）

自定義SpringMVC架構V1版本

定義處理器

處理器接口規範：

public interface HttpRequestHandler {
    void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

/**
 * 可以針對傳回值進行二次處理
 */
public interface SimpleControllertHandler {
    ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

處理器實作類：

/**
 * 查詢使用者處理器
 */
public class QueryUserHandler implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().write("--- QueryUserHandler ---");
    }
}

/**
 * 添加使用者處理器
 */
public class SaveUserHandler implements SimpleControllertHandler {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().write("--- SaveUserHandler ---");
        return null;
    }
}

定義處理器映射器

處理器映射器接口規範：

/**
 * 它的實作類是用來建立請求和處理類的映射關系
 * 該接口的作用是提供對該映射關系的通路，比如說根據請求查找處理類
 */
public interface HandlerMapping {
    /**
     * 根據請求查找處理類
     */
    Object getHandler(HttpServletRequest request) throws Exception;
}

處理器映射器實作類：

/**
 * <bean name="/queryUser" class="QueryUserHandler的全路徑"></bean>
 */
public class BeanNameUrlHandlerMapping implements HandlerMapping {
    private Map<String, Object> urlHandlers = new HashMap<>();

    public BeanNameUrlHandlerMapping() {
    	// TODO 暫時先寫死
        this.urlHandlers.put("/queryUser", new QueryUserHandler());
    }

    @Override
    public Object getHandler(HttpServletRequest request) throws Exception {
        String uri = request.getRequestURI();

        return this.urlHandlers.get(uri);
    }
}

/**
 * <bean  class="内置的處理器類">
 *  <props>
 *      <prop key="url">類的全路徑</prop>
 *  </props>
 * </bean>
 */
public class SimpleUrlHandlerMapping implements HandlerMapping {
    private Map<String, Object> urlHandlers = new HashMap<>();

    public SimpleUrlHandlerMapping() {
        // TODO 暫時先寫死
        this.urlHandlers.put("/saveUser", new SaveUserHandler());
    }

    @Override
    public Object getHandler(HttpServletRequest request) throws Exception {
        String uri = request.getRequestURI();
        return this.urlHandlers.get(uri);
    }
}

定義處理器擴充卡

處理器擴充卡接口規範：

/**
 * 該接口是DispatcherServlet用來調用不同類型處理器的統一類型
 * HandlerAdapter和Handler類型是一對一的，就類似于某一個類型的電腦，對應一個統一的電源擴充卡
 */
public interface HandlerAdapter {
    /**
     * 用來比對擴充卡和處理器
     */
    boolean supports(Object handler);

    /**
     * 調用不同類型的處理器完成請求處理
     */
    ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception;
}

處理器擴充卡實作類：

public class HttpRequestHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof HttpRequestHandler);
    }

    @Override
    public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
        ((HttpRequestHandler) handler).handleRequest(request, response);
        return null;
    }
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof SimpleControllertHandler);
    }

    @Override
    public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
        return ((SimpleControllertHandler) handler).handleRequest(request, response);
    }
}

定義前端控制器

抽象的Servlet：

public abstract class AbstractServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doDispatch(request, response);
    }

    /**
     * 請求分發
     */
    public abstract void doDispatch(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

DispatcherServlet：

/**
 * springmvc提供的唯一的一個Servlet類
 */
public class DispatcherServlet extends AbstractServlet {
    /**
     * HandlerMapping的政策集合
     */
    private List<HandlerMapping> handlerMappings = new ArrayList<>();
    /**
     * HandlerAdapter的政策集合
     */
    private List<HandlerAdapter> handlerAdapters = new ArrayList<>();

    /**
     * servlet初始化
     */
    @Override
    public void init() throws ServletException {
        handlerMappings.add(new BeanNameUrlHandlerMapping());
        handlerMappings.add(new SimpleUrlHandlerMapping());

        handlerAdapters.add(new HttpRequestHandlerAdapter());
        handlerAdapters.add(new SimpleControllerHandlerAdapter());
    }

    @Override
    public void doDispatch(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            // 1、根據請求，查找對應的處理類
            // 問題1：處理類長啥樣？（它和Servlet無關，可以随便寫，隻是說為了統一，最後指定規範[接口]）
            // 問題2：去哪找處理類？（也就是請求URL和處理類的關系在哪建立）
            Object handler = getHandler(request);
            if (handler == null) {
                return;
            }
            // 2、調用處理類的方法，執行請求處理，并傳回處理結果
            HandlerAdapter ha = getHandlerAdapter(handler);
            if (ha == null) {
                return;
            }
            ha.handleRequest(handler, request, response);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    private Object getHandler(HttpServletRequest request) throws Exception {
        // 首先 處理類和請求之間 的映射關系可能存儲在不同的地方（HandlerMapping）
        if (handlerMappings != null) {
            for (HandlerMapping hm : handlerMappings) {
                Object handler = hm.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
    }

    private HandlerAdapter getHandlerAdapter(Object handler) {
        if (handlerAdapters != null) {
            // 周遊政策集合
            for (HandlerAdapter ha : handlerAdapters) {
                if (ha.supports(handler)) {
                    return ha;
                }
            }
        }
        return null;
    }
}

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>com.yw.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

自定義SpringMVC架構V2版本

建立一個工程：springmvc-framework-custom，并引入之前手寫的Spring架構：

<!-- 引入自定義的Spring架構 -->
<dependency>
  <groupId>com.yw.spring.framework</groupId>
  <artifactId>spring-framework-custom</artifactId>
  <version>1.0</version>
</dependency>

将V1版本中的處理器映射器、處理器擴充卡、前端控制器等複制到該工程下，如下圖所示：

JavaEE 企業級分布式進階架構師（四）SpringMVC學習筆記（2）手寫架構篇

修改自定義Spring架構整合

JavaEE 企業級分布式進階架構師（四）SpringMVC學習筆記（2）手寫架構篇

新增标記接口：用于BeanFactory容器的注入

public interface Aware {
}
public interface BeanFactoryAware extends Aware {
    void setBeanFactory(BeanFactory beanFactory);
}

定義接口 InitializingBean：實作該接口可以在依賴注入與初始化Bean 之間完成一些事情

public interface InitializingBean {
    void afterPropertiesSet();
}

修改AbstractAutowiredCapableBeanFactory中的 initializeBean 方法：

public abstract class AbstractAutowiredCapableBeanFactory extends AbstractBeanFactory {
    // 省略...
    
    private void initializeBean(Object bean, BeanDefinition beanDefinition) {
        // 需要針對Aware接口标記的類進行特殊處理
        if (bean instanceof Aware) {
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(this);
            }
        }
        // 可以進行InitializeBean接口的處理
        if (bean instanceof InitializingBean) {
            ((InitializingBean) bean).afterPropertiesSet();
        }
        ReflectUtils.invokeMethod(bean, beanDefinition.getInitMethod());
    }
}

修改 ListableBeanFactory 接口

/**
 * 對于Bean容器中的Bean可以進行集合操作或者說叫批量操作
 */
public interface ListableBeanFactory extends BeanFactory {
    /**
     * 可以根據指定類型擷取它或者它實作類的對象
     */
    <T> List<T> getBeansByType(Class type);
}

修改 BeanDefinitionRegistry 接口：新增 getBeanDefinitions 方法

/**
 * 1、實作類是封裝了BeanDefinition集合資訊
 * 2、接口類是提供對于其封裝的BeanDefinition資訊進行添加和擷取功能
 */
public interface BeanDefinitionRegistry {
    /**
     * 擷取BeanDefinition
     */
    BeanDefinition getBeanDefinition(String beanName);

    /**
     * 注冊BeanDefinition
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);

    /**
     * 擷取BeanDefinition集合
     */
    List<BeanDefinition> getBeanDefinitions();
}

DefaultListableBeanFactory 實作 ListableBeanFactory，BeanDefinitionRegistry中的兩個方法：

/**
 * 既是spring中的真正管理Bean執行個體的容器工廠
 * 同時又是管理BeanDefinition的BeanDefinition注冊器
 */
public class DefaultListableBeanFactory extends AbstractAutowiredCapableBeanFactory
        implements BeanDefinitionRegistry, ListableBeanFactory {
    /**
     * 存儲BeanDefinition的容器
     */
    private Map<String, BeanDefinition> beanDefinitions = new ConcurrentHashMap<>(128);

    @Override
    public BeanDefinition getBeanDefinition(String beanName) {
        return beanDefinitions.get(beanName);
    }

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitions.put(beanName, beanDefinition);
    }

    @Override
    public List<BeanDefinition> getBeanDefinitions() {
        List<BeanDefinition> results = new ArrayList<>();
        for (BeanDefinition bd : beanDefinitions.values()) {
            results.add(bd);
        }
        return results;
    }

    @Override
    public <T> List<T> getBeansByType(Class type) {
        List<T> results = new ArrayList<>();
        // 擷取容器中所有的BeanDefinition，周遊每個BeanDefinition，取出來它的類型
        for (BeanDefinition bd : beanDefinitions.values()) {
            Class<?> clazzType = bd.getClazzType();
            // type如果是clazzType的父類型，則傳回true
            if (type.isAssignableFrom(clazzType)) {
                results.add((T) getBean(bd.getBeanName()));
            }
        }
        return results;
    }
}

修改處理器映射器

BeanNameUrlHandlerMapping 增加實作 InitializingBean 和 BeanFactoryAware 兩個接口：展現Spring架構和SpringMVC架構的整合

public class BeanNameUrlHandlerMapping implements HandlerMapping, InitializingBean, BeanFactoryAware {
    private Map<String, Object> urlHandlers = new HashMap<>();

    private DefaultListableBeanFactory beanFactory;

    public BeanNameUrlHandlerMapping() {
    }

    @Override
    public Object getHandler(HttpServletRequest request) throws Exception {
        String uri = request.getRequestURI();

        return this.urlHandlers.get(uri);
    }

    @Override
    public void afterPropertiesSet() {
        List<BeanDefinition> beanDefinitions = beanFactory.getBeanDefinitions();
        for (BeanDefinition bd : beanDefinitions) {
            String beanName = bd.getBeanName();
            if (beanName.startsWith("/")) {
                this.urlHandlers.put(beanName, beanFactory.getBean(beanName));
            }
        }
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = (DefaultListableBeanFactory) beanFactory;
    }
}

修改前端控制器

resources目錄下新增 DispatcherServlet.properties 檔案：

com.yw.springmvc.framework.mapping.HandlerMapping=com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping

com.yw.springmvc.framework.adapter.HandlerAdapter=com.yw.webmvc.framework.adapter.impl.HttpRequestHandlerAdapter,\
  com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter

修改DispatcherServlet：整合Spring架構，并從配置檔案中加載預設的處理器映射器、處理器擴充卡等政策

public class DispatcherServlet extends AbstractServlet {
    /**
     * HandlerMapping的政策集合
     */
    private List<HandlerMapping> handlerMappings = new ArrayList<>();
    /**
     * HandlerAdapter的政策集合
     */
    private List<HandlerAdapter> handlerAdapters = new ArrayList<>();

    private DefaultListableBeanFactory beanFactory;

    private static Properties defaultStrategies;

    static {
        try {
            ClasspathResource resource = new ClasspathResource("DispatcherServlet.properties");
            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
//        handlerAdapters.add(new HttpRequestHandlerAdapter());
//        handlerAdapters.add(new SimpleControllerHandlerAdapter());
//
//        handlerMappings.add(new BeanNameUrlHandlerMapping());
//        handlerMappings.add(new SimpleUrlHandlerMapping());
        String location = config.getInitParameter("contextConfigLocation");
        // 初始化spring容器
        initContainer(location);
        // 初始化政策集合
        initStrategies();
    }

    private void initContainer(String location) {
        // 加載spring容器需要的BeanDefinition資訊
        beanFactory = new DefaultListableBeanFactory();

        ClasspathResource resource = new ClasspathResource(location);
        InputStream inputStream = resource.getResource();

        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.loadBeanDefinitions(inputStream);

        // 注冊預設政策BeanDefinition
        registerDefaultStrategies();

        // 将spring容器中管理的所有單例Bean進行初始化(getBean)
        beanFactory.getBeansByType(Object.class);
    }

    private void registerDefaultStrategies() {
        registerDefaultStrategies(HandlerMapping.class);
        registerDefaultStrategies(HandlerAdapter.class);
    }

    private <T> void registerDefaultStrategies(Class<T> strategyInterface) {
        String key = strategyInterface.getName();
        String value = defaultStrategies.getProperty(key);
        if (value == null) {
            return;
        }
        String[] clazzNames = StringUtils.split(value, ",");
        for (String clazzName : clazzNames) {
            try {
                Class<?> clazzType = Class.forName(clazzName);
                String beanName = clazzType.getSimpleName();
                BeanDefinition beanDefinition = new BeanDefinition(clazzName, beanName);
                beanDefinition.setScope("singleton");
                beanFactory.registerBeanDefinition(beanName, beanDefinition);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }

    private void initStrategies() {
        initHandlerMappings();
        initHandlerAdapters();
    }

    private void initHandlerMappings() {
        handlerMappings = beanFactory.getBeansByType(HandlerMapping.class);
    }

    private void initHandlerAdapters() {
        handlerAdapters = beanFactory.getBeansByType(HandlerAdapter.class);
    }

    // 省略...
}

測試

定義處理器：

public class QueryUserHandler implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().write("--- QueryUserHandler V2 ---");
    }
}

public class SaveUserHandler implements SimpleControllerHandler {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().write("--- SaveUserHandler V2 ---");
        return null;
    }
}

配置springmvc.xml：

<beans>
  <!-- 配置處理器映射器 -->
  <bean class="com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping"/>

  <!-- 配置處理器擴充卡 -->
  <bean class="com.yw.springmvc.framework.adapter.impl.HttpRequestHandlerAdapter"/>
  <bean class="com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter"/>

  <!-- 配置處理器 -->
  <bean name="/queryUser" class="com.yw.springmvc.example.handler.QueryUserHandler" />
  <bean name="/saveUser" class="com.yw.springmvc.example.handler.SaveUserHandler" />
</beans>

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>com.yw.springmvc.framework.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

自定義SpringMVC架構V3版本

自定義注解

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

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ResponseBody {
}

定義RequestMappingHandlerMapping

public class RequestMappingHandlerMapping implements HandlerMapping, InitializingBean, BeanFactoryAware {
    private Map<String, HandlerMethod> urlHandlers = new HashMap<>();

    private DefaultListableBeanFactory beanFactory;

    @Override
    public Object getHandler(HttpServletRequest request) throws Exception {
        String uri = request.getRequestURI();
        return this.urlHandlers.get(uri);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = (DefaultListableBeanFactory) beanFactory;
    }

    @Override
    public void afterPropertiesSet() {
        List<BeanDefinition> beanDefinitions = this.beanFactory.getBeanDefinitions();
        for (BeanDefinition bd : beanDefinitions) {
            Class<?> clazzType = bd.getClazzType();
            // 如果類上帶有@Controller或者@RequestMapping注解
            if (isHandler(clazzType)) {
                RequestMapping classMapping = clazzType.getAnnotation(RequestMapping.class);
                String classUrl = classMapping.value();

                Method[] methods = clazzType.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(RequestMapping.class)) {
                        // 建立URL和HandlerMethod對象的映射關系

                        StringBuilder sb = new StringBuilder();
                        if (!classUrl.startsWith("/")) {
                            sb.append("/");
                        }
                        sb.append(classUrl);

                        RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
                        String methodUrl = methodMapping.value();
                        if (!methodUrl.startsWith("/")) {
                            sb.append("/");
                        }
                        sb.append(methodUrl);

                        // 擷取HandlerMethod
                        HandlerMethod hm = new HandlerMethod(beanFactory.getBean(bd.getBeanName()), method);
                        this.urlHandlers.put(sb.toString(), hm);
                    }
                }
            }
        }
    }

    private boolean isHandler(Class<?> clazzType) {
        return (clazzType.isAnnotationPresent(Controller.class)
                || clazzType.isAnnotationPresent(RequestMapping.class));
    }
}

定義RequestMappingHandlerAdapter

public class RequestMappingHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof HandlerMethod);
    }

    @Override
    public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
        HandlerMethod hm = (HandlerMethod) handler;
        Object controller = hm.getController();
        Method method = hm.getMethod();

        // 處理請求參數
        Object[] args = handleParameters(request, method);

        // 通過反射調用方法
        Object returnValue = method.invoke(controller, args);

        // 處理傳回值
        handleReturnValue(returnValue, response);

        return null;
    }

    private Object[] handleParameters(HttpServletRequest request, Method method) {
        List<Object> args = new ArrayList<>();

        // 請求參數KV集合
        Map<String, String[]> parameterMap = request.getParameterMap();

        // 方法參數數組
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            // 取出參數名稱（需要特殊處理，否則擷取到的就是arg0,arg1這樣的參數名稱）
            String name = parameter.getName();
            Class<?> type = parameter.getType();
            // 方法參數名稱一定要和請求的Key保持一緻
            String[] strings = parameterMap.get(name);
            Object valueToUse = resolveValue(strings, type);
            args.add(valueToUse);
        }
        return args.toArray();
    }

    private Object resolveValue(String[] strings, Class<?> type) {
        if (type == Integer.class) {
            return Integer.parseInt(strings[0]);
        } else if (type == String.class) {
            return strings[0];
        }
        return null;
    }

    private void handleReturnValue(Object value, HttpServletResponse response) throws Exception {
        if (value instanceof String) {
            response.setContentType("text/plain;charset=utf-8");
            response.getWriter().write(value.toString());
        } else if (value instanceof Map) {
            response.setContentType("application/json;charset=utf-8");
            response.getWriter().write(JsonUtils.object2Json(value));
        }
    }
}

DispatcherServlet.properties新增配置

com.yw.springmvc.framework.mapping.HandlerMapping=com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping,\
  com.yw.springmvc.framework.mapping.impl.RequestMappingHandlerMapping

com.yw.springmvc.framework.adapter.HandlerAdapter=com.yw.webmvc.framework.adapter.impl.HttpRequestHandlerAdapter,\
  com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter,\
  com.yw.springmvc.framework.adapter.impl.RequestMappingHandlerAdapter

測試

定義控制器：

/**
 * 注意：
 * SpringMvc中的處理器在該類中到底指的是誰？
 * 是Controller類呢？還是其他的？
 * 真正的處理器是Controller中的某個使用RequestMapping注解标記的方法
 * 也就是Controller對象+Method對象==> HandlerMethod對象（真正的處理器）
 */
@Controller
@RequestMapping("user")
public class UserController {

    @RequestMapping("query")
    @ResponseBody
    public Map<String, Object> query(Integer id, String name) {
        Map<String, Object> map = new HashMap<>(2);
        map.put("id", id);
        map.put("name", name);
        return map;
    }

    @RequestMapping("save")
    @ResponseBody
    public String save() {
        return "OK";
    }
}

代碼實作github位址

https://github.com/shouwangyw/ssm/tree/main/springmvc-framework-custom

JavaEE 企業級分布式進階架構師（四）SpringMVC學習筆記（2）手寫架構篇

SpringMVC學習筆記

手寫架構篇

需求分析

自定義SpringMVC架構V1版本

定義處理器

定義處理器映射器

定義處理器擴充卡

定義前端控制器

配置web.xml

自定義SpringMVC架構V2版本

修改自定義Spring架構整合

修改處理器映射器

修改前端控制器

測試

自定義SpringMVC架構V3版本

自定義注解

定義RequestMappingHandlerMapping

定義RequestMappingHandlerAdapter

DispatcherServlet.properties新增配置

測試

代碼實作github位址

繼續閱讀

SSM架構整合（一）：SSM環境的搭建

用Idea搭建一個簡單的SSM架構2

Maven+SSM架構搭建測試（三）

SSM整合之環境搭建

spring_Aop

PDF報表操作05~~SSM整合JasperReport+barcode4j制作動态報表(資料庫互動)案例

spring注解的開端（@Component替代bean标簽的使用）一、介紹二、簡單例子講解總結：

SpringMVC架構的常用注解1、RequestParam2、RequestBody3、PathVaribale4、RequestHeader5、CookieValue6、ModelAttribute7、SessionAttributes

SpringMVC-4—SpringMVC常用注解一、RequestMapping 注解二、RequestParam注解三、RequestBody注解四、PathVaribale注解五、RequestHeader注解六、CookieValue注解七、SessionAttribute注解

Spring MVC架構搭建

從你的WEB世界路過之--0.初識0) 前言1) WEB基本概念2) 響應資料3. 結語

如何搭建一個SSM架構

spring配置檔案拆分細節注意

基于SSM 技術的服裝店管理系統

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合