Common Java EE Architecture

Client Tier Principles
Overview
Difficulty
Intermediate
Duration
2h 32m
Students
16
Description

This course provides an in-depth look into Java EE architecture. We'll look at client-tier principles and object-oriented programming and then delve into the various features and concepts surrounding the Java EE architecture. We'll also run through examples of the types of questions that you can expect to find on the Oracle Java EE certification exam.

Learning Objectives

  • Learn about client-tier principles
  • Understand the fundamentals of object-oriented programming
  • Learn about the following features and concepts:
    • Constructors
    • Inheritance
    • Final keyword
    • Abstract class
    • Interfaces
    • Polymorphism
    • Encapsulation
    • Non-functional requirements
    • Exception handling
    • Integrating Enterprise Resources (EAI)

Intended Audience

This course is intended for anyone who already has basic knowledge of Java and now wants to learn about Java EE 6.

Prerequisites

Basic knowledge of Java programming

Transcript

Hello dear friends. In this section, we will start Common Architectures lecture with Client Tier Design Principles. Let's begin. For a long time, Java Enterprise Edition has been the platform of choice for developing and deploying enterprise business applications in industries such as banking, insurance, retail, hospitality, travel, and telecommunications. This is because Java EE provides a standard based platform to build robust and highly scalable distributed applications that support everything from core banking operations to airline booking engines. However, developing successful Java EE applications can be a difficult task. The rich set of choices provided by the Java EE platform is daunting at first. The plethora of frameworks, utility libraries, integrated development environments, and tool options make it all the more challenging. Hence, selecting appropriate technology is critical when developing Java EE-based software.

These choices backed by architectural and design principles go a long way in building applications that are easy to maintain, reuse, and extend. In distributed computing, an application is divided into smaller parts that run simultaneously on different computers. This is also referred to as network computing because the smaller parts communicate over the network generally using protocols built on top of TCP IP or UDP. The smaller application parts are called tiers. Each tier provides an independent set of services that can be consumed by the connecting or client tier. The tiers can be further divided into layers which provide granular level functions. Most applications have three distinct layers: Presentation layer, business layer, and data access layer. The presentation layer is responsible for the user interfaces. The business layer executes the business rules. In the process, it also interacts with the data access layer.

The data access layer is responsible for retrieving and manipulating data stored in Enterprise Information Systems also known as EISs. Applications can be single tier, two tiers, three tiers or N tiers. Let us now look at the structure of these applications. The 1-Tier architecture. It is the simplest one as it is equivalent to running the application on a personal computer. All of the required components for an application to run are on a single application or server. Presentation layer, business logic layer, and data layer are all located on a single machine. Let's move on to 2-Tier. The 2-Tier design is similar to the client-server architecture in that communication occurs between the client and the server. In this type of software architecture, the presentation layer, also referred to as the user interface layer, operates on the client side while the dataset layer is executed and stored on the server.

There is neither a business logic layer nor an intermediate layer between the client and the server. Let's now examine the 3-Tier architecture. 2-Tier thick client applications are easy to develop but any software upgrade because of changes in user interface or business logic has to be rolled out for all the clients. Luckily, hardware costs became cheaper and processing power increased significantly on the CPU in the mid '90s. This, coupled with the growth of the Internet and web-based application development trends resulted in the emergence of 3-Tier architectures. In 3-Tier, the application logic or process lives in the middle tier, it is separated from the data and the user interface. 3-Tier systems are more scalable, robust, and flexible. In addition, they can integrate data from multiple sources.

In the 3-Tier architecture, a middle tier was added between the user system interface, client environment and the database management server environment. There are a variety of ways of implementing this middle tier such as transaction processing monitors, message servers or application servers. Let's now examine the N-Tier architecture. N-Tier architecture is also known as multitier architecture since the software is designed to physically and logically divide the processing, data management, and presentation tasks. This means that these various functions are hosted on multiple servers or clusters ensuring that services are offered without sharing resources, and as a result, are given at maximum capacity. 

The N in N-Tier architecture refers to any integer starting with 1. Not only does your software benefit from being able to obtain services at the lowest possible cost but is also easier to manage. This is because while you work on one area, the modifications you make will not affect the other functions. And if there is a problem, it is simple to locate its source. In these tiers, you must also apply an object-oriented approach and some principles like solid and design patterns. In the following lessons, we will look at solid and design patterns in detail.

But first, let's explore the object-oriented approach and concepts. Object-Oriented Analysis and Design, also known as OOAD, is an engineering technique that models a system as a group of interacting objects. Each object represents an entity of interest in the system being modeled and is characterized by its class, state, and behavior. Models can be created to illustrate the static structure, dynamic behavior, and runtime deployment of these collaborating objects. That concludes our introduction to object-oriented programming. We'll continue discussing object-oriented concepts in the following video. So, let's keep our momentum rolling and I'll see you in the next video.

 

About the Author
Students
413
Courses
35
Learning Paths
2

OAK Academy is made up of tech experts who have been in the sector for years and years and are deeply rooted in the tech world. They specialize in critical areas like cybersecurity, coding, IT, game development, app monetization, and mobile development.

Covered Topics