Advanced programming
This presentation is the property of its rightful owner.
Sponsored Links
1 / 82

Advanced Programming PowerPoint PPT Presentation


  • 83 Views
  • Uploaded on
  • Presentation posted in: General

Advanced Programming. Rabie A. Ramadan [email protected] http://www.rabieramadan.org/classes/2012/Advpro/ Lecture 2. Introduction Thread Applications Defining Threads Java Threads and States Priorities Accessing Shared Resources Synchronisation Advanced Issues:

Download Presentation

Advanced Programming

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Advanced programming

Advanced Programming

Rabie A. Ramadan

[email protected]

http://www.rabieramadan.org/classes/2012/Advpro/

Lecture 2


Agenda

Introduction

Thread Applications

Defining Threads

Java Threads and States

Priorities

Accessing Shared Resources

Synchronisation

Advanced Issues:

Concurrency Models: master/worker, pipeline, peer processing

Serialization

Reflection

Java Beans

Agenda


A single threaded program

Asingle threaded program

class ABC

{

….

public void main(..)

{

..

}

}

begin

body

end


A multithreaded program

A Multithreaded Program

Main Thread

start

start

start

Thread A

Thread B

Thread C

Threads may switch or exchange data/results


Single and multithreaded processes

Single and Multithreaded Processes

threads are light-weight processes within a process

Single-threaded Process

Multiplethreaded Process

Threads of

Execution

Multiple instruction stream

Single instruction stream

Common

Address Space


Multithreaded server for serving multiple clients concurrently

Multithreaded Server: For Serving Multiple Clients Concurrently

Server Process

Client 1 Process

Server

Threads

  • Internet

Client 2 Process


Web internet applications serving many users simultaneousl y

Web/Internet Applications:Serving Many Users Simultaneously

PC client

Internet Server

Local Area Network

PDA


Multithreaded applications

Modern Applications need Threads

(ex1): Editing and Printing documents in background.

Multithreaded Applications

Printing Thread

Editing Thread


Multithreaded parallel file copy

Multithreaded/Parallel File Copy

  • reader()

  • {

    • - - - - - - - - - -

    • lock(buff[i]);

    • read(src,buff[i]);

    • unlock(buff[i]);

    • - - - - - - - - - -

  • }

  • writer()

  • {

    • - - - - - - - - - -

    • lock(buff[i]);

    • write(src,buff[i]);

    • unlock(buff[i]);

    • - - - - - - - - - -

  • }

buff[0]

buff[1]

Cooperative Parallel Synchronized Threads

9


What are threads

A piece of code that run in concurrent with other threads.

Each thread is a statically ordered sequence of instructions.

Threads are being extensively used express concurrency on both single and multiprocessors machines.

Programming a task having multiple threads of control – Multithreading or Multithreaded Programming.

What are Threads?


Java threads

Java has built in thread support for Multithreading

Synchronization

Thread Scheduling

Inter-Thread Communication:

currentThreadstartsetPriority

yieldrungetPriority

sleepstopsuspend

resume

Java Garbage Collector is a low-priority thread.

Java Threads


Threading mechanisms

Threading Mechanisms...

  • Create a class that extends the Thread class

  • Create a class that implements the Runnable interface

Thread

Runnable

Thread

MyThread

MyClass

(objects are threads)

(objects with run() body)

[a]

[b]


1st method extending thread class

1st method: Extending Thread class

  • Create a class by extending Thread class and override run() method:

    class MyThread extends Thread

    {

    public void run()

    {

    // thread body of execution

    }

    }

  • Create a thread:

    MyThread thr1 = new MyThread();

  • Start Execution of threads:

    thr1.start();

  • Create and Execute:

    new MyThread().start();


An example

class MyThread extends Thread {

public void run() {

System.out.println(" this thread is running ... ");

}

}

class ThreadEx1 {

public static void main(String [] args ) {

MyThread t = new MyThread();

t.start();

}

}

An example


Creating a task and thread

Creating a Task and Thread

  • Warning: old way(s), new ways

  • First, if you have a thread object, you can call start() on that object

    • Makes it available to be run

    • When it’s time to run it, Thread’s run() is called

  • So, create a thread using “old” (not good) way

    • Write class that extends Thread, e.g. MyThread

    • Define your own run()

    • Create a MyThread object and call start() on it

  • We won’t do this! Not good design


2nd method threads by implementing runnable interface

Create a class that implements the interface Runnable and override run() method:

class MyThread implements Runnable

{

.....

public void run()

{

// thread body of execution

}

}

Creating Object:

MyThreadmyObject = new MyThread();

Creating Thread Object:

Thread thr1 = new Thread( myObject );

Start Execution:

thr1.start();

2nd method: Threads by implementing Runnable interface


An example1

class MyThread implements Runnable {

public void run() {

System.out.println(" this thread is running ... ");

}

}

class ThreadEx2 {

public static void main(String [] args ) {

Thread t = new Thread(new MyThread());

t.start();

}

}

An example


Life cycle of thread

new

start()

I/O completed

ready

resume()

Time expired/interrupted

notify()

sleeping

blocked

waiting

dispatch

sleep()

wait()

suspend()

running

Block on I/O

completion

stop()

dead

Life Cycle of Thread


A program with three java threads

Write a program that creates 3 threads

A Program with Three Java Threads


Three threads example

Three threads example

  • class A extends Thread

  • {

  • public void run()

  • {

  • for(inti=1;i<=5;i++)

  • {

  • System.out.println("\t From ThreadA: i= "+i);

  • }

  • System.out.println("Exit from A");

  • }

  • }

  • class B extends Thread

  • {

  • public void run()

  • {

  • for(int j=1;j<=5;j++)

  • {

  • System.out.println("\t From ThreadB: j= "+j);

  • }

  • System.out.println("Exit from B");

  • }

  • }


Advanced programming

  • class C extends Thread

  • {

  • public void run()

  • {

  • for(int k=1;k<=5;k++)

  • {

  • System.out.println("\t From ThreadC: k= "+k);

  • }

  • System.out.println("Exit from C");

  • }

  • }

  • class ThreadTest

  • {

  • public static void main(String args[])

  • {

  • new A().start();

  • new B().start();

  • new C().start();

  • }

  • }


Run 1

threads [1:76] java ThreadTest

From ThreadA: i= 1

From ThreadA: i= 2

From ThreadA: i= 3

From ThreadA: i= 4

From ThreadA: i= 5

Exit from A

From ThreadC: k= 1

From ThreadC: k= 2

From ThreadC: k= 3

From ThreadC: k= 4

From ThreadC: k= 5

Exit from C

From ThreadB: j= 1

From ThreadB: j= 2

From ThreadB: j= 3

From ThreadB: j= 4

From ThreadB: j= 5

Exit from B

Run 1


Advanced programming

threads [1:77] java ThreadTest

From ThreadA: i= 1

From ThreadA: i= 2

From ThreadA: i= 3

From ThreadA: i= 4

From ThreadA: i= 5

From ThreadC: k= 1

From ThreadC: k= 2

From ThreadC: k= 3

From ThreadC: k= 4

From ThreadC: k= 5

Exit from C

From ThreadB: j= 1

From ThreadB: j= 2

From ThreadB: j= 3

From ThreadB: j= 4

From ThreadB: j= 5

Exit from B

Exit from A

Run2


Thread priority

Thread Priority

  • In Java, each thread is assigned priority, which affects the order in which it is scheduled for running. The threads so far had same default priority (NORM_PRIORITY) and they are served using FCFS policy.

    • Java allows users to change priority:

      • ThreadName.setPriority(intNumber)

        • MIN_PRIORITY = 1

        • NORM_PRIORITY=5

        • MAX_PRIORITY=10


Accessing shared resources

Applications Access to Shared Resources need to be coordinated.

Printer (two person jobs cannot be printed at the same time)

Simultaneous operations on your bank account.

Can the following operations be done at the same time on the same account?

Deposit()

Withdraw()

Enquire()

Accessing Shared Resources


Online bank serving many customers and operations

Online Bank: Serving Many Customers and Operations

PC client

Internet Bank Server

Local Area Network

Bank

Database

PDA


Shared resources

If one thread tries to read the data and other thread tries to update the same data, it leads to inconsistent state.

This can be prevented by synchronising access to the data.

Use “Synchronized” method:

public synchronized void update()

{

}

Shared Resources


The driver 3rd threads sharing the same object

the driver: 3rd Threads sharing the same object

class InternetBankingSystem {

public static void main(String [] args ) {

Account accountObject = new Account ();

Thread t1 = new Thread(new MyThread(accountObject));

Thread t2 = new Thread(new YourThread(accountObject));

Thread t3 = new Thread(new HerThread(accountObject));

t1.start();

t2.start();

t3.start();

// DO some other operation

} // end main()

}


Shared account object between 3 threads

Shared account object between 3 threads

class MyThread implements Runnable {

Accountaccount;

public MyThread (Account s) { account = s;}

public void run() { account.deposit(); }

} // end class MyThread

class YourThread implements Runnable {

Account account;

public YourThread (Account s) { account = s;}

public void run() { account.withdraw(); }

} // end class YourThread

class HerThread implements Runnable {

Account account;

public HerThread (Account s) { account = s; }

public void run() {account.enquire(); }

} // end class HerThread

account

(shared object)


Monitor shared object access serializes operation on shared object

Monitor (shared object access): serializes operation on shared object

class Account { // the 'monitor'

int balance;

// if 'synchronized' is removed, the outcome is unpredictable

public synchronized void deposit( ) {

// METHOD BODY : balance += deposit_amount;

}

public synchronized void withdraw( ) {

// METHOD BODY: balance -= deposit_amount;

}

public synchronized void enquire( ) {

// METHOD BODY: display balance.

}

}


Thread concurrency operation models

The master/worker model

The peer model

A thread pipeline

Thread concurrency/operation models


The master worker model

Themaster/worker model

Program

Resources

Workers

Files

taskX

Databases

Master

taskY

main ( )

Input (Stream)

Disks

taskZ

Special

Devices


The peer model

Resources

Files

Databases

Disks

taskZ

Special

Devices

Thepeermodel

Program

Workers

Input

taskX

taskY


A thread pipeline

Files

Files

Files

Databases

Databases

Databases

Disks

Disks

Disks

Special Devices

Special Devices

Special Devices

A thread pipeline

Program

Filter Threads

Stage 1

Stage 2

Stage 3

Input (Stream)

Resources


Java serialization

Java Serialization


So you want to save your data

Common problem:

You’ve built a large, complex object

Spam/Normal statistics tables

Game state

Database of student records

Etc…

Want to store on disk and retrieve later

Or: want to send over network to another Java process

In general: want your objects to be persistent

So you want to save your data…


Answer 1

Answer 1

  • You’ve got file I/O nailed, so…

  • Write a set of methods for saving/loading each class that you care about

public class MyClass {

public void saveYourself(Writer o)

throws IOException { … }

public static MyClassloadYourself(Reader r)

throws IOException { … }

}


Coolnesses of approach 1

Coolnesses of Approach 1

  • Can produce arbitrary file formats

  • Know exactly what you want to store and get back/don’t store extraneous stuff

  • Can build file formats to interface w/ other codes/programs

    • XML

    • Tab-delimited/spreadsheet

    • Etc.

  • If your classes are nicely hierarchical, makes saving/loading simple


Saving loading recursive data structs

Saving/Loading Recursive Data Structs

public interfaceSaveable{ // implemented by many classes

public void saveYourself(Writer w)

throws IOException;

// should also have this

// public static Object loadYourself(Reader r)

// throws IOException;

// but you can’t put a static method in an

// interface in Java

}


Painfulnesses of approach 1

Painfulnesses of Approach 1

  • This is called recursive descent parsing(and formatting)

  • If all you want to do is store/retrieve data, do you really need to go to all of that effort?

  • Fortunately, no. Java provides a shortcut that takes a lot of the work out.


Approach 2 using databases

Approach 2: Using Databases

  • Most Client-Server applications use a RDBMS as their data store while using an object-oriented programming language for development

  • Objects must be mapped to tables in the database and vice versa

  • Applications generally require the use of SQL statements embedded in another programming language

  • “Impedance mismatch”


Approach 3 enter serialization

Serialization is the process of transforming an in-memory object to a byte stream.

Deserialization is the inverse process of reconstructing an object from a byte stream to the same state in which the object was previously serialized.

“Serializing out” and “serializing in” are also used.

Approach 3: Enter Serialization...


Serialization basics

Serialization basics

  • The requirements for serialization are straightforward:

    • Only class instances rather than primitive types can be serialized.

    • For an object to be serializable, its class or some ancestor must implement the emptySerializableinterface.

    • An empty interface is called a markerinterface.


Serialization basics1

The syntax for serialization is straightforward:

An object is serialized by writing it to an ObjectOutputStream.

An object is deserialized by reading it from an ObjectInputStream.

Serialization basics


Serialization code

Serialization code

FileOutputStream out =

new FileOutputStream( “save.ser” );

ObjectOutputStreamoos =

new ObjectOutputStream( out );

oos.writeObject( new Date() );

oos.close();


Deserialization code

Deserialization code

FileInputStream in =

new FileInputStream( “save.ser” );

ObjectInputStream ois =

new ObjectInputStream( in );

Date d = (Date) ois.readObject();

ois.close();


Things that you don t want to save

Sometimes, you want to explicitly not store some non-static data

Computed values that are cached simply for convenience/speed

Passwords or other “secret” data that shouldn’t be written to disk

Java provides the “transient” keyword. transient foo==don’t save foo

Things that you don’t want to save

public class MyClass implements Serializable {

private int _primaryVal=3;// is serialized

private transientint _cachedVal=_primaryVal*2;

// _cachedVal is not serialized

}


Graphs

Serialization works by examining the variables of an object and writing primitives datatypes like numbers and characters to a byte stream.

It also caters to the situation where an object is inside another object.

If an object has a reference to an object which has a reference to another object, they are all saved together.

The set of all objects referenced is called a graph of objects and object serialization converts entire graphs to byte form.

Graphs


Graphs1

Graphs

Vector

1010100101

OutputStream

Object i

Object n


Gotchas 1 efficiency

For tables , it is not necessarily efficient, and may even be wrong

By default, Java will store the entire internal _table, including all of its null entries!

Now you’re wasting space/time to load/save all those empty cells

Plus, the hashCode()s of the keys may not be the same after deserialziation -- should explicitly rehash them to check.

Gotchas: #1 -- Efficiency


Gotchas 2 backward compatibility

Suppose that you have two versions of class Foo: Foo v. 1.0 and Foo v. 1.1

The public and protected members of 1.0 and 1.1 are the same; the semantics of both are the same

So Foo 1.0 and 1.1 should behave the same and be interchangable

BUT... The private fields and implementation of 1.0 and 1.1 are different

What happens if you serialize with a 1.0 object and deserialize with a 1.1? Or vice versa?

Gotchas: #2 -- Backward compatibility


Backward compat cont d

Issue is that in code, only changes to the public or protected interfaces matter

With serialization, all of a sudden, the private data members (and methods) count too

Have to be very careful to not muck up internals in a way that’s inconsistent with previous versions

E.g., changing the meaning, but not name of some data field

Backward compat, cont’d.


Backward compat cont d1

Example:

Backward compat, cont’d

// version 1.0

public class MyClass {

MyClass(intarg) { _dat=arg*2; }

private int _dat;

}

// version 1.1

public class MyClass {

MyClass(intarg) { _dat=arg*3; } // NO-NO!

private int _dat;

}


Backward compat cont d2

Java helps as much as it can

Java tracks a “version number” of a class that changes when the class changes “substantially”

Fields changed to/from static or transient

Field or method names changed

Data types change

Class moves up or down in the class hierarchy

Trying to deserialize a class of a different version than the one currently in memory throws InvalidClassException

Backward compat, cont’d:


Advanced programming

Java Reflection


What is reflection

Reflection: the process by which a program can observe and modify its own structure and behavior at runtime.

Based on RTTI (Run-Time Type Identification):

RTTI: allows programs to discover at runtime and use at runtime types that were not known at their compile time

Non-RTTI / Traditional approaches:

assume all types are known at compile time

Polymorphism in OO languages: is a particular case of very limited RTTI

What is Reflection


Kinds of tasks specific to reflection

Inspection: analyzing objects and types to gather information about their definition and behavior.

Find the run-time type information of an object

Find information about a type (supertypes, interfaces, members)

Dynamic type discovery

Manipulation: uses the information gained through inspection to change the structure/behavior:

create new instances of new types discovered at runtime

dynamically invoke discovered methods

Late binding: the types and methods used by a program are not known at compile-time

The most one could imagine to do in a reflective language: restructure types and objects on the fly !

Kinds of tasks specific to Reflection


How is reflection implemented

Reflective capabilities need special support in language and compiler !

Java: java.lang.reflection

.NET: System.Reflection

How is Reflection implemented


Reflection case study reflection in java

Class java.lang.reflect.Class

It is the entry point for all of the Reflection API

For each new class in a program a “Class” object is created.

Provides methods to examine the runtime properties of the object including its members and type information.

Provides the ability to create new objects of this type.

Reflection case study: Reflection in Java


The reflection logical hierarchy in java

The Reflection Logical Hierarchy in Java

Object

Class

compiled

class

file

Field

Method

Constructor

Member


Retrieving a class object

Object.getClass(): If an instance of an object is available, then the simplest way to get its Class is to invoke Object.getClass().

Class c = "foo".getClass();

.class: If the type is available but there is no instance then it is possible to obtain a Class by appending ".class" to the name of the type. This is also the easiest way to obtain the Class for a primitive type.

boolean b;

Class c = b.getClass(); // compile-time error

Class c = boolean.class; // correct

Class.forName(): If the fully-qualified name of a class is available, it is possible to get the corresponding Class using the static method Class.forName()

Class cString = Class.forName("java.lang.String;");

Retrieving a Class object


Inspecting a class

After we obtain a Class object myClass, we can:

Get the class name

String s = myClass.getName() ;

Get the class modifiers

int m = myClass.getModifiers() ;

boolisPublic = Modifier.isPublic(m) ;

boolisAbstract = Modifier.isAbstract(m) ;

boolisFinal = Modifier.isFinal(m) ;

Test if it is an interface

boolisInterface = myClass.isInterface() ;

Get the interfaces implemented by a class

Class [] itfs = myClass.getInterfaces() ;

Get the superclass

Class super = myClass.getSuperClass() ;

Inspecting a Class


Some ways to do introspection

java.lang.Class

Class.getMethods () // returns array of method objects

Class.getConstructor (Class[ ] parameterTypes)

returns the constructor with those parameters

java.lang.reflect.Array

Array.NewInstance (Class componentType, int length)

java.lang.reflect.Field

java.lang.reflect.Method

All of the above require the existence of run-time objects that describe methods and classes

Some ways to do introspection


Beans in java

Beans In Java


What is a bean

A Java Bean is a reusable software component that works with Java.

More specifically: a Java Bean is a reusable software component that can be visually manipulated in builder tools.

What is a Bean?


Reusable software components

Designed to apply the power and benefit of reusable, interchangeable parts from other industries to the field of software construction.

Reusable software components can be simple like familiar push buttons, text fields list boxes, scrollbars, dialogs

Reusable Software Components


Beans widgets controls and components

If you come from a Windows background, you probably think in terms of visual controls, possibly Visual Basic Extensions (VBXs) or OLE Controls (OCXs) and now Active X Controls.

If you're more accustomed to environments like X Windows, you probably think in terms of toolkits or widgets.

Beans, Widgets, Controls, and Components


Beans or class libraries

What is the difference between a Java Bean and an instance of a normal Java class?

Beans from typical Java classes is introspection.

Tools that recognize predefined patterns in method signatures and class definitions can "look inside" a Bean to determine its properties and behavior.

Method signatures within Beans must follow a certain pattern in order for introspection tools to recognize how Beans can be manipulated, both at design time, and run time.

Beans or Class Libraries


Basic bean concepts

Beans share certain common defining features.

Support for introspection allowing a builder tool to analyze how a bean works.

Support for customization allowing a user to alter the appearance and behavior of a bean.

Support for events allowing beans to fire events, and informing builder tools about both the events they can fire and the events they can handle.

Support for properties allowing beans to be manipulated programatically, as well as to support the customization mentioned above.

Support for persistence allowing beans that have been customized in an application builder to have their state saved and restored.

Basic Bean Concepts


Javabean rules

A JavaBean must have a public, no-argument constructor (a default constructor).

The JavaBean class attributes must be accessed via accessor and mutator methods that follow a standard naming convention (getXxxx and setXxxx, isXxxx for boolean attributes. This allows frameworks to automate operations on attribute values.

The JavaBean class should be serializable. This allows Java applications and frameworks to save, store, and restore the JavaBean’s state.

JavaBean Rules


Writing a simple javabean

Writing a Simple JavaBean


Simple bean test

Simple Bean Test


The java platform

Java Technology Enabled Desktop

Workgroup

Server

High-End

Server

Java Technology

Enabled Devices

The Java™ Platform

Umesh Bellur


The java tm platform

Java 2 Platform Micro Edition

(J2METM)

Java 2

Standard

Edition

(J2SE)

The JavaTM Platform

Optional

Packages

Optional

Packages

Personal

Basis Profile

Personal Profile

Java 2

Enterprise

Edition

(J2EE)

Foundation Profile

MIDP

Java Card APIs

CDC

CLDC

KVM

JVM

CardVM

* Under development in JCP


J2ee 1 4 apis and technologies

J2SE (improved)

JAX-RPC (new)

Web Service for J2EE

J2EE Management

J2EE Deployment

JMX 1.1

JMS 1.1

JTA 1.0

Servlet 2.4

JSP 2.0

EJB 2.1

JAXR

Connector 1.5

JACC

JAXP 1.2

JavaMail 1.3

JAF 1.0

J2EE 1.4 APIs and Technologies


Java ee 5 and 6

JAX-WS 2.0 & JSR 181

Java Persistence

EJB 3.0

JAXB 2.0

JavaSever Faces 1.2 – new to Platform

JSP 2.1 – Unification w/ JSF 1.2

StAX – Pull Parser – new to Platform

Java EE 5 and 6


Enterprise in j2ee

‘Programming in the large’ and ‘enterprise computing’ :

differ from small-scale and academic computing

Lots of users and the application has an ‘extended life’

Deployed on heterogeneous computing environments

Needs to have versioning mechanism

Developed by a team of developers over long time

Maintainability, Flexibility, Reusability are major issues

Difficulties

Needs to support transactions, resource-pooling, security, threading, persistence, life-cycle management etc…

System programming at the expense of business logic

Developers have to become specialists

Proprietary APIs result in non-portable code

Need for special solutions to manage complexity

Proprietary frameworks and middleware

Need for standard APIs for enterprise computing

Multi-tiered architecture in enterprise applications

‘Enterprise’ in J2EE


J2ee platform architecture

Component

A component is an application level software unit.

The J2EE platform supports the following types of components :

Applets,

Application clients,

Web components and

Enterprise Java Beans (EJBs)

Container

All J2EE components depend on the runtime support of a system-level entity called a container.

Containers provide components with services such as

life cycle management,

security,

deployment

threading

J2EE Platform Architecture


Servlet jsp javaserver pages

Servlet & JSP (JavaServer Pages)


What is a servlet

Java™ objects which extend the functionality of a HTTP server

Dynamic contents generation

Better alternative to CGI, ISAPI, etc.

Efficient

Platform and server independent

Session management

Java-based

What is a Servlet?


Servlet vs cgi

Request CGI1

Request CGI1

Request CGI1

Request CGI1

Request CGI1

Request CGI1

Request CGI1

Child for CGI1

Child for CGI1

Child for CGI1

Child for CGI1

Child for CGI1

Child for CGI1

Child for CGI1

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

CGI

Based

Webserver

Request CGI2

Request CGI2

Request CGI2

Request CGI2

Child for CGI2

Child for CGI2

Child for CGI2

Child for CGI2

Request CGI1

Request CGI1

Child for CGI1

Child for CGI1

Request Servlet1

Request Servlet1

Request Servlet1

Request Servlet1

Request Servlet1

Servlet Based Webserver

Servlet Based Webserver

Servlet Based Webserver

Servlet Based Webserver

Servlet Based Webserver

Servlet Based Webserver

Servlet1

Request Servlet2

Servlet1

Servlet1

Servlet1

Servlet1

Request Servlet2

Request Servlet2

JVM

JVM

JVM

JVM

JVM

JVM

Servlet2

Request Servlet1

Servlet2

Servlet2

Servlet vs. CGI


What is jsp technology

Enables separation of business logic from presentation

Presentation is in the form of HTML or XML

Business logic is implemented as Java Beans or custom tags

Better maintainability, reusability

Extensible via custom tags

Builds on Servlet technology

What is JSP Technology?


  • Login