एवरो रिकॉर्ड को क्रमबद्ध/deserializing के बाद स्कैला में java.util.HashMap को JSON में कनवर्ट करना

मैं स्काला के साथ एव्रो मैप कॉम्प्लेक्स टाइप को क्रमबद्ध/deserialize करने की कोशिश कर रहा हूँ।

अक्रमांकन के बाद, मैं हैश मैप को JSON में बदलने के लिए जैक्सन का उपयोग नहीं कर सकता।

मैं निम्नलिखित आउटपुट की उम्मीद कर रहा था:

{"MyKey2":"MyValue2", "MyKey1":MyValue1"}

लेकिन इसके बजाय मुझे निम्न आउटपुट मिल रहा है:

{"MyKey2":{"बाइट्स":"TXlWYWx1ZTI=","Length":8,"byteLength":8},"MyKey1":{"bytes":"TXlWYWx1ZTE=","length":8,"byteLength ":8}}

अक्रमांकन के बाद हैश मैप को कैसे संभालना है इस पर कोई सुराग? कोड:

import java.io.ByteArrayOutputStream

import com.fasterxml.jackson.databind.ObjectMapper
import org.apache.avro.Schema
import org.apache.avro.generic.GenericData.Record
import org.apache.avro.generic.GenericRecord
import org.apache.avro.io._
import org.apache.avro.specific.{SpecificDatumReader, SpecificDatumWriter}

object ScalaSandbox {

  def main(args: Array[String]) {

    //Avro Schema and Schema Parser
    val userSchema =
      """
        |{
        |  "type":"record",
        |  "name":"myrecord",
        |  "fields": [
        |    {"name": "test_str", "type":"string"},
        |    {"name": "test_map", "type": ["null", {"type": "map", "values": "string"}]}
        |  ]
        |}
      """.stripMargin
    val parser = new Schema.Parser()
    val schema = parser.parse(userSchema)

    //Create Record
    val f2map = new java.util.HashMap[String,String]
    f2map.put("MyKey1", "MyValue1")
    f2map.put("MyKey2", "MyValue2")
    val avroRecord: Record = new Record(schema)
    avroRecord.put("test_str", "test")
    avroRecord.put("test_map", f2map)

    //Serialize Record to Avro
    val writer = new SpecificDatumWriter[GenericRecord](schema)
    val out = new ByteArrayOutputStream()
    val encoder: BinaryEncoder = EncoderFactory.get().binaryEncoder(out, null)
    writer.write(avroRecord, encoder)
    encoder.flush()
    out.close()
    val serializedBytes: Array[Byte] = out.toByteArray()

    //Deserialize Record from Avro
    val reader: DatumReader[GenericRecord] = new SpecificDatumReader[GenericRecord](schema)
    val decoder: Decoder = DecoderFactory.get().binaryDecoder(serializedBytes, null)
    val userData: GenericRecord = reader.read(null, decoder)

    //Convert HashMap to JSON
    val test_str: String = userData.get("test_str").toString
    val test_map: java.util.HashMap[String,String] = userData.get("test_map").asInstanceOf[java.util.HashMap[String,String]]
    val example = new Example(test_str, test_map)

    println("toString of HashMap: " + example.get_map.toString) // {MyKey2=MyValue2, MyKey1=MyValue1}
    println("writeValueAsString of Hashmap: " + example.get_map_json) // {"MyKey2":"MyValue2", "MyKey1":MyValue1"}
  }

  class Example(str_field: String, map_field: java.util.HashMap[String,String]) {
    val mapper = new ObjectMapper()
    def get_str: String = str_field
    def get_map: java.util.HashMap[String,String] = map_field
    def get_map_json: String = mapper.writeValueAsString(map_field)
  }

}