Skip navigation links
SOAFaces API

SOAFaces 2.6.24

The SOAFaces Framework is a set of APIs and Specifications to enable the development, packaging, deployment, and execution of server-side and client-side AJAX and SOA powered software.

See: Description

Packages 
Package Description
org.soafaces.bundle.client.rpc
GWT client classes for handling RPC between GWT client and backend services.
org.soafaces.bundle.client.rpc.impl
Internal package used by SOAFaces container to interface with backend RPC - NOT to be used directly by application developers.
org.soafaces.bundle.client.ui
Widgets for building GWT GUI bundles/components.
org.soafaces.bundle.container
Container management classes used by SOAFaces server environment.
org.soafaces.bundle.workflow
Package for building server-side batch jobs and tasklets allowing jobs can be scheduled, run on demand, or triggered to run on events.
org.soafaces.services.annotation
Annotation class for marking POJO services that can be called using UniversalClient API.
org.soafaces.services.client.rpc
GWT client classes for using UniversalClient API to make RPC calls to backend services.
org.soafaces.services.rpc
Servlet classes that handle RPC calls to Mule endpoint services and other types of services endpoints.
org.soafaces.services.util
Utility classes used by backend services.

The SOAFaces Framework is a set of APIs and Specifications to enable the development, packaging, deployment, and execution of server-side and client-side AJAX and SOA powered software.

Overview

The goal is of this framework is to have the API as minimal as possible while allowing for modular and reusable Java software component development. These client and server-side Java components are referred to as SOAFaces Bundles (Bundles or sometimes called SFBs).

The essential building blocks of SOAFaces are the Tasklet and the Weblet interfaces. A SOAFaces component (Bundle) can be composed of one or both of these elements. The tasklet provides the API for implementing and executing back-end Java code and services when used in a job. The Weblet provides the abstraction for building AJAX web GUIs. These GUIs can be deployed as complete applications or can be used as JavaBean customizers. These GUI customizers can be used to customize the inputs and outputs of server-side Tasklets.

SOAFaces provides convenient access to Mule services and can easily be embedded within Mule containers and can be used to interface and communicate with remote and local Mule services and providers. SOAFaces also leverages the GWT framework which serves as the basis for its web GUI API.

You can use the SOAFaces API to build modular components such as Tasklets and Weblets. These can be deployed as Jobs/Workflows or as Web Applications. You can also use SOAFaces Bundles in your existing GWT client applications by using the UniversalClient Services API discussed below. This API can give your existing GWT applications a real SOA boost! Check the API in the org.soafaces.services package for more details as well. This package contains the API to allow your GWT applications to make SOA calls and pass JSON and POJO objects with no RPC complexity. The UniversalClient interface functions as a universal SOA interface to virtually any server-side endpoint and can be used from your existing GWT client applications.

Weblets

Weblets are the main abstraction for building end user GUIs for SOAFaces. A Weblet enabled web application can be published and presented to users and hosted in a web application server. Also, the requirement is that Weblet powered applications can be deployed and loaded dynamically within their hosting container, without requiring server restarts. The GUI and server code that makes up a Bundle is packaged in a JAR file with an extension of ".sfb".

With Weblets, you have the full power of the GWT API at your disposal. The Weblet API itself is nothing more than a GWT Composite widget that can contain any standard GWT UI you drop into it. It functions as the top level UI container for your application, mashup, property editor, or any other UI component you drop into it. What is especially nice about Weblets, is that you can just compile your GWT Java classes and include them in a JAR file (based on the SOAFaces specification) and the container will handle compiling your GWT Java code into ajax/javascript. Sort of similar to how a j2ee server complies JSP pages on the fly. Cool don't you think! So develop your components in GWT and drop them into a SOAFaces container and go!

There are two main GWT modules you can use when building your Weblet. They are the:

The Bundle GWT module provides you with the GWT UI and RPC classes for building Weblets. The Services GWT module references the GWT classes necessary for making SOA calls from your GWT client.

Tasklets

A Tasklet is a simple way to create any arbitrary server-side java code and runs in a container that supports the SOAFaces API. The inputs and outputs of a Tasklet are defined as JavaBeans. A Tasklet consumes a JavaBean as input and returns a JavaBean as output. These input and output JavaBeans can also have GUI customizers/viewers that can edit and render the contents of the input/output JavaBeans for the Tasklet. The Weblet API can be used to render the GUI for the customizers/viewers. Multiple Tasklets can then be composed and packaged together into back-end workflows and executed on timers or schedules, for example.

The specification defines a life cycle for the execution of one or more Tasklets that are chained together to execute in a single job. Individual Tasklets can pass JavaBeans to each other during the execution of the workflow (a chain of Tasklets). The output JavaBean of one Tasklet can serve as the input to the next Tasklet in the chain. This is done through a mapping specification to allow the end user the ability to pick and choose which properties of one particular output JavaBean get mapped to which corresponding properties of another input JavaBean. This is a very powerful feature, it allows end users to customize behavior using a simple point and click GUI.

Bundles get run within a SOAFaces container. A container can be anything from a simple desktop application to a complex server side engine. For more information visit the SOAFaces Project. Also visit the SOAFaces sub project BeanSoup to see example Bundles. BeanSoup is an open source collection of components that are based on the SOAFaces API. SOAFaces components span the range from simple email notification components to a unix/dos shell script batch job launchers.

UniversalClient Services and Messaging API

The UniversalClient API allows a GWT application to send SOA messages using a simple API that is similar to the MuleClient API from Mule. The API gives a GWT application the ability to send and receive JSON and POJO objects and invoke services on Mule endpoints and to access POJO services available directly in the servlet container.

This API is a subset of the full SOAFaces API. It is also useful for standalone GWT applications that wish to use the UniversalClient interface to access Mule and other SOA services directly from the browser.

To use the UniversalClient Services API in your Weblet or in any GWT client application, you will need to include the module name:

The Services GWT module references the GWT classes necessary for making SOA calls from your GWT client.

Skip navigation links
SOAFaces API

Copyright © Grand Logic, Inc. All Rights Reserved.