August 2010

Master of Science in Information Technology (MScIT-NEW) – Semester 3

MT0045 –: Java– 2 Credits(Book ID: B0831)

Assignment Set – 1 (20 Marks)

1. Explain the following features of java

a) Multithreaded

A fundamental concept of computer programming is the idea of handling more than one task at a

time. Within a program these separately running pieces are called threads and the general concept is

called multithreading.

The Java Virtual Machine allows an application to have multiple threads of execution running

concurrently. Each thread has a priority. Threads with higher priority are executed in preference to

threads with lower priority. When a Java Virtual Machine starts up there is usually a single non-

daemon thread. The Java Virtual Machine continues to execute threads until either of the following

occurs.

The exit method of class Runtime has been called and the security manager has permitted the exit

operation to take place.

All threads that are not daemon threads have died either by returning from the call to the run method

or by performing the stop method.

There are two ways to create a new thread of execution. One is to declare a class to be subclass of

Thread. This subclass should override the run method of class Thread. An instance of the subclass can

then be allocated and started.

Dynamic

While executing the java program the user can get the required files dynamically from a local drive or

from a computer thousands of miles away from the user just by connecting with the Internet.

2. Explain how you can compile and execute a java program.

Let’s assume that the JDK has been installed in

C:\Program Files\java\jdk1.6.0_07

and your program is stored in a file AreaOfSquare.java in the folder C:\MyJava.

We will run our programs using the “Command Prompt” window. This is also called the MS-DOS

window.

Open the window by clicking on Start > All Programs > Accessories > Command Prompt

At the command prompt >, type cd C:\MyJava

The window should now look as follows (your first lines may be slightly different):

This changes the directory to the folder containing your program, AreaOfSquare.java.

To compile the program, we would like to type

javac AreaOfSquare.java

where javac.exe is the file containing the compiler.

However, if we did this, we would get a message to the effect that javac is unknown.

1

The file javac.exe is found in the bin folder of the JDK.

C:\Program Files\java\jdk1.6.0_07\bin is called the “path” to the compiler. We must tell Windows

where to find the compiler by setting the Path “environment variable.”

How to set the "Path"

To set Path, go to Start > Control Panel and open the System control panel.

Click on the Advanced tab and then on Environment Variables. In the section System variables, click

on Path (you may need to scroll) and then on Edit. In the pop-up window, click in the Variable value

field and use the right arrow key to go to the end of the field.

Type a semi-colon ( ; ) if one is not present as the last character on the line. After the semi-colon, type

the path C:\Program Files\java\jdk1.6.0_07\bin\ or C:\ jdk1.6\bin\ or to wherever you installed it.

Click OK all the way out to the Control Panel.

Now you can type

javac xxxx.java

(where xxxx is the name of your program) from any command prompt and Windows will know where

to find the compiler.

Helpful hint: if you’ve set Path correctly and it doesn’t work, close the Command Prompt window and

then reopen it. (If it is open when you set Path, it will not recognize the change.)

Compile and execute

Now that you’ve set Path, you can compile the program with

javac AreaOfSquare.java

If there are no errors in the program, the compiler will create a file called AreaOfSquare.class in the

folder C:\MyJava. This file contains the Java bytecode (think of it as machine language) equivalent of

the source program.

2

To execute the program, type

java AreaOfSquare

(Note that you do not type .class.) This invokes the Java interpreter, java.exe, also stored in the bin

folder of the JDK. The Java interpreter will execute the code in the class file.

Here, the computer will type

Enter length of side:

and wait for you to enter a number. Suppose you type 12. The screen will then look like this:

Enter length of side: 12

Area of square is 144

and you are returned to the command prompt. The following shows the Command Prompt window at

the end of the above activities:

3. Explain the switch statement in java.

The switch statement transfers control to one of several statements depending on the value of an

expression.

SwitchStatement:

switch ( Expression ) SwitchBlock

SwitchBlock:

{ SwitchBlockStatementGroupsopt SwitchLabelsopt }

3

SwitchBlockStatementGroups:

SwitchBlockStatementGroup

SwitchBlockStatementGroups SwitchBlockStatementGroup

SwitchBlockStatementGroup:

SwitchLabels BlockStatements

SwitchLabels:

SwitchLabel

SwitchLabels SwitchLabel

SwitchLabel:

case ConstantExpression :

default :

The type of the Expression must be char, byte, short, or int, or a compile-time error occurs.

The body of a switch statement is known as a switch block. Any statement immediately contained by

the switch block may be labeled with one or more case or default labels. These labels are said to be

associated with the switch statement, as are the values of the constant expressions (§15.28) in the

case labels.

All of the following must be true, or a compile-time error will result:

Every case constant expression associated with a switch statement must be assignable (§5.2) to the

type of the switch Expression.

No two of the case constant expressions associated with a switch statement may have the same value.

At most one default label may be associated with the same switch statement. In C and C++ the body of

a switch statement can be a statement and statements with case labels do not have to be immediately

contained by that statement. Consider the simple loop:

for (i = 0; i < n; ++i) foo();

4

where n is known to be positive. A trick known as Duff's device can be used in C or C++ to unroll the

loop, but this is not valid code in the Java programming language:

int q = (n+7)/8;

switch (n%8) {

case 0: do { foo(); // Great C hack, Tom,

case 7: foo(); // but it's not valid here.

case 6: foo();

case 5: foo();

case 4: foo();

case 3: foo();

case 2: foo();

case 1: foo();

} while (--q >= 0);

}

Fortunately, this trick does not seem to be widely known or used. Moreover, it is less needed

nowadays; this sort of code transformation is properly in the province of state-of-the-art optimizing

compilers.

When the switch statement is executed, first the Expression is evaluated. If evaluation of the

Expression completes abruptly for some reason, the switch statement completes abruptly for the same

reason. Otherwise, execution continues by comparing the value of the Expression with each case

constant. Then there is a choice:

If one of the case constants is equal to the value of the expression, then we say that the case matches,

and all statements after the matching case label in the switch block, if any, are executed in sequence. If

all these statements complete normally, or if there are no statements after the matching case label,

then the entire switch statement completes normally.

If no case match but there is a default label, then all statements after the matching default label in the

switch block, if any, are executed in sequence. If all these statements complete normally, or if there

are no statements after the default label, then the entire switch statement completes normally.

If no case matches and there is no default label, then no further action is taken and the switch

statement completes normally.

5

If any statement immediately contained by the Block body of the switch statement completes

abruptly, it is handled as follows:

If execution of the Statement completes abruptly because of a break with no label, no further action is

taken and the switch statement completes normally.

If execution of the Statement completes abruptly for any other reason, the switch statement

completes abruptly for the same reason. The case of abrupt completion because of a break with a

label is handled by the general rule for labeled statements.

As in C and C++, execution of statements in a switch block "falls through labels."

For example, the program:

class Toomany {

static void howMany(int k) {

switch (k) {

case 1: System.out.print("one ");

case 2: System.out.print("too ");

case 3: System.out.println("many");

}

}

public static void main(String[] args) {

howMany(3);

howMany(2);

howMany(1);

}

}

contains a switch block in which the code for each case falls through into the code for the next case. As

a result, the program prints:

many

too many

one too many

6

If code is not to fall through case to case in this manner, then break statements should be used, as in

this example:

class Twomany {

static void howMany(int k) {

switch (k) {

case 1: System.out.println("one");

break; // exit the switch

case 2: System.out.println("two");

break; // exit the switch

case 3: System.out.println("many");

break; // not needed, but

good style

}

}

public static void main(String[] args) {

howMany(1);

howMany(2);

howMany(3);

}

}

This program prints:

one

two

many

4. What is an Exception? What are the different types of Exceptions?

7

Exceptions are the customary way in Java to indicate to a calling method that an abnormal condition

has occurred. When a method encounters an abnormal condition (an exception condition) that it can't

handle itself, it may throw an exception. When a program violates the semantic constraints of the Java

programming language, the Java virtual machine signals this error to the program as an exception. An

example of such a violation is an attempt to index outside the bounds of an array.

Some programming languages and their implementations react to such errors by peremptorily

terminating the program; other programming languages allow an implementation to react in an

arbitrary or unpredictable way. Neither of these approaches is compatible with the design goals of the

Java platform: to provide portability and robustness. Instead, the Java programming language specifies

that an exception will be thrown when semantic constraints are violated and will cause a non-local

transfer of control from the point where the exception occurred to a point that can be specified by the

programmer. An exception is said to be thrown from the point where it occurred and is said to be

caught at the point to which control is transferred.

Throwing an exception is like throwing a beeping, flashing red ball to indicate there is a problem that

can't be handled where it occurred. Somewhere, you hope, this ball will be caught and the problem

will be dealt with. Exceptions are caught by handlers positioned along the thread's method invocation

stack. If the calling method isn't prepared to catch the exception, it throws the exception up to its

calling method, and so on. If one of the threads of your program throws an exception that isn't caught

by any method along the method invocation stack, that thread will expire. When you program in Java,

you must position catchers (the exception handlers) strategically, so your program will catch and

handle all exceptions from which you want your program to recover.

Exception classes

In Java, exceptions are objects. When you throw an exception, you throw an object. You can't throw

just any object as an exception, however -- only those objects whose classes descend from Throwable.

Throwable serves as the base class for an entire family of classes, declared in java.lang, that your

program can instantiate and throw. A small part of this family is shown in Figure 1.

As you can see in Figure 1, Throwable has two direct subclasses, Exception and Error. Exceptions

(members of the Exception family) are thrown to signal abnormal conditions that can often be handled

by some catcher, though it's possible they may not be caught and therefore could result in a dead

thread. Errors (members of the Error family) are usually thrown for more serious problems, such as

8

OutOfMemoryError, that may not be so easy to handle. In general, code you write should throw only

exceptions, not errors. Errors are usually thrown by the methods of the Java API, or by the Java virtual

machine itself.

Figure 1. A partial view of the Throwable family

In addition to throwing objects whose classes are declared in java.lang, you can throw objects of your

own design. To create your own class of throwable objects, you need only declare it as a subclass of

some member of the Throwable family. In general, however, the throwable classes you define should

extend class Exception. They should be "exceptions." The reasoning behind this rule will be explained

later in this article.

Whether you use an existing exception class from java.lang or create one of your own depends upon

the situation. In some cases, a class from java.lang will do just fine. For example, if one of your

methods is invoked with an invalid argument, you could throw IllegalArgumentException, a subclass of

RuntimeException in java.lang.

Other times, however, you will want to convey more information about the abnormal condition than a

class from java.lang will allow. Usually, the class of the exception object itself indicates the type of

abnormal condition that was encountered. For example, if a thrown exception object has class

IllegalArgumentException, that indicates someone passed an illegal argument to a method. Sometimes

9

you will want to indicate that a method encountered an abnormal condition that isn't represented by a

class in the Throwable family of java.lang.

As an example, imagine you are writing a Java program that simulates a customer of a virtual café drinking a cup of coffee. Consider the exceptional conditions that might occur while the customer sips. The class hierarchy of exceptions shown in Figure 2 represents a few possibilities.

Figure 2. Exception hierarchy for coffee sipping

If the customer discovers, with dismay, that the coffee is cold, your program could throw a

TooColdException. On the other hand, if the customer discovers that the coffee is overly hot, your

program could throw a TooHotException. These conditions could be exceptions because they are

(hopefully) not the normal situation in your café. (Exceptional conditions are not necessarily rare, just

outside the normal flow of events.) The code for your new exception classes might look like this:

// In Source Packet in file except/ex1/TemperatureException.java

class TemperatureException extends Exception {

}

// In Source Packet in file except/ex1/TooColdException.java

class TooColdException extends TemperatureException {

}

10

// In Source Packet in file except/ex1/TooHotException.java

class TooHotException extends TemperatureException {

}

This family of classes, the TemperatureException family, declares three new types of exceptions for

your program to throw. Note that each exception indicates by its class the kind of abnormal condition

that would cause it to be thrown: TemperatureException indicates some kind of problem with

temperature; TooColdException indicates something was too cold; and TooHotException indicates

something was too hot. Note also that TemperatureException extends Exception -- not Throwable,

Error, or any other class declared in java.lang.

Exceptions in Java

Throwable Class

The Throwable class provides a String variable that can be set by the subclasses to provide a detail

message that provides more information of the exception occurred. All classes of throwables define a

one-parameter constructor that takes a string as the detail message.

The class Throwable provides getMessage() function to retrieve an exception. It has a printStackTrace()

method to print the stack trace to the standard error stream. Lastly It also has a toString() method to

print a short description of the exception. For more information on what is printed when the following

messages are invoked, please refer the java docs.

Syntax

String getMessage()

void printStackTrace()

String toString()

Class Exception

11

The class Exception represents exceptions that a program faces due to abnormal or special conditions

during execution. Exceptions can be of 2 types: Checked (Compile time Exceptions)/ Unchecked (Run

time Exceptions).

Class RuntimeException

Runtime exceptions represent programming errors that manifest at runtime. For example

ArrayIndexOutOfBounds, NullPointerException and so on are all subclasses of the

java.lang.RuntimeException class, which is a subclass of the Exception class. These are basically

business logic programming errors.

Class Error

Errors are irrecoverable condtions that can never be caught. Example: Memory leak, LinkageError etc.

Errors are direct subclass of Throwable class.

Checked and Unchecked Exceptions

Checked exceptions are subclass’s of Exception excluding class RuntimeException and its subclasses.

Checked Exceptions forces programmers to deal with the exception that may be thrown. Example:

Arithmetic exception. When a checked exception occurs in a method, the method must either catch

the exception and take the appropriate action, or pass the exception on to its caller

Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses

also are unchecked. Unchecked exceptions , however, the compiler doesn’t force the programmers to

either catch the exception or declare it in a throws clause. In fact, the programmers may not even

know that the exception could be thrown. Example: ArrayIndexOutOfBounds Exception. They are

either irrecoverable (Errors) and the program should not attempt to deal with them, or they are logical

programming errors. (Runtime Exceptions). Checked exceptions must be caught at compile time.

Runtime exceptions do not need to be. Errors often cannot be.

Exception Statement Syntax

Exceptions are handled using a try-catch-finally construct, which has the Syntax

12

try {

<code>

} catch (<exception type1> <parameter1>) { // 0 or more

<statements>

}

} finally { // finally block

<statements>

}

try Block

The java code that you think may produce an exception is placed within a try block for a

suitable catch block to handle the error.

If no exception occurs the execution proceeds with the finally block else it will look for the

matching catch block to handle the error. Again if the matching catch handler is not found execution

proceeds with the finally block and the default exception handler throws an exception. If an exception

is generated within the try block, the remaining statements in the try block are not executed.

catch Block

Exceptions thrown during execution of the try block can be caught and handled in a catch block. On

exit from a catch block, normal execution continues and the finally block is executed

(Though the catch block throws an exception).

finally Block

A finally block is always executed, regardless of the cause of exit from the try block, or whether any

catch block was executed. Generally finally block is used for freeing resources, cleaning up, closing

connections etc. If the finally clock executes a control transfer statement such as a return or a break

statement, then this control statement determines how the execution will proceed regardless of any

return or control statement present in the try or catch.

The following program illustrates the scenario.

try { <code>} catch (<exception type1> <parameter1>) { // 0 or more <statements>

13

}} finally { // finally block <statements>}

Output

Computing Division.Exception : / by zeroFinally Block Executes. Exception Occurredresult : -1

August 2010

Master of Science in Information Technology (MScIT-NEW) – Semester 3

MT0045 –: Java– 2 Credits

(Book ID: B0831)

Assignment Set – 2 (20 Marks)

Each question carries 5 marks

1. What are the different methods used in Input stream class and output stream class.

The java.io package contains two classes, InputStream and OutputStream, from which most of

the other classes in the package derive.

14

Figure : InputStream class hierarchy (partial)

The InputStream class is an abstract superclass that provides a minimal programming interface and a

partial implementation of input streams. The InputStream class defines methods for reading bytes or

arrays of bytes, marking locations in the stream, skipping bytes of input, finding out the number of

bytes available for reading, and resetting the current position within the stream. An input stream is 15

automatically opened when you create it. You can explicitly close a stream with the close method, or

let it be closed implicitly when the InputStream is garbage collected. Remember that garbage

collection occurs when the object is no longer referenced.

Methods available in InputSteam:

int available()

Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream.

void close()

Closes this input stream and releases any system resources associated with the stream.

void mark(int readlimit)

Marks the current position in this input stream.

boolean markSupported()

Tests if this input stream supports the mark and reset methods.

abstract int read()

Reads the next byte of data from the input stream.

int read(byte[] b)

Reads some number of bytes from the input stream and stores them into the buffer array b.

int read(byte[] b, int off, int len)

Reads up to len bytes of data from the input stream into an array of bytes.

void reset()

Repositions this stream to the position at the time the mark method was last called on this input stream.

long skip(long n)

Skips over and discards n bytes of data from this input stream.

16

Figure : OutputStream class hierarchy (partial)

The OutputStream class is an abstract superclass that provides a minimal programming interface and a

partial implementation of output streams. OutputStream defines methods for writing bytes or arrays

of bytes to the stream. An output stream is automatically opened when you create it. You can explicitly

close an output stream with the close method, or let it be closed implicitly when the OutputStream is

garbage collected, which occurs when the object is no longer referenced.

Methods available in InputSteam:

void close()

17

Closes this output stream and releases any system resources associated with this stream.

void flush()

Flushes this output stream and forces any buffered output bytes to be written out.

void write(byte[] b)

Writes b.length bytes from the specified byte array to this output stream.

void write(byte[] b, int off, int len)

Writes len bytes from the specified byte array starting at offset off to this output stream.

abstract void write(int b)

Writes the specified byte to this output stream.

The java.io package contains several subclasses of InputStream and OutputStream that implement

specific input or output functions. For example, FileInputStream and FileOutputStream are input and

output streams that operate on files on the native file system.

The first of the following two figures shows the class hierarchy for the input stream classes in the

java.io package. The second figure shows the class hierarchy for the output stream classes in the

java.io package.

read and write methods

InputStream class defines the following methods for reading bytes -

int read() throws IOException

int read(byte b[]) throws IOException

int read(byte b[], int offset, int length) throws IOException

Subclasses of InputStream implement the above mentioned methods.

OutputStream class defines the following methods for writing bytes -

void write(int b) throws IOException

void write(byte b[]) throws IOException

void write(byte b[], int offset, int length) throws IOException

Subclasses of OutputStream implement the above mentioned methods

18

2. What are Applets? What are different methods used to describe the life cycle

of an applet?

An applet is a special kind of Java program that a browser enabled with Java technology can download from the internet and run. An applet is typically embedded inside a web page and runs in the context of a browser. An applet must be a subclass of the java.applet.Applet class. The Applet class provides the standard interface between the applet and the browser environment.

Swing provides a special subclass of the Applet class called javax.swing.JApplet. The JApplet class should be used for all applets that use Swing components to construct their graphical user interfaces (GUIs).

The browser's Java Plug-in software manages the lifecycle of an applet.

An applet can react to major events in the following ways:

It can initialize itself. It can start running. It can stop running. It can perform a final cleanup, in preparation for being unloaded.

This section introduces a new applet, Simple, that uses all of these methods. Unlike Java applications, applets do not need to implement a main method.

Here is the Simple applet.

The following is the source code for the Simple applet. This applet displays a descriptive string whenever it encounters a major milestone in its life, such as when the user first visits the page the applet is on.

import java.applet.Applet;import java.awt.Graphics;

//No need to extend JApplet, since we don't add any components;//we just paint.public class Simple extends Applet {

StringBuffer buffer;

public void init() { buffer = new StringBuffer(); addItem("initializing... ");

19

}

public void start() { addItem("starting... "); }

public void stop() { addItem("stopping... "); }

public void destroy() { addItem("preparing for unloading..."); }

private void addItem(String newWord) { System.out.println(newWord); buffer.append(newWord); repaint(); }

public void paint(Graphics g) {//Draw a Rectangle around the applet's display area.

g.drawRect(0, 0, getWidth() - 1, getHeight() - 1);

//Draw the current string inside the rectangle. g.drawString(buffer.toString(), 5, 15); }}

Here are the lifecycle methods of an Applet:

init(): This method is called to initialized an applet

start(): This method is called after the initialization of the applet.

stop(): This method can be called multiple times in the life cycle of an Applet.

destroy(): This method is called only once in the life cycle of the applet when applet is destroyed.

init () method: The life cycle of an applet is begin on that time when the applet is first loaded into

the browser and called the init() method. The init() method is called only one time in the life cycle

on an applet. The init() method is basically called to read the PARAM tag in the html file. The init ()

method retrieve the passed parameter through the PARAM tag of html file using get Parameter()

method All the initialization such as initialization of variables and the objects like image, sound file 20

are loaded in the init () method .After the initialization of the init() method user can interact with

the Applet and mostly applet contains the init() method.

Start () method: The start method of an applet is called after the initialization method init(). This

method may be called multiples time when the Applet needs to be started or restarted. For Example

if the user wants to return to the Applet, in this situation the start Method() of an Applet will be

called by the web browser and the user will be back on the applet. In the start method user can

interact within the applet.

Stop () method: The stop() method can be called multiple times in the life cycle of applet like the

start () method. Or should be called at least one time. There is only miner difference between the

start() method and stop () method. For example the stop() method is called by the web browser on

that time When the user leaves one applet to go another applet and the start() method is called on

that time when the user wants to go back into the first program or Applet.

destroy() method: The destroy() method is called only one time in the life cycle of Applet like init()

method. This method is called only on that time when the browser needs to Shut down.

3. What do you mean by java bean? What are the advantages of java beans?

JavaBeans are reusable software components for Java that can be manipulated visually in a builder

tool. Practically, they are classes written in the Java programming language conforming to a particular

convention. They are used to encapsulate many objects into a single object (the bean), so that they

can be passed around as a single bean object instead of as multiple individual objects. A JavaBean is a

Java Object that is serializable, has a nullary constructor, and allows access to properties using getter

and setter methods.

JavaBeans is Java's component model. It allows users to construct applications by piecing components

together either programmatically or visually (or both). Support of visual programming is paramount to

the component model; it's what makes component-based software development truly powerful.

The model is made up of architecture and an API (Application Programming Interface). Together, these

elements provide a structure whereby components can be combined to create an application. This

21

environment provides services and rules, the framework that allows components to participate

properly. This means that components are provided with the tools necessary to work in the

environment, and they exhibit certain behaviors that identify them as such. One very important aspect

of this structure is containment. A container provides a context in which components can interact. A

common example would be a panel that provides layout management or mediation of interactions for

visual components. Of course, containers themselves can be components.

TestPersonBean.java:

import beans.PersonBean; /** * Class <code>TestPersonBean</code>. */public class TestPersonBean { /** * Tester method <code>main</code> for class <code>PersonBean</code>. * @param args */ public static void main(String[] args) { PersonBean person = new PersonBean(); person.setName("Bob"); person.setDeceased(false); // Output: "Bob [alive]" System.out.print(person.getName()); System.out.println(person.isDeceased() ? " [deceased]" : " [alive]"); }}

testPersonBean.jsp:

<% // Use of PersonBean in a JSP. %><jsp:useBean id="person" class="beans.PersonBean" scope="page"/><jsp:setProperty name="person" property="*"/> <html><body>Name: <jsp:getProperty name="person" property="name"/><br/>Deceased? <jsp:getProperty name="person" property="deceased"/><br/><br/>

22

<form name="beanTest" method="POST" action="testPersonBean.jsp">Enter a name: <input type="text" name="name" size="50"><br/>Choose an option:<select name="deceased"> <option value="false">Alive</option> <option value="true">Dead</option></select><input type="submit" value="Test the Bean"></form></body></html>

Advantages of Java Beans

Software component architecture provides standard mechanisms to deal with software building

blocks. The following list enumerates some of the specific benefits that Java technology provides

for a component developer:

A Bean obtains all the benefits of Java's "write-once, run-anywhere" paradigm.

The properties, events, and methods of a Bean that are exposed to an application

builder tool can be controlled.

A Bean may be designed to operate correctly in different locales, which makes it

useful in global markets.

Auxiliary software can be provided to help a person configure a Bean. This software is

only needed when the design-time parameters for that component are being set. It

does not need to be included in the run-time environment.

The configuration settings of a Bean can be saved in persistent storage and restored

at a later time.

A Bean may register to receive events from other objects and can generate events that

are sent to other objects.

4. Explain 2-tier and N-tier architecture.

2-tier architecture:

23

In a two-tier system we have a client program and a server program. The main difference between the

two is that the server responds to requests from many different clients while the clients usually initiate

the requests for information from a single server.

Two-tier client/server architectures have 2 essential components

1. A Client PC and

2. A Database Server

2-Tier Considerations:

• Client program accesses database directly

o Requires a code change to port to a different database

o Potential bottleneck for data requests

o High volume of traffic due to data shipping

• Client program executes application logic

o Limited by processing capability of client workstation (memory, CPU)

o Requires application code to be distributed to each client workstation

24

Figure 7.1 Client/Server 2-Tier Architecture

Usually N-Tier Architecture begins as a 3-Tier model and is expanded. It provides finer granularity.

Granularity is the ability of a system, in this case, an application, to be broken down into smaller

components or granules. The finer the granularity, the greater the flexibility of a system. It can also be

referred to as a system’s modularity. Therefore, it refers to the pulling apart of an application into

separate layers or finer grains.

One of the best examples of N-Tier Architecture in web applications is the popular shopping-cart web

application. The client tier interacts with the user through GUIs (Graphic User Interfaces) and with the

application and the application server. In web applications, this client tier is a web browser. In addition

to initiating the request, the web browser also receives and displays code in dynamic HTML (Hypertext

Markup Language), the primary language of the World Wide Web. In a shopping cart web 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. This layer calls custom tags throughout the

network and to other networks. It also calls database stored procedures and web services, all in the

goal of providing a more sophisticated response. This layer glues the whole application together and

allows different nodes to communicate with each other and be displayed to the user through the

browser. It is located in the application server.

25

In N-Tier Architecture, the business logic tier is pulled out from the presentation tier and, as its own

layer, it controls an application’s functionality by performing detailed processing. For example, in our

shopping cart example, this tier completes credit card authorization and calculates things like shipping

costs and sales tax. The tools used to encapsulate an application’s business logic into its own layer

include web services, custom tags, and stored procedures.

The business tier can also be considered the integration layer. Encapsulation allows the application to

communicate with the data tier or the business logic tier in a way that is intelligible to all nodes.

Encapsulation is one of the principles of object-oriented programming (OOP) and refers to an object’s

ability to conceal its data and methods. Encapsulated objects only publish the external interface so any

user interacting with them only needs to understand the interface and can remain ignorant as to the

internal specifications. This way a user can call all sorts of services into action by calling the custom tag

without having to know the code details of what made communication or implementation possible.

The services just have to be accessible in the custom tag library. Encapsulation in the integration tier

also liberates the network from just one vendor. The integration tier allows N-Tier Architecture to be

vendor independent. In the shopping cart example, the application may have a simple custom tag for

searching inventory and providing the most up-to-date, detailed information.

See diagram of N-Tier Architecture for an overview of all these technologies and how they fit in .

26

The final application tier is the data tier. It usually consists of database servers. It keeps data neutral

and independent from application servers or business logic. Giving data its own tier also improves

scalability and performance. As it grows, it is easily moved to another, more powerful machine.

27

3-tier architecture:

A three-tier application we have a client a server and a database in which the server stores its data.

The flow of information is still essentially linear: a request comes from the client to the server; the

server requests or stores data in the database; the database returns information to the server; the

server returns information back to the client.

First, we must make a distinction between layers and tiers. Layers are the way to logically break code into components and tiers are the physical nodes to place the components on. This question explains

it better: http://stackoverflow.com/questions/120438/whats-the-difference-between-layers-and-tiers

A two layer architecture is usually just a presentation layer and data store layer. These can be on 1 tier

(1 machine) or 2 tiers (2 machines) to achieve better performance by distributing the work load.

A three layer architecture usually puts something between the presentation and data store layers

such as a business logic layer or service layer. Again, you can put this into 1, 2, or 3 tiers depending on how much money you have for hardware and how much load you expect.

Putting multiple machines in a tier will help with the robustness of the system by providing redundancy.

Below is a good example of a layered architecture:

28

An n-tier architecture, on the other hand, allows an unlimited number of programs to run

simultaneously, send information to one another, use different protocols to communicate, and

interact concurrently. This allows for a much more powerful application, providing many different

services to many different clients.

29