Hallo! GO lernt!
Diesmal möchte ich mit gorm einfügen!
Daten sind die API, die ich zuletzt erhalten habe Verwenden Sie die Daten von.
Der Artikel, der die Datenbank selbst aus GO erstellt hat, ist hier.
Dann möchte ich anfangen.
mysql.go
// root/app/models/fgi.go
package mysql
import (
"database/sql"
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
)
//SQLConnect DB-Verbindung
func SQLConnect() (database *gorm.DB, err error) {
DBMS := "mysql"
USER := "root"
PASS := ""
PROTOCOL := "tcp(localhost:3306)"
DBNAME := "Tabellenname"
CONNECT := USER + ":" + PASS + "@" + PROTOCOL + "/" + DBNAME + "?charset=utf8&parseTime=true&loc=Asia%2FTokyo"
return gorm.Open(DBMS, CONNECT)
}
Hierbei wird davon ausgegangen, dass die DB bereits angelegt wurde. gorm ist das ORM-Paket von GO.
Deklarieren Sie in der Funktion SQLConnect () die DB-Informationen und
return gorm.Open(DBMS, CONNECT)
Auf diese Weise wird es mit db verbunden. Es ist möglicherweise besser, die DB-Informationen in Config usw. zusammenzufassen. Dieses Mal werden wir es als Root-Benutzer tun.
fgi/fgi.go
Dies ist der am Anfang eingeführte Artikel Dies ist die API-Datei, die Sie erhalten. Ich habe es gerade im obigen Artikel bekommen, aber hier Mit json.Unmarshal wird es in der vorbereiteten Struktur gespeichert.
Die Struktur ist hier json-to-go Sie können es einfach auf der Website vorbereiten.
Wenn Sie json von api auf der linken Seite einfügen, wird struct im Code vorbereitet.
package fgi
import (
"encoding/json"
"io/ioutil"
"log"
"net/http"
)
//APIClientFgi api Informationsspeicher
type APIClientFgi struct {
key string
host string
httpClient *http.Client
}
//Neue Strukturgenerierung
func New(key, host string) *APIClientFgi {
fgiClient := &APIClientFgi{key, host, &http.Client{}}
return fgiClient
}
//StructFgi fgi Speicher
type StructFgi struct {
Fgi struct {
Current struct {
Value int `json:"value"`
ValueText string `json:"valueText"`
} `json:"now"`
PreviousClose struct {
Value int `json:"value"`
ValueText string `json:"valueText"`
} `json:"previousClose"`
OneWeekAgo struct {
Value int `json:"value"`
ValueText string `json:"valueText"`
} `json:"oneWeekAgo"`
OneMonthAgo struct {
Value int `json:"value"`
ValueText string `json:"valueText"`
} `json:"oneMonthAgo"`
OneYearAgo struct {
Value int `json:"value"`
ValueText string `json:"valueText"`
} `json:"oneYearAgo"`
} `json:"fgi"`
}
//GetFgi API-Ausführung
func (fgi *APIClientFgi) GetFgi() (StructFgi, error) {
url := "https://fear-and-greed-index.p.rapidapi.com/v1/fgi"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-rapidapi-host", fgi.host)
req.Header.Add("x-rapidapi-key", fgi.key)
res, err := http.DefaultClient.Do(req)
if err != nil {
return StructFgi{}, nil
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return StructFgi{}, nil
}
var fgiStruct StructFgi
if err := json.Unmarshal(body, &fgiStruct); err != nil {
log.Fatal(err)
}
return fgiStruct, nil
}
Die von json-to-go generierte Struktur wird von json.Unmarshal aufgerufen und in der Struktur gespeichert.
models/fgi.go
In dieser Datei werden die in der obigen Struktur gespeicherten API-Informationen erweitert und in die Datenbank eingefügt.
package models
import (
"fmt"
"index-indicator-apis/mysql"
"time"
"index-indicator-apis/config"
"index-indicator-apis/fgi"
)
const (
tableNameFgis = "fgis"
)
//Fgis tägliche Lagerung
type Fgis struct {
CreatedAt time.Time `json:"created_at,omitempty"`
NowValue int `json:"now_value,omitempty"`
NowText string `json:"now_text,omitempty"`
PcValue int `json:"pc_value,omitempty"`
PcText string `json:"pc_text,omitempty"`
OneWValue int `json:"one_w_value,omitempty"`
OneWText string `json:"one_w_text,omitempty"`
OneMValue int `json:"one_m_value,omitempty"`
OneMText string `json:"one_m_text,omitempty"`
OneYValue int `json:"one_y_value,omitempty"`
OneYText string `json:"one_y_text,omitempty"`
}
//initFgis-Migration
func initFgis() {
var err error
db, err := mysql.SQLConnect()
if err != nil {
panic(err.Error())
}
defer db.Close()
db.AutoMigrate(&Fgis{})
}
// NewFgis fgi.Empfängt StructFgi, konvertiert es in Fgis und gibt es zurück
func NewFgis(f fgi.StructFgi) *Fgis {
createdAt := time.Now()
nowValue := f.Fgi.Current.Value
nowText := f.Fgi.Current.ValueText
pcValue := f.Fgi.PreviousClose.Value
pcText := f.Fgi.PreviousClose.ValueText
oneWValue := f.Fgi.OneWeekAgo.Value
oneWText := f.Fgi.OneWeekAgo.ValueText
oneMValue := f.Fgi.OneMonthAgo.Value
oneMText := f.Fgi.OneMonthAgo.ValueText
oneYValue := f.Fgi.OneYearAgo.Value
oneYText := f.Fgi.OneYearAgo.ValueText
return &Fgis{
createdAt,
nowValue,
nowText,
pcValue,
pcText,
oneWValue,
oneWText,
oneMValue,
oneMText,
oneYValue,
oneYText,
}
}
//Speichern Neue Fgis erstellen
func (f *Fgis) Create() error {
db, err := mysql.SQLConnect()
if err != nil {
panic(err.Error())
}
defer db.Close()
db.Create(&f)
return err
}
//Drücken Sie nach der Migration von CreateNewFgis auf api und speichern Sie es in db
func CreateNewFgis() error {
// initFgis() migration
fgiClient := fgi.New(config.Config.FgiAPIKey, config.Config.FgiAPIHost)
f, err := fgiClient.GetFgi()
if err != nil {
return err
}
fgi := NewFgis(f)
fmt.Println(fgi)
fmt.Println(fgi.Create())
return err
}
InitFgis () verwendet die gorm-Methode für die Migration.
Da die API-Informationen früher in der Struktur gespeichert wurden, bedeutet dies, dass eine Struktur vorbereitet wird, die sie erweitert und den erweiterten Wert speichert.
db.AutoMigrate (& Fgis {}) Dies ist die AutoMigrate-Methode der Gorm-Methode.
Der Name der zuvor vorbereiteten Struktur wird als Tabellenname migriert. In diesem Fall
Eine Tabelle namens fgis wird in MySQL erstellt.
func NewFgis(f fgi.StructFgi) *Fgis{}
Hier wird der Inhalt von StructFgi, in dem API-Daten gespeichert sind, erweitert und in der für INSERT vorbereiteten Struktur (migriert) gespeichert.
func (f *Fgis) Create() error {}
Bei dieser Methode wird nach dem Herstellen einer Verbindung mit dQ mit SQLConnect () die in der MySQL-Datei erstellte Funktion erstellt
db.Create(&f)
INSERT wird realisiert von. .Create ist die Methode von Gorm. Durch Ausführen von .Create (& struct) werden die Informationen der Struktur, die dem Tabellennamen entspricht, eingefügt.
Schließlich werden die von "CreateNewFgis ()" vorbereiteten Funktionen und Methoden ausgeführt.
Ich konnte diese Funktion sicher ausführen, indem ich sie von main.go aus aufrief.
das ist alles!