2. 程式人生 > 其它 >FATFS檔案管理函式中文名及入口引數

FATFS檔案管理函式中文名及入口引數

阿新 • • 發佈：2021-02-07

技術標籤：ssm

SpringMVC

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.2、Model1時代

  • 在web早期的開發中，通常採用的都是Model1。
  • Model1中，主要分為兩層，檢視層和模型層。

Model1優點：架構簡單，比較適合小型專案開發；

Model1缺點：JSP職責不單一，職責過重，不便於維護；

1.3、Model2時代

Model2把一個專案分成三部分，包括檢視、控制、模型。

  1. 使用者發請求
  2. Servlet接收請求資料，並呼叫對應的業務邏輯方法
  3. 業務處理完畢，返回更新後的資料給servlet
  4. servlet轉向到JSP，由JSP來渲染頁面
  5. 響應給前端更新後的頁面

職責分析：

Controller：控制器

  1. 取得表單資料
  2. 呼叫業務邏輯
  3. 轉向指定的頁面

Model：模型

  1. 業務邏輯
  2. 儲存資料的狀態

View：檢視

  1. 顯示頁面

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

1.4、回顧Servlet

  1. 新建一個Maven工程當做父工程！pom依賴！

    <!--匯入依賴-->
<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.3</version>
    </dependency>
    <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.0</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

  2. 建立一個Moudle：springmvc-01-servlet ， 新增Web app的支援！

  3. 匯入servlet 和 jsp 的 jar 依賴

    <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.0</version>
</dependency>

  4. 編寫一個Servlet類，用來處理使用者的請求

    package com.liu.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {

    //全棧 ：後臺 + 前端 + 資料庫 + 運維
    //前端 ：後臺 + 前端
    //Python ！= 人工智慧

    @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);
    }
}

  5. 編寫Hello.jsp，在WEB-INF目錄下新建一個jsp的資料夾，新建hello.jsp

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

  6. 在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.liu.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    <!--session的超時時間-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

  7. 配置Tomcat，並啟動測試

    • localhost:8080/user?method=add
    • localhost:8080/user?method=delete

MVC框架要做哪些事情

  1. 將url對映到java類或java類的方法 .
  2. 封裝使用者提交的資料 .
  3. 處理請求–呼叫相關的業務處理–封裝響應資料 .
  4. 將響應的資料進行渲染 . 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/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

我們為什麼要學習SpringMVC呢?

Spring MVC的特點：

  1. 輕量級，簡單易學
  2. 高效 , 基於請求響應的MVC框架
  3. 與Spring相容性好，無縫結合
  4. 約定優於配置
  5. 功能強大：RESTful、資料驗證、格式化、本地化、主題等
  6. 簡潔靈活

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框架提供的技術，不需要開發者實現，虛線表示需要開發者實現。

簡要分析執行流程

  1. DispatcherServlet表示前置控制器，是整個SpringMVC的控制中心。使用者發出請求，DispatcherServlet接收請求並攔截請求。

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

    如上url拆分成三部分：

    http://localhost:8080伺服器域名

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

    hello表示控制器

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

  2. HandlerMapping為處理器對映。DispatcherServlet呼叫HandlerMapping,HandlerMapping根據請求url查詢Handler。

  3. HandlerExecution表示具體的Handler,其主要作用是根據url查詢控制器，如上url被查詢控制器為：hello。

  4. HandlerExecution將解析後的資訊傳遞給DispatcherServlet,如解析控制器對映等。

  5. HandlerAdapter表示處理器介面卡，其按照特定的規則去執行Handler。

  6. Handler讓具體的Controller執行。

  7. Controller將具體的執行資訊返回給HandlerAdapter,如ModelAndView。

  8. HandlerAdapter將檢視邏輯名或模型傳遞給DispatcherServlet。

  9. DispatcherServlet呼叫檢視解析器(ViewResolver)來解析HandlerAdapter傳遞的邏輯檢視名。

  10. 檢視解析器將解析的邏輯檢視名傳給DispatcherServlet。

  11. DispatcherServlet根據檢視解析器解析的檢視結果，呼叫具體的檢視。

  12. 最終檢視呈現給使用者。

第一個MVC程式

配置版

1、新建一個Moudle ， springmvc-02-hello ， 新增web的支援！

2、確定匯入了SpringMVC 的依賴！

3、配置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">
    <!--註冊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>
        <!--啟動級別-->
        <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>

4、編寫SpringMVC 的 配置檔案！名稱：springmvc-servlet.xml : [servletname]-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>

5、新增 處理對映器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

6、新增 處理器介面卡

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

7、新增 檢視解析器

<!--檢視解析器：DispatcherServlet給他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--字首-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--字尾-->
        <property name="suffix" value=".jsp"/>
    </bean>

8、編寫我們要操作業務Controller ，要麼實現Controller介面，要麼增加註解；需要返回一個ModelAndView，裝資料，封檢視；

package com.liu.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;

//注意，我們這裡先當如Controller介面
public class HelloController implements Controller {
    public String value() {
        return null;
    }

    public Class<? extends Annotation> annotationType() {
        return null;
    }
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response){
        //ModelAndView 模型和檢視
        ModelAndView mv = new ModelAndView();

        //封裝物件，放在ModelAndView中，Model
        mv.addObject("msg","HelloSpringMVC!");
        //封裝要跳轉的檢視，放在ModelAndView中
        mv.setViewName("hello");//：/WEB--INF/jsp/hello.jsp
        return mv;
    }
}

9、將自己的類交給SpringIOC容器，註冊bean

<!--Handler--><bean id="/hello" class="com.kuang.controller.HelloController"/>

10、寫要跳轉的jsp頁面，顯示ModelandView存放的資料，以及我們的正常頁面；

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

11、配置Tomcat 啟動測試！

可能遇到的問題：訪問出現404，排查步驟：

  1. 檢視控制檯輸出，看一下是不是缺少了什麼jar包。
  2. 如果jar包存在，顯示無法輸出，就在IDEA的專案釋出中，新增lib依賴！
  3. 重啟Tomcat 即可解決！

註解版

1、新建一個Moudle，springmvc-03-hello-annotation 。新增web支援！

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

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

3、在pom.xml檔案引入相關的依賴：主要有Spring框架核心庫、Spring MVC、servlet , JSTL等。我們在父依賴中已經引入了！

4、配置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>

/ 和 /* 的區別：< url-pattern > / </ url-pattern > 不會匹配到.jsp， 只針對我們編寫的請求；即：.jsp 不會進入spring的 DispatcherServlet類 。< url-pattern > /* </ url-pattern > 會匹配 *.jsp，會出現返回 jsp檢視 時再次進入spring的DispatcherServlet 類，導致找不到對應的controller所以報404錯。

    • 注意web.xml版本問題，要最新版！

    • 註冊DispatcherServlet

    • 關聯SpringMVC的配置檔案

    • 啟動級別為1

    • 對映路徑為 / 【不要用/*，會404】

  2. 5、新增Spring MVC配置檔案

  3. 在resource目錄下新增springmvc-servlet.xml配置檔案，配置的形式與Spring容器配置基本類似，為了支援基於註解的IOC，設定了自動掃描包的功能，具體配置資訊如下：

  4. <?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.kuang.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>

  5. 在檢視解析器中我們把所有的檢視都存放在/WEB-INF/目錄下，這樣可以保證檢視安全，因為這個目錄下的檔案，客戶端不能直接訪問。

    • 讓IOC的註解生效

    • 靜態資源過濾 ：HTML . JS . CSS . 圖片 ， 視訊 …

    • MVC的註解驅動

    • 配置檢視解析器

  7. 6、建立Controller

  8. 編寫一個Java控制類：com.kuang.controller.HelloController , 注意編碼規範

  9. import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/HelloController")
public class HelloController {

    //真實訪問地址 : 專案名/HelloController/hello
    @RequestMapping("/hello")
    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。

  11. 7、建立檢視層

  12. 在WEB-INF/ jsp目錄中建立hello.jsp ， 檢視可以直接取出並展示從Controller帶回的資訊；

  13. 可以通過EL表示取出Model中存放的值，或者物件；

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

8、配置Tomcat執行

配置Tomcat ， 開啟伺服器 ， 訪問 對應的請求路徑！

OK，執行成功！

小結

實現步驟其實非常的簡單：

  1. 新建一個web專案
  2. 匯入相關jar包
  3. 編寫web.xml , 註冊DispatcherServlet
  4. 編寫springmvc配置檔案
  5. 接下來就是去建立對應的控制類 , controller
  6. 最後完善前端檢視和controller之間的對應
  7. 測試執行除錯.

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

處理器對映器、處理器介面卡、檢視解析器

通常，我們只需要手動配置檢視解析器，而處理器對映器和處理器介面卡只需要開啟註解驅動即可，而省去了大段的xml配置

再來回顧下原理吧~

下面我們準備研究下Controller及RestFul風格！

3、RestFul和控制器

控制器Controller

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

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

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

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

實現Controller介面

Controller是一個介面，在org.springframework.web.servlet.mvc包下，介面中只有一個方法；

測試

  1. 新建一個Moudle，springmvc-04-controller 。將剛才的03 拷貝一份, 我們進行操作！

    • 刪掉HelloController
    • mvc的配置檔案只留下 檢視解析器！

  3. 編寫一個Controller類，ControllerTest1

  4. 編寫完畢後，去Spring配置檔案中註冊請求的bean；name對應請求路徑，class對應處理請求的類

  5. 編寫前端test.jsp，注意在WEB-INF/jsp目錄下編寫，對應我們的檢視解析器

  6. 配置Tomcat執行測試，我這裡沒有專案釋出名配置的就是一個 / ，所以請求不用加專案名，OK！

說明：

  • 實現介面Controller定義控制器是較老的辦法

  • 缺點是：一個控制器中只有一個方法，如果要多個方法則需要定義多個Controller；定義的方式比較麻煩；

使用註解@Controller

  • @Controller註解型別用於宣告Spring類的例項是一個控制器（在講IOC時還提到了另外3個註解）；

  • Spring可以使用掃描機制來找到應用程式中所有基於註解的控制器類，為了保證Spring能找到你的控制器，需要在配置檔案中宣告元件掃描。

  • 增加一個ControllerTest2類，使用註解實現；

  • 執行tomcat測試

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

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

RequestMapping

@RequestMapping

  • @RequestMapping註解用於對映url到控制器類或一個特定的處理程式方法。可用於類或方法上。用於類上，表示類中的所有響應請求的方法都是以該地址作為父路徑。

  • 為了測試結論更加準確，我們可以加上一個專案名測試 myweb

  • 只註解在方法上面

    訪問路徑：http://localhost:8080 / 專案名 / h1

  • 同時註解類與方法

    訪問路徑：http://localhost:8080 / 專案名/ admin /h1 , 需要先指定類的路徑再指定方法的路徑；

RestFul 風格

概念

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

學習測試

  1. 在新建一個類 RestFulController

    @Controller
public class RestFulController {
}

  2. 在Spring MVC中可以使用 @PathVariable 註解，讓方法引數的值對應繫結到一個URI模板變數上。

    @Controller
public class RestFulController {

    //對映訪問路徑
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable int p2, Model model){
        
        int result = p1+p2;
        //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
        model.addAttribute("msg", "結果："+result);
        //返回檢視位置
        return "test";
        
    }
    
}

  3. 我們來測試請求檢視下

  4. 思考：使用路徑變數的好處？

    • 使路徑變得更加簡潔；
    • 獲得引數更加方便，框架會自動進行型別轉換。
    • 通過路徑變數的型別可以約束訪問引數，如果型別不一樣，則訪問不到對應的請求方法，如這裡訪問是的路徑是/commit/1/a，則路徑與方法不匹配，而不會是引數轉換失敗。

  6. 我們來修改下對應的引數型別，再次測試

    //對映訪問路徑
@RequestMapping("/commit/{p1}/{p2}")
public String index(@PathVariable int p1, @PathVariable String p2, Model model){

    String result = p1+p2;
    //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
    model.addAttribute("msg", "結果："+result);
    //返回檢視位置
    return "test";

}

使用method屬性指定請求型別

用於約束請求的型別，可以收窄請求範圍。指定請求謂詞的型別如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等

我們來測試一下：

  • 增加一個方法

    //對映訪問路徑,必須是POST請求
@RequestMapping(value = "/hello",method = {RequestMethod.POST})
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "test";
}

  • 我們使用瀏覽器位址列進行訪問預設是Get請求，會報錯405：

  • 如果將POST修改為GET則正常了；

    //對映訪問路徑,必須是Get請求
@RequestMapping(value = "/hello",method = {RequestMethod.GET})
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "test";
}

小結：

Spring MVC 的 @RequestMapping 註解能夠處理 HTTP 請求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的位址列請求預設都會是 HTTP GET 型別的。

方法級別的註解變體有如下幾個：組合註解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一個組合註解，平時使用的會比較多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一個快捷方式。

擴充套件：小黃鴨除錯法

場景一：我們都有過向別人（甚至可能向完全不會程式設計的人）提問及解釋程式設計問題的經歷，但是很多時候就在我們解釋的過程中自己卻想到了問題的解決方案，然後對方卻一臉茫然。

場景二：你的同行跑來問你一個問題，但是當他自己把問題說完，或說到一半的時候就想出答案走了，留下一臉茫然的你。

其實上面兩種場景現象就是所謂的小黃鴨除錯法（Rubber Duck Debuging），又稱橡皮鴨除錯法，它是我們軟體工程中最常使用除錯方法之一。

4、資料處理級跳轉

結果跳轉方式

ModelAndView

設定ModelAndView物件 , 根據view的名稱 , 和檢視解析器跳到指定的頁面 .

頁面 : {檢視解析器字首} + viewName +{檢視解析器字尾}

<!-- 檢視解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
      id="internalResourceViewResolver">
    <!-- 字首 -->
    <property name="prefix" value="/WEB-INF/jsp/" />
    <!-- 字尾 -->
    <property name="suffix" value=".jsp" />
</bean>

對應的controller類

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一個模型檢視物件
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

ServletAPI

通過設定ServletAPI , 不需要檢視解析器 .

1、通過HttpServletResponse進行輸出

2、通過HttpServletResponse實現重定向

3、通過HttpServletResponse實現轉發

@Controller
public class ResultGo {

    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
    }

    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
    }

    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //轉發
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
    }

}

SpringMVC

通過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為另一個請求/
    }

}

資料處理

處理提交資料

1、提交的域名稱和處理方法的引數名一致

提交資料 :

處理方法 :

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

後臺輸出 : kuangshen

2、提交的域名稱和處理方法的引數名不一致

提交資料 :

處理方法 :

//@RequestParam("username") : username提交的域的名稱 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

後臺輸出 : kuangshen

3、提交的是一個物件

要求提交的表單域和物件的屬性名一致 , 引數使用物件即可

1、實體類

public class User {
    private int id;
    private String name;
    private int age;
    //構造
    //get/set
    //tostring()
}

2、提交資料 :

3、處理方法 :

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

後臺輸出 : User { id=1, name=‘kuangshen’, age=15 }

說明：如果使用物件的話，前端傳遞的引數名和物件名必須一致，否則就是null。

資料顯示到前端

第一種 : 通過ModelAndView

我們前面一直都是如此 . 就不過多解釋

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一個模型檢視物件
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

第二種 : 通過ModelMap

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
    //封裝要顯示到檢視中的資料
    //相當於req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

第三種 : 通過Model

Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
    //封裝要顯示到檢視中的資料
    //相當於req.setAttribute("name",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

對比

就對於新手而言簡單來說使用區別就是：

Model 只有寥寥幾個方法只適合用於儲存資料，簡化了新手對於Model物件的操作和理解；

ModelMap 繼承了 LinkedMap ，除了實現了自身的一些方法，同樣的繼承 LinkedMap 的方法和特性；

ModelAndView 可以在儲存資料的同時，可以進行設定返回的邏輯檢視，進行控制展示層的跳轉。

當然更多的以後開發考慮的更多的是效能和優化，就不能單單僅限於此的瞭解。

請使用80%的時間打好紮實的基礎，剩下18%的時間研究框架，2%的時間去學點英文，框架的官方文件永遠是最好的教程。

亂碼問題

測試步驟：

1、我們可以在首頁編寫一個提交的表單

<form action="/e/t" method="post">
  <input type="text" name="name">
  <input type="submit">
</form>

2、後臺編寫對應的處理類

@Controller
public class Encoding {
    @RequestMapping("/e/t")
    public String test(Model model,String name){
        model.addAttribute("msg",name); //獲取表單提交的值
        return "test"; //跳轉到test頁面顯示輸入的值
    }
}

3、輸入中文測試，發現亂碼

不得不說，亂碼問題是在我們開發中十分常見的問題，也是讓我們程式猿比較頭大的問題！

以前亂碼問題通過過濾器解決 , 而SpringMVC給我們提供了一個過濾器 , 可以在web.xml中配置 .

修改了xml檔案需要重啟伺服器！

<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>

但是我們發現 , 有些極端情況下.這個過濾器對get的支援不好 .

處理方法 :

1、修改tomcat配置檔案 ：設定編碼！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

2、自定義過濾器

package com.kuang.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 {

    @Override
    public void destroy() {
    }

    @Override
    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);
    }

    @Override
    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;
    }
}

這個也是我在網上找的一些大神寫的，一般情況下，SpringMVC預設的亂碼處理就已經能夠很好的解決了！

然後在web.xml中配置這個過濾器即可！

亂碼問題，需要平時多注意，在儘可能能設定編碼的地方，都設定為統一編碼 UTF-8！

有了這些知識，我們馬上就可以進行SSM整合了！

5、JSON互動處理

什麼是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"}'

程式碼測試

1、新建一個module ，springmvc-05-json ， 新增web的支援

2、在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:3,
        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>

3、在IDEA中使用瀏覽器開啟，檢視控制檯輸出！

Controller返回JSON資料

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

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

我們這裡使用Jackson，使用它需要匯入它的jar包；

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</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.kuang.controller"/>

    <!-- 檢視解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 字首 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 字尾 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

我們隨便編寫一個User的實體類，然後我們去編寫我們的測試Controller；

package com.kuang.pojo;

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

//需要匯入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;
    private int age;
    private String sex;
    
}

這裡我們需要兩個新東西，一個是@ResponseBody，一個是ObjectMapper物件，我們看下具體的用法

編寫一個Controller；

@Controller
public class UserController {

    @RequestMapping("/json1")
    @ResponseBody
    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;
    }

}

配置Tomcat ， 啟動測試一下！

http://localhost:8080/json1

發現出現了亂碼問題，我們需要設定一下他的編碼格式為utf-8，以及它返回的型別；

通過@RequestMaping的produces屬性來實現，修改下程式碼

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

再次測試， http://localhost:8080/json1 ， 亂碼問題OK！

【注意：使用json記得處理亂碼問題】

程式碼優化

亂碼統一解決

上一種方法比較麻煩，如果專案中有許多請求則每一個都要新增，可以通過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;
    }

}

啟動tomcat測試，結果都正常輸出！

測試集合輸出

增加一個新的方法

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {

    //建立一個jackson的物件對映器，用來解析資料
    ObjectMapper mapper = new ObjectMapper();
    //建立一個物件
    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);

    //將我們的物件解析成為json格式
    String str = mapper.writeValueAsString(list);
    return str;
}

執行結果 : 十分完美，沒有任何問題！

圖片

輸出時間物件

增加一個新的方法

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();

    //建立時間一個物件，java.util.Date
    Date date = new Date();
    //將我們的物件解析成為json格式
    String str = mapper.writeValueAsString(date);
    return str;
}

執行結果 :

  • 預設日期格式會變成一個數字，是1970年1月1日到當前日期的毫秒數！
  • Jackson 預設是會把時間轉成timestamps形式

解決方案：取消timestamps形式 ， 自定義時間格式

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();

    //不使用時間戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定義日期格式物件
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //指定日期格式
    mapper.setDateFormat(sdf);

    Date date = new Date();
    String str = mapper.writeValueAsString(date);

    return str;
}

執行結果 : 成功的輸出了時間！

抽取為工具類

如果要經常使用的話，這樣是比較麻煩的，我們可以將這些程式碼封裝到一個工具類中；我們去編寫下

package com.kuang.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
    
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat) {
        ObjectMapper mapper = new ObjectMapper();
        //不使用時間差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定義日期格式物件
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

我們使用工具類，程式碼就更加簡潔了！

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

大功告成！完美！

FastJson

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字串之間的相互轉化。

程式碼測試，我們新建一個FastJsonDemo 類

package com.kuang.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);
    }
}

這種工具類，我們只需要掌握使用就好了，在使用的時候在根據具體的業務去找對應的實現。和以前的commons-io那種工具包一樣，拿來用就好了！

Json在我們資料傳輸中十分重要，一定要學會使用！

相關推薦

FATFS檔案管理函式中文名及入口引數

技術標籤：FATFS函式中文解釋 最近在做一個門緊鎖，需要記錄指紋的ID，IC卡卡號以及使用者編號，我選擇將資訊儲存到SD卡內，完成這個功能就需要用的FATFS檔案管理。在ff.c中函式較多，且都為英文，在這裡做一下中

JavaScript函式呼叫及this引數

JS有4種方式呼叫函式 作為一個函式(function)——fn()直接被呼叫 作為一個方法(methods)——obj.fn()，關聯在物件上呼叫，實現面向物件程式設計

C++預設引數與函式過載及注意事項

一、預設引數 在C++中，可以為引數指定預設值。在函式呼叫時沒有指定與形參相對應的實參時， 就自動使用預設引數。

py 中 函式基礎及 引數分類

1、函式基礎概念：函式是組織好的，可重複使用的，用來實現單一，或相關聯功能的程式碼段（還有其他的內建函式、匿名函式，後面總結）以下為 使用者自定義函式：即自己根據需要建立的函式：

Oracle 引數檔案管理

Oracle 啟動首先尋找引數檔案(spfile/pfile),然後根據引數檔案中的設定，建立例項，分配記憶體，啟動後臺程序。Oracle有三個引數檔案，按啟動順序查詢到第一個即可啟動，首選：spfile<sid>.ora ；其次: spfile

2.2.2 MySQL基本功能與引數檔案管理

MySQL資料庫管理-實戰案例5 需求： 目前業務系統執行比較慢，懷疑是mysql資料庫記憶體引數少低，需要修改

Linux檔案管理及命令

Linux 系統下的檔案型別與檔案許可權 檔案型別 Linux 下所有的東西（包括記憶體、網絡卡、外部裝置等等）都可以看做檔案，Linux 將檔案 分為以下五種型別： a. 普通檔案 ‘-’ b. 目錄檔案 ‘d’ c. 管道檔

函式基本及函式引數

一.函式 功能: 包裹一部分程式碼 實現某一個功能 達成某一個目的 特點:: \"\"\" 特點:可以反覆呼叫,提高程式碼的複用性,提高開發效率,便於維護管理

PHP檔案操作簡單介紹及函式彙總

檔案操作一直是Web程式設計師頭疼的地方，而檔案操作在CMS這樣的系統中又是必須的。如今，PHP檔案操作的函式內容已經非常強大，檔案這部分也是學習PHP非常重要的一部分，希望大家不要忽略。這篇文章會簡單介紹一下PH

RHCE-Day05-使用者及檔案管理

技術標籤：RHCE RHCE-Day05-使用者及檔案管理 1.使用者管理 管理員UID為0：系統的管理員使用者。

【轉】記憶體管理內幕mallco及free函式實現--簡易記憶體分配器、記憶體池、GC技術

原文：https://www.ibm.com/developerworks/cn/linux/l-memory/ 為什麼必須管理記憶體 記憶體管理是計算機程式設計最為基本的領域之一。在很多指令碼語言中，您不必擔心記憶體是如何管理的，這並不能使得記憶體管理

[Linux檔案管理之上傳與下載、輸出與重定向、字串處理、壓縮與打包、使用者及使用者組]

[Linux檔案管理之上傳與下載、輸出與重定向、字串處理、壓縮與打包、使用者及使用者組]

linux目錄結構，路徑，系統目錄作用及指令介紹，檔案管理基本命令，檢視檔案內容命令，vim編輯器

linux系統的目錄結構 windows系統：多跟結構 C:\\a\\b\\c\\d.txt D:\\xxx\\yyy\\zzz\\1.txt linux系統：單根結構

python學習記錄—檔案的操作模式及函式入門

今日內容概要 操作模式 檔案內游標的移動（瞭解） 檔案內容修改（瞭解） 函式（重要）

C#二次開發BIMFACE系列60 File Management檔案管理服務及應用場景

系列目錄     【已更新最新開發文章，點選檢視詳細】 　　在我的部落格《C#二次開發BIMFACE系列》教程中詳細介紹瞭如何註冊BIMFACE、測試、封裝伺服器端介面並提供了豐富的Demo、視訊教程等內容。目前已有70多家

C#二次開發BIMFACE系列61 File Management檔案管理服務介面二次開發及實戰詳解

系列目錄     【已更新最新開發文章，點選檢視詳細】 　　在我的部落格《C#二次開發BIMFACE系列61 File Management檔案管理服務介面二次開發及實戰詳解》最後列出了 File Management 的介面，本篇主要介紹對該

Python趣味入門9：函式是你走過的套路，詳解函式、呼叫、引數及返回值

概念 瓊恩·雪諾當上守夜人的司令後，為訓練士兵對付殭屍兵團，把成功斬殺殭屍的一系列動作編排成了“葵花寶典劍法”，這就是函式。相似，在計算機世界，一系列前後連續的計算機語句組合在一起稱之為函式，本章主要介

插曲：Kafka的生產者原理及重要引數說明

前言 本來插曲系列是應大家要求去更新的，但是好像第一篇的kafka效果還可以所以更插曲就勤快些了（畢竟誰不想看著自己被多多點贊呢hhh?），上一篇說了一個案例是為了說明如何去考量一個kafka叢集的部署，算是一個參考

BookStack v2.0 釋出，功能類似 GitBook 和看雲的線上檔案管理系統

程式介紹 BookStack，分享知識，共享智慧！知識，因分享，傳承久遠！ BookStack 是基於 Mindoc、使用Go語言的Beego框架開發的功能類似GitBook和看雲的線上檔案管理系統，實現了檔案採集、匯入、電子書生成以及版本控

C語言實現班檔案管理系統課程設計

本文例項為大家分享了C語言班檔案管理系統的具體程式碼，供大家參考，具體內容如下