Creazione di un oggetto json usando jackson

Question

Come posso creare un array JSON come nell'esempio seguente usando jackson.

Ho provato a utilizzare ObjectMapper, ma questo non sembra corretto.

 try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) { 
      for (Path file : ds) { 
       System.out.println("name:"+file.getFileName()+ 
         "\n"+ 
         "mime:"+Files.probeContentType(file)+ 
       "\n"+ 
       "locked:"+!Files.isWritable(file)); 
      } 
     } catch (IOException e) { 
      System.err.println(e); 
     } 

Eventualmente farò un json che ha i valori sotto.

* - (int) size file size in b. required 
* - (int) ts  file modification time in unix time. required 
* - (string) mime mimetype. required for folders, others - optionally 
* - (bool) read read permissions. required 
* - (bool) write write permissions. required 
* - (bool) locked is object locked. optionally 
* - (bool) hidden is object hidden. optionally 
* - (string) alias for symlinks - link target path relative to root path. optionally 
* - (string) target for symlinks - link target path. optionally 

Ecco un esempio di JSON che mi è stato fornito.

"files": [ 
    { 
     "mime": "directory", 
     "ts": 1334071677, 
     "read": 1, 
     "write": 0, 
     "size": 0, 
     "hash": "l1_Lw", 
     "volumeid": "l1_", 
     "name": "Demo", 
     "locked": 1, 
     "dirs": 1 
    }, 
    { 
     "mime": "directory", 
     "ts": 1334071677, 
     "read": 1, 
     "write": 0, 
     "size": 0, 
     "hash": "l1_Lw", 
     "volumeid": "l1_", 
     "name": "Demo", 
     "locked": 1, 
     "dirs": 1 
    }, 
    { 
     "mime": "directory", 
     "ts": 1340114567, 
     "read": 0, 
     "write": 0, 
     "size": 0, 
     "hash": "l1_QmFja3Vw", 
     "name": "Backup", 
     "phash": "l1_Lw", 
     "locked": 1 
    }, 
    { 
     "mime": "directory", 
     "ts": 1310252178, 
     "read": 1, 
     "write": 0, 
     "size": 0, 
     "hash": "l1_SW1hZ2Vz", 
     "name": "Images", 
     "phash": "l1_Lw", 
     "locked": 1 
    }, 
    { 
     "mime": "application\/x-genesis-rom", 
     "ts": 1310347586, 
     "read": 1, 
     "write": 0, 
     "size": 3683, 
     "hash": "l1_UkVBRE1FLm1k", 
     "name": "README.md", 
     "phash": "l1_Lw", 
     "locked": 1 
    } 
] 

EDIT 1

 Map<String, Object> filesMap = new HashMap<>(); 
     List<Object> files = new ArrayList<Object>(); 
     System.out.println("\nNo filter applied:"); 
     try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) { 
      for (Path file : ds) { 
       Map<String, Object> fileInfo = new HashMap<>(); 
       fileInfo.put("name", file.getFileName().toString()); 
//    Prints Files in Director 
//    Files.getAttribute(file,"size"); 
       System.out.println("name:" + file.getFileName().toString() + 
         "\n" + 
         "mime:" + Files.probeContentType(file) + 
         "\n" + 
         "locked:" + !Files.isWritable(file)); 
       ObjectMapper mapper = new ObjectMapper(); 
       String json = mapper.writeValueAsString(fileInfo); 
       files.add(json); 
      } 
     } catch (IOException e) { 
      System.err.println(e); 
     } 
     files.toArray(); 
     filesMap.put("files", files); 
     ObjectMapper mapper = new ObjectMapper(); 
     String jsonString; 
     try { 
      jsonString = mapper.writeValueAsString(filesMap); 
     } catch (IOException e) { 
      jsonString = "fail"; //To change body of catch statement use File | Settings | File Templates. 
     } 

mette fuori la seguente JSON che è più vicino, ma io non riesco a capire perché le virgolette in più prima e dopo il {}.

{"files":["{\"name\":\"32C92124-EFCF-42C1-AFD2-8B741AE6854B.jpg\"}","{\"name\":\"58D5B83F-4065-4D6E-92BE-8181D99CB6CB.jpg\"}","{\"name\":\"7B1464A0-FBA1-429E-8A39-3DE5B539FBF8.jpg\"}","{\"name\":\"888159CF-45BE-475F-8C6A-64B3E1D97278.jpg\"}"]} 

risposta definitiva

Map<String, Object> filesMap = new HashMap<>(); 
    List<Object> files = new ArrayList<Object>(); 
    System.out.println("\nNo filter applied:"); 
    try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) { 
     for (Path file : ds) { 
      Map<String, Object> fileInfo = new HashMap<>(); 
      fileInfo.put("name", file.getFileName().toString()); 
      System.out.println("name:" + file.getFileName().toString() + 
        "\n" + 
        "mime:" + Files.probeContentType(file) + 
        "\n" + 
        "locked:" + !Files.isWritable(file)); 
      files.add(fileInfo); 
     } 
    } catch (IOException e) { 
     System.err.println(e); 
    } 
    files.toArray(); 
    filesMap.put("files", files); 
    ObjectMapper mapper = new ObjectMapper(); 
    String jsonString; 
    try { 
     jsonString = mapper.writeValueAsString(filesMap); 
    } catch (IOException e) { 
     jsonString = "fail"; 
    } 

Answer 1

Hai bisogno di un JsonNodeFactory:

final JsonNodeFactory factory = JsonNodeFactory.instance; 

Questa classe ha metodi per creare ArrayNode s, ObjectNode s, IntNode s, DecimalNode s, TextNode s e quant'altro. ArrayNode s e ObjectNode hanno metodi di mutazione convenienti per aggiungere direttamente la maggior parte dei valori primitivi JSON (non contenitore) senza dover passare attraverso la fabbrica (beh, internamente, fanno riferimento a questa fabbrica, ecco perché).

Per quanto riguarda un ObjectMapper, si noti che è sia un serializzatore (ObjectWriter) che un deserializzatore (ObjectReader).

Answer 2

È possibile scrivere un oggetto in una stringa JSON. Quindi spero che tu abbia i tuoi dati in un oggetto di una classe definita secondo le tue necessità. Ecco come è possibile convertire l'oggetto in una stringa JSON:

//1. Convert Java object to JSON format 
ObjectMapper mapper = new ObjectMapper(); 

String jsonString = mapper.writeValueAsString(yourObject); 

Vedere here per l'intero javadoc jackson-databind.

Answer 3

È possibile eseguire questa operazione senza creare POJO e convertirlo in JSON. Presumo i tuoi dati nell'oggetto Record.

 JsonNode rootNode = mapper.createObjectNode(); 
     ArrayNode childNodes = mapper.createArrayNode(); 
     for (Record record : records) { 
      JsonNode element = mapper.createObjectNode(); 
      ((ObjectNode) element).put("mime": record.getDirectory()); 
        //fill rest of fields which are needed similar to this. 
        //Also here record.getDirectory() method will should return "directory" 
        //according to your json file. 
      childNodes.add(element); 
     } 
     ((ObjectNode) rootNode).put("files", childNodes); 

Answer 4

inizializzazione oggetto JSON come istanza singleton, e costruirlo:

ObjectNode node = JsonNodeFactory.instance.objectNode(); // initializing 
node.put("x", x); // building 

PS: per println uso node.toString().