Session Tracking

Session Tracking and E-Commerce

 Why session tracking?
 HTTP is stateless and you need to keep track of transactions between
requests especially for e-commerce to keep track of client purchases
 When clients at on-line store add item to their shopping cart, how does
server know what’s already in cart?
 When clients decide to proceed to checkout, how can server determine

which previously created cart is theirs?

Session tracking is done via
 Cookies
 Hidden files
 URL rewriting
 Session API
Cookies
 Three steps to creating a new cookie (simple):
1) Create a new Cookie Object
 Cookie cookie = new Cookie (name, value);
2) Set any cookie attributes
 Cookie.setMaxAge (60);
3) Add your cookie to the response object:
 Response.addCookie (cookie)

Disadvantages

 cookies can be deleted / disables by client

Rolling Your Own Session Tracking: URL-Rewriting
 Idea
 Client appends some extra data on the end of each URL that identifies the
session
 Server associates that identifier with data it has stored about that session

 E.g., http://host/path/file.html;jsessionid=1234

 Advantage
 Works even if cookies are disabled or unsupported

 Disadvantages
 Has a lot of tedious work to do processing to do

 Must encode all URLs that refer to your own site

 Searchstring = URLEncoder.encode(serchstring)

 When redirecting, you need to use the above line to encode url to avoid

illegal characters in url normally done by automatically by getParametr

method ( space to + and other non-alphanumeric characters %xy hex
values to ascii values).
 All pages must be dynamically generated (no static HTML pages) because
you need to add userdata to url
Rolling Your Own Session Tracking:
Hidden Form Fields
 Idea:
<INPUT TYPE="HIDDEN" NAME="session" VALUE="...">

 Advantage
 Works even if cookies are disabled or unsupported

 Disadvantages
 Lots of tedious processing

 All pages must be the result of form submissions

 Session API Tracking in Java
 Servlets include a built-in Session API:

 Enables you to very easily create applications that depend on

individual user data

 For example:
 Shopping Carts
 Personalization Services
 Maintaining state about the user’s preferences.
Overview of Session API Functionality
Using the Session API
 Steps to using the Java Session API
1) Get the Session object from the HTTPRequest object.
2) Extract Data from the user’s Session Object
3) Extract information about the session object”
- e.g. when was the session created, session ID?
4) Add data to the user’s Session Object.
Session Tracking Basics
 Access the session object
 Call request.getSession to get HttpSession object
 This is a hashtable associated with the user

HttpSession session = request.getSession();

 Look up information (user data) associated with a session.

 Call getAttribute on the HttpSession object,
 cast the return value to the appropriate type,

 and check whether the result is null.

 Store information in a session.

 Use setAttribute with a key and a value.
 Discard session data.
 Call removeAttribute discards a specific value associated with a specified
“key” (This is the most common approach used).
 Call invalidate to discard an entire session (all user data) will be lost
including data created by other servlets or jsp)– be careful!.
 Getting a Session Object
 To get the user’s session object

 call the getSession() method of the HttpServletRequest class.

 Example:
HttpSession session = request.getSession();

 If user already has a session

 the existing session is returned.

 If no session exists
 a new one is created and returned.

 If you want to know if this is a new session:

 call the Session isNew() method.
Disable creation of new sessions
 If you want to disable creation of new sessions:
 pass false to the getSession() method.

 For example:
HttpSession session = request.getSession(false);

 If no current session exists:

 you will now get back a null object.
Behind the Scenes
 When you call getSession()
 There is a lot going on behind the scenes.
 Each user is automatically assigned a unique session ID.
 How does this sessionID get to the user?
 Option 1:
 If the browser supports cookies
 the servlet will automatically create a session cookie
 and store the session ID within the cookie.
 (In Tomcat, the cookie is called: JSESSIONID)
 Option 2:
 If the browser does not support cookies,
 the servlet will try to extract the session ID from the URL.
Extracting Data from the Session
Extracting Data From Session
 The Session object works like a Hash Map

 Hash Map that enables you to store any type of Java object.
 You can therefore store any number of keys and their
associated values.

 To extract an existing object,

 use the getAttribute() method.

 Note: As of Servlet version 2.2,

 the getValue() method is now deprecated.
 Use getAttribute() instead.
 Extracting Data from Session
- getAttribute () method
-Extracts previously stored value from session object
 The getAttribute () method
 will return an Object type,
 so you will need to perform a type cast.
 Example:
Integer accessCount =
(Integer)session.getAttribute("accessCount");

returns an Object type, so you will need to perform a type cast

 Extracting Data from Session
 Tip:
 If you want to get a list of
all “keys” (or attributes) associated with a Session,

 use the
getAttributeNames() method.

 This getAttributeNames() method

 returns an Enumeration of all Attribute names (keys).
Additional Session Info.
 The Session API includes methods for determining Session specific
information.
 public String getId();
 Returns the unique session ID associated with this user, e.g.
gj9xswvw9p
 public boolean isNew();
 Indicates if the session was just created (first time to this servlet).
 public long getCreationTime();
 Indicates when the session was first created in milliseconds since
midnight January 1, 1970 (GMT).
 To get value useful for printing, pass value to Date constructor.
 public long getLastAccessedTime();
 Indicates when the session was last sent from the client.
 Returns value in Milliseconds since midnight January 1, 1970 (GMT).
 Additional Methods

 public int getMaxInactiveInterval

 Determine the length of time (in seconds)

 that a session should go without access before
being automatically invalidated.

 public void setMaxInactiveInterval (int seconds)

 Sets the length of time (in seconds) that a session

should go without access before being automatically
invalidated.

 A negative value specifies that the session should

never time out.
Adding Data to the Session
Adding Data To Session
 To add data to a session, use the
 putAttribute() method,
 and specify the key_name and value.
 Example:
 session.putAttribute("accessCount", accessCount);

key
Value
 To remove a value, you can use the following:
 removeAttribute (String name) method.
Terminating Sessions
 public void invalidate()
 If the user does not return to a servlet for XX minutes*,
 the session is automatically invalidated and deleted.

 If you want to manually invalidate the session,

 you can call invalidate().

* For the exact number of Minutes before automatic expiration,

check the getMaxInactiveInterval() method.
 Encoding URLs
 If a browser does not support cookies, you need some other way to maintain the
user’s session ID.

 The Servlet API provides methods to allow you to append the session ID to URLs
if the browser does not support cookies.
 http://host/path/file.html;jsessionid=1234

 Code that generates hypertext links back to same site:

 Pass URL through response.encodeURL.
 If server is using cookies, this returns URL unchanged

 If server is using URL rewriting, this appends the session info to the URL

 Example.:
String url = "order-page.html";
url = response.encodeURL(url);

 Since this is hard to ensure, lots of sites (e.g. Yahoo require cookies.)
Example Session Code
Example #1 Overview (9.1 in book)
 Our example tracks the number of visits for each unique visitor.
 If this is a first time visit,
 the servlet creates an accessCount of Integer Integer
Type and assigns it to the Session.
 If the user has visited before,
 the servlet extracts the accessCount
and increments it,
 and also
assigns it to the Session.
 Servlet also displays
 basic information regarding the session including
 creation time and time of last access.
package coreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.net.*;
import java.util.*;

public class ShowSession extends HttpServlet {

public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Session Tracking Example";
HttpSession session = request.getSession(true);
String heading;
 Integer accessCount =
(Integer)session.getAttribute("accessCount");
if (accessCount == null) { // new user
accessCount = new Integer(0);
heading = "Welcome, Newcomer";
} else { // returning user
heading = "Welcome Back";
accessCount = new Integer(accessCount.intValue() + 1);
}
// Integer is an immutable (nonmodifiable) data structure. So, you can not modify the old one in-place.
//Instead you have to to allocate a new one and redo setAttribute.
session.putAttribute("accessCount", accessCount);
out.println(ServletUtilities.headWithTitle(title) +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H1 ALIGN=\"CENTER\">" + heading + "</H1>\n" +
"<H2>Information on Your Session:</H2>\n" +
"<TABLE BORDER=1 ALIGN=\"CENTER\">\n" +
"<TR BGCOLOR=\"#FFAD00\">\n" +
" <TH>Info Type<TH>Value\n" +
"<TR>\n" +
" <TD>ID\n" +
" <TD>" + session.getId() + "\n" +
"<TR>\n" +
" <TD>Creation Time\n" +
" <TD>" +
new Date(session.getCreationTime()) + "\n" +
"<TR>\n" +
" <TD>Time of Last Access\n" +
" <TD>" +
new Date(session.getLastAccessedTime()) + "\n" +
"<TR>\n" +
" <TD>Number of Previous Accesses\n" +
" <TD>" + accessCount + "\n" +
"</TR>"+
 "</TABLE>\n" +
"</BODY></HTML>");
}

/** Handle GET and POST requests identically. */

public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
A Servlet that Shows (run it)
Access Counts (first Time) for a specific client
A Servlet that Shows Per-Client
Access Counts: (Welcome back)
Example #2 Overview (9.2 in book)
 Provides a simple shopping cart.
 Servlet that displays a list of items being ordered
 Accumulates them in an ArrayList

 session attribute is called, “previousItems”

 Each time you add a new item,
 the item is added to the ArrayList.

 Without checking for duplicates – meant to

demonstrate basic session tracking

package coreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

public class ShowItems extends HttpServlet {

public void doGet(HttpServletRequest request,HttpServletResponse
response)
throws ServletException, IOException {
HttpSession session = request.getSession();
ArrayList previousItems =
(ArrayList)session.getAttribute("previousItems");
if (previousItems == null) {
previousItems = new ArrayList();
session.setAttribute("previousItems", previousItems);
}
String newItem = request.getParameter("newItem");
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Items Purchased";
String docType =
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 " +
"Transitional//EN\">\n";
out.println(docType +
"<HTML>\n" +
"<HEAD><TITLE>" + title + "</TITLE></HEAD>\n" +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H1>" + title + "</H1>");
 synchronized(previousItems) {
if (newItem != null) {
previousItems.add(newItem); // add a new item
}
if (previousItems.size() == 0) { // No items
out.println("<I>No items</I>");
} else {
out.println("<UL>"); // print all items in array
for(int i=0; i<previousItems.size(); i++) {
out.println("<LI>" + (String)previousItems.get(i));
}
out.println("</UL>");
}
}
out.println("</BODY></HTML>");
}
}
Accumulating a List of User Data:
Front End (OrderFrom.html)
Accumulating a List of User Data:
Result (run it)
 Summary
 The Session API is
 a simple, &
 powerful API
 that enables you to store session information about each user.

 The Session API hides all the ugly details from you, so you can focus
on your specific application.

 Steps to using the Java Session API:

 Get the Session object from the HTTPRequest object.
 Extract Data from the user’s Session Object (getAttribute method)
 Add data to the user’s Session Object (putAttribute method)