GVKun编程网logo

疫情数据保存本地json（疫情数据导出）

9

对于疫情数据保存本地json感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍疫情数据导出，并为您提供关于angular请求本地json数据、fastjson解析本地json数据二、fetch获取

对于疫情数据保存本地json感兴趣的读者，本文将会是一篇不错的选择，我们将详细介绍疫情数据导出，并为您提供关于angular 请求本地json数据、fastjson解析本地json数据二、fetch获取本地json文件数据、Go语言将结构体数据保存为JSON格式数据的有用信息。

本文目录一览：

疫情数据保存本地json（疫情数据导出）

疫情数据保存本地json（疫情数据导出）

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
//    "time"
)

// RawData
type RawData struct {
    Ret int `json:"ret"`
    Data string `json:"data"`
}

// TotalData
type TotalData struct {
    Confirm int `json:"confirm"`
    Dead    int `json:"dead"`
    Heal    int `json:"heal"`
    Suspect int `json:"suspect"`
}

// ProvinceTree
type ProvinceTree struct {
    Name     string      `json:"name"`
    Children interface{} `json:"children"`
    Total    TotalData   `json:"total"`
}

// CountryTree
type CountryTree struct {
    Name     string         `json:"name"`
    Children []ProvinceTree `json:"children"`
    Total    TotalData      `json:"total"`
}

// AreaTree
type AreaTree struct {
    Name     string        `json:"name"`
    Children []CountryTree `json:"children"`
}

// ResData
type ResData struct {
    ChinaTotal     interface{} `json:"chinaTotal"`
    ChinaAdd       interface{} `json:"chinaAdd"`
    LastUpdateTime interface{} `json:"lastUpdateTime"`
    AreaTree       []AreaTree `json:"areaTree"`
}

// DetailData
type DetailData struct {
    Ret int `json:"ret"`
    Data ResData `json:"data"`
}

// ResProvinceMap
type ResProvinceData struct {
    Name  string `json:"name"`
    Value int    `json:"value"`
}

// MapData
type MapData struct {
    Ret int `json:"ret"`
    Data []ResProvinceData `json:"data"`
}


// todo func GetJson(xc , ty int) {
func main() {
// todo   for {
    // time.Sleep()
    url := "腾讯 h5 disease url" 
    dataStr := Download(url)

     
    // raw data
    rawData := &RawData{}
    err := json.Unmarshal([]byte(dataStr), rawData)
    if err != nil {
        return
    }
    
    resData := &ResData{}
    err = json.Unmarshal([]byte(rawData.Data), resData)
    if err != nil {
        return
    }

    // detail data
    detailData := DetailData{
        1,
        *resData,
    }
    WriteFile(detailData, "test.json") 

    // map data
    countryCN := AreaTree{}
    for _, country := range resData.AreaTree {
        if country.Name == "中国" {
            countryCN = country
        }
    }

    ProvinceDataList := make([]ResProvinceData, 0, len(countryCN.Children))
    var tmpProvinceData ResProvinceData
    for _, province := range countryCN.Children {
        tmpProvinceData.Name = province.Name
        tmpProvinceData.Value = province.Total.Confirm
        ProvinceDataList = append(ProvinceDataList, tmpProvinceData)
    }
    mapData := &MapData{
        1,
        ProvinceDataList, 
    }
    WriteFile(mapData, "test2.json")
}


func WriteFile(data interface{}, fileName string) {

    // 创建文件
    filePtr, err := os.Create(fileName)
    if err != nil {
        fmt.Println("Create file failed", err.Error())
        return
    }
    defer filePtr.Close()

    // 创建Json编码器
    encoder := json.NewEncoder(filePtr)

    err = encoder.Encode(data)
    if err != nil {
        fmt.Println("Encoder failed", err.Error())
    } else {
        fmt.Println("Encoder success")
    }
}

func Download(url string) (res string){
    client := &http.Client{}
    req, _ := http.NewRequest("GET", url, nil)
    // 自定义Header
    req.Header.Set("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)")

    resp, err := client.Do(req)
    if err != nil {
        // todo xlog.ErrorC(xc, "Download() get error:%v", err)
        return
    }
    //函数结束后关闭相关链接
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // todoxlog.ErrorC(xc, "Download() get while read. error:%v", err)
        return
    }
    res = string(body)
    return
}

angular 请求本地json数据

angular 请求本地json数据

本周写一个前台模块时，发现需要的数据依赖其他模块的支持，但其他模块暂时还不能用，所以需要手动添加模拟数据，然后参考模板demo，发现很有意思的写法，于是就拿来借鉴了。

1. 添加json测试数据

在assets/demo/data目录下创建checkRecord.json文件，如图添加数据：

clipboard.png

2. 请求数据

在check-record.service.ts文件中

getAll(): Observable<CheckRecord[]> {
   return this.http.get<CheckRecord[]>(''assets/demo/data/checkRecord.json'');
}

在check-record.component.ts文件中：

// 获取检定记录
getAllCheckRecords(): void {
    this.checkRecordService.getAll().subscribe((checkRecords: CheckRecord[]) => {
        this.checkRecords = checkRecords;
        console.log(checkRecords);
    }, () => {
        console.log(''network error'');
    });
}

结果发现写完后，控制台报404

clipboard.png

发现请求路径上多了''api''，于是就去改拦截器

intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    // 如果请求的是本地资源，则不进行拦截
    if (req.url.slice(0, 6) !== ''assets'') {
        const apiReq = req.clone({
            url: ''/api'' + req.url
        });
        return next.handle(apiReq);
    } else {
        return next.handle(req);
    }
}

再次请求，请求数据成功：

clipboard.png

总结

发现平时开发还是太依赖前后台相互配合，不能做到完全的前后台分离开发，这次参考别人的写法，学到了一手。

fastjson解析本地json数据二

fastjson解析本地json数据二



具体的fastjson我就不再次介绍了不懂得看我上一篇博客http://blog.csdn.net/kluing/article/details/40982143


先看一下解析的文本内容：

{
"id": "chart1","series": [{
"id": "bar1","type": "bar","groupId": "0","horizonal": false,"percentage": true,"stackType": "stack"
},{
"id": "bar2",{
"id": "bar3","groupId": "1",{
"id": "line1","type": "line","yAxis": "rightAxis"
}],"tools": [{
"type": "categoryTool"
}]
}


下面介绍如何解析assets的json数据文件

先写一个解析的类，具体什么作用我都用log来解释了 ，不懂得可以看下最后的log图与解析的内容比对。

<span>public class JsonTools {
    public static JSONObject jsonData(Context context,String fileName){//filename assets目录下的json文件名
        JSONObject jsonDate=null;
        try {
            InputStreamReader inputStreamReader=new InputStreamReader(context.getAssets().open(fileName),"UTF-8");
            BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
            String line;
            StringBuilder stringBuilder=new StringBuilder();
            while ((line=bufferedReader.readLine())!=null){
                stringBuilder.append(line);
            }
            bufferedReader.close();
            inputStreamReader.close();
            jsonDate=JSON.parSEObject(stringBuilder.toString());//得到JSONobject对象
            Log.e("jsonDate","=="+jsonDate);
            String idArray=jsonDate.getString("id");//得到id的内容
            Log.e("idArray","=="+idArray);
            JSONArray  seriesArray=jsonDate.getJSONArray("series");得到series节点，不懂得看Log打印就清楚了
            Log.e("seriesArray","="+seriesArray);
            List<Series> listSeries=JSON.parseArray(seriesArray.toString(),Series.class);
            for(Series series:listSeries){
                Log.e("series.getId","="+series.getId());
                Log.e("series.getType","="+series.getType());
                Log.e("series.getGroupId","="+series.getGroupId());
                Log.e("series.getHorizonal","="+series.getHorizonal());
                Log.e("series.getPercentage","="+series.getPercentage());
                Log.e("series.getStackType","="+series.getStackType());
                Log.e("series.getyAxis","="+series.getYAxis());
            }
            JSONArray  toolsArray=jsonDate.getJSONArray("tools");得到tools节点
            List<Tools> listTools=JSON.parseArray(toolsArray.toString(),Tools.class);
            for(Tools tools:listTools){
                Log.e("tools.getType","="+tools.getType());
            }

        } catch (IOException e) {
            e.printstacktrace();
        }
        return jsonDate;
    }
}</span>

然后写3个工具类：

<span>public class GroupData {
    private String id;
    private List<Series> seriesList=new ArrayList<Series>();
    private List<Tools> toolsList=new ArrayList<Tools>();

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public List<Series> getSeriesList() {
        return seriesList;
    }

    public void setSeriesList(List<Series> seriesList) {
        this.seriesList = seriesList;
    }

    public List<Tools> getToolsList() {
        return toolsList;
    }

    public void setToolsList(List<Tools> toolsList) {
        this.toolsList = toolsList;
    }
}</span>




<span>public class Series {
    private String id;
    private String type;
    private String groupId;
    private String horizonal;
    private String percentage;
    private String stackType;
    private String yAxis;
    public String getYAxis() {
        return yAxis;
    }

    public void setYAxis(String yAxis) {
        this.yAxis = yAxis;
    }




    public String getStackType() {
        return stackType;
    }

    public void setStackType(String stackType) {
        this.stackType = stackType;
    }

    public String getPercentage() {
        return percentage;
    }

    public void setPercentage(String percentage) {
        this.percentage = percentage;
    }

    public String getHorizonal() {
        return horizonal;
    }

    public void setHorizonal(String horizonal) {
        this.horizonal = horizonal;
    }

    public String getGroupId() {
        return groupId;
    }

    public void setGroupId(String groupId) {
        this.groupId = groupId;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }



}</span>

<span>public class Tools {
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}</span>


这里工具类，具体怎么写这个是需要根据我们的json数据的格式来写的。还有就是用的时候不要忘了导入有关fastjson的jar。

最后看一下打印的Log，版面问题就只截了一部分的图。希望对大家有帮助！！

fetch获取本地json文件数据

fetch获取本地json文件数据

关于这个问题请移步之前写过的文章，那里有详细的介绍：
配置vue.config.js 处理static文件夹下的静态文件

Go语言将结构体数据保存为JSON格式数据

Go语言将结构体数据保存为JSON格式数据

JSON 格式是一种对象文本格式，是当前互联网最常用的信息交换格式之一。在Go语言中，可以使用 json.Marshal() 函数将结构体格式的数据格式化为 JSON 格式。

想要使用 json.Marshal() 函数需要我们先引入 encoding/json 包，示例代码如下： 
package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string
        Level int
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",Age:  37,Skills: []Skill{
            {Name: "Roll and roll",Level: 1},{Name: "Flash your dog eye",Level: 2},{Name: "Time to have Lunch",Level: 3},},}
    result,err := json.Marshal(a)
    if err != nil {
        fmt.Println(err)
    }
    jsonStringData := string(result)
    fmt.Println(jsonStringData)
}
运行结果如下：

{
    "Name":"cow boy",
    "Age":37,
    "Skills":[
        {
            "Name":"Roll and roll",
            "Level":1
        },
        {
            "Name":"Flash your dog eye",
            "Level":2
        },
        {
            "Name":"Time to have Lunch",
            "Level":3
        }
    ]
}

通过运行结果可以看出我们成功的将结构体数据转换成了 JSON 格式。

提示：为了便于查看这里将输出结果做了格式化处理。

在转换 JSON 格式时，JSON 的各个字段名称默认使用结构体的名称，如果想要指定为其它的名称我们可以在声明结构体时添加一个`json:" "`标签，在" "中可以填入我们想要的内容，代码如下所示：
package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string `json:"name"`
        Level int    `json:"level"`
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",err := json.Marshal(a)
    if err != nil {
        fmt.Println(err)
    }
    jsonStringData := string(result)
    fmt.Println(jsonStringData)
}
运行结果如下：

{
    "Name":"cow boy",
    "Skills":[
        {
            "name":"Roll and roll",
            "level":1
        },
        {
            "name":"Flash your dog eye",
            "level":2
        },
        {
            "name":"Time to have Lunch",
            "level":3
        }
    ]
}

通过运行结果可以看出，我们成功将 Skill 结构体的 Name 和 Level 字段转换成了想要的内容。

我们还可以在上面的标签的" "中加入 omitempty（使用逗号,与前面的内容分隔），来过滤掉转换的 JSON 格式中的空值，如下所示：
package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 声明技能结构体
    type Skill struct {
        Name  string `json:"name,omitempty"`
        Level int    `json:"level"`
    }
    // 声明角色结构体
    type Actor struct {
        Name   string
        Age    int
        Skills []Skill
    }
    // 填充基本角色数据
    a := Actor{
        Name: "cow boy",Skills: []Skill{
            {Name: "",{Name: "Flash your dog eye"},

    "Skills":[

        {

            "level":1

        },

            "level":0

        },

            "level":3

        }

    ]

}

通过对比 Skill 结构体的 Name 和 Level 字段可以看出，Name 字段的空值被忽略了，而 Level 字段则没有。

`json:" "` 标签的使用总结为以下几点：

    

  • 
FieldName int `json:"-"`：表示该字段被本包忽略；
    • 

  • 
FieldName int `json:"myName"`：表示该字段在 JSON 里使用“myName”作为键名；
    • 

  • 
FieldName int `json:"myName,omitempty"`：表示该字段在 JSON 里使用“myName”作为键名，并且如果该字段为空时将其省略掉；
    • 

  • 
FieldName int `json:",omitempty"`：该字段在json里的键名使用默认值，但如果该字段为空时会被省略掉，注意 omitempty 前面的逗号不能省略。
    •

关于疫情数据保存本地json和疫情数据导出的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于angular 请求本地json数据、fastjson解析本地json数据二、fetch获取本地json文件数据、Go语言将结构体数据保存为JSON格式数据等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇【One by one系列】一步步学习docker（三）——推送镜像至阿里云（推送镜像到dockerhub）

下一篇C/C++ 信号量 CreateSemaphore 用法（c++信号量有什么用）

相关文章