Session Pattern Examples in Java

Session Pattern in Java

//[C] 2002 Sun Microsystems, Inc.----

import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.HashMap;

public class RunSessionPattern {
public static void main(String[] arguments) {
System.out.println("Example for the Session pattern");
System.out
.println("This demonstration will show how a Session can be used");
System.out
.println(" to organize a series of actions between a client and");
System.out.println(" server.");
System.out
.println("In this case, clients will use sessions to coordinate");
System.out.println(" edits of Contact addresses.");
System.out.println();

System.out.println("Running the RMI compiler (rmic)");
System.out.println();
try {
Process p1 = Runtime.getRuntime().exec("rmic SessionServerImpl");
p1.waitFor();
} catch (IOException exc) {
System.err
.println("Unable to run rmic utility. Exiting application.");
System.exit(1);
} catch (InterruptedException exc) {
System.err
.println("Threading problems encountered while using the rmic utility.");
}

System.out.println("Starting the rmiregistry");
System.out.println();
Process rmiProcess = null;
try {
rmiProcess = Runtime.getRuntime().exec("rmiregistry");
Thread.sleep(15000);
} catch (IOException exc) {
System.err
.println("Unable to start the rmiregistry. Exiting application.");
System.exit(1);
} catch (InterruptedException exc) {
System.err
.println("Threading problems encountered when starting the rmiregistry.");
}

System.out
.println("Creating the SessionServer and two SessionClient objects");
System.out.println();
SessionServer serverObject = new SessionServerImpl();
SessionClient clientOne = new SessionClient();
SessionClient clientTwo = new SessionClient();

System.out.println("Creating sample Contacts and Addresses");
System.out.println();
Contact firstContact = new ContactImpl("First", "Contact", "primo",
"OOI", null);
Contact secondContact = new ContactImpl("Second", "Contact", "secondo",
"OOI", null);
Address workAddress = new AddressImpl("Work address", "5440 Division",
"Fargo", "ND", "54321");
Address homeAddress = new AddressImpl("Home address", "40 Planar Way",
"Paris", "TX", "84301");

System.out
.println("Adding a contact. Both clients will attempt to edit");
System.out
.println(" the same contact at first, which will result in a");
System.out.println(" SessionException.");
try {
clientOne.addContact(firstContact);
clientTwo.addContact(firstContact);
} catch (SessionException exc) {
System.err.println("Exception encountered:");
System.err.println(exc);
}
try {
System.out
.println("Adding a different contact to the second client");
clientTwo.addContact(secondContact);
System.out
.println("Adding addresses to the first and second clients");
clientTwo.addAddress(workAddress);
clientOne.addAddress(homeAddress);
clientTwo.addAddress(workAddress);
clientTwo.addAddress(homeAddress);
System.out.println("Removing address from a client");
clientTwo.removeAddress(homeAddress);
System.out.println("Finalizing the edits to the contacts");
clientOne.commitChanges();
clientTwo.commitChanges();
System.out.println("Changes finalized");
clientTwo.addContact(firstContact);
} catch (SessionException exc) {
System.err.println("Exception encountered:");
System.err.println(exc);
}
System.out.println("The following lines will show the state");
System.out.println(" of the server-side delegate, which in this");
System.out.println(" example represents a persistent data store.");
System.out.println();
System.out.println("Contact list:");
System.out.println(SessionServerDelegate.getContacts());
System.out.println("Address list:");
System.out.println(SessionServerDelegate.getAddresses());
System.out.println("Edit contacts:");
System.out.println(SessionServerDelegate.getEditContacts());
}
}

--------------------------------------------------------------------------------

interface Address extends Serializable {
public static final String EOL_STRING = System
.getProperty("line.separator");

public static final String SPACE = " ";

public static final String COMMA = ",";

public String getType();

public String getDescription();

public String getStreet();

public String getCity();

public String getState();

public String getZipCode();

public void setType(String newType);

public void setDescription(String newDescription);

public void setStreet(String newStreet);

public void setCity(String newCity);

public void setState(String newState);

public void setZipCode(String newZip);
}

--------------------------------------------------------------------------------

class AddressImpl implements Address {
private String type;

private String description;

private String street;

private String city;

private String state;

private String zipCode;

public AddressImpl() {
}

public AddressImpl(String newDescription, String newStreet, String newCity,
String newState, String newZipCode) {
description = newDescription;
street = newStreet;
city = newCity;
state = newState;
zipCode = newZipCode;
}

public String getType() {
return type;
}

public String getDescription() {
return description;
}

public String getStreet() {
return street;
}

public String getCity() {
return city;
}

public String getState() {
return state;
}

public String getZipCode() {
return zipCode;
}

public void setType(String newType) {
type = newType;
}

public void setDescription(String newDescription) {
description = newDescription;
}

public void setStreet(String newStreet) {
street = newStreet;
}

public void setCity(String newCity) {
city = newCity;
}

public void setState(String newState) {
state = newState;
}

public void setZipCode(String newZip) {
zipCode = newZip;
}

public boolean equals(Object o) {
if (!(o instanceof AddressImpl)) {
return false;
} else {
AddressImpl address = (AddressImpl) o;
if (street.equals(address.street) && city.equals(address.city)
&& state.equals(address.state)
&& zipCode.equals(address.zipCode)) {
return true;
}
return false;
}
}

public String toString() {
return street + EOL_STRING + city + COMMA + SPACE + state + SPACE
+ zipCode + EOL_STRING;
}
}

------------------------------------------------------------------------------

class SessionServerImpl implements SessionServer {
private static final String SESSION_SERVER_SERVICE_NAME = "sessionServer";

public SessionServerImpl() {
try {
UnicastRemoteObject.exportObject(this);
Naming.rebind(SESSION_SERVER_SERVICE_NAME, this);
} catch (Exception exc) {
System.err
.println("Error using RMI to register the SessionServerImpl "
+ exc);
}
}

public long addContact(Contact contact, long sessionID)
throws SessionException {
return SessionServerDelegate.addContact(contact, sessionID);
}

public long addAddress(Address address, long sessionID)
throws SessionException {
return SessionServerDelegate.addAddress(address, sessionID);
}

public long removeAddress(Address address, long sessionID)
throws SessionException {
return SessionServerDelegate.removeAddress(address, sessionID);
}

public long finalizeContact(long sessionID) throws SessionException {
return SessionServerDelegate.finalizeContact(sessionID);
}
}

interface SessionServer extends Remote {
public long addContact(Contact contact, long sessionID)
throws RemoteException, SessionException;

public long addAddress(Address address, long sessionID)
throws RemoteException, SessionException;

public long removeAddress(Address address, long sessionID)
throws RemoteException, SessionException;

public long finalizeContact(long sessionID) throws RemoteException,
SessionException;
}

class SessionServerDelegate {
private static final long NO_SESSION_ID = 0;

private static long nextSessionID = 1;

private static ArrayList contacts = new ArrayList();

private static ArrayList addresses = new ArrayList();

private static HashMap editContacts = new HashMap();

public static long addContact(Contact contact, long sessionID)
throws SessionException {
if (sessionID <= NO_SESSION_ID) {
sessionID = getSessionID();
}
if (contacts.indexOf(contact) != -1) {
if (!editContacts.containsValue(contact)) {
editContacts.put(new Long(sessionID), contact);
} else {
throw new SessionException(
"This contact is currently being edited by another user.",
SessionException.CONTACT_BEING_EDITED);
}
} else {
contacts.add(contact);
editContacts.put(new Long(sessionID), contact);
}
return sessionID;
}

public static long addAddress(Address address, long sessionID)
throws SessionException {
if (sessionID <= NO_SESSION_ID) {
throw new SessionException(
"A valid session ID is required to add an address",
SessionException.SESSION_ID_REQUIRED);
}
Contact contact = (Contact) editContacts.get(new Long(sessionID));
if (contact == null) {
throw new SessionException(
"You must select a contact before adding an address",
SessionException.CONTACT_SELECT_REQUIRED);
}
if (addresses.indexOf(address) == -1) {
addresses.add(address);
}
contact.addAddress(address);
return sessionID;
}

public static long removeAddress(Address address, long sessionID)
throws SessionException {
if (sessionID <= NO_SESSION_ID) {
throw new SessionException(
"A valid session ID is required to remove an address",
SessionException.SESSION_ID_REQUIRED);
}
Contact contact = (Contact) editContacts.get(new Long(sessionID));
if (contact == null) {
throw new SessionException(
"You must select a contact before removing an address",
SessionException.CONTACT_SELECT_REQUIRED);
}
if (addresses.indexOf(address) == -1) {
throw new SessionException("There is no record of this address",
SessionException.ADDRESS_DOES_NOT_EXIST);
}
contact.removeAddress(address);
return sessionID;
}

public static long finalizeContact(long sessionID) throws SessionException {
if (sessionID <= NO_SESSION_ID) {
throw new SessionException(
"A valid session ID is required to finalize a contact",
SessionException.SESSION_ID_REQUIRED);
}
Contact contact = (Contact) editContacts.get(new Long(sessionID));
if (contact == null) {
throw new SessionException(
"You must select and edit a contact before committing changes",
SessionException.CONTACT_SELECT_REQUIRED);
}
editContacts.remove(new Long(sessionID));
return NO_SESSION_ID;
}

private static long getSessionID() {
return nextSessionID++;
}

public static ArrayList getContacts() {
return contacts;
}

public static ArrayList getAddresses() {
return addresses;
}

public static ArrayList getEditContacts() {
return new ArrayList(editContacts.values());
}
}

interface Contact extends Serializable {
public static final String SPACE = " ";

public static final String EOL_STRING = System
.getProperty("line.separator");

public String getFirstName();

public String getLastName();

public String getTitle();

public String getOrganization();

public ArrayList getAddresses();

public void setFirstName(String newFirstName);

public void setLastName(String newLastName);

public void setTitle(String newTitle);

public void setOrganization(String newOrganization);

public void addAddress(Address address);

public void removeAddress(Address address);
}

---------------------------------------------------------------------------------

class ContactImpl implements Contact {
private String firstName;

private String lastName;

private String title;

private String organization;

private ArrayList addresses = new ArrayList();

public ContactImpl() {
}

public ContactImpl(String newFirstName, String newLastName,
String newTitle, String newOrganization, ArrayList newAddresses) {
firstName = newFirstName;
lastName = newLastName;
title = newTitle;
organization = newOrganization;
if (newAddresses != null) {
addresses = newAddresses;
}
}

public String getFirstName() {
return firstName;
}

public String getLastName() {
return lastName;
}

public String getTitle() {
return title;
}

public String getOrganization() {
return organization;
}

public ArrayList getAddresses() {
return addresses;
}

public void setFirstName(String newFirstName) {
firstName = newFirstName;
}

public void setLastName(String newLastName) {
lastName = newLastName;
}

public void setTitle(String newTitle) {
title = newTitle;
}

public void setOrganization(String newOrganization) {
organization = newOrganization;
}

public void addAddress(Address address) {
if (!addresses.contains(address)) {
addresses.add(address);
}
}

public void removeAddress(Address address) {
addresses.remove(address);
}

public boolean equals(Object o) {
if (!(o instanceof ContactImpl)) {
return false;
} else {
ContactImpl contact = (ContactImpl) o;
if (firstName.equals(contact.firstName)
&& lastName.equals(contact.lastName)
&& organization.equals(contact.organization)
&& title.equals(contact.title)) {
return true;
}
return false;
}
}

public String toString() {
return firstName + SPACE + lastName + EOL_STRING + addresses;
}
}

class SessionClient {
private static final String SESSION_SERVER_SERVICE_NAME = "sessionServer";

private static final String SESSION_SERVER_MACHINE_NAME = "localhost";

private long sessionID;

private SessionServer sessionServer;

public SessionClient() {
try {
String url = "//" + SESSION_SERVER_MACHINE_NAME + "/"
+ SESSION_SERVER_SERVICE_NAME;
sessionServer = (SessionServer) Naming.lookup(url);
} catch (RemoteException exc) {
} catch (NotBoundException exc) {
} catch (MalformedURLException exc) {
} catch (ClassCastException exc) {
}
}

public void addContact(Contact contact) throws SessionException {
try {
sessionID = sessionServer.addContact(contact, 0);
} catch (RemoteException exc) {
}
}

public void addAddress(Address address) throws SessionException {
try {
sessionServer.addAddress(address, sessionID);
} catch (RemoteException exc) {
}
}

public void removeAddress(Address address) throws SessionException {
try {
sessionServer.removeAddress(address, sessionID);
} catch (RemoteException exc) {
}
}

public void commitChanges() throws SessionException {
try {
sessionID = sessionServer.finalizeContact(sessionID);
} catch (RemoteException exc) {
}
}
}

class SessionException extends Exception {
public static final int CONTACT_BEING_EDITED = 1;

public static final int SESSION_ID_REQUIRED = 2;

public static final int CONTACT_SELECT_REQUIRED = 3;

public static final int ADDRESS_DOES_NOT_EXIST = 4;

private int errorCode;

public SessionException(String cause, int newErrorCode) {
super(cause);
errorCode = newErrorCode;
}

public SessionException(String cause) {
super(cause);
}

public int getErrorCode() {
return errorCode;
}
}

What is Cookie

cookie

(1) A small amount of data sent back to the requesting party by the recipient. Also called a "magic cookie," it provides information about the transaction, such as an ID or session number, which may be required later either by the recipient or a third party. This is the same concept as definition #2 below, but not specific to the Web.

(2) A small data file created by a Web server that is stored on your computer either temporarily for that session only or permanently on the hard disk (persistent cookie). Cookies provide a way for the Web site to recognize you and keep track of your preferences.

Cookies Are Beneficial
Cookies are commonly used to "maintain the state" of the session as a user browses around the site. The shopping cart is an example. You can place an item in the cart, switch to another page or even another site, and when you come back, the site knows who you are, and you can continue with the order. Without cookies, the site would not be able to identify you automatically because the Internet is "stateless." See state and stateless.

Cookies contain a range of URLs (addresses) for which they are valid. When the Web browser or other HTTP application sends a request to a Web server with those URLs again, it also sends along the related cookies. For example, if your user ID and password are stored in a cookie, it saves you from typing in the same information all over again when accessing that service the next time. By retaining user history, cookies allow the Web site to tailor the pages and create a custom experience for that individual.

Your Cookies Know You
Quite a bit of personal data may reside in the cookie files in your computer. As a result, this storehouse of private information is sometimes the object of attack (see cookie poisoning.)

First-Party Cookies
The default settings in your Web browser typically allow "first-party" cookies, but not "third-party" cookies. First-party cookies are created by the Web site you are visiting and are necessary to keep track of your preferences and the current session as explained above.

Third-Party Tracking Cookies
Third-party cookies are created by a Web site other than the one you are currently visiting; for example, by a third-party advertiser on that site. The purpose of such cookies is usually to track your surfing habits, which is why third-party cookies are considered an invasion of privacy and riskier than first-party cookies.

Configuring Settings
A Web browser can be configured so that only first-party cookies coming from the originating sites are maintained. It can also be set to prevent all cookies from being stored in your computer, but that severely limits the Web surfing experience. To change settings, look for the cookie options in your browser in the Options or Preferences menu. See Web bug, cookie file and state.