ทําตามขั้นตอนที่อธิบายไว้ในหน้าอื่นๆ ที่เหลือในอีกประมาณ 5 นาที คุณก็จะมีแอปพลิเคชันบรรทัดคําสั่ง Go ที่เรียบง่ายซึ่งส่งคําขอไปยัง YouTube Data API
โค้ดตัวอย่างที่ใช้ในคําแนะนํานี้จะดึงทรัพยากรchannel
สําหรับช่อง YouTube ของ Google Developers และพิมพ์ข้อมูลพื้นฐานจากทรัพยากรนั้น
สิ่งที่ต้องดำเนินการก่อน
หากต้องการเรียกใช้คู่มือเริ่มต้นฉบับย่อนี้ คุณจะต้องมีสิ่งต่อไปนี้
- ไป แนะนําเวอร์ชันล่าสุด
- Git ขอแนะนําให้ใช้เวอร์ชันล่าสุด
- การเข้าถึงอินเทอร์เน็ตและเว็บเบราว์เซอร์
- บัญชี Google
ขั้นตอนที่ 1: เปิดใช้ YouTube Data API
-
ใช้วิซาร์ดนี้เพื่อสร้างหรือเลือกโปรเจ็กต์ใน Google Developers Console แล้วเปิด API โดยอัตโนมัติ คลิกต่อไป แล้วคลิกไปที่ข้อมูลเข้าสู่ระบบ
-
คลิกปุ่มยกเลิกในหน้าสร้างข้อมูลเข้าสู่ระบบ
-
เลือกแท็บหน้าจอขอความยินยอม OAuth ที่ด้านบนของหน้า เลือกอีเมล ป้อนชื่อผลิตภัณฑ์ หากยังไม่ได้ตั้งค่าไว้ แล้วคลิกปุ่มบันทึก
-
เลือกแท็บข้อมูลเข้าสู่ระบบ คลิกปุ่มสร้างข้อมูลเข้าสู่ระบบ แล้วเลือกรหัสไคลเอ็นต์ OAuth
-
เลือกประเภทแอปพลิเคชัน อื่นๆ จากนั้นป้อนชื่อ "คู่มือเริ่มใช้งาน YouTube Data API ฉบับย่อ" แล้วคลิกปุ่มสร้าง
-
คลิกตกลงเพื่อปิดกล่องโต้ตอบที่ได้รับ
-
คลิกปุ่ม
(ดาวน์โหลด JSON) ทางด้านขวาของรหัสไคลเอ็นต์ -
ย้ายไฟล์ที่ดาวน์โหลดมาไปยังไดเรกทอรีการทํางานและเปลี่ยนชื่อ
client_secret.json
ขั้นตอนที่ 2: เตรียมพื้นที่ทํางาน
- ตั้งค่าตัวแปรสภาพแวดล้อม
GOPATH
เป็นไดเรกทอรีการทํางาน - รับไลบรารีของไคลเอ็นต์ YouTube Data API Go และแพ็กเกจ OAuth2 โดยใช้คําสั่งต่อไปนี้
go get -u google.golang.org/api/youtube/v3
go get -u golang.org/x/oauth2/...
ขั้นตอนที่ 3: ตั้งค่าตัวอย่าง
สร้างไฟล์ชื่อ quickstart.go
ในไดเรกทอรีการทํางาน และคัดลอกโค้ดต่อไปนี้
// Sample Go code for user authorization
package main
import (
"encoding/json"
"fmt"
"log"
"io/ioutil"
"net/http"
"net/url"
"os"
"os/user"
"path/filepath"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/api/youtube/v3"
)
const missingClientSecretsMessage = `
Please configure OAuth 2.0
`
// getClient uses a Context and Config to retrieve a Token
// then generate a Client. It returns the generated Client.
func getClient(ctx context.Context, config *oauth2.Config) *http.Client {
cacheFile, err := tokenCacheFile()
if err != nil {
log.Fatalf("Unable to get path to cached credential file. %v", err)
}
tok, err := tokenFromFile(cacheFile)
if err != nil {
tok = getTokenFromWeb(config)
saveToken(cacheFile, tok)
}
return config.Client(ctx, tok)
}
// getTokenFromWeb uses Config to request a Token.
// It returns the retrieved Token.
func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
fmt.Printf("Go to the following link in your browser then type the "+
"authorization code: \n%v\n", authURL)
var code string
if _, err := fmt.Scan(&code); err != nil {
log.Fatalf("Unable to read authorization code %v", err)
}
tok, err := config.Exchange(oauth2.NoContext, code)
if err != nil {
log.Fatalf("Unable to retrieve token from web %v", err)
}
return tok
}
// tokenCacheFile generates credential file path/filename.
// It returns the generated credential path/filename.
func tokenCacheFile() (string, error) {
usr, err := user.Current()
if err != nil {
return "", err
}
tokenCacheDir := filepath.Join(usr.HomeDir, ".credentials")
os.MkdirAll(tokenCacheDir, 0700)
return filepath.Join(tokenCacheDir,
url.QueryEscape("youtube-go-quickstart.json")), err
}
// tokenFromFile retrieves a Token from a given file path.
// It returns the retrieved Token and any read error encountered.
func tokenFromFile(file string) (*oauth2.Token, error) {
f, err := os.Open(file)
if err != nil {
return nil, err
}
t := &oauth2.Token{}
err = json.NewDecoder(f).Decode(t)
defer f.Close()
return t, err
}
// saveToken uses a file path to create a file and store the
// token in it.
func saveToken(file string, token *oauth2.Token) {
fmt.Printf("Saving credential file to: %s\n", file)
f, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
log.Fatalf("Unable to cache oauth token: %v", err)
}
defer f.Close()
json.NewEncoder(f).Encode(token)
}
func handleError(err error, message string) {
if message == "" {
message = "Error making API call"
}
if err != nil {
log.Fatalf(message + ": %v", err.Error())
}
}
func channelsListByUsername(service *youtube.Service, part string, forUsername string) {
call := service.Channels.List(part)
call = call.ForUsername(forUsername)
response, err := call.Do()
handleError(err, "")
fmt.Println(fmt.Sprintf("This channel's ID is %s. Its title is '%s', " +
"and it has %d views.",
response.Items[0].Id,
response.Items[0].Snippet.Title,
response.Items[0].Statistics.ViewCount))
}
func main() {
ctx := context.Background()
b, err := ioutil.ReadFile("client_secret.json")
if err != nil {
log.Fatalf("Unable to read client secret file: %v", err)
}
// If modifying these scopes, delete your previously saved credentials
// at ~/.credentials/youtube-go-quickstart.json
config, err := google.ConfigFromJSON(b, youtube.YoutubeReadonlyScope)
if err != nil {
log.Fatalf("Unable to parse client secret file to config: %v", err)
}
client := getClient(ctx, config)
service, err := youtube.New(client)
handleError(err, "Error creating YouTube client")
channelsListByUsername(service, "snippet,contentDetails,statistics", "GoogleDevelopers")
}
ขั้นตอนที่ 4: เรียกใช้ตัวอย่าง
สร้างและเรียกใช้ตัวอย่างโดยใช้คําสั่งต่อไปนี้จากไดเรกทอรีการทํางานของคุณ
go run quickstart.go
ครั้งแรกที่เปิดตัวอย่าง จะมีข้อความแจ้งให้คุณให้สิทธิ์เข้าถึง
เรียกดู URL ที่ให้ไว้ในเว็บเบราว์เซอร์
หากยังไม่ได้เข้าสู่ระบบบัญชี Google ระบบจะแจ้งให้คุณลงชื่อเข้าใช้ หากลงชื่อเข้าใช้บัญชี Google หลายบัญชี ระบบจะขอให้คุณเลือก 1 บัญชีที่จะใช้สําหรับการให้สิทธิ์
- คลิกปุ่มยอมรับ
- คัดลอกโค้ดที่ได้รับ แล้ววางในข้อความแจ้งของบรรทัดคําสั่ง แล้วกด Enter
หมายเหตุ
- ระบบจัดเก็บข้อมูลการให้สิทธิ์ไว้ในระบบไฟล์ ดังนั้นคําสั่งที่ตามมาก็คือจะไม่แสดงการให้สิทธิ์
- ขั้นตอนการให้สิทธิ์ในตัวอย่างนี้ออกแบบมาสําหรับแอปพลิเคชันบรรทัดคําสั่ง สําหรับข้อมูลเกี่ยวกับวิธีให้สิทธิ์ในเว็บแอปพลิเคชัน โปรดดูการใช้ OAuth 2.0 สําหรับแอปพลิเคชันเว็บเซิร์ฟเวอร์