Richiamo di AEM Forms tramite i servizi web

Ultimo aggiornamento: 2023-05-04
  • Creato per:
  • Developer
ATTENZIONE

AEM 6.4 ha raggiunto la fine del supporto esteso e questa documentazione non viene più aggiornata. Per maggiori dettagli, consulta la nostra periodi di assistenza tecnica. Trova le versioni supportate qui.

La maggior parte dei servizi AEM Forms nel contenitore di servizi è configurata per esporre un servizio Web, con il supporto completo per la generazione del linguaggio WSDL (Web Service Definition Language). In altre parole, puoi creare oggetti proxy che utilizzano lo stack SOAP nativo di un servizio AEM Forms. Di conseguenza, i 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.

Utilizzando i servizi web, puoi eseguire le stesse operazioni dei servizi AEM Forms disponibili utilizzando l’API Java. L’utilizzo dei servizi web per richiamare i servizi AEM Forms offre il vantaggio 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 specifici. Ad esempio, è possibile creare un'applicazione client utilizzando Microsoft Visual Studio .NET e C# come linguaggio di programmazione.

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

AEM Forms supporta i seguenti standard di servizio Web:

  • Codifica: Supporta solo la codifica documentale e letterale (che è la codifica preferita in base al profilo WSI Basic). (Vedi Richiamo di AEM Forms con codifica Base64.)
  • MTOM: Rappresenta un modo per codificare gli allegati con le richieste SOAP. (Vedi Richiamo di AEM Forms tramite MTOM.)
  • SwaRef: Rappresenta un altro modo per codificare gli allegati con le richieste SOAP. (Vedi Richiamo di AEM Forms tramite SwaRef.)
  • SOAP con allegati: Supporta sia MIME che DIME (Incapsulamento diretto di messaggi Internet). Questi protocolli sono modi standard per inviare allegati tramite SOAP. Le applicazioni Microsoft Visual Studio .NET utilizzano DIME. (Vedi Richiamo di AEM Forms con codifica Base64.)
  • WS-Security: Supporta un profilo token password del 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.

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

È possibile 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 dell'applicazione J2EE che ospita AEM Forms.
  • your_port rappresenta la porta HTTP utilizzata dal server applicativo J2EE.
  • nome_servizio 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 ( false per impostazione predefinita).
  • lc_version rappresenta la versione di AEM Forms che desideri richiamare.

Nella tabella seguente sono elencate le definizioni WSDL del servizio (partendo dal presupposto 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 ripristino

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

moduli con codice a barre

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

Crittografia

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

Forms

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

Integrazione dei dati 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 del processo AEM Forms

Per accedere a una WSDL appartenente a un processo creato in Workbench, è necessario specificare il nome dell’applicazione e il nome del processo all’interno della definizione WSDL. Supponiamo che il nome dell'applicazione sia MyApplication e il nome del processo è EncryptDocument. In questa situazione, specifica la seguente definizione WSDL:

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

Per informazioni sull'esempio MyApplication/EncryptDocument processo di breve durata, vedi Esempio di processo a breve termine.

NOTA

Un'applicazione può contenere cartelle. In questo caso, specifica 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 alle nuove funzionalità dei servizi AEM Forms tramite i servizi web. Ad esempio, in AEM Forms viene introdotta la possibilità di codificare gli allegati utilizzando MTOM. (Vedi Richiamo di AEM Forms tramite MTOM.)

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

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

Quando si imposta la variabile lc_version assicurati di utilizzare tre cifre. Ad esempio, 9.0.1 è uguale alla versione 9.0.

Tipo di dati BLOB del servizio Web

Le WSDL del servizio AEM Forms definiscono molti tipi di dati. Uno dei tipi di dati più importanti esposti in un servizio Web è un BLOB digitare. Questo tipo di dati è associato al com.adobe.idp.Document Classe quando si lavora con le API Java di AEM Forms. (Vedi Trasmissione di dati ai servizi AEM Forms tramite l’API Java.)

A BLOB l'oggetto invia e recupera dati binari (ad esempio file PDF, dati XML e così via) da e verso AEM Forms Services. La BLOB Il tipo è definito in una WSDL di servizio 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>

La MTOM e swaRef i campi sono supportati solo in AEM Forms. Puoi utilizzare questi nuovi campi solo se specifichi un URL che include lc_version proprietà.

Fornitura di oggetti BLOB nelle richieste di servizi

Se un’operazione del servizio AEM Forms richiede un BLOB digita come valore di input, crea un'istanza del BLOB digita nella logica dell’applicazione. (Molti degli avvii rapidi del servizio Web si trovano in Programmazione con moduli AEM mostra come utilizzare un tipo di dati BLOB.)

Assegna valori ai campi che appartengono al gruppo BLOB come segue:

  • Base64: Per trasmettere i dati come testo codificato in formato Base64, impostare i dati in BLOB.binaryData e imposta il tipo di dati nel formato MIME (ad esempio application/pdf) nel BLOB.contentType campo . (Vedi Richiamo di AEM Forms con codifica Base64.)
  • MTOM: Per trasmettere dati binari in un allegato MTOM, imposta i dati in BLOB.MTOM campo . Questa impostazione allega i dati alla richiesta SOAP utilizzando il framework Java JAX-WS o l’API nativa del framework SOAP. (Vedi Richiamo di AEM Forms tramite MTOM.)
  • SwaRef: Per trasmettere dati binari in un allegato SwaRef WS-I, impostare i dati in BLOB.swaRef campo . Questa impostazione allega i dati alla richiesta SOAP utilizzando il framework Java JAX-WS. (Vedi Richiamo di AEM Forms tramite SwaRef.)
  • Allegato MIME o DIME: Per trasmettere i dati in un allegato MIME o DIME, allega i dati alla richiesta SOAP utilizzando l’API nativa del framework SOAP. Imposta l'identificatore allegato nella BLOB.attachmentID campo . (Vedi Richiamo di AEM Forms con codifica Base64.)
  • URL remoto: Se i dati sono ospitati su un server web e sono accessibili tramite un URL HTTP, imposta l’URL HTTP nella variabile BLOB.remoteURL campo . (Vedi Richiamo di dati AEM Forms tramite BLOB su HTTP.)

Accesso ai dati negli oggetti BLOB restituiti dai servizi

Protocollo di trasmissione per la restituzione BLOB Gli oggetti dipendono 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 nella chiamata SOAP contiene il parametro blob="BLOB_TYPE", quindi BLOB_TYPE determina il protocollo di trasmissione. BLOB_TYPE è un segnaposto per base64, dime, mime, http, mtom o swaref.

  2. 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 parametro dell'endpoint SOAP del servizio Default Protocol for Output Blob Objects è impostato su Smart.

      Per ogni servizio con un endpoint SOAP, la console di amministrazione consente di specificare il protocollo di trasmissione per eventuali BLOB restituiti. (Vedi aiuto amministrativo.)

    • Il 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 corrispondente BLOB campo . Ad esempio, se l’endpoint SOAP è impostato su DIME, il BLOB restituito si trova in blob.attachmentID indipendentemente dal protocollo di trasmissione di qualsiasi documento di input.

  4. Diversamente. Se un servizio non accetta il tipo di documento come input, i documenti di output vengono restituiti nella BLOB.remoteURL sul protocollo HTTP.

Come descritto nella prima condizione, è possibile 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

Ecco la correlazione tra i tipi di trasmissione e il campo da cui si ottengono i dati:

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

Si consiglia di non superare i 30 MB durante la compilazione di un BLOB richiamandone l'oggetto setBinaryData metodo . In caso contrario, esiste la possibilità che un OutOfMemory* si verifica un'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, utilizza il protocollo di trasmissione SwaRef invece di quello MTOM. In caso contrario, esiste la possibilità di OutOfMemory* eccezione.*

Trasmissione MTOM di array di byte codificati base64

Oltre al BLOB il protocollo MTOM supporta qualsiasi parametro della matrice di byte o campo della matrice di byte di un tipo complesso. Ciò significa che i framework SOAP client che supportano MTOM possono inviare qualsiasi xsd:base64Binary come allegato MTOM (anziché come testo codificato base64). Gli endpoint SOAP di AEM Forms possono leggere questo tipo di codifica byte-array. Tuttavia, il servizio AEM Forms restituisce sempre un tipo di matrice byte come testo codificato base64. I parametri della matrice dei byte di output non supportano MTOM.

I servizi AEM Forms che restituiscono una grande quantità di dati binari utilizzano il tipo Document/BLOB anziché il tipo di matrice dei 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

La DATE tipo, definito in una 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 del servizio AEM Forms richiede un java.util.Date come input, l’applicazione client SOAP deve passare la data nel DATE.date campo . Impostazione della DATE.calendar in questo caso causa un'eccezione di runtime. Se il servizio restituisce un java.util.Date, la data viene restituita nella DATE.date campo .

java.util.Calendar

La DATE tipo, definito in una 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 del servizio AEM Forms richiede un java.util.Calendar come input, l’applicazione client SOAP deve passare la data nel DATE.caledendar campo . Impostazione della DATE.date in questo caso causa un'eccezione di esecuzione. Se il servizio restituisce un java.util.Calendar, quindi 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

La apachesoap:Map, definito in una WSDL di servizio 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"/>

<element name="value" nillable="true" type="xsd:anyType"/>

</sequence>

</complexType>

<complexType name="Map">

<sequence>

<element maxOccurs="unbounded" minOccurs="0" name="item" type="apachesoap:mapItem"/>

</sequence>

</complexType>

</schema>

La mappa è rappresentata come una sequenza di coppie chiave/valore.

java.lang.Object

$1

java.lang.Short

xsd:short

java.lang.String

xsd:string

org.w3c.dom.Document

Il tipo XML, definito in una WSDL di servizio 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 accetta un org.w3c.dom.Document passa i dati XML nel XML.document campo .

Impostazione della XML.element causa un'eccezione di runtime. Se il servizio restituisce un valore org.w3c.dom.Document, quindi i dati XML vengono restituiti nella variabile XML.document campo .

org.w3c.dom.Element

Il tipo XML, definito in una WSDL di servizio 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 org.w3c.dom.Element come input, passa i dati XML nel XML.element campo .

Impostazione della XML.document causa un'eccezione di runtime. Se il servizio restituisce un valore org.w3c.dom.Element, quindi i dati XML vengono restituiti nella XML.element campo .

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 utilizzando JAX-WS

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

  1. Installa Apache Ant sul computer client. (Vedi https://ant.apache.org/bindownload.cgi.)

    • Aggiungi la directory bin al percorso della classe.
    • Imposta la ANT_HOME variabile di ambiente nella directory in cui è stata installata Ant.
  2. Installa JDK 1.6 o versione successiva.

    • Aggiungi la directory JDK bin al percorso della classe.
    • Aggiungi la directory bin JRE al percorso della classe. Questo cestino si trova nel [JDK_INSTALL_LOCATION] directory /jre.
    • Imposta la JAVA_HOME variabile di ambiente nella directory in cui è stato 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. (Vedi API Java per servizi Web XML.)

  4. Utilizza JAX-WS e Apache Ant per generare classi proxy Java. Crea uno script di creazione formica per eseguire questa operazione. Lo script seguente è uno script di esempio per la generazione di formiche 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>
    

    All'interno di questo script di creazione Ant, notare che url è impostata per fare riferimento al servizio di crittografia WSDL in esecuzione su localhost. La username e password le proprietà devono essere impostate su un nome utente e una password validi per i moduli AEM. Tieni presente che l’URL contiene lc_version attributo. Senza specificare la lc_version non è possibile richiamare nuove operazioni del servizio AEM Forms.

    NOTA

    Sostituisci EncryptionService* con il nome del servizio AEM Forms che desideri richiamare utilizzando le classi proxy Java. Ad esempio, per creare classi proxy Java per il servizio di Rights Management, specifica:*

     http://localhost:8080/soap/services/RightsManagementService?WSDL&lc_version=9.0.1
    
  5. Crea un file BAT per eseguire lo script di creazione Ant. Il seguente comando può essere posizionato all’interno di un file BAT responsabile dell’esecuzione dello script di creazione Ant:

     ant -buildfile "build.xml" wsdl
    

    Posiziona lo script della build ANT nella cartella C:\Program Files\Java\jaxws-ri\bin directory. Lo script scrive i file JAVA in ./classes. Lo script genera file JAVA che possono richiamare il servizio.

  6. Crea un pacchetto con i file JAVA in un file JAR. Se lavori su Eclipse, segui questi passaggi:

    • Crea un nuovo progetto Java che viene utilizzato per creare un pacchetto dei file proxy JAVA in un file JAR.
    • Crea una cartella sorgente nel progetto.
    • Crea un com.adobe.idp.services nella cartella Sorgente.
    • Seleziona la com.adobe.idp.services quindi importa i file JAVA dalla cartella adobe/idp/services nel pacchetto.
    • Se necessario, crea un org/apache/xml/xmlsoap nella cartella Sorgente.
    • Seleziona la cartella di origine e quindi importa i file JAVA dalla cartella org/apache/xml/xmlsoap.
    • Impostare il livello di conformità del compilatore Java su 5.0 o superiore.
    • Crea il progetto.
    • Esporta il progetto come file JAR.
    • Importa questo file JAR nel percorso di classe di un progetto client. Inoltre, importa tutti i file JAR che si trovano in <install directory="">\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty.
    NOTA

    Tutti gli avvii rapidi del servizio Web Java (ad eccezione del servizio Forms) che si trovano in Programmazione con moduli AEM creare file proxy Java utilizzando JAX-WS. Inoltre, tutti gli avvii rapidi del servizio Web Java, utilizza SwaRef. (Vedi Richiamo di AEM Forms tramite SwaRef.)

Consulta anche

Creazione di classi proxy Java utilizzando Apache Axis

Richiamo di AEM Forms con codifica Base64

Richiamo di dati AEM Forms tramite BLOB su HTTP

Richiamo di AEM Forms tramite SwaRef

Creazione di classi proxy Java utilizzando 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, puoi generare file di libreria Axis da una WSDL di servizio. Puoi scaricare Apache Axis all'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 anche di Base64 come tipo di codifica. (Vedi Avvio rapido API di Forms Service.)

Puoi generare file libreria Java Axis eseguendo le seguenti operazioni:

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

    • Aggiungi la directory bin al percorso della classe.
    • Imposta la ANT_HOME variabile di ambiente nella directory in cui è stata installata Ant.
  2. Installare Apache Axis 1.4 sul computer client. È disponibile all'indirizzo https://ws.apache.org/axis/.

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

  4. Utilizza lo strumento Apache WSDL2Java in Axis per generare classi proxy Java. Crea uno script di creazione formica per eseguire questa operazione. Lo script seguente è uno script di esempio per la generazione di formiche 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>
    

    All'interno di questo script di creazione Ant, notare che url è impostata per fare riferimento al servizio di crittografia WSDL in esecuzione su localhost. La username e password le proprietà devono essere impostate su un nome utente e una password validi per i moduli AEM.

  5. Crea un file BAT per eseguire lo script di creazione Ant. Il seguente comando può essere posizionato all’interno di un file BAT responsabile dell’esecuzione dello script di creazione Ant:

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

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

    Per impostazione predefinita, questi file appartengono a un pacchetto Java denominato com.adobe.idp.services. Si consiglia di inserire questi file JAVA in un file JAR. Quindi, importa il file JAR nel percorso della classe dell’applicazione client.

    NOTA

    Ci sono diversi modi per mettere i file .JAVA in un JAR. Un modo è usare un IDE Java come Eclipse. Creare un progetto Java e creare un com.adobe.idp.services* pacchetto (tutti i file .JAVA appartengono a questo pacchetto). Quindi, importa tutti i file .JAVA nel pacchetto. Infine, esporta il progetto come file JAR.*

  6. Modifica l’URL nel EncryptionServiceLocator per specificare il tipo di codifica. Ad esempio, per utilizzare base64, specifica ?blob=base64 assicurare che BLOB restituisce dati binari. Cioè, nella EncryptionServiceLocator , individua la seguente riga di codice:

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

    e cambiarlo in:

     http://localhost:8080/soap/services/EncryptionService?blob=base64;
    
  7. Aggiungi i seguenti file JAR Axis 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 [directory di installazione]/Adobe/Adobe Experience Manager Forms/sdk/lib/thirdparty directory .

Consulta anche

Creazione di classi proxy Java utilizzando JAX-WS

Richiamo di AEM Forms con codifica Base64

Richiamo di dati AEM Forms tramite BLOB su HTTP

Richiamo di 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 del servizio Web. Cioè, BLOB i dati sono codificati in Base64 e non nell’intero messaggio SOAP.

"Richiamo di AEM Forms utilizzando la codifica Base64" illustra come richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument utilizzando la codifica Base64.

NOTA

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, crea un processo denominato MyApplication/EncryptDocument utilizzo di Workbench. (Vedi Utilizzo di Workbench.)

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione si basa sul SetValue funzionamento. Il parametro di input per questo processo è un document variabile di processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. 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 .NET di Microsoft Visual Studio. Per creare un assembly client .NET che utilizza la codifica base64, eseguire le operazioni seguenti:

  1. Crea una classe proxy basata su un URL di chiamata di 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 client .NET utilizzando uno strumento che accompagna 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, aprire il prompt dei comandi e passare alla cartella contenente il file wsdl.exe. Per ulteriori informazioni sullo strumento wsdl.exe, vedere Guida a MSDN.

Immettere 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 in base al nome della WSDL. In questa situazione, crea un file CS denominato EncryptDocumentService.cs. Utilizza questo file CS per creare un oggetto proxy che ti consente di richiamare il servizio specificato nell'URL di chiamata.

Modifica l'URL nella classe proxy per includere ?blob=base64 assicurare che BLOB restituisce dati binari. Nella classe proxy, individua 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 Richiamo di AEM Forms tramite codifica Base64 utilizzi della sezione MyApplication/EncryptDocument come esempio. Se si crea un assembly client .NET per un altro servizio Forms, assicurarsi di sostituire MyApplication/EncryptDocument con il nome del servizio.

Sviluppo dell'assembly client .NET

Creare un progetto Libreria classi di Visual Studio che produce un assembly client .NET. Il file CS creato con wsdl.exe può essere importato in questo progetto. Questo progetto produce un file DLL (l'assembly 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 libreria di classi e denominarlo DocumentService.
  3. Importa il file CS creato utilizzando wsdl.exe.
  4. In Progetto menu, seleziona Aggiungi riferimento.
  5. Nella finestra di dialogo Aggiungi riferimento selezionare System.Web.Services.dll.
  6. Fai clic su Seleziona quindi fai clic su OK.
  7. Compila e crea il progetto.
NOTA

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

NOTA

Assicurati 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 dal BLOB oggetto.

Riferimento all'assembly client .NET

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

  1. In Progetto menu, seleziona Aggiungi riferimento.
  2. Fai clic sul pulsante .NET scheda .
  3. Fai clic su Sfoglia individuare il file DocumentService.dll.
  4. Fai clic su Seleziona quindi fai clic su OK.

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

È possibile richiamare MyApplication/EncryptDocument servizio (generato in Workbench) utilizzando un assembly client .NET che utilizza la codifica Base64. Per richiamare MyApplication/EncryptDocument , esegui i seguenti passaggi:

  1. Creare un assembly client Microsoft .NET che utilizzi MyApplication/EncryptDocument servizio WSDL.
  2. Creare un progetto client Microsoft .NET. 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 richiamando il relativo costruttore predefinito.
  4. Imposta la MyApplication_EncryptDocumentService dell’oggetto Credentials proprietà con un System.Net.NetworkCredential oggetto. All'interno di System.Net.NetworkCredential costruttore, specificare un nome utente AEM forms 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. Crea un BLOB utilizzando il relativo costruttore. La BLOB viene utilizzato per memorizzare un documento di PDF passato a MyApplication/EncryptDocument processo.
  6. Crea un System.IO.FileStream richiamando il relativo costruttore. Passa un valore 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 del System.IO.FileStream oggetto. È possibile determinare le dimensioni dell'array di byte ottenendo il System.IO.FileStream dell’oggetto Length proprietà.
  8. Compilare l'array di byte con i dati del flusso richiamando il System.IO.FileStream dell’oggetto Read metodo . Passa la matrice dei byte, la posizione iniziale e la lunghezza del flusso da leggere.
  9. Popolare BLOB oggetto assegnando il relativo binaryData con il contenuto dell'array di byte.
  10. Richiama il MyApplication/EncryptDocument richiamando il MyApplication_EncryptDocumentService dell’oggetto invoke e passare BLOB oggetto contenente il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.
  11. Crea un System.IO.FileStream richiamando il relativo costruttore e passando un valore di stringa che rappresenta il percorso del file del documento crittografato con password.
  12. Creare un array di byte che memorizza il contenuto dei dati del BLOB oggetto restituito da MyApplicationEncryptDocumentService dell’oggetto invoke metodo . Compilare l’array di byte ottenendo il valore del BLOB dell’oggetto binaryData membro dati.
  13. Crea un System.IO.BinaryWriter richiamando il relativo costruttore e passando System.IO.FileStream oggetto.
  14. Scrivi il contenuto dell’array di byte in un file PDF richiamando il System.IO.BinaryWriter dell’oggetto Write e passare l'array di byte.

Richiamo di un servizio utilizzando le classi proxy Java e la codifica Base64

È possibile richiamare un servizio AEM Forms utilizzando le classi proxy Java e Base64. Per richiamare MyApplication/EncryptDocument utilizzando le classi proxy Java, esegui i seguenti passaggi:

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

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

    NOTA

    Sostituisci hiro-xp* con l'indirizzo IP del server applicazioni J2EE che ospita AEM Forms. *

  2. Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.

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

    <install directory="">\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso classe del progetto client Java.

  4. Crea un MyApplicationEncryptDocumentService utilizzando il relativo costruttore.

  5. Crea un MyApplicationEncryptDocument richiamando l'oggetto MyApplicationEncryptDocumentService dell’oggetto getEncryptDocument metodo .

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

    • Assegna l’endpoint WSDL e il tipo di codifica al javax.xml.ws.BindingProvider dell’oggetto ENDPOINT_ADDRESS_PROPERTY campo . Per richiamare MyApplication/EncryptDocument utilizzando la codifica Base64, specifica il seguente valore URL:

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

    • Assegna l’utente dei moduli di AEM al javax.xml.ws.BindingProvider dell’oggetto USERNAME_PROPERTY campo .

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

    L'esempio di codice seguente mostra questa logica di 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. Recupera il documento PDF da inviare al MyApplication/EncryptDocument creazione di un java.io.FileInputStream utilizzando il relativo costruttore. Passa un valore stringa che specifica la posizione del documento PDF.

  8. Creare un array di byte e popolarlo con il contenuto del java.io.FileInputStream oggetto.

  9. Crea un BLOB utilizzando il relativo costruttore.

  10. Popolare BLOB richiamandone l'oggetto setBinaryData e passare l'array di byte. La BLOB dell’oggetto setBinaryData è il metodo da chiamare quando si utilizza la codifica Base64. Consultare Fornitura di oggetti BLOB nelle richieste di servizi.

  11. Richiama il MyApplication/EncryptDocument richiamando il MyApplicationEncryptDocument dell’oggetto invoke metodo . Passa la BLOB oggetto contenente il documento PDF. Il metodo invoke restituisce un BLOB oggetto contenente il documento PDF crittografato.

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

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

Consulta anche

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

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

Richiamo di AEM Forms tramite MTOM

È possibile richiamare i 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 del 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, crea un processo denominato MyApplication/EncryptDocument utilizzo di Workbench. (Vedi Utilizzo di Workbench.)

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione si basa sul SetValue funzionamento. Il parametro di input per questo processo è un document variabile di processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
NOTA

Il supporto per MTOM è stato 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, utilizza il protocollo di trasmissione SwaRef invece di quello MTOM. In caso contrario, esiste la possibilità di OutOfMemory* eccezione.*

La discussione qui riguarda l'utilizzo di MTOM all'interno di un progetto Microsoft .NET per richiamare i servizi AEM Forms. .NET Framework utilizzato è 3.5 e l'ambiente di sviluppo è Visual Studio 2008. Se nel computer di sviluppo è installato WSE (Web Service Enhancements), rimuoverlo. Il framework .NET 3.5 supporta un framework SOAP denominato Windows Communication Foundation (WCF). Quando si richiama 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. Per prima cosa, creare un progetto Microsoft .NET utilizzando Visual Studio 2008. Per richiamare un servizio AEM Forms, crea un riferimento al servizio AEM Forms che desideri richiamare all’interno del progetto. Quando crei un riferimento a un servizio, specifica un URL per il servizio AEM Forms:

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

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

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

La lc_version assicura la disponibilità della funzionalità AEM Forms, ad esempio MTOM. Senza specificare la lc_version 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, eseguire le operazioni seguenti:

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

  2. In Progetto menu, seleziona Aggiungi riferimento al servizio.

  3. In Indirizzo , specifica il WSDL al servizio AEM Forms. Ad esempio:

     http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
    
  4. Fai clic su Vai quindi fai clic su OK.

Richiamo di un servizio utilizzando MTOM in un progetto .NET

Considera la MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare MyApplication/EncryptDocument Il processo (generato in Workbench) utilizzando MTOM, esegue i seguenti passaggi:

  1. Creare un progetto Microsoft .NET.

  2. Crea un MyApplication_EncryptDocumentClient utilizzando il relativo costruttore predefinito.

  3. Crea un MyApplication_EncryptDocumentClient.Endpoint.Address utilizzando System.ServiceModel.EndpointAddress costruttore. Passa un valore 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 il lc_version attributo. Questo attributo viene utilizzato quando si crea un riferimento a un servizio. Tuttavia, assicurati di specificare ?blob=mtom.

    NOTA

    Sostituisci hiro-xp* con l'indirizzo IP del server applicazioni J2EE che ospita AEM Forms. *

  4. Crea un System.ServiceModel.BasicHttpBinding ottenendo il valore del EncryptDocumentClient.Endpoint.Binding membro dati. Imposta il valore restituito su BasicHttpBinding.

  5. Imposta la System.ServiceModel.BasicHttpBinding dell’oggetto MessageEncoding membro dei dati WSMessageEncoding.Mtom. Questo valore assicura che venga utilizzato MTOM.

  6. Abilita l’autenticazione HTTP di base eseguendo le seguenti attività:

    • Assegnare il nome utente del modulo di AEM al membro dati MyApplication_EncryptDocumentClient.ClientCredentials.UserName.UserName.
    • Assegna il valore della password corrispondente al membro dati MyApplication_EncryptDocumentClient.ClientCredentials.UserName.Password.
    • Assegna il valore costante HttpClientCredentialType.Basic al membro interessato BasicHttpBindingSecurity.Transport.ClientCredentialType.
    • Assegna il valore costante BasicHttpSecurityMode.TransportCredentialOnly al membro interessato 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. Crea un BLOB utilizzando il relativo costruttore. La BLOB viene utilizzato per memorizzare un documento PDF da passare a MyApplication/EncryptDocument processo.

  8. Crea un System.IO.FileStream richiamando il relativo costruttore. Passa un valore 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 del System.IO.FileStream oggetto. È possibile determinare le dimensioni dell'array di byte ottenendo il System.IO.FileStream dell’oggetto Length proprietà.

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

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

  12. Richiama il MyApplication/EncryptDocument richiamando il MyApplication_EncryptDocumentClient dell’oggetto invoke metodo . Passa la BLOB oggetto contenente il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

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

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

  15. Crea un System.IO.BinaryWriter richiamando il relativo costruttore e passando System.IO.FileStream oggetto.

  16. Scrivi il contenuto dell’array di byte in un file PDF richiamando il System.IO.BinaryWriter dell’oggetto Write e passare l'array di byte.

NOTA

La maggior parte delle operazioni del servizio AEM Forms ha un avvio rapido MTOM. Puoi visualizzare questi avvii rapidi nella sezione di avvio rapido corrispondente di un servizio. Ad esempio, per visualizzare la sezione Avvio rapido in uscita, vedi Avvio rapido API del servizio di output.

Consulta anche

Avvio rapido: Richiamo di un servizio utilizzando MTOM in un progetto .NET

Accesso a più servizi tramite i servizi web

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

Richiamo di AEM Forms tramite SwaRef

È possibile richiamare i servizi AEM Forms utilizzando SwaRef. Il contenuto del wsi:swaRef L'elemento XML viene inviato come allegato all'interno di un corpo SOAP in cui viene memorizzato 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). (Vedi API Java per servizi Web 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, crea un processo denominato MyApplication/EncryptDocument utilizzo di Workbench. (Vedi Utilizzo di Workbench.)

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione si basa sul SetValue funzionamento. Il parametro di input per questo processo è un document variabile di processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
NOTA

Supporto SwaRef aggiunto in AEM Forms

La discussione seguente è su come invocare i servizi Forms utilizzando SwaRef all'interno di 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 MyApplication/EncryptDocument utilizzando i file proxy Java creati con JAX-WS e SwaRef, esegui i seguenti passaggi:

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

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

    Per informazioni, consulta Creazione di classi proxy Java utilizzando JAX-WS.

    NOTA

    Sostituisci hiro-xp* con l'indirizzo IP del server applicativo J2EE che ospita AEM Forms. *

  2. Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.

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

    <install directory="">\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso classe del progetto client Java.

  4. Crea un MyApplicationEncryptDocumentService utilizzando il relativo costruttore.

  5. Crea un MyApplicationEncryptDocument richiamando l'oggetto MyApplicationEncryptDocumentService dell’oggetto getEncryptDocument metodo .

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

    • Assegna l’endpoint WSDL e il tipo di codifica al javax.xml.ws.BindingProvider dell’oggetto ENDPOINT_ADDRESS_PROPERTY campo . Per richiamare MyApplication/EncryptDocument utilizzando la codifica SwaRef, specifica il seguente valore URL:

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

    • Assegna l’utente dei moduli di AEM al javax.xml.ws.BindingProvider dell’oggetto USERNAME_PROPERTY campo .

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

    L'esempio di codice seguente mostra questa logica di 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. Recupera il documento PDF da inviare al MyApplication/EncryptDocument creazione di un java.io.File utilizzando il relativo costruttore. Passa un valore stringa che specifica la posizione del documento PDF.

  8. Crea un javax.activation.DataSource utilizzando FileDataSource costruttore. Passa la java.io.File oggetto.

  9. Crea un javax.activation.DataHandler utilizzando il relativo costruttore e passando javax.activation.DataSource oggetto.

  10. Crea un BLOB utilizzando il relativo costruttore.

  11. Popolare BLOB richiamandone l'oggetto setSwaRef e passare javax.activation.DataHandler oggetto.

  12. Richiama il MyApplication/EncryptDocument richiamando il MyApplicationEncryptDocument dell’oggetto invoke e passare BLOB oggetto contenente il documento PDF. Il metodo invoke restituisce un BLOB oggetto contenente un documento PDF crittografato.

  13. Popolare un javax.activation.DataHandler richiamando l'oggetto BLOB dell’oggetto getSwaRef metodo .

  14. Converti javax.activation.DataHandler oggetto a un java.io.InputSteam richiamando la javax.activation.DataHandler dell’oggetto getInputStream metodo .

  15. Scrivi java.io.InputSteam istanza a un file PDF che rappresenta il documento PDF crittografato.

NOTA

La maggior parte delle operazioni del servizio AEM Forms ha un avvio rapido SwaRef. Puoi visualizzare questi avvii rapidi nella sezione di avvio rapido corrispondente di un servizio. Ad esempio, per visualizzare la sezione Avvio rapido in uscita, vedi Avvio rapido API del servizio di output.

Consulta anche

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

Richiamo di dati AEM Forms tramite BLOB su HTTP

Puoi richiamare i servizi AEM Forms utilizzando i servizi web e passando dati BLOB su HTTP. Il passaggio dei dati BLOB su HTTP è una tecnica alternativa anziché utilizzare la codifica base64, DIME o MIME. Ad esempio, è possibile trasmettere dati tramite 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 il servizio AEM Forms venga richiamato.

"Richiamo di AEM Forms utilizzando i dati BLOB su HTTP" illustra come richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument passando i dati BLOB su HTTP.

NOTA

Questo processo non è basato su un processo AEM Forms esistente. Per seguire l'esempio di codice, crea un processo denominato MyApplication/EncryptDocument utilizzo di Workbench. (Vedi Utilizzo di Workbench.)

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione si basa sul SetValue funzionamento. Il parametro di input per questo processo è un document variabile di processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc.
NOTA

Si consiglia di avere familiarità con l’utilizzo di SOAP per richiamare AEM Forms. (Vedi Richiamo di AEM Forms tramite i servizi web.)

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

Per creare un assembly client che utilizza i dati tramite HTTP, seguire il processo specificato in Richiamo di AEM Forms con codifica Base64. Tuttavia, modifica l’URL nella classe proxy in modo da includere ?blob=http anziché ?blob=base64. Questa azione assicura che i dati vengano trasmessi via HTTP. Nella classe proxy, individua 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 clienMyApplication/EncryptDocument

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

  1. In Progetto menu, seleziona Aggiungi riferimento.
  2. Fai clic sul pulsante .NET scheda .
  3. Fai clic su Sfoglia individuare il file DocumentService.dll.
  4. Fai clic su Seleziona quindi fai clic su OK.

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

È possibile richiamare MyApplication/EncryptDocument servizio (generato in Workbench) tramite un assembly client .NET che utilizza i dati tramite HTTP. Per richiamare MyApplication/EncryptDocument , esegui i seguenti passaggi:

  1. Creare l'assembly client .NET.
  2. Fare riferimento all'assembly client Microsoft .NET. Creare un progetto client Microsoft .NET. 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 richiamando il relativo costruttore predefinito.
  4. Imposta la MyApplication_EncryptDocumentService dell’oggetto Credentials proprietà con un System.Net.NetworkCredential oggetto. All'interno di System.Net.NetworkCredential costruttore, specificare un nome utente AEM forms 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. Crea un BLOB utilizzando il relativo costruttore. La BLOB viene utilizzato per trasmettere i dati al MyApplication/EncryptDocument processo.
  6. Assegna un valore stringa al BLOB dell’oggetto remoteURL membro dati che specifica la posizione URI di un documento PDF da passare al MyApplication/EncryptDocumentservizio.
  7. Richiama il MyApplication/EncryptDocument richiamando il MyApplication_EncryptDocumentService dell’oggetto invoke e passare BLOB oggetto. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.
  8. Crea un System.UriBuilder utilizzando il relativo costruttore e passando il valore del valore restituito BLOB dell’oggetto remoteURL membro dati.
  9. Converti System.UriBuilder oggetto a un System.IO.Stream oggetto. (La Guida rapida C# che segue questo elenco illustra come eseguire questa attività.)
  10. Crea un array di byte e popolalo con i dati che si trovano nel System.IO.Stream oggetto.
  11. Crea un System.IO.BinaryWriter richiamando il relativo costruttore e passando System.IO.FileStream oggetto.
  12. Scrivi il contenuto dell’array di byte in un file PDF richiamando il System.IO.BinaryWriter dell’oggetto Write e passare l'array di byte.

Richiamo di un servizio utilizzando le classi proxy Java e i dati BLOB su HTTP

Puoi richiamare un servizio AEM Forms utilizzando le classi proxy Java e i dati BLOB su HTTP. Per richiamare MyApplication/EncryptDocument utilizzando le classi proxy Java, esegui i seguenti passaggi:

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

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

    Per informazioni, consulta Creazione di classi proxy Java utilizzando JAX-WS.

    NOTA

    Sostituisci hiro-xp* con l'indirizzo IP del server applicativo J2EE che ospita AEM Forms. *

  2. Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.

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

    <install directory="">\Adobe\Adobe_Experience_Manager_forms\sdk\client-libs\thirdparty

    nel percorso classe del progetto client Java.

  4. Crea un MyApplicationEncryptDocumentService utilizzando il relativo costruttore.

  5. Crea un MyApplicationEncryptDocument richiamando l'oggetto MyApplicationEncryptDocumentService dell’oggetto getEncryptDocument metodo .

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

    • Assegna l’endpoint WSDL e il tipo di codifica al javax.xml.ws.BindingProvider dell’oggetto ENDPOINT_ADDRESS_PROPERTY campo . Per richiamare MyApplication/EncryptDocument servizio che utilizza la codifica BLOB su HTTP, specifica il seguente valore URL:

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

    • Assegna l’utente dei moduli di AEM al javax.xml.ws.BindingProvider dell’oggetto USERNAME_PROPERTY campo .

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

    L'esempio di codice seguente mostra questa logica di 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. Crea un BLOB utilizzando il relativo costruttore.

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

  9. Richiama il MyApplication/EncryptDocument richiamando il MyApplicationEncryptDocument dell’oggetto invoke e passare BLOB oggetto contenente 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. Richiama il BLOB dell’oggetto getRemoteURL (utilizzare BLOB oggetto restituito da invoke metodo).

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

  12. Crea un java.io.FileOutputStream utilizzando il relativo costruttore e passando java.io.File oggetto.

  13. Richiama il java.io.FileOutputStream dell’oggetto write metodo . Passa la matrice di byte contenente il flusso di dati che rappresenta il documento PDF crittografato.

Richiamo di AEM Forms tramite DIME

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

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

  1. Ottiene il documento PDF non protetto passato al processo. Questa azione si basa sul SetValue funzionamento. Il parametro di input per questo processo è un document variabile di processo denominata inDoc.
  2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. 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, crea un processo denominato MyApplication/EncryptDocument**utilizzando Workbench. (Vedi Utilizzo di Workbench.)

NOTA

La chiamata delle operazioni del servizio AEM Forms tramite DIME è obsoleta. Si consiglia di utilizzare MTOM. (Vedi Richiamo di AEM Forms tramite 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:

  • Installa i miglioramenti dei servizi Web 2.0 nel computer di sviluppo.
  • Dall’interno del progetto .NET, creare un riferimento Web al servizio Forms FormsAEM.

Installazione dei miglioramenti dei servizi Web 2.0

Installare i miglioramenti dei servizi Web 2.0 nel computer di sviluppo e integrarli con Microsoft Visual Studio .NET. È possibile scaricare i miglioramenti di Web Services 2.0 dal Centro download Microsoft.

Da questa pagina web, cerca i miglioramenti dei servizi Web 2.0 e scaricalo sul computer di sviluppo. Questo download inserisce un file denominato Microsoft WSE 2.0 SPI.msi sul computer. 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 è il 2003 quando si utilizza Web Services Enhancements 2.0. Web Services Enhancements 3.0 non supporta DIME; tuttavia, supporta MTOM.

Creazione di un riferimento web a un servizio AEM Forms

Dopo aver installato Miglioramenti di Web Services 2.0 nel computer di sviluppo e aver creato un progetto Microsoft .NET, creare un riferimento Web al servizio Forms. Ad esempio, per creare un riferimento web al MyApplication/EncryptDocument e, partendo dal presupposto che Forms sia installato nel computer locale, specificare l'URL seguente:

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

Dopo aver creato un riferimento Web, sono disponibili i due tipi di dati proxy seguenti da utilizzare all'interno del progetto .NET: EncryptDocumentService e EncryptDocumentServiceWse. Per richiamare MyApplication/EncryptDocument utilizzando DIME, utilizza EncryptDocumentServiceWse digitare.

NOTA

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

Fai riferimento alla libreria WSE

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

Creare un riferimento Web a un servizio Forms

  1. Scegliere Aggiungi riferimento Web dal menu Progetto.
  2. Nella finestra di dialogo URL , specifica l’URL del servizio Forms.
  3. Fare clic su Vai e 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. Assicurarsi che la casella di controllo nella finestra di dialogo visualizzata sia selezionata.

Richiamo di un servizio tramite DIME in un progetto .NET

È possibile richiamare un servizio Forms utilizzando DIME. Considera la MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare MyApplication/EncryptDocument elabora utilizzando DIME, esegui le seguenti operazioni:

  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 per MyApplication/EncryptDocument processo, creare un EncryptDocumentServiceWse utilizzando il relativo costruttore predefinito.

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

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

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

  6. Aggiungi l'allegato DIME al BLOB assegnando l'oggetto Microsoft.Web.Services2.Dime.DimeAttachment dell’oggetto Id valore del membro dati nel BLOB dell’oggetto attachmentID membro dati.

  7. Richiama il EncryptDocumentServiceWse.RequestSoapContext.Attachments.Add e passare il Microsoft.Web.Services2.Dime.DimeAttachment oggetto.

  8. Richiama il MyApplication/EncryptDocument richiamando il EncryptDocumentServiceWse dell’oggetto invoke e passare BLOB oggetto contenente l'allegato DIME. Questo processo restituisce un documento PDF crittografato all'interno di un BLOB oggetto.

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

  10. Iterare attraverso gli allegati situati in EncryptDocumentServiceWse.ResponseSoapContext.Attachments e utilizzare il valore dell'identificatore allegato per ottenere il documento crittografato di PDF.

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

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

  13. Crea un System.IO.FileStream 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. Crea un System.IO.BinaryWriter richiamando il relativo costruttore e passando System.IO.FileStream oggetto.

  15. Scrivi il contenuto dell’array di byte al file PDF richiamando il System.IO.BinaryWriter dell’oggetto Write e passare 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 operazioni del servizio. Utilizzando Apache Ant, puoi generare file di libreria Axis da una WSDL di servizio AEM Forms che ti consente di richiamare il servizio. (Vedi Creazione di classi proxy Java utilizzando Apache Axis.)

Lo strumento Apache Axis WSDL2Java genera file JAVA contenenti metodi che vengono 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 MyApplication/EncryptDocument il servizio (generato in Workbench) utilizzando i file di libreria generati da Axis e DIME, esegue i seguenti passaggi:

  1. Creare classi proxy Java che utilizzano il MyApplication/EncryptDocument servizio WSDL tramite Apache Axis. (Vedi Creazione di classi proxy Java utilizzando Apache Axis.)

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

  3. Crea un MyApplicationEncryptDocumentServiceLocator utilizzando il relativo costruttore.

  4. Crea un URL utilizzando il relativo costruttore e passando un valore stringa che specifica la definizione WSDL del servizio AEM Forms. Assicurati di specificare ?blob=dime alla fine dell’URL dell’endpoint SOAP. Ad esempio, utilizza

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

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

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

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

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

  10. Allegare l'allegato richiamando il EncryptDocumentSoapBindingStub dell’oggetto addAttachment e passare org.apache.axis.attachments.AttachmentPart oggetto.

  11. Crea un BLOB utilizzando il relativo costruttore. Popolare BLOB oggetto con il valore dell'identificatore allegato richiamando il BLOB dell’oggetto setAttachmentID e passare il valore dell'identificatore allegato. Questo valore può essere ottenuto richiamando il org.apache.axis.attachments.AttachmentPart dell’oggetto getContentId metodo .

  12. Richiama il MyApplication/EncryptDocument richiamando il EncryptDocumentSoapBindingStub dell’oggetto invoke metodo . Passa la BLOB oggetto contenente 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 valore restituito BLOB dell’oggetto getAttachmentID metodo . Questo metodo restituisce un valore stringa che rappresenta il valore dell'identificatore dell'allegato restituito.

  14. Recupera gli allegati richiamando il EncryptDocumentSoapBindingStub dell’oggetto getAttachments metodo . Questo metodo restituisce un array di Objects che rappresentano gli allegati.

  15. Itera attraverso gli allegati (il Object e utilizzare il valore dell'identificatore allegato per ottenere il documento crittografato di PDF. Ogni elemento è un org.apache.axis.attachments.AttachmentPart oggetto.

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

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

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

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

  20. Crea un java.io.FileOutputStream utilizzando il relativo costruttore e passando java.io.File oggetto.

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

Consulta anche

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

Utilizzo dell’autenticazione basata su SAML

AEM Forms supporta diverse modalità di autenticazione dei servizi web quando si richiamano i servizi. Una modalità di autenticazione specifica sia un nome utente che un valore di 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 seguenti modi:

  • Trasferimento delle credenziali come parte dell'autorizzazione di base
  • Passaggio del token del 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 basata su certificato standard, ma supporta l’autenticazione basata su certificato in un modulo diverso.

NOTA

Il servizio Web inizia rapidamente in Programmazione con AEM Forms specifica i valori di nome utente e password per eseguire l'autorizzazione.

L’identità degli utenti dei moduli AEM può essere rappresentata tramite un’asserzione SAML firmata utilizzando una chiave segreta. Il seguente codice XML mostra 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 notevoli:

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

Un'applicazione client può recuperare l'asserzione da qualsiasi API di AEM Forms AuthenticationManager che restituisce un AuthResult oggetto. Puoi ottenere un AuthResult eseguendo uno dei due metodi seguenti:

  • Autenticazione dell'utente tramite uno dei metodi di autenticazione esposti dall'API AuthenticationManager. In genere si utilizzano il nome utente e la password; tuttavia, puoi anche utilizzare l’autenticazione dei certificati.
  • Utilizzo della AuthenticationManager.getAuthResultOnBehalfOfUser metodo . Questo metodo consente all'applicazione client di ottenere un AuthResult oggetto per qualsiasi utente di moduli AEM.

un utente di moduli AEM 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 effettuato l’accesso a tale client tramite un meccanismo diverso dall’utilizzo di un nome utente e di 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, invoca il AuthenticationManager.getAuthResultOnBehalfOfUser utilizzando un servizio Web. Questo metodo restituisce un AuthResult istanza che contiene l'asserzione SAML per l'utente specificato.

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

Utilizzo delle classi Apache Axis e dell'autenticazione basata su SAML

È possibile richiamare un servizio AEM Forms tramite classi proxy Java create utilizzando la libreria Axis. (Vedi Creazione di classi proxy Java utilizzando Apache Axis.)

Quando utilizzi AXIS che utilizza l’autenticazione basata su SAML, registra il gestore di richieste e risposte con Axis. Apache Axis richiama il gestore prima di inviare una richiesta di chiamata ad AEM Forms. Per registrare un gestore, crea una classe Java che si estende org.apache.axis.handlers.BasicHandler.

Creare un gestore di asserzione 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, crea un file client-config.wsdd. Per impostazione predefinita, Asse 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>

Richiamare 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 di un'autenticazione basata su SAML

È possibile richiamare un servizio Forms utilizzando un assembly client .NET e un'autenticazione basata su SAML. A questo scopo, è necessario utilizzare il servizio Web 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, sostituire WSE 2.0 con WSE 3.0. Installare i miglioramenti dei servizi Web 3.0 nel computer di sviluppo e integrarli con Microsoft Visual Studio .NET. È possibile scaricare i miglioramenti di Web Services 3.0 dal Centro download Microsoft.

L’architettura WSE utilizza tipi di dati Criteri, Asserzioni e SecurityToken. In breve, per una chiamata a un servizio Web, specifica un criterio. Un criterio può avere più asserzioni. Ogni asserzione può contenere filtri. Un filtro viene richiamato in determinate fasi di una chiamata a un servizio Web e, in quel momento, può modificare la richiesta SOAP. Per informazioni dettagliate, consulta la documentazione sul servizio Web Enhancements 3.0 .

Creare l’asserzione e il filtro

Nell'esempio di codice C# seguente vengono create classi di filtro e asserzione. Questo esempio di codice crea un SamlAssertionOutputFilter. Questo filtro viene richiamato dal framework WSE prima che la richiesta SOAP venga inviata ad 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

Crea 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 successivamente importato 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);
         }
        . . .
 }

Richiamare un servizio AEM Forms

L'esempio di codice C# seguente richiama 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 problemi quando si richiamano determinate operazioni dei servizi AEM Forms utilizzando i servizi web. L'obiettivo di questa discussione è quello di individuare tali questioni e di fornire una soluzione, se disponibile.

Richiamo asincrono delle operazioni del servizio

Se tenti di richiamare in modo asincrono un’operazione del servizio AEM Forms, ad esempio la funzione Genera PDF htmlToPDF funzionamento, SoapFaultException si verifica. Per risolvere il problema, creare un file XML con binding personalizzato che associa il ExportPDF_Result e altri elementi in classi diverse. Il seguente 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 durante la creazione di file proxy Java utilizzando JAX-WS. (Vedi Creazione di classi proxy Java utilizzando JAX-WS.)

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

Per garantire il corretto funzionamento della chiamata asincrona, modifica il valore dell’URL del punto finale e specifica async=true. Ad esempio, per i file proxy Java creati con JAX-WS, specifica quanto segue per 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
  • Gestione attività
  • Application Manager
  • Gestione directory
  • Distiller
  • Rights Management
  • Gestione dei documenti

Differenze nei server applicazioni J2EE

A volte una libreria proxy creata utilizzando un server applicativo J2EE specifico non richiama correttamente AEM Forms ospitata su un server applicativo J2EE diverso. Considera una libreria proxy generata utilizzando AEM Forms distribuita su WebSphere. Questa libreria proxy non può richiamare correttamente i servizi AEM Forms distribuiti sul server applicazioni JBoss.

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

Accesso a più servizi tramite i servizi web

A causa di conflitti nello spazio dei nomi, gli oggetti dati non possono essere condivisi tra più WSDL del servizio. I diversi servizi possono condividere tipi di dati e, pertanto, i servizi condividono la definizione di questi tipi nelle WSDL. Ad esempio, non è possibile aggiungere due assembly client .NET contenenti un BLOB tipo di dati nello stesso progetto client .NET. Se si tenta 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, ti consigliamo di qualificare completamente i tipi di dati. Ad esempio, considerare un'applicazione .NET che fa riferimento sia al servizio Forms che al servizio Signature utilizzando un riferimento al servizio. Entrambi i riferimenti di servizio contengono un BLOB classe. Per utilizzare un BLOB istanza, qualificare completamente il BLOB quando viene dichiarato. Questo approccio è mostrato nell'esempio di codice seguente. Per informazioni su questo esempio di codice, vedi Firma digitale di Forms interattivo.

Nell'esempio di codice C# seguente viene firmato un modulo interattivo di cui il servizio Forms esegue il rendering. L'applicazione client ha due riferimenti al servizio. La BLOB L'istanza associata al servizio Forms appartiene al SignInteractiveForm.ServiceReference2 spazio dei nomi. Allo stesso modo, il BLOB l’istanza associata al servizio Signature appartiene al 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);
                }
            }
        }
 }


I servizi che iniziano con la lettera producono file proxy non validi

Il nome di alcune classi proxy generate da 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 mancante nella classe proxy generata.

In questa pagina