JavaScript may be used to modify the visual styles of this document for viewing in different browsers. However, this does not affect the content of the document.

Welcome to the UIX Technologies Quick Tour!

Companies creating e-business applications face tremendous challenges adapting to rapid development cycles and robust infrastructure requirements that Internet application development demands.

The ability to design and implement high-quality, professional web applications faster than before gives companies a competitive advantage in a market that is constantly facing changing requirements.

Based on the latest standards of J2EE and XML, UIX is designed to give both user interface designers and application developers an extensible framework for building scalable web applications with a consistent look and feel. Using UIX, you can develop any kind of page-based application for desktop and mobile devices.

Browse through the Quick Tour to learn more about UIX components and features.

Contents of Quick Tour

• Introduction
  • What Is UIX?
  • Benefits
  • Architecture
  • Who Can Use
  • How to Use
  • Summary

• Basics
  • Page
  • User Interface Nodes
  • Page Flows and Events
  • uiXML Page
  • Localization and Customization
  • Summary

• UI Design
  • Introduction - UI Design
  • Types of UI Components
  • Typical Page Layouts
  • Design-Time Tools
  • Reusable Design Pages
  • Mobile User Interfaces
  • Summary

• Application Development
  • Introduction - Application Development
  • Declarative Development
  • Which UIX Features to Use?
  • JDeveloper Integration
  • XML Editor
  • Visual Editor
  • BC4J UIX Applications
  • UIX and Struts
  • UIX JSP Applications
  • Deployment Environments
  • Summary

• Next Steps
  • UIX Demos
  • UIX Examples
  • UIX Documentation

Introduction

What Is UIX Technologies?

UIX Technologies (or UIX) is an open framework for building J2EE-compliant web applications.

UIX includes Java class libraries, APIs, parsers, and other software for creating web applications with page-based navigation, such as an online shopping application.

Although UIX is server-based and implemented in the Java programming language, Java is not required on the client. All you need to view a UIX application is a browser. UIX supports a variety of clients, including HTML-compliant browsers and mobile devices.

You can use UIX to develop the entire application or different aspects of an application based on the Model-View-Controller Model 2 design pattern. The core pieces of UIX are the user interface components, which are designed for building the user presentation layer (View) of an application. UIX also provides the Controller portion for organizing individual pages into an application, enabling you to define how pages flow when a user interacts with the application.

Benefits of Using UIX

• Standards. UIX is based on the latest J2EE and XML standards. You can seamlessly integrate UIX pages with Apache Struts applications. Support for JavaServer Faces, an upcoming Java standard for building web application user interfaces, will be added in a future release.

• Platform independence. Because UIX is implemented in Java and other portable web technologies, you can use UIX to develop applications for a variety of platforms and browsers, including HTML-compliant browsers and mobile devices.

• Open, flexible framework. You can choose to use all UIX features or some, depending on your application development needs. For more information, see Which UIX Features to Use?

• Oracle9i JDeveloper integration. UIX support is integrated into the JDeveloper IDE. Interactive wizards, a schema-based XML Editor, and the Component Palette are just some of the features that assist you in creating UIX pages.

• Customization. UIX applications are easily customized for different end user environments. Different layouts and styles can also be implemented.

• Internationalization and accessibility support. UIX user interface components have built-in support for internationalization and accessibility.

• Declarative development environment. You can use uiXML (an XML language) to create UIX pages and manage page flows for your entire application, thus avoiding the need to write a lot of Java code.

• Streamlined design workflow. Using UIX to create user interfaces ensures a consistent look and feel, allowing you to focus more on user interface interaction rather than look and feel compliance. By default, the UIX user interface components and style settings comply with the Oracle Browser Look and Feel standards. Other look and feels will be added in future releases.

• Application development integration. UIX design prototypes may be used for actual product implementations.

UIX Framework

UIX is both a framework and a rich library of user interface components for developing interactive web applications with a consistent look and feel.

The UIX framework is based on the Model 2 implementation of the Model-View-Controller (MVC) design pattern, where the business logic of an application is separated from the presentation layer, and a servlet manages client communication and business logic execution. This framework simplifies adding and modifying client types, views, and workflow in application development.

UIX enables you to develop the View and Controller layers of an application. The View layer represents the visual aspects of the application, where data is presented to the user and the user can provide input to the application. The Controller part provides the interactions with the client-it maps incoming client requests to operations on the application model, and selects and formats the next client view to display.

You can develop the View and Controller layers using uiXML, or if you prefer you can use JavaServer Pages (JSP) to develop the View. UIX is accessible from JSP through the UIX JSP tag library.

For the Model layer, you can implement your application business data for any data source such as Business Components for Java (BC4J), or JavaBean components that are used directly by JSP or servlets. UIX then "glues" or data binds the application model code to the View.

The main technologies in the UIX framework are UIX Components and UIX Controller.

UIX Components

UIX Components, the primary technology in UIX, includes a set of user interface components implemented as JavaBeans, and a set of Java classes (renderers) that can generate output for many device types, e.g., HTML for a web browser. You use UIX Components to compose pages in UIX, and to transform them into user interfaces for a variety of clients.

By default, UIX Components implements the View or presentation layer as HTML that conforms to Oracle BLAF (Browser Look and Feel). All UIX user interface components have built-in support for internationalization and accessibility. For information about developing localized and accessible applications, see the UIX Developer's Guide.

UIX Controller

The UIX Controller is a J2EE-compliant servlet that receives and processes HTTP requests (events) from the client, and sends appropriate pages back to the browser after processing the data and updating the application state. You use the UIX Controller to group individual web pages to form an application, and to control how pages flow as a result of user events.

The UIX Controller technology is specifically designed to support UIX pages created using UIX Components, but it can also use JSP or Extensible Stylesheet Transformations (XSLT) to construct the HTML pages that are sent back to the browser.

Who Can Use UIX?

Regardless of your role in web application development, you can use UIX.

Whether you are involved in product definition, user interface design, prototype development, or product implementation, UIX lets you perform your tasks easily and efficiently.

If you are involved in pre-sales or post-sales activities, you can also use UIX because UIX applications are easily customized for different styles and end user environments. For information about developing customized applications, see the UIX Developer's Guide.

How to Use UIX

Whether you are implementing an application or developing a prototype, you can use UIX in any of these language and technology environments:

• Java—using UIX Java classes and APIs
• uiXML—using an XML dialect (declarative development)
• JSP technology—using JSP tags and a UIX JSP tag library

Oracle, however, recommends that you use uiXML to develop your UIX applications because it is easy to use, and it does not require programming. Also, compiling is not required to deploy changes. uiXML examples are used in this quick tour where an example helps to illustrate a concept.

For the development environment, Oracle recommends that you use Oracle9i JDeveloper because of these advantages:

• JDeveloper provides wizards to assist in developing uiXML files and templates. Wizards also assist in creating UIX applications based on BC4J projects.
• The XML Editor in JDeveloper includes a specialized schema for editing uiXML files.
• The Component Palette lets you select uiXML elements from a drop-down list.
• JDeveloper provides easy access to the UIX JSP tag library, if you prefer to work with JSP.
• You can preview, run, and deploy UIX applications directly from JDeveloper.

Installation and Requirements

To start using UIX, download the latest version from

/software/products/ids/uix/index.html

To use UIX in JDeveloper, download the latest JDeveloper release from

/products/jdev/index.html

If you use JDeveloper, you do not have to download and install UIX separately. UIX is integrated into JDeveloper.

Summary

• Standard technologies—UIX, an open framework for building web applications, is based on standard technologies like Java servlets, JavaBeans, XML, and resource bundles for internationalization.

• Technology integration—UIX is extensible, enabling you to work with other technologies like Struts, and in the future JavaServer Faces. In addition, UIX lets you data bind to any source, such as BC4J or Enterprise JavaBeans.

• Platform independence—UIX applications can be built for a variety of platforms and browsers, including HTML-compliant browsers and mobile devices.

• MVC approach—The UIX framework is based on the Model 2 implementation of the MVC design pattern, simplifying and reducing application development cycles. UIX focuses on the View layer, with UIX Components being the building blocks for developing the pages of a UIX application.

• Easy to use—Developers of varying skill levels can use UIX. For example, web page authors with no programming expertise can use UIX to build user interfaces that link to a data source without writing any Java code.

• Oracle9i JDeveloper—Oracle recommends that you use JDeveloper to build your UIX applications. Developing UIX applications in JDeveloper is significantly enhanced by the use of the Component Palette, wizards, tag libraries, and the XML Editor, which supports a schema for editing uiXML semantics.

Top of page

Basics

What Is a Page?

UIX pages constitute the core visual aspects of an application. You use UIX Components to create UIX pages.

A UIX page lets you specify the page layout, data sources, and events for a user interface. An application usually consists of multiple units of user interfaces or UIX pages. For example, one page might represent the order details in an online shopping application, and another page might represent the shipping form.

Each UIX page is the logical representation of a user interface in an application. The same logical page can be presented as an output page for many client devices, e.g., an HTML page for a web browser.

Dynamic data content in a UIX page is achieved through data binding with any source. UIX has built-in data binding support for Business Components for Java (BC4J) and JavaBeans.

User Interface Nodes

What are the logical parts that make up a UIX page? A UIX page consists of a hierarchical tree of user interface nodes. Each user interface node can have none, one, or more child nodes; this means a node can be a parent and a child node at the same time.

User interface nodes define both the visible and non-visible user interface components in a page. Examples of visible user interface components include text and images, and standard HTML controls such as buttons and checkboxes. Non-visible user interface components do not map to visible objects but they organize and manage the layout, appearance, and behavior of other components. For example, the StackLayout component does not define a visible object but it causes the child components to lay out vertically in a page.

Thus, a logical tree-like structure of parent and child nodes form the basis for the construction of a visual, physical hierarchy of user interface components on a page for a browser or a mobile device. The page construction occurs dynamically through client-specific renderers of the UIX Components.

Page Flows and Events

We've seen how UIX Components is the technology for creating UIX pages that become the user presentation layer of an application. A web application typically consists of multiple pages. The technology for managing application flow among the pages is the UIX Controller.

Users interact with web applications through browser requests. When a user clicks a link on a page, the UIX Controller processes the HTTP request and determines the next page to construct and return to the browser.

Sometimes a client request triggers an event that must be processed by special event handlers in the application. For example, when a user clicks the Submit button on the order form of an online shopping application, the UIX Controller executes the application code for the special event, updates the server state, and uses the results returned from the event handler to determine the next page to display.

Any J2EE-compliant servlet can use the UIX Controller technology to receive and process HTTP requests. The UIX Controller utilities also handle errors during data binding and event handling, and provide built-in support for logging in and file uploading.

Optionally, you can use Struts as the Controller portion of your application. The Struts UIX technology integration enables you to use Struts and UIX pages easily.

uiXML Page

Remember that you can use Java, JSP, or uiXML to develop your UIX application, but the recommended method is to use uiXML.

uiXML is a dialect of the XML language for creating UIX pages declaratively. Using uiXML elements, you can specify user interfaces and link them to data sources and events.

Like XML documents, you write your uiXML documents or pages in a text format. uiXML pages must be well formed and valid, complying with schemas that describe rules for uiXML elements semantics and XML syntax.

A basic empty UIX page written in uiXML would look like this:

<page xmlns="http://xmlns.oracle.com/uix/controller"
      xmlns:ctrl="http://xmlns.oracle.com/uix/controller"
      xmlns:html="http://www.w3.org/TR/REC-html40">

 <content>
   <dataScope xmlns="http://xmlns.oracle.com/uix/ui"
              xmlns:data="http://xmlns.oracle.com/uix/ui">

     <provider>
       <!-- Add data sources here -->
     </provider>

     <contents>
       <document>
         <metaContainer>
           <!-- Set the page title -->
           <head title=""/>
         </metaContainer>
         <contents>
           <pageLayout>
             <!-- Define the content of the page here -->
             <contents>
             </contents>
           </pageLayout>
         </contents>
       </document>
     </contents>

   </dataScope>
 </content>

 <handlers>
   <!-- Add event handlers here -->
 </handlers>

</page>

Using uiXML, you can create simple to complex pages such as these examples:

• A simple 3-column page
• A complex 1-column page

Localization and Customization

UIX includes image generation and style sheet management technologies, which together with the client-specific output renderers of UIX Components, make UIX user interfaces portable across different locales, fonts, platforms, and browsers.

The UIX image generation technology lets you incorporate localized images in your applications with minimal effort. UIX processes text separately from images, so your translators need to provide resource files for the translated text only. At runtime, UIX dynamically combines the translated text with the images to create localized images.

The UIX style management technology lets you define and customize style sheets for different end user environments easily. UIX uses a single XML style sheet document to contain styles for all end user environments, including locales, browsers, and platforms. At runtime, UIX generates a cascading style sheet (CSS) using the environment-specific style information in the style sheet document, as determined by the locale and platform information in the HTTP request.

To provide custom styles for your end users, you create a custom style sheet that imports the default style sheet document. Then you simply override whatever style you wish in the custom style sheet. For example, you may create a custom style sheet that uses a different font family and font size.

Summary

• Page—A UIX application is made up of multiple UIX pages. The primary technology for creating UIX pages is UIX Components. You build the presentation layer of an application by assembling reusable user interface components in pages and connecting the components to a data source. Client-specific output renderers of UIX Components then dynamically construct the pages for many target devices, including web browsers and mobile devices.

• Application Flow—The UIX Controller is the technology for managing page flows and handling events that result from user interactions with the application through a browser. Any J2EE-compliant servlet can use the UIX Controller utilities to receive and process HTTP requests and determine the proper view to return to the browser.

• uiXML—Oracle recommends that you use uiXML (an XML dialect) to build a UIX application declaratively. uiXML pages or files are well-formed XML documents containing a hierarchy of uiXML elements.

• Internationalization—Localized UIX user interfaces are automatically rendered at runtime using resource bundles and the end user's preferred locale. Custom style sheets may be used to provide styles for different end user environments, including browsers and platforms.

Top of page

UI Design

Introduction - UI Design

When designing a user interface for a web-based application, it would be useful to have an understanding of HTML tags and style sheets, and to be familiar with the Oracle Browser Look and Feel (BLAF) guidelines.

By default UIX implements BLAF for your UIX application by using a cascading style sheet. The BLAF guidelines are constantly being updated. You can always get the latest information at the BLAF Guidelines site.

Before you start designing user interfaces in UIX, look at some typical BLAF page layouts and learn to identify by name and appearance the major BLAF components. After identifying the major components in typical BLAF page layouts, it helps to learn the UIX user interface components associated with creating each BLAF component.

Types of User Interface Components

The UIX components that you use to create your user interfaces can be broadly divided into three groups:

• Simple components
• Layout components
• Composite components

Simple components define visible objects like text and images, and objects that map to standard HTML controls on a page. Examples include Button, Image, and Text components.

Layout components do not map to visible objects but define the appearance, behavior, and position of other visible objects. Examples include TableLayout, PageLayout, and StackLayout components.

Composite components define more complex visible objects that have greater interactive usage. Examples include Shuttle, HideShow, and Tree components.

For more details, the UIX Components Guide has live examples of what each UIX user interface component looks like, and the uiXML source file that is used to create the example.

Typical Page Layouts

The following links show typical BLAF page layouts you can create using uiXML pages:

• Three-column Home page
• Second page of a 3-step procedure

The examples illustrate the types of user interfaces you can create without writing a large amount of complicated code.

Three-column Home page

The first example shows a three-column home page. The visual styles such as color and fonts, and graphical components such as buttons, are dynamically generated through UIX. The page links at the bottom are also automatically generated by UIX. You do not have to write any special code to enable this feature. UIX uses the global buttons information and the tab bar information to create the page links.

Second page of a 3-step procedure

The second example shows the second page (step) of a three-step procedure. The button navigation links and graphics at the bottom are provided by the <pageButtonBar><navigationBar> elements. The steps graphics and text at the top (below the tab bars) are provided by the <location><train> elements. The mouse-over text for each step graphic is again "free" code provided by UIX.

Design-Time Tools

Oracle recommends that you use Oracle9i JDeveloper (release 9.0.2 or later) to create and edit your uiXML pages. JDeveloper includes wizards and tools for creating, editing, validating, previewing, and running uiXML files.

uiXML editing features are incorporated in the schema-driven XML Editor, where you can invoke code insight and tip insight for assistance in selecting uiXML elements and attribute value types.

Syntax checking, auto indenting, and schema validation are just some of the XML Editor features that enable you to create and edit uiXML pages with speed and ease.

In future JDeveloper releases, you will be able to develop uiXML pages visually using drag-and-drop features.

For those of you who don't wish to use JDeveloper to design user interfaces, you can use any text editor to create your uiXML pages. But keep in mind that uiXML files are like all XML documents-they must be well formed and valid. To view uiXML pages, you can use the UIX Browser that is included in the UIX download.

Reusable Design Pages

UIX offers two features for reusing uiXML content: "includes" and templating.

Many of your uiXML pages might share common content, especially in the <globalButtons>, <tabs>, and <productBranding> sections, just to name a few. A more modular design would be to define the common pieces in one UIX file, and then reuse the target UIX file where you need it. The <include> element lets you include the target UIX file from the uiXML pages that use the common content.

If you want to create uiXML pages that are similar, you can create a uiXML template (or UIT) file, and then build your uiXML pages based on the template. You can create and modify UIT files in JDeveloper using wizards and the XML Editor.

Templating takes building modular UIX files up a higher level by letting you define new uiXML elements in terms of pre-existing elements. Templates are special files that define and provide reusable components that may be imported and used in uiXML pages.

A UIT file defines one element only. To use the template-based element in a uiXML page, you have to import the template by listing it in the <templates> section using the <templateImport> element.

As your templates grow in number, you may group them into a template library, and import all of them at once using the same <templateImport> element.

Mobile User Interfaces

For mobile devices, UIX currently supports Internet Explorer for Pocket PC. Support for phones, pagers, and Palm browsers will be added in the future.

Although UIX provides a single technology to create pages for different devices, you must write pages with a specific device in mind. For instance, mobile user interfaces must be simpler than desktop ones because of screen size. For this reason, composite components like Tree and Shuttle will not work on mobile devices.

A subset of the simple and layout components are supported in mobile applications, but their behavior may differ from the desktop implementations. See the UIX Developer's Guide for details on writing applications for mobile devices.

Summary

• Consistent look and feel—Using UIX to create user interfaces ensures that you will get a consistent look and feel for all your applications. By default UIX user interface components and style settings comply with Oracle BLAF standards. Other look and feels will be implemented in future releases.

• UI components and uiXML—UIX user interface components and uiXML enable you to create user interfaces without having to write any special code. You can define simple to complex user interfaces and layouts in uiXML pages by using the familiar writing of XML syntax and uiXML elements.

• Design-time tools—Use Oracle9i JDeveloper interactive wizards and tools for creating, editing, validating, previewing, and running uiXML pages.

• Modular and reusable—Build modular and reusable uiXML files by using UIT templates or "include" files that contain common uiXML content.

Top of page

Application Development

Introduction - Application Development

Based on the Model 2 implementation of the Model-View-Controller (MVC) design pattern, the UIX framework encourages application architectures to define a clear separation between presentation and application logic.

UIX provides the View and Controller portions of an application while making it easy to connect the presentation layer to any standard data access technology such as Enterprise JavaBeans. This architecture enables each member of a web application development team to focus on their area of expertise. For example, web page authors can concentrate on designing the presentation layer while application developers who write the application code can focus on business logic, data access, and event handling.

Using UIX to build web applications enables you to divide development tasks among three types of developers:

• UI designers/developers—Create the View. Output is UIX pages for the front-end of an application.
• Model developers—Create the Model independently of the View and Controller. Output is Java classes for the back-end of an application.
• Controller developers—Make the View and Model work together by adding data manipulating, event handling, and workflow pieces to the UIX pages.

In real life, however, there is often an overlap of roles in any application development team. For instance, some developers may work on both the View and Controller layers. How you divide the tasks among your application team members is entirely up to you.

Declarative Development

Oracle recommends using uiXML to build your UIX applications. A dialect of XML, uiXML lets you create UIX pages and manage application flow using the familiar syntax of XML. You define user interfaces, data sources, and events in UIX pages.

Client-side validation and errors during data binding and event handling are also managed in UIX pages. In short, UI designers/developers and Controller developers can use uiXML.

Model developers can use any back-end technology that best meets the needs of the application because UIX can "glue" any model code in uiXML pages through data binding.

Although using uiXML is the preferred method, you can also use JavaServer Pages (JSP) without losing out on the benefits of other UIX features. UIX is directly accessible from JSP via the UIX JSP tag library.

For more information about uiXML, see the UIX Developer's Guide.

Which UIX Features to Use?

The UIX technology stack is open and flexible, allowing you to choose which features you want to use depending on your application needs.

The various UIX technologies, however, are designed to work together. Using one technology makes it easier to use another. For example, using UIX Components and UIX Controller enables you to get the most functionality with the least effort because the UIX Controller is especially designed to support and integrate with UIX Components and uiXML.

Review the following situations and recommendations before you decide on the technology choices:

• Brand new project: Start a new project using UIX Components to define your page layouts, data sources, and events. Use the UIX Controller to manage application flow.

• JSP or HTML pages already exist: Use the UIX Controller technology to manage logins and handle errors and file uploads. Later on you can add new pages based on UIX Components easily. Alternatively, you can implement all your pages using UIX Components. UIX lets you include non-UIX content (like JSP and HTML) in uiXML pages.

• Java-generated pages already exist: Use UIX Components on a page through the Java web bean classes. Merge the generated output into your existing Java-generated page output.

• Cannot replace current page flow technology: Use UIX Components for creating and rendering your pages. Although you cannot use the UIX Controller for application workflow, you might still be able to use the UIX Controller utility code for handling file uploads.

• Cannot replace current page rendering technology: Use the UIX image generation technology to generate images with localized text. Use the UIX style management technology to generate custom style sheets for different end user environments.

Oracle9i JDeveloper Integration

The UIX application development process is enhanced significantly by the use of Oracle9i JDeveloper.

JDeveloper provides page wizards, application wizards, data binding, tag insight, and other editing features for working with uiXML pages, UIX JSP pages, and BC4J UIX applications. For example, you can leverage BC4J client data files from within a uiXML page, and include BC4J interMedia data without writing any extra Java code.

After building a UIX application using JDeveloper, you can preview, run, and deploy your application directly from the JDeveloper IDE.

For more information about working with UIX in JDeveloper, see the Oracle9i JDeveloper online help.

XML Editor

The schema-based XML Editor in Oracle9i JDeveloper includes a specialized schema for editing uiXML pages.

You can invoke code insight and tip insight while editing uiXML files-code insight opens a list with valid uiXML elements or attributes; tip insight displays the type of value required for an attribute.

Proper indentation of the elements and validation against the schemas referenced in the uiXML page are just a mouse click away at any time during editing.

You can also select uiXML elements from the Component Palette to insert in your pages. The uiXML elements are included on several Component Palette pages, such as uiXML Simple Components, uiXML Page Layout, and uiXML Table. Context-sensitive help for each uiXML element is available from the Component Palette.

See the Oracle9i JDeveloper online help for more information about the editing features available while using the XML Editor.

Visual Editor

Coming soon: A design-time tool for creating and editing uiXML pages visually will be introduced in a post-9.0.4 release of Oracle9i JDeveloper.

The Visual Editor will let you select, move, copy and paste, and delete uiXML elements. You will also be able to drag and drop uiXML elements from the Component Palette onto the Visual Editor. Changes made in the visual editor will be automatically synchronized and refreshed in the XML Editor and Structure window.

BC4J UIX Applications

The BC4J UIX technology integration lets you build UIX applications that interact with the Oracle9i Database via Business Components for Java.

You can make your UIX pages dynamic by declaratively defining elements and attributes that bind to BC4J data sources. You can also specify how to validate and update the data sources in response to user events.

For more information about creating BC4J UIX applications, see the UIX Developer's Guide.

Oracle9i JDeveloper provides many features for developing BC4J UIX applications, enabling you to build complete applications easily and quickly with very little Java coding. The UIX application project must be in the same workspace as the BC4J project for the application module that you are working on.

After defining an application module in a BC4J project, you can use a wizard to create the UIX application based on the BC4J project. During the process you can select the view objects and the links for the view objects that you want in your BC4J UIX application. Besides generating the UIX pages for viewing, creating, and updating the BC4J data sources, the wizard also creates other files that make up your BC4J UIX application, such as the uiXML application properties file.

See the Oracle9i JDeveloper online help if you are interested in creating BC4J UIX applications using JDeveloper.

UIX and Struts

Like UIX, the Struts framework lets you build web applications based on published standards and proven design patterns. Struts provides its own Controller component, and lets you integrate with other technologies to provide the Model and the View layers.

The Struts UIX technology integration lets you use uiXML for part or all of your Struts applications. For example, you can use uiXML pages to create the View, and use standard Struts Action and ActionForm to control your uiXML-based application. You would reference Struts Action and ActionForm in UIX files by using the <struts:action> and <struts:form> elements respectively.

To use Struts and UIX, first you set up the UIX Struts Extensions in the UIX configuration file (uix-config.xml). To use Struts to control your uiXML-based application, you modify the Struts configuration file (struts-config.xml) to specify the UIX files that contain the target pages of Struts actions.

For more information about using uiXML and Struts, see the UIX Developer's Guide and the Oracle9i JDeveloper online help.

UIX JSP Applications

The UIX JSP technology integration lets you use custom tags to access UIX functionality directly from JavaServer Pages (JSP).

UIX provides a JSP 1.2 compliant tag library for UIX functionality, exposing most of the uiXML elements and attributes. See the UIX Developer's Guide if you want more details about the differences between uiXML and UIX JSP.

Oracle9i JDeveloper provides many features for working with UIX JSP pages, including JSP tag insight in the Code Editor, Component Palette, and wizards. One of the wizards helps you to generate UIX JSP pages that can browse and edit data.

UIX JSP pages support data binding to Business Components for Java (BC4J) projects through BC4J data tags and special BC4J UIX JSP convenience tags that simplify the presentation of data. You can also use non-UIX BC4J JSP tags and BC4J interMedia UIX JSP tags in your UIX JSP pages.

For information about creating UIX JSP applications using JDeveloper, see the Oracle9i JDeveloper online help.

Deployment Environments

UIX applications created in Oracle9i JDeveloper can be deployed directly from the IDE.

By default, JDeveloper runs applications in the embedded Oracle9iAS Containers for J2EE (OC4J) server to enable testing and debugging before deploying to a target application server.

The supported application server connection types are:

• Standalone OC4J
• Oracle9iAS via local Distributed Configuration Management (DCM)
• Oracle9iAS via remote DCM

Deploying UIX applications to Oracle9iAS is completely automated in JDeveloper. For example, when you create a BC4J UIX application, JDeveloper automatically generates a deployment descriptor and a Web Application Archive (WAR) file that contains both the BC4J and the UIX application files.

When you deploy to standalone OC4J or Oracle9iAS, JDeveloper automatically wraps the WAR files into an Enterprise Archive (EAR) file and sends the EAR file to the target application server.

For more information about deploying UIX applications, see the Oracle9i JDeveloper online help.

Summary

• MVC approach—The UIX framework encourages web application architectures based on Model 2 of the MVC design pattern, enabling individual team members to focus on their area of the development process. UIX provides the View and Controller portions of an application without limiting the View to a particular markup language or client device.

• Flexible technology—For maximum functionality, use all UIX technologies for your web applications because they are designed to work together easily. UIX, however, is also designed to be flexible, enabling you to use one technology without another. Furthermore, UIX has built-in support for JavaBeans and BC4J.

• Standardization—UIX works with other popular Java web application frameworks and technologies such Struts and JSP. Future UIX-based implementations will be able to use JavaServer Faces.

• IDE—uiXML is the recommended declarative environment for building UIX applications. Support for complete UIX development and uiXML editing is integrated into the IDE of Oracle9i JDeveloper. For example, you can use JDeveloper wizards and tools such as the Component Palette and XML Editor to build, preview, run, and deploy UIX applications.

Top of page

Next Steps

UIX Demos

Every UIX release includes a demo bundle, which contains all the files needed to view the UIX demos.

UIX Examples

To learn more about UIX user interface components, check out the UIX Components Guide.

The guide provides sample code that shows how to use each element of the UIX user interface components. It also links to the reference documentation for each component.

UIX Documentation

For a complete list of UIX documentation that is available, see

/docs/products/ids/uix/index.html

The Oracle9i JDeveloper online help has information about using UIX in JDeveloper.

Top of page

Copyright © 2002, Oracle Corporation.
All rights reserved.