# Java Embedding API ## Availability * \[SINCE Orbeon Forms 4.7] * The Form Runner Java Embedding API is a PE feature. ## Rationale The intent is to allow Java (and other Java Virtual Machine (JVM)-based languages) applications to easily embed forms produced with Form Builder within other pages. ![A form embedded in a simple page with a top banner](https://4129616727-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LEkBiSDvlXs3VWiO0Zu%2F-LEkBmMpnaxnftLGDglW%2F-LEkC2sZKyIhujH1O-kH%2Fembedding-bookshelf.png?generation=1528743354922987\&alt=media) ## Configuration ### Basic configuration #### Your web application Your own web app does the following: 1. Include `orbeon-embedding.jar` and `slf4j-api-1.7.7.jar` under `WEB-INF/lib`. Both are included in `orbeon-embedding.war` which ships\ with Orbeon Professional Edition (PE) only. 2. Setup the filter in your `web.xml` per the snippet below. 3. Call the embedding API when producing a page, as done in the example below. The page you do the embedding from must: 1. Start with ``, so your page is in [full standards mode](https://developer.mozilla.org/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode). Without this, you will notice that some CSS fails to apply as it should. 2. Use the UTF-8 character encoding for the HTML response.\ This is a typical filter configuration: ```xml orbeon-form-runner-filter org.orbeon.oxf.fr.embedding.servlet.ServletFilter form-runner-url http://localhost:8080/orbeon orbeon-prefix /orbeon orbeon-form-runner-filter *.jsp REQUEST FORWARD orbeon-form-runner-filter /orbeon/* REQUEST FORWARD ``` [\[SINCE Orbeon Forms 2023.1\]](https://doc.orbeon.com/release-notes/orbeon-forms-2023.1) If you are using Orbeon Forms 2023.1 or newer, and are running a servlet container that uses the Jakarta Servlet API (e.g. Tomcat 10+, WildFly 27+), you need to use the `org.orbeon.oxf.fr.embedding.servlet.JakartaServletFilter` servlet filter class instead of `org.orbeon.oxf.fr.embedding.servlet.ServletFilter`. And here is an example of embedding a form from a JSP page: ```jsp <%@ page pageEncoding="utf-8" contentType="text/html; charset=UTF-8" import="org.orbeon.oxf.fr.embedding.servlet.API" %> <% API.embedFormJava( request, // HttpServletRequest: incoming HttpServletRequest out, // Writer: where the embedded form is written "my-application", // String: Form Runner app name "my-form", // String: Form Runner form name "new", // String: Form Runner mode (`new`, `edit`, `view`) null, // String: Form Runner document id (optional) null, // String: query string (optional) null // Map: custom HTTP headers (optional) ); %> ``` The `Map` allows passing a Java `Map` of HTTP header name/value pairs. These are passed to Form Runner when loading a form. Form Runner can access HTTP headers using the [`xxf:get-request-header()` XPath function](https://doc.orbeon.com/xforms/xpath/extension-functions/extension-http#xxfget-request-header). [\[SINCE Orbeon Forms 2023.1\]](https://doc.orbeon.com/release-notes/orbeon-forms-2023.1) The `request` parameter can be either of type `javax.servlet.http.HttpServletRequest` or of type `jakarta.servlet.http.HttpServletRequest`. #### Form Runner configuration You deploy Form Runner in a separate web app, which can be located in the same servlet container as your web app or in a separate or even remote servlet container. Form runner must use "combined resources" to work. This is the case by default in `prod` mode (see [Run Modes](https://doc.orbeon.com/configuration/advanced/run-modes)), but if you happen to have setup Orbeon Forms in `dev` mode, make sure to add this property in your `properties-local.xml`: ```xml ``` ### Passing information about the current user You can pass information about the current user to Orbeon Forms through headers. For this: 1. Enable header-based authentication by editing the `properties-local.xml` in your Orbeon Forms web app, adding: ```xml ``` 2. \[SINCE Orbeon Forms 2020.1] You need to enable [sticky authentication headers](https://doc.orbeon.com/access-control/users#when-to-set-the-headers), adding: ```xml ``` 3. Back to your web app, pass the current user's username as the value of the `My-Username-Header` header, through a map you provide as the last argument to your call to `API.embedFormJava()`: ```java Map headers = new HashMap(); headers.put("My-Username-Header", request.getRemoteUser()); API.embedFormJava(…, headers); ``` If needed, you can also [pass the user's roles and group through additional headers](https://doc.orbeon.com/access-control/users#if-using-individual-headers). ### Logging configuration The embedding JAR uses SLF4J for logging. If your application already uses SLF4J and already has slf4j-api.jar, you can remove the one provided by Orbeon under `WEB-INF/lib`. Otherwise, you must keep slf4j-api.jar in your application's `WEB-INF/lib` folder. Optionally, and in addition, if you want to actually configure logging for the embedding library, you must add a logging adapter for SLF4j and the appropriate configuration file, for example for log4j. See the sample configuration file under `WEB-INF/classes/log4j.properties.template`. Here are example JAR files which work with Orbeon Forms 2018.2: * `slf4j-log4j12-1.7.25.jar` * `log4j-1.2.17.jar` ### HTTP client configuration The embedding implementation communicates with the rest of Orbeon Forms via HTTP or HTTPS. In general, you probably won't have to change this configuration. By default, it is as follows: ```xml oxf.http.stale-checking-enabled true oxf.http.so-timeout 0 oxf.http.chunk-requests false oxf.http.proxy.host oxf.http.proxy.port oxf.http.proxy.exclude oxf.http.ssl.hostname-verifier strict oxf.http.ssl.keystore.uri oxf.http.ssl.keystore.password oxf.http.proxy.use-ssl false oxf.http.proxy.username oxf.http.proxy.password oxf.http.proxy.ntlm.host oxf.http.proxy.ntlm.domain oxf.http.expired-connections-polling-delay 5000 oxf.http.idle-connections-delay 30000 ``` Details about the meaning of these parameters are [available here](https://doc.orbeon.com/configuration/properties/general). ### HTTP server configuration You can enable HTTP gzip compression between the embedding implementation and Form Runner. For example, with Tomcat: ```xml ``` ## Usage scenarios In your Java web application, any page covered by the servlet filter can call the embedding API. You can have a single page calling a single form, or several pages each calling a different form. Or, pages can (based on URL parameters, internal application state, etc.), embed a form dynamically. The embedded form cannot navigate in place to another form or mode (such as Review). However, it can save form or send form data as it does in the standalone case. It can also run custom [processes](https://doc.orbeon.com/form-runner/advanced/buttons-and-processes) which can redirect the entire embedding page with `navigate`, or run JavaScript functions with `navigate(uri = "javascript:alert('Done!')")`. This allows communicating with the embedding application. ## Form Builder embedding \[SINCE Orbeon Forms 2016.3] In addition to published forms, you can embed Form Builder: just use `orbeon` and `builder` as Form Runner app/form names. The embedding application can set the size the embedded Form Builder `
` element via CSS or JavaScript, and Form Builder will adjust its size accordingly: ```html