Winter 2012

Master of Computer Application (MCA) – Semester 4

MC0078 – Java Programming – 4 Credits(Book ID: B0831 & B0832)

(60 Marks)

Answer all Questions Each Question carries TEN marks

Book ID: B0831

Ques1. What are the difference between an interface and an abstract class?Ans. The difference between Interface and Abstract class are as follows:1. First and major difference between abstract class and interface is that, abstract class is

a class while interface is a interface, means by extending abstract class you cannot extend another class because Java does not support multiple inheritance but you can implement multiple inheritance in Java.

2. Second difference between interface and abstract class in Java is that you cannot create non abstract method in interface, every method in interface is by default abstract, but you can create non abstract method in abstract class. Even a class which doesn't contain any abstract method can be abstract by using abstract keyword.

3. Third difference between abstract class and interface in Java is that abstract class are slightly faster than interface because interface involves a search before calling any overridden method in Java. This is not a significant difference in most of cases but if you are writing a time critical application than you may not want to leave any stone unturned.

4. Fourth differences between abstract class vs. interface in Java is that, interface are better suited for Type declaration and abstract class is more suited for code reuse and evolution perspective.

5. Another notable difference between interface and abstract class is that when you add a new method in existing interface it breaks all its implementation and you need to provide an implementation in all clients which is not good. By using abstract class you can provide default implementation in super class.

Ques2. Explain the following with respect to Inheritance in Java:

a. Various Access Specifiers and their usage

b. Abstract classes and their applications

Ans.

Various Access Specifiers and their usage

An access specifier determines which features of a class (the class itself, the data

members, and the methods) may be used by other classes. Java supports three

access specifiers.

public private protected

The public Access Specifiers

All classes except inner class (class within classes) can have the public access

specifier. You can use a public class, a data member, or a method from any object

in any Java program.

ExamplePublic class publiclcass

{

Public int piblicvariable;

Public void publicmethod()

{

}

}

The private Access Specifier

Only objects of the same class can access a private variable or method. You can

declare only variables, methods, and inner classes as private.

Example

Private in privatevariable;

The protected Access Specifier

The variables, methods, and inner classes that are declared protected are

accessible to the subclasses of the class in which they are declared.

Example

protected int protectedvariable;

A b s t r a c t c la ss e s an d t hei r appli c a t ion s

An abstract class defines common properties and behaviors of other classes. An

abstract class is used as a base class to derive specific classes of the same kind. It

defines properties common to the classes derived from it. The abstract keyword is

used to declare such a class. The classes declared using the abstract keyword

cannot be instantiated.

S y ntax:

abstract class <class_name>

{

}

You can also declare abstract methods. Abstract methods have public scope.

The code below declares an abstract method for the class shape. Abstract class

shape

{

public abstract float calculateArea ();

}

The abstract method calculateArea (), given above, is inherited by the subclasses of

the shape class. The subclasses Rectangle, Circle and Hexagon implement this

method in different ways.

Public class circle extends shape

{

float radius;

public float calculateArea ()

{

return radius*22/7;

}

}In the above example, the calculateArea () method has been overridden in the circle

class. If the method is not overridden, the class will inherit the abstract method from

the parent class. Any class that has a abstract method is abstract. Hence, you would

not be able to create an object of the circle class. Therefore, it is necessary to

override the calculateArea () method in the circle class.

The final Keyword

A class called password authenticates user login. You do not want anybody to

change the functionality of the class by extending it. To prevent inheritance, use the

final modifier.

Example

final class password

{

}

You will also find final classes in JDK package. For example, the java.lang.String

class has been declared final. This is done for security reasons. It ensure that any

method that refers to the String class gets the actual String class and not a modified

one.

Ques3. Describe Exception Handling in JAVA.Ans.An exception is a problem that arises during the execution of a program. An exception can occur for many different reasons, including the following:

A user has entered invalid data. A file that needs to be opened cannot be found. A network connection has been lost in the middle of communications, or the JVM

has run out of memory.

Some of these exceptions are caused by user error, others by programmer error, and others by physical resources that have failed in some manner.

To understand how exception handling works in Java, you need to understand the three categories of exceptions:

Checked exceptions: A checked exception is an exception that is typically a user error or a problem that cannot be foreseen by the programmer. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.

Runtime exceptions: A runtime exception is an exception that occurs that probably could have been avoided by the programmer. As opposed to checked exceptions, runtime exceptions are ignored at the time of compliation.

Errors: These are not exceptions at all, but problems that arise beyond the control of the user or the programmer. Errors are typically ignored in your code because you can rarely do anything about an error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of compilation.

Exception Hierarchy

All exception classes are subtypes of the java.lang.Exception class. The exception class is a subclass of the Throwable class. Other than the exception class there is another subclass called Error which is derived from the Throwable class.

Errors are not normally trapped form the Java programs. These conditions normally happen in case of severe failures, which are not handled by the java programs. Errors are generated to indicate errors generated by the runtime environment. Example : JVM is out of Memory. Normally programs cannot recover from errors.

The Exception class has two main subclasses : IOException class and RuntimeException Class.

Here is a list of most common checked and unchecked Java's Built-in Exceptions.

Exceptions Methods

Following is the list of important methods available in the Throwable class.

SN Methods with Description

1public String getMessage()Returns a detailed message about the exception that has occurred. This message is initialized in the Throwable constructor.

2public Throwable getCause()Returns the cause of the exception as represented by a Throwable object.

3public String toString()Returns the name of the class concatenated with the result of getMessage()

4public void printStackTrace()Prints the result of toString() along with the stack trace to System.err, the error output stream.

5

public StackTraceElement [] getStackTrace()Returns an array containing each element on the stack trace. The element at index 0 represents the top of the call stack, and the last element in the array represents the method at the bottom of the call stack.

6public Throwable fillInStackTrace()Fills the stack trace of this Throwable object with the current stack trace, adding to any previous information in the stack trace.

Catching Exceptions

A method catches an exception using a combination of the try and catch keywords. A try/catch block is placed around the code that might generate an exception. Code within a try/catch block is referred to as protected code, and the syntax for using try/catch looks like the following:

try{ //Protected code}catch(ExceptionName e1){ //Catch block}

A catch statement involves declaring the type of exception you are trying to catch. If an exception occurs in protected code, the catch block (or blocks) that follows the try is checked. If the type of exception that occurred is listed in a catch block, the exception is passed to the catch block much as an argument is passed into a method parameter.

Example

The following is an array is declared with 2 elements. Then the code tries to access the 3rd element of the array which throws an exception.

// File Name : ExcepTest.javaimport java.io.*;public class ExcepTest{

public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } System.out.println("Out of the block"); }}

This would produce following result:

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3Out of the block

Multiple catch Blocks

A try block can be followed by multiple catch blocks. The syntax for multiple catch blocks looks like the following:

try{ //Protected code}catch(ExceptionType1 e1){ //Catch block}catch(ExceptionType2 e2){ //Catch block}catch(ExceptionType3 e3){ //Catch block}

The previous statements demonstrate three catch blocks, but you can have any number of them after a single try. If an exception occurs in the protected code, the exception is thrown

to the first catch block in the list. If the data type of the exception thrown matches ExceptionType1, it gets caught there. If not, the exception passes down to the second catch statement. This continues until the exception either is caught or falls through all catches, in which case the current method stops execution and the exception is thrown down to the previous method on the call stack.

Example

Here is code segment showing how to use multiple try/catch statements.

try{ file = new FileInputStream(fileName); x = (byte) file.read();}catch(IOException i){ i.printStackTrace(); return -1;}catch(FileNotFoundException f) //Not valid!{ f.printStackTrace(); return -1;}

The throws/throw Keywords

If a method does not handle a checked exception, the method must declare it using the throwskeyword. The throws keyword appears at the end of a method's signature.You can throw an exception, either a newly instantiated one or an exception that you just caught, by using the throw keyword. Try to understand the different in throws and throw keywords.

The following method declares that it throws a RemoteException:

import java.io.*;public class className{ public void deposit(double amount) throws RemoteException { // Method implementation throw new RemoteException(); } //Remainder of class definition}

A method can declare that it throws more than one exception, in which case the exceptions are declared in a list separated by commas. For example, the following method declares that it throws a RemoteException and an InsufficientFundsException:

import java.io.*;public class className{ public void withdraw(double amount) throws RemoteException, InsufficientFundsException { // Method implementation } //Remainder of class definition}

The finally Keyword

The finally keyword is used to create a block of code that follows a try block. A finally block of code always executes, whether or not an exception has occurred.

Using a finally block allows you to run any cleanup-type statements that you want to execute, no matter what happens in the protected code.

A finally block appears at the end of the catch blocks and has the following syntax:

try{ //Protected code}catch(ExceptionType1 e1){ //Catch block}catch(ExceptionType2 e2){ //Catch block}catch(ExceptionType3 e3){ //Catch block}finally{ //The finally block always executes.}

Example

public class ExcepTest{

public static void main(String args[]){ int a[] = new int[2]; try{ System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } finally{ a[0] = 6; System.out.println("First element value: " +a[0]); System.out.println("The finally statement is executed"); } }}

This would produce following result:

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3First element value: 6The finally statement is executed

Note the following:

A catch clause cannot exist without a try statement.

It is not compulsory to have finally clauses when ever a try/catch block is present.

The try block cannot be present without either catch clause or finally clause.

Any code cannot be present in between the try, catch, finally blocks.

Declaring you own Exception

You can create your own exceptions in Java. Keep the following points in mind when writing your own exception classes:

All exceptions must be a child of Throwable.

If you want to write a checked exception that is automatically enforced by the Handle or Declare Rule, you need to extend the Exception class.

If you want to write a runtime exception, you need to extend the RuntimeException class.

We can define our own Exception class as below:

class MyException extends Exception{}

You just need to extend the Exception class to create your own Exception class. These are considered to be checked exceptions. The following InsufficientFundsException class is a user-defined exception that extends the Exception class, making it a checked exception. An exception class is like any other class, containing useful fields and methods.

Example

// File Name InsufficientFundsException.javaimport java.io.*;

public class InsufficientFundsException extends Exception{ private double amount; public InsufficientFundsException(double amount) { this.amount = amount; } public double getAmount() { return amount; }}

To demonstrate using our user-defined exception, the following CheckingAccount class contains a withdraw() method that throws an InsufficientFundsException.

// File Name CheckingAccount.javaimport java.io.*;

public class CheckingAccount{ private double balance; private int number; public CheckingAccount(int number) { this.number = number; } public void deposit(double amount) {

balance += amount; } public void withdraw(double amount) throws InsufficientFundsException { if(amount <= balance) { balance -= amount; } else { double needs = amount - balance; throw new InsufficientFundsException(needs); } } public double getBalance() { return balance; } public int getNumber() { return number; }}

The following BankDemo program demonstrates invoking the deposit() and withdraw() methods of CheckingAccount.

// File Name BankDemo.javapublic class BankDemo{ public static void main(String [] args) { CheckingAccount c = new CheckingAccount(101); System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100..."); c.withdraw(100.00); System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); }catch(InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount()); e.printStackTrace();

} }}

Compile all the above three files and run BankDemo, this would produce following result:

Depositing $500...

Withdrawing $100...

Withdrawing $600...Sorry, but you are short $200.0InsufficientFundsException at CheckingAccount.withdraw(CheckingAccount.java:25) at BankDemo.main(BankDemo.java:13)

Common Exceptions

In java it is possible to define two catergories of Exceptions and Errors.

JVM Exceptions: - These are exceptions/errors that are exclusively or logically thrown by the JVM. Examples : NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException,

Programmatic exceptions . These exceptions are thrown explicitly by the application or the API programmers Examples: IllegalArgumentException, IllegalStateException.

Book ID: B0832

Ques4. What do you mean by Object Adapter? Explain with an example?

Ans.The CORBA specification defines the concept of an object adapter. An object adapter is a framework for implementing CORBA objects. It providesan API that object implementations use for various low level services.According to the CORBA specification, an object adapter is responsible forthe following functions:

Generation and interpretation of object references Method invocation Security of interactions Object and implementation activation and deactivation Mapping object references to the corresponding object implementations Registration of implementations

The architecture supports the definition of many kinds of object adapters.The specification includes the definition of the basic object adapter (BOA).In the previous section, you saw some server code that uses the services ofVisiBroker's implementation of the BOA. The BOA has been implemented in

various CORBA products. Unfortunately, since the specification of the BOAwas not complete, the various BOA implementations differ in somesignificant ways. This has compromised server portability.

To address this shortcoming, an entirely new object adapter was added, theportable object adapter (POA). Unfortunately, the POA is not yet supportedin many products. In any event, the BOA and the POA are described here.

Activation on Demand by the Basic Object Adapter (BOA)

One of the main tasks of the BOA is to support on-demand object activation.When a client issues a request, the BOA determines if the object is currentlyrunning and if so, it delivers the request to the object. If the object is notrunning, the BOA activates the object and then delivers the request. The BOA defines four different models for object activation:

Shared server Multiple active objects share the same server. The server services requests from multiple clients. The server remains active until it is deactivated or

Unshared server Only one object is active in the server. The server exits when the client that caused its activation exits.

Server-per-method

Each request results in the creation of a server. The server exits when the method completes.

Persistent server The server is started by an entity other than the BOA (you, operating services, etc.). Multiple active objects share the server.

Ques5. Describe the following with respect to implementation of Sockets in Java:a. Reading from and Writing to a Socket

b. Writing the Server Side of a Socket

Ans. Normally, a server runs on a specific computer and has a socket that is bound

to a specific port number. The server just waits, listening to the socket for a

client to make a connection request.

On the client-side: The client knows the hostname of the machine on which the

server is running and the port number on which the server is listening. To make a

connection request, the client tries to rendezvous with the server on the server's

machine and port. The client also needs to identify itself to the server so it binds

to a local port number that it will use during this connection. This is usually

assigned by the system.

If everything goes well, the server accepts the connection. Upon

acceptance, the server gets a new socket bound to the same local port and also has

its remote endpoint set to the address and port of the client. It needs a new

socket so that it can continue to listen to the original socket for connection requests

while tending to the needs of the connected client.

On the client side, if the connection is accepted, a socket is successfully created and

the client can use the socket to communicate with the server.

The client and server can now communicate by writing to or reading from their

sockets.

Definition: A socket is one endpoint of a two-way communication link

between two programs running on the network. A socket is bound to a port number

so that the TCP layer can identify the application that data is destined to be

sent.

An endpoint is a combination of an IP address and a port number. Every TCP

connection can be uniquely identified by its two endpoints. That way you can

have multiple connections between your host and the server.

The java.net package in the Java platform provides a class, Socket, that implements

one side of a two-way connection between your Java program and another program

on the network. The Socket class sits on top of a platform-dependent

implementation, hiding the details of any particular system from your Java program.

By using the java.net.Socket class instead of relying on native code, your Java

programs can communicate over the network in a platform-independent fashion.

Additionally, java.net includes the ServerSocket class, which implements a socket

that servers can use to listen for and accept connections to clients. This lesson

shows you how to use the Socket and ServerSocket classes.

If you are trying to connect to the Web, the URL class and related classes

(URLConnection, URLEncoder) are probably more appropriate than the socket

classes. In fact, URLs are a relatively high-level connection to the Web and use

sockets as part of the underlying implementation. See Working with URLs for

information about connecting to the Web via URLs.

Reading from and Writing to a Socket

Let's look at a simple example that illustrates how a program can establish a

connection to a server program using the Socket class and then, how the client can

send data to and receive data from the server through the socket.

The example program implements a client, EchoClient, that connects to the Echo

server. The Echo server simply receives data from its client and echoes it

back. The Echo server is a well-known service that clients can rendezvous with on

port 7.

EchoClient creates a socket thereby getting a connection to the Echo server.

It reads input from the user on the standard input stream, and then forwards that

text to the Echo server by writing the text to the socket. The server echoes the

input back through the socket to the client. The client program reads and

displays the data passed back to it from the server:

import java.io.*;

import java.net.*;

public class EchoClient {

public static void main(String[] args) throws IOException {

socket echoSocket = null;

printWriter out = null;

bufferedReader in = null;

try {

echoSocket = new Socket("taranis", 7);

out = new PrintWriter(echoSocket.getOutputStream(), true);

in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream()));

}

catch (UnknownHostException e) {

System.err.println("Don't know about host: taranis.");

System.exit(1);

} catch (IOException e) {

System.err.println("Couldn't get I/O for

"+ "the connection to: taranis.");

The example program implements a client, EchoClient, that connects to the Echo

server. The Echo server simply receives data from its client and echoes it

back. The Echo server is a well-known service that clients can rendezvous with on

port 7.

EchoClient creates a socket thereby getting a connection to the Echo server.

It reads input from the user on the standard input stream, and then forwards that

text to the Echo server by writing the text to the socket. The server echoes the

input back through the socket to the client. The client program reads and

displays the data passed back to it from the server: import java.io.*;

import java.net.*;

public class EchoClient {

public static void main(String[] args) throws IOException {

Socket echoSocket = null;

PrintWriter out = null;

BufferedReader in = null;

try {

echoSocket = new Socket("taranis", 7);

out = new PrintWriter(echoSocket.getOutputStream(), true);

in = new BufferedReader(new InputStreamReader(

echoSocket.getInputStream()));

} catch (UnknownHostException e) {

System.err.println("Don't know about host:

taranis.");

System.exit(1);

} catch (IOException e) {

System.err.println("Couldn't get I/O for

" + "the connection to: taranis.");

The first statement in this sequence creates a new Socket object and names it

echoSocket. The Socket constructor used here requires the name of the machine and

the port number to which you want to connect. The example program uses the host

name taranis. This is the name of a hypothetical machine on our local network.

When you type in and run this program on your machine, change the host name to

the name of a machine on your network. Make sure that the name you use is the

fully qualified IP name of the machine to which you want to connect. The second

argument is the port number. Port number 7 is the port on which the Echo server

listens.

The second statement gets the socket's output stream and opens a PrintWriter on it.

Similarly, the third statement gets the socket's input stream and opens a

BufferedReader on it. The example uses readers and writers so that it can write

Unicode characters over the socket.

To send data through the socket to the server, EchoClient simply needs to write to

the PrintWriter. To get the server's response, EchoClient reads from the

BufferedReader. The rest of the program achieves this. If you are not yet familiar

with the Java platform's I/O classes, you may wish to read B as i c I / O .

The next interesting part of the program is the while loop. The loop reads a line at a

time from the standard input stream and immediately sends it to the server by

writing it to the PrintWriter connected to the socket:

String userInput;

while ((userInput = stdIn.readLine()) != null)

{ out.println(userInput);

System.out.println("echo: " +

in.readLine());

}

The last statement in the while loop reads a line of information from the BufferedReader connected to the socket. The readLine method waits until the server echoes the information back to EchoClient. When readline returns, EchoClient prints the information to the standard output.

The while loop continues until the user types an end-of-input character. That is,

EchoClient reads input from the user, sends it to the Echo server, gets a response

from the server, and displays it, until it reaches the end-of-input. The while loop

then terminates and the program continues, executing the next four lines of code:

out.close();

in.close();

stdIn.close();

echoSocket.close();

These lines of code fall into the category of housekeeping. A well-behaved program

always cleans up after itself, and this program is well-behaved. These statements

close the readers and writers connected to the socket and to the standard input

stream, and close the socket connection to the server. The order here is

important. You should close any streams connected to a socket before you close

the socket itself.

This client program is straightforward and simple because the Echo server

implements a simple protocol. The client sends text to the server, and the server

echoes it back. When your client programs are talking to a more complicated server

such as an HTTP server, your client program will also be more complicated.

However, the basics are much the same as they are in this program:

1. Open a socket.2. Open an input stream and output stream to the socket.3. Read from and write to the stream according to the server's protocol.4. Close the streams.5. Close the socket.

Only step 3 differs from client to client, depending on the server. The other steps

remain largely the same.

Writing the Server Side of a Socket

This section shows you how to write a server and the client that goes with it. The

server in the client/server pair serves up Knock Knock jokes. Knock Knock jokes

are favored by children and are usually vehicles for bad puns. They go like this:

Server:"Knockknock!

"

Client:"Who'sthere?"

Server:"Dexter."

Client:"Dexterwho?"

Server:"Dexterhallswithboughsofholly."

Client: "Groan."

The example consists of two independently running Java programs: the client

program and the server program. The client program is implemented by a single

class, KnockKnockClient, and is very similar to the E ch oCli e n t example from the

previous section. The server program is implemented by two classes:

KnockKnockServer and KnockKnockProtocol, KnockKnockServer contains the

main method for the server program and performs the work of listening to the port,

establishing connections, and reading from and writing to the socket.

KnockKnockProtocol serves up the jokes. It keeps track of the current joke, the

current state (sent knock knock, sent clue, and so on), and returns the various text

pieces of the joke depending on the current state. This object implements the

protocol-the language that the client and server have agreed to use to communicate.

The following section looks in detail at each class in both the client and the server

and then shows you how to run them.

The Knock Knock Server

This section walks through the code that implements the Knock Knock server

program. Here is the complete source for the K n o c k K n o c k S e rv er class.

The server program begins by creating a new ServerSocket object to listen on a

specific port (see the statement in bold in the following code segment). When

writing a server, choose a port that is not already dedicated to some other service.

KnockKnockServer listens on port 4444 because 4 happens to be my favorite

number and port 4444 is not being used for anything else in my environment:

try {

serverSocket = new ServerSocket(4444);

} catch (IOException e) {

System.out.println("Could not listen on port:

4444"); System.exit(-1);

}

ServerSocket is a java.net class that provides a system-independent implementation

of the server side of a client/server socket connection. The constructor for

ServerSocket throws an exception if it can't listen on the specified port (for

example, the port is already being used). In this case, the KnockKnockServer has no

choice but to exit.

If the server successfully binds to its port, then the ServerSocket object is

successfully created and the server continues to the next step--accepting a

connection from a client (shown in bold):

Socket clientSocket = null;

try {

clientSocket = serverSocket.accept();

} catch (IOException e) {

System.out.println("Accept failed: 4444");

System.exit(-1);

}

The accept method waits until a client starts up and requests a connection on the host

and port of this server (in this example, the server is running on the hypothetical machine

taranis on port 4444). When a connection is requested and successfully established, the

accept method returns a new Socket object which is bound to the same local port and has

it's remote address and remote port set to that of the client. The server can communicate

with the client over this new Socket and continue to listen for client connection requests

on the original ServerSocket This particular version of the program doesn't listen for more

client connection requests. However, a modified version of the program is provided

in Supporting Multiple Clients.

After the server successfully establishes a connection with a client, it

communicates with the client using this code:

PrintWriter out = new PrintWriter(

clientSocket.getOutputStream(), true);

BufferedReader in = new BufferedReader(

new InputStreamReader(

clientSocket.getInputStream()));

String inputLine, outputLine;

// initiate conversation with client

KnockKnockProtocol kkp = new KnockKnockProtocol();

outputLine = kkp.processInput(null); out.println(outputLine);

while ((inputLine = in.readLine()) != null) {

outputLine = kkp.processInput(inputLine);out.println(outputLine);

if outputLine.equals("Bye."))

break;

}

This code:

1. Gets the socket's input and output stream and opens readers and writers

on them.

2. Initiates communication with the client by writing to the socket (shown in

bold).

3. Communicates with the client by reading from and writing to the socket

(the while loop).

Step 1 is already familiar. Step 2 is shown in bold and is worth a few comments. The bold

statements in the code segment above initiate the conversation with the client. The code

creates a KnockKnockProtocol object-the object that keeps track of the current joke, the

current state within the joke, and so on.

After the KnockKnockProtocol is created, the code calls KnockKnockProtocol's

processInput method to get the first message that the server sends to the client. For this

example, the first thing that the server says is "Knock! Knock!" Next, the server writes the

information to the PrintWriter connected to the client socket, thereby sending the message

to the client.

Step 3 is encoded in the while loop. As long as the client and server still have

something to say to each other, the server reads from and writes to the socket, sending

messages back and forth between the client and the server.

The server initiated the conversation with a "Knock! Knock!" so afterwards the server must wait for the client to say "Who's there?" As a result, the while loop iterates on a read from the input stream. The readLine method waits until the client responds by writing something to its output stream (the server's input stream). When the client responds, the server passes the client's response to the KnockKnockProtocol object and asks the KnockKnockProtocol object for a suitable reply. The server immediately sends the reply to the client via the output stream connected to the socket, using a call to println. If the server's response generated from the KnockKnockServer object is "Bye." this indicates that the client doesn't want any more jokes and the loop quits.The KnockKnockServer class is a well-behaved server, so the last several lines of this section of KnockKnockServer clean up by closing all of the input and output streams, the client socket, and the server socket:

out.close(); in.close();

clientSocket.close();

serverSocket.close();

Ques6. Define RMI. Define the architecture of RMI invocation.Ans.

Remote Method Invocation (RMI) technology, first introduced in JDK 1.1, elevates network programming to a higher plane. Although RMI is relatively easy to use, it is a remarkably powerful technology and exposes the average Java developer to an entirely new paradigm--the world of distributed object computing.

This course provides you with an in-depth introduction to this versatile technology. RMI has evolved considerably since JDK 1.1, and has been significantly upgraded under the Java 2 SDK. Where applicable, the differences between the two releases will be indicated.

The design goal for the RMI architecture was to create a Java distributed object model that integrates naturally into the Java programming language and the local object model. RMI

architects have succeeded; creating a system that extends the safety and robustness of the Java architecture to the distributed computing world.

Interfaces: The Heart of RMI

The RMI architecture is based on one important principle: the definition of behavior and the implementation of that behavior are separate concepts. RMI allows the code that defines the behavior and the code that implements the behavior to remain separate and to run on separate JVMs.

This fits nicely with the needs of a distributed system where clients are concerned about the definition of a service and servers are focused on providing the service.

Specifically, in RMI, the definition of a remote service is coded using a Java interface. The implementation of the remote service is coded in a class. Therefore, the key to understanding RMI is to remember that interfaces define behavior and classes define implementation. Remember that a Java interface does not contain executable code. RMI supports two classes that implement the same interface. The first class is the implementation of the behavior, and it runs on the server. The second class acts as a proxy for the remote service and it runs on the client. 

A client program makes method calls on the proxy object, RMI sends the request to the remote JVM, and forwards it to the implementation. Any return values provided by the implementation are sent back to the proxy and then to the client's program.

RMI Architecture Layers

The RMI Architecture (System) has a FOUR layer,

(1)  Application Layer

(2)  Proxy Layer

(3)  Remote Reference Layer

(4)  Transport Layer

RMI Architecture Diagram:

 

(1)  Application Layer:

It’s a responsible for the actual logic (implementation) of the client and server applications.

Generally at the server side class contain implementation logic and also apply the reference to the appropriate object as per the requirement of the logic in application.

(2)  Proxy Layer:

It’s also called the “Stub/Skeleton layer”.

A Stub class is a client side proxy handles the remote objects which are getting from the reference.

A Skeleton class is a server side proxy that set the reference to the objects which are communicates with the Stub.

(3)  Remote Reference Layer (RRL):

It’s a responsible for manage the references made by the client to the remote object on the server so it is available on both JVM (Client and Server).

The Client side RRL receives the request for methods from the Stub that is transferred into byte stream process called serialization (Marshaling) and then these data are send to the Server side RRL.

The Server side RRL doing reverse process and convert the binary data into object. This process called deserialization or unmarshaling and then sent to the Skeleton class.

(4)  Transport Layer:

It’s also called the “Connection layer”.

It’s a responsible for the managing the existing connection and also setting up new connections.

So it is a work like a link between the RRL on the Client side and the RRL on the Server side.