salut! GO apprend!
Cette fois, je voudrais insérer avec gorm!
Les données sont l'API que j'ai obtenue la dernière fois Utilisez les données de.
L'article qui a créé la base de données elle-même à partir de GO est ici.
Ensuite, je voudrais commencer.
mysql.go
// root/app/models/fgi.go
package mysql
import (
"database/sql"
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
)
//Connexion DB SQLConnect
func SQLConnect() (database *gorm.DB, err error) {
DBMS := "mysql"
USER := "root"
PASS := ""
PROTOCOL := "tcp(localhost:3306)"
DBNAME := "nom de la table"
CONNECT := USER + ":" + PASS + "@" + PROTOCOL + "/" + DBNAME + "?charset=utf8&parseTime=true&loc=Asia%2FTokyo"
return gorm.Open(DBMS, CONNECT)
}
Ici, on suppose que le DB a déjà été créé. gorm est le package ORM de GO.
Dans la fonction SQLConnect (), déclarez les informations DB et
return gorm.Open(DBMS, CONNECT)
Ce faisant, il est connecté à db. Il peut être préférable de résumer les informations de la base de données dans Config, etc. Cette fois, nous le ferons en tant qu'utilisateur root.
fgi/fgi.go
Voici l'article introduit au début C'est le fichier api dans lequel vous entrez. Je viens de l'avoir dans l'article ci-dessus, mais ici En faisant json.Unmarshal, il est stocké dans la structure préparée.
La structure est ici json-to-go Vous pouvez facilement le préparer sur le site.
Si vous collez json de l'api sur le côté gauche, la structure du code sera préparée.
package fgi
import (
"encoding/json"
"io/ioutil"
"log"
"net/http"
)
//Stockage d'informations sur l'API APIClientFgi
type APIClientFgi struct {
key string
host string
httpClient *http.Client
}
//Nouvelle génération de struct
func New(key, host string) *APIClientFgi {
fgiClient := &APIClientFgi{key, host, &http.Client{}}
return fgiClient
}
//Stockage StructFgi fgi
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"`
}
//Exécution de l'API GetFgi
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
}
La structure générée par json-to-go est appelée et stockée dans la structure par json.Unmarshal.
models/fgi.go
Dans ce fichier, les informations d'API stockées dans la structure ci-dessus sont développées et insérées dans la base de données.
package models
import (
"fmt"
"index-indicator-apis/mysql"
"time"
"index-indicator-apis/config"
"index-indicator-apis/fgi"
)
const (
tableNameFgis = "fgis"
)
//Stockage quotidien FGIS
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"`
}
//migration initFgis
func initFgis() {
var err error
db, err := mysql.SQLConnect()
if err != nil {
panic(err.Error())
}
defer db.Close()
db.AutoMigrate(&Fgis{})
}
// NewFgis fgi.Reçoit StructFgi, le convertit en Fgis et le renvoie
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,
}
}
//Enregistrer Créer un nouveau Fgis
func (f *Fgis) Create() error {
db, err := mysql.SQLConnect()
if err != nil {
panic(err.Error())
}
defer db.Close()
db.Create(&f)
return err
}
//Après la migration de CreateNewFgis, appuyez sur api et enregistrez dans la base de données
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 () utilise la méthode gorm pour la migration.
Étant donné que les informations de l'API ont été stockées dans la structure plus tôt, cela signifie préparer une structure qui la développe et stocke la valeur développée.
db.AutoMigrate (& Fgis {}) Ceci est la méthode AutoMigrate de la méthode gorm.
Il fera migrer le nom de la structure préparée à l'avance comme nom de table. Dans ce cas
Une table appelée fgis est créée dans mysql.
func NewFgis(f fgi.StructFgi) *Fgis{}
Ici, le contenu de StructFgi qui stocke les données de l'API est développé et stocké dans la structure (migrée) préparée pour INSERT.
func (f *Fgis) Create() error {}
Dans cette méthode, après la connexion à db avec SQLConnect () de la fonction créée dans le fichier mysql
db.Create(&f)
INSERT est réalisé par. .Create est la méthode de gorm. En faisant .Create (& struct), les informations de la structure correspondant au nom de la table seront INSERTées.
Enfin, les fonctions et méthodes préparées par CreateNewFgis () sont exécutées.
J'ai pu exécuter cette fonction en toute sécurité en l'appelant depuis main.go.
c'est tout!