1.4 The EJB philosophy
The EJB Specification is based on a small number of fundamental principles, an appreciation of which will help the developer to understand why the Specification has the form that it does.
EJB applications are loosely coupled This is discussed at [EJB2.0 5.4]. The EJB Specification was designed from the outset to support the integration of components from different vendors. For example, EJBs refer to other components and services to which they have access by arbitrary names. These names can be mapped onto real names without modifying program code. This allows EJBs to be authored without detailed knowledge of the environment in which they will be used or of the other components with which they will interact.
In traditional software engineering, this principle is called 'loose coupling.' A loosely coupled system is easier to test and maintain, and its components are easier to reuse.
The Specification distinguishes carefully between the role of the 'component provider' and the 'application assembler,' even though in practice these may be the same person or people. As we shall see, an 'application assembler' is someone who builds an application from separate EJBs, perhaps from different sources. The assembler's roles include resolving naming conflicts between the different components and ensuring that transactions are propagated between components correctly. These factors are largely controlled declarativelyin XML filesnot in Java code, allowing applications to be assembled without code changes.
EJB behaviour is specified by interfaces The clients of EJBs do not, in principle, need access to the EJB implementation code itself, either at compile time or runtime. An EJB's interaction with its clients is specified entirely in terms of Java interfaces. These interfaces expose the methods that clients can call, and thereby set out a 'contract' between the client and the EJB.
Developers who work with systems that do not enforce this strict separation between 'interface' and 'implementation' sometimes find the use of interfaces a burden in EJB development; nevertheless, it increases portability and modularity, and makes it easier to support integration with non-Java components (in which interfaces may be specified using IDL, for example).
EJB applications do not manage resources As far as possible, EJBs get access to external resources (databases, legacy systems) through their container.
It is the container's job to manage these resources and make the access as efficient as possible. In most cases, the container will implement resource-sharing and pooling schemes to support this. The programmer does not have to worry about resource allocation and deallocation. The EJB container itself cannot be configured or managed through API calls. It is the administrator's responsibility to configure resource sharing policies, not the developer's.
The container supports the application developer This is particularly important where persistence management and transaction coordination is required. When Version 1.1 of the EJB Specification was current, developers were loathe to use container-managed persistence (CMP). In Version 2.0, the CMP strategy has been radically revised. It is now possible to define container-managed relationships between objects as well as container-managed persistent data. These features are straightfoward to use when fully understood and significantly ease the development process. However, for these advantages to be fully realized, the developer must 'buy in' wholeheatedly and develop in the spirit of the EJB model.
EJB applications are tiered Although it is sometimes necessary to divert from this goal for reasons of efficiency, EJB applications are easiest to manage if a strict tiered architecture is followed. The fact that there were two types of EJB in Version 1.1 of the EJB Specification made it quite natural to adopt a two-tiered model: the client-facing tier based on session EJBs, with entity EJBs deployed between the session tier and the back-end data sources. Don't worry if the terms 'session EJB' and 'entity EJB' are not clear at the moment: We will have much more to say about these, and the tiered model in general, in Section 15.1.1.
The session tier is the API to the application Ideally, the entire business logic of the application should be encapsulated within its EJBs and exposed via the outermost tier. In most applications, this tier will consist of session EJBs, message-driven EJBs, or both. Thus, the session tier can be seen as the 'API to the application.' This interpretation favours the view that the application consists of services that are exposed through the outermost tier of EJBs. Clients that wish to get access to the services can do so, supplying input and rendering output as they see fit. If this logic is followed to its conclusion, then it becomes a very straightforward matter to provide a range of di3erent types of client for the same application. It also tends to decouple some of the internal business logic from the needs of the client, particularly that related to access to the back-end services.
Not all Web-based applications will benefit from being developed using EJBs. However, there is a tendency for developers of Web applications to have business logic in servlets, even when they are using EJBs. This reduces the effectiveness of the tier model and couples the servlet tier to the data model, leading to reduced ease of maintenance.
The entity tier is the API to the data sources If the session tier is the 'API to the application,' then the entity EJB tier is an 'API to the database.' What this means is that the entity tier hides the back-end datasources behind an object-oriented (or at least component-oriented) facade. This tier therefore exposes back-end functionality via the methods of its EJBs. There should therefore be little or no business logic in this tier. If this is taken to its logical conclusion, the application's business logic in the session tier is completely decoupled from the data representation. Again, this increases ease of maintenance.
There are sometimes good reasons for not following this architectural blueprint strictly, usually related to performance. Of course, imposing a new layer of abstraction in a system always leads to some performance penalty, however small. In earlier versions of the EJB Specification, and products that implemented it, it was probably fair to say that the performance penalties were more severe than they should have been. For example, using entity EJBs strictly to iterate a large database table could be breathtakingly slow. Recent changes to the Specification allow the purity of the tiered architecture to be upheld with relatively little degradation in performance, if the developer is careful.