返回
软件
分类

3.js获取json数据分页显示,将dict数据转化成json数据后写入json文件

日期: 2020-02-15 21:16 浏览次数 : 70

1.后台action产生json数据。

在Python语言中,json数据与dict字典以及对象之间的转化,是必不可少的操作。

json数据格式

参见json数据格式说明。

如果没操作过json数据,建议先看下上面的文章,有助于理解本文后面的内容。

List blackList = blackService.getBlackInfoList(mobileNum, gatewayid, startDate, endDate); 
int totalRows = blackList.size(); 
StringBuffer sb = new StringBuffer(); 
sb.append("{"totalCount":""+totalRows+"","); 
sb.append(""jsonRoot":["); 
for (int i=0;i<blackList.size();i++) { 
LBlack blackInfo = (LBlack)blackList.get(i); 
sb.append("{"id":""+ blackInfo.getId()); 
sb.append("","); 
sb.append(""mobile":""+ blackInfo.getMobile()); 
sb.append("","); 
sb.append(""province":""+ blackInfo.getProvince()); 
sb.append("","); 
sb.append(""gateway":""+ blackInfo.getGateway()); 
sb.append("","); 
sb.append(""insertTime":""+ blackInfo.getInsertTime()); 
sb.append("","); 
sb.append(""remark":""+ blackInfo.getRemark()); 
sb.append("""); 
sb.append("},"); 
} 
sb.deleteCharAt(sb.lastIndexOf(",")); // 删去最后一个逗号 
sb.append("]}"); 

HttpServletResponse response = ServletActionContext.getResponse(); 
response.setContentType("text/plain"); 
response.getWriter().print(sb);

在Python中自带json库。通过import json导入。

必赢备用网址 ,Go json包

Marshal():Go数据对象 -> json数据
UnMarshal():Json数据 -> Go数据对象

func Marshal(v interface{}) ([]byte, error)func Unmarshal(data []byte, v interface{}) error

2.struts.xml相关配置

在json模块有2个方法,

构建json数据

Marshal()和MarshalIndent()函数可以将数据封装成json数据。

  • struct、slice、array、map都可以转换成json
  • struct转换成json的时候,只有字段首字母大写的才会被转换
  • map转换的时候,key必须为string
  • 封装的时候,如果是指针,会追踪指针指向的对象进行封装

例如:

有一个struct结构:

type Post struct {    Id      int    Content string    Author  string}

这个结构表示博客文章类型,有文章ID,文章内容,文章的提交作者。这没什么可说的,唯一需要指明的是:它是一个struct,struct可以封装成JSON数据

要将这段struct数据转换成json,只需使用Marshal()即可。如下:

post := &Post{1, "Hello World", "userA"}b, err := json.Marshalif err != nil {    fmt.Println}

Marshal()返回的是一个[]byte类型,现在变量b就已经存储了一段[]byte类型的json数据,可以输出它:

fmt.Println)

结果:

{"Id":1,"Content":"Hello World","Author":"userA"}

可以在封装成json的时候进行"美化",使用MarshalIndent()即可自动添加前缀(前缀字符串一般设置为空)和缩进:

c,err := json.MarshalIndent(post,"","t")if err != nil {    fmt.Println}fmt.Println)

结果:

{    "Id": 1,    "Content": "Hello World",    "Author": "userA"}

除了struct,array、slice、map结构都能解析成json,但是map解析成json的时候,key必须只能是string,这是json语法要求的。

例如:

// slice -> jsons := []string{"a", "b", "c"}d, _ := json.MarshalIndent(s, "", "t")fmt.Println)// map -> jsonm := map[string]string{    "a":"aa",    "b":"bb",    "c":"cc",}e,_ := json.MarshalIndent(m,"","t")fmt.Println)

返回结果:

[    "a",    "b",    "c"]{    "a": "aa",    "b": "bb",    "c": "cc"}
<action name="blackList" class="blackAction" method="blackList"> 
<!--plaintext用于显示页面原始代码的结果类型--> 
<result type="plainText"> 
<param name="charSet">UTF-8</param> 
<param name="location">/WEB-INF/jsp/manage/black.jsp</param> 
</result> 
</action>

loads():将json数据转化成dict数据

使用struct tag辅助构建json

struct能被转换的字段都是首字母大写的字段,但如果想要在json中使用小写字母开头的key,可以使用struct的tag来辅助反射。

例如,Post结构增加一个首字母小写的字段createAt。

type Post struct {    Id      int      `json:"ID"`    Content string   `json:"content"`    Author  string   `json:"author"`    Label   []string `json:"label"`}postp := &Post{    2,    "Hello World",    "userB",    []string{"linux", "shell"},    }p, _ := json.MarshalIndent(postp, "", "t")fmt.Println)

结果:

{    "ID": 2,    "content": "Hello World",    "author": "userB",    "label": [        "linux",        "shell"    ]}

使用struct tag的时候,几个注意点:

  1. tag中标识的名称将称为json数据中key的值
  2. tag可以设置为`json:"-"`来表示本字段不转换为json数据,即使这个字段名首字母大写
    • 如果想要json key的名称为字符"-",则可以特殊处理`json:"-,"`,也就是加上一个逗号
  3. 如果tag中带有,omitempty选项,那么如果这个字段的值为0值,即false、0、""、nil等,这个字段将不会转换到json中
  4. 如果字段的类型为bool、string、int类、float类,而tag中又带有,string选项,那么这个字段的值将转换成json字符串

例如:

type Post struct {    Id      int      `json:"ID,string"`    Content string   `json:"content"`    Author  string   `json:"author"`    Label   []string `json:"label,omitempty"`}

3.js获取json数据分页显示

dumps():将dict数据转化成json数据

解析json数据到struct

json数据可以解析到struct或空接口interface{}中(也可以是slice、map等)。理解了上面构建json时的tag规则,理解解析json就很简单了。

例如,下面是一段json数据:

{    "id": 1,    "content": "hello world",    "author": {        "id": 2,        "name": "userA"    },    "published": true,    "label": [],    "nextPost": null,    "comments": [{            "id": 3,            "content": "good post1",            "author": "userB"        },        {            "id": 4,            "content": "good post2",            "author": "userC"        }    ]}

分析下这段json数据:

  1. 顶层的大括号表示是一个匿名对象,映射到Go中是一个struct,假设这个struct名称为Post
  2. 顶层大括号里的都是Post结构中的字段,这些字段因为都是json数据,所以必须都首字母大写,同时设置tag,tag中的名称小写
  3. 其中author是一个子对象,映射到Go中是另一个struct,在Post中这个字段的名称为Author,假设名称和struct名称相同,也为Author
  4. label是一个数组,映射到Go中可以是slice,也可以是array,且因为json array为空,所以Go中的slice/array类型不定,比如可以是int,可以是string,也可以是interface{},对于这里的示例来说,我们知道标签肯定是string
  5. nextPost是一个子对象,映射到Go中是一个struct,但因为json中这个对象为null,表示这个对象不存在,所以无法判断映射到Go中struct的类型。但对此处的示例来说,是没有下一篇文章,所以它的类型应该也是Post类型
  6. comment是子对象,且是数组包围的,映射到Go中,是一个slice/array,slice/array的类型是一个struct

分析之后,对应地去构建struct和struct的tag就很容易了。如下,是根据上面分析构建出来的数据结构:

type Post struct {    ID        int64         `json:"id"`           Content   string        `json:"content"`      Author    Author        `json:"author"`       Published bool          `json:"published"`    Label     []string      `json:"label"`        NextPost  *Post         `json:"nextPost"`     Comments  []*Comment    `json:"comments"` }type Author struct {    ID   int64  `json:"id"`      Name string `json:"name"`}type Comment struct {    ID      int64  `json:"id"`         Content string `json:"content"`    Author  string `json:"author"` }

注意,前面在介绍构建json数据的时候说明过,指针会进行追踪,所以这里反推出来的struct中使用指针类型是没问题的。

于是,解析上面的json数据到Post类型的对象中,假设这个json数据存放在a.json文件中。代码如下:

func main() {    // 打开json文件    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    // 读取json文件,保存到jsonData中    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        var post Post    // 解析json数据到post中    err = json.Unmarshal(jsonData, &post)    if err != nil {        fmt.Println        return    }    fmt.Println}

输出结果:

{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}

也许你已经感受到了,从json数据反推算struct到底有多复杂,虽然逻辑不难,但如果数据复杂一点,这是件非常恶心的事情。所以,使用别人写好的工具来自动转换吧。本文后面有推荐json到数据结构的自动转换工具。

function getJSONData(pn) { 
// alert(pn); 
$.getJSON("blackList.ce", function(data) { 
var totalCount = data.totalCount; // 总记录数 
var pageSize = 10; // 每页显示几条记录 
var pageTotal = Math.ceil(totalCount / pageSize); // 总页数 
var startPage = pageSize * (pn - 1); 
var endPage = startPage + pageSize - 1; 
var $ul = $("#json-list"); 
$ul.empty(); 
for (var i = 0; i < pageSize; i++) { 
$ul.append('<li class="li-tag"></li>'); 
} 
var dataRoot = data.jsonRoot; 
if (pageTotal == 1) { // 当只有一页时 
for (var j = 0; j < totalCount; j++) { 
$(".li-tag").eq(j).append("<input type='checkbox' value='"+parseInt(j + 1)+"'/>") 
.append("" + parseInt(j + 1) 
+ "").append("" + dataRoot[j].mobile 
+ "").append("" + dataRoot[j].province 
+ "").append("" + dataRoot[j].gateway 
+ "").append("" + dataRoot[j].insertTime 
+ "").append("" + dataRoot[j].remark 
+ "") 
} 
} else { 
for (var j = startPage, k = 0; j < endPage, k < pageSize; j++, k++) { 
if( j == totalCount){ 
break; // 当遍历到最后一条记录时,跳出循环 
} 
$(".li-tag").eq(k).append("<input type='checkbox' value='"+parseInt(j + 1)+"'/>") 
.append("" + parseInt(j + 1) 
+ "").append("" + dataRoot[j].mobile 
+ "").append("" + dataRoot[j].province 
+ "").append("" + dataRoot[j].gateway 
+ "").append("" + dataRoot[j].insertTime 
+ "").append("" + dataRoot[j].remark 
+ "") 
} 
} 
$(".page-count").text(pageTotal); 
}) 
} 
function getPage() { 
$.getJSON("blackList.ce", function(data) { 
pn = 1; 
var totalCount = data.totalCount; // 总记录数 
var pageSize = 10; // 每页显示几条记录 
var pageTotal = Math.ceil(totalCount / pageSize); // 总页数 
$("#next").click(function() { 
if (pn == pageTotal) { 
alert("后面没有了"); 
pn = pageTotal; 
} else { 
pn++; 
gotoPage(pn); 
} 
}); 
$("#prev").click(function() { 
if (pn == 1) { 
alert("前面没有了"); 
pn = 1; 
} else { 
pn--; 
gotoPage(pn); 
} 
}) 
$("#firstPage").click(function() { 
pn = 1; 
gotoPage(pn); 
}); 
$("#lastPage").click(function() { 
pn = pageTotal; 
gotoPage(pn); 
}); 
$("#page-jump").click(function(){ 
if($(".page-num").val() <= pageTotal && $(".page-num").val() != ''){ 
pn = $(".page-num").val(); 
gotoPage(pn); 
}else{ 
alert("您输入的页码有误!"); 
$(".page-num").val('').focus(); 
} 
}) 
$("#firstPage").trigger("click"); 

}) 
} 
function gotoPage(pn) { 
// alert(pn); 
$(".current-page").text(pn); 
getJSONData(pn) 
} 

$(function() { 
getPage(); 
})

load():读取json文件数据,转成dict数据

解析json到interface

上面是已知json数据结构的解析方式,如果json结构是未知的或者结构可能会发生改变的情况,则解析到struct是不合理的。这时可以解析到空接口interface{}map[string]interface{}类型上,这两种类型的结果是完全一致的。

解析到interface{}上时,Go类型和JSON类型的对应关系如下

  JSON类型             Go类型                ---------------------------------------------JSON objects    <-->  map[string]interface{} JSON arrays     <-->  []interface{}          JSON booleans   <-->  bool                   JSON numbers    <-->  float64                JSON strings    <-->  string                 JSON null       <-->  nil                    

例如:

func main() {    // 读取json文件    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        // 定义空接口接收解析后的json数据    var unknown interface{}    // 或:map[string]interface{} 结果是完全一样的    err = json.Unmarshal(jsonData, &unknown)    if err != nil {        fmt.Println        return    }    fmt.Println}

输出结果:

map[nextPost:<nil> comments:[map[id:3 content:good post1author:userB] map[id:4 content:good post2 author:userC]]id:1 content:hello world author:map[id:2 name:userA] published:true label:[]]

上面将输出map结构。这是显然的,因为类型对应关系中已经说明了,json object解析到Go interface的时候,对应的是map结构。如果将上面输出的结构进行一下格式化,得到的将是类似下面的结构:

map[    nextPost:<nil>    comments:[        map[            id:3            content:good post1            author:userB        ]        map[            id:4            content:good post2            author:userC        ]    ]    id:1    content:hello world    author:map[        id:2        name:userA    ]    published:true    label:[]]

现在,可以从这个map中去判断类型、取得对应的值。但是如何判断类型?可以使用类型断言:

func main() {    // 读取json数据    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        // 解析json数据到interface{}    var unknown interface{}    err = json.Unmarshal(jsonData, &unknown)    if err != nil {        fmt.Println        return    }    // 进行断言,并switch匹配    m := unknown.(map[string]interface{})    for k, v := range m {        switch vv := v. {        case string:            fmt.Println(k, "type: stringnvalue: ", vv)            fmt.Println("------------------")        case float64:            fmt.Println(k, "type: float64nvalue: ", vv)            fmt.Println("------------------")        case bool:            fmt.Println(k, "type: boolnvalue: ", vv)            fmt.Println("------------------")        case map[string]interface{}:            fmt.Println(k, "type: map[string]interface{}nvalue: ", vv)            for i, j := range vv {                fmt.Println(i,": ",j)            }            fmt.Println("------------------")        case []interface{}:            fmt.Println(k, "type: []interface{}nvalue: ", vv)            for key, value := range vv {                fmt.Println(key, ": ", value)            }            fmt.Println("------------------")        default:            fmt.Println(k, "type: nilnvalue: ", vv)            fmt.Println("------------------")        }    }}

结果如下:

comments type: []interface{}value:  [map[id:3 content:good post1 author:userB] map[author:userC id:4 content:good post2]]0 :  map[id:3 content:good post1 author:userB]1 :  map[id:4 content:good post2 author:userC]------------------id type: float64value:  1------------------content type: stringvalue:  hello world------------------author type: map[string]interface{}value:  map[id:2 name:userA]name :  userAid :  2------------------published type: boolvalue:  true------------------label type: []interface{}value:  []------------------nextPost type: nilvalue:  <nil>------------------

可见,从interface中解析非常复杂,而且可能因为嵌套结构而导致无法正确迭代遍历。这时候,可以使用第三方包simplejson,见后文。

必赢备用网址 1

dump():将dict数据转化成json数据后写入json文件

解析、创建json流

除了可以直接解析、创建json数据,还可以处理流式数据。

  • type Decoder解码json到Go数据结构
  • type Encoder编码Go数据结构到json

例如:

const jsonStream = `    {"Name": "Ed", "Text": "Knock knock."}    {"Name": "Sam", "Text": "Who's there?"}    {"Name": "Ed", "Text": "Go fmt."}    {"Name": "Sam", "Text": "Go fmt who?"}    {"Name": "Ed", "Text": "Go fmt yourself!"}`type Message struct {    Name, Text string}dec := json.NewDecoder(strings.NewReader(jsonStream))for {    var m Message    if err := dec.Decode; err == io.EOF {        break    } else if err != nil {        log.Fatal    }    fmt.Printf("%s: %sn", m.Name, m.Text)}

输出:

Ed: Knock knock.Sam: Who's there?Ed: Go fmt.Sam: Go fmt who?Ed: Go fmt yourself!

再例如,从标准输入读json数据,解码后删除名为Name的元素,最后重新编码后输出到标准输出。

func main() {    dec := json.NewDecoder    enc := json.NewEncoder(os.Stdout)    for {        var v map[string]interface{}        if err := dec.Decode; err != nil {            log.Println            return        }        for k := range v {            if k != "Name" {                delete            }        }        if err := enc.Encode; err != nil {            log.Println        }    }}

下面是具体的示例:

json转Go数据结构工具推荐

quicktype工具,可以轻松地将json文件转换成各种语言对应的数据结构。

地址:

在vscode中有相关插件

  1. 先在命令面板中输入"set quicktype target language"选择要将json转换成什么语言的数据结构
  2. 再输入"open quicktype for json"就可以将当前json文件转换对应的数据结构

转换后只需按实际的需求稍微修改一部分类型即可。比如为json顶级匿名对象对应的struct设定名称,还有一些无法转换成struct时因为判断数据类型而使用的interface{}类型也要改一改。

例如,下面是使用quicktype工具对前面示例json数据进行转换后的数据结构:

type A struct {    ID        int64         `json:"id"`           Content   string        `json:"content"`      Author    Author        `json:"author"`       Published bool          `json:"published"`    Label     []interface{} `json:"label"`        NextPost  interface{}   `json:"nextPost"`     Comments  []Comment     `json:"comments"` }type Author struct {    ID   int64  `json:"id"`      Name string `json:"name"`}type Comment struct {    ID      int64  `json:"id"`         Content string `json:"content"`    Author  string `json:"author"` }

其中需要将type A struct的A改成你自己的名称,将A中的interface{}也改成合理的类型。

dict字典转json数据

import json
def dict_to_json():
 dict = {}
 dict['name'] = 'many'
 dict['age'] = 10
 dict['sex'] = 'male'
 print(dict) # 输出:{'name': 'many', 'age': 10, 'sex': 'male'}
 j = json.dumps(dict)
 print(j) # 输出:{"name": "many", "age": 10, "sex": "male"}
if __name__ == '__main__':
 dict_to_json()

对象转json数据

import json
def obj_to_json():
 stu = Student('007', '007', 28, 'male', '13000000000', '123@qq.com')
 print(type(stu)) # <class 'json_test.student.Student'>
 stu = stu.__dict__ # 将对象转成dict字典
 print(type(stu)) # <class 'dict'>
 print(stu) # {'id': '007', 'name': '007', 'age': 28, 'sex': 'male', 'phone': '13000000000', 'email': '123@qq.com'}
 j = json.dumps(obj=stu)
 print(j) # {"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "123@qq.com"}
if __name__ == '__main__':
 obj_to_json()

json数据转成dict字典

import json
def json_to_dict():
 j = '{"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "123@qq.com"}'
 dict = json.loads(s=j)
 print(dict) # {'id': '007', 'name': '007', 'age': 28, 'sex': 'male', 'phone': '13000000000', 'email': '123@qq.com'}
if __name__ == '__main__':
 json_to_dict()

json数据转成对象

import json
def json_to_obj():
 j = '{"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "123@qq.com"}'
 dict = json.loads(s=j)
 stu = Student()
 stu.__dict__ = dict
 print('id: ' + stu.id + ' name: ' + stu.name + ' age: ' + str(stu.age) + ' sex: ' + str(
 stu.sex) + ' phone: ' + stu.phone + ' email: ' + stu.email) # id: 007 name: 007 age: 28 sex: male phone: 13000000000 email: 123@qq.com
if __name__ == '__main__':
 json_to_obj()

json的load()与dump()方法的使用

dump()方法的使用

import json
def dict_to_json_write_file():
 dict = {}
 dict['name'] = 'many'
 dict['age'] = 10
 dict['sex'] = 'male'
 print(dict) # {'name': 'many', 'age': 10, 'sex': 'male'}
 with open('1.json', 'w') as f:
 json.dump(dict, f) # 会在目录下生成一个1.json的文件,文件内容是dict数据转成的json数据
if __name__ == '__main__':
 dict_to_json_write_file()

load()的使用

import json
def json_file_to_dict():
 with open('1.json', 'r') as f:
 dict = json.load(fp=f)
 print(dict) # {'name': 'many', 'age': 10, 'sex': 'male'}
if __name__ == '__main__':
 json_file_to_dict()

以上这篇Python之dict(或对象)与json之间的互相转化实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:

  • Python中字典和JSON互转操作实例
  • python 对象和json互相转换方法
  • python对json的相关操作实例详解
  • 深入理解python对json的操作总结