A JSF page can host a Flex application, but they remain separate UI layers: JSF renders the page, while the page’s HTML wrapper embeds the Flex runtime. Use that wrapper for initialization values and JavaScript communication; use BlazeDS or HTTP services when the Flex client needs Java back-end functionality. There is no standardized JSF-to-Flex bridge established by the documentation cited here.
How JSF and Flex fit together
Think of the integration as two boundaries rather than one shared component model. A JSF view generates the surrounding page. That page’s HTML wrapper embeds the Flex application and can coordinate with it in the browser. The Flex application, in turn, communicates with server-side Java through a remoting broker or HTTP endpoints.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Core JavaServer Faces (Sun Core Series) | $7.22 | Buy on Amazon |
| 2 |
|
JavaServer Faces 2.0, The Complete Reference | $43.87 | Buy on Amazon |
| 3 |
|
Core JavaServer Faces | $19.99 | Buy on Amazon |
| 4 |
|
JavaServer Faces: Introduction by Example | $37.99 | Buy on Amazon |
| 5 |
|
Mastering JavaServer Faces (Java) | $36.17 | Buy on Amazon |
This distinction helps locate problems: page rendering and reusable JSF markup belong to JSF; initialization and page-to-application interaction belong to the wrapper; service requests belong to the client/server interface.
Pass values and communicate through the HTML wrapper
Apache Flex documents several ways to supply values or communicate between a Flex application and its host page, including flashVars, query-string parameters, navigateToURL(), ExternalInterface, and SharedObjects. For calls between the Flex application and the wrapper’s scripting language, ExternalInterface is the key bridge. Apache Flex: Using Flex in an HTML page
#1 Best Overall
Choose the mechanism according to the interaction: parameters are useful for values needed at startup, while a scripting interface is appropriate when the page and Flex app must call one another after loading. Plan the call direction, data representation, and timing around the application’s lifecycle. Verify that the browser/runtime combination and its security policies support the mechanism in the actual deployment.
Choose how Flex reaches Java services
The wrapper bridge is for interaction inside the browser page. It does not replace the server communication layer. Two documented approaches for a Flex client to reach Java functionality are BlazeDS remoting and HTTP requests to REST endpoints.
Rank #2
- New
- Mint Condition
- Dispatch same day for order received before 12 noon
- Guaranteed packaging
- No quibbles returns
| Pattern | What crosses the boundary | Useful when | Evaluate |
|---|---|---|---|
| Host-page bridge | Initialization parameters and JavaScript calls through ExternalInterface |
The Flex UI needs to coordinate with the surrounding page | Call direction, serialization, lifecycle timing, browser/runtime support, and security policy |
| BlazeDS remoting | Flex client requests to Java services through a message broker | An application already uses AMF/BlazeDS | Existing server configuration, supported runtime, authentication and security, and coupling to legacy client APIs |
| HTTP/REST service | Flex HTTPService requests to HTTP endpoints, such as Spring MVC resources |
The application already exposes HTTP resources or serves multiple client types | Payload format, endpoint security, versioning, and reuse by other clients |
Apache describes BlazeDS as Java remoting and web messaging. Spring BlazeDS Integration connected that broker model to Spring by making the BlazeDS MessageBroker a Spring-managed object. A separate documented hybrid pattern uses a Flex client’s HTTPService to consume REST endpoints served by Spring MVC. Apache Flex: BlazeDS Spring BlazeDS Integration 1.0.3 reference guide Spring BlazeDS Integration: REST support
These are architectural choices, not performance rankings. Prefer the interface that fits the existing service contract, client needs, security model, and ability to maintain the legacy application.
Rank #3
Where JSF composite components help—and where they do not
JSF’s component model remains independent of the Flex runtime. The JSF 2.3 specification describes custom components built with component classes, renderers, registration, and tag handlers. It also defines composite components: reusable JSF components assembled from Facelet markup in a resource library. JSF 2.3 specification
A composite component can help package reusable page markup around the area that hosts a Flex object. It does not, by itself, provide a Flex communication bridge or turn the embedded application into a JSF component. The reviewed documentation does not identify a standardized JSF-to-Flex bridge component.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Check legacy versions and deployment compatibility
Flex and BlazeDS version references are historical context, not a guarantee that a particular application will run in a present-day browser. Apache Flex’s “Using Flex” page lists Flex SDK 4.16.1 (November 2017), FlexJS SDK 0.8.0 (June 2017), and BlazeDS 4.8.0 (April 2023). The Apache Flex BlazeDS repository describes BlazeDS 5.0.0 as an update to earlier releases and says it is compatible with most code written for Flex 4.6; that project-level statement is not an application-specific compatibility guarantee. Apache Flex: Using Flex Apache Flex BlazeDS repository
The Spring BlazeDS Integration 1.0.3 guide, dated March 2010, lists Java 5 or higher, Spring 2.5.6 or higher, and BlazeDS 3.2 or higher for that guide’s version. These are historical, version-specific requirements; do not treat them as current platform recommendations. Spring BlazeDS Integration 1.0.3 reference guide
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
Best Value
- Identify the exact Flex SDK, BlazeDS, Java, Spring, and JSF versions used by the application.
- Test the exact browser/runtime and deployment configuration; the cited sources do not establish a current browser support matrix for an arbitrary legacy Flex application.
- Check the security and authentication behavior at both boundaries: wrapper-to-Flex calls and Flex-to-service requests.
- Confirm that startup parameters, service payloads, and error handling match the contracts the application actually implements.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
