如何使用SpringMVC框架

這篇文章主要講解了“如何使用SpringMVC框架”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“如何使用SpringMVC框架”吧！

一、介紹

在日常的 web 開發中，熟悉 java 的同學一定知道，Spring MVC  可以說是目前最流行的框架，之所以如此的流行，原因很簡單：編程簡潔、上手簡單!

我記得剛開始入行的時候，最先接觸到的是Struts1 + Hibernate +  Spring來web系統的整體開發框架，簡單的描述一下當時的編程心情：超難用，各種配置項很多，而且不容易快速入手!

之后，新的項目換成了Struts2 + hibernate +  spring來作為主體開發框架，Struts2相比Struts1編程要簡單很多，而且加強了對攔截器與IoC的支持，而在Struts1中，這些特性是很難做的的!

然而隨著Struts2的使用量越來越廣，業界爆出關于Struts2的bug和安全漏洞卻越來越多!

黑客們可以輕易的利用安全漏洞直接繞開安全防線，獲取用的隱私數據，網名因個人信息泄露造成的經濟損失高達 915 億元!

至此很多開發者開始轉到SpringMVC框架陣營!

今天我們要介紹的主角就是SpringMVC框架，剛開始玩這個的時候，給我最直接的感覺就是：很容易簡單!

直接通過幾個注解就可以完成方法的暴露，比起Struts2中繁瑣的xml配置，SpringMVC的使用可以說更加友好!

熟悉SpringMVC框架的同學一定清楚下面這張圖，

這張圖就是 SpringMVC 在處理 http 請求的整個流程中所做的一些事情。

1、用戶發送請求至前端控制器DispatcherServlet

2、DispatcherServlet收到請求調用HandlerMapping處理器映射器。

3、處理器映射器根據請求url找到具體的處理器，生成處理器對象及處理器攔截器(如果有則生成)一并返回給DispatcherServlet。

4、DispatcherServlet通過HandlerAdapter處理器適配器調用處理器

5、執行處理器(Controller，也叫后端控制器)。

6、Controller執行完成返回ModelAndView

7、HandlerAdapter將controller執行結果ModelAndView返回給DispatcherServlet

8、DispatcherServlet將ModelAndView傳給ViewReslover視圖解析器

9、ViewReslover解析后返回具體View

10、DispatcherServlet對View進行渲染視圖(即將模型數據填充至視圖中)。

11、DispatcherServlet響應用戶。

DispatcherServlet 主要承擔接收請求、響應結果、轉發等作用，剩下的就交給容器來處理!

基于上面的流程，我們可以編寫出一款簡化版的Spring MVC框架，話不多說，直接擼起來!

二、程序實踐

首先上圖!

這個就是我們簡易版的Spring MVC框架的實現流程圖!

1、首先創建一個DispatcherServlet類，在服務啟動的時候，讀取要掃描的包路徑，然后通過反射將類信息存儲到ioc容器，同時通過@Autowired注解，實現自動依賴注入，最后讀取@RequestMapping注解中的方法，將映射路徑與類的關系存儲到映射容器中。

2、當用戶發起請求的時候，通過請求路徑到映射容器中找到對應的執行類，然后調用具體的方法，發起邏輯處理，最后將處理結果返回給前端用戶!

以下是具體實踐過程!

2.1、創建掃描注解

因為Spring MVC基本全部都是基于注解開發，因此我們事先也需要創建對應的注解，各個含義與Spring MVC一致!

/**  * 控制層注解  * @Controller   */ @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Controller {      String value() default ""; }

請求路徑注解

/**  * 請求路徑注解  * @RequestMapping  */ @Target({ElementType.METHOD,ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestMapping {      String value() default ""; }

參數注解

/**  * 參數注解  * @RequestParam  */ @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestParam {      String value() default ""; }

服務層注解

/**  * 服務層注解  * @Controller  */ @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Service {      String value() default ""; }

自動裝載注解

/**  * 自動裝載注解  * @Autowrited  */ @Target({ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Autowired {      String value() default ""; }

2.2、編寫 DispatcherServlet 類

DispatcherServlet是一個Servlet類，主要承擔的任務是：接受前端用戶的請求，然后進行轉發，最后響應結果給前端用戶!

詳細代碼如下：

 * servlet跳轉層  */ @WebServlet(name = "DispatcherServlet",urlPatterns = "/*", loadOnStartup = 1, initParams = {@WebInitParam(name="scanPackage", value="com.example.mvc")}) public class DispatcherServlet extends HttpServlet {      private static final long serialVersionUID = 1L;      private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);      /**請求方法映射容器*/     private static List<RequestHandler> handlerMapping = new ArrayList<>();      /**      * 服務啟動的時候，進行初始化，流程如下：      * 1、掃描指定包下所有的類      * 2、通過反射將類實例，放入ioc容器      * 3、通過Autowired注解，實現自動依賴注入，也就是set類中的屬性      * 4、通過RequestMapping注解，獲取需要映射的所有方法，然后將類信息存放到容器中      * @param config      * @throws ServletException      */     @Override     public void init(ServletConfig config) throws ServletException {         try {             //1、掃描指定包下所有的類             String scanPackage = config.getInitParameter("scanPackage");             //1、掃描指定包下所有的類             List<String> classNames = doScan(scanPackage);             //2、初始化所有類實例，放入ioc容器，也就是map對象中             Map<String, Object> iocMap = doInstance(classNames);             //3、實現自動依賴注入             doAutowired(iocMap);             //5、初始化方法mapping             initHandleMapping(iocMap);         } catch (Exception e) {             logger.error("dispatcher-servlet類初始化失敗!",e);             throw new ServletException(e.getMessage());         }     }       /**      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)      */     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {         doPost(request, response);     }      /**      * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)      */     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {         //跳轉         doDispatch(request, response);     }      /**      * 掃描指定包下的類文件      * @param packageName      * @return      */     private List<String> doScan(String packageName){         if(StringUtils.isBlank(packageName)){             throw new RuntimeException("mvc配置文件中指定掃描包名為空!");         }         return PackageHelper.getClassName(packageName);     }      private Map<String, Object> doInstance(List<String> classNames) {         Map<String, Object> iocMap = new HashMap<>();         if(!CollectionUtils.isNotEmpty(classNames)){             throw new RuntimeException("獲取的類為空!");         }         for (String className : classNames) {             try {                 //通過反射機制構造對象                 Class<?> clazz = Class.forName(className);                 if(clazz.isAnnotationPresent(Controller.class)){                     //將類名第一個字母小寫                     String baneName = firstLowerCase(clazz.getSimpleName());                     iocMap.put(baneName, clazz.newInstance());                 }else if(clazz.isAnnotationPresent(Service.class)){                     //服務層注解判斷                     Service service = clazz.getAnnotation(Service.class);                     String beanName = service.value();                     //如果該注解上沒有自定義類名，則默認首字母小寫                     if(StringUtils.isBlank(beanName)){                         beanName = clazz.getName();                     }                     Object instance = clazz.newInstance();                     iocMap.put(beanName, instance);                     //如果注入的是接口，可以巧妙的用接口的類型作為key                     Class<?>[] interfaces = clazz.getInterfaces();                     for (Class<?> clazzInterface : interfaces) {                         iocMap.put(clazzInterface.getName(), instance);                     }                 }             } catch (Exception e) {                 logger.error("初始化mvc-ioc容器失敗!",e);                 throw new RuntimeException("初始化mvc-ioc容器失敗!");             }         }         return iocMap;     }      /**      * 實現自動依賴注入      * @throws Exception      */     private void doAutowired(Map<String, Object> iocMap) {         if(!MapUtils.isNotEmpty(iocMap)){             throw new RuntimeException("初始化實現自動依賴失敗，ioc為空!");         }         for(Map.Entry<String, Object> entry : iocMap.entrySet()){             //獲取對象下所有的屬性             Field[] fields = entry.getValue().getClass().getDeclaredFields();             for (Field field : fields) {                 //判斷字段上有沒有@Autowried注解，有的話才注入                 if(field.isAnnotationPresent(Autowired.class)){                     try {                         Autowired autowired = field.getAnnotation(Autowired.class);                         //獲取注解上有沒有自定義值                         String beanName = autowired.value().trim();                         if(StringUtils.isBlank(beanName)){                             beanName = field.getType().getName();                         }                         //如果想要訪問到私有的屬性，我們要強制授權                         field.setAccessible(true);                         field.set(entry.getValue(), iocMap.get(beanName));                     } catch (Exception e) {                         logger.error("初始化實現自動依賴注入失敗!",e);                         throw new RuntimeException("初始化實現自動依賴注入失敗");                     }                 }             }         }     }      /**      * 初始化方法mapping      */     private void initHandleMapping(Map<String, Object> iocMap){         if(!MapUtils.isNotEmpty(iocMap)){             throw new RuntimeException("初始化實現自動依賴失敗，ioc為空");         }         for(Map.Entry<String, Object> entry:iocMap.entrySet()){             Class<?> clazz = entry.getValue().getClass();             //判斷是否是controller層             if(!clazz.isAnnotationPresent(Controller.class)){                 continue;             }             String baseUrl = null;             //判斷類有沒有requestMapping注解             if(clazz.isAnnotationPresent(RequestMapping.class)){                 RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);                 baseUrl= requestMapping.value();             }             Method[] methods = clazz.getMethods();             for (Method method : methods) {                 //判斷方法上有沒有requestMapping                 if(!method.isAnnotationPresent(RequestMapping.class)){                     continue;                 }                 RequestMapping requestMethodMapping = method.getAnnotation(RequestMapping.class);                 //"/+",表示將多個"/"轉換成"/"                 String regex = (baseUrl + requestMethodMapping.value()).replaceAll("/+", "/");                 Pattern pattern = Pattern.compile(regex);                 handlerMapping.add(new RequestHandler(pattern, entry.getValue(), method));             }         }     }      /**      * servlet請求跳轉      * @param request      * @param response      * @throws IOException      */     private void doDispatch(HttpServletRequest request, HttpServletResponse response) throws IOException {         try {             request.setCharacterEncoding("UTF-8");             response.setHeader("Cache-Control", "no-cache");             response.setHeader("Pragma", "no-cache");             response.setDateHeader("Expires", -1);             response.setContentType("text/html");             response.setHeader("content-type", "text/html;charset=UTF-8");             response.setCharacterEncoding("UTF-8");             RequestHandler handle = getHandleMapping(request);             if(Objects.isNull(handle)){                 //異常請求地址                 logger.warn("異常請求地址!地址:" + request.getRequestURI());                 response.getWriter().append("error request url");                 return;             }             //獲取參數列表             Object[] paramValues = RequestParamHelper.buildRequestParam(handle, request, response);             Object result = handle.getMethod().invoke(handle.getController(), paramValues);             if(result != null){                 PrintWriter out = response.getWriter();                 out.println(result);                 out.flush();                 out.close();             }         } catch (Exception e) {             logger.error("接口請求失敗!",e);             PrintWriter out = response.getWriter();             out.println("請求異常,請稍后再試");             out.flush();             out.close();         }     }      /**      * 將類名第一個字母小寫      * @param clazzName      * @return      */     private String firstLowerCase(String clazzName){         char[] chars = clazzName.toCharArray();         chars[0] += 32;         return String.valueOf(chars);     }       /**      * 獲取用戶請求方法名      * 與handlerMapping中的路徑名進行匹配      * @param request      * @return      */     private RequestHandler getHandleMapping(HttpServletRequest request){         if(CollectionUtils.isNotEmpty(handlerMapping)){             //獲取用戶請求路徑             String url = request.getRequestURI();             String contextPath = request.getContextPath();             String serviceUrl = url.replace(contextPath, "").replaceAll("/+", "/");             for (RequestHandler handle : handlerMapping) {                 //正則匹配請求方法名                 Matcher matcher = handle.getPattern().matcher(serviceUrl);                 if(matcher.matches()){                     return handle;                 }             }         }         return null;     } }

這里要重點介紹一下初始化階段所做的操作!

DispatcherServlet在服務啟動階段，會調用init方法進行服務初始化，此階段所做的事情主要有以下內容：

1、掃描指定包下所有的類信息，返回的結果主要是包名 + 類名

2、通過反射機制，將類進行實例化，將類實例化對象存儲到ioc容器中，其中key是類名(小些駝峰)，value是類對象

3、通過Autowired注解找到類對象中的屬性，通過小駝峰從ioc容器中尋找對應的屬性值，然后進行set操作

4、通過Controller和RequestMapping注解尋找需要暴露的方法，并獲取對應的映射路徑，最后將映射路徑

5、最后，當前端用戶發起一個請求時，DispatcherServlet獲取到請求路徑之后，通過與RequestMapping中的路徑進行匹配，找到對應的controller類中的方法，然后通過invoke完成方法調用，將調用結果返回給前端!

2.3、編寫 controller 類

當DispatcherServlet編寫完成之后，緊接著我們需要編寫對應的controller控制類來接受前端用戶請求，下面我們以用戶登錄為例，程序示例如下：

編寫一個LoginController控制類，接受前端用戶調用

@Controller @RequestMapping("/user") public class LoginController {      @Autowired     private UserService userService;      /**      * 用戶登錄      * @param request      * @param response      * @param userName      * @param userPwd      * @return      */     @RequestMapping("/login")     public String login(HttpServletRequest request, HttpServletResponse response,                         @RequestParam("userName") String userName,                         @RequestParam("userPwd") String userPwd){         boolean result = userService.login(userName, userPwd);         if(result){             return "登錄成功！";         } else {             return "登錄失敗！";         }     } }

編寫一個UserService服務類，用于判斷賬戶、密碼是否正確

public interface UserService {      /**      * 登錄      * @param userName      * @param userPwd      * @return      */     boolean login(String userName, String userPwd); }

@Service public class UserServiceImpl implements UserService {      @Override     public boolean login(String userName, String userPwd) {         if("zhangsan".equals(userName) && "123456".equals(userPwd)){             return true;         } else {             return false;         }     } }

最后，將項目打包成war，通過tomcat啟動服務!

在瀏覽器中訪問http://localhost:8080/user/login?userName=hello&userPwd=123，結果顯示如下：

當我們將userName和userPwd換成正確的數據，訪問地址如下：http://localhost:8080/user/login?userName=zhangsan&userPwd=123456

可以很清晰的看到，服務調用正常!

感謝各位的閱讀，以上就是“如何使用SpringMVC框架”的內容了，經過本文的學習后，相信大家對如何使用SpringMVC框架這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！