Chiamata AEM Forms tramite servizi Web

La maggior parte servizi AEM Forms nel contenitore di servizi sono configurati per esporre un servizio Web, con il supporto completo per la generazione del linguaggio WSDL (Web Service Definition Language). In altre parole, potete creare oggetti proxy che utilizzano lo stack SOAP nativo di un servizio AEM Forms . Di conseguenza, servizi AEM Forms possono scambiare ed elaborare i seguenti messaggi SOAP:

  • Richiesta SOAP: Inviato a un servizio Forms da un'applicazione client che richiede un'azione.
  • Risposta SOAP: Inviato a un'applicazione client da un servizio Forms dopo l'elaborazione di una richiesta SOAP.

I servizi Web consentono di eseguire le stesse operazioni servizi AEM Forms che è possibile utilizzare l'API Java. L'utilizzo di servizi Web per richiamare servizi AEM Forms consente di creare un'applicazione client in un ambiente di sviluppo che supporta SOAP. Un'applicazione client non è associata a un ambiente di sviluppo o a un linguaggio di programmazione specifico. Ad esempio, è possibile creare un'applicazione client utilizzando Microsoft Visual Studio .NET e C# come linguaggio di programmazione.

servizi AEM Forms sono esposti attraverso il protocollo SOAP e sono conformi al profilo di base WSI 1.1. Web Services Interoperability (WSI) è un'organizzazione standard aperta che promuove l'interoperabilità dei servizi Web tra piattaforme. Per informazioni, consultate https://www.ws-i.org/.

AEM Forms supporta i seguenti standard di servizi Web:

  • Codifica: Supporta solo la codifica documentale e letterale (che è la codifica preferita in base al profilo di base WSI). Consultate Richiamo AEM Forms con codificaBase64.
  • MTOM: Rappresenta un modo per codificare gli allegati con le richieste SOAP. Consultate Attivazione AEM Forms con MTOM.
  • SwaRef: Rappresenta un altro modo per codificare gli allegati con le richieste SOAP. Consultate Attivazione AEM Forms tramite SwaRef.
  • SOAP con allegati: Supporta sia MIME che DIME (Direct Internet Message Encapsulation). Questi protocolli sono metodi standard per inviare allegati via SOAP. Le applicazioni Microsoft Visual Studio .NET utilizzano DIME. Consultate Richiamo AEM Forms con codificaBase64.
  • WS-Security: Supporta un profilo token password di nome utente, che è un modo standard di inviare nomi utente e password come parte dell'intestazione SOAP di WS Security. AEM Forms supporta anche l'autenticazione di base HTTP. (vedere Trasmissione delle credenziali tramite intestazioniWS-Security).

Per richiamare servizi AEM Forms utilizzando un servizio Web, in genere si crea una libreria proxy che utilizza il servizio WSDL. La sezione Invoking AEM Forms tramite Web Services utilizza JAX-WS per creare classi proxy Java per richiamare i servizi. (vedere Creazione di classi proxy Java tramite JAX-WS).

Potete recuperare un servizio WDSL specificando la seguente definizione URL (gli elementi tra parentesi sono facoltativi):

 https://<your_serverhost>:<your_port>/soap/services/<service_name>?wsdl[&version=<version>][&async=true|false][lc_version=<lc_version>]

dove:

  • your_serverhost rappresenta l'indirizzo IP del server applicazione J2EE che ospita AEM Forms.
  • your_port rappresenta la porta HTTP utilizzata dal server applicazione J2EE.
  • service_name rappresenta il nome del servizio.
  • version rappresenta la versione di destinazione di un servizio (per impostazione predefinita viene utilizzata la versione di servizio più recente).
  • async specifica il valore true per abilitare ulteriori operazioni di chiamata asincrona (per impostazione false predefinita).
  • lc_version rappresenta la versione di AEM Forms che si desidera richiamare.

Nella tabella seguente sono elencate le definizioni WSDL del servizio (supponendo che AEM Forms sia distribuito sull'host locale e che il post sia 8080).

Servizio

Definizione WSDL

Assemblatore

http://localhost:8080/soap/services/ AssemblerService?wsdl

Indietro e ripristinare

http://localhost:8080/soap/services/BackupService?wsdl

Barcoded Forms

http://localhost:8080/soap/services/ BarcodedFormsService?wsdl

Converti PDF

http://localhost:8080/soap/services/ ConvertPDFService?wsdl

Distiller

http://localhost:8080/soap/services/ DistillerService?wsdl

DocConverter

http://localhost:8080/soap/services/DocConverterService?WSDL

DocumentManagement

http://localhost:8080/soap/services/DocumentManagementService?WSDL

Cifratura

http://localhost:8080/soap/services/EncryptionService?wsdl

Forms

http://localhost:8080/soap/services/FormsService?wsdl

Integrazione dei dati del modulo

http://localhost:8080/soap/services/FormDataIntegration?wsdl

Genera PDF

http://localhost:8080/soap/services/ GeneratePDFService?wsdl

Genera PDF 3D

http://localhost:8080/soap/services/Generate3dPDFService?WSDL

Output

http://localhost:8080/soap/services/ OutputService?wsdl

Utilità PDF

http://localhost:8080/soap/services/ PDFUtilityService?wsdl

Estensioni Acrobat Reader DC

http://localhost:8080/soap/services/ ReaderExtensionsService?wsdl

Archivio

http://localhost:8080/soap/services/ RepositoryService?wsdl

Rights Management

http://localhost:8080/soap/services/ RightsManagementService?wsdl

Firma

http://localhost:8080/soap/services/ SignatureService?wsdl

Utilità XMP

http://localhost:8080/soap/services/ XMPUtilityService?wsdl

definizioni WSDL di AEM Forms Process

È necessario specificare il nome dell'applicazione e il nome del processo all'interno della definizione WSDL per accedere a un WSDL appartenente a un processo creato in Workbench. Si supponga che il nome dell’applicazione sia MyApplication e che il nome del processo sia EncryptDocument. In questa situazione, specificare la seguente definizione WSDL:

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?wsdl
Nota

Per informazioni sull’esempio di processo MyApplication/EncryptDocument di breve durata, consultate Esempio di processo dibreve durata.

Nota

Un'applicazione può contenere cartelle. In questo caso, specificate i nomi delle cartelle nella definizione WSDL:

 http://localhost:8080/soap/services/MyApplication/[<folderA>/.../<folderZ>/]EncryptDocument?wsdl

Accesso a nuove funzionalità tramite i servizi Web

È possibile accedere nuova funzionalità del servizio AEM Forms tramite i servizi Web. Ad esempio, in AEM Forms viene introdotta la possibilità di codificare gli allegati utilizzando MTOM. Consultate Attivazione AEM Forms con MTOM.

Per accedere alle nuove funzionalità introdotte in AEM Forms, specificate l' lc_version attributo nella definizione WSDL. Ad esempio, per accedere alle nuove funzionalità del servizio (incluso il supporto MTOM), specificate la seguente definizione WSDL:

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?wsdl&lc_version=9.0.1
Nota

Quando impostate l’ lc_version attributo, accertatevi di usare tre cifre. Ad esempio, 9.0.1 è uguale alla versione 9.0.

Tipo di dati BLOB del servizio Web

WSDL del servizio AEM Forms definiscono molti tipi di dati. Uno dei tipi di dati più importanti esposti in un servizio Web è un BLOB tipo. Questo tipo di dati viene mappato sulla com.adobe.idp.Document classe quando si utilizzano API Java AEM Forms. (vedere Trasmissione di dati a servizi AEM Forms tramite l'APIJava).

Un BLOB oggetto invia e recupera dati binari (ad esempio, file PDF, dati XML e così via) da e verso servizi AEM Forms. Il BLOB tipo è definito in un servizio WSDL come segue:

 <complexType name="BLOB">
     <sequence>
         <element maxOccurs="1" minOccurs="0" name="contentType"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="binaryData"
             type="xsd:base64Binary"/>
         <element maxOccurs="1" minOccurs="0" name="attachmentID"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="remoteURL"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="MTOM"
             type="xsd:base64Binary"
             xmime:expectedContentTypes="*/*"
             xmlns:xmime="https://www.w3.org/2005/05/xmlmime"/>
         <element maxOccurs="1" minOccurs="0" name="swaRef"
             type="tns1:swaRef"/>
         <element maxOccurs="1" minOccurs="0" name="attributes"
             type="impl:MyMapOf_xsd_string_To_xsd_anyType"/>
     </sequence>
 </complexType>

I campi MTOM e swaRef sono supportati solo in AEM Forms. Potete utilizzare questi nuovi campi solo se specificate un URL che includa la lc_version proprietà.

Fornitura di oggetti BLOB nelle richieste di servizio

Se un'operazione del servizio AEM Forms richiede un BLOB tipo come valore di input, create un'istanza del BLOB tipo nella logica dell'applicazione. (Molti degli avvii rapidi del servizio Web disponibili nella programmazione con moduli AEM mostrano come utilizzare un tipo di dati BLOB.)

Assegnare valori ai campi appartenenti all' BLOB istanza come segue:

  • Base64: Per trasmettere dati come testo codificato in formato Base64, impostare i dati nel BLOB.binaryData campo e impostare il tipo di dati nel formato MIME (ad esempio application/pdf) del BLOB.contentType campo. Consultate Richiamo AEM Forms con codificaBase64.
  • MTOM: Per trasmettere dati binari in un allegato MTOM, impostare i dati nel BLOB.MTOM campo. Questa impostazione associa i dati alla richiesta SOAP utilizzando il framework Java JAX-WS o l'API nativa del framework SOAP. Consultate Attivazione AEM Forms con MTOM.
  • SwaRef: Per trasmettere dati binari in un allegato SwaRef WS-I, impostare i dati nel BLOB.swaRef campo. Questa impostazione allega i dati alla richiesta SOAP utilizzando il framework Java JAX-WS. Consultate Attivazione AEM Forms tramite SwaRef.
  • Allegato MIME o DIME: Per trasmettere i dati in un allegato MIME o DIME, allegare i dati alla richiesta SOAP utilizzando l'API nativa del framework SOAP. Impostare l'identificatore allegato nel BLOB.attachmentID campo. Consultate Richiamo AEM Forms con codificaBase64.
  • URL remoto: Se i dati sono in hosting su un server Web e sono accessibili tramite un URL HTTP, impostate l’URL HTTP nel BLOB.remoteURL campo. (vedere Chiamata AEM Forms tramite dati BLOB via HTTP).

Accesso ai dati in oggetti BLOB restituiti dai servizi

Il protocollo di trasmissione per BLOB gli oggetti restituiti dipende da diversi fattori, considerati nell'ordine seguente, che si arrestano quando la condizione principale è soddisfatta:

  1. L’URL di destinazione specifica il protocollo di trasmissione. Se l’URL di destinazione specificato alla chiamata SOAP contiene il parametro blob="BLOB_TYPE", BLOB_TYPE determina il protocollo di trasmissione. BLOB_TYPE è un segnaposto per base64, dime, mime, http, mtom o swaref.

  2. L'endpoint SOAP del servizio è Smart. Se le seguenti condizioni sono vere, i documenti di output vengono restituiti utilizzando lo stesso protocollo di trasmissione dei documenti di input:

    • Il protocollo predefinito del parametro endpoint SOAP del servizio per gli oggetti BLOB di output è impostato su Smart.

      Per ogni servizio con un endpoint SOAP, la console di amministrazione consente di specificare il protocollo di trasmissione per tutti i BLOB restituiti. (vedere la guidadi amministrazione.)

    • servizio AEM Forms accetta uno o più documenti come input.

  3. L'endpoint SOAP del servizio non è Smart. Il protocollo configurato determina il protocollo di trasmissione del documento e i dati vengono restituiti nel BLOB campo corrispondente. Ad esempio, se l'endpoint SOAP è impostato su DIME, il BLOB restituito si trova nel blob.attachmentID campo indipendentemente dal protocollo di trasmissione di qualsiasi documento di input.

  4. In caso contrario. Se un servizio non accetta il tipo di documento come input, i documenti di output vengono restituiti nel BLOB.remoteURL campo mediante il protocollo HTTP.

Come descritto nella prima condizione, potete garantire il tipo di trasmissione per tutti i documenti restituiti estendendo l'URL dell'endpoint SOAP con un suffisso come segue:

     https://<your_serverhost>:<your_port>/soap/services/<service
     name>?blob=base64|dime|mime|http|mtom|swaref

Di seguito è riportata la correlazione tra i tipi di trasmissione e il campo da cui si ottengono i dati:

  • Formato Base64: Impostate il blob suffisso base64 per restituire i dati nel BLOB.binaryData campo.
  • Allegato MIME o DIME: Impostare il blob suffisso su DIME o MIME per restituire i dati come tipo di allegato corrispondente con l'identificatore di allegato restituito nel BLOB.attachmentID campo. Utilizzare l'API proprietaria del framework SOAP per leggere i dati dall'allegato.
  • URL remoto: Impostate il blob suffisso http per mantenere i dati sul server dell’applicazione e restituire l’URL che punta ai dati nel BLOB.remoteURL campo.
  • MTOM o SwaRef: Impostare il blob suffisso su mtom o swaref per restituire i dati come tipo di allegato corrispondente con l'identificatore di allegato restituito nei campi BLOB.MTOM o BLOB.swaRef . Utilizzare l'API nativa del framework SOAP per leggere i dati dall'allegato.
Nota

È consigliabile non superare i 30 MB quando si compila un BLOB oggetto richiamandone il setBinaryData metodo. In caso contrario, esiste la possibilità che si verifichi un' OutOfMemory eccezione.

Nota

Le applicazioni basate su JAX WS che utilizzano il protocollo di trasmissione MTOM sono limitate a 25 MB di dati inviati e ricevuti. Questa limitazione è dovuta a un bug in JAX-WS. Se la dimensione combinata dei file inviati e ricevuti supera i 25 MB, utilizzate il protocollo di trasmissione SwaRef invece di quello MTOM. In caso contrario, esiste la possibilità di un' OutOfMemory eccezione.

Trasmissione MTOM di array di byte con codifica base64

Oltre all' BLOB oggetto, il protocollo MTOM supporta qualsiasi parametro dell'array di byte o campo dell'array di byte di un tipo complesso. Ciò significa che i framework SOAP client che supportano MTOM possono inviare qualsiasi xsd:base64Binary elemento come allegato MTOM (invece di un testo con codifica base64). endpoint SOAP AEM Forms è in grado di leggere questo tipo di codifica matrice byte. Tuttavia, il servizio AEM Forms restituisce sempre un tipo di array di byte come testo con codifica base64. I parametri dell'array di byte di output non supportano MTOM.

servizi AEM Forms che restituiscono una grande quantità di dati binari utilizzano il tipo Document/BLOB anziché il tipo di matrice byte. Il tipo di documento è molto più efficiente per la trasmissione di grandi quantità di dati.

Tipi di dati del servizio Web

La tabella seguente elenca i tipi di dati Java e mostra il tipo di dati del servizio Web corrispondente.

Tipo di dati Java

Tipo di dati del servizio Web

java.lang.byte[]

xsd:base64Binary

java.lang.Boolean

xsd:boolean

java.util.Date

Il DATE tipo, definito in un WSDL di servizio come segue:

<complexType name="DATE">

<sequence>

<element maxOccurs="1" minOccurs="0" name="date" type="xsd:dateTime" />

<element maxOccurs="1" minOccurs="0" name="calendar" type="xsd:dateTime" />

</sequence>

</complexType>

Se un'operazione servizio AEM Forms richiede un java.util.Date valore come input, l'applicazione client SOAP deve passare la data nel DATE.date campo. L'impostazione del DATE.calendar campo in questo caso causa un'eccezione di runtime. Se il servizio restituisce un java.util.Date, la data viene restituita nel DATE.date campo.

java.util.Calendar

Il DATE tipo, definito in un WSDL di servizio come segue:

<complexType name="DATE">

<sequence>

<element maxOccurs="1" minOccurs="0" name="date" type="xsd:dateTime" />

<element maxOccurs="1" minOccurs="0" name="calendar" type="xsd:dateTime" />

</sequence>

</complexType>

Se un'operazione servizio AEM Forms richiede un java.util.Calendar valore come input, l'applicazione client SOAP deve passare la data nel DATE.caledendar campo. L'impostazione del DATE.date campo in questo caso causa un'eccezione di runtime. Se il servizio restituisce un java.util.Calendar, la data viene restituita nel DATE.calendar campo.

java.math.BigDecimal

xsd:decimal

com.adobe.idp.Document

BLOB

java.lang.Double

xsd:double

java.lang.Float

xsd:float

java.lang.Integer

xsd:int

java.util.List

MyArrayOf_xsd_anyType

java.lang.Long

xsd:long

java.util.Map

Il apachesoap:Map, definito in un servizio WSDL come segue:

<schema elementFormDefault="qualified" targetNamespace="https://xml.apache.org/xml-soap" xmlns="https://www.w3.org/2001/XMLSchema">

<complexType name="mapItem">

<sequence>

<element name="key" nillable="true" type="xsd:anyType"/>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E<element%20name=?lang=it"value" nillable="true" type="xsd:anyType"/>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E</sequence>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E</complexType>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E<complexType%20name=?lang=it"Map">

<sequence>

<element maxOccurs="unbounded" minOccurs="0" name="item" type="apachesoap:mapItem"/>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E</sequence>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E</complexType>%3C/code%3E%3C/p%3E%3Cp%3E%3Ccode%3E</schema>%3C/code%3E%3C/p%3E%3Cp%3ELa%20mappa%20%C3%A8%20rappresentata%20come%20una%20sequenza%20di%20coppie%20chiave/valore.%3C/p%3E%3C/td%3E%20%20%3C/tr%3E%20%20%3Ctr%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Ejava.lang.Object%3C/code%3E%3C/p%3E%3C/td%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3E$1%3C/code%3E%3C/p%3E%3C/td%3E%20%20%3C/tr%3E%20%20%3Ctr%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Ejava.lang.Short%3C/code%3E%3C/p%3E%3C/td%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Exsd:short%3C/code%3E%3C/p%3E%3C/td%3E%20%20%3C/tr%3E%20%20%3Ctr%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Ejava.lang.String%3C/code%3E%3C/p%3E%3C/td%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Exsd:string%3C/code%3E%3C/p%3E%3C/td%3E%20%20%3C/tr%3E%20%20%3Ctr%3E%20%20%20%3Ctd%3E%3Cp%3E%3Ccode%3Eorg.w3c.dom.Document%3C/code%3E%3C/p%3E%3C/td%3E%20%20%20%3Ctd%3E%3Cp%3EIl%20tipo%20XML,%20definito%20in%20un%20servizio%20WSDL%20come%20segue:%3C/p%3E%3Cp%3E%3Ccode%3E<complexType%20name=?lang=it"XML">

<sequence>

<element maxOccurs="1" minOccurs="0" name="document" type="xsd:string" />

<element maxOccurs="1" minOccurs="0" name="element" type="xsd:string" />

</sequence>

</complexType>

Se un'operazione del servizio AEM Forms accetta un org.w3c.dom.Document valore, trasmettere i dati XML nel XML.document campo.

L'impostazione del XML.element campo causa un'eccezione di runtime. Se il servizio restituisce un org.w3c.dom.Document, i dati XML vengono restituiti nel XML.document campo.

org.w3c.dom.Element

Il tipo XML, definito in un servizio WSDL come segue:

<complexType name="XML">

<sequence>

<element maxOccurs="1" minOccurs="0" name="document" type="xsd:string" />

<element maxOccurs="1" minOccurs="0" name="element" type="xsd:string" />

</sequence>

</complexType>

Se un'operazione del servizio AEM Forms richiede un input org.w3c.dom.Element come input, trasmettere i dati XML nel XML.element campo.

L'impostazione del XML.document campo causa un'eccezione di runtime. Se il servizio restituisce un org.w3c.dom.Element, i dati XML vengono restituiti nel XML.element campo.

Sito Web Adobe per sviluppatori

Il sito Web Adobe Developer contiene il seguente articolo che descrive come richiamare servizi AEM Forms mediante l'API del servizio Web:

Creazione di applicazioni ASP.NET per il rendering dei moduli

Chiamata di servizi Web mediante componenti personalizzati

Nota

L'invocazione di servizi Web tramite componenti personalizzati descrive come creare un componente AEM Forms che richiama servizi Web di terze parti.

Creazione di classi proxy Java tramite JAX-WS

È possibile utilizzare JAX-WS per convertire un WSDL del servizio Forms in classi proxy Java. Queste classi consentono di richiamare operazioni dei servizi AEM Forms. Apache Ant consente di creare uno script di compilazione che genera classi proxy Java facendo riferimento a un WSDL servizio AEM Forms. È possibile generare file proxy JAX-WS eseguendo i passaggi seguenti:

  1. Installate Apache Ant sul computer client. Consultate https://ant.apache.org/bindownload.cgi.

    • Aggiungete la directory bin al percorso della classe.
    • Impostate la variabile di ANT_HOME ambiente sulla directory in cui avete installato Ant.
  2. Installate JDK 1.6 o versione successiva.

    • Aggiungete la directory bin JDK al percorso della classe.
    • Aggiungete la directory JRE bin al percorso della classe. Questo bin si trova nella [JDK_INSTALL_LOCATION]/jre directory.
    • Impostate la variabile di JAVA_HOME ambiente sulla directory in cui avete installato il JDK.

    JDK 1.6 include il programma wsimport utilizzato nel file build.xml. JDK 1.5 non include tale programma.

  3. Installare JAX-WS sul computer client. (Vedere API Java per i serviziWeb XML.)

  4. Utilizzate JAX-WS e Apache Ant per generare classi proxy Java. Creare uno script di creazione Ant per eseguire questa operazione. Lo script seguente è un esempio di script Ant build denominato build.xml:

     <?xml version="1.0" encoding="UTF-8"?>
     
     <project basedir="." default="compile">
     
     <property name="port" value="8080" />
     <property name="host" value="localhost" />
     <property name="username" value="administrator" />
     <property name="password" value="password" />
     <property name="tests" value="all" />
     
     <target name="clean" >
            <delete dir="classes" />
     </target>
     
     <target name="wsdl" depends="clean">
            <mkdir dir="classes"/>
            <exec executable="wsimport" failifexecutionfails="false" failonerror="true" resultproperty="foundWSIMPORT">
                <arg line="-keep -d classes https://${host}:${port}/soap/services/EncryptionService?wsdl&lc_version=9.0.1"/>
            </exec>
            <fail unless="foundWSIMPORT">
               !!! Failed to execute JDK's wsimport tool. Make sure that JDK 1.6 (or later) is on your PATH !!!
            </fail>
     </target>
     
     <target name="compile" depends="clean, wsdl" >
          <javac destdir="./classes" fork="true" debug="true">
             <src path="./src"/>
          </javac>
     </target>
     
     <target name="run">
          <java classname="Client" fork="yes" failonerror="true" maxmemory="200M">
             <classpath>
               <pathelement location="./classes"/>
             </classpath>
             <arg value="${port}"/>
             <arg value="${host}"/>
             <arg value="${username}"/>
             <arg value="${password}"/>
             <arg value="${tests}"/>
          </java>
     </target>
     </project>
    

    In questo script di creazione Ant, si noti che la url proprietà è impostata per fare riferimento al WSDL del servizio di cifratura in esecuzione su localhost. Le proprietà username e password devono essere impostate su un nome utente e una password validi per i moduli AEM. L’URL contiene l’ lc_version attributo. Senza specificare l' lc_version opzione, non è possibile richiamare nuove operazioni servizio AEM Forms.

    Nota

    Sostituire EncryptionServicecon il nome del servizio AEM Forms che si desidera richiamare utilizzando le classi proxy Java. Ad esempio, per creare classi proxy Java per il servizio di Rights Management, specificate:

     http://localhost:8080/soap/services/RightsManagementService?WSDL&lc_version=9.0.1
    
  5. Creare un file BAT per eseguire lo script di creazione Ant. È possibile individuare il seguente comando all'interno di un file BAT che è responsabile dell'esecuzione dello script di compilazione Ant:

     ant -buildfile "build.xml" wsdl
    

    Posizionare lo script di compilazione ANT nella cartella C:\Program Files\Java\jaxws-ri\bin directory. Lo script scrive i file JAVA in ./class. Lo script genera file JAVA in grado di richiamare il servizio.

  6. Creare pacchetti di file JAVA in un file JAR. Se state lavorando su Eclipse, effettuate le seguenti operazioni:

    • Create un nuovo progetto Java utilizzato per creare il pacchetto dei file JAVA proxy in un file JAR.
    • Create una cartella sorgente nel progetto.
    • Create un com.adobe.idp.services pacchetto nella cartella Sorgente.
    • Selezionate il com.adobe.idp.services pacchetto, quindi importate i file JAVA dalla cartella adobe/idp/services nel pacchetto.
    • Se necessario, create un org/apache/xml/xmlsoap pacchetto nella cartella Sorgente.
    • Selezionate la cartella di origine e importate i file JAVA dalla cartella org/apache/xml/xmlsoap.
    • Impostate il livello di conformità del compilatore Java su 5.0 o superiore.
    • Create il progetto.
    • Esportate il progetto come file JAR.
    • Importa questo file JAR nel percorso di classe di un progetto client. Inoltre, importate tutti i file JAR che si trovano in <Directory di installazione>\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty.
    Nota

    Tutti i servizi Web Java avviano rapidamente (ad eccezione del servizio Forms) che si trova in Programmazione con moduli AEM creare file proxy Java utilizzando JAX-WS. Inoltre, tutti i servizi Web Java si avviano rapidamente, utilizza SwaRef. Consultate Attivazione AEM Forms tramite SwaRef.

Consulta anche

Creazione di classi proxy Java tramite Apache Axis

Richiamo AEM Forms con codifica Base64

Richiamo AEM Forms utilizzando dati BLOB su HTTP

Chiamata AEM Forms tramite SwaRef

Creazione di classi proxy Java tramite Apache Axis

È possibile utilizzare lo strumento Apache Axis WSDL2Java per convertire un servizio Forms in classi proxy Java. Queste classi consentono di richiamare le operazioni del servizio Forms. Utilizzando Apache Ant, potete generare file libreria Axis da un servizio WSDL. Potete scaricare Apache Axis dall'URL https://ws.apache.org/axis/.

Nota

Gli avvii rapidi del servizio Web associati al servizio Forms utilizzano le classi proxy Java create utilizzando Apache Axis. Il servizio Web Forms avvia rapidamente l'utilizzo di Base64 come tipo di codifica. Consultate Avvio rapido diForms Service API.

È possibile generare file libreria Java Axis eseguendo i seguenti passaggi:

  1. Installate Apache Ant sul computer client. È disponibile all'indirizzo https://ant.apache.org/bindownload.cgi.

    • Aggiungete la directory bin al percorso della classe.
    • Impostate la variabile di ANT_HOME ambiente sulla directory in cui avete installato Ant.
  2. Installate Apache Axis 1.4 nel computer client. È disponibile all'indirizzo https://ws.apache.org/axis/.

  3. Configurate il percorso della classe per utilizzare i file JAR Axis nel client di servizi Web, come descritto nelle istruzioni di installazione Axis all'indirizzo https://ws.apache.org/axis/java/install.html.

  4. Utilizzate lo strumento Apache WSDL2Java in Axis per generare classi proxy Java. Creare uno script di creazione Ant per eseguire questa operazione. Lo script seguente è un esempio di script Ant build denominato build.xml:

     <?xml version="1.0"?>
     <project name="axis-wsdl2java">
     
     <path id="axis.classpath">
     <fileset dir="C:\axis-1_4\lib" >
         <include name="**/*.jar" />
     </fileset>
     </path>
     
     <taskdef resource="axis-tasks.properties" classpathref="axis.classpath" />
     
     <target name="encryption-wsdl2java-client" description="task">
     <axis-wsdl2java
         output="C:\JavaFiles"
         testcase="false"
         serverside="false"
         verbose="true"
         username="administrator"
         password="password"
         url="http://localhost:8080/soap/services/EncryptionService?wsdl&lc_version=9.0.1" >
     </axis-wsdl2java>
     </target>
     
     </project>
    

    In questo script di creazione Ant, si noti che la url proprietà è impostata per fare riferimento al WSDL del servizio di cifratura in esecuzione su localhost. Le proprietà username e password devono essere impostate su un nome utente e una password validi per i moduli AEM.

  5. Creare un file BAT per eseguire lo script di creazione Ant. È possibile individuare il seguente comando all'interno di un file BAT che è responsabile dell'esecuzione dello script di compilazione Ant:

     ant -buildfile "build.xml" encryption-wsdl2java-client
    

    I file JAVA vengono scritti nella proprietà C:\JavaFiles folder as specified by the output . Per richiamare il servizio Forms, importate questi file JAVA nel percorso della classe.

    Per impostazione predefinita, questi file appartengono a un pacchetto Java denominato com.adobe.idp.services. È consigliabile inserire questi file JAVA in un file JAR. Quindi importate il file JAR nel percorso di classe dell'applicazione client.

    Nota

    Ci sono diversi modi per inserire i file .JAVA in una JAR. Un modo è utilizzare un IDE Java come Eclipse. Create un progetto Java e create un com.adobe.idp.servicespacchetto (tutti i file .JAVA appartengono a questo pacchetto). Quindi importate tutti i file .JAVA nel pacchetto. Infine, esportate il progetto come file JAR.

  6. Modificate l'URL nella EncryptionServiceLocator classe per specificare il tipo di codifica. Ad esempio, per utilizzare base64, specificare ?blob=base64 in modo che l' BLOB oggetto restituisca dati binari. Nella EncryptionServiceLocator classe, individuare la seguente riga di codice:

     http://localhost:8080/soap/services/EncryptionService;
    

    e cambiarlo in:

     http://localhost:8080/soap/services/EncryptionService?blob=base64;
    
  7. Aggiungete i seguenti file JAR dell'asse al percorso di classe del progetto Java:

    • activation.jar
    • axis.jar
    • commons-codec-1.3.jar
    • commons-collections-3.1.jar
    • commons-discovery.jar
    • commons-logging.jar
    • dom3-xml-apis-2.5.0.jar
    • jai_imageio.jar
    • jaxen-1.1-beta-9.jar
    • jaxrpc.jar
    • log4j.jar
    • mail.jar
    • saaj.jar
    • wsdl4j.jar
    • xalan.jar
    • xbean.jar
    • xercesImpl.jar

    Questi file JAR si trovano nella [install directory]/Adobe/Adobe Experience Manager Forms/sdk/lib/thirdparty directory.

Consulta anche

Creazione di classi proxy Java tramite JAX-WS

Richiamo AEM Forms con codifica Base64

Richiamo AEM Forms utilizzando dati BLOB su HTTP

Richiamo AEM Forms con codifica Base64

È possibile richiamare un servizio AEM Forms utilizzando la codifica Base64. La codifica Base64 codifica gli allegati inviati con una richiesta di chiamata al servizio Web. In altre parole, BLOB i dati sono codificati Base64, non l'intero messaggio SOAP.

"Richiamando AEM Forms con codifica Base64" viene illustrato come richiamare il seguente processo di breve durata di AEM Forms denominato MyApplication/EncryptDocument utilizzando la codifica Base64.

Nota

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedere Uso di Workbench.)

Quando viene richiamato, questo processo esegue le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione è basata sull' SetValue operazione. Il parametro di input per questo processo è una variabile di document processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione è basata sull' PasswordEncryptPDF operazione. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.

Creazione di un assembly client .NET che utilizza la codifica Base64

È possibile creare un assembly client .NET per richiamare un servizio Forms da un progetto Microsoft Visual Studio .NET. Per creare un assembly client .NET che utilizza la codifica base64, effettuare le seguenti operazioni:

  1. Create una classe proxy basata su un URL di chiamata AEM Forms.
  2. Creare un progetto Microsoft Visual Studio .NET che produca l'assembly client .NET.

Creazione di una classe proxy

È possibile creare una classe proxy utilizzata per creare l'assembly del client .NET utilizzando uno strumento associato a Microsoft Visual Studio. Il nome dello strumento è wsdl.exe e si trova nella cartella di installazione di Microsoft Visual Studio. Per creare una classe proxy, aprite il prompt dei comandi e individuate la cartella che contiene il file wsdl.exe. Per ulteriori informazioni sullo strumento wsdl.exe, vedere la Guida ** MSDN.

Digitare il comando seguente al prompt dei comandi:

 wsdl https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1

Per impostazione predefinita, questo strumento crea un file CS nella stessa cartella che si basa sul nome del WSDL. In questa situazione, crea un file CS denominato EncryptDocumentService.cs. Questo file CS consente di creare un oggetto proxy che consente di richiamare il servizio specificato nell'URL di chiamata.

Modificate l'URL nella classe proxy in modo da includere ?blob=base64 BLOB l'oggetto che restituisce dati binari. Nella classe proxy, individuare la seguente riga di codice:

 "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument";

e cambiarlo in:

 "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=base64";

La sezione Invoking AEM Forms tramite Codifica Base64 viene utilizzata MyApplication/EncryptDocument come esempio. Se si sta creando un assembly client .NET per un altro servizio Forms, assicurarsi di sostituire MyApplication/EncryptDocument con il nome del servizio.

Sviluppo dell'assembly del client .NET

Creare un progetto della libreria di classi di Visual Studio che produca un assembly client .NET. Il file CS creato con wsdl.exe può essere importato in questo progetto. Questo progetto genera un file DLL (l'assembly del client .NET) che è possibile utilizzare in altri progetti .NET di Visual Studio per richiamare un servizio.

  1. Avviare Microsoft Visual Studio .NET.
  2. Creare un progetto della libreria di classi e denominarlo DocumentService.
  3. Importate il file CS creato con wsdl.exe.
  4. Nel menu Progetto , selezionate Aggiungi riferimento.
  5. Nella finestra di dialogo Aggiungi riferimento, selezionare System.Web.Services.dll.
  6. Click Select and then click OK.
  7. Compilate e create il progetto.
Nota

Questa procedura crea un assembly client .NET denominato DocumentService.dll che è possibile utilizzare per inviare richieste SOAP al MyApplication/EncryptDocument servizio.

Nota

Accertatevi di aver aggiunto ?blob=base64 all'URL nella classe proxy utilizzata per creare l'assembly client .NET. In caso contrario, non è possibile recuperare dati binari dall' BLOB oggetto.

Riferimento all'assembly del client .NET

Posizionare l'assembly client .NET appena creato sul computer in cui si sta sviluppando l'applicazione client. Dopo aver posizionato l'assembly del client .NET in una directory, è possibile farvi riferimento da un progetto. Fate anche riferimento alla System.Web.Services libreria dal progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.

  1. Nel menu Progetto , selezionate Aggiungi riferimento.
  2. Click the .NET tab.
  3. Fare clic su Sfoglia e individuare il file DocumentService.dll.
  4. Click Select and then click OK.

Richiamo di un servizio utilizzando un assembly client .NET che utilizza la codifica Base64

È possibile richiamare il MyApplication/EncryptDocument servizio (creato in Workbench) utilizzando un assembly client .NET che utilizza la codifica Base64. Per richiamare il MyApplication/EncryptDocument servizio, effettuare le seguenti operazioni:

  1. Creare un assembly client Microsoft .NET che utilizzi il MyApplication/EncryptDocument servizio WSDL.
  2. Creare un progetto Microsoft .NET client. Fare riferimento all'assembly client Microsoft .NET nel progetto client. Riferimento anche System.Web.Services.
  3. Utilizzando l'assembly client Microsoft .NET, creare un MyApplication_EncryptDocumentService oggetto richiamando il relativo costruttore predefinito.
  4. Impostare la proprietà dell' MyApplication_EncryptDocumentService oggetto Credentials con un System.Net.NetworkCredential oggetto. All'interno del System.Net.NetworkCredential costruttore, specificare un nome utente per i moduli AEM e la password corrispondente. Impostare i valori di autenticazione per consentire all'applicazione client .NET di scambiare correttamente i messaggi SOAP con AEM Forms.
  5. Creare un BLOB oggetto utilizzando il relativo costruttore. L' BLOB oggetto viene utilizzato per memorizzare un documento PDF passato al MyApplication/EncryptDocument processo.
  6. Creare un System.IO.FileStream oggetto richiamandone il costruttore. Passare un valore di stringa che rappresenta la posizione del file del documento PDF e la modalità di apertura del file.
  7. Creare un array di byte che memorizza il contenuto dell' System.IO.FileStream oggetto. È possibile determinare la dimensione dell'array di byte ottenendo la proprietà dell' System.IO.FileStream oggetto Length .
  8. Compilare l'array di byte con i dati del flusso richiamando il metodo dell' System.IO.FileStream oggetto Read . Passare l'array di byte, la posizione iniziale e la lunghezza del flusso da leggere.
  9. Compilare l' BLOB oggetto assegnandone binaryData la proprietà con il contenuto dell'array di byte.
  10. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplication_EncryptDocumentService metodo dell' invoke oggetto e passando l' BLOB oggetto che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.
  11. Creare un System.IO.FileStream oggetto richiamando il relativo costruttore e passando un valore di stringa che rappresenta la posizione del file del documento crittografato con password.
  12. Creare un array di byte che memorizza il contenuto dei dati dell' BLOB oggetto restituito dal MyApplicationEncryptDocumentService metodo dell' invoke oggetto. Compilare l'array di byte ottenendo il valore del membro BLOB dati dell' binaryData oggetto.
  13. Creare un System.IO.BinaryWriter oggetto richiamando il relativo costruttore e passando l' System.IO.FileStream oggetto.
  14. Scrivere il contenuto dell'array di byte in un file PDF richiamando il metodo dell' System.IO.BinaryWriter oggetto Write e passando l'array di byte.

Chiamata di un servizio mediante classi proxy Java e codifica Base64

È possibile richiamare un servizio AEM Forms utilizzando le classi proxy Java e Base64. Per richiamare il MyApplication/EncryptDocument servizio utilizzando le classi proxy Java, effettuare le seguenti operazioni:

  1. Creare classi proxy Java utilizzando JAX-WS che utilizza il WSDL del MyApplication/EncryptDocument servizio. Utilizzate il seguente endpoint WSDL:

    https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1

    Nota

    Sostituire hiro-xp con l'indirizzo IP del server applicazione J2EE che ospita AEM Forms.

  2. Creare pacchetti delle classi proxy Java create utilizzando JAX-WS in un file JAR.

  3. Includete il file Java proxy JAR e i file JAR che si trovano nel seguente percorso:

    <Directory di installazione>\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso di classe del progetto client Java.

  4. Creare un MyApplicationEncryptDocumentService oggetto utilizzando il relativo costruttore.

  5. Creare un MyApplicationEncryptDocument oggetto richiamando il MyApplicationEncryptDocumentService metodo dell' getEncryptDocument oggetto.

  6. Impostate i valori di connessione necessari per richiamare AEM Forms assegnando valori ai seguenti membri di dati:

    • Assegnare l'endpoint WSDL e il tipo di codifica al campo dell' javax.xml.ws.BindingProvider oggetto ENDPOINT_ADDRESS_PROPERTY . Per richiamare il MyApplication/EncryptDocument servizio con la codifica Base64, specificate il seguente valore URL:

      https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=base64

    • Assegnare l'utente dei moduli AEM al campo dell' javax.xml.ws.BindingProvider oggetto USERNAME_PROPERTY .

    • Assegnare il valore della password corrispondente al campo dell' javax.xml.ws.BindingProvider oggetto PASSWORD_PROPERTY .

    L'esempio di codice seguente mostra la logica dell'applicazione:

     //Set connection values required to invoke AEM Forms
     String url = "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=base64";
     String username = "administrator";
     String password = "password";
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
    
  7. Recuperare il documento PDF da inviare al MyApplication/EncryptDocument processo creando un java.io.FileInputStream oggetto utilizzando il relativo costruttore. Passa un valore di stringa che specifica la posizione del documento PDF.

  8. Creare un array di byte e compilarlo con il contenuto dell' java.io.FileInputStream oggetto.

  9. Creare un BLOB oggetto utilizzando il relativo costruttore.

  10. Compilare l' BLOB oggetto richiamandone il setBinaryData metodo e passando l'array di byte. L'oggetto BLOB è setBinaryData il metodo da chiamare quando si utilizza la codifica Base64. Consultate Fornitura di oggetti BLOB nelle richieste di assistenza.

  11. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplicationEncryptDocument metodo dell' invoke oggetto. Passa l' BLOB oggetto che contiene il documento PDF. Il metodo invoke restituisce un BLOB oggetto che contiene il documento PDF crittografato.

  12. Creare un array di byte contenente il documento PDF crittografato richiamando il BLOB metodo dell' getBinaryData oggetto.

  13. Salvare il documento PDF crittografato come file PDF. Scrivere l'array di byte in un file.

Consulta anche

Avvio rapido: Chiamata di un servizio tramite file proxy Java e codifica Base64

Creazione di un assembly client .NET che utilizza la codifica Base64

Chiamata AEM Forms tramite MTOM

È possibile richiamare servizi AEM Forms utilizzando l'MTOM standard del servizio Web. Questo standard definisce il modo in cui i dati binari, come un documento PDF, vengono trasmessi via Internet o Intranet. Una caratteristica di MTOM è l'uso dell' XOP:Include elemento. Questo elemento è definito nella specifica XML Binary Optimized Packaging (XOP) per fare riferimento agli allegati binari di un messaggio SOAP.

La discussione qui riguarda l'utilizzo di MTOM per invocare il seguente processo di breve durata AEM Forms denominato MyApplication/EncryptDocument.

Nota

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedere Uso di Workbench.)

Quando viene richiamato, questo processo esegue le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione è basata sull' SetValue operazione. Il parametro di input per questo processo è una variabile di document processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione è basata sull' PasswordEncryptPDF operazione. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
Nota

Supporto per MTOM aggiunto in AEM Forms, versione 9.

Nota

Le applicazioni basate su JAX WS che utilizzano il protocollo di trasmissione MTOM sono limitate a 25 MB di dati inviati e ricevuti. Questa limitazione è dovuta a un bug in JAX-WS. Se la dimensione combinata dei file inviati e ricevuti supera i 25 MB, utilizzate il protocollo di trasmissione SwaRef invece di quello MTOM. In caso contrario, esiste la possibilità di un' OutOfMemory eccezione.

La discussione qui riguarda l'utilizzo di MTOM all'interno di un progetto Microsoft .NET per richiamare servizi AEM Forms. .NET framework utilizzato è 3.5 e l'ambiente di sviluppo è Visual Studio 2008. Se nel computer di sviluppo è installato Web Service Enhancements (WSE), rimuoverlo. Il framework .NET 3.5 supporta un framework SOAP denominato Windows Communication Foundation (WCF). Quando si esegue AEM Forms utilizzando MTOM, è supportato solo WCF (non WSE).

Creazione di un progetto .NET che richiama un servizio utilizzando MTOM

È possibile creare un progetto Microsoft .NET in grado di richiamare un servizio AEM Forms utilizzando i servizi Web. Creare innanzitutto un progetto Microsoft .NET utilizzando Visual Studio 2008. Per richiamare un servizio AEM Forms , create un riferimento al servizio AEM Forms che desiderate richiamare all'interno del progetto. Quando create un riferimento a un servizio, specificate un URL per il servizio AEM Forms :

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1

Sostituire localhost con l'indirizzo IP del server applicazione J2EE che ospita AEM Forms. Sostituire MyApplication/EncryptDocument con il nome del servizio AEM Forms da richiamare. Ad esempio, per richiamare un'operazione di Rights Management, specificate:

http://localhost:8080/soap/services/RightsManagementService?WSDL&lc_version=9.0.1

L' lc_version opzione assicura che funzionalità AEM Forms, come MTOM, sia disponibile. Senza specificare l' lc_version opzione, non è possibile richiamare AEM Forms utilizzando MTOM.

Dopo aver creato un riferimento a un servizio, i tipi di dati associati al servizio AEM Forms sono disponibili per l'utilizzo all'interno del progetto .NET. Per creare un progetto .NET che richiama un servizio AEM Forms , effettuare le seguenti operazioni:

  1. Creare un progetto .NET utilizzando Microsoft Visual Studio 2008.

  2. Nel menu Progetto , selezionate Aggiungi riferimento servizio.

  3. Nella finestra di dialogo Indirizzo , specificare il WSDL nel servizio AEM Forms . Esempio,

     http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
    
  4. Click Go and then click OK.

Chiamata di un servizio tramite MTOM in un progetto .NET

Prendere in considerazione il MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il MyApplication/EncryptDocument processo (incorporato in Workbench) utilizzando MTOM, eseguire i passaggi seguenti:

  1. Creare un progetto Microsoft .NET.

  2. Creare un MyApplication_EncryptDocumentClient oggetto utilizzando il relativo costruttore predefinito.

  3. Creare un MyApplication_EncryptDocumentClient.Endpoint.Address oggetto utilizzando il System.ServiceModel.EndpointAddress costruttore. Passa un valore di stringa che specifica il WSDL al servizio AEM Forms e il tipo di codifica:

     https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=mtom
    

    Non è necessario utilizzare l' lc_version attributo. Questo attributo viene utilizzato quando create un riferimento a un servizio. Tuttavia, accertatevi di specificare ?blob=mtom.

    Nota

    Sostituire hiro-xp con l'indirizzo IP del server applicazione J2EE che ospita AEM Forms.

  4. Creare un System.ServiceModel.BasicHttpBinding oggetto ottenendo il valore del membro EncryptDocumentClient.Endpoint.Binding dati. Inserite il valore restituito in BasicHttpBinding.

  5. Impostare il membro dati dell' System.ServiceModel.BasicHttpBinding oggetto MessageEncoding su WSMessageEncoding.Mtom. Questo valore assicura che venga utilizzato MTOM.

  6. Abilitate l'autenticazione HTTP di base eseguendo le seguenti operazioni:

    • Assegnare il nome utente del modulo AEM al membro dati MyApplication_EncryptDocumentClient.ClientCredentials.UserName.UserName.
    • Assegnare il valore della password corrispondente al membro dati MyApplication_EncryptDocumentClient.ClientCredentials.UserName.Password.
    • Assegnare il valore costante HttpClientCredentialType.Basic al membro dati BasicHttpBindingSecurity.Transport.ClientCredentialType.
    • Assegnare il valore costante BasicHttpSecurityMode.TransportCredentialOnly al membro dati BasicHttpBindingSecurity.Security.Mode.

    L'esempio di codice seguente mostra queste attività.

     //Enable BASIC HTTP authentication
     encryptProcess.ClientCredentials.UserName.UserName = "administrator";
     encryptProcess.ClientCredentials.UserName.Password = "password";
     b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
     b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
     b.MaxReceivedMessageSize = 4000000;
     b.MaxBufferSize = 4000000;
     b.ReaderQuotas.MaxArrayLength = 4000000;
    
  7. Creare un BLOB oggetto utilizzando il relativo costruttore. L' BLOB oggetto viene utilizzato per memorizzare un documento PDF da passare al MyApplication/EncryptDocument processo.

  8. Creare un System.IO.FileStream oggetto richiamandone il costruttore. Passare un valore di stringa che rappresenta la posizione del file del documento PDF e la modalità di apertura del file.

  9. Creare un array di byte che memorizza il contenuto dell' System.IO.FileStream oggetto. È possibile determinare la dimensione dell'array di byte ottenendo la proprietà dell' System.IO.FileStream oggetto Length .

  10. Compilare l'array di byte con i dati del flusso richiamando il metodo dell' System.IO.FileStream oggetto Read . Passare l'array di byte, la posizione iniziale e la lunghezza del flusso da leggere.

  11. Compilare l' BLOB oggetto assegnando il membro MTOM dati con il contenuto dell'array di byte.

  12. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplication_EncryptDocumentClient metodo dell' invoke oggetto. Passa l' BLOB oggetto che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

  13. Creare un System.IO.FileStream oggetto richiamando il relativo costruttore e passando un valore di stringa che rappresenta la posizione del file del documento PDF protetto.

  14. Creare un array di byte che memorizza il contenuto dei dati dell' BLOB oggetto restituito dal invoke metodo. Compilare l'array di byte ottenendo il valore del membro BLOB dati dell' MTOM oggetto.

  15. Creare un System.IO.BinaryWriter oggetto richiamando il relativo costruttore e passando l' System.IO.FileStream oggetto.

  16. Scrivere il contenuto dell'array di byte in un file PDF richiamando il metodo dell' System.IO.BinaryWriter oggetto Write e passando l'array di byte.

Nota

La maggior parte operazioni di servizio AEM Forms hanno un avvio rapido MTOM. Potete visualizzare questi avvii rapidi nella sezione di avvio rapido corrispondente del servizio. Ad esempio, per vedere la sezione Avvio rapido di Output, vedere Avvio rapido diOutput Service API.

Consulta anche

Avvio rapido: Chiamata di un servizio tramite MTOM in un progetto .NET

Accesso a più servizi tramite i servizi Web

Creazione di un'applicazione Web ASP.NET che richiama un processo longevo incentrato sull'uomo

Chiamata AEM Forms tramite SwaRef

È possibile richiamare servizi AEM Forms utilizzando SwaRef. Il contenuto dell'elemento wsi:swaRef XML viene inviato come allegato all'interno di un corpo SOAP che memorizza il riferimento all'allegato. Quando si richiama un servizio Forms utilizzando SwaRef, creare classi proxy Java utilizzando l'API Java per i servizi Web XML (JAX-WS). (Vedere API Java per i serviziWeb XML.)

La discussione qui riguarda l'invocazione del seguente processo Forms di breve durata denominato MyApplication/EncryptDocument utilizzando SwaRef.

Nota

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedere Uso di Workbench.)

Quando viene richiamato, questo processo esegue le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione è basata sull' SetValue operazione. Il parametro di input per questo processo è una variabile di document processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione è basata sull' PasswordEncryptPDF operazione. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
Nota

Supporto SwaRef aggiunto in AEM Forms

Di seguito viene illustrato come invocare i servizi Forms utilizzando SwaRef in un'applicazione client Java. L'applicazione Java utilizza le classi proxy create utilizzando JAX-WS.

Richiamare un servizio utilizzando i file di libreria JAX-WS che utilizzano SwaRef

Per richiamare il MyApplication/EncryptDocument processo utilizzando i file proxy Java creati utilizzando JAX-WS e SwaRef, eseguire le operazioni seguenti:

  1. Creare classi proxy Java utilizzando JAX-WS che utilizza il WSDL del MyApplication/EncryptDocument servizio. Utilizzate il seguente endpoint WSDL:

     https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
    

    Per informazioni, vedere Creazione di classi proxy Java tramite JAX-WS.

    Nota

    Sostituire hiro-xp con l'indirizzo IP del server applicazione J2EE che ospita AEM Forms.

  2. Creare pacchetti delle classi proxy Java create utilizzando JAX-WS in un file JAR.

  3. Includete il file Java proxy JAR e i file JAR che si trovano nel seguente percorso:

    <Directory di installazione>\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso di classe del progetto client Java.

  4. Creare un MyApplicationEncryptDocumentService oggetto utilizzando il relativo costruttore.

  5. Creare un MyApplicationEncryptDocument oggetto richiamando il MyApplicationEncryptDocumentService metodo dell' getEncryptDocument oggetto.

  6. Impostate i valori di connessione necessari per richiamare AEM Forms assegnando valori ai seguenti membri di dati:

    • Assegnare l'endpoint WSDL e il tipo di codifica al campo dell' javax.xml.ws.BindingProvider oggetto ENDPOINT_ADDRESS_PROPERTY . Per richiamare il MyApplication/EncryptDocument servizio con la codifica SwaRef, specificate il seguente valore URL:

       https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=swaref

    • Assegnare l'utente dei moduli AEM al campo dell' javax.xml.ws.BindingProvider oggetto USERNAME_PROPERTY .

    • Assegnare il valore della password corrispondente al campo dell' javax.xml.ws.BindingProvider oggetto PASSWORD_PROPERTY .

    L'esempio di codice seguente mostra la logica dell'applicazione:

     //Set connection values required to invoke AEM Forms
     String url = "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=swaref";
     String username = "administrator";
     String password = "password";
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
    
  7. Recuperare il documento PDF da inviare al MyApplication/EncryptDocument processo creando un java.io.File oggetto utilizzando il relativo costruttore. Passa un valore di stringa che specifica la posizione del documento PDF.

  8. Creare un javax.activation.DataSource oggetto utilizzando il FileDataSource costruttore. Passate l' java.io.File oggetto.

  9. Creare un javax.activation.DataHandler oggetto utilizzando il relativo costruttore e passando l' javax.activation.DataSource oggetto.

  10. Creare un BLOB oggetto utilizzando il relativo costruttore.

  11. Compilare l' BLOB oggetto richiamandone il setSwaRef metodo e passando l' javax.activation.DataHandler oggetto.

  12. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplicationEncryptDocument metodo dell' invoke oggetto e passando l' BLOB oggetto che contiene il documento PDF. Il metodo invoke restituisce un BLOB oggetto che contiene un documento PDF crittografato.

  13. Compilare un javax.activation.DataHandler oggetto richiamando il BLOB metodo dell' getSwaRef oggetto.

  14. Convertire l' javax.activation.DataHandler oggetto in un' java.io.InputSteam istanza richiamando il metodo dell' javax.activation.DataHandler oggetto getInputStream .

  15. Scrivere l' java.io.InputSteam istanza in un file PDF che rappresenta il documento PDF crittografato.

Nota

La maggior parte operazioni del servizio AEM Forms hanno un avvio rapido SwaRef. Potete visualizzare questi avvii rapidi nella sezione di avvio rapido corrispondente del servizio. Ad esempio, per vedere la sezione Avvio rapido di Output, vedere Avvio rapido diOutput Service API.

Consulta anche

Avvio rapido: Richiamo di un servizio tramite SwaRef in un progetto Java

Richiamo AEM Forms utilizzando dati BLOB su HTTP

È possibile richiamare servizi AEM Forms utilizzando i servizi Web e inviando dati BLOB via HTTP. La trasmissione di dati BLOB su HTTP è una tecnica alternativa anziché utilizzare la codifica base64, DIME o MIME. Ad esempio, è possibile trasmettere dati via HTTP in un progetto Microsoft .NET che utilizza Web Service Enhancement 3.0, che non supporta DIME o MIME. Quando si utilizzano dati BLOB su HTTP, i dati di input vengono caricati prima che venga richiamato il servizio AEM Forms .

"Richiamando AEM Forms utilizzando i dati BLOB su HTTP" viene richiamato il seguente processo di breve durata di AEM Forms denominato MyApplication/EncryptDocument trasmettendo i dati BLOB su HTTP.

Nota

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedere Uso di Workbench.)

Quando viene richiamato, questo processo esegue le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione è basata sull' SetValue operazione. Il parametro di input per questo processo è una variabile di document processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione è basata sull' PasswordEncryptPDF operazione. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
Nota

Si consiglia di avere familiarità con l'invocazione AEM Forms utilizzando SOAP. (Vedere Chiamata AEM Forms tramite i serviziWeb.)

Creazione di un assembly client .NET che utilizza i dati su HTTP

Per creare un assembly client che utilizza i dati via HTTP, seguire il processo specificato in Chiamata AEM Forms con codificaBase64. Tuttavia, modificate l'URL nella classe proxy in modo da includerlo ?blob=http invece di ?blob=base64. In questo modo i dati vengono trasferiti su HTTP. Nella classe proxy, individuare la seguente riga di codice:

 "http://localhost:8080/soap/services/MyApplication/EncryptDocument";

e cambiarlo in:

 "http://localhost:8080/soap/services/MyApplication/EncryptDocument?blob=http";

Riferimento all'assembly .NET clientMyApplication/EncryptDocumentt

Posizionare il nuovo assembly client .NET sul computer in cui si sta sviluppando l'applicazione client. Dopo aver posizionato l'assembly del client .NET in una directory, è possibile farvi riferimento da un progetto. Fate riferimento alla System.Web.Services libreria dal progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.

  1. Nel menu Progetto , selezionate Aggiungi riferimento.
  2. Click the .NET tab.
  3. Fare clic su Sfoglia e individuare il file DocumentService.dll.
  4. Click Select and then click OK.

Richiamo di un servizio utilizzando un assembly client .NET che utilizza dati BLOB su HTTP

È possibile richiamare il MyApplication/EncryptDocument servizio (creato in Workbench) utilizzando un assembly client .NET che utilizza i dati via HTTP. Per richiamare il MyApplication/EncryptDocument servizio, effettuare le seguenti operazioni:

  1. Creare l'assembly del client .NET.
  2. Fare riferimento all'assembly client Microsoft .NET. Creare un progetto Microsoft .NET client. Fare riferimento all'assembly client Microsoft .NET nel progetto client. Riferimento anche System.Web.Services.
  3. Utilizzando l'assembly client Microsoft .NET, creare un MyApplication_EncryptDocumentService oggetto richiamando il relativo costruttore predefinito.
  4. Impostare la proprietà dell' MyApplication_EncryptDocumentService oggetto Credentials con un System.Net.NetworkCredential oggetto. All'interno del System.Net.NetworkCredential costruttore, specificare un nome utente per i moduli AEM e la password corrispondente. Impostare i valori di autenticazione per consentire all'applicazione client .NET di scambiare correttamente i messaggi SOAP con AEM Forms.
  5. Creare un BLOB oggetto utilizzando il relativo costruttore. L' BLOB oggetto viene utilizzato per trasmettere i dati al MyApplication/EncryptDocument processo.
  6. Assegnare un valore di stringa al membro di dati dell' BLOB oggetto che specifica la posizione URI di un documento PDF da trasmettere al remoteURL MyApplication/EncryptDocumentservizio.
  7. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplication_EncryptDocumentService metodo dell'oggetto invoke e passando l' BLOB oggetto. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.
  8. Creare un System.UriBuilder oggetto utilizzando il relativo costruttore e passando il valore del membro dati dell' BLOB oggetto restituito remoteURL .
  9. Convertire l' System.UriBuilder oggetto in un System.IO.Stream oggetto. (L'Avvio rapido C# che segue questo elenco illustra come eseguire questa attività.)
  10. Creare un array di byte e compilarlo con i dati che si trovano nell' System.IO.Stream oggetto.
  11. Creare un System.IO.BinaryWriter oggetto richiamando il relativo costruttore e passando l' System.IO.FileStream oggetto.
  12. Scrivere il contenuto dell'array di byte in un file PDF richiamando il metodo dell' System.IO.BinaryWriter oggetto Write e passando l'array di byte.

Richiamo di un servizio mediante classi proxy Java e dati BLOB su HTTP

Potete richiamare un servizio AEM Forms utilizzando le classi proxy Java e i dati BLOB su HTTP. Per richiamare il MyApplication/EncryptDocument servizio utilizzando le classi proxy Java, effettuare le seguenti operazioni:

  1. Creare classi proxy Java utilizzando JAX-WS che utilizza il WSDL del MyApplication/EncryptDocument servizio. Utilizzate il seguente endpoint WSDL:

     https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
    

    Per informazioni, vedere Creazione di classi proxy Java tramite JAX-WS.

    Nota

    Sostituire hiro-xp con l'indirizzo IP del server applicazione J2EE che ospita AEM Forms.

  2. Creare pacchetti delle classi proxy Java create utilizzando JAX-WS in un file JAR.

  3. Includete il file Java proxy JAR e i file JAR che si trovano nel seguente percorso:

    <Directory di installazione>\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso di classe del progetto client Java.

  4. Creare un MyApplicationEncryptDocumentService oggetto utilizzando il relativo costruttore.

  5. Creare un MyApplicationEncryptDocument oggetto richiamando il MyApplicationEncryptDocumentService metodo dell' getEncryptDocument oggetto.

  6. Impostate i valori di connessione necessari per richiamare AEM Forms assegnando valori ai seguenti membri di dati:

    • Assegnare l'endpoint WSDL e il tipo di codifica al campo dell' javax.xml.ws.BindingProvider oggetto ENDPOINT_ADDRESS_PROPERTY . Per richiamare il MyApplication/EncryptDocument servizio utilizzando la codifica BLOB su HTTP, specificate il seguente valore URL:

      https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=http

    • Assegnare l'utente dei moduli AEM al campo dell' javax.xml.ws.BindingProvider oggetto USERNAME_PROPERTY .

    • Assegnare il valore della password corrispondente al campo dell' javax.xml.ws.BindingProvider oggetto PASSWORD_PROPERTY .

    L'esempio di codice seguente mostra la logica dell'applicazione:

     //Set connection values required to invoke AEM Forms
     String url = "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=http";
     String username = "administrator";
     String password = "password";
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.USERNAME_PROPERTY, username);
     ((BindingProvider) encryptDocClient).getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, password);
    
  7. Creare un BLOB oggetto utilizzando il relativo costruttore.

  8. Compilare l' BLOB oggetto richiamandone il setRemoteURL metodo. Passa un valore di stringa che specifica la posizione URI di un documento PDF da trasmettere al MyApplication/EncryptDocument servizio.

  9. Richiamare il MyApplication/EncryptDocument processo richiamando il MyApplicationEncryptDocument metodo dell' invoke oggetto e passando l' BLOB oggetto che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

  10. Creare un array di byte per memorizzare il flusso di dati che rappresenta il documento PDF crittografato. Richiamare il metodo dell' BLOB oggetto getRemoteURL (utilizzare l' BLOB oggetto restituito dal invoke metodo).

  11. Creare un java.io.File oggetto utilizzando il relativo costruttore. Questo oggetto rappresenta il documento PDF crittografato.

  12. Creare un java.io.FileOutputStream oggetto utilizzando il relativo costruttore e passando l' java.io.File oggetto.

  13. Richiama il metodo dell’ java.io.FileOutputStream oggetto write . Trasmettere l'array di byte che contiene il flusso di dati che rappresenta il documento PDF crittografato.

Richiamo AEM Forms tramite DIME

È possibile richiamare servizi AEM Forms utilizzando SOAP con allegati. AEM Forms supporta sia gli standard dei servizi Web MIME che DIME. DIME consente di inviare allegati binari, come documenti PDF, insieme a richieste di chiamata invece di codificare l'allegato. Nella sezione Richiamo AEM Forms tramite DIME viene illustrato come richiamare il seguente processo di breve durata AEM Forms denominato MyApplication/EncryptDocument tramite DIME.

Quando viene richiamato, questo processo esegue le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione è basata sull' SetValue operazione. Il parametro di input per questo processo è una variabile di document processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione è basata sull' PasswordEncryptPDF operazione. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.

Questo processo non è basato su un processo AEM Forms esistente. Per seguire gli esempi di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedere Uso di Workbench.)

Nota

La chiamata operazioni di servizio AEM Forms tramite DIME è obsoleta. Si consiglia di utilizzare MTOM. Consultate Attivazione AEM Forms con MTOM.

Creazione di un progetto .NET che utilizza DIME

Per creare un progetto .NET in grado di richiamare un servizio Forms utilizzando DIME, eseguire le operazioni seguenti:

  • Installazione di Web Services Enhancements 2.0 nel computer di sviluppo.
  • Dall'interno del progetto .NET, creare un riferimento Web al servizio Forms FormsAEM.

Installazione dei miglioramenti ai servizi Web 2.0

Installazione dei miglioramenti ai servizi Web 2.0 nel computer di sviluppo e integrazione con Microsoft Visual Studio .NET. È possibile scaricare Web Services Enhancements 2.0 dal Centro di download di Microsoft.

Da questa pagina Web, cercare Web Services Enhancements 2.0 e scaricarlo sul computer di sviluppo. Questo download inserisce nel computer un file denominato Microsoft WSE 2.0 SPI.msi. Eseguire il programma di installazione e seguire le indicazioni online.

Nota

Web Services Enhancements 2.0 supporta DIME. La versione supportata di Microsoft Visual Studio è 2003 quando si utilizzano i miglioramenti ai servizi Web 2.0. Web Services Enhancement 3.0 non supporta DIME; tuttavia, supporta MTOM.

Creazione di un riferimento Web a un servizio AEM Forms

Dopo aver installato Web Services Enhancements 2.0 nel computer di sviluppo e creato un progetto Microsoft .NET, creare un riferimento Web al servizio Forms. Ad esempio, per creare un riferimento Web al MyApplication/EncryptDocument processo e presupponendo che Forms sia installato sul computer locale, specificate il seguente URL:

     http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL

Dopo aver creato un riferimento Web, è possibile utilizzare nel progetto .NET i due tipi di dati proxy seguenti: EncryptDocumentService e EncryptDocumentServiceWse. Per richiamare il MyApplication/EncryptDocument processo con DIME, utilizzare il EncryptDocumentServiceWse tipo.

Nota

Prima di creare un riferimento Web al servizio Forms, assicurarsi di fare riferimento a Web Services Enhancements 2.0 nel progetto. (Vedere "Installazione dei miglioramenti ai servizi Web 2.0".)

Riferimento alla libreria WSE

  1. Nel menu Progetto, selezionate Aggiungi riferimento.
  2. Nella finestra di dialogo Aggiungi riferimento, selezionare Microsoft.Web.Services2.dll.
  3. Selezionare System.Web.Services.dll.
  4. Fate clic su Seleziona e quindi su OK.

Creare un riferimento Web a un servizio Forms

  1. Nel menu Progetto, selezionate Aggiungi riferimento Web.
  2. Nella finestra di dialogo URL, specificate l'URL del servizio Forms.
  3. Fare clic su Vai, quindi su Aggiungi riferimento.
Nota

Assicurarsi di abilitare il progetto .NET per l'utilizzo della libreria WSE. In Esplora progetti, fare clic con il pulsante destro del mouse sul nome del progetto e selezionare Abilita WSE 2.0. Verificare che la casella di controllo nella finestra di dialogo visualizzata sia selezionata.

Richiamo di un servizio mediante DIME in un progetto .NET

È possibile richiamare un servizio Forms utilizzando DIME. Prendere in considerazione il MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il MyApplication/EncryptDocument processo con DIME, eseguire le operazioni seguenti:

  1. Creare un progetto Microsoft .NET che consenta di richiamare un servizio Forms utilizzando DIME. Assicurarsi di includere i miglioramenti ai servizi Web 2.0 e creare un riferimento Web al servizio AEM Forms .

  2. Dopo aver impostato un riferimento Web al MyApplication/EncryptDocument processo, creare un EncryptDocumentServiceWse oggetto utilizzando il relativo costruttore predefinito.

  3. Impostare il membro dati dell' EncryptDocumentServiceWse oggetto Credentials con un System.Net.NetworkCredential valore che specifica il nome utente e il valore della password del modulo AEM.

  4. Creare un Microsoft.Web.Services2.Dime.DimeAttachment oggetto utilizzando il relativo costruttore e passando i seguenti valori:

    • Un valore di stringa che specifica un valore GUID. È possibile ottenere un valore GUID richiamando il System.Guid.NewGuid.ToString metodo.
    • Una stringa che specifica il tipo di contenuto. Poiché questo processo richiede un documento PDF, specificare application/pdf.
    • Un valore TypeFormat di enumerazione. Specifica TypeFormat.MediaType.
    • Una stringa che specifica la posizione del documento PDF da passare al processo AEM Forms .
  5. Creare un BLOB oggetto utilizzando il relativo costruttore.

  6. Aggiungere l'allegato DIME all' BLOB oggetto assegnando il valore del membro Microsoft.Web.Services2.Dime.DimeAttachment dati dell' Id oggetto al membro BLOB dati dell' attachmentID oggetto.

  7. Richiamare il EncryptDocumentServiceWse.RequestSoapContext.Attachments.Add metodo e passare l' Microsoft.Web.Services2.Dime.DimeAttachment oggetto.

  8. Richiamare il MyApplication/EncryptDocument processo richiamando il EncryptDocumentServiceWse metodo dell' invoke oggetto e passando l' BLOB oggetto che contiene l'allegato DIME. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

  9. Ottenere il valore dell'identificatore allegato ottenendo il valore del membro dati BLOB dell' attachmentID oggetto restituito.

  10. Per ottenere il documento PDF crittografato, è possibile utilizzare l'identificatore allegato EncryptDocumentServiceWse.ResponseSoapContext.Attachments e spostarsi tra gli allegati presenti nel documento.

  11. Ottenere un System.IO.Stream oggetto ottenendo il valore del membro di dati dell' Attachment oggetto Stream .

  12. Creare un array di byte e passare tale array di byte al metodo dell' System.IO.Stream oggetto Read . Questo metodo popola l'array di byte con un flusso di dati che rappresenta il documento PDF crittografato.

  13. Creare un System.IO.FileStream oggetto richiamando il relativo costruttore e passando un valore di stringa che rappresenta una posizione di file PDF. Questo oggetto rappresenta il documento PDF crittografato.

  14. Creare un System.IO.BinaryWriter oggetto richiamando il relativo costruttore e passando l' System.IO.FileStream oggetto.

  15. Scrivere il contenuto dell'array di byte nel file PDF richiamando il metodo dell' System.IO.BinaryWriter oggetto Write e passando l'array di byte.

Creazione di classi proxy Java Apache Axis che utilizzano DIME

È possibile utilizzare lo strumento Apache Axis WSDL2Java per convertire un servizio WSDL in classi proxy Java in modo da poter richiamare le operazioni del servizio. Apache Ant consente di generare file libreria Axis da un WSDL servizio AEM Forms che consente di richiamare il servizio. Consultate Creazione di classi proxy Java tramite Apache Axis.

Lo strumento Apache Axis WSDL2Java genera file JAVA contenenti metodi utilizzati per inviare richieste SOAP a un servizio. Le richieste SOAP ricevute da un servizio vengono decodificate dalle librerie generate da Axis e tornate ai metodi e agli argomenti.

Per richiamare il MyApplication/EncryptDocument servizio (incorporato in Workbench) utilizzando i file libreria generati da Axis e DIME, effettuare le seguenti operazioni:

  1. Create classi proxy Java che utilizzano il WSDL del MyApplication/EncryptDocument servizio utilizzando Apache Axis. Consultate Creazione di classi proxy Java tramite Apache Axis.

  2. Includete le classi proxy Java nel percorso della classe.

  3. Creare un MyApplicationEncryptDocumentServiceLocator oggetto utilizzando il relativo costruttore.

  4. Creare un URL oggetto utilizzando il relativo costruttore e passando un valore di stringa che specifica la definizione WSDL del servizio AEM Forms . Assicurarsi di specificare ?blob=dime alla fine dell'URL dell'endpoint SOAP. Ad esempio, utilizzate

     https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=dime.
    
  5. Creare un EncryptDocumentSoapBindingStub oggetto richiamando il relativo costruttore e passando l' MyApplicationEncryptDocumentServiceLocatoroggetto e l' URL oggetto.

  6. Impostare il nome utente e il valore della password dei moduli AEM richiamando i EncryptDocumentSoapBindingStub metodi setUsername e setPassword dell'oggetto.

     encryptionClientStub.setUsername("administrator");
     encryptionClientStub.setPassword("password");
    
  7. Recuperare il documento PDF da inviare al MyApplication/EncryptDocument servizio creando un java.io.File oggetto. Passa un valore di stringa che specifica la posizione del documento PDF.

  8. Creare un javax.activation.DataHandler oggetto utilizzando il relativo costruttore e passando un javax.activation.FileDataSource oggetto. È possibile creare l' javax.activation.FileDataSource oggetto utilizzando il relativo costruttore e passando l' java.io.File oggetto che rappresenta il documento PDF.

  9. Creare un org.apache.axis.attachments.AttachmentPart oggetto utilizzando il relativo costruttore e passando l' javax.activation.DataHandler oggetto.

  10. Associare l'allegato richiamando il metodo dell' EncryptDocumentSoapBindingStub oggetto addAttachment e passando l' org.apache.axis.attachments.AttachmentPart oggetto.

  11. Creare un BLOB oggetto utilizzando il relativo costruttore. Compilare l' BLOB oggetto con il valore dell'identificatore allegato richiamando il BLOB metodo dell' setAttachmentID oggetto e passando il valore dell'identificatore allegato. Questo valore può essere ottenuto richiamando il metodo dell' org.apache.axis.attachments.AttachmentPart oggetto getContentId .

  12. Richiamare il MyApplication/EncryptDocument processo richiamando il EncryptDocumentSoapBindingStub metodo dell' invoke oggetto. Passare l' BLOB oggetto che contiene l'allegato DIME. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

  13. Ottenere il valore dell'identificatore allegato richiamando il metodo dell' BLOB oggetto restituito getAttachmentID . Questo metodo restituisce un valore di stringa che rappresenta il valore identificatore dell'allegato restituito.

  14. Recuperare gli allegati richiamando il EncryptDocumentSoapBindingStub metodo dell' getAttachments oggetto. Questo metodo restituisce un array di allegati Objects che li rappresentano.

  15. Per ottenere il documento PDF cifrato, è necessario utilizzare l' Object array di allegati e il valore dell'identificatore allegato. Ciascun elemento è un org.apache.axis.attachments.AttachmentPart oggetto.

  16. Ottenere l' javax.activation.DataHandler oggetto associato all'allegato richiamando il metodo dell' org.apache.axis.attachments.AttachmentPart oggetto getDataHandler .

  17. Ottenere un java.io.FileStream oggetto richiamando il javax.activation.DataHandler metodo dell' getInputStream .

  18. Creare un array di byte e passare tale array di byte al metodo dell' java.io.FileStream oggetto read . Questo metodo popola l'array di byte con un flusso di dati che rappresenta il documento PDF crittografato.

  19. Creare un java.io.File oggetto utilizzando il relativo costruttore. Questo oggetto rappresenta il documento PDF crittografato.

  20. Creare un java.io.FileOutputStream oggetto utilizzando il relativo costruttore e passando l' java.io.File oggetto.

  21. Richiamare il metodo dell' java.io.FileOutputStream oggetto write e passare l'array di byte contenente il flusso di dati che rappresenta il documento PDF crittografato.

Consulta anche

Avvio rapido: Chiamata di un servizio tramite DIME in un progetto Java

Utilizzo dell'autenticazione basata su SAML

AEM Forms supporta diverse modalità di autenticazione del servizio Web quando si richiamano i servizi. Una modalità di autenticazione consiste nel specificare sia il nome utente che il valore della password utilizzando un'intestazione di autorizzazione di base nella chiamata al servizio Web. AEM Forms supporta anche l'autenticazione basata sull'asserzione SAML. Quando un'applicazione client richiama un servizio AEM Forms utilizzando un servizio Web, l'applicazione client può fornire informazioni di autenticazione in uno dei modi seguenti:

  • Invio delle credenziali nell'ambito dell'autorizzazione di base
  • Passaggio del token nome utente come parte dell'intestazione WS-Security
  • Passaggio di un'asserzione SAML come parte dell'intestazione WS-Security
  • Passaggio del token Kerberos come parte dell'intestazione WS-Security

AEM Forms non supporta l'autenticazione standard basata sui certificati, ma supporta l'autenticazione basata sui certificati in un modulo diverso.

Nota

Il servizio Web avvia rapidamente la programmazione con AEM Forms specifica i valori di nome utente e password per eseguire l'autorizzazione.

L'identità degli utenti AEM moduli può essere rappresentata tramite un'asserzione SAML firmata utilizzando una chiave segreta. Nel seguente codice XML è riportato un esempio di asserzione SAML.

 <Assertion xmlns="urn:oasis:names:tc:SAML:1.0:assertion"
     xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion"
     xmlns:samlp="urn:oasis:names:tc:SAML:1.0:protocol"
     AssertionID="fd4bd0c87302780e0d9bbfa8726d5bc0" IssueInstant="2008-04-17T13:47:00.720Z" Issuer="LiveCycle"
     MajorVersion="1" MinorVersion="1">
     <Conditions NotBefore="2008-04-17T13:47:00.720Z" NotOnOrAfter="2008-04-17T15:47:00.720Z">
     </Conditions>
     <AuthenticationStatement
         AuthenticationInstant="2008-04-17T13:47:00.720Z"
         AuthenticationMethod="urn:oasis:names:tc:SAML:1.0:am:unspecified">
         <Subject>
             <NameIdentifier NameQualifier="DefaultDom">administrator</NameIdentifier>
             <SubjectConfirmation>
                 <ConfirmationMethod>urn:oasis:names:tc:SAML:1.0:cm:sender-vouches</ConfirmationMethod>
             </SubjectConfirmation>
         </Subject>
     </AuthenticationStatement>
     <ds:Signature >
         <ds:SignedInfo>
             <ds:CanonicalizationMethod Algorithm="https://www.w3.org/2001/10/xml-exc-c14n#"></ds:CanonicalizationMethod>
             <ds:SignatureMethod    Algorithm="https://www.w3.org/2000/09/xmldsig#hmac-sha1"></ds:SignatureMethod>
             <ds:Reference URI="#fd4bd0c87302780e0d9bbfa8726d5bc0">
                 <ds:Transforms>
                     <ds:Transform Algorithm="https://www.w3.org/2000/09/xmldsig#enveloped-signature"></ds:Transform>
                     <ds:Transform Algorithm="https://www.w3.org/2001/10/xml-exc-c14n#">
                         <ec:InclusiveNamespaces
                             PrefixList="code ds kind rw saml samlp typens #default">
                         </ec:InclusiveNamespaces>
                     </ds:Transform>
                 </ds:Transforms>
                 <ds:DigestMethod Algorithm="https://www.w3.org/2000/09/xmldsig#sha1"></ds:DigestMethod>
                 <ds:DigestValue>hVrtqjWr+VzaVUIpQx0YI9lIjaY=</ds:DigestValue>
             </ds:Reference>
         </ds:SignedInfo>
         <ds:SignatureValue>UMbBb+cUcPtcWDCIhXes4n4FxfU=</ds:SignatureValue>
     </ds:Signature>
 </Assertion>

Questa affermazione di esempio viene rilasciata per un utente amministratore. Questa asserzione contiene i seguenti elementi visibili:

  • È valido per una certa durata.
  • Viene emesso per un utente specifico.
  • È firmato digitalmente. Qualsiasi modifica apportata alla firma potrebbe quindi interrompere la firma.
  • Può essere presentato a AEM Forms come un token dell'identità dell'utente simile al nome utente e alla password.

Un'applicazione client può recuperare l'asserzione da qualsiasi API AEM Forms AuthenticationManager che restituisce un AuthResult oggetto. Per ottenere un’ AuthResult istanza, effettuate una delle due seguenti operazioni:

  • Autenticazione dell'utente tramite uno dei metodi di autenticazione esposti dall'API AuthenticationManager. In genere, è possibile utilizzare il nome utente e la password; tuttavia, potete anche utilizzare l'autenticazione basata sui certificati.
  • Utilizzo del AuthenticationManager.getAuthResultOnBehalfOfUser metodo. Questo metodo consente a un'applicazione client di ottenere un AuthResult oggetto per qualsiasi utente AEM moduli.

un utente AEM modulo può essere autenticato utilizzando un token SAML ottenuto. Questa asserzione SAML (frammento xml) può essere inviata come parte dell'intestazione WS-Security con la chiamata del servizio Web per l'autenticazione dell'utente. In genere, un'applicazione client ha autenticato un utente ma non ha memorizzato le credenziali utente. Oppure l’utente ha eseguito l’accesso a tale client tramite un meccanismo diverso dall’uso di un nome utente e una password. In questa situazione, l'applicazione client deve richiamare AEM Forms e rappresentare un utente specifico che può richiamare AEM Forms.

Per rappresentare un utente specifico, invocate il AuthenticationManager.getAuthResultOnBehalfOfUser metodo utilizzando un servizio Web. Questo metodo restituisce un' AuthResult istanza che contiene l'asserzione SAML per l'utente specificato.

Quindi, utilizzate l'asserzione SAML per richiamare qualsiasi servizio che richiede l'autenticazione. Questa azione prevede l'invio dell'asserzione come parte dell'intestazione SOAP. Quando viene effettuata una chiamata a un servizio Web con questa asserzione, AEM Forms identifica l'utente come rappresentato da tale asserzione. In altre parole, l'utente specificato nell'asserzione è l'utente che sta richiamando il servizio.

Uso delle classi Apache Axis e autenticazione basata su SAML

È possibile richiamare un servizio AEM Forms dalle classi proxy Java create utilizzando la libreria Asse. Consultate Creazione di classi proxy Java tramite Apache Axis.

Quando si utilizza AXIS che utilizza l'autenticazione basata su SAML, registrare il gestore di richieste e risposte con Axis. Apache Axis richiama il gestore prima di inviare una richiesta di chiamata a AEM Forms. Per registrare un gestore, creare una classe Java che si estenda org.apache.axis.handlers.BasicHandler.

Creare un gestore di attività con Axis

La seguente classe Java, denominata AssertionHandler.java, mostra un esempio di classe Java che si estende org.apache.axis.handlers.BasicHandler.

 public class AssertionHandler extends BasicHandler {
        public void invoke(MessageContext ctx) throws AxisFault {
            String assertion = (String) ctx.getProperty(LC_ASSERTION);
 
            //no assertion hence nothing to insert
            if(assertion == null) return;
 
            try {
                MessageElement samlElement = new MessageElement(convertToXML(assertion));
                SOAPHeader header = (SOAPHeader) ctx.getRequestMessage().getSOAPHeader();
                //Create the wsse:Security element which would contain the SAML element
                SOAPElement wsseHeader = header.addChildElement("Security", "wsse", WSSE_NS);
                wsseHeader.appendChild(samlElement);
                //remove the actor attribute as in LC we do not specify any actor. This would not remove the actor attribute though
                //it would only remove it from the soapenv namespace
                wsseHeader.getAttributes().removeNamedItem("actor");
            } catch (SOAPException e) {
                throw new AxisFault("Error occured while adding the assertion to the SOAP Header",e);
            }
        }
 }

Registra il gestore

Per registrare un gestore con Axis, create un file client-config.wsdd. Per impostazione predefinita, Axis cerca un file con questo nome. Il seguente codice XML è un esempio di file client-config.wsdd. Per ulteriori informazioni, consulta la documentazione sull’asse.

 <deployment xmlns="https://xml.apache.org/axis/wsdd/" xmlns:java="https://xml.apache.org/axis/wsdd/providers/java">
     <transport name="http" pivot="java:org.apache.axis.transport.http.HTTPSender"/>
      <globalConfiguration >
       <requestFlow >
        <handler type="java:com.adobe.idp.um.example.AssertionHandler" />
       </requestFlow >
      </globalConfiguration >
 </deployment>
 

Richiamo di un servizio AEM Forms

L'esempio di codice seguente richiama un servizio AEM Forms utilizzando l'autenticazione basata su SAML.

 public class ImpersonationExample {
        . . .
        public void  authenticateOnBehalf(String superUsername,String password,
                String canonicalName,String domainName) throws UMException, RemoteException{
            ((org.apache.axis.client.Stub) authenticationManager).setUsername(superUsername);
            ((org.apache.axis.client.Stub) authenticationManager).setPassword(password);
 
            //Step 1 - Invoke the Auth manager api to get an assertion for the user to be impersonated
            AuthResult ar = authenticationManager.getAuthResultOnBehalfOfUser(canonicalName, domainName, null);
            String assertion = ar.getAssertion();
            //Step 2 - Setting the assertion here to be picked later by the AssertionHandler. Note that stubs are not threadSafe
            //hence should not be reused. For this simple example we have made them instance variable but care should be taken
            //regarding the thread safety
            ((javax.xml.rpc.Stub) authorizationManager)._setProperty(AssertionHandler.LC_ASSERTION, assertion);
        }
 
        public Role findRole(String roleId) throws UMException, RemoteException{
            //This api would be invoked under bob's user rights
            return authorizationManager.findRole(roleId);
        }
 
        public static void main(String[] args) throws Exception {
            ImpersonationExample ie = new ImpersonationExample("http://localhost:5555");
            //Get the SAML assertion for the user to impersonate and store it in stub
            ie.authenticateOnBehalf(
                    "administrator", //The Super user which has the required impersonation permission
                    "password", // Password of the super user as referred above
                    "bob", //Cannonical name of the user to impersonate
                    "testdomain" //Domain of the user to impersonate
                    );
 
            Role r = ie.findRole("BASIC_ROLE_ADMINISTRATOR");
            System.out.println("Role "+r.getName());
        }
 }

Utilizzo di un assembly client .NET e autenticazione basata su SAML

È possibile richiamare un servizio Forms utilizzando un assembly client .NET e l'autenticazione basata su SAML. A tal fine, è necessario utilizzare il Web Service Enhancements 3.0 (WSE). Per informazioni sulla creazione di un assembly client .NET che utilizza WSE, vedere Creazione di un progetto .NET che utilizza DIME.

Nota

La sezione DIME utilizza WSE 2.0. Per utilizzare l'autenticazione basata su SAML, seguire le stesse istruzioni specificate nell'argomento DIME. Tuttavia, sostituite WSE 2.0 con WSE 3.0. Installazione di Web Services Enhancements 3.0 nel computer di sviluppo e integrazione con Microsoft Visual Studio .NET. È possibile scaricare Web Services Enhancements 3.0 dal Centro di download diMicrosoft.

L'architettura WSE utilizza i tipi di dati Criteri, Asserzioni e SecurityToken. Brevemente, per una chiamata a un servizio Web, specificate un criterio. Un criterio può contenere più asserzioni. Ogni asserzione può contenere filtri. Un filtro viene invocato in determinate fasi di una chiamata a un servizio Web e, in quel momento, può modificare la richiesta SOAP. Per informazioni dettagliate, consultate la documentazione sui miglioramenti dei servizi Web 3.0.

Creare l'asserzione e il filtro

Nell'esempio di codice C# vengono create classi di filtri e asserzioni. Questo esempio di codice crea un SamlAssertionOutputFilter. Questo filtro viene richiamato dal framework WSE prima che la richiesta SOAP venga inviata a AEM Forms.

 class LCSamlPolicyAssertion : Microsoft.Web.ServicES4.Design.PolicyAssertion
 {
        public override Microsoft.Web.ServicES4.SoapFilter CreateClientOutputFilter(FilterCreationContext context)
        {
           return new SamlAssertionOutputFilter();
        }
        . . .
 }
 
 
 class SamlAssertionOutputFilter : SendSecurityFilter
 {
        public override void SecureMessage(SoapEnvelope envelope, Security security)
        {
           // Get the SamlToken from the SessionState
           SamlToken samlToken = envelope.Context.Credentials.UltimateReceiver.GetClientToken<SamlToken>();
           security.Tokens.Add(samlToken);
        }
 }

Creare il token SAML

Create una classe per rappresentare l'asserzione SAML. L'attività principale eseguita da questa classe è convertire i valori dei dati da stringa a xml e mantenere lo spazio vuoto. Questo xml di asserzione viene importato in seguito nella richiesta SOAP.

 class SamlToken : SecurityToken
 {
        public const string SAMLAssertion = "https://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1";
        private XmlElement _assertionElement;
 
        public SamlToken(string assertion)
             : base(SAMLAssertion)
        {
           XmlDocument xmlDoc = new XmlDocument();
           //The white space has to be preserved else the digital signature would get broken
           xmlDoc.PreserveWhitespace = true;
           xmlDoc.LoadXml(assertion);
           _assertionElement = xmlDoc.DocumentElement;
         }
 
         public override XmlElement GetXml(XmlDocument document)
         {
            return (XmlElement)document.ImportNode(_assertionElement, true);
         }
        . . .
 }

Richiamo di un servizio AEM Forms

Nell'esempio di codice C# riportato di seguito viene richiamato un servizio Forms utilizzando l'autenticazione basata su SAML.

 public class ImpersonationExample
 {
        . . .
        public void AuthenticateOnBehalf(string superUsername, string password, string canonicalName, string domainName)
        {
            //Create a policy for UsernamePassword Token
            Policy usernamePasswordPolicy = new Policy();
            usernamePasswordPolicy.Assertions.Add(new UsernameOverTransportAssertion());
 
            UsernameToken token = new UsernameToken(superUsername, password, PasswordOption.SendPlainText);
            authenticationManager.SetClientCredential(token);
            authenticationManager.SetPolicy(usernamePasswordPolicy);
 
            //Get the SAML assertion for impersonated user
            AuthClient.AuthenticationManagerService.AuthResult ar
                = authenticationManager.getAuthResultOnBehalfOfUser(canonicalName, domainName, null);
            System.Console.WriteLine("Received assertion " + ar.assertion);
 
            //Create a policy for inserting SAML assertion
            Policy samlPolicy = new Policy();
            samlPolicy.Assertions.Add(new LCSamlPolicyAssertion());
            authorizationManager.SetPolicy(samlPolicy);
            //Set the SAML assertion obtained previously as the token
            authorizationManager.SetClientCredential(new SamlToken(ar.assertion));
        }
 
        public Role findRole(string roleId)
        {
            return authorizationManager.findRole(roleId);
        }
 
        static void Main(string[] args)
        {
            ImpersonationExample ie = new ImpersonationExample("http://localhost:5555");
            ie.AuthenticateOnBehalf(
                 "administrator", //The Super user which has the required impersonation permission
                 "password", // Password of the super user as referred above
                 "bob", //Cannonical name of the user to impersonate
                 "testdomain" //Domain of the user to impersonate
                 );
 
         Role r = ie.findRole("BASIC_ROLE_ADMINISTRATOR");
            System.Console.WriteLine("Role "+r.name);
     }
 }

A volte si verificano dei problemi quando si richiamano determinate operazioni servizi AEM Forms utilizzando i servizi Web. L'obiettivo di questa discussione è identificare tali questioni e fornire una soluzione, se disponibile.

Attivazione asincrona delle operazioni del servizio

Se tentate di richiamare in modo asincrono un'operazione del servizio AEM Forms , ad esempio l'operazione Genera PDF, htmlToPDF si SoapFaultException verifica un errore. Per risolvere il problema, creare un file XML di binding personalizzato che associ l' ExportPDF_Result elemento e gli altri elementi in classi diverse. Il seguente codice XML rappresenta un file di binding personalizzato.

 <bindings
        xmlns:xsd="https://www.w3.org/2001/XMLSchema"
        xmlns:jxb="https://java.sun.com/xml/ns/jaxb" jxb:version="1.0"
        xmlns:wsdl="https://schemas.xmlsoap.org/wsdl/"
      wsdlLocation="http://localhost:8080/soap/services/GeneratePDFService?wsdl&async=true&lc_version=9.0.0"
        xmlns="https://java.sun.com/xml/ns/jaxws">
        <enableAsyncMapping>false</enableAsyncMapping>
        <package name="external_customize.client"/>
        <enableWrapperStyle>true</enableWrapperStyle>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='ExportPDF_Result']">
            <jxb:class name="ExportPDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='CreatePDF_Result']">
            <jxb:class name="CreatePDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='HtmlToPDF_Result']">
            <jxb:class name="HtmlToPDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='OptimizePDF_Result']">
            <jxb:class name="OptimizePDFAsyncResult">
            </jxb:class>
        </bindings>
        <!--bindings node="//wsdl:portType[@name='GeneratePDFService']/wsdl:operation[@name='HtmlToPDF_Result']">
            <jxb:class name="HtmlToPDFAsyncResult"/>
        </bindings-->
 </bindings>

Utilizzare questo file XML per creare file proxy Java utilizzando JAX-WS. (vedere Creazione di classi proxy Java tramite JAX-WS).

Fare riferimento a questo file XML durante l'esecuzione dello strumento JAX-WS (wsimport.exe) utilizzando l'opzione della riga di comando - b . Aggiornare l' wsdlLocation elemento nel file XML di binding per specificare l'URL di AEM Forms.

Per garantire il funzionamento della chiamata asincrona, modificate il valore dell’URL del punto finale e specificate async=true. Ad esempio, per i file proxy Java creati con JAX-WS, specificate quanto segue per il BindingProvider.ENDPOINT_ADDRESS_PROPERTY.

https://server:port/soap/services/ServiceName?wsdl&async=true&lc_version=9.0.0

L'elenco seguente specifica altri servizi che richiedono un file di binding personalizzato quando viene richiamato in modo asincrono:

  • PDFG3D
  • Task Manager
  • Application Manager
  • Gestione directory
  • Distiller
  • Rights Management
  • Gestione documenti

Differenze nei server applicazioni J2EE

A volte una libreria proxy creata utilizzando uno specifico server applicazione J2EE non richiama correttamente AEM Forms ospitato su un server applicazione J2EE diverso. Considerare una libreria proxy generata utilizzando AEM Forms distribuita su WebSphere. Questa libreria proxy non è in grado di richiamare servizi AEM Forms distribuiti sul server applicazioni JBoss.

Alcuni tipi di dati complessi di AEM Forms, come PrincipalReference, vengono definiti in modo diverso quando AEM Forms viene distribuito su WebSphere rispetto al server applicazioni JBoss. Le differenze nei JDK utilizzati dai diversi servizi applicativi J2EE sono il motivo per cui esistono differenze nelle definizioni WSDL. Di conseguenza, utilizzate le librerie proxy generate dallo stesso server applicazione J2EE.

Accesso a più servizi tramite i servizi Web

A causa di conflitti di spazio nomi, gli oggetti dati non possono essere condivisi tra più WSDL di servizi. Diversi servizi possono condividere tipi di dati e, di conseguenza, i servizi condividono la definizione di questi tipi nei WSDL. Ad esempio, non è possibile aggiungere allo stesso progetto client .NET due assembly client .NET che contengono un tipo di BLOB dati. Se tentate di farlo, si verifica un errore di compilazione.

L'elenco seguente specifica i tipi di dati che non possono essere condivisi tra più WSDL di servizi:

  • User
  • Principals
  • PrincipalReference
  • Groups
  • Roles
  • BLOB

Per evitare questo problema, è consigliabile qualificare completamente i tipi di dati. Si consideri ad esempio un'applicazione .NET che fa riferimento sia al servizio Forms che al servizio Signature utilizzando un riferimento al servizio. Entrambi i riferimenti di servizio conterranno una BLOB classe. Per utilizzare un' BLOB istanza, qualificare completamente l' BLOB oggetto quando viene dichiarato. Questo approccio è illustrato nel seguente esempio di codice. Per informazioni su questo esempio di codice, vedere Firma digitale di Formsinterattivo.

Nell'esempio di codice C# riportato di seguito viene firmato un modulo interattivo di cui il servizio Forms esegue il rendering. L'applicazione client ha due riferimenti di servizio. L' BLOB istanza associata al servizio Forms appartiene allo SignInteractiveForm.ServiceReference2 spazio dei nomi. Analogamente, l' BLOB istanza associata al servizio Signature appartiene allo SignInteractiveForm.ServiceReference1 spazio dei nomi. Il modulo interattivo firmato viene salvato come file PDF denominato LoanXFASigned.pdf.

 ???/**
     * Ensure that you create a .NET project that uses
     * MS Visual Studio 2008 and version 3.5 of the .NET
     * framework. This is required to invoke a
     * AEM Forms service using MTOM.
     *
     * For information, see "Invoking AEM Forms using MTOM" in Programming with AEM forms
     */
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.ServiceModel;
 using System.IO;
 
 //A reference to the Signature service
 using SignInteractiveForm.ServiceReference1;
 
 //A reference to the Forms service
 using SignInteractiveForm.ServiceReference2;
 
 namespace SignInteractiveForm
 {
        class Program
        {
            static void Main(string[] args)
            {
                try
                {
                    //Because BLOB objects are used in both service references
                    //it is necessary to fully-qualify the BLOB objects
 
                    //Retrieve the form -- invoke the Forms service
                    SignInteractiveForm.ServiceReference2.BLOB formData = GetForm();
 
                    //Create a BLOB object associated with the Signature service
                    SignInteractiveForm.ServiceReference1.BLOB sigData = new SignInteractiveForm.ServiceReference1.BLOB();
 
                    //Transfer the byte stream from one Forms BLOB object to the
                    //Signature BLOB object
                    sigData.MTOM = formData.MTOM;
 
                    //Sign the Form -- invoke the Signature service
                    SignForm(sigData);
                }
                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
            }
 
            //Creates an interactive PDF form based on a XFA form - invoke the Forms service
            private static SignInteractiveForm.ServiceReference2.BLOB GetForm()
            {
 
                try
                {
                    //Create a FormsServiceClient object
                    FormsServiceClient formsClient = new FormsServiceClient();
                    formsClient.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/FormsService?blob=mtom");
 
                    //Enable BASIC HTTP authentication
                    BasicHttpBinding b = (BasicHttpBinding)formsClient.Endpoint.Binding;
                    b.MessageEncoding = WSMessageEncoding.Mtom;
                    formsClient.ClientCredentials.UserName.UserName = "administrator";
                    formsClient.ClientCredentials.UserName.Password = "password";
                    b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                    b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
                    b.MaxReceivedMessageSize = 2000000;
                    b.MaxBufferSize = 2000000;
                    b.ReaderQuotas.MaxArrayLength = 2000000;
 
                    //Create a BLOB to store form data
                    SignInteractiveForm.ServiceReference2.BLOB formData = new SignInteractiveForm.ServiceReference2.BLOB();
                    SignInteractiveForm.ServiceReference2.BLOB pdfForm = new SignInteractiveForm.ServiceReference2.BLOB();
 
                    //Specify a XML form data
                    string path = "C:\\Adobe\Loan.xml";
                    FileStream fs = new FileStream(path, FileMode.Open);
 
                    //Get the length of the file stream
                    int len = (int)fs.Length;
                    byte[] ByteArray = new byte[len];
 
                    fs.Read(ByteArray, 0, len);
                    formData.MTOM = ByteArray;
 
                    //Specify a XML form data
                    string path2 = "C:\\Adobe\LoanSigXFA.pdf";
                    FileStream fs2 = new FileStream(path2, FileMode.Open);
 
                    //Get the length of the file stream
                    int len2 = (int)fs2.Length;
                    byte[] ByteArray2 = new byte[len2];
 
                    fs2.Read(ByteArray2, 0, len2);
                    pdfForm.MTOM = ByteArray2;
 
                    PDFFormRenderSpec renderSpec = new PDFFormRenderSpec();
                    renderSpec.generateServerAppearance = true;
 
                    //Set out parameter values
                    long pageCount = 1;
                    String localValue = "en_US";
                    FormsResult result = new FormsResult();
 
                    //Render an interactive PDF form
                    formsClient.renderPDFForm2(
                        pdfForm,
                        formData,
                        renderSpec,
                        null,
                        null,
                        out pageCount,
                        out localValue,
                        out result);
 
                    //Write the data stream to the BLOB object
                    SignInteractiveForm.ServiceReference2.BLOB outForm = result.outputContent;
                    return outForm;
                }
                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
                return null;
            }
 
            //Sign the form -- invoke the Signature service
            private static void SignForm(SignInteractiveForm.ServiceReference1.BLOB inDoc)
            {
 
                try
                {
                    //Create a SignatureServiceClient object
                    SignatureServiceClient signatureClient = new SignatureServiceClient();
                    signatureClient.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/SignatureService?blob=mtom");
 
                    //Enable BASIC HTTP authentication
                    BasicHttpBinding b = (BasicHttpBinding)signatureClient.Endpoint.Binding;
                    b.MessageEncoding = WSMessageEncoding.Mtom;
                    signatureClient.ClientCredentials.UserName.UserName = "administrator";
                    signatureClient.ClientCredentials.UserName.Password = "password";
                    b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                    b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
                    b.MaxReceivedMessageSize = 2000000;
                    b.MaxBufferSize = 2000000;
                    b.ReaderQuotas.MaxArrayLength = 2000000;
 
                    //Specify the name of the signature field
                    string fieldName = "form1[0].grantApplication[0].page1[0].SignatureField1[0]";
 
                    //Create a Credential object
                    Credential myCred = new Credential();
                    myCred.alias = "secure";
 
                    //Specify the reason to sign the document
                    string reason = "The document was reviewed";
 
                    //Specify the location of the signer
                    string location = "New York HQ";
 
                    //Specify contact information
                    string contactInfo = "Tony Blue";
 
                    //Create a PDFSignatureAppearanceOptions object
                    //and show date information
                    PDFSignatureAppearanceOptionSpec appear = new PDFSignatureAppearanceOptionSpec();
                    appear.showDate = true;
 
                    //Sign the PDF document
                    SignInteractiveForm.ServiceReference1.BLOB signedDoc = signatureClient.sign(
                        inDoc,
                        fieldName,
                        myCred,
                        HashAlgorithm.SHA1,
                        reason,
                        location,
                        contactInfo,
                        appear,
                        true,
                        null,
                        null,
                        null);
 
                    //Populate a byte array with BLOB data that represents the signed form
                    byte[] outByteArray = signedDoc.MTOM;
 
                    //Save the signed PDF document
                    string fileName = "C:\\Adobe\LoanXFASigned.pdf";
                    FileStream fs2 = new FileStream(fileName, FileMode.OpenOrCreate);
 
                    //Create a BinaryWriter object
                    BinaryWriter w = new BinaryWriter(fs2);
                    w.Write(outByteArray);
                    w.Close();
                    fs2.Close();
                }
 
                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
            }
        }
 }
 
 

Servizi che iniziano con la lettera Propongo file proxy non validi

Il nome di alcune classi proxy generate AEM Forms non è corretto quando si utilizzano Microsoft .Net 3.5 e WCF. Questo problema si verifica quando vengono create classi proxy per IBMFilenetContentRepositoryConnector, IDPSchedulerService o qualsiasi altro servizio il cui nome inizia con la lettera I. Ad esempio, il nome del client generato nel caso di IBMFileNetContentRepositoryConnector è BMFileNetContentRepositoryConnectorClient. Lettera I mancante nella classe proxy generata.

In questa pagina