Hantera innehållstyper i Azure Logic Apps

Artikel
02/04/2025

Gäller för: Azure Logic Apps (Förbrukning + Standard)

Olika innehållstyper kan flöda genom en logikapp, till exempel JSON, XML, flata filer och binära data. Logic Apps stöder alla innehållstyper, men vissa har inbyggt stöd och kräver inte gjutning eller konvertering i dina logikappar. Andra typer kan kräva gjutning eller konvertering efter behov. Den här artikeln beskriver hur Logic Apps hanterar innehållstyper och hur du kan konvertera eller konvertera dessa typer korrekt vid behov.

För att fastställa det lämpliga sättet att hantera innehållstyper förlitar sig Logic Apps på Content-Type huvudvärdet i HTTP-anrop, till exempel:

application/json (intern typ)
text/oformaterad (ursprunglig typ)
application/xml och application/octet-stream
Andra innehållstyper

application/json

Logic Apps lagrar och hanterar alla begäranden med program-/json-innehållstypen som ett JSON-objekt (JavaScript Object Notation). Som standard kan du parsa JSON-innehåll utan gjutning. Om du vill parsa en begäran som har en rubrik med innehållstypen "application/json" kan du använda ett uttryck. Det här exemplet returnerar värdet dog från matrisen animal-type utan gjutning:

@body('myAction')['client']['animal-type'][0]

{
  "client": {
     "name": "Fido",
     "animal-type": [ "dog", "cat", "rabbit", "snake" ]
  }
}

Om du arbetar med JSON-data som inte anger ett huvud kan du manuellt omvandla dessa data till JSON med hjälp av funktionen json(), till exempel:

@json(triggerBody())['client']['animal-type']

Skapa token för JSON-egenskaper

Logic Apps ger dig möjlighet att generera användarvänliga token som representerar egenskaperna i JSON-innehåll så att du kan referera till och använda dessa egenskaper enklare i logikappens arbetsflöde.

Utlösare för begäran

När du använder den här utlösaren i Logikappdesignern kan du ange ett JSON-schema som beskriver nyttolasten som du förväntar dig att få. Designern parsar JSON-innehåll med hjälp av det här schemat och genererar användarvänliga token som representerar egenskaperna i ditt JSON-innehåll. Du kan sedan enkelt referera till och använda dessa egenskaper i hela logikappens arbetsflöde.

Om du inte har något schema kan du generera schemat.
1. I utlösaren Begäran väljer du Använd exempelnyttolast för att generera schema.
2. Under Ange eller klistra in en JSON-exempelnyttolast anger du en exempelnyttolast och väljer sedan Klar. Till exempel:
  
  Det genererade schemat visas nu i utlösaren.
  
  Här är den underliggande definitionen för utlösaren för begäran i kodvisningsredigeraren:
```
"triggers": { 
   "manual": {
      "type": "Request",
      "kind": "Http",
      "inputs": { 
         "schema": {
            "type": "object",
            "properties": {
               "client": {
                  "type": "object",
                  "properties": {
                     "animal-type": {
                        "type": "array",
                        "items": {
                           "type": "string"
                        },
                     },
                     "name": {
                        "type": "string"
                     }
                  }
               }
            }
         }
      }
   }
}
```
3. I HTTP-begäran som klientappen skickar till Azure Logic Apps ser du till att du inkluderar ett huvud med namnet Content-Type och anger huvudets värde till application/json.
Parsa JSON-åtgärd

När du använder den här åtgärden i Logic App Designer kan du parsa JSON-utdata och generera användarvänliga token som representerar egenskaperna i ditt JSON-innehåll. Du kan sedan enkelt referera till och använda dessa egenskaper i hela logikappens arbetsflöde. På samma sätt som med utlösaren Förfrågning kan du ange eller generera ett JSON-schema som beskriver det JSON-innehåll som du vill parsa. På så sätt kan du enklare använda data från Azure Service Bus, Azure Cosmos DB och så vidare.

text/plain

När logikappen Content-Type tar emot HTTP-meddelanden som har huvudet inställt på text/plainlagrar logikappen dessa meddelanden i råform. Om du inkluderar dessa meddelanden i efterföljande åtgärder utan att gjuta går begäranden ut med huvudet inställt på Content-Typetext/plain.

När du till exempel arbetar med en flat fil kan du få en HTTP-begäran med Content-Type rubriken inställd på text/plain innehållstyp:

Date,Name,Address
Oct-1,Frank,123 Ave

Om du sedan skickar den här begäran i en senare åtgärd som brödtext för en annan begäran, till exempel , @body('flatfile')har den andra begäran också ett Content-Type huvud som är inställt på text/plain. Om du arbetar med data som är oformaterad text men inte har angett någon rubrik kan du manuellt omvandla dessa data till text med hjälp av funktionen string(), till exempel det här uttrycket:

@string(triggerBody())

application/xml och application/octet-stream

Logic Apps bevarar Content-Type alltid i en mottagen HTTP-begäran eller ett mottaget HTTP-svar. Om logikappen tar emot innehåll med Content-Type inställt på application/octet-stream, och du inkluderar innehållet i en senare åtgärd utan gjutning, har Content-Type den utgående begäran också angetts till application/octet-stream. På så sätt kan Logic Apps garantera att data inte går förlorade när de flyttas genom arbetsflödet. Åtgärdstillståndet, eller indata och utdata, lagras dock i ett JSON-objekt medan tillståndet flyttas genom arbetsflödet.

Konverterarfunktioner

För att bevara vissa datatyper konverterar Logic Apps innehåll till en binär base64-kodad sträng med lämpliga metadata som bevarar både $content nyttolasten och $content-type, som konverteras automatiskt.

I den här listan beskrivs hur Logic Apps konverterar innehåll när du använder dessa funktioner:

json(): Omvandlar data till application/json
xml(): Omvandlar data till application/xml
binary(): Omvandlar data till application/octet-stream
string(): Omvandlar data till text/plain
base64(): Konverterar innehåll till en base64-kodad sträng
base64toString(): Konverterar en base64-kodad sträng till text/plain
base64toBinary(): Konverterar en base64-kodad sträng till application/octet-stream
dataUri(): Konverterar en sträng till en data-URI
dataUriToBinary(): Konverterar en data-URI till en binär sträng
dataUriToString(): Konverterar en data-URI till en sträng

Om du till exempel får en HTTP-begäran som Content-Type är inställd på , till application/xmlexempel det här innehållet:

<?xml version="1.0" encoding="UTF-8" ?>
<CustomerName>Frank</CustomerName>

Du kan casta det här innehållet med hjälp @xml(triggerBody()) av uttrycket med xml() funktionerna och triggerBody() och sedan använda det här innehållet senare. Eller så kan du använda @xpath(xml(triggerBody()), '/CustomerName') uttrycket med xpath() funktionerna och xml() .

Andra innehållstyper

Logic Apps fungerar med och stöder andra innehållstyper, men kan kräva att du manuellt hämtar meddelandetexten genom att avkoda variabeln $content .

Anta till exempel att logikappen utlöses av en begäran med application/x-www-url-formencoded innehållstypen. För att bevara alla data har variabeln $content i begärandetexten en nyttolast som är kodad som en base64-sträng:

CustomerName=Frank&Address=123+Avenue

Eftersom begäran inte är oformaterad text eller JSON lagras begäran i åtgärden på följande sätt:

"body": {
   "$content-type": "application/x-www-url-formencoded",
   "$content": "AAB1241BACDFA=="
}

Logic Apps tillhandahåller inbyggda funktioner för hantering av formulärdata, till exempel:

Du kan också komma åt data manuellt med hjälp av ett uttryck som det här exemplet:

@string(body('formdataAction'))

Om du vill att den utgående begäran ska ha samma application/x-www-url-formencoded rubrik för innehållstypen kan du lägga till begäran i åtgärdens brödtext utan att behöva gjuta med hjälp av ett uttryck som @body('formdataAction'). Den här metoden fungerar dock bara när brödtexten är den enda parametern body i indata. Om du försöker använda uttrycket @body('formdataAction') i en application/json begäran får du ett körningsfel eftersom brödtexten skickas kodad.

Dela via