使用 json 将 django 日期时间传递到 golang 服务器

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《使用 json 将 django 日期时间传递到 golang 服务器》，涉及到，有需要的可以收藏一下

这是我的 django 模型

class data(models.model):
    created = models.datetimefield(null=true, blank=true, editable=false)
    modified = models.datetimefield(null=true, blank=true)
    raw = models.textfield(null=true, blank=true)
    uuid = models.charfield(blank=true, null=true, max_length=48,unique=true)
    used = models.booleanfield(default=false,null=true)
    name = models.charfield(blank=true, null=true, max_length=200)
    geohash = models.charfield(blank=true, null=true, max_length=200)
    def __str__(self):
        return str(self.created) + ":" + str(self.raw)

    def __unicode__(self):
        return str(self.created) + ":" + str(self.raw)

    def save(self, *args, **kwargs):
        """ on save, update timestamps """
        if not self.uuid :
            self.uuid = str(uuid.uuid4().hex) +str(random.randint(1000,9999) )
        if not self.id:
            self.created = timezone.now()
        self.modified = timezone.now()
        # if not self.geohash and (self.gpslat and self.gpslong):
        # geohash.encode(self.gpslat, self.gpslong)
        return super(datalbc, self).save(*args, **kwargs)
    def tojson(self):
        ret = {}
        ret["created"] = str(self.created)
        ret["modified"] = str(self.modified)
        ret["used"] = self.used
        ret["raw"] = self.raw
        return ret

这是我将其发送到我的 golang 服务器的方式：

from rawoffer.models import data
while true:
    try :
        for data in data.objects.all()[:10]:
            requests.post("http://127.0.0.1:8087/convert/",json=data.tojson())
    except exception as e:
        print(e)
    time.sleep(5)

现在我的 golang 服务器：

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "github.com/jmoiron/sqlx"
    "github.com/lib/pq"
    "strings"
    "gopkg.in/guregu/null.v3"
)

type RawOffer struct {
    RawOfferData string  `json:"Raw"`
    Modified      null.Time    `json:"Modified"`
    Created       null.Time    `json:"Created"`
}

func convertLbc(c *gin.Context) {
    var rawOffer RawOffer
    c.BindJSON(&rawOffer)
    fmt.Println(rawOffer.Created)
    var err error
    s := strings.Split(rawOffer.RawOfferData, `"ads": `)

    s2 := `{ "ads": ` + s[1]
    result := strings.Replace(s2, `, "status": "ready"}]`, ``, -1)
    //fmt.Println(result)
    var rawOfferLbc RawOfferLbc
    if err = json.Unmarshal([]byte(result), &rawOfferLbc); err != nil {
        fmt.Println(result)
        panic(err)
    }
}

var db *sqlx.DB
func main() {
    var err error
    fmt.Println("begin")
    r := gin.Default()
    r.Use(cors.Default())
    r.POST("/convert/",convert)
    r.Run((":8087"))
}

但是对于当我尝试接收它时创建和修改的内容，我有 {0001-01-01 00:00:00 +0000 utc false}

如何序列化 django 日期时间以将其以 json 形式发送以及如何在 golang 中获取它？

我的主要目标是将带有日期的对象从 django 应用程序发送到 golang 中的微服务。所以我需要序列化 ​​django 日期，并且需要编写大量文本，因为如果我没有编写足够的文本，stackoverflow 不会让我发布我的程序...

问候

解决方案

这是一个与该问题相关的工作示例，可能对将来的某人有所帮助。

服务器.go

package main

import (
    "fmt"
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "github.com/jmoiron/sqlx"
    "gopkg.in/guregu/null.v3"
    "strconv"
)


type rawoffer struct {
    used_f        bool          `json:"used_f"`
    used_t        bool          `json:"used_t"`
    rawofferdata  string        `json:"raw"`
    modified      null.time     `json:"modified"`
    created       null.time     `json:"created"`
}

func convert(c *gin.context) {
    var rawoffer rawoffer
    c.bindjson(&rawoffer)

    fmt.println(`used_f       = ` + strconv.formatbool(rawoffer.used_f))
    fmt.println(`used_t       = ` + strconv.formatbool(rawoffer.used_t))
    fmt.println(`rawofferdata = `, rawoffer.rawofferdata)
    fmt.println(`modified     = `, rawoffer.modified)
    fmt.println(`created      = `, rawoffer.created)
}


var db *sqlx.db
func main() {
    fmt.println("begin")
    r := gin.default()
    r.use(cors.default())

    r.post("/convert/", convert)
    r.run((":8087"))
}

测试.py

import requests
import json
import datetime


def default(o):
    if isinstance(o, (datetime.date, datetime.datetime)):
        return o.isoformat() + 'z'

try :
    data = dict(
        created = datetime.datetime.utcnow(),
        modified = datetime.datetime.utcnow(),
        used_f = false,
        used_t = true,
        raw = 'some raw data here',
    )

    datastr = json.dumps(data, default=default)

    print(datastr)
    requests.post("http://127.0.0.1:8087/convert/", datastr)
except exception as e:
    print(e)

登录test.py：

$ python test.py
{"created": "2019-06-09t15:48:38.978230z", "modified": "2019-06-09t15:48:38.978689z", "used_f": false, "used_t": true, "raw": "some raw data here"}

登录服务器：

begin
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] POST   /convert/                 --> main.convert (4 handlers)
[GIN-debug] Listening and serving HTTP on :8087

Used_f       = false
Used_t       = true
RawOfferData =  some raw data here
Modified     =  {2019-06-09 15:48:38.978689 +0000 UTC true}
Created      =  {2019-06-09 15:48:38.97823 +0000 UTC true}
[GIN] 2019/06/09 - 11:48:39 |[97;42m 200 [0m|   16.979399ms |       127.0.0.1 |[97;46m POST    [0m /convert/

默认情况下，django 日期时间字段具有时区支持。你需要换个方式思考。或者您可以使用 django-extentions 。此第三方软件包附带一个创建和修改的日期时间字段，该字段不记录时区，使用这两个字段您将得到类似 {0001-01-01 00:00:00 }

本篇关于《使用 json 将 django 日期时间传递到 golang 服务器》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！