Erstellen von Webanwendungen, die Forms rendern

Erstellen von Webanwendungen, die Forms rendern

Sie können eine webbasierte Anwendung erstellen, die Java-Servlets verwendet, um den Forms-Dienst aufzurufen und Formulare wiederzugeben. Ein Vorteil der Verwendung eines Java™-Servlets besteht darin, dass Sie den Rückgabewert des Prozesses in einen Client-Webbrowser schreiben können. Das heißt, ein Java-Servlet kann als Link zwischen dem Forms-Dienst, der ein Formular zurückgibt, und einem Client-Webbrowser verwendet werden.

HINWEIS

In diesem Abschnitt wird beschrieben, wie Sie eine webbasierte Anwendung erstellen, die ein Java-Servlet verwendet, das den Forms-Dienst aufruft und Formulare basierend auf Fragmenten rendert. (Siehe Rendern von Forms basierend auf Fragmenten.

Mithilfe eines Java-Servlets können Sie ein Formular in einen Client-Webbrowser schreiben, damit ein Kunde Daten anzeigen und in das Formular eingeben kann. Nachdem der Webbenutzer das Formular mit Daten ausgefüllt hat, klickt er auf eine Senden-Schaltfläche im Formular, um Informationen zurück an das Java-Servlet zu senden, wo die Daten abgerufen und verarbeitet werden können. Beispielsweise können die Daten an einen anderen Prozess gesendet werden.

In diesem Abschnitt wird beschrieben, wie Sie eine webbasierte Anwendung erstellen, mit der der Benutzer entweder amerikanische oder kanadische Formulardaten auswählen kann, wie in der folgenden Abbildung dargestellt.

cw_cw_fragmentwebclient

Das Formular, das wiedergegeben wird, ist ein Formular, das auf Fragmenten basiert. Das heißt, wenn der Benutzer Amerikanische Daten auswählt, verwendet das zurückgegebene Formular Fragmente, die auf amerikanischen Daten basieren. Beispielsweise enthält die Fußzeile des Formulars eine amerikanische Adresse, wie in der folgenden Abbildung dargestellt.

cw_cw_teilformfooter

Wenn der Benutzer kanadische Daten auswählt, enthält das zurückgegebene Formular eine kanadische Adresse, wie in der folgenden Abbildung dargestellt.

cw_cw_teilformfootercnd

HINWEIS

Informationen zum Erstellen von Formularentwürfen basierend auf Fragmenten finden Sie unter Forms Designer.

Beispieldateien

In diesem Abschnitt werden Beispieldateien verwendet, die sich am folgenden Speicherort befinden können:

<Installationsordner von Forms Designer>/Samples/Forms/Purchase Order/Form Fragments

wobei <Installationsordner> ist der Installationspfad. Für die Clientanwendung wurde die Datei "Purchase Order Dynamic.xdp"aus diesem Installationsspeicherort kopiert und in eine Forms-Anwendung mit dem Namen Anwendungen/FormsApplication. Die Datei "Purchase Order Dynamic.xdp"wird in einem Ordner mit dem Namen "FormsFolder"abgelegt. Ebenso werden die Fragmente in dem Ordner Fragments platziert, wie in der folgenden Abbildung dargestellt.

cw_cw_fragmentsrepository

Um auf den Formularentwurf "Purchase Order Dynamic.xdp"zuzugreifen, geben Sie Applications/FormsApplication/1.0/FormsFolder/Purchase Order Dynamic.xdp als Formularname (der erste Parameter, der an die renderPDFForm Methode) und repository:/// als Inhaltsstamm-URI-Wert.

Die von der Webanwendung verwendeten XML-Datendateien wurden aus dem Ordner "Data"in C:\Adobe(das Dateisystem, das zum J2EE-Anwendungsserver gehört, der als Host für AEM Forms dient). Die Dateinamen sind "Bestellung". Canada.xml und Bestellung US.xml.

HINWEIS

Informationen zum Erstellen einer Forms-Anwendung mit Workbench finden Sie unter Workbench-Hilfe.

Zusammenfassung der Schritte

Um eine webbasierte Anwendung zu erstellen, die Formulare basierend auf Fragmenten wiedergibt, führen Sie die folgenden Schritte aus:

  1. Erstellen Sie ein neues Webprojekt.
  2. Erstellen Sie eine Java-Anwendungslogik, die das Java-Servlet darstellt.
  3. Erstellen Sie die Webseite für die Webanwendung.
  4. Verpacken Sie die Webanwendung in eine WAR-Datei.
  5. Stellen Sie die WAR-Datei auf dem J2EE-Anwendungsserver bereit.
  6. Testen Sie Ihre Webanwendung.
HINWEIS

Einige dieser Schritte hängen von der J2EE-Anwendung ab, auf der AEM Forms bereitgestellt wird. Die Methode zum Bereitstellen einer WAR-Datei hängt beispielsweise von dem verwendeten J2EE-Anwendungsserver ab. In diesem Abschnitt wird davon ausgegangen, dass AEM Forms auf JBoss® bereitgestellt wird.

Webprojekt erstellen

Der erste Schritt zum Erstellen einer Webanwendung, die ein Java-Servlet enthält, das den Forms-Dienst aufrufen kann, besteht darin, ein neues Webprojekt zu erstellen. Die Java-IDE, auf der dieses Dokument basiert, ist Eclipse 3.3. Erstellen Sie mit der Eclipse IDE ein Webprojekt und fügen Sie die erforderlichen JAR-Dateien zu Ihrem Projekt hinzu. Fügen Sie abschließend eine HTML-Seite mit dem Namen index.html und ein Java-Servlet zu Ihrem Projekt hinzufügen.

In der folgenden Liste sind die JAR-Dateien aufgeführt, die Sie Ihrem Webprojekt hinzufügen müssen:

  • adobe-forms-client.jar
  • adobe-livecycle-client.jar
  • adobe-usermanager-client.jar
  • adobe-utilities.jar

Informationen zum Speicherort dieser JAR-Dateien finden Sie unter Einschließen von AEM Forms-Java-Bibliotheksdateien.

So erstellen Sie ein Webprojekt:

  1. Starten Sie Eclipse und klicken Sie auf Datei > Neues Projekt.
  2. Im Neues Projekt Dialogfeld auswählen Web > Dynamisches Webprojekt.
  3. Typ FragmentsWebApplication für den Namen Ihres Projekts klicken Sie auf Beenden.

So fügen Sie erforderliche JAR-Dateien zu Ihrem Projekt hinzu:

  1. Klicken Sie im Projekt-Explorer-Fenster mit der rechten Maustaste auf das FragmentsWebApplication Projekt und wählen Sie Eigenschaften.
  2. Klicken Java-Build-Pfad und klicken Sie dann auf Bibliotheken Registerkarte.
  3. Klicken Sie auf Externe JARs hinzufügen und navigieren Sie zu den einzuschließenden JAR-Dateien.

So fügen Sie Ihrem Projekt ein Java-Servlet hinzu:

  1. Klicken Sie im Projekt-Explorer-Fenster mit der rechten Maustaste auf das FragmentsWebApplication Projekt und wählen Sie Neu > Sonstiges.
  2. Erweitern Sie die Web Ordner, wählen Sie Servlet und klicken Sie anschließend auf Nächste.
  3. Geben Sie im Dialogfeld "Servlet erstellen"Folgendes ein: RenderFormFragment für den Namen des Servlets und klicken Sie dann auf Beenden.

So fügen Sie Ihrem Projekt eine HTML-Seite hinzu:

  1. Klicken Sie im Projekt-Explorer-Fenster mit der rechten Maustaste auf das FragmentsWebApplication Projekt und wählen Sie Neu > Sonstiges.
  2. Erweitern Sie die Web Ordner, wählen Sie HTML und klicken Sie auf Nächste.
  3. Geben Sie im Dialogfeld "Neue HTML"ein. index.html für den Dateinamen ein und klicken Sie dann auf Beenden.
HINWEIS

Informationen zum Erstellen der HTML-Seite, die die RenderFormFragment Java-Servlet, siehe Webseiten erstellen.

Java-Anwendungslogik für das Servlet erstellen

Sie erstellen eine Java-Anwendungslogik, die den Forms-Dienst vom Java-Servlet aus aufruft. Der folgende Code zeigt die Syntax der RenderFormFragment Java-Servlet:

     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 
             }

Normalerweise platzieren Sie keinen Client-Code in einem Java-Servlet doGet oder doPost -Methode. Eine bessere Programmierungspraxis besteht darin, diesen Code in einer separaten Klasse zu platzieren und die -Klasse aus der im doPost -Methode oder doGet -Methode) und rufen Sie die entsprechenden Methoden auf. Die Codebeispiele in diesem Abschnitt werden jedoch für die Codereihenfolge auf ein Minimum beschränkt und Codebeispiele werden im doPost -Methode.

Führen Sie die folgenden Aufgaben aus, um ein Formular basierend auf Fragmenten mithilfe der Forms-Dienst-API wiederzugeben:

  1. Schließen Sie Client-JAR-Dateien wie adobe-forms-client.jar in den Klassenpfad Ihres Java-Projekts ein. Weitere Informationen über den Speicherort dieser Dateien finden Sie unter Einbeziehung von AEM Forms Java-Bibliotheksdateien.

  2. Rufen Sie den Wert des Radiobuttons ab, der vom HTML-Formular gesendet wird, und geben Sie an, ob amerikanische oder kanadische Daten verwendet werden sollen. Wenn American gesendet wird, erstellen Sie eine com.adobe.idp.Document , das Daten speichert, die sich im Purchase Order US.xml. Erstellen Sie auf die gleiche Weise, wenn Kanadier, eine com.adobe.idp.Document , das Daten speichert, die sich im Purchase Order Canada.xml -Datei.

  3. Erstellen Sie ein ServiceClientFactory-" -Objekt, das Verbindungseigenschaften enthält. (Siehe Einstellung von Verbindungseigenschaften.)

  4. Erstellen Sie eine FormsServiceClient -Objekt durch Verwendung seines Konstruktors und Übergabe des ServiceClientFactory -Objekt.

  5. Erstellen Sie eine URLSpec -Objekt, das URI-Werte mithilfe seines Konstruktors speichert.

  6. Rufen Sie die URLSpec -Objekt setApplicationWebRoot -Methode verwenden und einen string -Wert übergeben, der den Webstamm der Anwendung darstellt.

  7. Rufen Sie die URLSpec -Objekt setContentRootURI -Methode verwenden und einen string -Wert übergeben, der den Inhaltsstamm-URI-Wert angibt. Stellen Sie sicher, dass sich der Formularentwurf und die Fragmente im Inhaltsstamm-URI befinden. Andernfalls gibt der Forms-Dienst eine Ausnahme aus. Um auf das AEM Forms-Repository zu verweisen, geben Sie repository://.

  8. Rufen Sie die URLSpec -Objekt setTargetURL -Methode verwenden und einen Zeichenfolgenwert übergeben, der den Ziel-URL-Wert angibt, an den die Formulardaten gesendet werden. Wenn Sie die Ziel-URL im Formularentwurf definieren, können Sie eine leere Zeichenfolge übergeben. Sie können auch die URL angeben, an die ein Formular gesendet wird, um Berechnungen durchzuführen.

  9. Rufen Sie die FormsServiceClient -Objekt renderPDFForm -Methode verwenden und die folgenden Werte übergeben:

    • Ein string -Wert, der den Namen des Formularentwurfs einschließlich der Dateinamenerweiterung angibt.
    • A com.adobe.idp.Document -Objekt, das Daten enthält, die mit dem Formular zusammengeführt werden sollen (erstellt in Schritt 2).
    • A PDFFormRenderSpec -Objekt, das Laufzeitoptionen speichert. Weitere Informationen finden Sie unter AEM Forms API-Referenz.
    • A URLSpec -Objekt, das URI-Werte enthält, die der Forms-Dienst zum Rendern eines Formulars basierend auf Fragmenten benötigt.
    • A java.util.HashMap -Objekt, das Dateianlagen speichert. Dies ist ein optionaler Parameter, den Sie null , wenn Sie keine Dateien an das Formular anhängen möchten.

    Die renderPDFForm -Methode gibt eine FormsResult -Objekt, das einen Formulardatenstrom enthält, der in den Client-Webbrowser geschrieben werden muss.

  10. Erstellen Sie eine com.adobe.idp.Document -Objekt durch Aufrufen der FormsResult object ‘s getOutputContent -Methode.

  11. Abrufen des Inhaltstyps der com.adobe.idp.Document -Objekt durch Aufrufen seiner getContentType -Methode.

  12. Legen Sie die javax.servlet.http.HttpServletResponse Inhaltstyp des Objekts durch Aufrufen seiner setContentType -Methode und Übergabe des Inhaltstyps der com.adobe.idp.Document -Objekt.

  13. Erstellen Sie eine javax.servlet.ServletOutputStream -Objekt, das zum Schreiben des Formulardaten-Streams in den Client-Webbrowser durch Aufrufen der javax.servlet.http.HttpServletResponse -Objekt getOutputStream -Methode.

  14. Erstellen Sie eine java.io.InputStream -Objekt durch Aufrufen der com.adobe.idp.Document -Objekt getInputStream -Methode.

  15. Erstellen Sie ein Byte-Array, das mit dem Formulardatenstream gefüllt wird, indem Sie die InputStream -Objekt read-Methode verwenden und das Byte-Array als Argument übergeben.

  16. Rufen Sie die javax.servlet.ServletOutputStream -Objekt write -Methode zum Senden des Formulardaten-Streams an den Client-Webbrowser. Übergeben Sie das Byte-Array an die write -Methode.

Das folgende Codebeispiel stellt das Java-Servlet dar, das den Forms-Dienst aufruft und ein Formular basierend auf Fragmenten rendert.

 /* 
     * 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()); 
       } 
     } 
 }

Webseiten erstellen

Die Webseite index.html bietet einen Einstiegspunkt zum Java-Servlet und ruft den Forms-Dienst auf. Diese Webseite ist ein einfaches HTML-Formular mit zwei Optionsfeldern und einer Senden-Schaltfläche. Der Name der Optionsfelder ist radio. Wenn der Benutzer auf die Senden-Schaltfläche klickt, werden die Formulardaten an die RenderFormFragment Java-Servlet.

Das Java-Servlet erfasst die von der HTML-Seite veröffentlichten Daten mithilfe des folgenden Java-Codes:

             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);  
             }

Der folgende HTML-Code befindet sich in der Datei index.html , die beim Einrichten der Entwicklungsumgebung erstellt wurde. (Siehe Webprojekt erstellen.

 <!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>

Verpacken der Webanwendung

Um das Java-Servlet bereitzustellen, das den Forms-Dienst aufruft, verpacken Sie Ihre Webanwendung in eine WAR-Datei. Stellen Sie sicher, dass externe JAR-Dateien, von denen die Geschäftslogik der Komponente abhängig ist, wie adobe-livecycle-client.jar und adobe-forms-client.jar, ebenfalls in der WAR-Datei enthalten sind.

So packen Sie eine Webanwendung in eine WAR-Datei:

  1. Aus dem Projekt-Explorer Fenster, klicken Sie mit der rechten Maustaste auf die FragmentsWebApplication Projekt und wählen Sie Export > WAR-Datei.
  2. Im Webmodul Textfeld, Typ FragmentsWebApplication für den Namen des Java-Projekts.
  3. Im Ziel Textfeld, Typ FragmentsWebApplication.warfür Dateinamen, geben Sie den Speicherort für Ihre WAR-Datei an und klicken Sie auf "Fertig stellen".

Bereitstellen der WAR-Datei auf dem J2EE-Anwendungsserver

Sie können die WAR-Datei auf dem J2EE-Anwendungsserver bereitstellen, auf dem AEM Forms bereitgestellt wird. Nachdem die WAR-Datei bereitgestellt wurde, können Sie über einen Webbrowser auf die HTML-Webseite zugreifen.

So stellen Sie die WAR-Datei auf dem J2EE-Anwendungsserver bereit:

  • Kopieren Sie die WAR-Datei aus dem Exportpfad in [Forms-Installation]\Adobe\Adobe Experience Manager Forms\jboss\server\all\deploy.

Webanwendung testen

Nach der Bereitstellung der Webanwendung können Sie sie mithilfe eines Webbrowsers testen. Wenn Sie denselben Computer verwenden, auf dem AEM Forms gehostet wird, können Sie die folgende URL angeben:

  • http://localhost:8080/FragmentsWebApplication/index.html

    Wählen Sie ein Optionsfeld aus und klicken Sie auf die Schaltfläche Senden . Ein Formular, das auf Fragmenten basiert, wird im Webbrowser angezeigt. Wenn Probleme auftreten, lesen Sie die Protokolldatei des J2EE-Anwendungsservers.

Auf dieser Seite