springmvc源碼分析之DispatcherServlet

時間  2020-12-27
標籤 html 前端 ios web spring json 後端 架構 app less 欄目 Spring 简体版
原文   原文鏈接

 

概述

MVC你們比較熟悉，html

  • M即model，是業務處理層，與咱們開發中的（service、dao、model）等對應起來；
  • V即view，是視圖層，之前jsp、freemarker、velocity等，如今都是先後端分離了。使用@ResponseBody註解把Controller方法返回的對象經過轉換器轉換成指定的格式（如json/xml/protobuf）後，再寫入到Response對象的body區，再也不走視圖解析器，把渲染到工做交給前端去作。
  • C，即controller，控制器，能夠分爲前端控制器（負責請求的分發，即DispatcherServlet）、映射處理器（uri與處理方法的映射，即HandlerMapping）、業務控制器（即咱們的controller層）、視圖解析器（即ViewResolver）。

三層架構與MVC的區別和聯繫前端

  • MVC是站在BS結構的視角去看待問題，是爲了把業務邏輯和用戶界面分離開
  • 分層是站在程序架構的視角去看待問題的 ，把業務的不一樣處理過程進行封裝，若是須要咱們能夠分爲更多層次，把整個事務分爲數據訪問層、業務處理層、視圖層
  • 二者的目的都是爲了分層、 解耦

下面是咱們常見的配置，DispatcherServlet就是springMVC的入門。再下面是DispatcherServlet的類圖， Aware接口咱們知道會向實例中注入一種IOC容器相關的信息。和IOC相似，能夠分爲兩個過程，先對初始化的過程進行分析，後面再來分析請求過程，核心的內容放在後面的文章進行分析ios

  • 初始化過程
  • 請求過程　　

　

初始化過程

因爲上面咱們配置文件雖配置了load-on-startup爲，也就是說在容器啓動時就會進行加載DispatcherServlet。咱們看下實例化方法，發現只設置了是否能夠分發OPTIONS請求，沒有什麼其它事情。接下來就是init方法的分析，下面從這裏開始web

  • 初始化方法，關注兩件事
    • 給DispatcherServlet實例設置屬性，比較上面配置的contextConfigLocation
    • 初始化Servlet，IOC容器的啓動等都在這裏發生　　
//HttpServletBean類的方法
//初始化方法
public final void init() throws ServletException { if (logger.isDebugEnabled()) { logger.debug("Initializing servlet '" + getServletName() + "'"); } // Set bean properties from init parameters.
    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties); if (!pvs.isEmpty()) { try { BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this); ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext()); bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment())); initBeanWrapper(bw); bw.setPropertyValues(pvs, true); } catch (BeansException ex) { if (logger.isErrorEnabled()) { logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex); } throw ex; } } // Let subclasses do whatever initialization they like.
 initServletBean(); if (logger.isDebugEnabled()) { logger.debug("Servlet '" + getServletName() + "' configured successfully"); } }
  • 初始化DispatcherServlet
//FrameworkServlet類的方法
//初始化servlet，這裏是去初始化IOC容器
protected final void initServletBean() throws ServletException { getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'"); if (this.logger.isInfoEnabled()) { this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started"); } long startTime = System.currentTimeMillis(); try { this.webApplicationContext = initWebApplicationContext();
　　　　//子類去實現,默認空實現，DispatcherServlet沒有去重寫
　　　　 initFrameworkServlet(); } catch (ServletException ex) { this.logger.error("Context initialization failed", ex); throw ex; } catch (RuntimeException ex) { this.logger.error("Context initialization failed", ex); throw ex; } if (this.logger.isInfoEnabled()) { long elapsedTime = System.currentTimeMillis() - startTime; this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " + elapsedTime + " ms"); } }
  • 獲取上下文
    • 獲取父上下文，這個上下文由ContextLoaderListener建立，使用較多，具體能夠參考連接博文，這裏不進行分析。後面的上下文，都會把這個上下文設置爲父上下文
    • 獲取DiapatcherServlet構造函數傳進來的上下文（能夠在DispatcherServlet中看到有這個一個重載構造函數），平時開發中lz沒有這麼使用過
    • FrameworkServlet設置的上下文屬性注入的上下文，平時開發不使用
    • 建立一個上下文，平時開發配置都會走到這一步，建立一個XmlWebApplicationContext（也能夠指定容器類，但必須實現了ConfigurableWebApplicationContext）
    • onRefresh方法，DispatcherServlet的刷新工做從這裏開始，分析的重點
//FrameworkServlet類的方法
//初始化IOC容器
protected WebApplicationContext initWebApplicationContext() {  WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext()); WebApplicationContext wac = null; if (this.webApplicationContext != null) { // A context instance was injected at construction time -> use it
        wac = this.webApplicationContext; if (wac instanceof ConfigurableWebApplicationContext) { ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac; if (!cwac.isActive()) { // The context has not yet been refreshed -> provide services such as // setting the parent context, setting the application context id, etc
                if (cwac.getParent() == null) { // The context instance was injected without an explicit parent -> set // the root application context (if any; may be null) as the parent
 cwac.setParent(rootContext); }  configureAndRefreshWebApplicationContext(cwac); } } } if (wac == null) { // No context instance was injected at construction time -> see if one // has been registered in the servlet context. If one exists, it is assumed // that the parent context (if any) has already been set and that the // user has performed any initialization such as setting the context id
        wac = findWebApplicationContext(); } if (wac == null) { // No context instance is defined for this servlet -> create a local one
        wac = createWebApplicationContext(rootContext); } if (!this.refreshEventReceived) { // Either the context is not a ConfigurableApplicationContext with refresh // support or the context injected at construction time had already been // refreshed -> trigger initial onRefresh manually here.
 onRefresh(wac); } if (this.publishContext) { // Publish the context as a servlet context attribute.
        String attrName = getServletContextAttributeName(); getServletContext().setAttribute(attrName, wac); if (this.logger.isDebugEnabled()) { this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
                    "' as ServletContext attribute with name [" + attrName + "]"); } } return wac; }
  • DispatcherServlet定製的刷新方法
//DispatcherServlet類的方法
protected void onRefresh(ApplicationContext context) { initStrategies(context); }
//DispatcherServlet類的方法
protected void initStrategies(ApplicationContext context) {
　　 //初始化多媒體解析器，這個不分析 initMultipartResolver(context);
　　//初始化國際化解析器，這個不進行分析 initLocaleResolver(context);
　　//初始化主題解析器，基本不用，不進行分析 initThemeResolver(context);
　　//初始化映射器 initHandlerMappings(context);
　　//初始化適配器 initHandlerAdapters(context);
　　//初始化異常解析器 initHandlerExceptionResolvers(context);
　　//初始化視圖名轉換器，不進行分析 initRequestToViewNameTranslator(context);
　　//初始化視圖解析器，前端分離後，用得少了，也分析下 initViewResolvers(context);
　　//初始化FlashMapManager，只知道是重定向時用來保存數據用的，沒有使用過，這裏不進行分析 initFlashMapManager(context); }
  •  初始化代碼

　　下面貼的代碼的幾個初始化代碼的邏輯實際上是同樣的，分爲三步，以initHandlerMappings進行說明spring

    • 判斷是否尋找全部容器中實現HandlerMapping接口的，是則尋找全部容器中實現了HandlerMapping接口的對象，設置到handlerMappings對象中並排序（日常開發中走的都是這個分支）
    • 否的話，只找尋到前容器實現了HandlerMapping接口的對象
    • 若是上面查找後爲空的話，則加載配置文件中的類並實例化，再設置到handlerMappings中。注意的是：這個配置文件位置是:org/springframework/web/servlet/DispatcherServlet.properties
private void initHandlerMappings(ApplicationContext context) { this.handlerMappings = null; if (this.detectAllHandlerMappings) { // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
        Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values()); // We keep HandlerMappings in sorted order.
            AnnotationAwareOrderComparator.sort(this.handlerMappings); } } else { try { HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class); this.handlerMappings = Collections.singletonList(hm); } catch (NoSuchBeanDefinitionException ex) { // Ignore, we'll add a default HandlerMapping later.
 } } // Ensure we have at least one HandlerMapping, by registering // a default HandlerMapping if no other mappings are found.
    if (this.handlerMappings == null) { this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class); if (logger.isDebugEnabled()) { logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default"); } } }

 

　　

private void initHandlerAdapters(ApplicationContext context) { this.handlerAdapters = null; if (this.detectAllHandlerAdapters) { // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
        Map<String, HandlerAdapter> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values()); // We keep HandlerAdapters in sorted order.
            AnnotationAwareOrderComparator.sort(this.handlerAdapters); } } else { try { HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class); this.handlerAdapters = Collections.singletonList(ha); } catch (NoSuchBeanDefinitionException ex) { // Ignore, we'll add a default HandlerAdapter later.
 } } // Ensure we have at least some HandlerAdapters, by registering // default HandlerAdapters if no other adapters are found.
    if (this.handlerAdapters == null) { this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class); if (logger.isDebugEnabled()) { logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default"); } } }

 

private void initHandlerAdapters(ApplicationContext context) { this.handlerAdapters = null; if (this.detectAllHandlerAdapters) { // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
        Map<String, HandlerAdapter> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values()); // We keep HandlerAdapters in sorted order.
            AnnotationAwareOrderComparator.sort(this.handlerAdapters); } } else { try { HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class); this.handlerAdapters = Collections.singletonList(ha); } catch (NoSuchBeanDefinitionException ex) { // Ignore, we'll add a default HandlerAdapter later.
 } } // Ensure we have at least some HandlerAdapters, by registering // default HandlerAdapters if no other adapters are found.
    if (this.handlerAdapters == null) { this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class); if (logger.isDebugEnabled()) { logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default"); } } } /** * Initialize the HandlerExceptionResolver used by this class. * <p>If no bean is defined with the given name in the BeanFactory for this namespace, * we default to no exception resolver. */
private void initHandlerExceptionResolvers(ApplicationContext context) { this.handlerExceptionResolvers = null; if (this.detectAllHandlerExceptionResolvers) { // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
        Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false); if (!matchingBeans.isEmpty()) { this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values()); // We keep HandlerExceptionResolvers in sorted order.
            AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers); } } else { try { HandlerExceptionResolver her = context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class); this.handlerExceptionResolvers = Collections.singletonList(her); } catch (NoSuchBeanDefinitionException ex) { // Ignore, no HandlerExceptionResolver is fine too.
 } } // Ensure we have at least some HandlerExceptionResolvers, by registering // default HandlerExceptionResolvers if no other resolvers are found.
    if (this.handlerExceptionResolvers == null) { this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class); if (logger.isDebugEnabled()) { logger.debug("No HandlerExceptionResolvers found in servlet '" + getServletName() + "': using default"); } } }

 

private void initViewResolvers(ApplicationContext context) { this.viewResolvers = null; if (this.detectAllViewResolvers) { // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
        Map<String, ViewResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false); if (!matchingBeans.isEmpty()) { this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values()); // We keep ViewResolvers in sorted order.
            AnnotationAwareOrderComparator.sort(this.viewResolvers); } } else { try { ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class); this.viewResolvers = Collections.singletonList(vr); } catch (NoSuchBeanDefinitionException ex) { // Ignore, we'll add a default ViewResolver later.
 } } // Ensure we have at least one ViewResolver, by registering // a default ViewResolver if no other resolvers are found.
    if (this.viewResolvers == null) { this.viewResolvers = getDefaultStrategies(context, ViewResolver.class); if (logger.isDebugEnabled()) { logger.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default"); } } }

 

請求過程

開始跟蹤下service方法json

  • 一步步跟下去，最後發現全部的請求都交給了DispatcherServlet類的doService方法，後面專門來介紹這塊
//HttpServlet類的方法
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String method = req.getMethod(); if (method.equals(METHOD_GET)) { long lastModified = getLastModified(req); if (lastModified == -1) { // servlet doesn't support if-modified-since, no reason // to go through further expensive logic
 doGet(req, resp); } else { long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE); if (ifModifiedSince < (lastModified / 1000 * 1000)) { // If the servlet mod time is later, call doGet() // Round down to the nearest second for a proper compare // A ifModifiedSince of -1 will always be less
 maybeSetLastModified(resp, lastModified); doGet(req, resp); } else { resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED); } } } else if (method.equals(METHOD_HEAD)) { long lastModified = getLastModified(req); maybeSetLastModified(resp, lastModified); doHead(req, resp); } else if (method.equals(METHOD_POST)) { doPost(req, resp); } else if (method.equals(METHOD_PUT)) { doPut(req, resp); } else if (method.equals(METHOD_DELETE)) { doDelete(req, resp); } else if (method.equals(METHOD_OPTIONS)) { doOptions(req,resp); } else if (method.equals(METHOD_TRACE)) { doTrace(req,resp); } else { //
        // Note that this means NO servlet supports whatever // method was requested, anywhere on this server. //  String errMsg = lStrings.getString("http.method_not_implemented"); Object[] errArgs = new Object[1]; errArgs[0] = method; errMsg = MessageFormat.format(errMsg, errArgs); resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg); } }
//FremeworkServlet類的方法
protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }
//FrameworkServlet類的方法
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { long startTime = System.currentTimeMillis(); Throwable failureCause = null; LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext(); LocaleContext localeContext = buildLocaleContext(request); RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes(); ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes); WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor()); initContextHolders(request, localeContext, requestAttributes); try { doService(request, response); } catch (ServletException ex) { failureCause = ex; throw ex; } catch (IOException ex) { failureCause = ex; throw ex; } catch (Throwable ex) { failureCause = ex; throw new NestedServletException("Request processing failed", ex); } finally { resetContextHolders(request, previousLocaleContext, previousAttributes); if (requestAttributes != null) { requestAttributes.requestCompleted(); } if (logger.isDebugEnabled()) { if (failureCause != null) { this.logger.debug("Could not complete request", failureCause); } else { if (asyncManager.isConcurrentHandlingStarted()) { logger.debug("Leaving response open for concurrent processing"); } else { this.logger.debug("Successfully completed request"); } } } publishRequestHandledEvent(request, response, startTime, failureCause); } }

 

//DispatcherServlet類的方法
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { if (logger.isDebugEnabled()) { String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : ""; logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
                " processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]"); } // Keep a snapshot of the request attributes in case of an include, // to be able to restore the original attributes after the include.
    Map<String, Object> attributesSnapshot = null; if (WebUtils.isIncludeRequest(request)) { attributesSnapshot = new HashMap<String, Object>(); Enumeration<?> attrNames = request.getAttributeNames(); while (attrNames.hasMoreElements()) { String attrName = (String) attrNames.nextElement(); if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) { attributesSnapshot.put(attrName, request.getAttribute(attrName)); } } } // Make framework objects available to handlers and view objects.
 request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext()); request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver); request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver); request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource()); FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response); if (inputFlashMap != null) { request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap)); } request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap()); request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager); try { doDispatch(request, response); } finally { if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) { // Restore the original attribute snapshot, in case of an include.
            if (attributesSnapshot != null) { restoreAttributesAfterInclude(request, attributesSnapshot); } } } }
  • 而後咱們來到這個doDispatch這個核心方法，這個是咱們分析的重點，這裏咱們關心下面核心的幾步，忽略掉其它的，主要有
    • 根據請求拿到HandlerExecutionChain
    • 根據handler拿到handlerAdapter
    • 執行攔截器鏈和controller中的方法
    • 異常處理和視圖解析　　
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHandler = null; boolean multipartRequestParsed = false; WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); try { ModelAndView mv = null; Exception dispatchException = null; try { processedRequest = checkMultipart(request); multipartRequestParsed = (processedRequest != request); // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest); if (mappedHandler == null || mappedHandler.getHandler() == null) { noHandlerFound(processedRequest, response); return; } // Determine handler adapter for the current request.
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); // Process last-modified header, if supported by the handler.
            String method = request.getMethod(); boolean isGet = "GET".equals(method); if (isGet || "HEAD".equals(method)) { long lastModified = ha.getLastModified(request, mappedHandler.getHandler()); if (logger.isDebugEnabled()) { logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified); } if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) { return; } } if (!mappedHandler.applyPreHandle(processedRequest, response)) { return; } // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); if (asyncManager.isConcurrentHandlingStarted()) { return; } applyDefaultViewName(processedRequest, mv);  mappedHandler.applyPostHandle(processedRequest, response, mv); } catch (Exception ex) { dispatchException = ex; } catch (Throwable err) { // As of 4.3, we're processing Errors thrown from handler methods as well, // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err); } processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); } catch (Exception ex) { triggerAfterCompletion(processedRequest, response, mappedHandler, ex); } catch (Throwable err) { triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", err)); } finally { if (asyncManager.isConcurrentHandlingStarted()) { // Instead of postHandle and afterCompletion
            if (mappedHandler != null) { mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response); } } else { // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) { cleanupMultipart(processedRequest); } } } }

 

總結

本篇主要是對初始化過程和請求處理的入口進行分析。咱們看到上面的初始化過程主要作了兩件事情後端

  • 建立了一個IOC容器
  • 把HandlerMapping、HandlerAdapter等屬性設置進來

其實這個過程並非這麼簡單的，目前咱們只是分析了web.xml內容解析，並無對dispatcher-servlet.xml的解析過程進行分析。後面會結合dispatcher-servlet.xml的解析過程和請求過程來分析，這樣會對整個過程更爲清楚。架構

後面的博文會對下面幾塊進行分析app

  • 經過請求怎麼找到controller對應的方法
  • 請求參數和方法參數怎麼綁定起來
  • 攔截器鏈怎麼生成
  • 異常怎麼處理
  • @ResponseBody註解的流程
  • 視圖解析器的處理流程

參考連接

  • https://www.cnblogs.com/weknow619/p/6341395.html（ContextLoaderListener與DispatcherServlet的建立的上下文）
  • http://www.cnblogs.com/fangjian0423/p/springMVC-dispatcherServlet.html（源碼分析參考博文）
  • https://blog.csdn.net/qq_21033663/article/details/52374436（解析器參考博文）
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程