SpringBoot中实现JSON转Word格式的示例详解

<!-- json 相关依赖 -->
<dependency>
    <groupid>com.fasterxml.jackson.core</groupid>
    <artifactid>jackson-databind</artifactid>
    <version>2.13.3</version>
</dependency>
 
<!-- apache poi 相关依赖 -->
<dependency>
    <groupid>org.apache.poi</groupid>
    <artifactid>poi-ooxml</artifactid>
    <version>5.2.3</version>
</dependency>
 
<dependency>
    <groupid>org.apache.poi</groupid>
    <artifactid>poi</artifactid>
    <version>5.2.3</version>
</dependency>

import com.fasterxml.jackson.databind.objectmapper;
import org.apache.poi.xwpf.usermodel.xwpfdocument;
import org.apache.poi.xwpf.usermodel.xwpfparagraph;
import org.springframework.http.responseentity;
import org.springframework.web.bind.annotation.*;
 
import java.io.bytearrayoutputstream;
import java.io.ioexceptionimport;
 java.util.map;
 
@restcontroller
@requestmapping("/json-to-word")
public class jsontowordcontroller {
 
    @postmapping
    public responseentity<byte[]> jsontoword(@requestbody map<string, object> json) throws ioexception {
        // 创建一个 word 文档
        xwpfdocument document = new xwpfdocument();
 
        // 创建一个新的段落
        xwpfparagraph paragraph = document.createparagraph();
        // 设置段落的文本内容为 json 的字符串形式
        paragraph.createrun().settext(new objectmapper().writevalueasstring(json));
 
        // 将 word 文档转换为字节数组
        bytearrayoutputstream outputstream = new bytearrayoutputstream();
        document.write(outputstream);
        byte[] wordbytes = outputstream.tobytearray();
 
        // 设置响应头，指定内容类型为 word 文，并档设置文件名
        return responseentity.ok()
                .header("content-type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
                .header("content-disposition", "attachment; filename=generated-word.docx")
                .body(wordbytes);
    }
}

        <dependency>
            <groupid>com.fasterxml.jackson.core</groupid>
            <artifactid>jackson-databind</artifactid>
            <version>2.11.1</version>
        </dependency>

        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

package test;
 
import com.fasterxml.jackson.databind.objectmapper;
 
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;
import java.util.map;
 
public class test {
 
    public static void main(string[] args) throws exception {
        objectmapper mapper = new objectmapper();
 
        map<string, object> person = new hashmap<>();
        person.put("name", "zhangsan");
        person.put("age", 18);
 
        list<map<string, object>> personlist = new arraylist<>();
        personlist.add(person);
 
        //对象转json字符串
        string jsonmap = mapper.writevalueasstring(person);
        system.out.println(jsonmap);//{"name":"zhangsan","age":18}
        string jsonlist = mapper.writevalueasstring(personlist);
        system.out.println(jsonlist);//[{"name":"zhangsan","age":18}]
 
        //json字符串转对象
        map<string, object> map = mapper.readvalue(jsonmap, map.class);
        list<map<string, object>> list = mapper.readvalue(jsonlist, list.class);
        system.out.println();
    }
}

from docx import document
from io import bytesio

openapi_data = {
    "openapi": "3.1.0",
    "info": {
        "title": "fastapi",
        "version": "0.1.0"
    },
    "paths": {

        "/download-model": {
            "post": {
                "summary": "download model",
                "description": "下载训练好的模型文件的api端点。\n\nargs:\n    request (downloadrequest): 包含模型文件路径的请求体。 file_path: str  # 文件路径，必须提供\n\nreturns:\n    fileresponse: 返回模型文件流。\n\nraises:\n    httpexception: 如果文件不存在，返回404错误。\n    httpexception: 如果路径无效，返回400错误。",
                "operationid": "download_model_download_model_post",
                "requestbody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/downloadrequest"
                            }
                        }
                    },
                    "required": true
                },
                "responses": {
                    "200": {
                        "description": "successful response",
                        "content": {
                            "application/json": {
                                "schema": {}
                            }
                        }
                    },
                    "422": {
                        "description": "validation error",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/httpvalidationerror"
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    "components": {

    }
}

doc = document()
doc.add_heading('api documentation', 0)

# add api information
doc.add_heading('api information', level=1)
doc.add_paragraph(f"title: {openapi_data['info']['title']}")
doc.add_paragraph(f"version: {openapi_data['info']['version']}")

# add path information
doc.add_heading('api endpoints', level=1)
for path, methods in openapi_data['paths'].items():
    for method, details in methods.items():
        doc.add_heading(f"{method.upper()} {path}", level=2)
        doc.add_paragraph(f"summary: {details.get('summary', 'no summary')}")
        doc.add_paragraph(f"description: {details.get('description', 'no description')}")
        if 'requestbody' in details:
            doc.add_heading('request body', level=3)
            for content_type, content in details['requestbody']['content'].items():
                doc.add_paragraph(f"content-type: {content_type}")
                schema_ref = content['schema'].get('$ref', none)
                if schema_ref:
                    schema_name = schema_ref.split('/')[-1]
                    schema = openapi_data['components']['schemas'][schema_name]
                    doc.add_paragraph(f"schema: {schema_name}")
                    doc.add_paragraph(f"description: {schema.get('description', 'no description')}")
                    doc.add_paragraph(f"required: {', '.join(schema.get('required', []))}")
                    doc.add_paragraph(f"properties:")
                    for prop, prop_details in schema.get('properties', {}).items():
                        doc.add_paragraph(f"- {prop} ({prop_details.get('type', 'unknown')}): {prop_details.get('title', '')}")

        if 'responses' in details:
            doc.add_heading('responses', level=3)
            for status_code, response in details['responses'].items():
                doc.add_paragraph(f"status code: {status_code}")
                doc.add_paragraph(f"description: {response.get('description', 'no description')}")

# save the document to a bytesio buffer
buffer = bytesio()
doc.save(buffer)
buffer.seek(0)

# save the file to disk (or you can return it as a download in a web app)
with open("api_documentation.docx", "wb") as f:
    f.write(buffer.read())