This page contains definitions of terms commonly used when
discussing Portlet Factory. Feel free to add definitions of any terms you
think are important to understand.
Builders are software automation components that capture
design intelligence and automate the creation of code.
Similar to customizable robots in an assembly line, builders
perform specific software automation tasks, based upon inputs or parameters
specified by developers. WebSphere Portlet Factory software includes more
than 120 builders that automate a wide range of tasks, such as creating
HTML from a schema or integrating with common back-end systems - for example,
IBM Lotus® Domino® software, SAP, or Siebel databases.
Builders have easy-to-use, wizard-like user interfaces,
that make it both fast and easy to develop portlets. Builders, however,
are much more powerful than wizards, because builders can be used iteratively
throughout the entire development process. You can always go back and change
a builder's input values and have the entire portlet application update
Behind the scenes, a builder is made up of a Java class
that performs the appropriate automation task (for example, creating the
JSP for the button) and an XML document that defines the builder characteristics.
A BuilderCall is the invocation of a Builder, for a specific
use in a specific Model. Consider that the Button Builder puts a Button
for a Button puts the "Click Me" button on the Page "page1"
"ButtonSample." (These were just made up – don't go looking
WebSphere Portlet Factory Designer tool plugs seamlessly
into Rational Application Developer 6 and the Eclipse family of IDEs.
A model is simply the container that holds the ordered
list of builder calls.
Typically, when a developer wants to create a new portlet,
the developer creates a new model and then adds the appropriate builders
to the model.
A profile contains a set of parameters that vary the way
an application behaves. A profile feeds values into a builder based on
user identity or other contextual information (such as language). Using
profiles, you can automatically generate different variations of a portlet
(from the same model) for different users, customers or situations.
A Profile Entry is a single potential value (or a single
column) in a particular Profile Set. For example, suppose a particular
Profile Set caled "StudentType" has two profiles in it "Jock"
and "Nerd." There might be a Profile Entry called "ShowAdvancedInfoColumn."
The value for this entry would be "false" for the Jock profile,
and "true" for the Nerd profile. In a Model, there might be a
Visibility Setter Builder which depends on the value of this Profile Entry.
A collection of Profiles, such that each Profile will have
a value for each Profile Entry.
When a model is regenerated, each builder in the model
executes in sequence and creates pieces of your portlet, such as JSPs or
Java methods. During regeneration, profiles can feed different inputs to
builders based on the user or situation, automatically creating custom
portlets on the fly. Regeneration is similar to the process of recalculating
a spreadsheet, the difference being that WebSphere Portlet Factory software
regenerates the portlet code, rather than a set of numbers.
The WebApp (Web application) is a profile-specific instance
of a portlet application that is dynamically created by the WebSphere Portlet
Factory regeneration engine. Each builder, when called during regeneration,
creates the artifacts that make up this WebApp or run-time portlet application,
such as pages, forms, variables, Java Objects and methods. The regeneration
engine creates the WebApp by regenerating a model with a unique instance
of profile data. The generated WebApp code is then processed by the WebSphere
Portal Factory execution engine to instantiate the executable J2EE application
WebSphere Application Server
WebSphere Portlet Factory software leverages the WebSphere
Application Server HTTP stack, as well as all of the services from the
application server, such as clustering, failover, J2EE security and session
Portlets created with WebSphere Portlet Factory Designer
tool automatically plug into WebSphere Portal software via the IBM WebSphere
Portlet Adapter component. This is a standard portlet Web archive (WAR)
file that includes the WebSphere Portlet Factory classes (Java ARchive
[JAR] files). When a request comes in from the portal, the WebSphere Portlet
Adapter component invokes the WebSphere Portlet Factory code at the layer
below the servlet layer (the WebAppRunner class).