2. Both the approaches have advantages & disadvantages

org.apache.struts.action.ActionServlet in the web.xml configuration file must defined as
ActionServlet provided by the struts Framework is a built-in servlet. ActionServlet nothing but a controller.It has the following inbuilt design patterns.
1 singleton designpatteren.

2.FrontController

3.ApplicationController

4.MVC

5.Data Transfer object/value object

6.Inversion of control/Dependency injection
ActionServlet take the multiple request but it creates single instance for that requests by using singleton design pattern.
Few servers likes weblogic violates single instance multiple threads principle of servlet programming.That means these servers that will create more than once object for a class in special situation. see hereTo avoid this type of situations & to follow servlet specifications, struts framework software developers have made built-in servlet called ActionServlet.
Note:

1. According to MVC principles, there should be only one servlet acting as controller and this servlet should have only one object.

2. Both the approaches have advantages & disadvantages

Random Posts

• September 7, 2008 -- Define Cookies (0)
• October 5, 2008 -- Difference between GET and HEAD request methods (0)
• August 15, 2008 -- Thread example for Runnable Interface (1)
• April 7, 2009 -- OVERVIEW OF SERVLETS (0)
• October 5, 2008 -- Thread safety of the servlet (0)

Hashtable is basically a datastructure to retain values of key-value pair.

• It didn’t allow null for both key and value. You will get NullPointerException if you add null value.
• It is synchronized. So it come with its cost. Only one thread can access in one time

1. Hashtable<Interger,String>; cityTable=new Hashtable<Interger,String>();
2. cityTable.put(1,”Lahore”);
3. cityTable.put(2,”Karachi”);
4. cityTable.put(3,null); // NullPointerException at runtime
5. System.out.println(cityTable.get(1));
6. System.out.println(cityTable.get(2));
7. System.out.println(cityTable.get(3));

HashMap

Like Hashtable it also accepts key value pair.

• It allows null for both key and value
• It is un-synchronized. So come up with better performance

1. HashMap<Interger,String>; prodcutTable=new HashMap<Interger,String>();
2. prodcutTable.put(1,”Keys”);
3. prodcutTable.put(2,null);

HashSet

HashSet does not allow duplicate values. It provides add method rather put method. You also use its contain method to check whether the object is already available in HashSet. HashSet can be used  where you want to maintain a unique list.

1. HashSet<String>; stateSet=new HashSet<String>();
2. stateSet.add(“CA”);
3. stateSet.add(“WI”);
4. stateSet.add(“NY”);
6. if(stateSet.contains(“PB”)) /* if CA,it will not add but shows following message */
7. System.out.println(Already found);
8. else
   
9. stateSet.add(“PB”);

Use hashSet if you just want to have a set of object, HashMap if you want some mappings(key-value pair), Use Hashtable in multi threaded enviroment as its synchronized (alternatively you can use a synchronizedMap as well)

For More Information on Collections Visit UTIL PACKAGE

Related Post

• June 23, 2008 -- JAVA UTIL PACKAGE (0)
• June 23, 2008 -- Java Basic Questions (1)
• May 22, 2008 -- Core Java Interview Questions (1)
• May 22, 2008 -- Basic Java Interview Question (1)
• March 24, 2009 -- Define HashSet Class (0)

1. Input Variables

2. Input Variables with SELECT and UPDATE Statements

3. Exercise:  Pass Data to a SELECT Stored Procedure

4. Conclusion

5. Database script for SPFORBEGINNERS (the database referenced in this article)

At the end, I have also included a SQL script for creating the database used in my examples. It is a small database, and easily replicated.

What Are Stored Procedures?

Have you ever written SQL statements, like inserts, selects, and updates? Then you have already written most of a stored procedure. A stored procedure is an already written SQL statement that is saved in the database. If you find yourself using the same query over and over again, it would make sense to put it into a stored procedure. When you put this SQL statement in a stored procedure, you can then run the stored procedure from the database’s command environment.
An example is:

exec usp_displayallusers

The name of the stored procedure is “usp_displayallusers”, and “exec” tells SQL Server to execute the code in the stored procedure. (Note: “usp_” in front of the stored procedure name is used to designate this stored procedure as a user-created stored procedure.) The code inside the stored procedure can be something as simple as:

SELECT * FROM USERLIST

This “select” statement will return all data in the USERLIST table. You may think, skeptically, that stored procedures aren’t terribly useful. Just save the query and run it when you need to. Too easy, right?

Well, there is more to the story. Many queries get more complex than “select * from . . .”  Also, you may want to call the stored procedure from an application, such as an ASP page, Visual Basic application, or a Java servlet. With a stored procedure, you can store all the logic in the database, and use a simple command to call the stored procedure. Later, if you decide to use J2EE, you only need to change the application layer, which will be significantly easier. Much of the business logic will remain in the database.

Enough background—let’s write some stored procedures.

Getting Started with Stored Procedures

What do I need to get started? I have heard that question often. To begin writing stored procedures, the following are essential:

1. A database management system.

2. A database built inside the database management system (see the end of this article for a sample).

3. A text editor, such as Notepad or Query Analyzer.

Items 1 and 2 are absolutely essential. You can’t write stored procedures without a database. They would be useless. Sometimes, I write my procedures in Notepad (or another text editor), and copy them into the New Stored Procedure window in My SQL Server.

Next, you will have to decide what you want your stored procedure to do. It can be tempting to just dive right into the task at hand, but it is always prudent to sketch out some ideas first. Some considerations should be:

* Do you want to view data in the database (SELECT), insert new records (INSERT INTO), or do I want to change an existing record (UPDATE)?

* With which tables will you have to work? Does it make sense to create a VIEW first?

* How often will this procedure actually be used?

Once you have struggled with these questions (something of an exaggeration, I guess), you will be ready to start coding!

Note: Throughout this article, I will focus on stored procedures for My SQL Server. You can apply the same principles to other database management systems, but I will make clear references to working in a My SQL Server environment.

You May Consider this things also

Before creating a stored procedure, consider that:

* CREATE PROCEDURE statements cannot be combined with other SQL statements in a single batch.

* To create procedures, you must have CREATE PROCEDURE permission in the database and ALTER permission on the schema in which the procedure is being created. For CLR stored procedures, you must either own the assembly referenced in <method_specifier>, or have REFERENCES permission on that assembly.

* Stored procedures are schema-scoped objects, and their names must follow the rules for identifiers.

* You can create a stored procedure only in the current database.

When creating a stored procedure, you should specify:

* Any input parameters and output parameters to the calling procedure or batch.

* The programming statements that perform operations in the database, including calling other procedures.

* The status value returned to the calling procedure or batch to indicate success or failure (and the reason for failure).

* Any error handling statements needed to catch and handle potential errors.

Error handing functions such as ERROR_LINE and ERROR_PROCEDURE can be specified in the stored procedure.

Related Post

• April 7, 2009 -- OVERVIEW OF SERVLETS (0)
• April 5, 2009 -- How to get a Leap Year (0)
• March 29, 2009 -- J2EE Interview Questions (0)
• March 25, 2009 -- Creating a Stateful session Bean (1)
• March 24, 2009 -- Define HashSet Class (0)

Serialization is also called as Marker Interface

There are four basic things you must do when you are making a class serializable. They are:

1. Implement the Serializable interface.

2. Make sure that instance-level, locally defined state is serialized properly.

3. Make sure that superclass state is serialized properly.

4. Override equals( ) and hashCode( ).

Let’s look at each of these steps in more detail.
Implement the Serializable Interface

This is by far the easiest of the steps. The Serializable interface is an empty interface; it declares no methods at all. So implementing it amounts to adding “implements Serializable” to your class declaration.

Reasonable people may wonder about the utility of an empty interface. Rather than define an empty interface, and require class definitions to implement it, why not just simply make every object serializable? The main reason not to do this is that there are some classes that don’t have an obvious serialization. Consider, for example, an instance of File. An instance of File represents a file. Suppose, for example, it was created using the following line of code:

File file = new File(“c:\\New Floder\\Temp”);

It’s not at all clear what should be written out when this is serialized. The problem is that the file itself has a different lifecyle than the serialized data. The file might be edited, or deleted entirely, while the serialized information remains unchanged. Or the serialized information might be used to restart the application on another machine, where “C:\\New Floder\\Temp” is the name of an entirely different file.

Another example is provided by the Thread[4] class. A thread represents a flow of execution within a particular JVM. You would not only have to store the stack, and all the local variables, but also all the related locks and threads, and restart all the threads properly when the instance is deserialized.

TIP:   Things get worse when you consider platform dependencies. In general, any class that involves native code is not really a good candidate for serialization.

Make Sure That Instance-Level, Locally Defined State Is Serialized Properly

Class definitions contain variable declarations. The instance-level, locally defined variables (e.g., the nonstatic variables) are the ones that contain the state of a particular instance. For example, in our Money class, we declared one such field:

public class Money extends ValueObject {
private int _cents;
….
}

The serialization mechanism has a nice default behavior–if all the instance-level, locally defined variables have values that are either serializable objects or primitive datatypes, then the serialization mechanism will work without any further effort on our part. For example, our implementations of Account, such as Account_Impl, would present no problems for the default serialization mechanism:

public class Account_Impl extends UnicastRemoteObject implements Account {
private Money _balance;
…
}

While _balance doesn’t have a primitive type, it does refer to an instance of Money, which is a serializable class.

If, however, some of the fields don’t have primitive types, and don’t refer to serializable classes, more work may be necessary. Consider, for example, the implementation of ArrayList from the java.util package. An ArrayList really has only two pieces of state:

public class ArrayList extends AbstractList implements List, Cloneable, java.io.
Serializable {
private Object elementData[];
private int size;
…
}

But hidden in here is a huge problem: ArrayList is a generic container class whose state is stored as an array of objects. While arrays are first-class objects in Java, they aren’t serializable objects. This means that ArrayList can’t just implement the Serializable interface. It has to provide extra information to help the serialization mechanism handle its nonserializable fields. There are three basic solutions to this problem:

* Fields can be declared to be transient.

* The writeObject( )/readObject( ) methods can be implemented.

* serialPersistentFields can be declared.

You can find more information on serialization at 1 and 2

Related Post

• July 21, 2010 -- Explain Briefly about Serialization (0)
• July 21, 2010 -- Using Serialization (0)

Note: When serializing an object to a file, the standard convention in Java is to give the file a .ser extension.

import java.io.*;

public class SerializeDemo
{

public static void main(String [] args)
{

Employee e = new Employee();
e.name = “Ramakrishna”;
e.address = “Hyderabad”;
e.SSN = 11122333;
e.number = 200113;

try
{

FileOutputStream fileOut =
new FileOutputStream(“employee.ser”);
ObjectOutputStream out =
new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();

}catch(IOException i)
{
i.printStackTrace();
}
}
}

The following DeserializeDemo program deserializes the Employee object created in the SerializeDemo program. Study the program and try to determine its output:

import java.io.*;

public class DeserializeDemo
{

public static void main(String [] args)
{

Employee e = null;

try
{
FileInputStream fileIn =
new FileInputStream(“employee.ser”);
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;

}catch(ClassNotFoundException c)
{
System.out.println(.Employee class not found.);
c.printStackTrace();
return;
}

System.out.println(“Deserialized Employee…”);
System.out.println(“Name: ” + e.name);
System.out.println(“Address: ” + e.address);
System.out.println(“SSN: ” + e.SSN);
System.out.println(“Number: ” + e.number);
}
}

This would produce following result:

Deserialized Employee…
Name: Ramakrishna
Address:Hyderabad
SSN: 0
Number:200113

In particular, there are three main uses of serialization:

As a persistence mechanism
If the stream being used is FileOutputStream, then the data will automatically be written to a file.

As a copy mechanism
If the stream being used is ByteArrayOutputStream, then the data will be written to a byte array in memory. This byte array can then be used to create duplicates of the original objects.

As a communication mechanism
If the stream being used comes from a socket, then the data will automatically be sent over the wire to the receiving socket, at which point another program will decide what to do.

The important thing to note is that the use of serialization is independent of the serialization algorithm itself. If we have a serializable class, we can save it to a file or make a copy of it simply by changing the way we use the output of the serialization mechanism.

As you might expect, serialization is implemented using a pair of streams. Even though the code that underlies serialization is quite complex, the way you invoke it is designed to make serialization as transparent as possible to Java developers. To serialize an object, create an instance of ObjectOutputStream and call the writeObject( ) method; to read in a serialized object, create an instance of ObjectInputStream and call the readObject( ) object.

TIP: There are two versions of the serialization protocol currently defined: PROTOCOL_VERSION_1 and PROTOCOL_VERSION_2. If you send serialized data to a 1.1 (or earlier) JVM, you should probably use PROTOCOL_VERSION_1. The most common case of this involves applets. Most applets run in browsers over which the developer has no control. This means, in particular, that the JVM running the applet could be anything, from Java 1.0.2 through the latest JVM. Most servers, on the other hand, are written using JDK1.2.2 or later.[3] If you pass serialized objects between an applet and a server, you should specify the serialization protocol.

Related Post

• July 21, 2010 -- How to Make a Class Serializable (1)
• July 21, 2010 -- Explain Briefly about Serialization (0)

What does it mean for the client to pass an instance of Money to the server? At a minimum, it means that the server is able to call public methods on the instance of Money. One way to do this would be to implicitly make Money into a server as well.[1] For example, imagine that the client sends the following two pieces of information whenever it passes an instance as an argument:

• The type of the instance; in this case, Money.
• A unique identifier for the object (i.e., a logical reference). For example, the address of the instance in memory.

The RMI runtime layer in the server can use this information to construct a stub for the instance of Money, so that whenever the Account server calls a method on what it thinks of as the instance of Money, the method call is relayed over the wire

Attempting to do things this way has three significant drawbacks:

• You can’t access fields on the objects that have been passed as arguments.

Stubs work by implementing an interface. They implement the methods in the interface by simply relaying the method invocation across the network. That is, the stub methods take all their arguments and simply marshall them for transport across the wire. Accessing a public field is really just dereferencing a pointer–there is no method invocation and hence, there isn’t a method call to forward over the wire.

• It can result in unacceptable performance due to network latency.

Even in our simple case, the instance of Account is going to need to call getCents( ) on the instance of Money. This means that a simple call to makeDeposit( ) really involves at least two distinct networked method calls: makeDeposit( ) from the client and getCents( ) from the server.

• It makes the application much more vulnerable to partial failure.

Let’s say that the server is busy and doesn’t get around to handling the request for 30 seconds. If the client crashes in the interim, or if the network goes down, the server cannot process the request at all. Until all data has been requested and sent, the application is particularly vulnerable to partial failures.

This last point is an interesting one. Any time you have an application that requires a long-lasting and durable connection between client and server, you build in a point of failure. The longer the connection needs to last, or the higher the communication bandwidth the connection requires, the more likely the application is to occasionally break down.
TIP: The original design of the Web, with its stateless connections, serves as a good example of a distributed application that can tolerate almost any transient network failure. These three reasons imply that what is really needed is a way to copy objects and send them over the wire. That is, instead of turning arguments into implicit servers, arguments need to be completely copied so that no further network calls are needed to complete the remote method invocation. Put another way, we want the result of makeWithdrawal( ) to involve creating a copy of the instance of Money on the server side. The runtime structure should resemble

The desire to avoid unnecessary network dependencies has two significant consequences:

• Once an object is duplicated, the two objects are completely independent of each other.

Any attempt to keep the copy and the original in sync would involve propagating changes over the network, entirely defeating the reason for making the copy in the first place.

• The copying mechanism must create deep copies.

If the instance of Money references another instance, then copies must be made of both instances. Otherwise, when a method is called on the second object, the call must be relayed across the wire. Moreover, all the copies must be made immediately–we can’t wait until the second object is accessed to make the copy because the original might change in the meantime.

These two consequences have a very important third consequence:

• If an object is sent twice, in separate method calls, two copies of the object will be created.

In addition to arguments to method calls, this holds for objects that are referenced by the arguments. If you pass object A, which has a reference to object C, and in another call you pass object B, which also has a reference to C, you will end up with two distinct copies of C on the receiving side.

Related Post

• July 21, 2010 -- How to Make a Class Serializable (1)
• July 21, 2010 -- Using Serialization (0)

import java.awt.*;
import java.applet.*;

public class GuiExample extends Applet
{

// A Button to click
Button okButton;

// A textField to get text input
TextField nameField;

// A group of radio buttons
// necessary to only allow one radio button to be selected at the same time

CheckboxGroup radioGroup;
// The radio buttons to be selected
Checkbox radio1;
Checkbox radio2;

// An independant selection box
Checkbox option;

public void init()
{

// Tell the applet not to use a layout manager.
setLayout(null);

// initialze the button and give it a text.
okButton = new Button(“A button”);

// text and length of the field
nameField = new TextField(“A TextField”,100);

// initialize the radio buttons group
radioGroup = new CheckboxGroup();

// first radio button. Gives the label text, tells to which
// group it belongs and sets the default state (unselected)
radio1 = new Checkbox(“Radio1″, radioGroup,false);

// same but selected
radio2 = new Checkbox(“Radio2″, radioGroup,true);

// Label and state of the checkbox
option = new Checkbox(“Option”,false);

// now we will specify the positions of the GUI components.// this is done by specifying the x and y coordinate and
//the width and height.

okButton.setBounds(20,20,100,30);
nameField.setBounds(20,70,100,40);
radio1.setBounds(20,120,100,30);
radio2.setBounds(140,120,100,30);
option.setBounds(20,170,100,30);

// now that all is set we can add these components to the applet
add(okButton);
add(nameField);
add(radio1);
add(radio2);
add(option);
}

}

// Thats’s it, you now have given the user visual options.
// However there are no actions related to these comonents.
// that makes it easier to place components.

Related Post

• June 8, 2008 -- Applet Interview Question (4)

if you need to delete the rows just u need to select that check box and go for the delete button .

You can have this code for using in your application this must be related to the button which you will use in your application

the Code is

function deleteRow() {
try {
var table = document.getElementById(‘myTable’);
//alert(‘table’+table);
var rowCount = table.rows.length;

for(var i=0; i<rowCount; i++) {
var row = table.rows[i];
var chkbox = row.cells[0].childNodes[0];
if(null != chkbox && false == chkbox.checked) {
table.deleteRow(i);
rowCount–;
i–;
}

}
}catch(e) {
alert(e);
}
}

<INPUT type=”button” value=”Delete Row” onclick=”deleteRow()” />

Random Posts

• July 15, 2008 -- Springs Interview Questions (0)
• September 2, 2008 -- Define HttpSession Class (0)
• September 2, 2008 -- Difference between session.update() and session.lock() (0)
• May 22, 2008 -- Basic Java Interview Question (1)
• September 22, 2008 -- What is JRE ? Explain (1)

Rep) Java 2 Platform, Enterprise Edition.

Q)   What is J2EE application

Rep) Any deployable unit of J2EE functionality. This can be
a single J2EE module or a group of modules packaged
into an EAR file along with a J2EE application
deployment descriptor. J2EE applications are typically
engineered to be distributed across multiple computing
tiers.

Q)  What is J2EE component

Rep) A self-contained functional software unit supported by
a container and configurable at deployment time. The
J2EE specification defines the following J2EE
components: Application clients and applets are
components that run on the client. Java servlet and
JavaServer Pages (JSP) technology components are Web
components that run on the server. Enterprise
JavaBeans (EJB) components (enterprise beans) are
business components that run on the server. J2EE
components are written in the Java programming
language and are compiled in the same way as any
program in the language. The difference between J2EE
components and “standard” Java classes is that J2EE
components are assembled into a J2EE application,
verified to be well formed and in compliance with the
J2EE specification, and deployed to production, where
they are run and managed by the J2EE server or client
container.

Q)  What is J2EE module

Rep) A software unit that consists of one or more J2EE
components of the same container type and one
deployment descriptor of that type. There are four
types of modules: EJB, Web, application client, and
resource adapter. Modules can be deployed as
stand-alone units or can be assembled into a J2EE
application.

Q)  What is J2EE product

Rep) An implementation that conforms to the J2EE platform
specification.

Q)   What is J2EE product provider

Rep) A vendor that supplies a J2EE product.

Q)  What is J2EE server

Rep) The runtime portion of a J2EE product. A J2EE server
provides EJB or Web containers or both.

Q)   What is J2ME

Rep) Abbreviate of Java 2 Platform, Micro Edition.

Q)  What is J2SE

Rep) Abbreviate of Java 2 Platform, Standard Edition.

Q)  What is JAR

Rep) Java archive. A platform-independent file format that
permits many files to be aggregated into one file.

Q)   What is Java 2 Platform, Enterprise Edition(J2EE)

Rep) An environment for developing and deploying enterprise
applications. The J2EE platform consists of a set of
services, application programming interfaces (APIs),
and protocols that provide the functionality for
developing multitiered, Web-based applications.

Q)  What is Java 2 Platform, Micro Edition (J2ME)

Rep) A highly optimized Java runtime environment targeting
a wide range of consumer products, including pagers,
cellular phones, screen phones, digital set-top boxes,
and car navigation systems.

Q)  What is Java 2 Platform, Standard Edition (J2SE)

Rep) The core Java technology platform.

Q)  What is Java API for XML Processing (JAXP)

Rep) An API for processing XML documents. JAXP leverages
the parser standards SAX and DOM so that you can
choose to parse your data as a stream of events or to
build a tree-structured representation of it. JAXP
supports the XSLT standard, giving you control over
the presentation of the data and enabling you to
convert the data to other XML documents or to other
formats, such as HTML. JAXP provides namespace
support, allowing you to work with schema that might
otherwise have naming conflicts.

Q)  What is Java API for XML Registries (JAXR)

Rep) An API for accessing various kinds of XML registries.

Q)  What is Java API for XML-based RPC (JAX-RPC)

Rep) An API for building Web services and clients that use
remote procedure calls and XML

Q)   What is Java IDL

Rep) A technology that provides CORBA interoperability and
connectivity capabilities for the J2EE platform. These
capabilities enable J2EE applications to invoke
operations on remote network services using the Object
Management Group IDL and IIOP.

Q)  What is Java Message Service (JMS)

Rep) An API for invoking operations on enterprise messaging
systems.

Q)  What is Java Naming and Directory Interface (JNDI)

Rep) An API that provides naming and directory
functionality.

Q)   What is Java Secure Socket Extension (JSSE)

Rep) A set of packages that enable secure Internet
communications.

Q)   What is Java Transaction API (JTA)

Rep) An API that allows applications and J2EE servers to
access transactions.

Q)  What is Java Transaction Service (JTS)

Rep) Specifies the implementation of a transaction manager
that supports JTA and implements the Java mapping of
the Object Management Group Object Transaction Service
1.1 specification at the level below the API.

Q)  What is JavaBeans component

Rep) A Java class that can be manipulated by tools and
composed into applications. A JavaBeans component must
adhere to certain property and event interface
conventions.

Q)  What is JavaMail

Rep) An API for sending and receiving email.

Q)   What is JavaServer Faces Technology

Rep) A framework for building server-side user interfaces
for Web applications written in the Java programming
language.

Q)  What is JavaServer Faces conversion model

Rep) A mechanism for converting between string-based markup
generated by JavaServer Faces UI components and
server-side Java objects.

Q)  What is JavaServer Faces event and listener model

Rep) A mechanism for determining how events emitted by
JavaServer Faces UI components are handled. This model
is based on the JavaBeans component event and listener
model.

Q)  What is JavaServer Faces _expression language

Rep) A simple _expression language used by a JavaServer
Faces UI component tag attributes to bind the
associated component to a bean property or to bind the
associated component’s value to a method or an
external data source, such as a bean property. Unlike
JSP EL expressions, JavaServer Faces EL expressions
are evaluated by the JavaServer Faces implementation
rather than by the Web container.

Q)  What is JavaServer Faces navigation model

Rep) A mechanism for defining the sequence in which pages
in a JavaServer Faces application are displayed.

Q)  What is JavaServer Faces UI component

Rep) A user interface control that outputs data to a client
or allows a user to input data to a JavaServer Faces
application.

Q)  What is JavaServer Faces UI component class

Rep) A JavaServer Faces class that defines the behavior and
properties of a JavaServer Faces UI component.

Q)  What is JavaServer Faces validation model

Rep) A mechanism for validating the data a user inputs to a
JavaServer Faces UI component.

Q)  What is JavaServer Pages (JSP)

Rep) An extensible Web technology that uses static data,
JSP elements, and server-side Java objects to generate
dynamic content for a client. Typically the static
data is HTML or XML elements, and in many cases the
client is a Web browser.

Q)  What is JavaServer Pages Standard Tag Library(JSTL)

Rep) A tag library that encapsulates core functionality
common to many JSP applications. JSTL has support for
common, structural tasks such as iteration and
conditionals, tags for manipulating XML documents,
internationalization and locale-specific formatting
tags, SQL tags, and functions.

Q)  What is JAXR client

Rep) A client program that uses the JAXR API to access a
business registry via a JAXR provider.

Related Post

• June 23, 2008 -- Java Basic Questions (1)
• May 22, 2008 -- Core Java Interview Questions (1)
• May 22, 2008 -- Basic Java Interview Question (1)
• April 7, 2009 -- OVERVIEW OF SERVLETS (0)
• March 25, 2009 -- Creating a Stateful session Bean (1)

Servlets provide a Java based solution used to address the problems currently associated with doing server side programming including inextensible scripting solution, platform specific API’s, and incomplete interfaces.

Servlets are objects that confirm to a specific interface that can be plugged into a Java based server. Servlets are to the server side what applets are to the client side object byte code that can be dynamically loaded off the net.
They differ from applets. In that they are face less objects (with out graphics or GUI component).They serve as platform independent, dynamically loadable, pluggable  helper byte code objects on the server side that can be used to dynamically extend server side functionality.

For example, an HTTP servlet can be used to generate dynamic HTML content. When you use servlets to do dynamic content you get the following advantages:

They are faster and cleaner than CGI scripts
They use a  standard API (the servlet API)
They provide all the advantages of Java(run on variety of    servers with out needing to be rewritten)

The Attractiveness of Servlets

There are many features of servlets that make them easy and attractive to use. These include:
Easily configured using the GUI based admin Tool.
Can be loaded and invoked from a local disc or remotely across the network.
Can be linked together, or chained so that on a servlet can call another servlet, or several servlets in sequence.
Can be called dynamically from within HTML pages, using server side include tags.
Are secure- even when downloading across the net work, the servlet security model and servlet sandbox protect your system from unfriendly behavior.

The Advantages of the servlet API

One of the great advantages of the servlet API is protocol independence. It assumes nothing about:
The protocol being used to transmit on the net
How it is loaded
The server environment it will be running in tjese qualities are important, because it allows the servlet API to be embedded in many different kindsof servers.
There are other advantages to the servlet API  as well.
These include:
It’s extensible-you can inherit all your functionality from the classes made available to you;
It’s simple, small, and easy to use.

JAVA SERVLET FEATURES:

The JavaServer provides several important servlet features.
These includes:
Loading and Invoking Servlets

Servlets can be loaded both locally and remotely.

Filters and Servlet Chaining

The JavaServer uses mime types to call servlets sequentially.

Server-Side Includes

Server can be invoked from dynamic HTML docements using    server-side include tags.

Replacing CGI Scripts

Servlets are an effective substitute for CGI scripts, and provide a faster and cleaner way to genarate dynamic documents.

INTERNAL SERVLETS:

The Java TM Web Server TM servlet architecture is very flexible and the server takes advantage of thie by dividing  its work among several internal servlets. These are:

File Servlet:

The File Servlet provides the standard document serving capabilities of Java Web Server. This servlet includes a caching mechanism to speed up response times for frequently accessed files.

Invoker Servlet:

The purpose of this servlet is to invoke other servlets which are explicitly requested by name, that is

http://<server-host-name>/servlets/servlet name.

Server Side Include Servlet:

Servlets can be embedded within html documents using the servlet tag. When the server detects the servlet, and sends output of the servlet to the client at the point where the servlet tag was embedded.

Admin Servlet:

The Admin servlet facilitates administration of the Java web server through a GUI front end Administration Tool.

CGI Servlet:

This servlet acts as a gateway for CGI 1.1 interface. This servlet allows any program that utilizes the CGI 1.1     standard to under operate Java Web Server.

Image Map Servlet:

This servlet implements server-side image maps utilizing an extension of standard NCSA map files.

Related Post

• June 23, 2008 -- Java Basic Questions (1)
• May 22, 2008 -- Basic Java Interview Question (1)
• April 7, 2009 -- J2EE Interview Questions (0)
• March 29, 2009 -- J2EE Interview Questions (0)
• March 25, 2009 -- Creating a Stateful session Bean (1)