Hantera innehållstyper i Azure Logic Apps

Artikel
01/04/2024

Gäller för: Azure Logic Apps (Consumption + 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 omvandling eller konvertering i dina logikappar. Andra typer kan kräva omvandling eller konvertering efter behov. Den här artikeln beskriver hur Logic Apps hanterar innehållstyper och hur du kan omvandla eller konvertera dessa typer korrekt vid behov.

Logic Apps förlitar sig på Content-Type huvudvärdet i HTTP-anrop för att fastställa lämpligt sätt att hantera innehållstyper, 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 Notation). Som standard kan du parsa JSON-innehåll utan någon omvandling. Om du vill parsa en begäran som har en rubrik med innehållstypen "application/json" kan du använda ett uttryck. I det här exemplet returneras värdet dog från matrisen animal-type utan omvandling:

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

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

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

@json(triggerBody())['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 logikappens Designer 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 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 schemat.
2. Under Ange eller klistra in en JSON-exempelnyttolast anger du en exempelnyttolast och väljer sedan Klar. Exempel:
  
  Det genererade schemat visas nu i utlösaren.
  
  Här är den underliggande definitionen för begärandeutlösaren 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 logikappens arbetsflöde. På samma sätt som med begärandeutlösaren 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/oformaterad

När logikappen Content-Type tar emot HTTP-meddelanden som har huvudet inställt text/plainpå lagrar logikappen dessa meddelanden i råform. Om du inkluderar de här meddelandena i efterföljande åtgärder utan att ångra omvandlingen Content-Type går begäranden ut med huvudet inställt på text/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, @body('flatfile')till exempel , har den andra begäran också ett Content-Type huvud som är inställt text/plainpå . Om du arbetar med data som är oformaterad text men inte angav ett sidhuvud 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. Så 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 omvandling, har Content-Type den utgående begäran även 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 omvandla det här innehållet med hjälp @xml(triggerBody()) av uttrycket med xml() funktionerna och triggerBody() och och sedan använda det här innehållet senare. Eller så kan du använda uttrycket @xpath(xml(triggerBody()), '/CustomerName') 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 att hantera formulärdata, till exempel:

Eller så kan du manuellt komma åt data 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 innehållstypsrubrik kan du lägga till begäran i åtgärdens brödtext utan någon omvandling 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.