Chapter 2 Creating Component-Based Applications

Application architecture

Jaguar applications are composed of clients and a Jaguar server that hosts components. The clients can run on different machines; the components execute on the server machine as part of the Jaguar server process. Some components, in turn, connect to databases on other machines.

Building Jaguar applications is different from building standard client/server applications in that the parts of the application communicate with each other across network lines in a three-tiered architecture.

Jaguar three tiered architecture

In this figure, the client resides on the first tier, the Jaguar server and components reside on the second tier, and databases reside on the third tier. Executing methods on a component from the client or another component, retrieving data from databases, and other communications are managed by the Jaguar server. Because Jaguar handles the details of transactions, threads, security, database connections, and network communication, you can concentrate on writing the business logic and user interface for the components and clients.

Figure 2-1: Jaguar's 3-tier architecture

As in traditional client/server applications, the client contains the user interface. Unlike client/server applications, however, business logic (such as stored procedures) is separate from both the clients and the database server. Instead, business logic resides in the second tier as components that analyze data, perform computations, or retrieve information from data sources and process it. You design a Jaguar application by coding these tasks into an interface and into method prototypes.

A primary benefit of this model is that you can include pre-built components in the Jaguar application. If these components have been built outside Jaguar, you can import them using the Jaguar Manager. Importing components adds their interfaces and method prototypes to Jaguar. The client and components are built from the same interface and method prototypes. You can build the client and components concurrently, as long as the client and component development teams notify each other if either of them changes the interface or method prototypes.