Show Menu
ARGOMENTI×

Creazione di applicazioni Web per il rendering di moduli

Creazione di applicazioni Web per il rendering di moduli

È possibile creare un'applicazione basata sul Web che utilizza servlet Java per richiamare il servizio Forms ed eseguire il rendering dei moduli. Un vantaggio derivante dall'utilizzo di un servlet Java™ è rappresentato dal fatto che è possibile scrivere il valore restituito dal processo in un browser Web client. In altre parole, un servlet Java può essere utilizzato come collegamento tra il servizio Forms che restituisce un modulo e un browser Web client.
Questa sezione descrive come creare un'applicazione basata sul Web che utilizza un servlet Java per richiamare il servizio Forms ed eseguire il rendering di moduli basati su frammenti. (Vedere Rendering dei moduli basati su frammenti .)
Utilizzando un servlet Java, è possibile scrivere un modulo in un browser Web client in modo che il cliente possa visualizzare e immettere i dati nel modulo. Dopo aver compilato il modulo con i dati, l'utente Web fa clic su un pulsante di invio situato nel modulo per inviare le informazioni al servlet Java, dove è possibile recuperare ed elaborare i dati. Ad esempio, i dati possono essere inviati a un altro processo.
In questa sezione viene illustrato come creare un'applicazione basata sul Web che consenta all'utente di selezionare dati del modulo basati su Stati Uniti o dati del modulo basati su Canada, come illustrato nell'illustrazione seguente.
Il modulo di cui si esegue il rendering è un modulo basato sui frammenti. Se l'utente seleziona dati americani, il modulo restituito utilizza quindi frammenti basati su dati americani. Ad esempio, il piè di pagina del modulo contiene un indirizzo americano, come illustrato nell'illustrazione seguente.
Analogamente, se l'utente seleziona dati canadesi, il modulo restituito contiene un indirizzo canadese, come illustrato nell'illustrazione seguente.
Per informazioni sulla creazione di strutture del modulo basate sui frammenti, vedere Designer di moduli.
File di esempio
In questa sezione vengono utilizzati file di esempio che possono essere memorizzati nel seguente percorso:
<directory di installazione di Designer Forms>/Samples/Forms/Purchase Order/Form Fragments
dove <directory di installazione> è il percorso di installazione. Ai fini dell'applicazione client, il file Purchase Order Dynamic.xdp è stato copiato da questo percorso di installazione e distribuito in un'applicazione Forms denominata Applications/FormsApplication . Il file Purchase Order Dynamic.xdp viene memorizzato in una cartella denominata FormsFolder. Analogamente, i frammenti vengono inseriti in una cartella denominata Frammenti, come illustrato nell'illustrazione seguente.
Per accedere alla struttura del modulo Purchase Order Dynamic.xdp, specificare Applications/FormsApplication/1.0/FormsFolder/Purchase Order Dynamic.xdp come nome del modulo (il primo parametro passato al renderPDFForm metodo) e repository:/// come valore URI della directory principale del contenuto.
I file di dati XML utilizzati dall'applicazione Web sono stati spostati dalla cartella Data a C:\Adobe (il file system che appartiene al server applicazione J2EE in cui è installato AEM Forms). I nomi dei file sono Purchase Order Canada.xml e Purchase Order US.xml .
Per informazioni sulla creazione di un'applicazione Forms utilizzando Workbench, vedere la Guida learn_aemforms_workbench_63di Workbench.

Riepilogo dei passaggi

Per creare un'applicazione basata sul Web che esegue il rendering di moduli basati su frammenti, procedere come segue:
  1. Crea un nuovo progetto Web.
  2. Creare una logica di applicazione Java che rappresenta il servlet Java.
  3. Creare la pagina Web per l’applicazione Web.
  4. Creare un pacchetto dell'applicazione Web in un file WAR.
  5. Distribuire il file WAR sul server applicazioni J2EE.
  6. Eseguite il test dell'applicazione Web.
Alcuni di questi passaggi dipendono dall’applicazione J2EE da cui è distribuito AEM Forms. Ad esempio, il metodo utilizzato per distribuire un file WAR dipende dal server applicazione J2EE in uso. Questa sezione presuppone che AEM Forms sia implementato su JBoss®.

Creazione di un progetto Web

Il primo passaggio per creare un'applicazione Web che contenga un servlet Java in grado di richiamare il servizio Forms consiste nel creare un nuovo progetto Web. L'IDE Java su cui si basa il presente documento è Eclipse 3.3. Utilizzando Eclipse IDE, create un progetto Web e aggiungete i file JAR richiesti al progetto. Infine, aggiungete una pagina HTML denominata index.html e un servlet Java al progetto.
L'elenco seguente specifica i file JAR da aggiungere al progetto Web:
  • adobe-forms-client.jar
  • adobe-livecycle-client.jar
  • adobe-usermanager-client.jar
  • adobe-utilities.jar
Per la posizione di questi file JAR, consultate Inclusione di file libreria Java AEM Forms.
Per creare un progetto Web:
  1. Avviate Eclipse e fate clic su File > Nuovo progetto .
  2. Nella finestra di dialogo Nuovo progetto , selezionare Web > Progetto Web dinamico.
  3. Digitare FragmentsWebApplication il nome del progetto e fare clic su Fine .
Per aggiungere al progetto i file JAR richiesti:
  1. Nella finestra Esplora progetti, fare clic con il pulsante destro del mouse sul FragmentsWebApplication progetto e selezionare Proprietà .
  2. Fate clic sul percorso di creazione Java, quindi fate clic sulla scheda Librerie .
  3. Fate clic sul pulsante Aggiungi JARs esterni e individuate i file JAR da includere.
Per aggiungere un servlet Java al progetto:
  1. Nella finestra Esplora progetti, fare clic con il pulsante destro del mouse sul FragmentsWebApplication progetto e selezionare Nuovo > Altro .
  2. Espandete la cartella Web , selezionate Servlet e fate clic su Avanti .
  3. Nella finestra di dialogo Crea servlet, digitare RenderFormFragment il nome del servlet, quindi fare clic su Fine .
Per aggiungere una pagina HTML al progetto:
  1. Nella finestra Esplora progetti, fare clic con il pulsante destro del mouse sul FragmentsWebApplication progetto e selezionare Nuovo > Altro .
  2. Espandete la cartella Web , selezionate HTML e fate clic su Avanti .
  3. Nella finestra di dialogo Nuovo HTML, digitare index.html il nome del file, quindi fare clic su Fine .
Per informazioni sulla creazione di una pagina HTML che richiama il servlet RenderFormFragment Java, vedere Creazione di una pagina Web.

Creazione di una logica di applicazione Java per il servlet

È possibile creare una logica dell'applicazione Java che richiama il servizio Forms dall'interno del servlet Java. Il codice seguente mostra la sintassi del servlet RenderFormFragment Java:
     public class RenderFormFragment extends HttpServlet implements Servlet {
         public void doGet(HttpServletRequest req, HttpServletResponse resp
         throws ServletException, IOException {
         doPost(req,resp);
 
         }
         public void doPost(HttpServletRequest req, HttpServletResponse resp
         throws ServletException, IOException {
             //Add code here to invoke the Forms service
             }

Normalmente, il codice client non viene inserito all'interno di un servlet doGet o di un doPost metodo Java. Una procedura di programmazione migliore consiste nel posizionare il codice all'interno di una classe separata, creare un'istanza della classe all'interno del doPost metodo (o doGet metodo) e chiamare i metodi appropriati. Tuttavia, per la brevità del codice, gli esempi di codice riportati in questa sezione sono limitati al minimo e gli esempi di codice sono inseriti nel doPost metodo.
Per eseguire il rendering di un modulo basato su frammenti utilizzando l'API del servizio Forms, effettuare le seguenti operazioni:
  1. Includete file JAR client, ad esempio adobe-forms-client.jar, nel percorso di classe del progetto Java. Per informazioni sulla posizione di questi file, consultate Inclusione di file libreria Java AEM Forms.
  2. Recuperare il valore del pulsante di scelta inviato dal modulo HTML e specificare se utilizzare dati americani o canadesi. Se viene inviato American, creare un com.adobe.idp.Document oggetto che memorizza i dati presenti nel file Purchase Order US.xml . Analogamente, se canadese, creare un com.adobe.idp.Document che memorizza i dati presenti nel file Purchase Order Canada.xml .
  3. Creare un ServiceClientFactory oggetto che contenga proprietà di connessione. (Vedere Impostazione delle proprietà di connessione.)
  4. Creare un FormsServiceClient oggetto utilizzando il relativo costruttore e passando l' ServiceClientFactory oggetto.
  5. Creare un URLSpec oggetto che memorizza i valori URI utilizzando il relativo costruttore.
  6. Richiamate il metodo dell' URLSpec oggetto setApplicationWebRoot e passate un valore di stringa che rappresenta la radice Web dell'applicazione.
  7. Richiamate il metodo dell' URLSpec oggetto setContentRootURI e passate un valore di stringa che specifica il valore URI della radice del contenuto. Verificare che la struttura del modulo e i frammenti si trovino nell'URI principale del contenuto. In caso contrario, il servizio Forms genera un'eccezione. Per fare riferimento all'archivio di AEM Forms, specificare repository:// .
  8. Richiamare il metodo dell' URLSpec oggetto setTargetURL e passare un valore di stringa che specifica il valore dell'URL di destinazione in cui vengono inviati i dati del modulo. Se si definisce l'URL di destinazione nella struttura del modulo, è possibile passare una stringa vuota. È inoltre possibile specificare l'URL al quale viene inviato il modulo per eseguire i calcoli.
  9. Richiama il metodo dell’ FormsServiceClient oggetto renderPDFForm e passa i seguenti valori:
    • Una stringa che specifica il nome della struttura del modulo, inclusa l'estensione del nome file.
    • Un com.adobe.idp.Document oggetto che contiene i dati da unire al modulo (creato nel passaggio 2).
    • Un PDFFormRenderSpec oggetto che memorizza le opzioni di esecuzione. Per ulteriori informazioni, consulta Riferimento API per AEM Forms.
    • Un URLSpec oggetto che contiene valori URI richiesti dal servizio Forms per eseguire il rendering di un modulo basato su frammenti.
    • Un java.util.HashMap oggetto che memorizza gli allegati. Si tratta di un parametro facoltativo e potete specificare null se non desiderate allegare file al modulo.
    Il renderPDFForm metodo restituisce un FormsResult oggetto che contiene un flusso di dati del modulo che deve essere scritto nel browser Web del client.
  10. Creare un com.adobe.idp.Document oggetto richiamando il FormsResult metodo ‘s getOutputContent .
  11. Ottenere il tipo di contenuto dell' com.adobe.idp.Document oggetto richiamandone il getContentType metodo.
  12. Impostare il tipo di contenuto dell' javax.servlet.http.HttpServletResponse oggetto richiamandone setContentType il metodo e passando il tipo di contenuto dell' com.adobe.idp.Document oggetto.
  13. Creare un javax.servlet.ServletOutputStream oggetto utilizzato per scrivere il flusso di dati del modulo nel browser Web del client richiamando il javax.servlet.http.HttpServletResponse metodo dell' getOutputStream oggetto.
  14. Creare un java.io.InputStream oggetto richiamando il com.adobe.idp.Document metodo dell' getInputStream oggetto.
  15. Per creare un array di byte, è necessario inserirlo nel flusso di dati del modulo richiamando il InputStream read metodo dell'oggetto e passando l'array di byte come argomento.
  16. Richiamare il metodo dell' javax.servlet.ServletOutputStream oggetto write per inviare il flusso di dati del modulo al browser Web del client. Passa l'array di byte al write metodo.
L'esempio di codice seguente rappresenta il servlet Java che richiama il servizio Forms ed esegue il rendering di un modulo basato sui frammenti.
 /*
     * This Java Quick Start uses the following JAR files
     * 1. adobe-forms-client.jar
     * 2. adobe-livecycle-client.jar
     * 3. adobe-usermanager-client.jar
     *
     * (Because Forms quick starts are implemented as Java servlets, it is
     * not necessary to include J2EE specific JAR files - the Java project
     * that contains this quick start is exported as a WAR file which
     * is deployed to the J2EE application server)
     *
     * These JAR files are located in the following path:
     * <install directory>/sdk/client-libs
     *
     * For complete details about the location of these JAR files,
     * see "Including AEM Forms library files" in Programming with AEM forms
     */
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.PrintWriter;
 
 import javax.servlet.Servlet;
 import javax.servlet.ServletException;
 import javax.servlet.ServletOutputStream;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import com.adobe.livecycle.formsservice.client.*;
 import java.util.*;
 import java.io.InputStream;
 import java.net.URL;
 
 import com.adobe.idp.Document;
 import com.adobe.idp.dsc.clientsdk.ServiceClientFactory;
 import com.adobe.idp.dsc.clientsdk.ServiceClientFactoryProperties;
 
 public class RenderFormFragment extends HttpServlet implements Servlet {
 
     public void doGet(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
             doPost(req,resp);
 
     }
     public void doPost(HttpServletRequest req, HttpServletResponse resp)
     throws ServletException, IOException {
 
 
 
         try{
             //Set connection properties required to invoke AEM Forms
             Properties connectionProps = new Properties();
             connectionProps.setProperty(ServiceClientFactoryProperties.DSC_DEFAULT_SOAP_ENDPOINT, "https://'[server]:[port]'");
             connectionProps.setProperty(ServiceClientFactoryProperties.DSC_TRANSPORT_PROTOCOL,ServiceClientFactoryProperties.DSC_SOAP_PROTOCOL);
             connectionProps.setProperty(ServiceClientFactoryProperties.DSC_SERVER_TYPE, "JBoss");
             connectionProps.setProperty(ServiceClientFactoryProperties.DSC_CREDENTIAL_USERNAME, "administrator");
             connectionProps.setProperty(ServiceClientFactoryProperties.DSC_CREDENTIAL_PASSWORD, "password");
 
             //Get the value of selected radio button
             String radioValue = req.getParameter("radio");
 
             //Create an Document object to store form data
             Document oInputData = null;
 
             //The value of the radio button determines the form data to use
             //which determines which fragments used in the form
             if (radioValue.compareTo("AMERICAN") == 0)            {
                 FileInputStream myData = new FileInputStream("C:\\Adobe\Purchase Order US.xml");
                 oInputData = new Document(myData);
             }
             else if (radioValue.compareTo("CANADIAN") == 0)            {
                 FileInputStream myData = new FileInputStream("C:\\Adobe\Purchase Order Canada.xml");
                 oInputData = new Document(myData);
             }
 
             //Create a ServiceClientFactory object
             ServiceClientFactory myFactory = ServiceClientFactory.createInstance(connectionProps);
 
             //Create a FormsServiceClient object
             FormsServiceClient formsClient = new FormsServiceClient(myFactory);
 
             //Set the parameter values for the renderPDFForm method
             String formName = "Applications/FormsApplication/1.0/FormsFolder/Purchase Order Dynamic.xdp";
 
             //Cache the PDF form
             PDFFormRenderSpec pdfFormRenderSpec = new PDFFormRenderSpec();
             pdfFormRenderSpec.setCacheEnabled(new Boolean(true));
 
             //Specify URI values that are required to render a form
             //design based on fragments
             URLSpec uriValues = new URLSpec();
             uriValues.setApplicationWebRoot("https://'[server]:[port]'/RenderFormFragment");
             uriValues.setContentRootURI("repository:///");
             uriValues.setTargetURL("https://'[server]:[port]'/FormsServiceClientApp/HandleData");
 
             //Invoke the renderPDFForm method and write the
             //results to a client web browser
             FormsResult formOut = formsClient.renderPDFForm(
                         formName,               //formQuery
                         oInputData,             //inDataDoc
                         pdfFormRenderSpec,      //PDFFormRenderSpec
                         uriValues,                //urlSpec
                         null                    //attachments
                         );
 
             //Create a Document object that stores form data
             Document myData = formOut.getOutputContent();
 
             //Get the content type of the response and
             //set the HttpServletResponse object’s content type
             String contentType = myData.getContentType();
             resp.setContentType(contentType);
 
             //Create a ServletOutputStream object
             ServletOutputStream oOutput = resp.getOutputStream();
 
             //Create an InputStream object
             InputStream inputStream = myData.getInputStream();
 
             //Write the data stream to the web browser
             byte[] data = new byte[4096];
             int bytesRead = 0;
             while ((bytesRead = inputStream.read(data)) > 0)
             {
                 oOutput.write(data, 0, bytesRead);
             }
 
         }catch (Exception e) {
              System.out.println("The following exception occurred: "+e.getMessage());
       }
     }
 }

Creazione di una pagina Web

La pagina Web index.html fornisce un punto di ingresso al servlet Java e richiama il servizio Forms. Questa pagina Web è un modulo HTML di base che contiene due pulsanti di scelta e un pulsante di invio. Il nome dei pulsanti di scelta è una scelta. Quando l'utente fa clic sul pulsante di invio, i dati del modulo vengono inviati al servlet RenderFormFragment Java.
Il servlet Java acquisisce i dati inviati dalla pagina HTML utilizzando il seguente codice Java:
             Document oInputData = null;
 
             //Get the value of selected radio button
             String radioValue = req.getParameter("radio");
 
             //The value of the radio button determines the form data to use
             //which determines which fragments used in the form
             if (radioValue.compareTo("AMERICAN") == 0)            {
                 FileInputStream myData = new FileInputStream("C:\\Adobe\Purchase Order US.xml");
                 oInputData = new Document(myData);
             }
             else if (radioValue.compareTo("CANADIAN") == 0)            {
                 FileInputStream myData = new FileInputStream("C:\\Adobe\Purchase Order Canada.xml");
                 oInputData = new Document(myData);
             }

Il seguente codice HTML si trova nel file index.html creato durante l'impostazione dell'ambiente di sviluppo. Consultate Creazione di un progetto Web.
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="https://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <title>Untitled Document</title>
 </head>
 
 <body>
 <form name="myform" action="https://'[server]:[port]'/FragmentsWebApplication/RenderFormFragment" method="post">
      <table>
      <tr>
        <th>Forms Fragment Web Client</th>
      </tr>
      <tr>
        <td>
          <label>
          <input type="radio" name="radio" id="radio_Data" value="CANADIAN" />
          Canadian data<br />
          </label>
          <p>
            <label>
            <input type="radio" name="radio" id="radio_Data" value="AMERICAN" checked/>
            American data</label>
          </p>
        </td>
      </tr>
      <tr>
      <td>
        <label>
          <input type="submit" name="button_Submit" id="button_Submit" value="Submit" />
            </label>
            </td>
         </tr>
        </table>
      </form>
 </body>
 </html>

Creazione del pacchetto dell'applicazione Web

Per distribuire il servlet Java che richiama il servizio Forms, creare un pacchetto con l'applicazione Web in un file WAR. Assicurati che nel file WAR siano inclusi anche i file JAR esterni da cui dipende la logica aziendale del componente, come adobe-livecycle-client.jar e adobe-forms-client.jar.
Per creare un pacchetto di un'applicazione Web in un file WAR:
  1. Nella finestra Esplora progetti, fare clic con il pulsante destro del mouse sul FragmentsWebApplication progetto e selezionare Esporta > File ​WAR.
  2. Nella casella di testo del modulo ​Web, digitare FragmentsWebApplication il nome del progetto Java.
  3. Nella casella di testo Destinazione , digitare FragmentsWebApplication.war il nome del ​file, specificare il percorso del file WAR, quindi fare clic su Fine.

Distribuzione del file WAR nel server applicazioni J2EE

È possibile distribuire il file WAR al server applicazione J2EE su cui è distribuito AEM Forms. Dopo la distribuzione del file WAR, è possibile accedere alla pagina Web HTML utilizzando un browser Web.
Per distribuire il file WAR al server applicazione J2EE:
  • Copiare il file WAR dal percorso di esportazione a [Forms Install]\Adobe\Adobe Experience Manager Forms\jboss\server\all\deploy .

Verifica dell’applicazione Web

Dopo aver implementato l'applicazione Web, potete verificarla utilizzando un browser Web. Se si utilizza lo stesso computer in cui è installato AEM Forms, è possibile specificare il seguente URL:
  • http://localhost:8080/FragmentsWebApplication/index.html
    Selezionare un pulsante di scelta e fare clic sul pulsante Invia. Nel browser Web viene visualizzato un modulo basato sui frammenti. Se si verificano dei problemi, consultare il file di registro del server applicazione J2EE.