Go標準庫Context

時間  2020-05-14
標籤 標準 context 简体版
原文   原文鏈接

Go標準庫Context

mark

在 Go http包的Server中，每個請求在都有一個對應的 goroutine 去處理。請求處理函數一般會啓動額外的 goroutine 用來訪問後端服務，好比數據庫和RPC服務。用來處理一個請求的 goroutine 一般須要訪問一些與請求特定的數據，好比終端用戶的身份認證信息、驗證相關的token、請求的截止時間。 當一個請求被取消或超時時，全部用來處理該請求的 goroutine 都應該迅速退出，而後系統才能釋放這些 goroutine 佔用的資源。html

總結一下：golang

上面哇啦哇啦一大堆，說白了，context就是用來簡潔的管理goroutines的生命週期。數據庫

爲何須要Context

基本示例

package main

import (
	"fmt"
	"sync"

	"time"
)

var wg sync.WaitGroup

// 初始的例子
func worker() {
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
	}
	// 如何接收外部命令實現退出
	wg.Done()
}

func main() {
	wg.Add(1)
	go worker()
	// 如何優雅的實現結束子goroutine
	wg.Wait()
	fmt.Println("over")
}

全局變量方式

package main

import (
	"fmt"
	"sync"

	"time"
)

var wg sync.WaitGroup
var exit bool

// 全局變量方式存在的問題：
// 1. 使用全局變量在跨包調用時不容易統一
// 2. 若是worker中再啓動goroutine，就不太好控制了。

func worker() {
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		if exit {
			break
		}
	}
	wg.Done()
}

func main() {
	wg.Add(1)
	go worker()
	time.Sleep(time.Second * 3) // sleep3秒以避免程序過快退出
	exit = true                 // 修改全局變量實現子goroutine的退出
	wg.Wait()
	fmt.Println("over")
}

通道方式

package main

import (
	"fmt"
	"sync"

	"time"
)

var wg sync.WaitGroup

// 管道方式存在的問題：
// 1. 使用全局變量在跨包調用時不容易實現規範和統一，須要維護一個共用的channel

func worker(exitChan chan struct{}) {
LOOP:
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		select {
		case <-exitChan: // 等待接收上級通知
			break LOOP
		default:
		}
	}
	wg.Done()
}

func main() {
	var exitChan = make(chan struct{})
	wg.Add(1)
	go worker(exitChan)
	time.Sleep(time.Second * 3) // sleep3秒以避免程序過快退出
	exitChan <- struct{}{}      // 給子goroutine發送退出信號
	close(exitChan)
	wg.Wait()
	fmt.Println("over")
}

官方版的方案

package main

import (
	"context"
	"fmt"
	"sync"

	"time"
)

var wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		select {
		case <-ctx.Done(): // 等待上級通知
			break LOOP
		default:
		}
	}
	wg.Done()
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	wg.Add(1)
	go worker(ctx)//這裏的ctx起到了全局變量的做用
	time.Sleep(time.Second * 3)
	cancel() // 通知子goroutine結束
	wg.Wait()
	fmt.Println("over")
}

當子goroutine又開啓另一個goroutine時，只須要將ctx傳入便可：編程

package main

import (
	"context"
	"fmt"
	"sync"

	"time"
)

var wg sync.WaitGroup

func worker(ctx context.Context) {
	go worker2(ctx)
LOOP:
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		select {
		case <-ctx.Done(): // 等待上級通知
			break LOOP
		default:
		}
	}
	wg.Done()
}

func worker2(ctx context.Context) {
LOOP:
	for {
		fmt.Println("worker2")//邏輯代碼塊
		time.Sleep(time.Second)
		select {
		case <-ctx.Done(): // 等待上級通知
			break LOOP
		default:
		}
	}
}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 3)
	cancel() // 通知子goroutine結束
	wg.Wait()
	fmt.Println("over")
}

因而可知在存在協程嵌套時，相同時中止全部協程，用context比較方便後端

Context初識

Go1.7加入了一個新的標準庫context，它定義了Context類型，專門用來簡化 對於處理單個請求的多個 goroutine 之間與請求域的數據、取消信號、截止時間等相關操做，這些操做可能涉及多個 API 調用。api

對服務器傳入的請求應該建立上下文，而對服務器的傳出調用應該接受上下文。它們之間的函數調用鏈必須傳遞上下文，或者可使用WithCancel、WithDeadline、WithTimeout或WithValue建立的派生上下文。當一個上下文被取消時，它派生的全部上下文也被取消。安全

Context接口

context.Context是一個接口，該接口定義了四個須要實現的方法。具體簽名以下：服務器

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}
  • Deadline方法須要返回當前Context被取消的時間，也就是完成工做的截止時間（deadline）；
  • Done 使用<-chan struct{}來通知退出，供被調用的goroutine監聽。
  • Err方法會返回當前Context結束的緣由，它只會在Done返回的Channel被關閉時纔會返回非空的值；
    • 若是當前Context被取消就會返回Canceled錯誤；
    • 若是當前Context超時就會返回DeadlineExceeded錯誤；
  • Value方法會從Context中返回鍵對應的值，對於同一個上下文來講，屢次調用Value 並傳入相同的Key會返回相同的結果，該方法僅用於傳遞跨API和進程間跟請求域的數據；

Background()和TODO()

Go內置兩個函數：Background()和TODO()，這兩個函數分別返回一個實現了Context接口的background和todo。咱們代碼中最開始都是以這兩個內置的上下文對象做爲最頂層的partent context，衍生出更多的子上下文對象。網絡

Background()主要用於main函數、初始化以及測試代碼中，做爲Context這個樹結構的最頂層的Context，也就是根Context。ide

TODO()，它目前還不知道具體的使用場景，若是咱們不知道該使用什麼Context的時候，可使用這個。

background和todo本質上都是emptyCtx結構體類型，是一個不可取消，沒有設置截止時間，沒有攜帶任何值的Context。

With系列函數

此外，context包中還定義了四個With系列函數。

WithCancel

WithCancel的函數簽名以下：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

WithCancel返回帶有新Done通道的父節點的副本。當調用返回的cancel函數或當關閉父上下文的Done通道時，將關閉返回上下文的Done通道，不管先發生什麼狀況。

取消此上下文將釋放與其關聯的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel。

func gen(ctx context.Context) <-chan int {
		dst := make(chan int)
		n := 1
		go func() {
			for {
				select {
				case <-ctx.Done():
					return // return結束該goroutine，防止泄露
				case dst <- n:
					n++
				}
			}
		}()
		return dst
	}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel() // 當咱們取完須要的整數後調用cancel

	for n := range gen(ctx) {
		fmt.Println(n)
		if n == 5 {
			break
		}
	}
}

上面的示例代碼中，gen函數在單獨的goroutine中生成整數並將它們發送到返回的通道。 gen的調用者在使用生成的整數以後須要取消上下文，以避免gen啓動的內部goroutine發生泄漏。

WithDeadline

WithDeadline的函數簽名以下：

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)

返回父上下文的副本，並將deadline調整爲不遲於d。若是父上下文的deadline已經早於d，則WithDeadline(parent, d)在語義上等同於父上下文。當截止日過時時，當調用返回的cancel函數時，或者當父上下文的Done通道關閉時，返回上下文的Done通道將被關閉，以最早發生的狀況爲準。

取消此上下文將釋放與其關聯的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel。

func main() {
	d := time.Now().Add(50 * time.Millisecond)
	ctx, cancel := context.WithDeadline(context.Background(), d)

	// 儘管ctx會過時，但在任何狀況下調用它的cancel函數都是很好的實踐。
	// 若是不這樣作，可能會使上下文及其父類存活的時間超過必要的時間。
    
    //這個函數至關於爲context的撤銷提供了兩個限制，一是主動調用cancel，另外一個就是到達deadlines
	defer cancel()

	select {
	case <-time.After(1 * time.Second):
		fmt.Println("overslept")
	case <-ctx.Done():
		fmt.Println(ctx.Err())
	}
}

上面的代碼中，定義了一個50毫秒以後過時的deadline，而後咱們調用context.WithDeadline(context.Background(), d)獲得一個上下文（ctx）和一個取消函數（cancel），而後使用一個select讓主程序陷入等待：等待1秒後打印overslept退出或者等待ctx過時後退出。 由於ctx50秒後就過時，因此ctx.Done()會先接收到值，上面的代碼會打印ctx.Err()取消緣由。

WithTimeout

WithTimeout的函數簽名以下：

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

WithTimeout返回WithDeadline(parent, time.Now().Add(timeout))。

取消此上下文將釋放與其相關的資源，所以代碼應該在此上下文中運行的操做完成後當即調用cancel，一般用於數據庫或者網絡鏈接的超時控制。具體示例以下：

package main

import (
	"context"
	"fmt"
	"sync"

	"time"
)

// context.WithTimeout

var wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
	for {
		fmt.Println("db connecting ...")
		time.Sleep(time.Millisecond * 10) // 假設正常鏈接數據庫耗時10毫秒
		select {
		case <-ctx.Done(): // 50毫秒後自動調用
			break LOOP
		default:
		}
	}
	fmt.Println("worker done!")
	wg.Done()
}

func main() {
	// 設置一個50毫秒的超時
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 5)
	cancel() // 通知子goroutine結束
	wg.Wait()
	fmt.Println("over")
}

WithValue

WithValue函數可以將請求做用域的數據與 Context 對象創建關係。聲明以下：

func WithValue(parent Context, key, val interface{}) Context

WithValue返回父節點的副本，其中與key關聯的值爲val。

僅對API和進程間傳遞請求域的數據使用上下文值，而不是使用它來傳遞可選參數給函數。

所提供的鍵必須是可比較的，而且不該該是string類型或任何其餘內置類型，以免使用上下文在包之間發生衝突。WithValue的用戶應該爲鍵定義本身的類型。爲了不在分配給interface{}時進行分配，上下文鍵一般具備具體類型struct{}。或者，導出的上下文關鍵變量的靜態類型應該是指針或接口。

package main

import (
	"context"
	"fmt"
	"sync"

	"time"
)

// context.WithValue

type TraceCode string

var wg sync.WaitGroup

func worker(ctx context.Context) {
	key := TraceCode("TRACE_CODE")
	traceCode, ok := ctx.Value(key).(string) // 在子goroutine中獲取trace code
	if !ok {
		fmt.Println("invalid trace code")
	}
LOOP:
	for {
		fmt.Printf("worker, trace code:%s\n", traceCode)
		time.Sleep(time.Millisecond * 10) // 假設正常鏈接數據庫耗時10毫秒
		select {
		case <-ctx.Done(): // 50毫秒後自動調用
			break LOOP
		default:
		}
	}
	fmt.Println("worker done!")
	wg.Done()
}

func main() {
	// 設置一個50毫秒的超時
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
	// 在系統的入口中設置trace code傳遞給後續啓動的goroutine實現日誌數據聚合
	ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 5)
	cancel() // 通知子goroutine結束
	wg.Wait()
	fmt.Println("over")
}

使用Context的注意事項

  • 推薦以參數的方式顯示傳遞Context
  • 以Context做爲參數的函數方法，應該把Context做爲第一個參數。
  • 給一個函數方法傳遞Context的時候，不要傳遞nil，若是不知道傳遞什麼，就使用context.TODO()
  • Context的Value相關方法應該傳遞請求域的必要數據，不該該用於傳遞可選參數
  • Context是線程安全的，能夠放心的在多個goroutine中傳遞

客戶端超時取消示例

調用服務端API時如何在客戶端實現超時控制？

server端

// context_timeout/server/main.go
package main

import (
	"fmt"
	"math/rand"
	"net/http"

	"time"
)

// server端，隨機出現慢響應

func indexHandler(w http.ResponseWriter, r *http.Request) {
	number := rand.Intn(2)
	if number == 0 {
		time.Sleep(time.Second * 10) // 耗時10秒的慢響應
		fmt.Fprintf(w, "slow response")
		return
	}
	fmt.Fprint(w, "quick response")
}

func main() {
	http.HandleFunc("/", indexHandler)
	err := http.ListenAndServe(":8000", nil)
	if err != nil {
		panic(err)
	}
}

client端

// context_timeout/client/main.go
package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
)

// 客戶端

type respData struct {
	resp *http.Response
	err  error
}

func doCall(ctx context.Context) {
	transport := http.Transport{
	   // 請求頻繁可定義全局的client對象並啓用長連接
	   // 請求不頻繁使用短連接
	   DisableKeepAlives: true, 	}
	client := http.Client{
		Transport: &transport,
	}

	respChan := make(chan *respData, 1)
	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
	if err != nil {
		fmt.Printf("new requestg failed, err:%v\n", err)
		return
	}
	req = req.WithContext(ctx) // 使用帶超時的ctx建立一個新的client request
	var wg sync.WaitGroup
	wg.Add(1)
	defer wg.Wait()
	go func() {
		resp, err := client.Do(req)
		fmt.Printf("client.do resp:%v, err:%v\n", resp, err)
		rd := &respData{
			resp: resp,
			err:  err,
		}
		respChan <- rd
		wg.Done()
	}()

	select {
	case <-ctx.Done():
		//transport.CancelRequest(req)
		fmt.Println("call api timeout")
	case result := <-respChan:
		fmt.Println("call server api success")
		if result.err != nil {
			fmt.Printf("call server api failed, err:%v\n", result.err)
			return
		}
		defer result.resp.Body.Close()
		data, _ := ioutil.ReadAll(result.resp.Body)
		fmt.Printf("resp:%v\n", string(data))
	}
}

func main() {
	// 定義一個100毫秒的超時
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
	defer cancel() // 調用cancel釋放子goroutine資源
	doCall(ctx)
}

理解GO CONTEXT機制

1 什麼是Context

最近在公司分析gRPC源碼，proto文件生成的代碼，接口函數第一個參數統一是ctx context.Context接口，公司很多同事都不瞭解這樣設計的出發點是什麼，其實我也不瞭解其背後的原理。今天趁着妮妲颱風妹子正面登錄深圳，全市停工、停課、停業，在家休息找了一些資料研究把玩一把。

Context一般被譯做上下文，它是一個比較抽象的概念。在公司技術討論時也常常會提到上下文。通常理解爲程序單元的一個運行狀態、現場、快照，而翻譯中上下又很好地詮釋了其本質，上下上下則是存在上下層的傳遞，上會把內容傳遞給下。在Go語言中，程序單元也就指的是Goroutine。

每一個Goroutine在執行以前，都要先知道程序當前的執行狀態，一般將這些執行狀態封裝在一個Context變量中，傳遞給要執行的Goroutine中。上下文則幾乎已經成爲傳遞與請求同生存週期變量的標準方法。在網絡編程下，當接收到一個網絡請求Request，處理Request時，咱們可能須要開啓不一樣的Goroutine來獲取數據與邏輯處理，即一個請求Request，會在多個Goroutine中處理。而這些Goroutine可能須要共享Request的一些信息；同時當Request被取消或者超時的時候，全部從這個Request建立的全部Goroutine也應該被結束。

2 context包

Go的設計者早考慮多個Goroutine共享數據，以及多Goroutine管理機制。Context介紹請參考Go Concurrency Patterns: Context，golang.org/x/net/context包就是這種機制的實現。

context包不只實現了在程序單元之間共享狀態變量的方法，同時能經過簡單的方法，使咱們在被調用程序單元的外部，經過設置ctx變量值，將過時或撤銷這些信號傳遞給被調用的程序單元。在網絡編程中，若存在A調用B的API, B再調用C的API，若A調用B取消，那也要取消B調用C，經過在A,B,C的API調用之間傳遞Context，以及判斷其狀態，就能解決此問題，這是爲何gRPC的接口中帶上ctx context.Context參數的緣由之一。

Go1.7(當前是RC2版本)已將原來的golang.org/x/net/context包挪入了標準庫中，放在$GOROOT/src/context下面。標準庫中net、net/http、os/exec都用到了context。同時爲了考慮兼容，在原golang.org/x/net/context包下存在兩個文件，go17.go是調用標準庫的context包，而pre_go17.go則是以前的默認實現，其介紹請參考go程序包源碼解讀。

context包的核心就是Context接口，其定義以下：

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}
  • Deadline會返回一個超時時間，Goroutine得到了超時時間後，例如能夠對某些io操做設定超時時間。
  • Done方法返回一個信道（channel），當Context被撤銷或過時時，該信道是關閉的，即它是一個表示Context是否已關閉的信號。
  • 當Done信道關閉後，Err方法代表Context被撤的緣由。
  • Value可讓Goroutine共享一些數據，固然得到數據是協程安全的。但使用這些數據的時候要注意同步，好比返回了一個map，而這個map的讀寫則要加鎖。

Context接口沒有提供方法來設置其值和過時時間，也沒有提供方法直接將其自身撤銷。也就是說，Context不能改變和撤銷其自身。那麼該怎麼經過Context傳遞改變後的狀態呢？

3 context使用

不管是Goroutine，他們的建立和調用關係老是像層層調用進行的，就像人的輩分同樣，而更靠頂部的Goroutine應有辦法主動關閉其下屬的Goroutine的執行（否則程序可能就失控了）。爲了實現這種關係，Context結構也應該像一棵樹，葉子節點須老是由根節點衍生出來的。

要建立Context樹，第一步就是要獲得根節點，context.Background函數的返回值就是根節點：

func Background() Context

該函數返回空的Context，該Context通常由接收請求的第一個Goroutine建立，是與進入請求對應的Context根節點，它不能被取消、沒有值、也沒有過時時間。它經常做爲處理Request的頂層context存在。

有了根節點，又該怎麼建立其它的子節點，孫節點呢？context包爲咱們提供了多個函數來建立他們：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithValue(parent Context, key interface{}, val interface{}) Context

函數都接收一個Context類型的參數parent，並返回一個Context類型的值，這樣就層層建立出不一樣的節點。子節點是從複製父節點獲得的，而且根據接收參數設定子節點的一些狀態值，接着就能夠將子節點傳遞給下層的Goroutine了。

再回到以前的問題：該怎麼經過Context傳遞改變後的狀態呢？使用Context的Goroutine沒法取消某個操做，其實這也是符合常理的，由於這些Goroutine是被某個父Goroutine建立的，而理應只有父Goroutine能夠取消操做。在父Goroutine中能夠經過WithCancel方法得到一個cancel方法，從而得到cancel的權利。

第一個WithCancel函數，它是將父節點複製到子節點，而且還返回一個額外的CancelFunc函數類型變量，該函數類型的定義爲：

type CancelFunc func()

調用CancelFunc對象將撤銷對應的Context對象，這就是主動撤銷Context的方法。在父節點的Context所對應的環境中，經過WithCancel函數不只可建立子節點的Context，同時也得到了該節點Context的控制權，一旦執行該函數，則該節點Context就結束了，則子節點須要相似以下代碼來判斷是否已結束，並退出該Goroutine：

select {
    case <-cxt.Done():
        // do some clean...
}

WithDeadline函數的做用也差很少，它返回的Context類型值一樣是parent的副本，但其過時時間由deadline和parent的過時時間共同決定。當parent的過時時間早於傳入的deadline時間時，返回的過時時間應與parent相同。父節點過時時，其全部的子孫節點必須同時關閉；反之，返回的父節點的過時時間則爲deadline。

WithTimeout函數與WithDeadline相似，只不過它傳入的是從如今開始Context剩餘的生命時長。他們都一樣也都返回了所建立的子Context的控制權，一個CancelFunc類型的函數變量。

當頂層的Request請求函數結束後，咱們就能夠cancel掉某個context，從而層層Goroutine根據判斷cxt.Done()來結束。

WithValue函數，它返回parent的一個副本，調用該副本的Value(key)方法將獲得val。這樣咱們不光將根節點原有的值保留了，還在子孫節點中加入了新的值，注意若存在Key相同，則會被覆蓋。

3.1 小結

context包經過構建樹型關係的Context，來達到上一層Goroutine能對傳遞給下一層Goroutine的控制。對於處理一個Request請求操做，須要採用context來層層控制Goroutine，以及傳遞一些變量來共享。

  • Context對象的生存週期通常僅爲一個請求的處理週期。即針對一個請求建立一個Context變量（它爲Context樹結構的根）；在請求處理結束後，撤銷此ctx變量，釋放資源。

  • 每次建立一個Goroutine，要麼將原有的Context傳遞給Goroutine，要麼建立一個子Context並傳遞給Goroutine。

  • Context能靈活地存儲不一樣類型、不一樣數目的值，而且使多個Goroutine安全地讀寫其中的值。

  • 當經過父Context對象建立子Context對象時，可同時得到子Context的一個撤銷函數，這樣父Context對象的建立環境就得到了對子Context將要被傳遞到的Goroutine的撤銷權。

  • 4 使用原則

    Programs that use Contexts should follow these rules to keep interfaces consistent across packages and enable static analysis tools to check context propagation:
    使用Context的程序包須要遵循以下的原則來知足接口的一致性以及便於靜態分析。

    • Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it. The Context should be the first parameter, typically named ctx；不要把Context存在一個結構體當中，顯式地傳入函數。Context變量須要做爲第一個參數使用，通常命名爲ctx；
    • Do not pass a nil Context, even if a function permits it. Pass context.TODO if you are unsure about which Context to use；即便方法容許，也不要傳入一個nil的Context，若是你不肯定你要用什麼Context的時候傳一個context.TODO；
    • Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions；使用context的Value相關方法只應該用於在程序和接口中傳遞的和請求相關的元數據，不要用它來傳遞一些可選的參數；
    • The same Context may be passed to functions running in different goroutines; Contexts are safe for simultaneous use by multiple goroutines；一樣的Context能夠用來傳遞到不一樣的goroutine中，Context在多個goroutine中是安全的；

    在子Context被傳遞到的goroutine中，應該對該子Context的Done信道（channel）進行監控，一旦該信道被關閉（即上層運行環境撤銷了本goroutine的執行），應主動終止對當前請求信息的處理，釋放資源並返回。

這篇博客分別轉載自兩個大佬的文章：
李文周的博客

這篇偏重於實戰。

http://www.javashuo.com/article/p-ezaxcrps-do.html

這一篇偏重於邏輯分析 。

受益不淺！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程