SpringMVC完整版詳解

来源:https://www.cnblogs.com/twq46/archive/2022/08/26/16601237.html
-Advertisement-
Play Games

本文講解了什麼是SpringMVC,詳解第一個MVC程式,restFul和控制器講解,數據處理及跳轉,JSON交互處理,SSM框架的整合,Ajax詳解以及攔截器的講解都在此文章里 ...


1.回顧MVC

1.1什麼是MVC

  • MVC是模型(Model)、視圖(View)、控制器(Controller)的簡寫,是一種軟體設計規範。

  • 是將業務邏輯、數據、顯示分離的方法來組織代碼。

  • MVC主要作用是降低了視圖與業務邏輯間的雙向偶合。

  • MVC不是一種設計模式,MVC是一種架構模式。當然不同的MVC存在差異。

Model(模型):數據模型,提供要展示的數據,因此包含數據和行為,可以認為是領域模型或JavaBean組件(包含數據和行為),不過現在一般都分離開來:Value Object(數據Dao) 和 服務層(行為Service)。也就是模型提供了模型數據查詢和模型數據的狀態更新等功能,包括數據和業務。

View(視圖):負責進行模型的展示,一般就是我們見到的用戶界面,客戶想看到的東西。

Controller(控制器):接收用戶請求,委托給模型進行處理(狀態改變),處理完畢後把返回的模型數據返回給視圖,由視圖負責展示。也就是說控制器做了個調度員的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

1.2Model1時代

  • 在web早期的開發中,通常採用的都是Model1。

  • Model1中,主要分為兩層,視圖層和模型層。

Model1優點:架構簡單,比較適合小型項目開發;

Model1缺點:JSP職責不單一,職責過重,不便於維護;

1.3Model2時代

Model2把一個項目分成三部分,包括視圖、控制、模型。

  • 用戶發請求

  • Servlet接收請求數據,並調用對應的業務邏輯方法

  • 業務處理完畢,返回更新後的數據給servlet

  • servlet轉向到JSP,由JSP來渲染頁面

  • 響應給前端更新後的頁面

職責分析:

Controller:控制器

  • 取得表單數據

  • 調用業務邏輯

  • 轉向指定的頁面

Model:模型

  • 業務邏輯

  • 保存數據的狀態

View:視圖

  • 顯示頁面

Model2這樣不僅提高的代碼的復用率與項目的擴展性,且大大降低了項目的維護成本。Model 1模式的實現比較簡單,適用於快速開發小規模項目,Model1中JSP頁面身兼View和Controller兩種角色,將控制邏輯和表現邏輯混雜在一起,從而導致代碼的重用性非常低,增加了應用的擴展性和維護的難度。Model2消除了Model1的缺點。

1.4回顧Servlet

1.4.1新建Maven導入依賴

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.22</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

1.4.2 建子項目

為子項目添加Web

1.4.3 編寫一個Servlet類

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.獲取前端參數
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","執行了add方法");
        }
        if(method.equals("delete")){
            req.getSession().setAttribute("msg","執行了delete方法");

        }
        //2.調用業務層

        //3.視圖轉發或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

1.4.4 編寫Hello.jsp

在WEB-INF目錄下新建一個jsp的文件夾,新建test.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>Kuangshen</title>
</head>
<body>
${msg}
</body>
</html>

1.4.5 web.xml中註冊Servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.tang.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>


</web-app>

1.4.5編寫form.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/hello" method="post">
    <input type="text" name="method">
    <input type="submit" name="method">
</form>
</body>
</html>

1.4.6配置Tomcat,並啟動測試

*http://localhost:8080/SpringMVC_01_servlet_war_exploded/hello?method=delete

1.5MVC框架要做的事情

  • 將url映射到java類或java類的方法 .

  • 封裝用戶提交的數據 .

  • 處理請求--調用相關的業務處理--封裝響應數據 .

  • 將響應的數據進行渲染 . jsp / html 等表示層數據

說明:

常見的伺服器端MVC框架有:Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF;常見前端MVC框架:vue、angularjs、react、backbone;由MVC演化出了另外一些模式如:MVP、MVVM 等等....

2.什麼是SpringMVC

2.1、概述

Spring MVC是Spring Framework的一部分,是基於Java實現MVC的輕量級Web框架。

查看官方文檔:https://docs.spring.io/spring-framework/docs/4.3.24.RELEASE/spring-framework-reference/html/

我們為什麼要學習SpringMVC呢?

Spring MVC的特點:

  • 輕量級,簡單易學

  • 高效 , 基於請求響應的MVC框架

  • 與Spring相容性好,無縫結合

  • 約定優於配置

  • 功能強大:RESTful、數據驗證、格式化、本地化、主題等

  • 簡潔靈活

Spring的web框架圍繞DispatcherServlet [ 調度Servlet ] 設計。

DispatcherServlet的作用是將請求分發到不同的處理器。從Spring 2.5開始,使用Java 5或者以上版本的用戶可以採用基於註解形式進行開發,十分簡潔;

正因為SpringMVC好 , 簡單 , 便捷 , 易學 , 天生和Spring無縫集成(使用SpringIoC和Aop) , 使用約定優於配置 . 能夠進行簡單的junit測試 . 支持Restful風格 .異常處理 , 本地化 , 國際化 , 數據驗證 , 類型轉換 , 攔截器 等等......所以我們要學習 .

最重要的一點還是用的人多 , 使用的公司多 .

2.2、中心控制器

Spring的web框架圍繞DispatcherServlet設計。DispatcherServlet的作用是將請求分發到不同的處理器。從Spring 2.5開始,使用Java 5或者以上版本的用戶可以採用基於註解的controller聲明方式。

Spring MVC框架像許多其他MVC框架一樣, 以請求為驅動 , 圍繞一個中心Servlet分派請求及提供其他功能,DispatcherServlet是一個實際的Servlet (它繼承自HttpServlet 基類)。

SpringMVC的原理如下圖所示:

當發起請求時被前置的控制器攔截到請求,根據請求參數生成代理請求,找到請求對應的實際控制器,控制器處理請求,創建數據模型,訪問資料庫,將模型響應給中心控制器,控制器使用模型與視圖渲染視圖結果,將結果返回給中心控制器,再將結果返回給請求者。

2.3、SpringMVC執行原理


圖為SpringMVC的一個較完整的流程圖,實線表示SpringMVC框架提供的技術,不需要開發者實現,虛線表示需要開發者實現。

簡要分析執行流程

  • DispatcherServlet表示前置控制器,是整個SpringMVC的控制中心。用戶 發出請求,DispatcherServlet接收請求並攔截請求。

    我們假設請求的url為 : http://localhost:8080/SpringMVC/hello

    如上url拆分成三部分:

    http://localhost:8080伺服器功能變數名稱

    SpringMVC部署在伺服器上的web站點

    hello表示控制器

    通過分析,如上url表示為:請求位於伺服器localhost:8080上的SpringMVC站點的hello控制器。

  • HandlerMapping為處理器映射。DispatcherServlet調用 HandlerMapping,HandlerMapping根據請求url查找Handler。

  • HandlerExecution表示具體的Handler,其主要作用是根據url查找控制器,如上url被查找控制器為:hello。

  • HandlerExecution將解析後的信息傳遞給DispatcherServlet,如解析控制器映射等。

  • HandlerAdapter表示處理器適配器,其按照特定的規則去執行Handler。

  • Handler讓具體的Controller執行。

  • Controller將具體的執行信息返回給HandlerAdapter,如ModelAndView。

  • HandlerAdapter將視圖邏輯名或模型傳遞給DispatcherServlet。

  • DispatcherServlet調用視圖解析器(ViewResolver)來解析HandlerAdapter傳遞的邏輯視圖名。

  • 視圖解析器將解析的邏輯視圖名傳給DispatcherServlet。

  • DispatcherServlet根據視圖解析器解析的視圖結果,調用具體的視圖。

  • 最終視圖呈現給用戶。

在這裡先聽一遍原理,不理解沒有關係,我們馬上來寫一個對應的代碼實現大家就明白了,如果不明白,那就寫10遍,沒有笨人,只有懶人!

3.第一個MVC程式

3.1、配置版

  • 新建一個Moudle ,SpringMVC-02-hellomvc , 添加web的支持!

  • 確定導入了SpringMVC 的依賴!

  • 配置web.xml , 註冊DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--1.註冊DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--關聯一個springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--啟動級別-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的請求;(不包括.jsp)-->
    <!--/* 匹配所有的請求;(包括.jsp)-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>
  • 編寫SpringMVC 的 配置文件!名稱:springmvc-servlet.xml
    說明,這裡的名稱要求是按照官方來的

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      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">

</beans>
  • 在springmvc-servlet.xml 添加 處理映射器
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
  • 繼續添加添加 處理器適配器

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
  • 繼續添加 視圖解析器

<!--視圖解析器:DispatcherServlet給他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
   <!--首碼-->
   <property name="prefix" value="/WEB-INF/jsp/"/>
   <!--尾碼-->
   <property name="suffix" value=".jsp"/>
</bean>
  • 編寫我們要操作業務Controller ,要麼實現Controller介面,要麼增加註解;需要返回一個ModelAndView,裝數據,封視圖;
//註意:這裡我們先導入Controller介面
public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和視圖
        ModelAndView mv = new ModelAndView();

        //封裝對象,放在ModelAndView中。Model
        mv.addObject("msg", "HelloSpringMVC!");
        //封裝要跳轉的視圖,放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}
  • 將自己的類交給SpringIOC容器,註冊bean
<!--Handler-->
<bean id="/hello" class="com.kuang.controller.HelloController"/>
  • 寫要跳轉的jsp頁面,顯示ModelandView存放的數據,以及我們的正常頁面;
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

${msg}
</body>
</html>
  • 配置Tomcat 啟動測試!

可能遇到的問題:訪問出現404,排查步驟:

  • 查看控制台輸出,看一下是不是缺少了什麼jar包。

  • 如果jar包存在,顯示無法輸出,就在IDEA的項目發佈中,添加lib依賴!

  • 重啟Tomcat 即可解決!

小結:看這個估計大部分同學都能理解其中的原理了,但是我們實際開發才不會這麼寫,不然就瘋了,還學這個玩意幹嘛!我們來看個註解版實現,這才是SpringMVC的精髓,到底有多麼簡單,看這個圖就知道了

3.2、註解版

  • 新建一個Moudle,SpringMVC-03-annotation 。添加web支持!

  • 由於Maven可能存在資源過濾的問題,我們將配置完善

  • 配置web.xml

    
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
            version="4.0">
    
       <!--1.註冊servlet-->
       <servlet>
           <servlet-name>SpringMVC</servlet-name>
           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
           <!--通過初始化參數指定SpringMVC配置文件的位置,進行關聯-->
           <init-param>
               <param-name>contextConfigLocation</param-name>
               <param-value>classpath:springmvc-servlet.xml</param-value>
           </init-param>
           <!-- 啟動順序,數字越小,啟動越早 -->
           <load-on-startup>1</load-on-startup>
       </servlet>
    
       <!--所有請求都會被springmvc攔截 -->
       <servlet-mapping>
           <servlet-name>SpringMVC</servlet-name>
           <url-pattern>/</url-pattern>
       </servlet-mapping>
    
    </web-app>
    
  • 添加Spring MVC配置文件

    
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:mvc="http://www.springframework.org/schema/mvc"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/mvc
           https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
       <!-- 自動掃描包,讓指定包下的註解生效,由IOC容器統一管理 -->
       <context:component-scan base-package="com.tang.controller"/>
       <!-- 讓Spring MVC不處理靜態資源 -->
       <mvc:default-servlet-handler />
       <!--
       支持mvc註解驅動
           在spring中一般採用@RequestMapping註解來完成映射關係
           要想使@RequestMapping註解生效
           必須向上下文中註冊DefaultAnnotationHandlerMapping
           和一個AnnotationMethodHandlerAdapter實例
           這兩個實例分別在類級別和方法級別處理。
           而annotation-driven配置幫助我們自動完成上述兩個實例的註入。
        -->
       <mvc:annotation-driven />
    
       <!-- 視圖解析器 -->
       <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
             id="internalResourceViewResolver">
           <!-- 首碼 -->
           <property name="prefix" value="/WEB-INF/jsp/" />
           <!-- 尾碼 -->
           <property name="suffix" value=".jsp" />
       </bean>
    
    </beans>
    
    
  • 創建Controller
    編寫一個Java控制類:com.kuang.controller.HelloController , 註意編碼規範

    @Controller
    public class HelloController {
    
        //真實訪問地址 : 項目名/h1
        @RequestMapping("/h1")
        public String sayHello(Model model){
            //向模型中添加屬性msg與值,可以在JSP頁面中取出並渲染
            model.addAttribute("msg","hello,SpringMVC");
            //web-inf/jsp/hello.jsp
            return "hello";
        }
    }
    
    • @Controller是為了讓Spring IOC容器初始化時自動掃描到;

    • @RequestMapping是為了映射請求路徑,這裡因為類與方法上都有映射所以訪問時應該是/HelloController/hello;

  • 方法中聲明Model類型的參數是為了把Action中的數據帶到視圖中;

  • 方法返回的結果是視圖的名稱hello,加上配置文件中的前尾碼變成WEB-INF/jsp/hello.jsp。

創建視圖層
在WEB-INF/ jsp目錄中創建hello.jsp , 視圖可以直接取出並展示從Controller帶回的信息;

可以通過EL表示取出Model中存放的值,或者對象;


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>SpringMVC</title>
</head>
<body>
${msg}
</body>
</html>

測試結果圖

  • 小結

    • 實現步驟其實非常的簡單:

    • 新建一個web項目

    • 導入相關jar包

    • 編寫web.xml , 註冊DispatcherServlet

    • 編寫springmvc配置文件

    • 接下來就是去創建對應的控制類 , controller

    • 最後完善前端視圖和controller之間的對應

    測試運行調試.

    使用springMVC必須配置的三大件:

    處理器映射器、處理器適配器、視圖解析器

    通常,我們只需要手動配置視圖解析器,而處理器映射器和處理器適配器只需要開啟註解驅動即可,而省去了大段的xml配置

4.控制器controller

  • 控制器複雜提供訪問應用程式的行為,通常通過介面定義或註解定義兩種方法實現。

  • 控制器負責解析用戶的請求並將其轉換為一個模型。

  • 在Spring MVC中一個控制器類可以包含多個方法

  • 在Spring MVC中,對於Controller的配置方式有很多種

4.1實現Controller介面

Controller是一個介面,在org.springframework.web.servlet.mvc包下,介面中只有一個方法; 測試
  1. 新建一個Moudle,SpringMVC-04-controller 。將剛纔的03 拷貝一份, 我們進行操作!
  • 刪掉HelloController

  • mvc的配置文件只留下 視圖解析器!

編寫一個Controller類,ControllerTest1

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");

        return mv;
    }
}
  1. 編寫完畢後,去Spring配置文件中註冊請求的bean;name對應請求路徑,class對應處理請求的類
<bean name="/t1" class="com.tang.controlller.ControllerTest1"></bean>
  1. 編寫前端test.jsp,註意在WEB-INF/jsp目錄下編寫,對應我們的視圖解析器
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

配置Tomcat運行測試,我這裡沒有項目發佈名配置的就是一個 / ,所以請求不用加項目名,OK!

4.2使用註解@Controller

  • @Controller註解類型用於聲明Spring類的實例是一個控制器(在講IOC時還提到了另外3個註解);

  • Spring可以使用掃描機制來找到應用程式中所有基於註解的控制器類,為了保證Spring能找到你的控制器,需要在配置文件中聲明組件掃描。

<!-- 自動掃描包,讓指定包下的註解生效,由IOC容器統一管理 -->
<context:component-scan base-package="com.tang.controller"/>
  • 增加一個ControllerTest2類,使用註解實現;
@Controller
public class ControllerTest2 {
    //映射訪問路徑
    @RequestMapping("/t2")
    public String test(Model model){
        //Spring MVC會自動實例化一個Model對象用於向視圖中傳值
        model.addAttribute("msg","ControllerTest2");
        //返回視圖位置
        return "test";
    }
}

運行tomcat測試


可以發現,我們的兩個請求都可以指向一個視圖,但是頁面結果的結果是不一樣的,從這裡可以看出視圖是被覆用的,而控制器與視圖之間是弱偶合關係。

註解方式是平時使用的最多的方式!

4.3RestFul風格

概念

Restful就是一個資源定位及資源操作的風格。不是標準也不是協議,只是一種風格。基於這個風格設計的軟體可以更簡潔,更有層次,更易於實現緩存等機制。

功能

資源:互聯網所有的事物都可以被抽象為資源

資源操作:使用POST、DELETE、PUT、GET,使用不同方法對資源進行操作。

分別對應 添加、 刪除、修改、查詢。

傳統方式操作資源 :通過不同的參數來實現不同的效果!方法單一,post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查詢,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 刪除,GET或POST

使用RESTful操作資源 :可以通過不同的請求方式來實現不同的效果!如下:請求地址一樣,但是功能可以不同!

http://127.0.0.1/item/1 查詢,GET

http://127.0.0.1/item 新增,POST

http://127.0.0.1/item 更新,PUT

http://127.0.0.1/item/1 刪除,DELETE

學習測試

在新建一個類 RestFulController

4.4結果跳轉方式

通過SpringMVC來實現轉發和重定向 - 無需視圖解析器;
測試前,需要將視圖解析器註釋掉

@Controller
public class ResultSpringMVC {
   @RequestMapping("/rsm/t1")
   public String test1(){
       //轉發
       return "/index.jsp";
  }

   @RequestMapping("/rsm/t2")
   public String test2(){
       //轉發二
       return "forward:/index.jsp";
  }

   @RequestMapping("/rsm/t3")
   public String test3(){
       //重定向
       return "redirect:/index.jsp";
  }
}

通過SpringMVC來實現轉發和重定向 - 有視圖解析器;

重定向 , 不需要視圖解析器 , 本質就是重新請求一個新地方嘛 , 所以註意路徑問題.

可以重定向到另外一個請求實現 .

@Controller
public class ResultSpringMVC2 {
   @RequestMapping("/rsm2/t1")
   public String test1(){
       //轉發
       return "test";
  }

   @RequestMapping("/rsm2/t2")
   public String test2(){
       //重定向
       return "redirect:/index.jsp";
       //return "redirect:hello.do"; //hello.do為另一個請求/
  }

}

4.5數據處理

處理提交數據

4.5.1提交的功能變數名稱稱和處理方法的參數名一致

提交數據 : http://localhost:8080/SpringMVC_04_controller_war_exploded/user/t1?name=Twq

處理方法 :

@RequestMapping("/user")
public class UserController {


    @GetMapping("/t1")
    public String test1(String name,Model model){

        //1.接收前端參數
        System.out.println("接收到的前端的參數為:" +name);

        //2.返回的結果傳遞給前端
        model.addAttribute("msg",name);

        //3.視圖跳轉
        return "test";
    }

}

4.5.2提交的功能變數名稱稱和處理方法的參數名不一致

4.5.3提交的功能變數名稱稱和處理方法的參數名不一致

@Controller
@RequestMapping("/user")
public class UserController {


    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){

        //1.接收前端參數
        System.out.println("接收到的前端的參數為:" +name);

        //2.返回的結果傳遞給前端
        model.addAttribute("msg",name);

        //3.視圖跳轉
        return "test";
    }

}

4.5.4提交的是一個對象

要求提交的表單域和對象的屬性名一致 , 參數使用對象即可
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

測試代碼

//前端接受的是一個對象:id,name,age

  /*
  1.接收前端用戶傳的參數,判斷參數的名字,假設名字直接在方法上,可以直接使用
  2.假設出阿尼的是一個對象User,匹配User對象中的欄位名:如果名字一致則OK,否則,匹配不到

   */
  @GetMapping("/t2")
  public String test2(User user){
      System.out.println(user);
      return "test";
  }

4.6亂碼問題解決

@Controller
public class EncodingController {
    @PostMapping("e1/t1")
    public String test(String name,Model model){

        model.addAttribute("msg",name);
        return "test";
    }
}

提交界面

<body>

<form action="e1/t1" method="post">
   用戶名 <input type="text" name="name">
    <input type="submit">
</form>
</body>

測試結果


解決方法
在web.xml中配置SpringMVC的亂碼的過濾

<!--配置SpringMVC的亂碼過濾 -->
<filter>
    <filter-name>encoding</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>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

在啟動Tomcat測試


如果以上方法還是解決不了,可以自定義以下過濾器,以下代碼建議全部複製,如果讓IDEA自動導包的話可能會倒錯包,以下代碼為網上大牛寫的,實在不行的情況下建議使用

package com.tang.filter;//這一行除外,根據自己的包名寫

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * 解決get和post請求 全部亂碼的過濾器
 */
public class GenericEncodingFilter implements Filter {


    public void destroy() {
    }


    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //處理response的字元編碼
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");

        // 轉型為與協議相關對象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 對request包裝增強
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }


    public void init(FilterConfig filterConfig) throws ServletException {
    }

}

//自定義request對象,HttpServletRequest的包裝類
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;
    //是否編碼的標記
    private boolean hasEncode;
    //定義一個可以傳入HttpServletRequest對象的構造函數,以便對其進行裝飾
    public MyRequest(HttpServletRequest request) {
        super(request);// super必須寫
        this.request = request;
    }

    // 對需要增強方法 進行覆蓋
    @Override
    public Map getParameterMap() {
        // 先獲得請求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post請求
            try {
                // 處理post亂碼
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get請求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 確保get手動編碼邏輯只運行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 處理get亂碼
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }

    //取一個值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回參數的第一個值
    }

    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

web.xml註冊該過濾器

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.tang.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

6.JSON

6.1什麼是JSON

  • JSON(JavaScript Object Notation, JS 對象標記) 是一種輕量級的數據交換格式,目前使用特別廣泛。

  • 採用完全獨立於編程語言的文本格式來存儲和表示數據。

  • 簡潔和清晰的層次結構使得 JSON 成為理想的數據交換語言。

  • 易於人閱讀和編寫,同時也易於機器解析和生成,並有效地提升網路傳輸效率。

在 JavaScript 語言中,一切都是對象。因此,任何JavaScript 支持的類型都可以通過 JSON 來表示,例如字元串、數字、對象、數組等。看看他的要求和語法格式:

  • 對象表示為鍵值對,數據由逗號分隔

  • 花括弧保存對象

  • 方括弧保存數組

JSON 鍵值對是用來保存 JavaScript 對象的一種方式,和 JavaScript 對象的寫法也大同小異,鍵/值對組合中的鍵名寫在前面並用雙引號 "" 包裹,使用冒號 : 分隔,然後緊接著值:

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 對象的關係,甚至連誰是誰都不清楚。其實,可以這麼理解:

JSON 是 JavaScript 對象的字元串表示法,它使用文本表示一個 JS 對象的信息,本質是一個字元串。

var obj = {a: 'Hello',
 b: 'World'}; //這是一個對象,註意鍵名也是可以使用引號包裹的

var json = '{"a": "Hello", 
"b": "World"}'; //這是一個 JSON 字元串,本質是一個字元串

JSON 和 JavaScript 對象互轉
要實現從JSON字元串轉換為JavaScript 對象,使用 JSON.parse() 方法:

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//結果是 {a: 'Hello', b: 'World'}

要實現從JavaScript 對象轉換為JSON字元串,使用 JSON.stringify() 方法:

var json = JSON.stringify({a: 'Hello', b: 'World'});
//結果是 '{"a": "Hello", "b": "World"}'

代碼測試

  • 新建一個module ,springmvc-05-json , 添加web的支持

  • 在web目錄下新建一個 json-1.html , 編寫測試內容

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>JSON</title>
</head>
<body>

<script type="text/javascript">
   //編寫一個js的對象
   var user = {
       name:"唐昊",
       age:21,
       sex:"男"
  };
   //將js對象轉換成json字元串
   var str = JSON.stringify(user);
   console.log(str);
   
   //將json字元串轉換為js對象
   var user2 = JSON.parse(str);
   console.log(user2.age,user2.name,user2.sex);

</script>

</body>
</html>

6.2Jackson使用

Jackson應該是目前比較好的json解析工具了

當然工具不止這一個,比如還有阿裡巴巴的 fastjson 等等。

我們這裡使用Jackson,使用它需要導入它的jar包;

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

配置SpringMVC需要的配置

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0">

   <!--1.註冊servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通過初始化參數指定SpringMVC配置文件的位置,進行關聯-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!-- 啟動順序,數字越小,啟動越早 -->
       <load-on-startup>1</load-on-startup>
   </servlet>

   <!--所有請求都會被springmvc攔截 -->
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

   <filter>
       <filter-name>encoding</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>
   </filter>
   <filter-mapping>
       <filter-name>encoding</filter-name>
       <url-pattern>/</url-pattern>
   </filter-mapping>

</web-app>

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自動掃描指定的包,下麵所有註解類交給IOC容器管理 -->
    <context:component-scan base-package="com.tang.controller"/>

    <context:annotation-config />
    <mvc:annotation-driven />
    <!-- 視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 首碼 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 尾碼 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

這裡我們需要兩個新東西,一個是@ResponseBody,一個是ObjectMapper對象,我們看下具體的用法

編寫一個Controller;

package com.tang.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @RequestMapping("/j1")
    @ResponseBody
    public String test() throws JsonProcessingException {

        ObjectMapper mapper = new ObjectMapper();

        User user = new User("唐三", 2, "女");

        String str = mapper.writeValueAsString(user);
        return str;
    }
}


實體類

package com.tang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}  

發現出現了亂碼問題,我們需要設置一下他的編碼格式為utf-8,以及它返回的類型;

通過@RequestMaping的produces屬性來實現,修改下代碼

//produces:指定響應體返回類型和編碼
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

再次測試發現亂碼問題解決

亂碼統一解決

上一種方法比較麻煩,如果項目中有許多請求則每一個都要添加,可以通過Spring配置統一指定,這樣就不用每次都去處理了!

我們可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter轉換配置!

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

返回json字元串統一解決

在類上直接使用 @RestController ,這樣子,裡面所有的方法都只會返回 json 字元串了,不用再每一個都添加@ResponseBody !我們在前後端分離開發中,一般都使用 @RestController ,十分便捷!

@RestController
public class UserController {

   //produces:指定響應體返回類型和編碼
   @RequestMapping(value = "/json1")
   public String json1() throws JsonProcessingException {
       //創建一個jackson的對象映射器,用來解析數據
       ObjectMapper mapper = new ObjectMapper();
       //創建一個對象
       User user = new User("秦疆1號", 3, "男");
       //將我們的對象解析成為json格式
       String str = mapper.writeValueAsString(user);
       //由於@ResponseBody註解,這裡會將str轉成json格式返回;十分方便
       return str;
  }

}

6.3fastjson

fastjson.jar是阿裡開發的一款專門用於Java開發的包,可以方便的實現json對象與JavaBean對象的轉換,實現JavaBean對象與json字元串的轉換,實現json對象與json字元串的轉換。實現json的轉換方法很多,最後的實現結果都是一樣的。

fastjson 的 pom依賴!

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.60</version>
</dependency>

fastjson 三個主要的類:

  • JSONObject 代表 json 對象

    • JSONObject實現了Map介面, 猜想 JSONObject底層操作是由Map實現的。

    • JSONObject對應json對象,通過各種形式的get()方法可以獲取json對象中的數據,也可利用諸如size(),isEmpty()等方法獲取"鍵:值"對的個數和判斷是否為空。其本質是通過實現Map介面並調用介面中的方法完成的。

  • JSONArray 代表 json 對象數組

    • 內部是有List介面中的方法來完成操作的。
  • JSON代表 JSONObject和JSONArray的轉化

    • JSON類源碼分析與使用

    • 仔細觀察這些方法,主要是實現json對象,json對象數組,javabean對象,json字元串之間的相互轉化。

package com.tang.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kuang.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonDemo {
   public static void main(String[] args) {
       //創建一個對象
       User user1 = new User("唐昊1號", 3, "男");
       User user2 = new User("唐昊2號", 3, "男");
       User user3 = new User("唐昊3號", 3, "男");
       User user4 = new User("唐昊4號", 3, "男");
       List<User> list = new ArrayList<User>();
       list.add(user1);
       list.add(user2);
       list.add(user3);
       list.add(user4);

       System.out.println("*******Java對象 轉 JSON字元串*******");
       String str1 = JSON.toJSONString(list);
       System.out.println("JSON.toJSONString(list)==>"+str1);
       String str2 = JSON.toJSONString(user1);
       System.out.println("JSON.toJSONString(user1)==>"+str2);

       System.out.println("\n****** JSON字元串 轉 Java對象*******");
       User jp_user1=JSON.parseObject(str2,User.class);
       System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

       System.out.println("\n****** Java對象 轉 JSON對象 ******");
       JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
       System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

       System.out.println("\n****** JSON對象 轉 Java對象 ******");
       User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
       System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
  }
}

7.SSM整合

導入依賴
<?xml version="1.0" encoding="UTF-8" ?>

<!--maven的版本和頭文件-->
<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>org.example </groupId>
    <artifactId>SSMBuild</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--    建立父子關係時,父類的打包方式必須是pom,而且必須聲明-->
    <packaging>pom</packaging>
    <dependencies>
        <!--Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <!--資料庫驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!-- 資料庫連接池 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>

        <!--Servlet - JSP -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--Mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>

        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.22</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

7.1Mybatis層

項目結構圖

7.1.1編寫db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai

jdbc.username=root
jdbc.password=root123456

7.1.2IDEA關聯資料庫

7.1.3編寫MyBatis的核心配置文件

mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.tang.pojo"/>
    </typeAliases>

    <mappers>
        <mapper class="com.tang.dao.BookMapper"/>
    </mappers>
</configuration>

7.1.4.編寫實體類

Books
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {

    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

}

7.1.5編寫Dao層的 Mapper介面!

public interface BookMapper {

    //增加一本書
    int addBook(Books books);

    //刪除一本書
    int deleteBookById(@Param("bookId") int id);

    //更新一本書
    int updateBook(Books books);

    //查詢一本書
    Books queryBookById(@Param("bookId") int id);

    //查詢全部的書
    List<Books> queryAllBook();
}

7.1.6編寫介面對應的 Mapper.xml 文件

需要導入MyBatis的包; BookMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tang.dao.BookMapper">
    <!--增加一本Book-->
    <insert id="addBook" parameterType="Books">
        insert into ssmbuild.books (bookName,bookCounts,detail)
        values (#{bookName},#{bookCounts},#{detail})
    </insert>

    <!--根據id刪除一本Book-->
    <delete id="deleteBookById" parameterType="int">
        delete from ssmbuild.books where bookID=#{bookId}
    </delete>

   <!--更新Book-->
    <update id="updateBook" parameterType="Books">
        update ssmbuild.books
        set bookName=#{bookName},bookCounts=#{bookCounts},detail=#{detail}
        where bookID=#{bookID}
    </update>
  
    <!--根據id查詢,返回一本Book-->
    <select id="queryBookById" resultType="Books">
        select * from books
        where bookID=#{bookId}
    </select>

  <!--查詢全部Book-->
    <select id="queryAllBook" resultType="Books">
        select * from books
    </select>
</mapper>

7.1.7編寫Service層的介面和實現類

介面
public interface BookService {
    //增加一本書
    int addBook(Books books);

    //刪除一本書
    int deleteBookById( int id);

    //更新一本書
    int updateBook(Books books);

    //查詢一本書
    Books queryBookById(int id);

    //查詢全部的書
    List<Books> queryAllBook();
}
實現類
package com.tang.service;

import com.tang.dao.BookMapper;
import com.tang.pojo.Books;

import java.util.List;

public class BookServiceImpl implements BookService{
    //service調dao層,組合Dao
    private BookMapper bookMapper;
    public void setBookMapper(BookMapper bookMapper){
        this.bookMapper = bookMapper;
    }

    public int addBook(Books books) {
        return bookMapper.addBook(books);
    }

    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
    }

    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }
}

OK,到此,底層需求操作編寫完畢!

7.2Spring層

7.2.1配置Spring整合MyBatis

我們這裡數據源使用c3p0連接池;

7.2.2編寫Spring整合Mybatis的配置文件

7.2.3spring整合dao層

spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--1.關聯資料庫配置文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

    <!--2.連接池-->
    <!--資料庫連接池
      dbcp 半自動化操作 不能自動連接
      c3p0 自動化操作(自動的載入配置文件 並且設置到對象裡面)
  -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!-- c3p0連接池的私有屬性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 關閉連接後不自動commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 獲取連接超時時間 ms-->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 當獲取連接失敗重試次數 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!-- 3.配置SqlSessionFactory對象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 註入資料庫連接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--配置dao介面掃描包,動態的實現了Dao介面可以註入到Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>

        <!--要掃描的dao包-->
        <property name="basePackage" value="com.tang.dao"/>
    </bean>
</beans>

7.2.4Spring整合service層

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd">

    <!--1. 掃描service相關的bean -->
    <context:component-scan base-package="com.tang.service" />

    <!--2.BookServiceImpl註入到IOC容器中-->
    <bean id="BookServiceImpl" class="com.tang.service.BookServiceImpl">
        <!--service層要和dao層聯繫起來,除了IDEA自動幫我們做的之外,
        還可以在service層通過import來導入spring-dao.xml使得service層和dao層關聯起來-->
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

    <!--3.配置事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 註入資料庫連接池 -->
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

7.3SpringMVC層

7.3.1web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 引言 領域驅動設計並不是新的架構設計理論,從Eric Evans提出至今已經有十多年曆史。由於微服務架構的興起,DDD常用於指導微服務邊界劃分,並重新廣泛進入軟體研發大眾的視野。DDD的理念及應用普及在國外相對成熟,在國內尚處於初期發展階段。國內的很多社區以及企業組織內部近幾年對於DDD的探討和應用 ...
  • 微服務說起來高大尚,實際擼一遍來試試看,用現在比較常用的微服務框架,Consul和Ocelote做一個Demo,一起來試試吧! 說在前面的話 準備好環境,拉取源代碼,按照每個章節中的【實踐操作】進行操作,即可搭建起來,已經測試通過。 不想把篇幅拉太長,且此文實踐為主,如果對微服務沒有理論基礎,建議先 ...
  • 單例模式是一種創建型設計模式, 讓開發者能夠保證一個類只有一個實例, 並提供一個訪問該實例的全局節點,有助於協調系統整體的行為。 ...
  • 類成員函數指針(member function pointer),是 C++ 語言的一類指針數據類型,用於存儲一個指定類具有給定的形參列表與返回值類型的成員函數的訪問信息。一般我們是不會使用的,都是直接將帶有返回值的函數作為參數或者另存後使用;像函數指針我們一般在“由庫的提供者決定函數調用時機,庫的 ...
  • AOP面向切麵編程 什麼是AOP AOP (Aspect Oriented Programming)意為:面向切麵編程,通過預編譯方式和運行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續,是軟體開發中的一個熱點,也是Spring框架中的一個重要內容,是函數式編程的一種衍生範型。利用 ...
  • 目錄 一.OpenGL 圖像亮度調節 1.原始圖片 2.效果演示 二.OpenGL 圖像亮度調節源碼下載 三.猜你喜歡 零基礎 OpenGL ES 學習路線推薦 : OpenGL ES 學習目錄 >> OpenGL ES 基礎 零基礎 OpenGL ES 學習路線推薦 : OpenGL ES 學習目 ...
  • 1.字典的定義 使用{}定義字典,括弧內用逗號分隔開多個key:value,其中value可以是任意類型,但是key必須是不可變類型且不能重覆,是無序的! info=[ ['name','zhang'], ('age',19) ['gender','男'] ] d={} # 第一種方式定義 d=di ...
  • 什麼是標簽調用?標簽調用是根據調用條件(condition)從數據表(table)讀取調用數量(pagesize)條數據,並按排序方式(order)排序,最終通過標簽模板的佈局輸出數據。可以看出,標簽的工作分兩個部分,一是讀取數據,二是顯示數據。標簽函數原型標簽函數保存於 include/tag.f ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...