servlet context:servletcontext is only one web web 
application object
servlet config: servlet config is multiple object in 
webapplication

Servlet config is one per servlet and servlet context is one for
the whole webapplication. 

Servlet config is used to pass deploy time information to servlet
where servlet context can be used to get information about the
container,server.

YES,There is some difference,when we deploy the web 
application the web container will create the Context 
object and when we load the servlet class then container 
will create config object,so for each web application web 
container will create one servlet context obj and for each 
servlet web container will create servlet config object.

Generally we use this objects to avoid the hardcoding,we 
declare this variables in deployment descriptor,we declare 
context parameters under web-app tag so that all servlets 
can use this parameter values ,and config parameters under 
servlet tag so that only specific servlet can use this 
parameter values,in simple way context object is like 
global object and config obj is like local obj.

doGet is called in response to an HTTP GET request. This 
happens when users click on a link, or enter a URL into the 
browser's address bar. It also happens with some HTML FORMs 
(those with METHOD="GET" specified in the FORM tag). 
doPost is called in response to an HTTP POST request. This 
happens with some HTML FORMs (those with METHOD="POST" 
specified in the FORM tag). 

Both methods are called by the default (superclass) 
implementation of service in the HttpServlet base class. 
You should override one or both to perform your servlet's 
actions. You probably shouldn't override service().

doGet method will append data to URL while transferring 
data to the server.

doPost method will not append data. It is considered to be 
secured. The data will be inside the body of request and 
response.

FORWARD-->
1. THE REQUEST AND RESPONSE OBJECT REMAIN SAME.
2. CONTROL DIRECTLY GOES TO REQUESTED PAGE AT THE POINT 
WHERE FORWARD IS CALLED.
3. REQUEST DISPATCHER IS NEEDED.

SEND REDIRECT:--->
1.NEW REQUEST AND RESPONSE IS GENERATED IN CASE THIS CASE.
2.IN THIS CASE FIRST CONTROL GOES TO CLIENT(BROWSER) AND 
THEN TO REQUESTED PAGE.
3.JUST RESPONSE OBJECT IS NEEDED.

If I am not wrong,
forward() is used to transfer the request within the web 
application whereas sendRedirect() is used to transfer the 
request from one webapplication to another.

yes, it is possible. write a javascript method to validate 
input fields and call this method based on event of your 
requirement.

Yes,
If it client side validation do with the javascript
if it is serverside validation we can use Filters and do 
the validations there example login authenticated or not

By using Filters u can also validating the form feilds

yes, we can override service() in our servlet, but not 
preferable. if we want use these service from any protocol 
like ftp,telnet, then we have to override.

we can override service method in my servlet class if the 
request is not protocol dependent.
Bcoz we exdend HttpSrevlet class to handle Http GET and 
POST requests and we have to override some methods like 
doGet,doPost,doHead,doPut,doDelete.

But if u want to override service method then u have to 
extend genricServlet Class.Then only u can implement Service
() method.

you can write as like for regular class.

No..not at all,,,,servlet is a class which is dynamically 
loaded...dynamically loaded class never requires 
constructors.

constructor required, but it should be public no-argument
constructor. even though if you are not write that
constructor   java compiler will create that construtctor by
default. for that your servlet class should be public other
wise you will get RuntimeWxception saying RequestedResource
is not available  like that.

yes offcourse you can write a constructor for a servlet
after all it is a java class. you can simply provide but if
u do not provide then it is by default include the no
argument constructor that is used by the Init() method in
the servlet life cycle.

yes, we can write constructor on our own but it should be 
no argument public constructor only, cause container will 
create the object so it needs no argument constructor.

yes., when ever the servlet is executed .,it requires 
configuration.,the configuration should be done in init() 
method only.,

Cookies is used for identify to request.
if we disable the coookies then we cannot identify the 
request

If cookies are disabled in our browser, Session tracking 
gets failed.

To overcome this limitation URL Rewriting concept will be 
used.

to track web pages we can use

1. Cookies
2. URLRewriting
3. storing data in session
4. Using Hidden variable in form

if cookies are disable the session tracking gets failed it 
unable to identifies the clients previous request.

even cookies are disable we can maintain session with 
res.encodeURL("path") method.

If we disable the cookies in our webpage then the it cant
identify the clients request.because there will be no
jsessionid  for our request.So it fails to remember our req
on the server .so once again it creates the sessionid for
another req.

Parser is used to parser the xml file it parse the xml file
and set the data in the domain model and if the Schema
validation is set to true then it will validate the xml file
against the Schema .Parser is needed for reading the data
from the xml node and to populate that data

yes we can create constructor of servlet instead of init 
method but i dont get servlet specification answers.

sure why not if we are not provide a constuctor for servlet 
it automatically get constructor by the java compiler if we 
provide a constuctor for a servlet the java compiler will 
not provide constuctor at that situation

yes ofcourse we should.
it is mandatory for servlet.
for servlets we required publc no argument constructor. if v
don't having that one, our servlet should not work, even
though if you are not crating the public no-argument
constructor, the java compiler will take the responsibility
to create public no- argument constructor.. mean while your
servlet should be public otherwise you will get
RuntimeException.


we can create costructor for sevelet but it should b no-
argument constructor. and u r servlet should be public. 
and one more thing this constructor in not in the place of
init() method..

RequestDispatcher is used to connect to another webresource
with in the same context.

RequestDispatcher
rd=ServletContext.getRequestDispatcher("url of resource");
rd.forward(req,res);----used to forward to another resource.
rd.include(req,res);----used to include other resource.

RequestDispatcher is an interface,In a web application 
having multiple webcomponents to handle a single request at 
time we go for RequestDispatcher.
RequestDispatcher rd=servletRequest.getRequestDispatcher
("url of the webcomponent");
rd.inculude(request,response);
rd.forward(request,response);

request dispatcher is used to transfer the value attributes
to servlets and jsps. the request diapatcher is use the
relative url and there is one more thing in request
dispatcher is (non -idempotant) means when u will do the
multiple submits then it will update the database again and
again so to avoid the multiple submits use the (Synchronizer
token pattern,PSG pattern,or sendRedirect)

RequestDispatcher is used to move/call the another 
resources (Servlets,jsps,htmls) available in the web 
applicaions 
we can get RequestDispatcher in two ways
1. servletContext.getRequestDispatcher("/path");
2. servletRequet.getRequestDispatcher("relativepath");

now we can move to another resources with the following 
methods available in RequestDispatcher
include(req,res);
forward(req,res);

RequestDispatcher is used to dispatch the request.that means
one resource take the ownership from another 
resources (Servlets,jsps,htmls) available in the web 
applicaions for handle the request.
we can get RequestDispatcher in two ways
1. servletContext.getRequestDispatcher("/absolute path");
2. servletRequet.getRequestDispatcher("relativepath");

now we can move to another resources with the following 
methods available in RequestDispatcher
include(req,res);
forward(req,res);

If you are using HTTP Session then you can use 
session.remove().
But if you are using some other ways for session management 
let’s say cookies then you have to then you can setMaxAge 
to zero for the cookie.

session.invalidate() used to kill the session object,this 
method is usually called, for ex: when we logoff from an 
application.

and 

session.removeAttribute()

To remove the session object .
1. with the help of web.xml
 <session-timeout>time in minutes</session-timeout>
2. in programatically
 session.setMaxInactiveInterval(time in seconds)
 
to terminate immediately the session
use session.invalidate()