Java Client allows your application to look and feel like a traditional desktop application and still take full advantage of the power of WebObjects.

Rapid Development

WebObjects is both powerful and flexible. With that power and flexibility, however, comes a certain degree of complexity. For many applications, whether HTML-based or Java Clientbased, its more important to develop the application quickly than strive for maximum flexibility or polish. As an example, a simple data-browsing and editing application, intended only for internal use by a system administrator, probably wouldnt warrant the same degree of effort you would put into an Internet-enabled application accessible by the general public. To simplify the development of applications like the former, WebObjects includes a set of rapid-development technologies: Direct to Web and Direct to Java Client. Direct to Web and Direct to Java Client are similar in approach. Their primary difference is in how the application interacts with the end user. Direct to Web creates HTML-based WebObjects applications, whereas Direct to Java Client creates WebObjects applications that employ Java Client to partition the application between server and client. Both are useful not only for creating simple database browser applications, but in many situations can also serve as rapid prototyping tools. Because Direct to Web and Direct to Java Client both allow customization on various levels, they are well-suited for bootstrapping and creating your mission-critical applications.

Direct to Web

Direct to Web is a system for creating HTML-based WebObjects applications that access a database. All Direct to Web needs to create the application is a model of the database, which you can build using EOModeler (a data-modeling tool). Direct to Web applications are not a set of static Web pages. Instead, Direct to Web uses information from the data model available at runtime to dynamically generate the pages. Consequently, you can modify your applications configuration at runtimeusing the Direct to Web Assistantto hide objects of a particular class, hide their properties, reorder properties, and change the way they are displayed without recompiling or relaunching the application.
Rapid Development Apple Computer, Inc. January 2002
What Is WebObjects? Out of the box, Direct to Web generates Web pages for nine common database tasks, including querying, editing, and listing. To do this, Direct to Web uses a task-specific component called a template that can perform the task on any entity. The templates, in conjunction with a set of rules (which you can customize), are the essential elements of your Direct to Web application. Direct to Web is highly customizable. For example, you can change the appearance of the standard templates, mix traditional HTML-based WebObjects components with Direct to Web pages, and create custom components and templates that implement specialized behavior.

Figure 2-4 Multiple instances, multiple applications

Application 1 Instance 2

Application 2 Instance 3

Application 1 Instance 4

Application 2 Instance 5

Application 1 Instance 1

Application 2 Instance 2

Application 1 Instance 3

Application 1 Instance 1 Application server 1

Application server 2

As mentioned in What Is WebObjects? (page 13), WebObjects applications gain much of their usefulness by interacting with a persistent data store, that is, a datasource, which is usually a database. In WebObjects, database tables are represented as collections of Java classes called enterprise objects. Enterprise objects contain the bulk of your applications business logic, the part of the application you write regardless of which of the four approaches you take. This chapter introduces enterprise objects, describes how they map to a database, outlines how WebObjects supports and interacts with them, and enumerates the advantages of the Enterprise Objects approach over other approaches available in the industry. You may wish to read the first section,What Is an Enterprise Object? (page 25), and the last section, The Enterprise Objects Advantage (page 34), and skip the rest of the chapter, which is written for those familiar with relational databases.
What Is an Enterprise Object?
An enterprise object is like any other object in that it couples data with the methods for operating on that data. However, an enterprise object class has certain characteristics that distinguish it from other classes:
It has properties that map to stored or persistent data; an enterprise object instance typically corresponds to a single row or record in a database table. It knows how to interact with other parts of WebObjects to give and receive values for its properties. This is done through a mechanism known as key-value coding, which enables the setting and getting of these properties.
What Is an Enterprise Object? Apple Computer, Inc. January 2002
Enterprise Objects In addition to providing classes that manage a set of enterprise-object instances in memory, WebObjects defines an API to which enterprise objects must conform, as well as default implementations for this API. As a result, you only need to concentrate on the parts of your enterprise-object classes specific to your application. To maximize the reusability and extensibility of your objects, they shouldnt embed knowledge of the user interface or database alongside the business logic. For example, if you embed knowledge of your user interface, you cant reuse the objects because each applications user interface is different. Similarly, if you embed knowledge of your database, youll have to update your objects every time you modify the databases schema. If not in the business objects, then where does this knowledge go? Its handled by WebObjects as shown in Figure 3-1 (page 27).

Figure 3-1 Connecting enterprise objects to data and the user interface

Model WebObjects

Enterprise objects
WebObjects provides a database-to-objects mapping, called a model, so your objects are independent of the database. WebObjects also provides an objects-to-interface mapping so they are independent of the user interface. This approach allows you to create libraries of enterprise objects that can be used in as
Enterprise Objects many applications as you need, with any user interface, and with any database server. Therefore, you can concentrate on coding the logic of your business while WebObjects takes care of the rest. For example, you could create an enterprise object called Customer that defines such business rules as customers must have a work or home phone number, or customers cannot spend more than their credit limit. Without rewriting your business logic, you could use these objects in a public, Web-based application and an internal customer service application. You could also switch the database that serves the customer data.
Enterprise Objects and the Model-View-Controller Paradigm
A common and useful paradigm for object-oriented applications, particularly business applications, is Model-View-Controller (MVC). Derived from Smalltalk-80, MVC proposes three types of objects in an application, separated by abstract boundaries, and communicating with each other across those boundaries. Model objects represent special knowledge and expertise. For example, model objects can hold a company's data and define the logic that manipulates that data. Model objects are not directly displayed. They often are reusable, distributed, persistent, and portable to a variety of platforms. Note: WebObjects uses the term model differently from MVC. In WebObjects, a model establishes and maintains a correspondence between an enterprise object class and data stored in a relational database. In MVC, model objects represent the special knowledge of the application. View objects represent things visible on the user interface (for example, windows, buttons, and so on). A view object is ignorant of the data it displays. View objects in general are reusable, which helps in providing consistency between applications. Acting as a mediator between model and view objects in an application is the controller object. There is usually one per application or window. A controller object communicates data back and forth between the model objects and view objects. Since what a controller does is very specific to an application, it is generally not reusable even though it often constitutes much of an application's code.

It offers greater reuse. In WebObjects, you code your business logic once, and each application that accesses your database can use it. You dont have to re-code your business logic into each screen or Web page.
The Enterprise Objects Advantage Apple Computer, Inc. January 2002
Its more maintainable. With WebObjects, you dont have to duplicate your business logic. Thus you can easily make substantial changes to your rules without resorting to finding and fixing every affected page in every affected application. You can also easily track changes to your schema. It improves data integrity. In WebObjects, you dont need to rely on all application developers to implement the business rules correctly. If one application has an error, it is less likely to corrupt your database. It scales better. In WebObjects, you can improve your applications performance without having to provide your users with faster systems. Instead, you can simply move some computation-intensive processing to fast computers.

Figure 3-5

Implementing business logic in the user interface application
Application Business logic
Another approach (Figure 3-6) is to implement your business rules in the databasewith stored procedures, rules, constraints, and triggers, for example. The WebObjects approach betters this approach in the following ways:
It offers improved interactivity. If you implement your business rules in the datasource, you need to make a round trip to the database every time the user performs an action. Alternatively, you can batch up database changes, which prevents the user from receiving immediate feedback. In WebObjects applications, changes immediately appear in the user interface, but you access the database only when saving these changes or fetching data.
It improves back-end portability. Database vendors have different ways of implementing logic. If you have to support more than one database and youre using WebObjects, you dont have to implement the logic multiple times and thus suffer maintenance problems. Java is a good development language. With WebObjects, you program in Java, an industrial-strength language designed from the ground up to be object-oriented. The programmable variants of SQL usually have some object-oriented features, but are basically procedural languages.

Figure 3-6

Implementing business logic in the database
Relational Business logic Database
The HTML-based application approach allows you to create applications that dynamically generate HTML pages. WebObjects provides graphical tools and a set of flexible frameworks with which you can develop elaborate applications. This chapter describes how a WebObjects HTML application works, the parts of a WebObjects application the programmer sees, the advantages of using this approach, and what the development process is like.

A Programmers View of WebObjects
The following features of WebObjects ease the development of HTML-based Web applications:
The HTML and code reside in separate files. An object called a component represents a Web page and consists of separate files for HTML and Java code. WebObjects provides dynamic versions of static HTML elements. These are called dynamic elements. You can reuse HTML and Java code. Components can be embedded within other components as if they were dynamic elements. WebObjects automatically maintains state information. WebObjects overcomes the inherent statelessness of HTTP and maintains session state (like a shopping cart) and application state (like application statistics). Your presentation code remains separate from your business logic. Enterprise objects, discussed in Enterprise Objects (page 25), contain all of your business logic. This allows you to reuse your business logic in multiple Web pages and even multiple applications.
A Programmers View of WebObjects Apple Computer, Inc. January 2002
HTML-Based Applications These advantages are discussed in more detail in the sections that follow.
Separating Presentation Code from Event-Handling Logic
In WebObjects, a Web page is represented by a component, an object that has both content and behavior. A component can also represent a portion of a page but usually represents an entire page, so the word page is used interchangeably with the word component. Components consist of
a template in HTML code that specifies how the component looks. This file can be edited by any HTML editor or text editor. event-handling logic that specifies how the component acts. You specify this with a standard Java source file. bindings that associate the components layout specification (HTML code) with its event-handling methods. These bindings are stored in a text file.
Separating the presentation code, event-handling logic, and bindings makes it much easier to maintain a Web application. A graphic artist can modify the presentation code, thus modifying the appearance of the page, without breaking its event-handling logic. A programmer can completely rewrite the event-handling logic without accidentally changing the pages layout. You do not need to edit all three files separately. WebObjects Builder, a graphical component editing tool provided with WebObjects Development, edits the template, bindings, and event-handling code files simultaneously, relieving you of having to manually synchronize them. WebObjects Builder is described in more detail in WebObjects Builder (page 46). Figure 4-1 (page 39) shows the three files in an example component.

Figure 5-1

A login page
Direct to Web Applications After the user logs in, Direct to Web displays its first dynamically generated page: a query-all page (Figure 5-2). This page allows the user to specify the enterprise objects he or she wants to work with. The user can query for any type of enterprise object that is visible in the application (the developer decides which types are visible and which are not).

Figure 5-2

A query-all page
If the query-all page is not specific enough, the user can click one of the hyperlinks labeled more., which brings up a query page specific to the corresponding type of enterprise object (Figure 5-3). In this page, the user can specify the values for several properties at the same time. The resulting query is the logical and of the individual queries for the properties.

Figure 5-3 A query page

When the user clicks the Query button on the query page or the magnifying glass icon on the query-all page, Direct to Web displays the enterprise objects matching the query on a list page (Figure 5-4). This page presents the enterprise objects in batches; the user can change the batch size and navigate from batch to batch.

Figure 5-4 A list page

Note that each Movie enterprise object on the list page in Figure 5-4 has an Edit button, which indicates that Movie objects are read-write. The developer can configure whether a type of enterprise object is read-only or read-write. If the Movie objects are read-only, an Inspect button appears on each row instead of an Edit button. If the user clicks the Inspect button next to one of the enterprise objects, Direct to Web displays an inspect page for the object (Figure 5-5) that reveals more detailed information about the object.

Figure 5-5

An inspect page
If the objects displayed on the list page are writable and the user clicks the Edit button next to one of them, Direct to Web displays an edit page for the object (Figure 5-6). On the edit page, the user can edit the attributes for the object or click the Edit button next to one of the relationships to edit the relationship.

partNum color size retail
Direct to Web Applications that override the default rules for special cases. This is exactly what the Direct to Web Assistant does. Figure 5-12 shows the relationship between the Direct to Web template, the rule system, the rule database, and the Direct to Web Assistant.

Figure 5-12

The Direct to Web rule system
Web Assistant Server Direct to Web template Template Bindings Code Rule system Rules
Note that when you configure your application with the Direct to Web Assistant, you dont need to recompile your code to try your changes. Direct to Web is not a code generation wizard. It generates Web pages at runtime based on the templates and the rules.
Developing a Direct to Web Application
There are four steps to creating a Direct to Web application:
Create a Direct to Web project using Project Builder. Create a model using EOModeler. Customize your Direct to Web application using the Direct to Web Assistant (optional). Further customize your Direct to Web application (optional).
Of the four steps, the last two are unique to Direct to Web and are discussed in more detail below.
The Direct to Web Assistant
The Direct to Web Assistant is a Java applet that runs at the same time as your application. It communicates directly with Direct to Web and allows you to reconfigure your application in many ways. Figure 5-14 (page 60) shows the Direct to Web Assistant in use.
Developing a Direct to Web Application Apple Computer, Inc. January 2002
Figure 5-13 The Direct to Web Assistant
With the assistant, you can designate which entities are read-write, read-only, or hidden, as shown in Chapter Figure 5-14 (page 60). You can also set appearance parameters for most of the pages that Direct to Web generates. For example, you can control whether or not the page displays with a banner. You can also change the background color for the table the page displays, if applicable. The assistant also permits you to configure the way properties (attributes and relationships) appear on list, edit, and inspect pages.
Figure 5-14 The Entities pane of the Direct to Web Assistant
As mentioned earlier, the assistant defines a set of rules that override the default Direct to Web rules. Thus, the assistant is the preferred way to modify rules. However, sometimes you need to change the default rules or override the default rules in ways the assistant cant. You can use an application called the Rule Editor to edit the rules directly. Figure 5-15 shows the Rule Editor.

Limitations Apple Computer, Inc. January 2002
Guidelines for Choosing Direct to Web
If your application requires a fast graphical user interface similar to that of a desktop application, you need to use one of the Java Client approaches (Java Client or Direct to Java Client). Direct to Web produces HTML-based applications. Direct to Web is particularly suited for mission-critical applications, prototypes, and intranet applications where development time is critical and the limitations that Direct to Web imposes on the flow and user interface are not an issue. Although you can customize the application, you first need to familiarize yourself with the WebObjects HTML-based application approach and possibly Direct to Web. Once you are familiar with how Direct to Web works, you can also use the Direct to Web reusable components in a standard WebObjects HTML-based website. This technique can dramatically reduce the development time for certain types of pages like forms and list pages.
Guidelines for Choosing Direct to Web Apple Computer, Inc. January 2002
WebObjects recognizes the need for distributed, three-tier application solutions with more complex, rich, and responsive user interfaces than HTML allows. So, in addition to HTML-based WebObjects applications, you can also write Java-based WebObjects desktop applications which use Swing for the user interface. These applications can be deployed either as applets running in a web browser or as real desktop applications running in the clients Java Virtual Machine (though deploying as desktop applications is highly recommended). This feature of WebObjects is called Java Client. In the sample Java Client application shown in Figure 6-1, the user interface is like the interfaces you see in traditional desktop applications.
Figure 6-1 A sample Java Client application
WebObjects Java Client is a three-tier network application solution that allows you to develop platform-agnostic desktop applications with database access and rich user interfaces. Java Client applications are WebObjects applications: they share much of their API with traditional HTML-based WebObjects applications, such as Enterprise Objects for database access and the Foundation APIs that supply data structures and other core functionality to applications.

Client-side processing: Web applications do the majority of their processing on the server, while Java Client moves much of an applications processing to the client. This reduces the amount of client-server communication considerably, making Java Client applications much snappier than their Web counterparts. User experience: These criteria all affect user experience in some way. If your application demands a rich user interface, the manipulation of complex data, and long sessions, Java Client is an excellent choice.
Two Approaches to Java Client
For both HTML and Java Client applications, WebObjects offers rapid development environments that are useful both for prototyping applications and for building full-featured, usable applications. The Java Client rapid development environment is called Direct to Java Client. Direct to Java Client and non-direct Java Client are very similar in that they use the Enterprise Objects technology the same way to access data stores. They only differ at the user interface level. Think of the relationship this way: a Java Client application is a completely customized Direct to Java Client application. Whereas the user interface in Direct to Java Client applications is generated dynamically at run time, the user interface in Java Client applications is built by hand. If you need the precise user interface customization that the non-direct approach allows, its much easier to integrate a custom interface file in a Direct to Java Client application than to develop a completely custom Java Client application (though this is possible and supported). That way, you get the best of both worlds: the advantages of Direct to Java Client and the advantages of custom interfaces built with the non-direct approach. The primary advantage of Direct to Java Client is that its not necessary to write source code to generate or manage an applications user interface. This allows you to focus on writing business logic instead. Although the direct approach lets you manage user interfaces without writing much source code, the approach offers a number of mechanisms to customize user interfaces:

Java Client Assistant

Two Approaches to Java Client Apple Computer, Inc. January 2002
Rule Editor freezing XML freezing.nib files using custom controller classes using factory delegates
The user interfaces for the two approaches to Java Client development each have a particular character. However, keep in mind that its possible to customize each type of interface to look like the other. Typically, user interfaces built in Interface Builder for non-direct Java Client applications or for use as frozen interface files in Direct to Java Client applications resemble (page 68).

Summary Apple Computer, Inc. January 2002
Choosing Your Approach Direct to Java Client allows you to quickly develop data-driven Java Client applications and therefore has the advantages and disadvantages of Java Client. However, like Direct to Web, Direct to Java Client imposes a particular user interface that may not be suitable for your application.

Where to Go From Here

Once you have decided upon an approach, you can go to companion documents that cover the creation of WebObjects applications for each approach. These documents are
Discovering WebObjects for HTML WebObjects Desktop Applications
Where to Go From Here Apple Computer, Inc. January 2002
same types of instance variables and have access to the same methods belong to the same class. column In a relational database, the dimension of a table that holds values for a particular attribute. For example, a table that contains employee records might have a column titled LAST_NAME that contains the values for each employees last name. See also attribute. component An object (of the WOComponent class) that represents a web page or a reusable portion of one. database server A data storage and retrieval system. Database servers typically run on a dedicated computer and are accessed by client applications over a network. Direct to Java Client A WebObjects development approach that can generate a Java Client application from a model. Direct to Java Client Assistant A tool used to customize a Direct to Java Client application. Direct to Web A WebObjects development approach that can generate a HTML-based Web applications from a model. Direct to Web Assistant A tool that used to customize a Direct to Web application.
adaptor, WebObjects A process (or a part of one) that connects WebObjects applications to an HTTP server. application object An object (of the WOApplication class) that represents a single instance of a WebObjects application. The application objects main role is to coordinate the handling of HTTP requests, but it can also maintain application-wide state information. attribute In Entity-Relationship modeling, an identifiable characteristic of an entity. For example, lastName can be an attribute of an Employee entity. An attribute typically corresponds to a column in a database table. See also entity; relationship. business logic The rules associated with the data in a database that typically encode business policies. An example is automatically adding late fees for overdue items. CGI A standard for interfacing external applications with information servers, such as HTTP or Web servers. Short for Common Gateway Interface. class In object-oriented languages such as Java, a prototype for a particular kind of object. A class definition declares instance variables and defines methods for all members of the class. Objects that have the

G L O S S A R Y

Direct to Web template A component used in Direct to Web applications that can generate a web page for a particular task (for example, a list page) for any entity. dynamic element A dynamic version of an HTML element. WebObjects includes a list of dynamic elements with which you can build your component. EJB container The execution environment of EJB components. It's managed by an EJB server. enterprise object A Java object that conforms to the key-value coding protocol and whose properties (instance data) can map to stored data. An enterprise object brings together stored data with methods for operating on that data. See also key-value coding; property. entity In Entity-Relationship modeling, a distinguishable object about which data is kept. For example, you can have an Employee entity with attributes such as lastName, firstName, address, and so on. An entity typically corresponds to a table in a relational database; an entitys attributes, in turn, correspond to a tables columns. See also attribute; table. Entity-Relationship modeling A Discipline for examining and representing the components and interrelationships in a database system. Also known as E-R modeling, this discipline factors a database system into entities, attributes, and relationships. EOModeler A tool used to create and edit models.
faulting A mechanism used by WebObjects to increase performance whereby destination objects of relationships are not fetched until they are explicitly accessed. fetch In Enterprise Objects Framework applications, to retrieve data from the database server into the client application, usually into enterprise objects. foreign key An attribute in an entity that gives it access to rows in another entity. This attribute must be the primary key of the related entity. For example, an Employee entity can contain the foreign key deptID, which matches the primary key in the entity Department. You can then use deptID as the source attribute in Employee and as the destination attribute in Department to form a relationship between the entities. See also primary key; relationship. HTML-based application approach A WebObjects development approach that allows you to create HTML-based Web applications. inheritance In object-oriented programming, the ability of a superclass to pass its characteristics (methods and instance variables) on to its subclasses. instance In object-oriented languages such as Java, an object that belongs to (is a member of) a particular class. Instances are created at runtime according to the specification in the class definition. Interface Builder A tool used to create and edit graphical user interfaces like those used in Java Client applications.

Glossary uniquing A mechanism to ensure that, within a given context, only one object is associated with each row in the database. validation A mechanism to ensure that user-entered data lies within specified limits. WebObjects Builder A tool used to graphically edit WebObjects components.
adaptor (WebObjects) 15, 41, 44 Apache API 44 Apple documentation 11 applet 56, 83 applets 69 application object 41 application process 44 attribute editing 52
batch 51 bean framework 88 stub 88 beans 88 bindings le 38, 42 business logic 25, 67 in enterprise object 34 implementing 3436 separating from interface code 41 business object 21 business objects 69 business rules 67 bytecodes 81
Client-side processing 70 code le 3839 Common Gateway Interface (CGI) 16, 44 component 21, 3742 See also page creating 45 editing of 38, 46 persistence of 41 reusable 4041, 64, 91 separating 38 task-specic 20 controlled network environments 68 Controller object 28 CORBA 81 CORBA stubs 81 custom business logic 68, 81 customize 73
data access mechanisms 67 data model 68 database access to 2021 maintenance tools 93 modifying 21 synchronizing Java Client data 78 tasks 20 database table mapping to enterprise object class 2930 database-to-objects mapping 49 database-to-objects mapping. See model decompiled 81 deploying 89 Deployment 67 deployment requirements 69 developer documentation 11 Direct to Java Client 20, 64
client 88 client code 92 Client JDBC applications 81 client-server communication 17, 70, 78
Direct to Java Client application advantages of 9196 combining with HTML-based approach 94 creating 6885 disadvantages of 9196 extending classes of 85 Direct to Web 1920 reusable components of 41 Direct to Web application 4964 advantages of 62, 9196 combining with WebObjects 95 conguring 56 customizing 61 developing 5860 disadvantages of 9196 dynamically generated pages of 50 xed structure 55 guidelines for choosing 64 limitations of 63 modifying single page of 61 overview 49 reusable components of 64 rules 60 Direct to Web Assistant 5662 Direct to Web template 55, 62 directory 89 DNS 89 dynamic element 37, 3940, 46 dynamic HTML publishing 1316
extensibility of 26 mapping to database table 2930 overview 2526 reusability of 26 WebObjects support for 3133 Enterprise Objects 20, 66, 67, 68 entity 55 entity-relationship (E-R) model 29 eogeneration 74 EOModeler application 29, 82
fat-client 81 faulting 33 fetching 21, 33 foreign key 32 freeze (a page) 61
HTTP 70 HTTP adaptor 89 HTTP protocol 21 HTTP server 44
Edit button 52 edit page 53 edit-relationship page 53 EJB 88 EJB container 88 enterprise object 2536, 4142 advantages of 3436 in batch 51 conguring on list page 52 designing for Java Client 82 entity of 55
inspect page 52 Interface Builder 8283 internal application 94 Internet Server API (ISAPI) 44 intranet application 64