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.