Session tracking in servlets:

->session means a particular interval of time

->session tracking is a way to maintain state(data) of a user.it is also known as management in

servlet.

->Http protocol is a stateless,so we need to maintain state using session tracking techniques.

->Each time user requests t o the server,server treats the requests as the new requests.

->so we need to maintain the state of an user to recognize the particular user.

->Http is stateless that means each request is considered as the new request.All req& response are
independent.

3)Second request(new)
Client
1)Request(new)
server
2)response

->session tracking is used to recognize the particular user.

->session tracking techniques:

Four techniques used in session tracking:

1)cookies 2)hidden form fields 3) URL Rewriting 4)Httprequest

How session works:

Client1
server

Request id=123
Web container
Session
Client2 id=123
servlet
request id=124 Session
id=124
Cookies in Servlet:

A cookie is a small piece of information that is persisted b/w the multiple client request.

It has a name,single value attributes such as a comment,path& domain qualifier,a max age and
version no:

3.request+cookie
User
1.request server

2.response+cookies

How cookies works:

By default each cookie request is considered as a new request .in cookie technique we add cookie
with response from the servlet.so cookies is stored in a cache of a browser.After that if request is
sent by the user cookie is added with request by default.Thus we recognize the user as the old user.

Types of Cookie:

1)Non-Persistent Cookie

2)Persistent cookie

1)Non-Persistent Cookie:It is Valid for single session only.It is removed each time when user closes
the browser.

2)Persistent cookie: It is valid for multiple session.it is not removed each time when the user closes
browser.it is removed only if usr logout of the session.

Advantages:

1)Simplest technique of mainting the state.

2)Cookie are maintained at client side.

Disadvantage:

1)itvl not work if cookie is disables from the browser.

2)only textual information can be set in cookie object.

Cookie class:

Cookie class provides the method and functionality for session management using cookie.

Javax.servlet.http.cookie class provides the functionality of using cookies.

Constructor of cookie class

Constructor Description

->cookie() constructs a cookie

->Cookie(string name,string value) constructs a cookie with specified name & value

->cookie class provides a lot of useful methods for cookies.

Commonly used methods of cookie class

Method Description

Public void setMaxAge(int expiry) - Sets the max age of the cooki in second s

Public string getName() - Returns the name of the cookie.The name cannot be changed after
creation.

Public string getvalue() - Returns the value of the cookie

Public void setName(straName) - changes the name of the cookie

Public void setValue(strValue) – changes the value of the cookie.

How to create cookie?

Cookie ck= new Cookie(“user”,”divya”);//creating cookie object

Response.addcookie(ck);//adding cookie in the response

How to delete cookie?

It is mainly used to logout or signout the user.

Cookie ck=new cookie(“user”,””);//deleting value of cookie

Ck.setMaxAge(0);//changing the max age to 0 seconds

response.addcookie(ck);//adding cookie in the response

How to get cookies?

Cookie ck[]=request.get cookies();

For(int i=0;i<ck.length;i++)
{

out.print(“<br>”+ck[1].getName()+” “+a[i].getValue());//printing name & value of cookie

Client1 server client2

HTTP reqHTTP request

HTTP responsesession id =123

HTTP responses

HTTP req session id=192

HTTP request Session id=191

What are Cookies?
Cookies are data, stored in small text files, on your computer.

When a web server has sent a web page to a browser, the connection is shut
down, and the server forgets everything about the user.

Cookies were invented to solve the problem "how to remember information

about the user":

 When a user visits a web page, his/her name can be stored in a

cookie.
 Next time the user visits the page, the cookie "remembers" his/her
name.

Cookies are saved in name-value pairs like:

username = John Doe

When a browser requests a web page from a server, cookies belonging to the
page are added to the request. This way the server gets the necessary data
to "remember" information about users.

Create a Cookie with JavaScript

JavaScript can create, read, and delete cookies with
the document.cookie property.

With JavaScript, a cookie can be created like this:

document.cookie = "username=John Doe";

You can also add an expiry date (in UTC time). By default, the cookie is
deleted when the browser is closed:

document.cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00

UTC";

With a path parameter, you can tell the browser what path the cookie
belongs to. By default, the cookie belongs to the current page.

document.cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00

UTC; path=/";
Read a Cookie with JavaScript
With JavaScript, cookies can be read like this:

let x = document.cookie;

document.cookie will return all cookies in one string much like: cookie1=value;
cookie2=value; cookie3=value;

Change a Cookie with JavaScript

With JavaScript, you can change a cookie the same way as you create it:

document.cookie = "username=John Smith; expires=Thu, 18 Dec 2013

12:00:00 UTC; path=/";

The old cookie is overwritten.

Delete a Cookie with JavaScript

Deleting a cookie is very simple.

You don't have to specify a cookie value when you delete a cookie.

Just set the expires parameter to a past date:

document.cookie = "username=; expires=Thu, 01 Jan 1970 00:00:00 UTC;

path=/;";

You should define the cookie path to ensure that you delete the right cookie.

Some browsers will not let you delete a cookie if you don't specify the path.

The Cookie String

The document.cookie property looks like a normal text string. But it is not.
Even if you write a whole cookie string to document.cookie, when you read it
out again, you can only see the name-value pair of it.

If you set a new cookie, older cookies are not overwritten. The new cookie is
added to document.cookie, so if you read document.cookie again you will get
something like:

cookie1 = value; cookie2 = value;

Display All Cookies Create Cookie 1 Create Cookie 2 Delete Cookie 1 Delete
Cookie 2

If you want to find the value of one specified cookie, you must write a
JavaScript function that searches for the cookie value in the cookie string.

JavaScript Cookie Example

In the example to follow, we will create a cookie that stores the name of a
visitor.

The first time a visitor arrives to the web page, he/she will be asked to fill in
his/her name. The name is then stored in a cookie.

The next time the visitor arrives at the same page, he/she will get a welcome
message.

For the example we will create 3 JavaScript functions:

1. A function to set a cookie value

2. A function to get a cookie value
3. A function to check a cookie value

A Function to Set a Cookie

First, we create a function that stores the name of the visitor in a cookie
variable:

Example
function setCookie(cname, cvalue, exdays) {
const d = new Date();
 d.setTime(d.getTime() + (exdays*24*60*60*1000));
let expires = "expires="+ d.toUTCString();
document.cookie = cname + "=" + cvalue + ";" + expires + ";path=/";
}

Example explained:

The parameters of the function above are the name of the cookie (cname),
the value of the cookie (cvalue), and the number of days until the cookie
should expire (exdays).

The function sets a cookie by adding together the cookiename, the cookie
value, and the expires string.

A Function to Get a Cookie

Then, we create a function that returns the value of a specified cookie:

Example
function getCookie(cname) {
let name = cname + "=";
let decodedCookie = decodeURIComponent(document.cookie);
let ca = decodedCookie.split(';');
for(let i = 0; i <ca.length; i++) {
let c = ca[i];
while (c.charAt(0) == ' ') {
c = c.substring(1);
}
if (c.indexOf(name) == 0) {
return c.substring(name.length, c.length);
}
}
return "";
}

Function explained:

Take the cookiename as parameter (cname).

Create a variable (name) with the text to search for (cname + "=").

Decode the cookie string, to handle cookies with special characters, e.g. '$'
Split document.cookie on semicolons into an array called ca (ca =
decodedCookie.split(';')).

Loop through the ca array (i = 0; i < ca.length; i++), and read out each
value c = ca[i]).

If the cookie is found (c.indexOf(name) == 0), return the value of the cookie
(c.substring(name.length, c.length).

If the cookie is not found, return "".