Article on Client – Server Technology

Client–server model
From Wikipedia, the free encyclopedia

(Redirected from Client server architecture)

Jump to: navigation, search

This article needs additional citations for verification.

Please help improve this article by adding reliable references. Unsourced material may be
challenged and removed. (August 2010)

The client–server model of computing is a distributed application structure that partitions

tasks or workloads between the providers of a resource or service, called servers, and service
requesters, called clients.[1] Often clients and servers communicate over a computer network
on separate hardware, but both client and server may reside in the same system. A server
machine is a host that is running one or more server programs which share their resources
with clients. A client does not share any of its resources, but requests a server's content or
service function. Clients therefore initiate communication sessions with servers which await
(listen for) incoming requests.

Contents
[hide]

 1 Description
 2 Comparison to peer-to-peer architecture
 3 Advantages
 4 Disadvantages
 5 See also
 6 References

[edit] Description
The client–server characteristic describes the relationship of cooperating programs in an
application. The server component provides a function or service to one or many clients,
which initiate requests for such services.

Functions such as email exchange, web access and database access, are built on the client–
server model. For example, a web browser is a client program running on a user's computer
that may access information stored on a web server on the Internet. Users accessing banking
services from their computer use a web browser client to send a request to a web server at a
bank. That program may in turn forward the request to its own database client program that
sends a request to a database server at another bank computer to retrieve the account
information. The balance is returned to the bank database client, which in turn serves it back
to the web browser client displaying the results to the user. The client–server model has
become one of the central ideas of network computing. Many business applications being
written today use the client–server model. So do the Internet's main application protocols,
such as HTTP, SMTP, Telnet, and DNS. In marketing, the term has been used to distinguish
distributed computing by smaller dispersed computers from the "monolithic" centralized
1
 Article on Client – Server Technology

computing of mainframe computers. But this distinction has largely disappeared as

mainframes and their applications have also turned to the client–server model and become
part of network computing.

Each instance of the client software can send data requests to one or more connected servers.
In turn, the servers can accept these requests, process them, and return the requested
information to the client. Although this concept can be applied for a variety of reasons to
many different kinds of applications, the architecture remains fundamentally the same.

The most basic type of client–server architecture employs only two types of hosts: clients and
servers. This type of architecture is sometimes referred to as two-tier. It allows devices to
share files and resources. The two tier architecture means that the client acts as one tier and
application in combination with server acts as another tier. The Internet increasingly uses a
three-tier architecture. In this the server side consists of an Application Server (such as Web
Server) and a Database Server (such as a SQL Server). Thus the three tiers become - Client,
Application Server and Database. All three tiers are relatively independent; for example you
can switch to a different Web Server while maintaining the integrity of the model.

The interaction between client and server is often described using sequence diagrams.
Sequence diagrams are standardized in the Unified Modeling Language.

Specific types of clients include web browsers, email clients, and online chat clients.

Specific types of servers include web servers, ftp servers, application servers, database
servers, name servers, mail servers, file servers, print servers, and terminal servers. Most web
services are also types of servers.

[edit] Comparison to peer-to-peer architecture

This section requires expansion.

In peer-to-peer architectures, each host or instance of the program can simultaneously act as
both a client and a server, and each has equivalent responsibilities and status.

Both client–server and peer-to-peer architectures are in wide usage today. Details may be
found in Comparison of Centralized (Client-Server) and Decentralized (Peer-to-Peer)
Networking.

[edit] Advantages
 In most cases, a client–server architecture enables the roles and responsibilities of a
computing system to be distributed among several independent computers that are known
to each other only through a network. This creates an additional advantage to this
architecture: greater ease of maintenance. For example, it is possible to replace, repair,
upgrade, or even relocate a server while its clients remain both unaware and unaffected by
that change.
 All data is stored on the servers, which generally have far greater security controls than most
clients.[citation needed] Servers can better control access and resources, to guarantee that only
those clients with the appropriate permissions may access and change data.
 Since data storage is centralized, updates to that data are far easier to administer in
comparison to a P2P paradigm. In the latter, data updates may need to be distributed and

2
 Article on Client – Server Technology

applied to each peer in the network, which is both time-consuming and error-prone, [citation
needed]
as there can be thousands or even millions of peers.
 Many mature client–server technologies are already available which were designed to
ensure security, friendliness of the user interface, and ease of use.[citation needed]
 It functions with multiple different clients of different capabilities.

[edit] Disadvantages
 As the number of simultaneous client requests to a given server increases, the server can
become overloaded.[citation needed] Contrast that to a P2P network, where its aggregated
bandwidth actually increases as nodes are added, since the P2P network's overall bandwidth
can be roughly computed as the sum of the bandwidths of every node in that network.
 The client–server paradigm lacks the robustness of a good P2P network.[citation needed] Under
client–server, should a critical server fail, clients’ requests cannot be fulfilled. In P2P
networks, resources are usually distributed among many nodes. Even if one or more nodes
depart and abandon a downloading file, for example, the remaining nodes should still have
the data needed to complete the download.

[edit] See also

 Hybrid client
 Inter-server
 Mainframe computer
 Mobile software
 Name server
 Observer pattern
 Push technology
 Pull technology
 Servent
 Standalone server
 Thin client
 Multitier architecture
 Client (computing)
 Server (computing)

[edit] References
1. ^ "Distributed Application Architecture". Sun Microsystem.
http://java.sun.com/developer/Books/jdbc/ch07.pdf. Retrieved 2009-06-16.

Retrieved from "http://en.wikipedia.org/wiki/Client%E2%80%93server_model"

Categories: Clients | Servers | Distributed computing architecture | Mobile software

3
Article on Client – Server Technology

4
Article on Client – Server Technology

5
 Article on Client – Server Technology

Multitier architecture
From Wikipedia, the free encyclopedia

(Redirected from 3-tier architecture)

Jump to: navigation, search

For other uses, see Three-tier system (disambiguation).

This article does not cite any references or sources.

Please help improve this article by adding citations to reliable sources. Unsourced material may be
challenged and removed. (January 2008)

In software engineering, multi-tier architecture (often referred to as n-tier architecture) is

a client–server architecture in which the presentation, the application processing, and the data
management are logically separate processes. For example, an application that uses
middleware to service data requests between a user and a database employs multi-tier
architecture. The most widespread use of multi-tier architecture is the three-tier
architecture.

N-tier application architecture provides a model for developers to create a flexible and
reusable application. By breaking up an application into tiers, developers only have to modify
or add a specific layer, rather than have to rewrite the entire application over. There should be
a presentation tier, a business or data access tier, and a data tier.

The concepts of layer and tier are often used interchangeably. However, one fairly common
point of view is that there is indeed a difference, and that a layer is a logical structuring
mechanism for the elements that make up the software solution, while a tier is a physical
structuring mechanism for the system infrastructure.[1]

Contents
[hide]

 1 Three-tier architecture
o 1.1 Comparison with the MVC architecture
o 1.2 Web development usage
o 1.3 Other considerations
o 1.4 Traceability
o 1.5 Comments
 2 See also
 3 External links
 4 References

[edit] Three-tier architecture

6
 Article on Client – Server Technology

Visual overview of a Three-tiered application

Three-tier[2] is a client–server architecture in which the user interface, functional process

logic ("business rules"), computer data storage and data access are developed and maintained
as independent modules, most often on separate platforms. It was developed by John J.
Donovan in Open Environment Corporation (OEC), a tools company he founded in
Cambridge, MA.

The three-tier model is a software architecture and a software design pattern.

Apart from the usual advantages of modular software with well-defined interfaces, the three-
tier architecture is intended to allow any of the three tiers to be upgraded or replaced
independently as requirements or technology change. For example, a change of operating
system in the presentation tier would only affect the user interface code.

Typically, the user interface runs on a desktop PC or workstation and uses a standard
graphical user interface, functional process logic may consist of one or more separate
modules running on a workstation or application server, and an RDBMS on a database server
or mainframe contains the computer data storage logic. The middle tier may be multi-tiered
itself (in which case the overall architecture is called an "n-tier architecture").

Three-tier architecture has the following three tiers:

Presentation tier

This is the topmost level of the application. The presentation tier displays information
related to such services as browsing merchandise, purchasing, and shopping cart contents. It
communicates with other tiers by outputting results to the browser/client tier and all other
tiers in the network.

Application tier (business logic, logic tier, data access tier, or middle tier)

The logic tier is pulled out from the presentation tier and, as its own layer, it controls an
application’s functionality by performing detailed processing.
7
 Article on Client – Server Technology

Data tier

This tier consists of database servers. Here information is stored and retrieved. This tier
keeps data neutral and independent from application servers or business logic. Giving data
its own tier also improves scalability and performance.

[edit] Comparison with the MVC architecture

At first glance, the three tiers may seem similar to the model-view-controller (MVC) concept;
however, topologically they are different. A fundamental rule in a three tier architecture is the
client tier never communicates directly with the data tier; in a three-tier model all
communication must pass through the middleware tier. Conceptually the three-tier
architecture is linear. However, the MVC architecture is triangular: the view sends updates to
the controller, the controller updates the model, and the view gets updated directly from the
model.

From a historical perspective the three-tier architecture concept emerged in the 1990s from
observations of distributed systems (e.g., web applications) where the client, middleware and
data tiers ran on physically separate platforms. Whereas MVC comes from the previous
decade (by work at Xerox PARC in the late 1970s and early 1980s) and is based on
observations of applications that ran on a single graphical workstation; MVC was applied to
distributed applications much later in its history (see Model 2).

[edit] Web development usage

In the web development field, three-tier is often used to refer to websites, commonly
electronic commerce websites, which are built using three tiers:

1. A front-end web server serving static content, and potentially some are cached dynamic
content. In web based application, Front End is the content rendered by the browser. The
content may be static or generated dynamically.
2. A middle dynamic content processing and generation level application server, for example
Java EE, ASP.NET, PHP platform.
3. A back-end database, comprising both data sets and the database management system or
RDBMS software that manages and provides access to the data.

[edit] Other considerations

Data transfer between tiers is part of the architecture. Protocols involved may include one or
more of SNMP, CORBA, Java RMI, .NET Remoting, Windows Communication Foundation,
sockets, UDP, web services or other standard or proprietary protocols. Often middleware is
used to connect the separate tiers. Separate tiers often (but not necessarily) run on separate
physical servers, and each tier may itself run on a cluster.

[edit] Traceability

The end-to-end traceability of data flows through n-tier systems is a challenging task which
becomes more important when systems increase in complexity. The Application Response
Measurement defines concepts and APIs for measuring performance and correlating
transactions between tiers.

8
 Article on Client – Server Technology

[edit] Comments

This article refers to tiers and layers as equivalent concepts. General, the term tiers is used to
describe physical distribution of components of a system on separate servers, computers, or
networks (processing nodes). A three-tier architecture then will have three processing nodes.
Layers refer to a logical grouping of components which may or may not be physically located
on one processing node.

[edit] See also

 Business logic
 Client–server model
 Database-centric architecture
 Front-end and back-end
 Hierarchical internetworking model
 Model-view-controller (MVC)
 Open Services Architecture
 Rich Internet application
 Service layer
 Web application
 Load balancing (computing)
 Multilayered architecture