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:
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:
Per richiamare i servizi AEM Forms utilizzando un servizio Web, in genere si crea una libreria proxy che utilizza il servizio WSDL. La sezione Invoking AEM Forms using Web Services utilizza JAX-WS per creare classi proxy Java per richiamare i servizi. (Vedere 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:
async
specifica il valore true
per abilitare ulteriori operazioni di chiamata asincrona ( false
per impostazione predefinita).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 |
|
Indietro e ripristino |
|
Barcoded Forms |
|
Converti PDF |
|
Distiller |
|
DocConverter |
|
DocumentManagement |
|
Crittografia |
|
Forms |
|
Integrazione dei dati modulo |
|
Genera PDF |
|
Genera PDF 3D |
|
Output |
|
Utilità PDF |
|
Estensioni Acrobat Reader DC |
|
Archivio |
|
Rights Management |
|
Firma |
|
Utilità XMP |
|
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 che il nome del processo sia EncryptDocument
. In questa situazione, specifica la seguente definizione WSDL:
http://localhost:8080/soap/services/MyApplication/EncryptDocument?wsdl
Per informazioni sull'esempio MyApplication/EncryptDocument
processo di breve durata, vedere Esempio di processo di breve durata.
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. (Consultare Richiamo di AEM Forms utilizzando MTOM.)
Per accedere alle nuove funzionalità introdotte in AEM Forms, specifica l’attributo 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
Quando imposti l’attributo lc_version
, accertati 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 tipo BLOB
. Questo tipo di dati è associato alla classe com.adobe.idp.Document
quando si lavora con le API Java di AEM Forms. (Consulta Trasmissione di dati ai servizi AEM Forms tramite l'API Java.)
Un oggetto BLOB
invia e recupera dati binari (ad esempio, file PDF, dati XML e così via) da e verso i servizi AEM Forms. Il tipo BLOB
viene 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>
I campi MTOM
e swaRef
sono supportati solo in AEM Forms. Puoi utilizzare questi nuovi campi solo se specifichi un URL che include la proprietà lc_version
.
Fornitura di oggetti BLOB nelle richieste di servizi
Se un’operazione del servizio AEM Forms richiede un tipo BLOB
come valore di input, crea un’istanza del tipo BLOB
nella logica dell’applicazione. (Molti degli avvii rapidi del servizio Web che si trovano in Programmazione con moduli AEM mostrano come lavorare con un tipo di dati BLOB.)
Assegna i valori ai campi che appartengono all'istanza BLOB
come segue:
BLOB.binaryData
campo e imposta il tipo di dati nel formato MIME (ad esempio application/pdf
) nel BLOB.contentType
campo . (Vedere Richiamo di AEM Forms utilizzando la codifica Base64.)BLOB.MTOM
campo . Questa impostazione allega i dati alla richiesta SOAP utilizzando il framework Java JAX-WS o l’API nativa del framework SOAP. (Consultare Richiamo di AEM Forms utilizzando MTOM.)BLOB.swaRef
campo . Questa impostazione allega i dati alla richiesta SOAP utilizzando il framework Java JAX-WS. (Vedere Richiamo di AEM Forms utilizzando SwaRef.)BLOB.attachmentID
. (Vedere Richiamo di AEM Forms utilizzando la codifica Base64.)BLOB.remoteURL
campo . (Consultare Richiamo di dati AEM Forms tramite BLOB su HTTP.)Accesso ai dati negli oggetti BLOB restituiti dai servizi
Il protocollo di trasmissione per gli oggetti BLOB
restituiti dipende da diversi fattori, considerati nell'ordine seguente, che si arrestano quando la condizione principale è soddisfatta:
L’URL di destinazione specifica il protocollo di trasmissione. Se l’URL di destinazione specificato nella chiamata SOAP contiene il parametro blob="
BLOB_TYPE", il protocollo di trasmissione viene determinato da BLOB_TYPE. BLOB_ TYPE è un segnaposto per base64, dime, mime, http, mtom o swaref.
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. (Consultare guida all'amministrazione.)
Il servizio AEM Forms accetta uno o più documenti come input.
L'endpoint SOAP del servizio non è Smart. Il protocollo configurato determina il protocollo di trasmissione del documento e i dati vengono restituiti nel campo corrispondente BLOB
. Ad esempio, se l’endpoint SOAP è impostato su DIME, il BLOB restituito si trova nel campo blob.attachmentID
indipendentemente dal protocollo di trasmissione di qualsiasi documento di input.
Altrimenti. Se un servizio non accetta il tipo di documento come input, i documenti di output vengono restituiti nel campo 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:
blob
suffisso su base64
per restituire i dati nel BLOB.binaryData
campo.blob
suffisso su DIME
o MIME
per restituire i dati come tipo di allegato corrispondente con l'identificatore allegato restituito nel BLOB.attachmentID
campo. Utilizza l’API proprietaria del framework SOAP per leggere i dati dall’allegato.blob
suffisso su http
per mantenere i dati sul server dell'applicazione e restituisce l'URL che punta ai dati nel BLOB.remoteURL
campo .blob
suffisso su mtom
o swaref
per restituire i dati come tipo di allegato corrispondente con l'identificatore allegato restituito nei BLOB.MTOM
campi BLOB.swaRef
o . Utilizza l’API nativa del framework SOAP per leggere i dati dall’allegato.È consigliabile non superare i 30 MB durante la compilazione di un oggetto BLOB
richiamando il relativo metodo setBinaryData
. In caso contrario, è possibile che si verifichi un'eccezione OutOfMemory
.
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 un'eccezione OutOfMemory
.
Trasmissione MTOM di array di byte codificati base64
Oltre all'oggetto 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 elemento xsd:base64Binary
come allegato MTOM (invece di un 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.
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 |
---|---|
|
|
|
|
|
Il tipo
Se un’operazione del servizio AEM Forms richiede un valore |
|
Il tipo
Se un’operazione del servizio AEM Forms richiede un valore |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Il
La mappa è rappresentata come una sequenza di coppie chiave/valore. |
|
|
|
|
|
|
|
Il tipo XML, definito in una WSDL di servizio come segue:
Se un'operazione del servizio AEM Forms accetta un valore L'impostazione del campo |
|
Il tipo XML, definito in una WSDL di servizio come segue:
Se un'operazione del servizio AEM Forms richiede un L'impostazione del campo |
L’invocazione di servizi web tramite componenti personalizzati descrive come creare un componente AEM Forms che richiama servizi Web di terze parti.
È 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:
Installa Apache Ant sul computer client. (Vedere https://ant.apache.org/bindownload.cgi.)
ANT_HOME
nella directory in cui hai installato Ant.Installa JDK 1.6 o versione successiva.
JAVA_HOME
nella directory in cui hai installato il JDK.JDK 1.6 include il programma wsimport utilizzato nel file build.xml. JDK 1.5 non include tale programma.
Installare JAX-WS sul computer client. (Vedere API Java per i servizi Web XML.)
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 Ant build, notare che la proprietà url
è impostata per fare riferimento al servizio di crittografia WSDL in esecuzione su localhost. Le proprietà username
e password
devono essere impostate su un nome utente e una password validi per i moduli AEM. L’URL contiene l’attributo lc_version
. Senza specificare l’opzione lc_version
, non è possibile richiamare nuove operazioni del servizio AEM Forms.
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
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.
Crea un pacchetto con i file JAVA in un file JAR. Se lavori su Eclipse, segui questi passaggi:
com.adobe.idp.services
nella cartella Sorgente.com.adobe.idp.services
e quindi importa i file JAVA dalla cartella adobe/idp/services nel pacchetto.org/apache/xml/xmlsoap
nella cartella Sorgente.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. (Vedere Richiamo di AEM Forms utilizzando 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
È 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. È possibile scaricare Apache Axis dall'URL https://ws.apache.org/axis/.
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. (Consulta Avvio rapido API di Forms Service.)
Puoi generare file libreria Java Axis eseguendo le seguenti operazioni:
Installa Apache Ant sul computer client. È disponibile all'indirizzo https://ant.apache.org/bindownload.cgi.
ANT_HOME
nella directory in cui hai installato Ant.Installare Apache Axis 1.4 sul computer client. È disponibile all'indirizzo https://ws.apache.org/axis/.
Imposta il percorso della classe per utilizzare i file JAR dell'asse nel client del servizio Web, come descritto nelle istruzioni di installazione dell'asse in https://ws.apache.org/axis/java/install.html.
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 Ant build, notare che la proprietà url
è impostata per fare riferimento al servizio di crittografia WSDL in esecuzione su localhost. Le proprietà username
e password
devono essere impostate su un nome utente e una password validi per i moduli AEM.
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 proprietà C:\JavaFiles folder as specified by the output
. 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.
Ci sono diversi modi per mettere i file .JAVA in un JAR. Un modo è usare un IDE Java come Eclipse. Crea un progetto Java e crea un pacchetto com.adobe.idp.services
* (tutti i file .JAVA appartengono a questo pacchetto). Quindi, importa tutti i file .JAVA nel pacchetto. Infine, esporta il progetto come file JAR.*
Modifica l’URL nella classe EncryptionServiceLocator
per specificare il tipo di codifica. Ad esempio, per utilizzare base64, specificare ?blob=base64
per garantire che l'oggetto BLOB
restituisca dati binari. Nella classe EncryptionServiceLocator
, individua la seguente riga di codice:
http://localhost:8080/soap/services/EncryptionService;
e cambiarlo in:
http://localhost:8080/soap/services/EncryptionService?blob=base64;
Aggiungi i seguenti file JAR Axis al percorso di classe del progetto Java:
Questi file JAR si trovano nella directory [install]/Adobe/Adobe Experience Manager Forms/sdk/lib/thirdparty.
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
È 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. In altre parole, i dati BLOB
sono codificati in Base64, non l’intero messaggio SOAP.
"Invoking AEM Forms using Base64 encoding" illustra come richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument
utilizzando la codifica Base64.
Questo processo non è basato su un processo AEM Forms esistente. Per seguire l’esempio di codice, crea un processo denominato MyApplication/EncryptDocument
utilizzando Workbench. (Vedere Uso di Workbench.)
Quando si richiama questo processo, vengono eseguite le azioni seguenti:
SetValue
. Il parametro di input per questo processo è una variabile di processo document
denominata inDoc
.PasswordEncryptPDF
. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc
.È 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:
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 la Guida 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 in modo da includere ?blob=base64
per garantire che l'oggetto BLOB
restituisca 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 sezione Invoking AEM Forms using Base64 Encoding utilizza MyApplication/EncryptDocument
come esempio. Se si sta creando un assembly client .NET per un altro servizio Forms, assicurarsi di sostituire MyApplication/EncryptDocument
con il nome del servizio.
Sviluppo dell'assembly 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.
Questa procedura crea un assembly client .NET denominato DocumentService.dll che è possibile utilizzare per inviare richieste SOAP al servizio MyApplication/EncryptDocument
.
Assicurarsi di aver aggiunto ?blob=base64
all'URL nella classe proxy utilizzata per creare l'assembly client .NET. In caso contrario, non è possibile recuperare dati binari dall'oggetto BLOB
.
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 alla libreria System.Web.Services
dal tuo progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.
Richiamo di un servizio utilizzando un assembly client .NET che utilizza la codifica Base64
È possibile richiamare il servizio MyApplication/EncryptDocument
(creato in Workbench) utilizzando un assembly client .NET che utilizza la codifica Base64. Per richiamare il servizio MyApplication/EncryptDocument
, esegui i seguenti passaggi:
MyApplication/EncryptDocument
.System.Web.Services
.MyApplication_EncryptDocumentService
richiamando il relativo costruttore predefinito.MyApplication_EncryptDocumentService
dell'oggetto Credentials
con un oggetto System.Net.NetworkCredential
. All’interno del costruttore System.Net.NetworkCredential
, specificare un nome utente per i moduli di AEM e la password corrispondente. Impostare i valori di autenticazione per consentire all'applicazione client .NET di scambiare correttamente i messaggi SOAP con AEM Forms.BLOB
utilizzando il relativo costruttore. L'oggetto BLOB
viene utilizzato per memorizzare un documento PDF trasmesso al processo MyApplication/EncryptDocument
.System.IO.FileStream
richiamando il relativo costruttore. Passare un valore di stringa che rappresenta la posizione del file del documento PDF e la modalità di apertura del file.System.IO.FileStream
. È possibile determinare le dimensioni dell'array di byte ottenendo la proprietà Length
dell'oggetto System.IO.FileStream
.Read
dell’oggetto System.IO.FileStream
. Passa la matrice dei byte, la posizione iniziale e la lunghezza del flusso da leggere.BLOB
assegnando la relativa proprietà binaryData
con il contenuto dell'array di byte.MyApplication/EncryptDocument
richiamando il metodo MyApplication_EncryptDocumentService
dell'oggetto invoke
e passando l'oggetto BLOB
che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.System.IO.FileStream
richiamando il relativo costruttore e passando un valore di stringa che rappresenta la posizione del file del documento crittografato con password.BLOB
restituito dal metodo MyApplicationEncryptDocumentService
dell'oggetto invoke
. Compilare l'array di byte ottenendo il valore del membro dati BLOB
dell'oggetto binaryData
.System.IO.BinaryWriter
richiamandone il costruttore e passando l'oggetto System.IO.FileStream
.Write
dell’oggetto System.IO.BinaryWriter
e passando l’array di byte.È possibile richiamare un servizio AEM Forms utilizzando le classi proxy Java e Base64. Per richiamare il servizio MyApplication/EncryptDocument
utilizzando le classi proxy Java, esegui i seguenti passaggi:
Creare classi proxy Java utilizzando JAX-WS che utilizza il servizio WSDL MyApplication/EncryptDocument
. Utilizza il seguente endpoint WSDL:
https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
Sostituisci hiro-xp
* con l’indirizzo IP del server applicazioni J2EE che ospita AEM Forms. *
Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.
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.
Creare un oggetto MyApplicationEncryptDocumentService
utilizzando il relativo costruttore.
Creare un oggetto MyApplicationEncryptDocument
richiamando il metodo MyApplicationEncryptDocumentService
dell'oggetto getEncryptDocument
.
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 campo javax.xml.ws.BindingProvider
dell’oggetto ENDPOINT_ADDRESS_PROPERTY
. Per richiamare il servizio 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 campo USERNAME_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
Assegna il valore della password corrispondente al campo PASSWORD_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
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);
Recupera il documento PDF da inviare al processo MyApplication/EncryptDocument
creando un oggetto java.io.FileInputStream
utilizzando il relativo costruttore. Passa un valore stringa che specifica la posizione del documento PDF.
Creare una matrice di byte e compilarla con il contenuto dell'oggetto java.io.FileInputStream
.
Creare un oggetto BLOB
utilizzando il relativo costruttore.
Compilare l'oggetto BLOB
richiamandone il metodo setBinaryData
e passando la matrice dei byte. L'oggetto setBinaryData
BLOB
è il metodo da chiamare quando si utilizza la codifica Base64. Consultare Fornitura di oggetti BLOB nelle richieste di servizi.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo MyApplicationEncryptDocument
dell'oggetto invoke
. Passa l'oggetto BLOB
che contiene il documento PDF. Il metodo invoke restituisce un oggetto BLOB
contenente il documento PDF crittografato.
Creare una matrice di byte contenente il documento PDF crittografato richiamando il metodo getBinaryData
dell'oggetto BLOB
.
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
È 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 funzione di MTOM è l’utilizzo dell’elemento XOP:Include
. 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 richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument
.
Questo processo non è basato su un processo AEM Forms esistente. Per seguire l’esempio di codice, crea un processo denominato MyApplication/EncryptDocument
utilizzando Workbench. (Vedere Uso di Workbench.)
Quando si richiama questo processo, vengono eseguite le azioni seguenti:
SetValue
. Il parametro di input per questo processo è una variabile di processo document
denominata inDoc
.PasswordEncryptPDF
. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc
.Il supporto per MTOM è stato aggiunto in AEM Forms, versione 9.
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 un'eccezione OutOfMemory
.
In questo caso, per invocare i servizi AEM Forms, si tratta di utilizzare MTOM all'interno di un progetto Microsoft .NET. .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).
È 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 applicativo 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
L’opzione lc_version
garantisce la disponibilità della funzionalità AEM Forms, ad esempio MTOM. Senza specificare l’opzione 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:
Creare un progetto .NET utilizzando Microsoft Visual Studio 2008.
Nel menu Progetto, seleziona Aggiungi riferimento servizio.
Nella finestra di dialogo Indirizzo, specifica il WSDL al servizio AEM Forms. Ad esempio,
http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
Fare clic su Vai e quindi su OK.
Considera il processo MyApplication/EncryptDocument
che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il processo MyApplication/EncryptDocument
(generato in Workbench) utilizzando MTOM, esegui i seguenti passaggi:
Creare un progetto Microsoft .NET.
Creare un oggetto MyApplication_EncryptDocumentClient
utilizzando il relativo costruttore predefinito.
Creare un oggetto MyApplication_EncryptDocumentClient.Endpoint.Address
utilizzando il costruttore System.ServiceModel.EndpointAddress
. 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 l'attributo lc_version
. Questo attributo viene utilizzato quando si crea un riferimento a un servizio. Tuttavia, assicurati di specificare ?blob=mtom
.
Sostituisci hiro-xp
* con l’indirizzo IP del server applicazioni J2EE che ospita AEM Forms. *
Crea un oggetto System.ServiceModel.BasicHttpBinding
ottenendo il valore del membro dati EncryptDocumentClient.Endpoint.Binding
. Imposta il valore restituito su BasicHttpBinding
.
Impostare il membro dati MessageEncoding
dell'oggetto System.ServiceModel.BasicHttpBinding
su WSMessageEncoding.Mtom
. Questo valore assicura che venga utilizzato MTOM.
Abilita l’autenticazione HTTP di base eseguendo le seguenti attività:
MyApplication_EncryptDocumentClient.ClientCredentials.UserName.UserName
.MyApplication_EncryptDocumentClient.ClientCredentials.UserName.Password
.HttpClientCredentialType.Basic
al membro dati BasicHttpBindingSecurity.Transport.ClientCredentialType
.BasicHttpSecurityMode.TransportCredentialOnly
al membro dati BasicHttpBindingSecurity.Security.Mode
.L'esempio di codice seguente mostra queste attività.
//Enable BASIC HTTP authentication
encryptProcess.ClientCredentials.UserName.UserName = "administrator";
encryptProcess.ClientCredentials.UserName.Password = "password";
b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
b.MaxReceivedMessageSize = 4000000;
b.MaxBufferSize = 4000000;
b.ReaderQuotas.MaxArrayLength = 4000000;
Creare un oggetto BLOB
utilizzando il relativo costruttore. L'oggetto BLOB
viene utilizzato per memorizzare un documento PDF da passare al processo MyApplication/EncryptDocument
.
Creare un oggetto System.IO.FileStream
richiamando il relativo costruttore. Passare un valore di stringa che rappresenta la posizione del file del documento PDF e la modalità di apertura del file.
Creare una matrice di byte che memorizza il contenuto dell'oggetto System.IO.FileStream
. È possibile determinare le dimensioni dell'array di byte ottenendo la proprietà Length
dell'oggetto System.IO.FileStream
.
Compilare l’array di byte con i dati del flusso richiamando il metodo Read
dell’oggetto System.IO.FileStream
. Passa la matrice dei byte, la posizione iniziale e la lunghezza del flusso da leggere.
Compilare l'oggetto BLOB
assegnando il relativo membro dati MTOM
con il contenuto dell'array di byte.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo MyApplication_EncryptDocumentClient
dell'oggetto invoke
. Passa l'oggetto BLOB
che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.
Creare un oggetto System.IO.FileStream
richiamando il relativo costruttore e passando un valore di stringa che rappresenta la posizione del file del documento PDF protetto.
Creare una matrice di byte che memorizza il contenuto dei dati dell'oggetto BLOB
restituito dal metodo invoke
. Compilare l'array di byte ottenendo il valore del membro dati BLOB
dell'oggetto MTOM
.
Creare un oggetto System.IO.BinaryWriter
richiamandone il costruttore e passando l'oggetto System.IO.FileStream
.
Scrivi il contenuto dell’array di byte in un file PDF richiamando il metodo Write
dell’oggetto System.IO.BinaryWriter
e passando l’array di byte.
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 output , consulta 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
È possibile richiamare i servizi AEM Forms utilizzando SwaRef. Il contenuto dell'elemento XML wsi:swaRef
viene inviato come allegato all'interno di un corpo SOAP in cui è 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). (Vedere API Java per i servizi Web XML.)
La discussione qui riguarda l'invocazione del seguente processo Forms di breve durata chiamato MyApplication/EncryptDocument
utilizzando SwaRef.
Questo processo non è basato su un processo AEM Forms esistente. Per seguire l’esempio di codice, crea un processo denominato MyApplication/EncryptDocument
utilizzando Workbench. (Vedere Uso di Workbench.)
Quando si richiama questo processo, vengono eseguite le azioni seguenti:
SetValue
. Il parametro di input per questo processo è una variabile di processo document
denominata inDoc
.PasswordEncryptPDF
. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc
.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.
Per richiamare il processo MyApplication/EncryptDocument
utilizzando i file proxy Java creati utilizzando JAX-WS e SwaRef, esegui i seguenti passaggi:
Creare classi proxy Java utilizzando JAX-WS che utilizza il servizio WSDL MyApplication/EncryptDocument
. Utilizza il seguente endpoint WSDL:
https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
Per informazioni, vedere Creazione di classi proxy Java utilizzando JAX-WS.
Sostituisci hiro-xp
* con l'indirizzo IP del server applicativo J2EE che ospita AEM Forms. *
Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.
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.
Creare un oggetto MyApplicationEncryptDocumentService
utilizzando il relativo costruttore.
Creare un oggetto MyApplicationEncryptDocument
richiamando il metodo MyApplicationEncryptDocumentService
dell'oggetto getEncryptDocument
.
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 campo javax.xml.ws.BindingProvider
dell’oggetto ENDPOINT_ADDRESS_PROPERTY
. Per richiamare il servizio 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 campo USERNAME_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
Assegna il valore della password corrispondente al campo PASSWORD_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
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);
Recupera il documento PDF da inviare al processo MyApplication/EncryptDocument
creando un oggetto java.io.File
utilizzando il relativo costruttore. Passa un valore stringa che specifica la posizione del documento PDF.
Creare un oggetto javax.activation.DataSource
utilizzando il costruttore FileDataSource
. Passa l'oggetto java.io.File
.
Creare un oggetto javax.activation.DataHandler
utilizzando il relativo costruttore e passando l'oggetto javax.activation.DataSource
.
Creare un oggetto BLOB
utilizzando il relativo costruttore.
Compilare l'oggetto BLOB
richiamandone il metodo setSwaRef
e passando l'oggetto javax.activation.DataHandler
.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo MyApplicationEncryptDocument
dell'oggetto invoke
e passando l'oggetto BLOB
che contiene il documento PDF. Il metodo invoke restituisce un oggetto BLOB
contenente un documento PDF crittografato.
Compilare un oggetto javax.activation.DataHandler
richiamando il metodo BLOB
dell'oggetto getSwaRef
.
Converti l’oggetto javax.activation.DataHandler
in un’istanza java.io.InputSteam
richiamando il metodo javax.activation.DataHandler
dell’oggetto getInputStream
.
Scrivere l'istanza java.io.InputSteam
in un file PDF che rappresenta il documento PDF crittografato.
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 output , consulta Avvio rapido API del servizio di output.
Consulta anche
Avvio rapido: Richiamo di un servizio utilizzando SwaRef in un progetto Java
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 il miglioramento del servizio Web 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.
"Invoking AEM Forms using BLOB Data over HTTP" (Richiamare 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.
Questo processo non è basato su un processo AEM Forms esistente. Per seguire l’esempio di codice, crea un processo denominato MyApplication/EncryptDocument
utilizzando Workbench. (Vedere Uso di Workbench.)
Quando si richiama questo processo, vengono eseguite le azioni seguenti:
SetValue
. Il parametro di input per questo processo è una variabile di processo document
denominata inDoc
.PasswordEncryptPDF
. Il documento PDF crittografato con password viene restituito in una variabile di processo denominata outDoc
.Si consiglia di avere familiarità con l’utilizzo di SOAP per richiamare AEM Forms. (Vedere Richiamo di AEM Forms tramite Web Services.)
Per creare un assembly client che utilizza i dati via HTTP, seguire il processo specificato in Richiamo di AEM Forms utilizzando la codifica Base64. Tuttavia, modifica l’URL nella classe proxy in modo da includere ?blob=http
invece di ?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 alla libreria System.Web.Services
dal progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.
Richiamo di un servizio utilizzando un assembly client .NET che utilizza dati BLOB su HTTP
È possibile richiamare il servizio MyApplication/EncryptDocument
(creato in Workbench) utilizzando un assembly client .NET che utilizza i dati tramite HTTP. Per richiamare il servizio MyApplication/EncryptDocument
, esegui i seguenti passaggi:
System.Web.Services
.MyApplication_EncryptDocumentService
richiamando il relativo costruttore predefinito.MyApplication_EncryptDocumentService
dell'oggetto Credentials
con un oggetto System.Net.NetworkCredential
. All’interno del costruttore System.Net.NetworkCredential
, specificare un nome utente per i moduli di AEM e la password corrispondente. Impostare i valori di autenticazione per consentire all'applicazione client .NET di scambiare correttamente i messaggi SOAP con AEM Forms.BLOB
utilizzando il relativo costruttore. L'oggetto BLOB
viene utilizzato per trasmettere dati al processo MyApplication/EncryptDocument
.remoteURL
dell'oggetto BLOB
che specifica la posizione URI di un documento PDF da passare al servizio MyApplication/EncryptDocument
.MyApplication/EncryptDocument
richiamando il metodo MyApplication_EncryptDocumentService
dell'oggetto invoke
e passando l'oggetto BLOB
. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.System.UriBuilder
utilizzando il relativo costruttore e passando il valore del membro dati BLOB
dell'oggetto remoteURL
restituito.System.UriBuilder
in un oggetto System.IO.Stream
. (La Guida rapida C# che segue questo elenco illustra come eseguire questa attività.)System.IO.Stream
.System.IO.BinaryWriter
richiamandone il costruttore e passando l'oggetto System.IO.FileStream
.Write
dell’oggetto System.IO.BinaryWriter
e passando l’array di byte.Puoi richiamare un servizio AEM Forms utilizzando le classi proxy Java e i dati BLOB su HTTP. Per richiamare il servizio MyApplication/EncryptDocument
utilizzando le classi proxy Java, esegui i seguenti passaggi:
Creare classi proxy Java utilizzando JAX-WS che utilizza il servizio WSDL MyApplication/EncryptDocument
. Utilizza il seguente endpoint WSDL:
https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1
Per informazioni, vedere Creazione di classi proxy Java utilizzando JAX-WS.
Sostituisci hiro-xp
* con l'indirizzo IP del server applicativo J2EE che ospita AEM Forms. *
Crea un pacchetto con le classi proxy Java create utilizzando JAX-WS in un file JAR.
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.
Creare un oggetto MyApplicationEncryptDocumentService
utilizzando il relativo costruttore.
Creare un oggetto MyApplicationEncryptDocument
richiamando il metodo MyApplicationEncryptDocumentService
dell'oggetto getEncryptDocument
.
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 campo javax.xml.ws.BindingProvider
dell’oggetto ENDPOINT_ADDRESS_PROPERTY
. Per richiamare il servizio MyApplication/EncryptDocument
utilizzando 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 campo USERNAME_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
Assegna il valore della password corrispondente al campo PASSWORD_PROPERTY
dell’oggetto javax.xml.ws.BindingProvider
.
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);
Creare un oggetto BLOB
utilizzando il relativo costruttore.
Compilare l'oggetto BLOB
richiamandone il metodo setRemoteURL
. Passa un valore stringa che specifica la posizione URI di un documento PDF da passare al servizio MyApplication/EncryptDocument
.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo MyApplicationEncryptDocument
dell'oggetto invoke
e passando l'oggetto BLOB
che contiene il documento PDF. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.
Creare un array di byte per memorizzare il flusso di dati che rappresenta il documento PDF crittografato. Richiamare il metodo getRemoteURL
dell'oggetto BLOB
(utilizzare l'oggetto BLOB
restituito dal metodo invoke
).
Creare un oggetto java.io.File
utilizzando il relativo costruttore. Questo oggetto rappresenta il documento PDF crittografato.
Creare un oggetto java.io.FileOutputStream
utilizzando il relativo costruttore e passando l'oggetto java.io.File
.
Richiama il metodo write
dell'oggetto java.io.FileOutputStream
. Passa la matrice di byte contenente il flusso di dati che rappresenta il documento PDF crittografato.
È 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, come documenti PDF, insieme a richieste di chiamata invece di codificare l'allegato. La sezione Invoking AEM Forms using DIME illustra 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:
SetValue
. Il parametro di input per questo processo è una variabile di processo document
denominata inDoc
.PasswordEncryptPDF
. 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. (Vedere Uso di Workbench.)
La chiamata delle operazioni del servizio AEM Forms tramite DIME è obsoleta. Si consiglia di utilizzare MTOM. (Consultare Richiamo di AEM Forms utilizzando MTOM.)
Per creare un progetto .NET in grado di richiamare un servizio Forms utilizzando DIME, eseguire le operazioni seguenti:
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 dei servizi Web 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 nel computer. Eseguire il programma di installazione e seguire le indicazioni online.
Web Services Enhancements 2.0 supporta DIME. La versione supportata di Microsoft Visual Studio è il 2003 quando si utilizzano i miglioramenti dei servizi Web 2.0. I miglioramenti dei servizi Web 3.0 non supportano 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 processo MyApplication/EncryptDocument
e presupponendo che Forms sia installato sul 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 il processo MyApplication/EncryptDocument
utilizzando DIME, utilizzare il tipo EncryptDocumentServiceWse
.
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
Creare un riferimento Web a un servizio Forms
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 il processo MyApplication/EncryptDocument
che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il processo MyApplication/EncryptDocument
utilizzando DIME, esegui i seguenti passaggi:
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.
Dopo aver impostato un riferimento Web al processo MyApplication/EncryptDocument
, creare un oggetto EncryptDocumentServiceWse
utilizzando il relativo costruttore predefinito.
Impostare il membro dati Credentials
dell'oggetto EncryptDocumentServiceWse
con un valore System.Net.NetworkCredential
che specifica il nome utente e il valore della password del modulo di AEM.
Creare un oggetto Microsoft.Web.Services2.Dime.DimeAttachment
utilizzando il relativo costruttore e passando i seguenti valori:
System.Guid.NewGuid.ToString
.application/pdf
.TypeFormat
. Specifica TypeFormat.MediaType
.Creare un oggetto BLOB
utilizzando il relativo costruttore.
Aggiungere l'allegato DIME all'oggetto BLOB
assegnando il valore del membro dati Microsoft.Web.Services2.Dime.DimeAttachment
dell'oggetto Id
al membro dati BLOB
dell'oggetto attachmentID
.
Richiama il metodo EncryptDocumentServiceWse.RequestSoapContext.Attachments.Add
e passa l'oggetto Microsoft.Web.Services2.Dime.DimeAttachment
.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo EncryptDocumentServiceWse
dell'oggetto invoke
e passando l'oggetto BLOB
che contiene l'allegato DIME. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.
Ottenere il valore dell'identificatore allegato ottenendo il valore del membro dati BLOB
dell'oggetto attachmentID
restituito.
Iterare gli allegati presenti in EncryptDocumentServiceWse.ResponseSoapContext.Attachments
e utilizzare il valore dell'identificatore allegato per ottenere il documento PDF crittografato.
Ottenere un oggetto System.IO.Stream
ottenendo il valore del membro dati Attachment
dell'oggetto Stream
.
Creare un array di byte e passare tale array di byte al metodo System.IO.Stream
dell'oggetto Read
. Questo metodo popola l'array di byte con un flusso di dati che rappresenta il documento PDF crittografato.
Creare un oggetto 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.
Creare un oggetto System.IO.BinaryWriter
richiamandone il costruttore e passando l'oggetto System.IO.FileStream
.
Scrivere il contenuto dell’array di byte nel file PDF richiamando il metodo System.IO.BinaryWriter
dell’oggetto Write
e passando l’array di byte.
È 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. (Consulta Creazione di classi proxy Java tramite 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 il servizio MyApplication/EncryptDocument
(generato in Workbench) utilizzando i file di libreria generati da Axis e DIME, esegui i seguenti passaggi:
Crea classi proxy Java che utilizzano il servizio WSDL MyApplication/EncryptDocument
utilizzando Apache Axis. (Consulta Creazione di classi proxy Java tramite Apache Axis.)
Includi le classi proxy Java nel percorso della classe.
Creare un oggetto MyApplicationEncryptDocumentServiceLocator
utilizzando il relativo costruttore.
Creare un oggetto URL
utilizzando il relativo costruttore e passando un valore di 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.
Creare un oggetto EncryptDocumentSoapBindingStub
richiamando il relativo costruttore e passando l'oggetto MyApplicationEncryptDocumentServiceLocator
e l'oggetto URL
.
Impostare il nome utente e il valore della password dei moduli AEM richiamando i metodi setUsername
e setPassword
dell’oggetto EncryptDocumentSoapBindingStub
.
encryptionClientStub.setUsername("administrator");
encryptionClientStub.setPassword("password");
Recupera il documento PDF da inviare al servizio MyApplication/EncryptDocument
creando un oggetto java.io.File
. Passa un valore stringa che specifica la posizione del documento PDF.
Creare un oggetto javax.activation.DataHandler
utilizzando il relativo costruttore e passando un oggetto javax.activation.FileDataSource
. È possibile creare l'oggetto javax.activation.FileDataSource
utilizzando il relativo costruttore e passando l'oggetto java.io.File
che rappresenta il documento PDF.
Creare un oggetto org.apache.axis.attachments.AttachmentPart
utilizzando il relativo costruttore e passando l'oggetto javax.activation.DataHandler
.
Allegare l'allegato richiamando il metodo addAttachment
dell'oggetto org.apache.axis.attachments.AttachmentPart
e passando l'oggetto EncryptDocumentSoapBindingStub
.
Creare un oggetto BLOB
utilizzando il relativo costruttore. Compilare l'oggetto BLOB
con il valore dell'identificatore allegato richiamando il metodo BLOB
dell'oggetto setAttachmentID
e passando il valore dell'identificatore allegato. Questo valore può essere ottenuto richiamando il metodo getContentId
dell'oggetto org.apache.axis.attachments.AttachmentPart
.
Richiamare il processo MyApplication/EncryptDocument
richiamando il metodo EncryptDocumentSoapBindingStub
dell'oggetto invoke
. Passa l'oggetto BLOB
che contiene l'allegato DIME. Questo processo restituisce un documento PDF crittografato all'interno di un oggetto BLOB
.
Per ottenere il valore dell'identificatore allegato, richiamare il metodo getAttachmentID
dell'oggetto BLOB
restituito. Questo metodo restituisce un valore stringa che rappresenta il valore dell'identificatore dell'allegato restituito.
Recupera gli allegati richiamando il metodo getAttachments
dell'oggetto EncryptDocumentSoapBindingStub
. Questo metodo restituisce una matrice di Objects
che rappresenta gli allegati.
Iterare attraverso gli allegati (l' Object
array) e utilizzare il valore dell'identificatore allegato per ottenere il documento PDF crittografato. Ogni elemento è un oggetto org.apache.axis.attachments.AttachmentPart
.
Ottenere l'oggetto javax.activation.DataHandler
associato all'allegato richiamando il metodo org.apache.axis.attachments.AttachmentPart
dell'oggetto getDataHandler
.
Per ottenere un oggetto java.io.FileStream
, richiamare il metodo javax.activation.DataHandler
dell'oggetto getInputStream
.
Creare un array di byte e passare tale array di byte al metodo java.io.FileStream
dell'oggetto read
. Questo metodo popola l'array di byte con un flusso di dati che rappresenta il documento PDF crittografato.
Creare un oggetto java.io.File
utilizzando il relativo costruttore. Questo oggetto rappresenta il documento PDF crittografato.
Creare un oggetto java.io.FileOutputStream
utilizzando il relativo costruttore e passando l'oggetto java.io.File
.
Richiamare il metodo write
dell'oggetto java.io.FileOutputStream
e passare la matrice di byte che contiene il flusso di dati che rappresenta il documento PDF crittografato.
Consulta anche
Avvio rapido: Richiamo di un servizio tramite DIME in un progetto Java
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:
AEM Forms non supporta l’autenticazione basata su certificato standard, ma supporta l’autenticazione basata su certificato in un modulo diverso.
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:
Un'applicazione client può recuperare l'asserzione da qualsiasi API di AEM Forms AuthenticationManager che restituisce un oggetto AuthResult
. Per ottenere un'istanza AuthResult
è possibile eseguire uno dei due metodi seguenti:
AuthenticationManager.getAuthResultOnBehalfOfUser
. Questo metodo consente a un'applicazione client di ottenere un oggetto AuthResult
per qualsiasi utente AEM forms.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 metodo AuthenticationManager.getAuthResultOnBehalfOfUser
utilizzando un servizio Web. Questo metodo restituisce un'istanza AuthResult
che contiene l'asserzione SAML per tale utente.
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.
È possibile richiamare un servizio AEM Forms tramite classi proxy Java create utilizzando la libreria Axis. (Consulta Creazione di classi proxy Java tramite 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 una 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());
}
}
È 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.
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 dei servizi Web 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.
Se tenti di richiamare in modo asincrono un’operazione del servizio AEM Forms, ad esempio l’operazione Genera PDF htmlToPDF
, si verifica un SoapFaultException
. Per risolvere questo problema, crea un file XML con binding personalizzato che mappa l’elemento 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. (Vedere Creazione di classi proxy Java utilizzando JAX-WS.)
Fare riferimento a questo file XML durante l'esecuzione dello strumento JAX-WS (wsimport.exe) utilizzando l'opzione della riga di comando - b
. Aggiornare l’elemento 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:
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, come PrincipalReference
, vengono 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.
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 tipo di dati BLOB
allo 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 conterranno una classe BLOB
. Per utilizzare un'istanza BLOB
, qualificare completamente l'oggetto BLOB
quando lo si dichiara. Questo approccio è mostrato nell'esempio di codice seguente. Per informazioni su questo esempio di codice, consulta Digitally Signing Interactive Forms.
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. L’istanza BLOB
associata al servizio Forms appartiene allo spazio dei nomi SignInteractiveForm.ServiceReference2
. Analogamente, l’istanza BLOB
associata al servizio Signature appartiene allo spazio dei nomi SignInteractiveForm.ServiceReference1
. 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);
}
}
}
}
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.