นโยบาย XMLtoJSON

คุณกำลังดูเอกสารประกอบของ Apigee Edge
ไปที่เอกสารประกอบของ Apigee X
ข้อมูล

อะไร

นโยบายนี้จะแปลงข้อความจากรูปแบบภาษามาร์กอัป (XML) ที่ขยายได้เป็น JavaScript Object Notation (JSON) เพื่อให้คุณควบคุมวิธีแปลงข้อความได้หลายวิธี

สมมติว่าความตั้งใจคือการแปลงการตอบกลับในรูปแบบ XML เป็นการตอบกลับในรูปแบบ JSON ระบบจะแนบนโยบายไปกับโฟลว์การตอบกลับ (เช่น Response / ProxyEndpoint / PostFlow)

เกี่ยวกับ

ในสถานการณ์สื่อกลางทั่วไป นโยบาย JSON เป็น XML บนโฟลว์คำขอขาเข้ามักจะจับคู่กับนโยบาย XML เป็น JSON ในขั้นตอนการตอบสนองขาออก การรวมนโยบายด้วยวิธีนี้จะทำให้ระบบแสดง JSON API สำหรับบริการแบ็กเอนด์ที่รองรับ XML เพียงอย่างเดียวได้

สำหรับสถานการณ์ที่แอปไคลเอ็นต์ที่หลากหลายใช้ API ซึ่งอาจต้องใช้ JSON หรือ XML ก็สามารถตั้งค่ารูปแบบการตอบสนองแบบไดนามิกได้โดยกำหนดค่านโยบาย JSON เป็น XML และ XML เป็น JSON เพื่อดำเนินการตามเงื่อนไข ดูตัวแปรและเงื่อนไขสำหรับโฟลว์สำหรับการนำสถานการณ์นี้ไปใช้


ลองฟัง

สำหรับการสนทนาโดยละเอียดเกี่ยวกับการแปลงระหว่าง JSON และ XML โปรดดู http://community.apigee.com/articles/1839/converting-between-xml-and-json-what-you-need-to-k.html

กำลังแปลงคำตอบ

<XMLToJSON name="ConvertToJSON">
  <Options>
  </Options>
  <OutputVariable>response</OutputVariable>
  <Source>response</Source>
</XMLToJSON>

การกำหนดค่านี้เป็นการกำหนดค่าขั้นต่ำสุดที่จำเป็นในการแปลง XML เป็น JSON จะนำข้อความตอบกลับในรูปแบบ XML เป็นแหล่งที่มา จากนั้นสร้างข้อความรูปแบบ JSON ที่มีการป้อนข้อมูลใน response ExportVariable Edge จะใช้เนื้อหาของตัวแปรนี้เป็นข้อความโดยอัตโนมัติสำหรับขั้นตอนการประมวลผลถัดไป


การอ้างอิงองค์ประกอบ

ต่อไปนี้คือองค์ประกอบและแอตทริบิวต์ที่คุณสามารถกำหนดค่าในนโยบายนี้ได้

<XMLToJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">
    <DisplayName>XML to JSON 1</DisplayName>
    <Source>response</Source>
    <OutputVariable>response</OutputVariable>
    <Options>
        <RecognizeNumber>true</RecognizeNumber>
        <RecognizeBoolean>true</RecognizeBoolean>
        <RecognizeNull>true</RecognizeNull>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
        <NamespaceSeparator>***</NamespaceSeparator>
        <TextAlwaysAsProperty>true</TextAlwaysAsProperty>
        <TextNodeName>TEXT</TextNodeName>
        <AttributeBlockName>FOO_BLOCK</AttributeBlockName>
        <AttributePrefix>BAR_</AttributePrefix>
        <OutputPrefix>PREFIX_</OutputPrefix>
        <OutputSuffix>_SUFFIX</OutputSuffix>
        <StripLevels>2</StripLevels>
        <TreatAsArray>
            <Path unwrap="true">teachers/teacher/studentnames/name</Path>
        </TreatAsArray>
    </Options>
    <!-- Use Options or Format, not both -->
    <Format>yahoo</Format>
</XMLToJSON>

แอตทริบิวต์ <XMLtoJSON>

<XMLtoJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1"> 

ตารางต่อไปนี้อธิบายแอตทริบิวต์ที่ใช้ร่วมกันในองค์ประกอบระดับบนสุดของนโยบายทั้งหมด

แอตทริบิวต์ คำอธิบาย ค่าเริ่มต้น การมีบุคคลอยู่
name

ชื่อภายในของนโยบาย ค่าของแอตทริบิวต์ name มีตัวอักษร ตัวเลข ช่องว่าง ขีดกลาง ขีดล่าง และจุด ค่านี้ต้องมีอักขระไม่เกิน 255 ตัว

(ไม่บังคับ) ใช้องค์ประกอบ <DisplayName> เพื่อติดป้ายกำกับนโยบายในเครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติที่แตกต่างออกไป

ไม่มีข้อมูล จำเป็น
continueOnError

ตั้งค่าเป็น false เพื่อแสดงผลข้อผิดพลาดเมื่อนโยบายล้มเหลว ซึ่งถือเป็นเรื่องปกติสำหรับนโยบายส่วนใหญ่

ตั้งค่าเป็น true เพื่อให้การดำเนินการโฟลว์ดำเนินต่อไปได้แม้ว่านโยบายจะล้มเหลวก็ตาม

false ไม่บังคับ
enabled

ตั้งค่าเป็น true เพื่อบังคับใช้นโยบาย

ตั้งค่าเป็น false เพื่อปิดนโยบาย ระบบจะไม่บังคับใช้นโยบายแม้ว่าจะยังแนบอยู่กับขั้นตอนก็ตาม

จริง ไม่บังคับ
async

แอตทริบิวต์นี้เลิกใช้งานแล้ว

false เลิกใช้

องค์ประกอบ <DisplayName>

ใช้เพิ่มเติมจากแอตทริบิวต์ name เพื่อติดป้ายกำกับนโยบายในเครื่องมือแก้ไขพร็อกซี UI การจัดการด้วยชื่อที่เป็นภาษาธรรมชาติที่แตกต่างออกไป

<DisplayName>Policy Display Name</DisplayName>
ค่าเริ่มต้น

ไม่มีข้อมูล

หากคุณไม่ใส่องค์ประกอบนี้ ระบบจะใช้ค่าของแอตทริบิวต์ name ของนโยบาย

การมีบุคคลอยู่ ไม่บังคับ
Type สตริง

องค์ประกอบ <Source>

ตัวแปร คำขอ หรือการตอบกลับที่มีข้อความ XML ที่ต้องการแปลงเป็น JSON

ต้องตั้งค่าส่วนหัวประเภทเนื้อหา HTTP ของข้อความต้นฉบับเป็น application/xml มิเช่นนั้นจะไม่มีการบังคับใช้นโยบาย

หากไม่ได้กำหนด <Source> ระบบจะถือว่าเป็นข้อความ (ซึ่งจะส่งคำขอเมื่อแนบนโยบายไว้กับขั้นตอนการส่งคำขอ หรือตอบกลับเมื่อแนบนโยบายไว้กับขั้นตอนการตอบกลับ)

หากแก้ไขตัวแปรแหล่งที่มาไม่ได้ หรือแปลงเป็นประเภทที่ไม่ใช่ข้อความ นโยบายจะแสดงข้อผิดพลาด

<Source>response</Source>
ค่าเริ่มต้น คำขอหรือการตอบกลับ ซึ่งกำหนดโดยตำแหน่งที่นโยบายเพิ่มลงในโฟลว์พร็อกซี API
การปรากฏ ไม่บังคับ
ประเภท ข้อความ

องค์ประกอบ <ExportVariable>

จัดเก็บเอาต์พุตของการแปลงรูปแบบ XML เป็น JSON ปกติแล้วค่านี้จะเหมือนกับแหล่งที่มา ซึ่งโดยปกติแล้วการตอบกลับ XML จะถูกแปลงเป็นการตอบกลับ JSON

ระบบจะแยกวิเคราะห์และแปลงเพย์โหลดของข้อความ XML เป็น JSON และมีการตั้งค่าส่วนหัวประเภทเนื้อหา HTTP ของข้อความรูปแบบ XML เป็น application/json

หากไม่ได้ระบุ OutputVariable ระบบจะถือว่า source เป็น OutputVariable เช่น หาก source คือ response แล้ว OutputVariable จะมีค่าเริ่มต้นเป็น response

<OutputVariable>response</OutputVariable>
ค่าเริ่มต้น คำขอหรือการตอบกลับ ซึ่งกำหนดโดยตำแหน่งที่นโยบายเพิ่มลงในโฟลว์พร็อกซี API
การปรากฏ องค์ประกอบนี้จำเป็นเมื่อตัวแปรที่กำหนดไว้ในองค์ประกอบ <Source> เป็นประเภทสตริง
ประเภท ข้อความ

<ตัวเลือก>

ตัวเลือกต่างๆ ช่วยให้คุณควบคุมการแปลงจาก XML เป็น JSON ได้ ใช้กลุ่ม <Options> ที่ช่วยให้เพิ่มการตั้งค่า Conversion ที่เฉพาะเจาะจง หรือองค์ประกอบ <Format> ที่ช่วยให้คุณอ้างอิงเทมเพลตของตัวเลือกที่กําหนดไว้ล่วงหน้าได้ คุณใช้ทั้ง <Options> และ <Format> ไม่ได้

ต้องระบุ <Options> หากไม่ได้ใช้ <Format>

องค์ประกอบ <ตัวเลือก>/<RecognizeNumber>

หากเป็น "จริง" ช่องตัวเลขในเพย์โหลด XML จะยังคงใช้รูปแบบเดิม

<RecognizeNumber>true</RecognizeNumber>

ลองดูตัวอย่าง XML ต่อไปนี้

<a>
  <b>100</b>
  <c>value</c>
</a>

หากเป็น true ให้แปลงเป็น:

{
    "a": {
        "b": 100,
        "c": "value"
    }
}

หากเป็น false ให้แปลงเป็น:

{
    "a": {
        "b": "100",
        "c": "value"
    }
}
ค่าเริ่มต้น false
การปรากฏ ไม่บังคับ
ประเภท บูลีน

องค์ประกอบ <ตัวเลือก>/<RecognizeBoolean>

ให้ Conversion คงค่าบูลีนจริง/เท็จแทนการเปลี่ยนค่าเป็นสตริง

<RecognizeBoolean>true</RecognizeBoolean>

สำหรับตัวอย่าง XML ต่อไปนี้

<a>
  <b>true</b>
  <c>value</c>
</a>

หากเป็น true ให้แปลงเป็น:

{
    "a": {
        "b": true,
        "c": "value"
    }
}

หากเป็น false ให้แปลงเป็น:

{
    "a": {
        "b": "true",
        "c": "value"
    }
}
ค่าเริ่มต้น false
การปรากฏ ไม่บังคับ
ประเภท บูลีน

องค์ประกอบ <ตัวเลือก>/<RecognizeNull>

ให้คุณแปลงค่าว่างเป็นค่าว่าง

<RecognizeNull>true</RecognizeNull>

สำหรับ XML ต่อไปนี้

<a>
  <b></b>
  <c>value</c>
</a>

หากเป็น true ให้แปลงเป็น:

{
  "a": {
    "b": null,
    "c": "value"
  }
}

หากเป็น false ให้แปลงเป็น:

{
  "a": {
    "b": {},
    "c": "value"
  }
}
ค่าเริ่มต้น false
การปรากฏ ไม่บังคับ
ประเภท บูลีน

องค์ประกอบ <Options>/<NullValue>

ระบุค่าที่ควรแปลงค่า Null ที่รู้จักในข้อความต้นฉบับ ค่าเริ่มต้นคือ null ตัวเลือกนี้จะมีผลก็ต่อเมื่อ RecognizeNull เป็นจริง

<NullValue>not-present</NullValue>

ค่าเริ่มต้น null
การปรากฏ ไม่บังคับ
ประเภท สตริง

<Options>/<NamespaceBlockName>
<Options>/<DefaultNamespaceNodeName>
องค์ประกอบ <Options>/<NamespaceSeparator>

ใช้องค์ประกอบเหล่านี้ร่วมกัน

<NamespaceBlockName>#namespaces</NamespaceBlockName>
<DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
<NamespaceSeparator>***</NamespaceSeparator>

ลองดูตัวอย่าง XML ต่อไปนี้

<a xmlns="http://ns.com" xmlns:ns1="http://ns1.com">
  <ns1:b>value</ns1:b>
</a>

หากไม่ได้ระบุ NamespaceSeparator ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": {
        "b": "value"
    }
}

หากระบุองค์ประกอบ NamespaceBlockName, DefaultNamespaceNodeName และ NamespaceSeparator เป็น #namespaces, & และ *** ตามลำดับ ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": {
        "#namespaces": {
            "&": "http://ns.com",
            "ns1": "http://ns1.com"
        },
        "ns1***b": "value"
    }
}
ค่าเริ่มต้น ดูตัวอย่างด้านบน
การปรากฏ ไม่บังคับ
อย่างไรก็ตาม หากระบุ <NamespaceBlockName> คุณต้องระบุองค์ประกอบอีก 2 รายการด้วย
ประเภท สตริง

<Options>/<TextalwaysAsProperty>
องค์ประกอบ <Options>/<TextNodeName>

ใช้องค์ประกอบเหล่านี้ร่วมกัน

หากตั้งค่าเป็น true ระบบจะแปลงเนื้อหาขององค์ประกอบ XML เป็นพร็อพเพอร์ตี้สตริง

<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<TextNodeName>TEXT</TextNodeName>

สำหรับ XML ต่อไปนี้

<a>
  <b>value1</b>
  <c>value2<d>value3</d>value4</c>
</a>

หากตั้งค่า TextAlwaysAsProperty เป็น true และ TextNodeName ระบุเป็น TEXT ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
  "a": {
    "b": {
      "TEXT": "value1"
    },
    "c": {
      "TEXT": [
        "value2",
        "value4"
        ],
        "d": {
          "TEXT": "value3"
        }
      }
    }
}

หากตั้งค่า TextAlwaysAsProperty เป็น false และ TextNodeName ที่ระบุเป็น TEXT ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
  "a": {
    "b": "value1",
    "c": {
      "TEXT": [
        "value2",
        "value4"
      ],
      {
        "d": "value3",
      }
    }
}
ค่าเริ่มต้น <TextAlwaysAsProperty>: เท็จ
<TextNodeName>: ไม่มี
การปรากฏ ไม่บังคับ
ประเภท <TextAlwaysAsProperty>: บูลีน
<TextNodeName>: สตริง

<Options>/<AttributeBlockName>
องค์ประกอบ <Options>/<AttributePrefix>

ใช้องค์ประกอบเหล่านี้ร่วมกัน

ช่วยให้คุณจัดกลุ่มค่าลงในบล็อก JSON และเพิ่มคำนำหน้าต่อท้ายชื่อแอตทริบิวต์ได้

<AttributeBlockName>FOO_BLOCK</AttributeBlockName>
<AttributePrefix>BAR_</AttributePrefix>

ลองดูตัวอย่าง XML ต่อไปนี้

<a attrib1="value1" attrib2="value2"/>

หากมีการระบุทั้งแอตทริบิวต์ (AttributeBlockName และ AttributePrefix) ตามที่ระบุไว้ในตัวอย่าง XML เป็น JSON ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
  "a": {
    "FOO_BLOCK": {
      "BAR_attrib1": "value1",
      "BAR_attrib2": "value2"
    }
  }
}

หากระบุเพียง AttributeBlockName ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": {
        "FOO_BLOCK": {
            "attrib1": "value1",
            "attrib2": "value2"
        }
    }
}

หากระบุเพียง AttributePrefix ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": {
        "BAR_attrib1": "value1",
        "BAR_attrib2": "value2"
    }
}

หากไม่ได้ระบุทั้ง 2 อย่างนี้ ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}
ค่าเริ่มต้น ดูตัวอย่างด้านบน
การปรากฏ ไม่บังคับ
ประเภท สตริง

องค์ประกอบ <Options>/<ExportPrefix>
<Options>/<ExportSuffix>

ใช้องค์ประกอบเหล่านี้ร่วมกัน

<OutputPrefix>PREFIX_</OutputPrefix>
<OutputSuffix>_SUFFIX</OutputSuffix>

ลองดูตัวอย่าง XML ต่อไปนี้

<a>value</a>

หากมีการระบุทั้งแอตทริบิวต์ (OutputPrefix และ OutputSuffix) ตามที่ระบุไว้ในตัวอย่าง XML เป็น JSON ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

PREFIX_{
    "a": "value"
}_SUFFIX

ถ้าระบุเพียง OutputPrefix ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

PREFIX_{
  "a" : "value"
}

ถ้าระบุเพียง OutputSuffix ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
  "a" : "value"
}_SUFFIX

หากไม่ได้ระบุ OutputPrefix และ OutputSuffix ระบบจะสร้างโครงสร้าง JSON ต่อไปนี้

{
    "a": "value"
}
ค่าเริ่มต้น ดูตัวอย่างด้านบน
การปรากฏ ไม่บังคับ
ประเภท สตริง

องค์ประกอบ <Options>/<StripLevels>

<Options>
    <StripLevels>4</StripLevels>
</Options>

บางครั้งเพย์โหลด XML เช่น SOAP มีระดับบนสุดหลายระดับที่คุณไม่ต้องการรวมไว้ใน JSON ที่แปลงแล้ว ต่อไปนี้คือตัวอย่างการตอบสนอง SOAP ที่มีหลายระดับ

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/Schemata-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
      <GetCityWeatherByZIPResponse xmlns="http://ws.cdyne.com/WeatherWS/">
          <GetCityWeatherByZIPResult>
              <State>CO</State>
              <City>Denver</City>
              <Description>Sunny</Description>
              <Temperature>62</Temperature>
          </GetCityWeatherByZIPResult>
      </GetCityWeatherByZIPResponse>
  </soap:Body>
</soap:Envelope>

มี 4 ระดับก่อนไปถึงระดับรัฐ เมือง คำอธิบาย และอุณหภูมิ หากไม่ได้ใช้ <StripLevels> การตอบสนอง JSON ที่แปลงแล้วจะมีลักษณะดังนี้

{
   "Envelope" : {
      "Body" : {
         "GetCityWeatherByZIPResponse" : {
            "GetCityWeatherByZIPResult" : {
               "State" : "CO",
               "City" : "Denver",
               "Description" : "Sunny",
               "Temperature" : "62"
            }
         }
      }
   }
}

หากต้องการตัด 4 ระดับแรกเหล่านั้นในการตอบกลับ JSON ให้ตั้งค่า <StripLevels>4</StripLevels> ซึ่งจะให้ JSON ต่อไปนี้

{
  "State" : "CO",
  "City" : "Denver",
  "Description" : "Sunny",
  "Temperature" : "62"
}

คุณสามารถตัดระดับออกไปได้จนถึงองค์ประกอบแรกที่มีเด็กหลายคน หมายความว่าอย่างไร มาดูตัวอย่าง JSON ที่ซับซ้อนมากขึ้นกัน

{
   "Envelope" : {
      "Body" : {
         "GetCityForecastByZIPResponse" : {
            "GetCityForecastByZIPResult" : {
               "ResponseText" : "City Found",
               "ForecastResult" : {
                  "Forecast" : [
                     {
                        "ProbabilityOfPrecipiation" : {
                           "Nighttime" : "00",
                           "Daytime" : 10
                        }  ...

ระดับ 3 ในตัวอย่างนี้คือ GetCityForecastByZIPResponse ซึ่งมีบุตรหลานเพียง 1 ราย ดังนั้นหากคุณใช้ <StripLevels>3</StripLevels> (นำ 3 ระดับแรกออก) JSON จะมีลักษณะดังนี้

{
   "GetCityForecastByZIPResult" : {
      "ResponseText" : "City Found",
      "ForecastResult" : {
         "Forecast" : [
            {
               "ProbabilityOfPrecipiation" : {
                  "Nighttime" : "00",
                  "Daytime" : 10
               }  ...

สังเกตว่า GetCityForecastByZIPResult มีรายการย่อยหลายรายการ เนื่องจากเป็นองค์ประกอบแรกที่มีองค์ประกอบย่อยหลายรายการ คุณจะตัดระดับสุดท้ายนี้ออกได้โดยใช้ <StripLevels>4</StripLevels> ซึ่งจะให้ JSON ต่อไปนี้

{
   "ResponseText" : "City Found",
   "ForecastResult" : {
      "Forecast" : [
         {
            "ProbabilityOfPrecipiation" : {
               "Nighttime" : "00",
               "Daytime" : 10
            }  ...

เนื่องจากระดับ 4 คือระดับแรกที่มีเด็กหลายคน คุณจึงตัดระดับใดๆ ที่ต่ำกว่านี้ออกไม่ได้ หากคุณตั้งค่าระดับแถบเป็น 5, 6, 7 และอื่นๆ คุณจะยังคงได้รับการตอบสนองด้านบนต่อไป

ค่าเริ่มต้น 0 (ไม่มีการตัดระดับ)
การปรากฏ ไม่บังคับ
ประเภท จำนวนเต็ม

องค์ประกอบ <Options>/<TreatAsArray>/<Path>

<Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

ชุดค่าผสมองค์ประกอบนี้ช่วยให้คุณมั่นใจได้ว่าค่าจากเอกสาร XML จะอยู่ในอาร์เรย์ JSON ซึ่งจะเป็นประโยชน์ เช่น เมื่อจำนวนองค์ประกอบย่อยอาจแตกต่างกัน (ตั้งแต่ 1 ถึงหลายรายการ) และคุณต้องการทำให้ค่าอยู่ในอาร์เรย์เสมอ วิธีนี้จะช่วยให้โค้ดมีความเสถียร เนื่องจากคุณจะรับข้อมูลจากอาร์เรย์ได้ในลักษณะเดียวกันทุกครั้ง เช่น $.teachers.teacher.studentnames[0] จะได้รับค่าชื่อนักเรียนคนแรกในอาร์เรย์โดยไม่คำนึงถึงจำนวนค่าในอาร์เรย์

เราย้อนกลับไปดูลักษณะการทำงานเริ่มต้นของ XML เป็น JSON จากนั้นดูวิธีควบคุมเอาต์พุตโดยใช้ <TreatAsArray>/<Path>

เมื่อเอกสาร XML มีองค์ประกอบที่มีค่าย่อยหลายค่า (มักอิงตามสคีมาที่มี maxOccurs='unbounded' ขององค์ประกอบ) นโยบาย XML เป็น JSON จะใส่ค่าเหล่านั้นในอาร์เรย์โดยอัตโนมัติ ตัวอย่างเช่น บล็อก XML ต่อไปนี้

<teacher>
    <name>teacherA</name>
    <studentnames>
        <name>student1</name>
        <name>student2</name>
    </studentnames>
</teacher>

...จะถูกแปลงเป็น JSON ต่อไปนี้โดยอัตโนมัติโดยไม่มีการกำหนดค่านโยบายพิเศษ:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}
           }
      }
}

สังเกตว่าระบบใส่ชื่อนักเรียนทั้ง 2 คนไว้ในอาร์เรย์

อย่างไรก็ตาม หากมีนักเรียนเพียงรายเดียวปรากฏในเอกสาร XML นโยบาย XML เป็น JSON จะถือว่าค่าเป็นสตริงเดียวโดยอัตโนมัติ ไม่ใช่อาร์เรย์ของสตริง ดังที่แสดงในตัวอย่างต่อไปนี้

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : "student1"
              }
          }
      }
}

ในตัวอย่างก่อนหน้านี้ ข้อมูลที่คล้ายกันได้รับการแปลงต่างออกไป กล่าวคือ 1 ครั้งเป็นอาร์เรย์ และอีกข้อมูลหนึ่งเป็นสตริงเดียว ซึ่งเป็นส่วนที่องค์ประกอบ <TreatAsArray>/<Path> ให้คุณควบคุมเอาต์พุต ตัวอย่างเช่น คุณสามารถตรวจสอบว่าได้ใส่ชื่อนักเรียนไว้ในอาร์เรย์เสมอแม้ว่าจะมีค่าเพียงค่าเดียว คุณกำหนดค่านี้ได้โดยการระบุเส้นทางไปยังองค์ประกอบที่มีค่าที่ต้องการใส่ในอาร์เรย์ เช่น

<Options>
    <TreatAsArray>
        <Path>teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

การกำหนดค่าข้างต้นจะเขียน JSON ดังนี้

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : ["student1"]
              }
            ]
          }
      }
}

โปรดทราบว่า ตอนนี้บัตรนักเรียน1 อยู่ในอาร์เรย์แล้ว ไม่ว่าจะมีนักเรียนคนเดียวหรือหลายคน คุณก็สามารถดึงข้อมูลนักเรียนจากอาร์เรย์ JSON ในโค้ดได้โดยใช้ JSONPath ต่อไปนี้ $.teachers.teacher.studentnames.name[0]

นอกจากนี้ องค์ประกอบ <Path> ยังมีแอตทริบิวต์ unwrap ดังที่อธิบายไว้ในส่วนถัดไปด้วย

ค่าเริ่มต้น ไม่มี
การปรากฏ ไม่บังคับ
ประเภท สตริง

Attributes

 <Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>
แอตทริบิวต์ คำอธิบาย การมีบุคคลอยู่ Type
แยก

ค่าเริ่มต้น: เท็จ

นำองค์ประกอบออกจากเอาต์พุต JSON ใช้ตัวเลือกนี้เพื่อปรับปรุงประสิทธิภาพหรือรวม JSON ("แยก") ซึ่งจะย่อ JSONPath ที่จําเป็นในการดึงค่าด้วย เช่น แทนที่ $.teachers.teacher.studentnames.name[*] คุณอาจรวม JSON เข้าด้วยกันและใช้ $.teachers.studentnames[*]

ต่อไปนี้คือตัวอย่าง JSON

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}...

ในตัวอย่างนี้ คุณอาจโต้แย้งได้ว่าองค์ประกอบ teacher และองค์ประกอบชื่อนักเรียน name นั้นไม่จำเป็น ดังนั้นคุณจะนำออกหรือถอดออกก็ได้ วิธีกำหนดค่าองค์ประกอบ <Path> มีดังนี้

<TreatAsArray>
    <Path unwrap="true">teachers/teacher</Path>
    <Path unwrap="true">teachers/teacher/studentnames/name</Path>
</TreatAsArray>

แอตทริบิวต์ unwrap ได้รับการตั้งค่าเป็น "จริง" และมีการระบุเส้นทางไปยังองค์ประกอบที่จะแยก เอาต์พุต JSON จะมีลักษณะดังนี้

{
  "teachers" : [{
      "name" : "teacherA",
      "studentnames" : ["student1","student2"]
      }]...

โปรดทราบว่าเนื่องจากองค์ประกอบ <Path> อยู่ในองค์ประกอบ <TreatAsArray> ระบบจึงจะจัดการทั้ง 2 องค์ประกอบในเส้นทางเป็นอาร์เรย์ในเอาต์พุต JSON

ไม่บังคับ บูลีน

ดูตัวอย่างเพิ่มเติมและคำแนะนำแบบทีละขั้นเกี่ยวกับฟีเจอร์ได้จากบทความเรื่องชุมชน Apigee นี้ https://community.apigee.com/content/kbentry/33374/new-edge-minifeature-the-treatasarray-option-in-th.html

<รูปแบบ>

รูปแบบช่วยให้คุณควบคุมการแปลงจาก XML เป็น JSON ได้ ป้อนชื่อเทมเพลตที่กำหนดไว้ล่วงหน้าซึ่งมีชุดค่าผสมที่เฉพาะเจาะจงขององค์ประกอบตัวเลือกที่อธิบายไว้ในหัวข้อนี้ รูปแบบที่กำหนดไว้ล่วงหน้า ได้แก่ xml.com, yahoo, google, badgerFish

ใช้องค์ประกอบ <Format> หรือกลุ่ม <Options> คุณใช้ทั้ง <Format> และ <Options> ไม่ได้

ต่อไปนี้เป็นการกำหนดรูปแบบของเทมเพลตที่กำหนดไว้ล่วงหน้าแต่ละรายการ

xml.com

<RecognizeNull>true</RecognizeNull>
<TextNodeName>#text</TextNodeName>
<AttributePrefix>@</AttributePrefix>

yahoo

<RecognizeNumber>true</RecognizeNumber>
<TextNodeName>content</TextNodeName>

google

<TextNodeName>$t</TextNodeName>
<NamespaceSeparator>$</NamespaceSeparator>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>

badgerFish

<TextNodeName>$</TextNodeName>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<AttributePrefix>@</AttributePrefix>
<NamespaceSeparator>:</NamespaceSeparator>
<NamespaceBlockName>@xmlns</NamespaceBlockName>
<DefaultNamespaceNodeName>$</DefaultNamespaceNodeName>

ไวยากรณ์องค์ประกอบ:

<Format>yahoo</Format>
ค่าเริ่มต้น ป้อนชื่อรูปแบบที่พร้อมใช้งาน:
xml.com, yahoo, google, badgerFish
การปรากฏ ต้องระบุหากไม่ได้ใช้ <Options>
ประเภท สตริง

สคีมา


การอ้างอิงข้อผิดพลาด

ส่วนนี้จะอธิบายโค้ดข้อผิดพลาดและข้อความแสดงข้อผิดพลาดที่แสดงผลและตัวแปรข้อผิดพลาดที่ Edge กําหนดเมื่อนโยบายนี้ทําให้เกิดข้อผิดพลาด ข้อมูลนี้เป็นสิ่งสำคัญที่ต้องทราบหากคุณกำลังกำหนดกฎข้อผิดพลาดเพื่อจัดการกับข้อผิดพลาด ดูข้อมูลเพิ่มเติมได้ที่สิ่งที่คุณต้องทราบเกี่ยวกับข้อผิดพลาดของนโยบายและการจัดการข้อผิดพลาด

ข้อผิดพลาดเกี่ยวกับรันไทม์

ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อนโยบายทำงาน

รหัสข้อผิดพลาด สถานะ HTTP สาเหตุ แก้ไข
steps.xmltojson.ExecutionFailed 500 ข้อผิดพลาดนี้เกิดขึ้นเมื่อเพย์โหลดอินพุต (XML) ว่างเปล่าหรือ XML ของอินพุตไม่ถูกต้องหรือผิดรูปแบบ
steps.xmltojson.InCompatibleType 500 ข้อผิดพลาดนี้เกิดขึ้นหากประเภทของตัวแปรที่กำหนดไว้ในองค์ประกอบ <Source> และองค์ประกอบ <OutputVariable> ไม่เหมือนกัน ต้องระบุประเภทของตัวแปรที่มีอยู่ภายในองค์ประกอบ <Source> และองค์ประกอบ <OutputVariable> ให้ตรงกัน
steps.xmltojson.InvalidSourceType 500 ข้อผิดพลาดนี้เกิดขึ้นหากประเภทของตัวแปรที่ใช้กำหนดองค์ประกอบ <Source> ไม่ถูกต้อง ประเภทตัวแปรที่ถูกต้องคือข้อความและสตริง
steps.xmltojson.OutputVariableIsNotAvailable 500 ข้อผิดพลาดนี้เกิดขึ้นหากตัวแปรที่ระบุในองค์ประกอบ <Source> ของนโยบาย XML เป็น JSON เป็นประเภทสตริงและไม่ได้กำหนดองค์ประกอบ <OutputVariable> คุณจำเป็นต้องระบุองค์ประกอบ <OutputVariable> เมื่อตัวแปรที่กำหนดไว้ในองค์ประกอบ <Source> เป็นสตริงประเภท
steps.xmltojson.SourceUnavailable 500 ข้อผิดพลาดนี้เกิดขึ้นหากตัวแปร message ที่ระบุในองค์ประกอบ <Source> ของนโยบาย XML เป็น JSON เป็นไปตามข้อใดข้อหนึ่งต่อไปนี้
  • อยู่นอกขอบเขต (ใช้ไม่ได้ในขั้นตอนเฉพาะเจาะจงที่มีการใช้นโยบาย) หรือ
  • แก้ไขไม่ได้ (ไม่ได้กำหนด)

ข้อผิดพลาดในการทำให้ใช้งานได้

ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นเมื่อคุณใช้พร็อกซีที่มีนโยบายนี้

ชื่อข้อผิดพลาด สาเหตุ แก้ไข
EitherOptionOrFormat หากไม่มีการประกาศองค์ประกอบ <Options> หรือ <Format> ในนโยบาย XML เป็น JSON การทำให้พร็อกซี API ใช้งานได้จะไม่สำเร็จ
UnknownFormat หากองค์ประกอบ <Format> ภายในนโยบาย XML เป็น JSON มีรูปแบบที่ไม่รู้จักที่กำหนดไว้ การทำให้พร็อกซี API ใช้งานได้จะไม่สำเร็จ รูปแบบที่กำหนดไว้ล่วงหน้า ได้แก่ xml.com, yahoo, google และ badgerFish

ตัวแปรของข้อผิดพลาด

ระบบจะตั้งค่าตัวแปรเหล่านี้เมื่อเกิดข้อผิดพลาดรันไทม์ ดูข้อมูลเพิ่มเติมได้ที่สิ่งที่คุณต้องทราบเกี่ยวกับข้อผิดพลาดของนโยบาย

ตัวแปร สถานที่ ตัวอย่าง
fault.name="fault_name" fault_name คือชื่อของข้อผิดพลาดตามที่แสดงในตารางข้อผิดพลาดรันไทม์ด้านบน ชื่อข้อผิดพลาดคือส่วนสุดท้ายของโค้ดข้อผิดพลาด fault.name = "SourceUnavailable"
xmltojson.policy_name.failed policy_name คือชื่อที่ผู้ใช้ระบุของนโยบายที่เป็นข้อผิดพลาด xmltojson.XMLtoJSON-1.failed = true

ตัวอย่างการตอบกลับข้อผิดพลาด

{
  "fault": {
    "faultstring": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.xml2json.SourceUnavailable"
    }
  }
}

ตัวอย่างกฎข้อผิดพลาด

<faultrule name="VariableOfNonMsgType"></faultrule><FaultRule name="XML to JSON Faults">
    <Step>
        <Name>AM-SourceUnavailableMessage</Name>
        <Condition>(fault.name Matches "SourceUnavailable") </Condition>
    </Step>
    <Step>
        <Name>AM-BadXML</Name>
        <Condition>(fault.name = "ExecutionFailed")</Condition>
    </Step>
    <Condition>(xmltojson.XMLtoJSON-1.failed = true) </Condition>
</FaultRule>

หัวข้อที่เกี่ยวข้อง

JSON เป็น XML: นโยบาย JSON เป็น XML