JSP
Scriptlet:
-In this, we use java code i.e.
request.getparamater (" property name");
=> When the object is stored in the Request
scope. i.e.
out.println (request.getparamater (" property name"));
Jsp expression:
- In this,
<%= request.getparamater ("property name")
=> This is used instead of out.println ();
Action tag:
- In this
<jsp: getproperty property="name as in form"
name="key for request scope">
Custom
Tag: -
<c: out>
in cout user either jsp expression or
ELExpression
Page Scope: For every jsp one page
context object is created. When java object is used by single jsp then those
cases we are going to use Page Scope.
Request Scope: Java object is used by
multiple servlets.ie multiple Servlets are involved while processing a single request
then those cases use request scope. Multiple Servlets involved means when you
use include or forward the same request object given to included Jsp. i.e. Servlet
chaining.
Session Scope: Java object is used by
multiple Servlets. I.e. multiple Servlets are involved while processing a Multiple
Requests (not single request). In wizard style every time when we click on Next
Button it becomes a new request. Then those cases use session scope. Each time
when you click on Next Button it is stored in the session scope in the wizard
style when we mention scope is session.
Note:
In wizard Style every time when you click on Next
Button it becomes a new request.
Then it creates a new Request and Response objects.
So if you use request scope in wizard style then it create a new request every
time when we click on Next Button. Then what ever java object in request scope
is removed every time when you click Next Button. So, In Wizard style uses session
scope. In session scope we are going to store client specific information.
Means
From Hyderabad we fill data in the form belong to our data. And our friend fill
the data from Bangalore belong to his specific data. For every
browser/client/user one session object is created. So for every user specific
data is stored in their own specific session object. After closing the browser
the session object will be removed. In between if you want stored the data in
the DATABASE before closing the browser. For one browser/client/user one
session object is created. For every browser/client/user one session object is
created. That session object is pointed to implicit variable Http Session. Client
specific information is stored in the session scope.
Application Scope:
- When we deploy the application in the server.
Then ServletContex (application) object is created. This object is pointing to
implicit variable in jsp ServletContex context. The common data belong to
entire application is stored in the Application scope. Client specific
information is stored in session scope (i.e. for one browser one session object
is created. whatever person is using the browser that person is stored in that
browser specific session object. For every browser one session object is created)
.The java object in the application scope you can get from anywhere and from
any flow in entire Application. SESSION SCOPE store client specific
information. APPLICATION SCOPE store common data belong to entire application.
DEFINATIONS FOR SCOPES: -
Page: - If a java object is used by a
single jsp during executing of jsp then we need to use page scope.
Request: - when multiple Servlets
are involved in processing a single request has to share the same java object
then we need to use request scope.
Session: - when java object holds
anything specific to the client and if the object is required while dealing
with multiple request (not single request) then we need to use session scope.
Application: - Application object
holds the data that is not specific to the client (It holds global data) and
this is required while dealing with multiple requests.
REMEMBER: - While dealing with
multiple requests (In wizard style), we can go for Session scope or Application
scope.
JSP ELEMENTS: -
Template Text: - Whatever we write in
the jsp is displayed in the browser.
Scriptlet: - whatever we write in
this, is placed in jspService () method. In this we are going to write java
code. Scriptlet by default support java language to support any other languages
you write code page directive in the top of jsp. For support java script in the
scriptlet you are going to write as
<%@ page
language="javascript" %> in the top of the jsp.
Jsp Expressions: - Use instead of out.println
(Object or string). out.println () does not support null value as parameter so we
are going to use Jsp expressions instead of out.println ();
Jsp Declarations: - for declaring instance
variables, instance methods, static variables, static methods. But calling of
methods from Scriplets only.
Jsp Directives: - For importing java
packages and java classes. And for supporting diff languages in jsp
Jsp Action Tags: -
<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
Jsp Custom Tags: -
El Expressions:
-
According to the Microsoft specification
not going to write the java code in the jsp. So by using Action Tags and Custom
Tags we are going to eliminate the java code form jsp.
JSTL
JSTL supports expression language (EL
expressions).
EL Expressions are provided for an
alternative to jsp Expressions.
EL Expressions are used for only for Scoped
variables.
Key of the attribute is called as scoped
variable in case of EL Expressions (key place main role in case of EL Expressions).
<Html>
<% pageContext.setAttribute
("vone","SANTOSH");
<-- here we write java code in jsp. So to avoid java code form
jsp
use<c:set> tag-->
pageContext.setAttribute ("vtwo","SIVA");
%>
<Body>
<c:out value="${vone}"></c:out><br/>
<c:out
value="${vtwo}"></c:out></br>
</body>
</html>
USE <C:SET> =>
<c:set var="vone" value="SANTOSH BHAI"
scope="page"></c:set>
<c:set
var="vtwo" value="SIVA REDDY"
scope="page"></c:set>
EL Expressions supports various operators
that are supported by programming languages like c, java.
<% pageContext.setAttribute ("vone","100");
pageContext.setAttribute ("vtwo","200");
Or
%>
Here
you observe one thing is set integer value as string here concentrate on this
point
<c:set var="vone" value="100"
scope="page"></c:set>
<c:set var="vtwo" value="100"
scope="page"></c:set>
<c:out value="${vone*vtwo}"></c:out>
<c:out
value="${vone*vtwo}"></c:out>
<c:out
value="${vone*vtwo}"></c:out>
Like in jsp in EL Expressions also some
implicit variables are there. Some of them are
1) pageScope
2) requestScope
3) sessionScope
3) applicationScope
5) param
6) header
Note:
Suffix with scope is very important
PROGRAM: -
<html>
<c:set var="vone" value="100"
scope="page"></c:set>
<c:set var="vone" value="200"
scope="request"></c:set>
<c:set var="vone" value="300"
scope="session"></c:set>
<c:set var="vone" value="400"
scope="application"></c:set>
<body>
<c:out value="${vone}"></c:out><br/>
<c:out
value="${requestScope.vone}"></c:out><br/>
</body>
</html>
Here variable ‘vone’ we can keep it in all
scopes. So when we print as <c:out value="${vone}">
From which scope it takes values. Jsp
compiler by default follow one order the order is first check in pageScope, in
key available in page scope and then prints the value. If the key is not available
in page scope. Next it checks in request, session and application, and then prints
the values.
If we mention scope like this.
<c:out
value="${requestScope.vone}">
Then prints the value for that particular
scope variable.
<c:out value="${requestScope.vone}">
<-
If you mention scope like this it improves the performance and more readable->
--------------------------------------------------------------------------
<jsp: useBean id="idOne" class="com.siva.Trail"
scope="session"/>
(or)
<c:set value="com.siva.Trail" var="idOne"
scope="session"></c:set>
Internally it creates object as like this
Trail idOne=new
Trail();
So when you print as
<c:out value="${session.idOne}"></c:out>
Then it prints the address of Trail object
When
you print as
<c:out
value="${session.idOne.propertyName}"></c:out>
Then it calls getter method and print
property value
Sample Program for Scopes:
-
Addressbean: -
public class Address {
private String street;
private String city;
private String state;
}
Employeebean: -
public class EmployeeJB {
String eno;
String ename;
String esalary;
Address address;
}
Scopestest.jsp: -
<html>
<body>
<%
Address a=new Address();
a.setCity("NELLORE");
a.setState("ANDHRAPRADESH");
a.setStreet("PETA SATRAM ROAD");
EmployeeJB employee=new EmployeeJB();
employee.setEname("SIVA");
employee.setEno("47");
employee.setEsalary("1000000000");
employee.setAddress(a);
request.setAttribute("keyvar",employee);
%>
<c:out
value="${requestScope.keyvar.eno}"></c:out><br/>
<c:out
value="${requestScope.keyvar.ename}"></c:out><br/>
<c:out
value="${requestScope.keyvar.esalary}"></c:out><br/>
<c:out value="${requestScope.keyvar.address.street}"></c:out>
<br/>
<c:out value="${requestScope.keyvar.address.city}"></c:out>
<br/>
<c:out value="${requestScope.keyvar.address.state}"></c:out>
<br/>
</body>
</html>
How to keep collections object in scope variables::::
Using of vector: -
<html>
<body>
<%
Vector vector=new Vector();
Address address1=new Address();
address1.setCity("Nellore");
address1.setState("Andhrapradesh");
address1.setStreet("Peta Satram Road");
Address adress2=new Adress();
address2.setCity("Karimnagar");
address2.setState("Telanagana");
address2.setStreet("Kanagarthi");
vector.add(address1);
vector.add(address2);
request.setAttribute("vectorvkey",vector); %>
<c:forEach
var="adr" items="${requestScope.vectorvkey}">
<c:out
value="${adr.city}"></c:out><br/>
<c:out
value="${adr.state}"></c:out><br/>
<c:out
value="${adr.street}"></c:out><br/>
</c:forEach>
</body>
</html>
Using Of Hashtable: -
<html>
<body>
<%
Hashtable hashTable=new Hashtable();
Address address1=new Address();
address1.setCity("Nellore");
address1.setState("Andhrapradesh");
address1.setStreet("Peta Satram Road");
Address adress2=new Adress();
address2.setCity("Karimnagar");
address2.setState("Telanagana");
address2.setStreet("Kanagarthi");
hashTable.put("keyOne",address1);
hashTable.put("keyTwo",address2);
request.setAttribute("hashtableKey",hashTable);
%>
<c:forEach var="adr" items="${requestScope.hashtableKey}">
<c:out value="${adr}"></c:out>
<c:out value="${adr.key}"></c:out><br/>
<c:out
value="${adr.value}"></c:out><br/>
<c:out
value="${adr.value.city}"></c:out><br/>
<c:out
value="${adr.value.state}"></c:out><br/>
<c:out value="${adr.value.street}"></c:out><br/>
</c:forEach>
</body>
</html>
Output Is:
-
keyOne=com.siva.Adress@7283b2
keyOne
// <c:out value="${adr}"></c:out> prints key and
value both
keyOne
//<c:out value="${adr.key}"> prints Key of adress
object in hashtable object
<c:out
value="${adr.value}"> print the reference of adress
object in hashtable object
Nellore
<c:out
value="${adr.value.city}"> print the value in address object
Andhrapradesh
Peta Satram Road
CUSTOM TAGS by sumanth
In the jsp we are going to use custom tags.
By using custom tags we are able to remove the java code from jsp. But some
time it is not possible to remove java code form jsp by using action tags. So
we are going to use custom tags..
To iterate the ArrayList in the jsp there is
no Action tags. So to iterate ArrayList in jsp we use Custom tags.
To use
custom tags first
1) We
need to identify what are the tags as part of our tag library
2) You
need to identify the functionality of tags. Identify the functionality that
needs to carry out by every tag.
NOTE: -
The jsp compiler uses the TLD files to find which tag is mapped to which tag
handler class.
In the tld file <taglib-version> tag
indicates the version info about our tag library.
In the tld file <jsp-version> tag is
used to specify which version of jsp container is supported our taglibrary.
This usp version tag specify from which lower version of jsp, is supported for
this tag library.
How to use tld fils in our project?
1) Copy
the library files in lib folder of our project.
2) Copy
the required tld files into the WEB-INF directory.
3) The information
regarding the taglibrary must place inside the web.xml file...
4) To use
tag library in our jsp we have to provide the jsp page directive (taglib)
FLOW: When you use tag in the jsp then based on prefix of tab it identify the
uri in the jsp pagedirective. Based on the uri it goes to web.xml file. In the
web.xml file if uri is matched then find the tld file in web.xml file.Then go
to WEB-INF,here tld file entry is there. In the tld file class name is
there.the .class file file for that class is in lib folder. Then it executes
the class and do the operations for that tag...
In the tagHandler class doEnd() will
return EVAL_PAGE (or) SKIP_PAGE.
Compulsary taghandler class must return any of the above constant. If doEnd()
tag method return EVAL_PAGE. After tag is evaluated or executed the jsp
complier can process the other tags which are available in the jsp.
If taghandler class returns SKIP_PAGE after
tag is evaluated the jsp compiler will discard all other tags which are available
in the jsp.
If anyone develops the tag library most of
the time they return EVAL_PAGE only.
FOUR TYES OF TLDS
1)
c.tld, c-rt.tld: All tags that are required to project is
placed in the tld.
2)
sql.tld, sql-rt.tld: All tags which are required to interact wt DB
3)
fmt.tld, fmt-rt.tld: To develop
I18N applications.
4)
x.tld, x-rt.tld: This tag
library consist of set of tags to read the contents form xml files
<c:out value="SANTOSH"></c:out>
Here
SANTOSH is static text .For static text better to use TemplateText. Because for
custom tags lot of code will be generated internally.
VERY IMPORTANT POINT
Most of the
times when data is given to View by controller. The data will be placed in any
of the scope (page, request, session, application). Mainly the core tag library
deals with getting data from the scopes and iterates them and display result s
to the user.
As part JSTL it supports EL Expressions. Jstl
EL Expressions will support only scoped variables. EL Expressions are
replacement of Jsp Expressions
NOTE: We cannot use EL Expressions on the java
variables.
<c:out value="${vone+vtwo}"></c:out>
In the above <c:out> tag vone, vtwo
variables assume are not in any of the scope. And if the variable is
participated in arithmetic expressions it returns '0' value.
SET TAG: set tag is used to create the object and add
the object to a specific scope.
<c:set var="Vone" value="100"
scope="request" />
Default scope is page.
When ever set tag is evaluated it create a
variable Vone and store the data inside the Vone variable. And Vone variable
will be added to request scope with key Vone.
${ } : This
type of syntax is called as EL Expressions...
NOTE: param is the implicit variable. Using this
implicit variable we can read the data from HTML form.
VECTOR EXAMPLE
First time when for Each tag is evaluated it
gets the first element from collection object, The element reference will be
stored in a variable obj. This variable will be added to the page scope. we can
get this object by using out tag.
<c:forEach var="obj" items="${requestScope.empdet}">
<c:out
value="${pageScope.obj.name}"/><br/>
<c:out
value="${pageScope.obj.street}"/><br/>
<c:out
value="${pageScope.obj.city}"/><br/>
<c:out
value="${pageScope.obj.state}"/><br/>
</c:forEach>
In the code forEach tag is evaluated and it
gets the first object form vector and it is assigned to variable obj. This object
will be added to the pageScope with key obj.
We have use the cout tag to get the data from
pageScope whose key is obj. The same process will be repeated for all the
elements which are available in object.
Every time it will execute for each tag page
Context object will be refreshed with the objects....
<c:forEach var="i"
items="one,two,three,four,five">
<c:out
value="${i}"/></c:forEach>
When
the forEach tag is evaluated the forEach tag checks weather items object is separated
with the separator delimiter, it is , operator then forEach tag gets the value
which is available before the coma operator.
Session Tracking Techniques
HIDDEN VARIABLES
COOKIES
SESSIONS
URLREWRITTING
Http, Https Protocol is a stateless protocol.
All servers are developed by supporting for http, https protocols. So all
servers are stateless because http, https are state less protocols.
Https for security => security available by the process of. If
network administrator is did as server support https protocol. So when you send
the request to the server. Then server encrypts the data and does the process.
Then server gives response back to the client with certifications. Then based
on the certifications client (Browser) decrypt the information. This is the
process when you use https protocol.
If the protocol needs to behaves as stateful protocol
it uses the following techniques.
V IMP NOTE: Sometimes we need to capture the data from the user
using multiple forms (i.e. by Wizard style)
When you click on NEXT BUTTON each time it is
new request. (That is in wizard style)
FLOW IN WIZARD STYLE:- You
send the request to f1.jsp . After sending the request to f1.jsp it is
displayed in browser and you fill the form with some fields and click on next
button. When you click on next button again request goes to server and request
goes to f2.jsp
In f1.jsp the fields are sno, sname and in
f2.jsp the fields are fathername, adress. When you click on next button i.e.
before request goes to f2.jsp--- The browser will capture the details entered
by user in f1.jsp and send the request to server for executing ftwo.jsp
NOTE: The
server has placed user details inside the request object. This request object
will be removed from the user after ftwo.jsp is proceeding. After ftwo.jsp is
processed the server will remove the request, response objects and displays the
ftwo.jsp in browser. After user has filled the data in the ftwo.jsp form the
user will click on store button. Now new request will send to the server for
procession store.jsp.
Now the server will execute the store.jsp
program. This program captures the data sno, sname, fathername and address from
the request object and stores the info in DB. But the current request object is
holding the information about fname and adress. It does not consist of sno
information and sname informatio. Because of this reason we will get null values.
To rectify this problem we will goes to 1)
Hidden variables 2) cookies 3) sessonns 4)urlRewritting
HIDDEN VARIABLES
Using this approach or technique. When you
send the data to the server our application captures the data and sends back
the same data to the client program once again in the form of hidden variables
fone.jsp
<html>
<body>
<form action="hidden2.jsp">
STUDENT NO::<input
type="text" name="sno"><br/>
STUDENT NAME::<input
type="text" name="sname"><br/>
<input
type="submit" value="NEXT">
</form>
</body>
</html>
ftwo.jsp
<html>
<body>
<form action="hidden3.jsp">
<input type="hidden" name="sno"
value="<%=request.getParameter("sno")
%>"><br/>
<input type="hidden" name="sname"
value="<%=request.getParameter("sname")
%>"><br/>
FATHER NAME::<input
type="text" name="fname"><br/>
ADRESS::<input
type="text" name="address"><br/>
<input
type="submit" value="STORE">
</form>
</body>
</html>
Store.jsp
<html>
<body>
<%
String
studentno=request.getParameter("sno");
String
studentname=request.getParameter("sname");
String
fathername=request.getParameter("fname");
String address=request.getParameter("address");
%>
<%=studentno
%><br/>
<%=studentname
%><br/>
<%=fathername
%><br/>
<%=address
%><br/>
</body>
</html>
Using of the hidden variables or hidden
fields for huge amount of the data is not recommended. It reduces the
performance of the application.
NOTE: Hidden variables cab be used to
store for very less amount of data. Generally we use this in search criteria.
Most of the developers prefer using of hidden
variables. Because this technique will not consume the server resources (Will
not create any objects or memory in the server).
When you using hidden variable you observe
the URL and VIEWSOURCE (You observe the values of the hidden variables).
COOKIES
A Cookie is a small piece of information set
by server on the client program. A cookie is available in client pc. Cookie
concept is also for maintaining the state like as hidden variables.
A Cookie will be having name and value i.e.
cone=valueOne.
In the
earlier version there is no restriction on no of cookies set by server on
client pc. But now new version of browser there is a restriction on no of
cookies.
If the cookies are available with the client
and when ever client sends the request to the server the cookies will send back
to the client program.
Whenever server sets a cookie on the client.
Client uses the domain name of the server to store the cookies of to categories
the cookies in the client program.
In the old applications most of the customers
does not like using of cookies. Because of security reasons. In the latest
browsers all the security related problems are rectified. Because of this
reason in the latest applications has started using cookies...
In java to represent cookies we use a class javax.servlet.http.Cookie.
Note: -
Here two types of cookies are there they are
1) Default
cookies (created by server)
2) Developer
created cookies.
NOTE: -
Sessions concept depend on default cookies .Example of default cookie is
JsessionId cookie.
REQUIREMENT: - Develop a jsp program which will be able to create two cookies and
set them or place them inside the client program.
PROGRAMG FOR HIDDEN VARIABLES?
fone.jsp
<html>
<body>
<form
action="hidden2.jsp">
STUDENT NO::<input type="text"
name="sno"><br/>
STUDENT NAME::<input type="text"
name="sname"><br/>
<input type="submit" value="NEXT">
</form>
</body>
</html>
ftwo.jsp
<html>
<body>
<%
String
studentno=request.getParameter("sno");
String
studentname=request.getParameter("sname");
Cookie c1=new
Cookie("ckone",studentno);
Cookie c2=new
Cookie("ctwo",studentname);
response.addCookie(c1);
response.addCookie(c2);
%>
<form action="hidden3.jsp">
<!-- <input
type="hidden" name="sno"
value="<%=request.getParameter("sno")
%>"><br/>
<input type="hidden" name="sname"
value="<%=request.getParameter("sname")
%>"><br/>
-->
FATHER NAME::<input type="text"
name="fname"><br/>
ADRESS::<input
type="text" name="adress"><br/>
<input
type="submit" value="STORE">
</form>
</body>
</html>
Store.jsp
<html>
<body>
<%
Cookie
ckarr[]=request.getCookies();
out.println("length;::"+ckarr.length);
//Here length is three the third one is
default cookie is JSESSIONID COOCKIE. This jsessionId cookie
//useful in session concept. You observe
there.
String
defailtname=ckarr[0].getName();
out.println("defailtname;::"+defailtname);
String
studentno=ckarr[1].getValue();
String
studentname=ckarr[2].getValue();
String
fathername=request.getParameter("fname");
String address=request.getParameter("address");
%>
<%=studentno
%><br/>
<%=studentname
%><br/>
<%=fathername
%><br/>
<%=address
%><br/>
</body>
</html>
After cookies are created the programmer is
responsible to write the code to send the cookies back to the client program.
we can send the cookies back to the client program using response object.
Whatever cookies
we want send it to client. They need to be added to addCoockie() method of our response object.
Whenever client sends the request to the
ftwo.jsp the server will create two cookies’ objects and they will send to the
client program. response.addCoockie()
method is responsible to send the cookie to the client program.
PROCESS OF HOW SERVER ADDS THE COOKIES TO THE BROWSER
http://localost:8080/ftwo.jsp: When
we send the above request query to the server. Request will go by request
format. Then server will create the request object and also create the cookies (cookies
are created in the form of an array). Then server will create the response
object then cookies are added to response object. Then the response object
gives it to ftwo.jsp. While giving response object to ftwo.jsp, server is
responsible to translate HttpResponse object into HttpResponse format. When the
server is translating the response object to response format, servers checks
are there any cookies are available. If they are available the server converts
the cookies into setcookie header format and sends it to the client program.
PROCESS OF WHEN WE SEND THE REQUEST FROM BROWSER THEN HOW COOCKIES
ARD SENDS TO SERVER
Whenever the browser sends the request to
server, The browser will check for the corresponding domain name. Are there any
cookies are available. If it is available the cookies will be added to request
object and send to server.
To read the cookies of the client program we
use a method getCookies(). This method will return an array of cookies.
On the client program if the cookies are not available.
Then request.getCookies() method will return null value. Because of the above
reason if the programmer want to handle the cookies he need to check whether
the cookies array is null or not. Otherwise it will give error.
TESTING OF COOKIES
See Above store.jsp. In that we display size
of the cookie array. After sending the request to store.jsp you go to tools
-> internet options and delete the cookies. Now again send the request to
store.jsp. Now see the size of the cookies array...
PROGRAM
Like this
you can iterate the arrays of cookies....
for(int i=0;i<ckarr.length;i++){
Cookie c=ckarr[i];
String name=c.getName();
if(name.equals(sno)){
sno0=c.getValue();
}
if(name.equas("sno")){
sno=c.getValue();
}
}
THE MAIN APPLICATION AREA OF USING COOKIES
Generally cookies
are not used as like above program for storing the data. It is not recommended
to store data
The main purpose of using cookies is for
developing personalized applications (Based on customer choice the application
will display appropriate content)
1)
Two users are visiting the site. Internally have black background for
the pages. But personally you want yellow background for page..I can develop an
application using cookies generate the content according to the personal taste
of user.
2)
If you open amazon.com and buy a books. And latter 5 days you buy toys
form amazon.com after 5 days you open that site once again then it shows
messages and images like new books are come, please buy it. And latter 5 days
you open site once again. Now it shows a message new toys are come. Please buy
it. It shows messages based on info of cookies.
SESSIONS
I have a doubt is this sessions concept and
session scope concept is same or not i don't know. But i am thinking as these
both are same. For every browser, on behalf of browser one session object is
created. i think this session object only is used for sessions, session scope concept..
From the Firefox browser when we send the
request to fone.jsp. In the server it checks on behalf of Firefox browser the
session object is available or not. As it not available the server will create
the one session object on behalf of Firefox browser. Then the server will
assign a unique id for the session object. Then server will create one cookies
object with name JSESSIIONID, in that cookies, server stores the unique id of
session object as value in the jsessionId cookies. And the cookies will send to
Firefox browser with response object.
NOTE after session is created it will added to session object pool.
Second time when we send the request to any
file in the domain (any jsp). Then the client program finds all the cookies
which are belongs to that domain and send back all the cookies belong to that
domain to the server. Now when server receives the request, the server first
checks for a specific cookies JSESSIONID. If it is available then server gets
the value from that and checks for already created session object unique id is available
or not in that cookies on behalf of browser. If it is available it will not
create the session object. Otherwise it will create the session object.
NOTE: If the client did not send any JSESSION cookies
to the server, without checking in the object pool the server will create one
session object on behalf of the client.
HOW TO REMOVE SESSION OBJECT FROM THE SERVER
After creating the session object in the
server then you close the browser. Then cookies are removed from browser. So
the mechanism of remembering client information will be removed. But the server
will not be aware of restarting the browser and it holds old session object. Next
time when we got the request the server treats that the client is sending the
request for 1st time and create the session object.
According to the Servlet specification there
are so many mechanisms are available to remove the session object from the
server.
The programmer want to remove the session
object we can use the method invalidate() to remove session object from session object pool.
After session object is created inside the
server it is not used for more than 30 minutes then server will remove the
session object from the server( actually not remove - it made it as invalidate
by invalidate()).
NOTE: Actually the program will not remove the session object. The object will
be marked as invalidate object. Server will run the thread to remove all the
invalid objects from session pool.
By default most of the server vendors will
provide 30 minutes as default time out. But base on our project requirement we
can reduce the time using
setMaxInactiveInterval(10)...This method takes no of seconds as input.
DISADVANTAGES OF SESSIONS: -
Sessions object consumes server resources. If
too much of data is stored in the session object the performance of the
applications will be affected. In case of sessions more amounts of data will
not be transfer between client and server.
Hidden variables, cookies not use server
resources. But sessions use server resources. Because we store data in session
object. In the session we maintain data inside the server. But not in cookies, hidden
variables, only session maintain data inside the server.
NOTE NOTE NOTE NOTE NOTE NOTE VVVVVVVVVVVVVVVVV VVVVVVVV IMP IMP IMP
IMP IMP IMP IMP
COPY
servlet-api.jar in delete folder and extract that servlet-api.jar in delete
folder. Now in that one DTD file is there. In that DTD file all the tag names
of web.xml file is there. If you want to use tags in web.xml file that tags
must be specify in DTD FILE....
Instead of specifying the max time out in all
jsps and servlets, we can specify the session time out in wex.xml file.
In
a project if we have 100 jsps and Servlets in all the files we need to specify
maxInactiveTimeInterval(). If customer wants to change max time then you need
to change in all jsps or Servlets. so better to declare in web.xml file...BY
using tags <session-config>,<session-timeout>
To create the seseeion object we take
help of javax.servlet.http.HttpSession
interface.
To create session in Servlets we use the
following code.
PROGRAM
public void service(){
printWriter
out=response.getWriter();
HttpSession session=null;
sesssion==request.getSession();
out.print("session
id::"+session.getId());
}
When request.getseesion() is executed then
service check weather already the session object available on behalf of this
client. If it is not available getSession() creates a new session object. If it
is available getSession() method returns the same session object which is already
available.
request.getSession(true); If session object is already available it
returns the session object. If it is not available it creates the new session
object.
request.getSession(false);If session object is already available it
returns the session object. If it is not available it returns the null value.
In case of jsp whenever we send the request
to jsp. If session object is available it returns the session objects else it
will create the new session object. Inside the generated Servlet for jsp it
have the code something similar to
request.getSession(true); In the jsp it never returns null value. Because
is has code something like request.getSession(true);
PROGRAM AND ONE PROBLEM WITH SESSIONS
trailOne.jsp
<html>
<body>
<form action="trailTwo.jsp">
SANTOSH ONE : <input
type="text" name="santoshOne"><br/>
<input
type="submit" value="NEXT">
</form>
</body>
</html>
trailTwo.jsp
<html>
<body>
<form
action="trailThree.jsp">
SANTOSH TWO : <input type="text"
name="santoshTwo"><br/>
SANTOSH THREE : <input
type="text" name="santoshThree"><br/>
<input type="submit" value="NEXT">
</form>
</body>
</html>
trailThree.jsp
<jsp:useBean id="idOne" class="com.siva.Trail"
scope="session"/>
<jsp:setProperty property="santoshTwo"
name="idOne"/>
<jsp:setProperty property="santoshThree"
name="idOne"/>
<html>
<body>
<!--<jsp:getProperty property="santoshOne"
name="idOne"/><br/>
<jsp:getProperty property="santoshTwo"
name="idOne"/><br/>
<jsp:getProperty property="santoshThree"
name="idOne"/><br/>
-->
<c:out
value="${sessionScope.idOne.santoshOne}" ></c:out><br/>
<c:out
value="${sessionScope.idOne.santoshTwo}"></c:out><br/>
value="${sessionScope.idOne.santoshThree}"></c:out><br/>
<c:out
value="${sessionScope.idOne}"></c:out><br/>
<c:out
value="${sessionScope}"></c:out><br/>
</body>
</html>
In the above code first you execute
trailone,trailtwo,trailthree jsps. Now see the output. Then second time doesn’t
close the browser and directly send the request to trailTwo.jsp. and fill the
from then see the output. The changed values in trailTwo.jsp are displayed in output.
But trailone.jsp values are displayed as it is. ie first form data is not
changed. But second form data is changed..
NOTE: sessions are very good because they do not
transfer the data between client and server. But much careful about the code.
In the session we maintain the data inside
the server. But not transfer between client and server only by jsessionId
coockie will maintain the state. But not with data
But in cookies and hidden variables data will
not maintain in the server. But data is transfer between client and server. So
session is the best technique compare to cookies and hidden variables. But
careful while doing program with sessions.
Note: There
are two types of cookies are available. They are
1)) persistence Cookies
2)) Non persistence Cookies
Persistence cookies will store inside the hard
disk of the computer. Non persistence cookies stored inside the memory of the
program.
As persistence cookies store inside computer
hard disk even we have restarted the application we can get back the cookies. Whereas
nonresistance cookies store inside the program memory. If we restart the
program we lose the cookies.
NOTE: BY default when we create the cookies’ they
are of type nonresistance cookies.
To make a cookies’ as persistence cookies’ we
need to set the expire date to the cookie. By default the cookie will become a
non persistence cookie. The programmer is responsible to call the method
setMaxAge() to make cookie as persistence cookie.
Inside the hard disk under the browsers cache
folder the cookie will be stored. Writing state of the cookie in a file or hard
disk is called as persistence.
URLREWRITING (NOT
UNDERSTAND)
Q)) what is the purpose of urlreWriting?
In the browser if you set an option like
server does not send cookies’ to client. You check this option in browser. Then
server will not send the cookies’ to the client..
Now execute the above project with fone.jsp,
ftwo.jsp, store.jsp. Then for every request separate session object is created i.e.
in output diff session object id will shown to you..By this it not possible to
maintain state full.
To achieve
above problem we go to another technique is urlRewriting technique. For this
for above program in every anchor tag we write like bellow.
<a href="<%=response.encodeUrl("one.jsp")
%>"> By
this with url every time id is add and send to server i.e. same session is send
to server every time even we set an option in the browser for not accessing of cookies’.
Sometimes
the browser programs will not accept the cookies’. If the browser program has
not accepted the cookies’ the session management will not work fine. To solve
this problem we encode the url.
PROGRAM
<html>
<%
<a href="<%=response.encodeUrl("two.jsp")
%>"> two.jsp</a>
<a href="<%=response.encodeUrl("three.jsp")
%>"> three.jsp</a>
%>
<html>
Whenever the encodeUrl() method is executed
it takes the URL which we have specified and update with the sessionId of the
object and send to the client.
SOME POINTS FROM SURESH FOR SESSION TRACKING
1. Hidden fields
2. Cookies
3. Session (session managed
using Cookies)
4. Url rewriting (session
managed using UrlRewritting)
Note: The 3rd and 4th concept is Sessions and urlrewriting technique both
concepts depend on session object only. That‘s why session managed using
cookies and session managed using urlrewritting.
Note:
More amounts of data get transferred between the client and server in case of
the application using hiddenfields(compare the application with single form
with the application using multiple forms with hidden fields).
Note: In
case of hidden fields, memory (server resources) will not be used on the server
to remember the data provided by the user in the earlier steps.
Note: For
cookies domain name (hot mail,gmail) is important, server port number is
important, which web server(tomcat,weblogic) you are running not important to
browser.
Note:
Like hidden fields application more amount of data will be transfer between the
client and server when the cookies are used. The application using cookies will
fail, if the cookies are not accepted by the browser. We cannot use cookies
when huge amount of data or information is given by the user in the forms. Like
hidden fields, in case of cookies their server resources (memory) are not used.
Note: VVVVIMPVVVVVIMPVVVVVIMPVVVVIMP:
If the cookies are disabling in the browser, then the server will
not be able to link up the session object with the browser.
Note: (But not understand)
response.encodeUrl("three.jsp") generates the url with the is of the
session object like three.jsp.
Note: URL rewriting technique reduces the
performance of the application. But our application will be able to use the
session objects even if the cookies are not allowed by the browsers.
JUST INFORMATION
If an option set in the browser is not allow accessing
the cookies i.e. block the cookies. Then for every request one session object
is created. I.e. for form.jsp, gsf.jsp, sd.jsp.
For the above three jsps for every request
one session object is created. You send the request for form.jsp, for this one
session object is created. Then request goes to gsf.jsp for this another
session object is created. The values you fill in the form.jsp is stored in one
session object. And the values you fill in the gsf.jsp is stored in another session
object. So for every request one session object is created. Server memory is
wasted and you get unreliable data i.e. wrong data.
CODE TO URL REWRITTING
In the above trailOne, trailTwo, trailThree
jsps are there. Then in trailTwo.jsp in the form tag just you change the code
for urlrewriting as bellow.
<form
action="<%=response.encodeUrl("sd.jsp")%">
Note: The session object consumes server resources (memory). If too much of
info (data) is stored in session object. Then the performance of the
application will be affected.
Note: -
In case of sessions more amounts of data will not be transferred between the
client and server.
SMALL PROGRAM FOR HOW TO MAKE A
COOCKIE AS PERSISTANCE
<%
cookie c1,c2;
c1 = new
Cookie("ckone","value one");
c2 = new
Cookie("cktwo","value two");
c2.setMaxAge(60*60*2*90); //just
for example
response.addCookie(c1);
response.addCookie(c2);
%>
Our application has set cookies on browser.
The cookie that will be lost when we close the browser is called as non Persistence
cookie or session cookie .vone is the non persistence cookie. The browser
stores this cookie in the memory.
The cookie
that will stay with browser even if we close the browser is called as persistence
cookie. The browser stores these cookies in the disk.
Note: - The old version of Firefox uses coockies.txt file and new version uses
cookies. sqlite fie storing the cookies.
Internet
explorer uses multiple files in temporary internet files folder for storing the
cookies...
NOTE: VVVVIMP VVVVIMP VVVVIMP VVVVIMP
We can use
the query string for passing on the information from jsp/manually developed Servlets
to a jsp/manually developed Servlets
<a
href="getmail.jsp?id=1">HELLO</a>
<a
href="getmail.jsp?id=2">MAIL ONE</a>
<a
href="getmail.jsp?id=3">MAIL TWO</a>
In above “getmail.jsp?id=1" and id=2,id=3 are called query string.
Note:
Query string is different for encodeUrl concept. In the jsp when you use
enoceUrl() method then only it is a encode Ur concept. But in spring how write the code
for encode url, I don't know. I think query string is used in sendRedirect
process.
The next concepts in suresh book
is about is
1)
Absolute path and relative path, context path and when you use absolute
path and when you use relative path. I.e. used in RequestDispatcher object get
from application (ServletContex) or request (ServletRequest). What happen when
you get rd object from ServletContex, what happen when you get form ServletRequest.
When you use absolute path and when you use relative path
2)
requestdispatcher.include(), requestdispatcher.forward(). Concepts
3)
sendRedirect concept.
4)
what is the diff between the
<%@ include="sitwo.jsp" %> and <jsp:include
page="ditwo.jsp" />
NOTE: We can use the path starting with a /
excluding the context path as a parameter to
application.getRequestDispatcher();
request.getRequestDispatcher();
NOTE: -
We can use the relative path with request.getRequestDispathcer() but not with application.getRequestDispathcer().
No comments:
Post a Comment