1.2 Enterprise Architecture Styles

1.2 Enterprise Architecture Styles

J2EE Architecture

-          The client/server application architecture.

-          Which was a two-tier architecture.

-          Evolved over time to a multitier architecture.

-          This natural progression occurred as additional tiers were introduced between the end-user clients and back-end systems.

-          Although a multitier architecture brings greater flexibility of design.

-          It also increases the

o   complexity of building,

o   testing, deploying,

o   administering, and

o    maintaining application components.

Two-Tier Architecture

-          The two-tier architecture is also known as the client/server architecture.

-          It consists mainly of two tiers:

o   data and

o   client (GUI).

-          The application logic can be located in either the client tier.

-          Which results in a fat client or located in the data tier.

-          which results in a fat server (see Figure).

[ Figure :  Two-tier architecture. ]

-          This type of architecture suffers from a lack of scalability.

-          Because both the client and the server have limited resources.

-          In addition to the negative effect of network traffic to transfer data to the fat client.

-          Another issue is maintainability.

-          We have to roll out the new system version to all system users.

Three-Tier Architecture

-          To address the issues of the two-tier architecture, the application logic will be placed in its own tier.

-          Thus applications can be portioned into three tiers.

-          The first tier is referred to as the presentation layer, and consists of the application GUI.

-          The middle tier, or the business layer, consists of the business logic to retrieve data for the user requests.

-          The back-end tier, or data layer, consists of the data needed by the application.

-          Figure illustrates the three-tier architecture.

[ Figure : Three-tier architecture. ]

-          The decoupling of application logic from either presentation or data increases the flexibility of the application design.

-          Multiple views or a GUI can be added without changing the existing application logic.

-          Similarly, multiple applications can be created using the same data model.

-          Changing the components of one tier should not impact the other two tiers.

-          For example, any change to the data or GUI will not affect the application logic.

Note :- 1

-          The three-tier architecture is the basis for J2EE applications.

-          In which EJBs provide a mechanism to build application logic.

-          While JSPs and servlets abstract the presentation layer and allow interaction with the business layer.

-          One important feature of the three-tier architecture is sharing system resources by all clients.

-          Which results in :

o   highly efficient,

o   scalable,

o   secure, and

o   reliable applications.

Multitier J2EE Architecture

-          Multitier (or n-tier) architecture differs from the three-tier architecture in viewing each tier logically.

-          Rather than physically.

-          The application logic, for example, can be split into more than one layer; the business logic tier and the presentation logic tier.

-          Similarly, the user interface is partitioned into the client tier and the presentation tier.

-          A multitier architecture determines where the software components that make up a computing system are executed in relation to each other and to the hardware, network, and users.

-          J2EE is a multitier architecture, which partitions the application into client,

o   presentation logic,

o   business logic, and

o   enterprise information tiers.

Note : - 2

-          The J2EE platform is designed not only to support a multitier architecture to partition applications.

-          But also to provide infrastructure common services to reduce the complexity of developing and deploying these applications.

-          Other than multitier, the J2EE architecture provides the enterprise with common infrastructure services.

-          Which help in developing and deploying :

o   portable,

o   secure and

o   transactional applications.

-          The J2EE architecture partitions enterprise applications into three fundamental parts:

o   components,

o   containers, and

o   connectors.

-          Components are the key focus of application developers.

-          Whereas system vendors implement containers and

-          Connectors to hide complexity and enhance portability.

-          Enterprise Java applications can run on any J2EE-compliant application server.

Note :- 3

-          Multitier distributed applications follow the Model-View-Controller (MVC) paradigm,.

-          This design pattern provides clean separation between tiers.

-          Using this paradigm, the model (data tier) is separated from the view (client and presentation tiers).

-          Similarly, the controller (the application logic tier) is separated from both the view and the model.

-          Containers transparently provide common services :

o   including transaction,

o   security,

o   persistence, and

o   resource pooling, to both clients and components.

-          A container allows the configuration of applications.

-          And components at deployment.

-          Rather than hard-coding them in program code.

-          Connectors extend the J2EE platform.

-          By defining a portable client service API to plug into existing enterprise vendor products.

-          Connectors promote flexibility by enabling a variety of implementations of specific services.