WebObjects Release 3.0

Topics

NOTE: All changes described in this document also apply to WOF Release 3.1.

WebObjects Framework Class Hierarchy

---

The class hierarchy in WebObjects 3.0 has changed somewhat from that in WebObjects 2.0. This diagram summarizes the changes.

WebObjects Builder

• You can now display a component's script file at the same time as its HTML template. The main display of the component window always shows you the component's variables and methods as well as the HTML template. Choose Tools->Script->Script or press the script button on the component window's toolbar to see the entire script file.
  
  
• To bind an element, you can simply select the element and double-click a variable or method. You no longer have to type the name of the variable in the inspector window.
  
  
• The bindings inspector now lists all of a dynamic element's attributes instead of listing only the required attributes.
  
  
• You can create a dictionary type (or class) without first having to create variables. Choose Classes from the Tools menu, enter a name for the class, and then enter names for the class's attributes.
  
  
• Drag-and-drop database support and a wizard for creating applications that access a database have been added. These are described in more detail later in this document.
  
  
• Support for creating reusable components has been improved. The page inspector now lists all of a component's variables. Using this interface, you can select which variables should be exported, meaning that the parent component can bind to them.
  

Project Builder

PASSWORD : WOApplet {
    code = "next.wo.client.controls.TextFieldApplet.class";
    codebase = "/WebObjects/Java";
    width = "200";
    height = "20";
    associationClass = "next.wo.client.SimpleAssociation";
    stringValue = nameString;
    echoCharacter = "*";
    action = "validateUser";
};

• Built-in support for two-tier database access
• Rapid database application development with WebObjects Builder
• Integration of existing C or C++ libraries
• Support for compiled C, C++, or Objective-C code, as well as WebScript

Enhancements

• Built-in support for minimal enterprise object state archiving. To store state in the page (or in cookies) in WebObjects 2.0, you had to provide custom implementations of the methods initWithCoder: and encodeWithCoder:. In WebObjects 3.0, this is no longer necessary.
  
  
• Per-session object graphs.
  

New Features Summary

WebObjects 3.0 provides graphical development tools for creating web-based database applications. With little or no coding you can map database records to objects and then bind the objects to elements in your web pages.

In WebObjects 2.0, WebObjects Enterprise included Enterprise Objects Framework database integration technology, but you had to write scripts or compiled code to use it. In WebObjects 3.0, WebObjects Builder provides drag-and-drop support for:

• Displaying data from a database in your web pages
• Updating database records
• Searching the database based on arbitrary criteria

Both WebObjects Enterprise and WebObjects Pro include EOModeler (an application for defining a database-to-object mapping) and the Enterprise Objects Framework library of classes. For information on EOModeler and Enterprise Objects Framework classes, see the Enterprise Objects Framework Developer's Guide and Reference.

Note that some of the Enterprise Objects Framework capabilities are limited in WebObjects Pro. For a complete description of the features in WebObjects Pro, see "Differences between WebObjects Enterprise and Pro," accessible from the WebObjects home page.

More On New Features

The emphasis of WebObjects 3.0 is on providing an easy-to-use, graphical development environment for integrating databases with web applications. WebObjects Builder delivers the bulk of this environment by providing the following database integration features:

• The Database Wizard
• Display Groups
• An Editing Context

Each of these features is described below.


The Database Wizard

The Database Wizard is the simplest way to define how a WebObjects application interacts with a database. Running the wizard performs all the setup necessary to fetch database records and display them in a web page. Depending on the configuration you choose, the wizard may also provide database search forms in which users can specify record-matching criteria and forms for inserting, updating, and deleting database records.

To use the Database Wizard, choose Database Wizard from the Tools menu and perform the steps as the wizard prompts you. When the Database Wizard finishes, simply save your WebObjects application, and run it. If the web page created by the wizard doesn't have all the features you want, use WebObjects Builder to extend or modify it. Pages created by the Database Wizard provide great jumping off points for web-based database applications.


Display Groups

The WebObjects Framework includes a new class, WODisplayGroup, whose instances provide a simple interface for interacting with relational databases in terms of objects. WODisplayGroup objects--also referred to as display groups--use classes defined in Enterprise Objects Framework to:

• Fetch from the database.
• Insert, update, and delete database records.
• Build qualifiers from user input and order search results.
• Manage batches of search results.

In your code, you work with objects. WODisplayGroup and Enterprise Objects Framework take care of converting operations on objects to database operations on records.

As part of its tasks, the Database Wizard creates a display group object and adds it to your application as a component variable. To create a display group without using the wizard, perform the following steps:

1. Open a model file in EOModeler.
   
   
2. Select an entity in the Model Editor.
   
   

   A display group manages objects associated with a single entity. For example, if you choose the Movie entity, the resulting WODisplayGroup operates on Movie objects. Note, however, that you can also access other kinds of objects through a Movie object's relationships. For example, if a relationship between a MOVIE table and a STUDIO table can be expressed with an join, you could access Studio objects associated with a particular Movie object. For information on creating relationships, see the chapter "Using EOModeler" in the Enterprise Objects Framework Developer's Guide.
   

   
   
3. Drag the entity into the component window to which you want to add a display group.
   
   

	[[[self session] defaultEditingContext] tryToSaveChanges]

	self.session.defaultEditingContext.tryToSaveChanges(); 

Templates for Dynamic Elements

<WEBOBJECT NAME="MYFORM">
    <FORM TARGET=MYTARGET>
    ...
    </FORM>
</WEBOBJECT>

<WEBOBJECT NAME="MY_FORM.">
	<INPUT TYPE="TEXT">
</WEBOBJECT>

New or Revised Elements

WOConditional { 	
    condition = YES|NO; 
    [negate=YES|NO;]
};

- payingCustomer {
    if (/* ordered something */) {
	return YES;
    }
    return NO;
}

WOHyperlink { 
    [string=aString;] 
    action=aMethod | href=aURL | pageName=aString; 
    [fragmentIdentifier=anchorFragment;] 
    [target=frameName;] 
    [disabled=YES|NO;] 
    ... 
};

ALINK: WOHyperlink {
    string = "[ Book of all Knowledge ]"; 
    pageName = "IRS1040"; 
    fragmentIdentifier= "ScheduleA";
};

• The keywords persistent, session, and action have been dropped.
• A syntax variation similar to Visual Basic is now supported.
• Scripts can now implement init and dealloc to initialize and deallocate associated objects.
• Objective-C-style categories and scripted classes have been added.

Summary

willPrepareForRequest:inContext:

didPrepareForRequest:inContext:

willGenerateResponse:inContext:

didGenerateResponse:inContext:

takeValuesFromRequest:inContext:

appendToResponse:inContext:

Discussion

- willPrepareForRequest:r inContext:c {
    // code A
}
- didPrepareForRequest:r inContext:c {
    // code B
}

- takeValuesFromRequest:r inContext:c {
    // code A
    [super takeValueFromRequest:r inContext:c];
    // code B
}

- appendToResponse:aResponse inContext:aContext
{
    id sailboards = [[self session] selectedSailboards];
    id count = [sailboards count];
    id i;

    total = 0;
    for (i = 0; i < count; i++) {
	sailboard = [sailboards objectAtIndex:i];
	total = total + [[sailboard 
		objectForKey:@"price"] intValue];
    }
    [super appendToResponse:aResponse inContext:aContext];
}

Application Directory Name

Resource Paths and URLs

pathForResourceNamed:ofType:

urlForResourceNamed:ofType:

Component Templates

Localization

{
    buttonTitle = "Submit your request";
}

{
    buttonTitle = "Soumettez votre requete";
}

<HTML>
<WEBOBJECT NAME = "PALETTE"></WEBOBJECT>
</HTML>

PALETTE: Palette {
    selection = number;
    callBack = "displaySelection";
 };

- displaySelection  
{
    /* display the selection identified by number */
}

- click             /* this is the child's action */
{
    selection = /* some value */;
    /* now invoke the parent's action */
    return [self performParentAction: callBack];
}

Application Extension

Initialization

• The first message should be an invocation of super's init method.
  
• The last statement should be" return self".
  

- init {
    [super init];
    someVar = aValue;
    return self;
}

Parent-Child Callbacks (action Keyword)

persistent Variables

1. Locate each component variable declared with a persistent keyword.
2. Delete the keyword.

session Variables

1. Create a Session.wos file if one doesn't exist.
2. Locate each component variable declared with a session keyword.
3. Delete the keyword.
4. Copy the declaration to the Session.wos file.
5. In Session.wos, initialize these variables (if necessary) in init.

Request-Handling Methods

- takeValuesFromRequest:r inContext:c {
    [super takeValueFromRequest:r inContext:c];
    // code goes here
}

willPrepareForRequest:inContext: --> takeValuesFromRequest:inContext: (before super invocation)

didPrepareForRequest:inContext: --> takeValuesFromRequest:inContext: (after super invocation)

willGenerateResponse:inContext: --> appendToResponse:inContext: (before super invocation)

didGenerateResponse:inContext: --> appendToResponse:inContext: (after super invocation)