spring事務(6)-----手寫SpringMVC模式（手寫@RequestMapping和@Controller註解）
阿新 • • 發佈：2018-11-23
一，spring原生態的程式碼分析
1.1，首先，我們先來認識一下SpringMVC的主要元件
前端控制器（DisatcherServlet）:接收請求，響應結果，返回可以是json,String等資料型別，也可以是頁面（Model）。
處理器對映器（HandlerMapping）:根據URL去查詢處理器，一般通過xml配置或者註解進行查詢。
處理器（Handler）：就是我們常說的controller控制器啦，由程式設計師編寫。
處理器介面卡（HandlerAdapter）:可以將處理器包裝成介面卡，這樣就可以支援多種型別的處理器。
檢視解析器（ViewResovler）:進行檢視解析，返回view物件（常見的有JSP,FreeMark等）。
1.2，工作原理
圖解：
1、使用者傳送請求到前端控制器（DispatcherServlet）。
2、前端控制器請求處理器對映器（HandlerMapping）去查詢處理器（Handler）。
3、找到以後處理器對映器（HandlerMappering）向前端控制器返回執行鏈（HandlerExecutionChain）。
4、前端控制器（DispatcherServlet）呼叫處理器介面卡（HandlerAdapter）去執行處理器（Handler）。
5、處理器介面卡去執行Handler。
6、處理器執行完給處理器介面卡返回ModelAndView。
7、處理器介面卡向前端控制器返回ModelAndView。
8、前端控制器請求檢視解析器（ViewResolver）去進行檢視解析。
9、檢視解析器向前端控制器返回View。
10、前端控制器對檢視進行渲染。
11、前端控制器向用戶響應結果。
看到這些步驟我相信大家很感覺非常的亂，這是正常的，但是這裡主要是要大家理解springMVC中的幾個元件：
前端控制器（DispatcherServlet）：接收請求，響應結果，相當於電腦的CPU。
處理器對映器（HandlerMapping）：根據URL去查詢處理器
處理器（Handler）：（需要程式設計師去寫程式碼處理邏輯的）
處理器介面卡（HandlerAdapter）：會把處理器包裝成介面卡，這樣就可以支援多種型別的處理器，類比筆記本的介面卡（介面卡模式的應用）
檢視解析器（ViewResovler）：進行檢視解析，多返回的字串，進行處理，可以解析成對應的頁面
換成自己的理解：
通過上面的程式碼我們可以看出它的順序
1，瀏覽器request請求過來，到前端控制器。（DispatcherServlet）。。。。ps：在專案啟動的時候已經通過掃包把所有@Controller註解的類已經加到一個map中去了，其中key就是類名小寫，value就是例項
2，在前端處理器中（DispatcherServlet）通過處理器對映器（HandlerMapping）來確定呼叫的類和方法
3，處理器處理程式碼邏輯（Handler），程式設計師自己寫的程式碼。
4，讓後通過處理器的介面卡（HandlerAdapter）去返回檢視解析器（ModelAndView）。。。。ps：也就是我們常看到的<property name="prefix" value="/" /> <property name="suffix" value=".jsp" /> 這段程式碼
5，在前端控制器中再把檢視解析器渲染成檢視（view）返回
1.3，mvc模式回憶殺（springmvc中的mvc設計模式）
1.使用者發起request請求至控制器(Controller)
控制接收使用者請求的資料，委託給模型進行處理
2.控制器通過模型(Model)處理資料並得到處理結果
模型通常是指業務邏輯
3.模型處理結果返回給控制器
4.控制器將模型資料在檢視(View)中展示
web中模型無法將資料直接在檢視上顯示，需要通過控制器完成。如果在C/S應用中模型是可以將資料在檢視中展示的。
5.控制器將檢視response響應給使用者
通過檢視展示給使用者要的資料或處理結果。
自己理解：
在這裡我們需要理解的是mvc模式
request請求到控制器，控制器，C
控制器請求請求模型（就是自己寫的程式碼）把值賦給bean M
然後進行處理，這個時候控制器會把返回的M的資料統一渲染之後返回一個V中去。
1.4,上程式碼
web.xml
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter
</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Spring MVC 核心控制器 DispatcherServlet 配置
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:mvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
攔截所有/* 的請求,交給DispatcherServlet處理,效能最好
<url-pattern>/</url-pattern>
</servlet-mapping>
mvc-config.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 掃描要自動管理的包，使SpringMVC認為包下用了@Controller 註解的類是控制器 --> <context:component-scan base-package="com.itmayiedu.controller" /> <!-- 添加註解驅動，擴充了註解驅動，可以將請求引數繫結到控制器引數 --> <mvc:annotation-driven enable-matrix-variables="true" /> <!-- 靜態資源處理，靜態資原始檔路徑設定 --> <mvc:resources location="/styles/" mapping="/styles/.**" /> <mvc:resources location="/images/" mapping="/images/.**" /> <mvc:resources location="/plugins/" mapping="/plugins/.**" /> <mvc:resources location="/scripts/" mapping="/scripts/.**" /> <mvc:resources location="/html/" mapping="/html/.**" /> <mvc:resources location="/index.html" mapping="/index.html" /> <!--避免IE執行AJAX時，返回JSON出現下載檔案 --> <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> <property name="supportedMediaTypes"> <list> <value>text/html;charset=UTF-8</value> </list> </property> </bean> <!-- 啟動SpringMVC的註解功能，完成請求和註解POJO的對映 --> <context:component-scan base-package="com.qingruihappy2"></context:component-scan> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list> <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON轉換器 --> </list> </property> </bean> <!-- 配置檔案上傳，如果沒有使用檔案上傳可以不用配置，當然如果不配，那麼配置檔案中也不必引入上傳元件包 --> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <!-- 預設編碼 --> <property name="defaultEncoding" value="utf-8" /> <!-- 檔案大小最大值 --> <property name="maxUploadSize" value="10485760000" /> <!-- 記憶體中的最大值 --> <property name="maxInMemorySize" value="40960" /> <!-- 啟用是為了推遲檔案解析，以便捕獲檔案大小異常 --> <property name="resolveLazily" value="true" /> </bean> <!-- 定義跳轉的檔案的前後綴 ，檢視模式配置 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 這裡的配置我的理解是自動給後面action的方法return的字串加上字首和字尾，變成一個 可用的url地址 --> <property name="prefix" value="/" /> <property name="suffix" value=".jsp" /> </bean> </beans>
@Controller
package com.qingruihappy2.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; /** * * @author qingruihappy * @data 2018年11月23日 上午1:05:45 * @說明: 通過上面的程式碼我們可以看出它的順序 * 1，瀏覽器request請求過來，到前端控制器。（DispatcherServlet）。。。。ps：在專案啟動的時候已經通過掃包把所有@Controller註解的類已經加到一個map中去了，其中key就是類名小寫，value就是例項 * 2，在前端處理器中（DispatcherServlet）通過處理器對映器（HandlerMapping）來確定呼叫的類和方法 * 3，處理器處理程式碼邏輯（Handler），程式設計師自己寫的程式碼。 * 4，讓後通過處理器的介面卡（HandlerAdapter）去返回檢視解析器（ModelAndView）。。。。ps：也就是我們常看到的<property * name="prefix" value="/" /> <property name="suffix" value=".jsp" /> 這段程式碼 * 5，在前端控制器中再把檢視解析器渲染成檢視（view）返回 */ @Controller @RequestMapping("/ext") public class ExtIndexController { // ext/test/?name=122&age=6440654 @RequestMapping("/test") public String test() { System.out.println("手寫springmvc框架..."); return "index"; } }
二，手寫springMVC框架
web.xml
<web-app>
<!-- Spring MVC 核心控制器 DispatcherServlet 配置 -->
<!-- 自定義的下面 -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>com.qingruihappy1.ext.springmvc.servlet.ExtDispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<!-- //攔截所有/* 的請求,交給DispatcherServlet處理,效能最好
--> <url-pattern>/</url-pattern>
</servlet-mapping>
註解類：
package com.qingruihappy1.extspringmvc.extannotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** */ @Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface ExtController { }
package com.qingruihappy1.extspringmvc.extannotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** */ @Target({ ElementType.METHOD, ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface ExtRequestMapping { String value() default ""; }
獲取包下面所有類的工具類，不是重點
package com.qingruihappy1.utils; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net.URLDecoder; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import java.util.jar.JarEntry; import java.util.jar.JarFile; public class ClassUtil { /** * 取得某個介面下所有實現這個介面的類 */ public static List<Class> getAllClassByInterface(Class c) { List<Class> returnClassList = null; if (c.isInterface()) { // 獲取當前的包名 String packageName = c.getPackage().getName(); // 獲取當前包下以及子包下所以的類 List<Class<?>> allClass = getClasses(packageName); if (allClass != null) { returnClassList = new ArrayList<Class>(); for (Class classes : allClass) { // 判斷是否是同一個介面 if (c.isAssignableFrom(classes)) { // 本身不加入進去 if (!c.equals(classes)) { returnClassList.add(classes); } } } } } return returnClassList; } /* * 取得某一類所在包的所有類名 不含迭代 */ public static String[] getPackageAllClassName(String classLocation, String packageName) { // 將packageName分解 String[] packagePathSplit = packageName.split("[.]"); String realClassLocation = classLocation; int packageLength = packagePathSplit.length; for (int i = 0; i < packageLength; i++) { realClassLocation = realClassLocation + File.separator + packagePathSplit[i]; } File packeageDir = new File(realClassLocation); if (packeageDir.isDirectory()) { String[] allClassName = packeageDir.list(); return allClassName; } return null; } /** * 從包package中獲取所有的Class * * @param pack * @return */ public static List<Class<?>> getClasses(String packageName) { // 第一個class類的集合 List<Class<?>> classes = new ArrayList<Class<?>>(); // 是否迴圈迭代 boolean recursive = true; // 獲取包的名字 並進行替換 String packageDirName = packageName.replace('.', '/'); // 定義一個列舉的集合 並進行迴圈來處理這個目錄下的things Enumeration<URL> dirs; try { dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName); // 迴圈迭代下去 while (dirs.hasMoreElements()) { // 獲取下一個元素 URL url = dirs.nextElement(); // 得到協議的名稱 String protocol = url.getProtocol(); // 如果是以檔案的形式儲存在伺服器上 if ("file".equals(protocol)) { // 獲取包的物理路徑 String filePath = URLDecoder.decode(url.getFile(), "UTF-8"); // 以檔案的方式掃描整個包下的檔案 並新增到集合中 findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes); } else if ("jar".equals(protocol)) { // 如果是jar包檔案 // 定義一個JarFile JarFile jar; try { // 獲取jar jar = ((JarURLConnection) url.openConnection()).getJarFile(); // 從此jar包 得到一個列舉類 Enumeration<JarEntry> entries = jar.entries(); // 同樣的進行迴圈迭代 while (entries.hasMoreElements()) { // 獲取jar裡的一個實體 可以是目錄 和一些jar包裡的其他檔案 如META-INF等檔案 JarEntry entry = entries.nextElement(); String name = entry.getName(); // 如果是以/開頭的 if (name.charAt(0) == '/') { // 獲取後面的字串 name = name.substring(1); } // 如果前半部分和定義的包名相同 if (name.startsWith(packageDirName)) { int idx = name.lastIndexOf('/'); // 如果以"/"結尾 是一個包 if (idx != -1) { // 獲取包名 把"/"替換成"." packageName = name.substring(0, idx).replace('/', '.'); } // 如果可以迭代下去 並且是一個包 if ((idx != -1) || recursive) { // 如果是一個.class檔案 而且不是目錄 if (name.endsWith(".class") && !entry.isDirectory()) { // 去掉後面的".class" 獲取真正的類名 String className = name.substring(packageName.length() + 1, name.length() - 6); try { // 新增到classes classes.add(Class.forName(packageName + '.' + className)); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } } } catch (IOException e) { e.printStackTrace(); } } } } catch (IOException e) { e.printStackTrace(); } return classes; } /** * 以檔案的形式來獲取包下的所有Class * * @param packageName * @param packagePath * @param recursive * @param classes */ public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes) { // 獲取此包的目錄 建立一個File File dir = new File(packagePath); // 如果不存在或者 也不是目錄就直接返回 if (!dir.exists() || !dir.isDirectory()) { return; } // 如果存在 就獲取包下的所有檔案 包括目錄 File[] dirfiles = dir.listFiles(new FileFilter() { // 自定義過濾規則 如果可以迴圈(包含子目錄) 或則是以.class結尾的檔案(編譯好的java類檔案) public boolean accept(File file) { return (recursive && file.isDirectory()) || (file.getName().endsWith(".class")); } }); // 迴圈所有檔案 for (File file : dirfiles) { // 如果是目錄 則繼續掃描 if (file.isDirectory()) { findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes); } else { // 如果是java類檔案 去掉後面的.class 只留下類名 String className = file.getName().substring(0, file.getName().length() - 6); try { // 新增到集合中去 classes.add(Class.forName(packageName + '.' + className)); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } } // 首字母轉小寫 public static String toLowerCaseFirstOne(String s) { if (Character.isLowerCase(s.charAt(0))) return s; else return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString(); } // 初始化物件 public static Object newInstance(Class<?> classInfo) throws ClassNotFoundException, InstantiationException, IllegalAccessException { return classInfo.newInstance(); } }
重點類似於前端控制器的核心類
package com.qingruihappy1.ext.springmvc.servlet; import java.io.IOException; import java.lang.reflect.Method; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.lang.StringUtils; import com.qingruihappy1.extspringmvc.extannotation.ExtController; import com.qingruihappy1.extspringmvc.extannotation.ExtRequestMapping; import com.qingruihappy1.utils.ClassUtil; /** * 自定義前端控制器<br> * 手寫springmvc 原理分析<br> * 1.建立一個前端控制器（）ExtDispatcherServlet 攔截所有請求(springmvc 基於servlet實現)<br> * ####2.初始化操作 重寫servlet init 方法<br> * #######2.1 將掃包範圍所有的類,注入到springmvc容器裡面，存放在Map集合中 key為預設類名小寫，value 物件<br> * #######2.2 將url對映和方法進行關聯 <br> * ##########2.2.1 判斷類上是否有註解,使用java反射機制迴圈遍歷方法 ,判斷方法上是否存在註解，進行封裝url和方法對應存入集合中<br> * ####3.處理請求 重寫Get或者是Post方法 <br> * ##########3.1 * 獲取請求url,從urlBeans集合獲取例項物件,獲取成功例項物件後,呼叫urlMethods集合獲取方法名稱,使用反射機制執行 2. 作者: */ public class ExtDispatcherServlet extends HttpServlet { // springmvc 容器物件 key:類名id ,value 物件 private ConcurrentHashMap<String, Object> springmvcBeans = new ConcurrentHashMap<String, Object>(); // springmvc 容器物件 keya:請求地址 ,vlue類 private ConcurrentHashMap<String, Object> urlBeans = new ConcurrentHashMap<String, Object>(); // springmvc 容器物件 key:請求地址 ,value 方法名稱 private ConcurrentHashMap<String, String> urlMethods = new ConcurrentHashMap<String, String>(); @Override public void init() throws ServletException { // 1.獲取當前包下的所有的類 List<Class<?>> classes = ClassUtil.getClasses("com.qingruihappy1.controller"); // 2.將掃包範圍所有的類,注入到springmvc容器裡面，存放在Map集合中 key為預設類名小寫，value 物件 try { findClassMVCAnnotation(classes); } catch (Exception e) { // TODO: handle exception } // 3.將url對映和方法進行關聯 handlerMapping(); } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doPost(req, resp); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // #################處理請求#################### // 1.獲取請求url地址 String requestURI = req.getRequestURI(); if (StringUtils.isEmpty(requestURI)) { return; } // 2.從Map集合中獲取控制物件 Object object = urlBeans.get(requestURI); if (object == null) { resp.getWriter().println(" not found 404 url"); return; } // 3.使用url地址獲取方法 String methodName = urlMethods.get(requestURI); if (StringUtils.isEmpty(methodName)) { resp.getWriter().println(" not found method"); } // 4.使用java的反射機制呼叫方法 String resultPage = (String) methodInvoke(object, methodName); // 5.呼叫檢視轉換器渲染給頁面展示 extResourceViewResolver(resultPage, req, resp); } private void extResourceViewResolver(String pageName, HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { // 根路徑 String prefix = "/"; String suffix = ".jsp"; req.getRequestDispatcher(prefix + pageName + suffix).forward(req, res); } private Object methodInvoke(Object object, String methodName) { try { Class<? extends Object> classInfo = object.getClass(); Method method = classInfo.getMethod(methodName); Object result = method.invoke(object); return result; } catch (Exception e) { return null; } } // 2.將掃包範圍所有的類,注入到springmvc容器裡面，存放在Map集合中 key為預設類名小寫，value 物件 public void findClassMVCAnnotation(List<Class<?>> classes) throws ClassNotFoundException, InstantiationException, IllegalAccessException { for (Class<?> classInfo : classes) { // 判斷類上是否有加上註解 ExtController extController = classInfo.getAnnotation(ExtController.class); if (extController != null) { // 預設類名是小寫 String beanId = ClassUtil.toLowerCaseFirstOne(classInfo.getSimpleName()); // 例項化物件 Object object = ClassUtil.newInstance(classInfo); springmvcBeans.put(beanId, object); } } } // 3.將url對映和方法進行關聯 public void handlerMapping() { // 1.遍歷springmvc bean容器 判斷類上屬否有url對映註解 for (Map.Entry<String, Object> mvcBean : springmvcBeans.entrySet()) { // 2.遍歷所有的方法上是否有url對映註解 // 獲取bean的物件 Object object = mvcBean.getValue(); // 3.判斷類上是否有加url對映註解 Class<? extends Object> classInfo = object.getClass(); ExtRequestMapping declaredAnnotation = classInfo.getAnnotation(ExtRequestMapping.class); String baseUrl = ""; if (declaredAnnotation != null) { // 獲取類上的url對映地址 baseUrl = declaredAnnotation.value(); } // 4.判斷方法上是否有加url對映地址 Method[] declaredMethods = classInfo.getDeclaredMethods(); for (Method method : declaredMethods) { // 判斷方法上是否有加url對映註解 ExtRequestMapping methodExtRequestMapping = method.getAnnotation(ExtRequestMapping.class); if (methodExtRequestMapping != null) { String methodUrl = baseUrl + methodExtRequestMapping.value(); // springmvc 容器物件 keya:請求地址 ,vlue類 urlBeans.put(methodUrl, object); // springmvc 容器物件 key:請求地址 ,value 方法名稱 urlMethods.put(methodUrl, method.getName()); } } } } }
controller類
package com.qingruihappy1.controller; import com.qingruihappy1.extspringmvc.extannotation.ExtController; import com.qingruihappy1.extspringmvc.extannotation.ExtRequestMapping; @ExtController @ExtRequestMapping("/ext") public class ExtIndexController { //ext/test/?name=122&age=6440654 @ExtRequestMapping("/test") public String test() { System.out.println("手寫springmvc框架..."); return "index"; } }
index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <html> <body> <h2>我的第一個手寫springMVC的程式碼</h2> </body> </html>