Java/Design Pattern/Transaction Pattern

Transaction Pattern Demo

//[C] 2002 Sun Microsystems, Inc.---
import java.io.IOException;
import java.io.Serializable;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
public class RunTransactionPattern {
  private static Calendar dateCreator = Calendar.getInstance();
  public static void main(String[] arguments) {
    System.out.println("Example for the Transaction pattern");
    System.out.println("This code example shows how a Transaction can");
    System.out
        .println(" be applied to support change across a distributed");
    System.out.println(" system. In ths case, a distributed transaction");
    System.out.println(" is used to coordinate the change of dates in");
    System.out.println(" appointment books.");
    System.out.println("Running the RMI compiler (rmic)");
    System.out.println();
    try {
      Process p1 = Runtime.getRuntime().exec("rmic AppointmentBook");
      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();
    try {
      Process 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 three appointment books");
    System.out.println();
    AppointmentBook apptBookOne = new AppointmentBook();
    AppointmentBook apptBookTwo = new AppointmentBook();
    AppointmentBook apptBookThree = new AppointmentBook();
    System.out.println("Creating appointments");
    System.out.println();
    Appointment apptOne = new AppointmentImpl(
        "Swim relay to Kalimantan (or Java)", new ArrayList(),
        new LocationImpl("Sidney, Australia"), createDate(2001, 11, 5,
            11, 0));
    Appointment apptTwo = new AppointmentImpl(
        "Conference on World Patternization", new ArrayList(),
        new LocationImpl("London, England"), createDate(2001, 11, 5,
            14, 0));
    Appointment apptThree = new AppointmentImpl(
        "Society for the Preservation of Java - Annual Outing",
        new ArrayList(), new LocationImpl("Kyzyl, Tuva"), createDate(
            2001, 11, 5, 10, 0));
    System.out.println("Adding appointments to the appointment books");
    System.out.println();
    apptBookOne.addAppointment(apptThree);
    apptBookTwo.addAppointment(apptOne);
    apptBookOne.addAppointment(apptTwo);
    apptBookTwo.addAppointment(apptTwo);
    apptBookThree.addAppointment(apptTwo);
    System.out.println("AppointmentBook contents:");
    System.out.println();
    System.out.println(apptBookOne);
    System.out.println(apptBookTwo);
    System.out.println(apptBookThree);
    System.out.println();
    System.out.println("Rescheduling an appointment");
    System.out.println();
    System.out.println();
    boolean result = apptBookThree.changeAppointment(apptTwo, getDates(
        2001, 11, 5, 10, 3), lookUpParticipants(new String[] {
        apptBookOne.getUrl(), apptBookTwo.getUrl(),
        apptBookThree.getUrl() }), 20000L);
    System.out.println("Result of rescheduling was " + result);
    System.out.println("AppointmentBook contents:");
    System.out.println();
    System.out.println(apptBookOne);
    System.out.println(apptBookTwo);
    System.out.println(apptBookThree);
  }
  private static AppointmentTransactionParticipant[] lookUpParticipants(
      String[] remoteUrls) {
    AppointmentTransactionParticipant[] returnValues = new AppointmentTransactionParticipant[remoteUrls.length];
    for (int i = 0; i < remoteUrls.length; i++) {
      try {
        returnValues[i] = (AppointmentTransactionParticipant) Naming
            .lookup(remoteUrls[i]);
      } catch (Exception exc) {
        System.out
            .println("Error using RMI to look up a transaction participant");
      }
    }
    return returnValues;
  }
  private static Date[] getDates(int year, int month, int day, int hour,
      int increment) {
    Date[] returnDates = new Date[increment];
    for (int i = 0; i < increment; i++) {
      returnDates[i] = createDate(year, month, day, hour + i, 0);
    }
    return returnDates;
  }
  public static Date createDate(int year, int month, int day, int hour,
      int minute) {
    dateCreator.set(year, month, day, hour, minute);
    return dateCreator.getTime();
  }
}
interface Location extends Serializable {
  public String getLocation();
  public void setLocation(String newLocation);
}
class LocationImpl implements Location {
  private String location;
  public LocationImpl() {
  }
  public LocationImpl(String newLocation) {
    location = newLocation;
  }
  public String getLocation() {
    return location;
  }
  public void setLocation(String newLocation) {
    location = newLocation;
  }
  public String toString() {
    return location;
  }
}
interface Contact extends Serializable {
  public static final String SPACE = " ";
  public String getFirstName();
  public String getLastName();
  public String getTitle();
  public String getOrganization();
  public void setFirstName(String newFirstName);
  public void setLastName(String newLastName);
  public void setTitle(String newTitle);
  public void setOrganization(String newOrganization);
}
class ContactImpl implements Contact {
  private String firstName;
  private String lastName;
  private String title;
  private String organization;
  public ContactImpl() {
  }
  public ContactImpl(String newFirstName, String newLastName,
      String newTitle, String newOrganization) {
    firstName = newFirstName;
    lastName = newLastName;
    title = newTitle;
    organization = newOrganization;
  }
  public String getFirstName() {
    return firstName;
  }
  public String getLastName() {
    return lastName;
  }
  public String getTitle() {
    return title;
  }
  public String getOrganization() {
    return organization;
  }
  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 String toString() {
    return firstName + SPACE + lastName;
  }
}
interface Appointment extends Serializable {
  public static final String EOL_STRING = System
      .getProperty("line.separator");
  public Date getStartDate();
  public String getDescription();
  public ArrayList getAttendees();
  public Location getLocation();
  public void setDescription(String newDescription);
  public void setLocation(Location newLocation);
  public void setStartDate(Date newStartDate);
  public void setAttendees(ArrayList newAttendees);
  public void addAttendee(Contact attendee);
  public void removeAttendee(Contact attendee);
}
class AppointmentImpl implements Appointment {
  private Date startDate;
  private String description;
  private ArrayList attendees = new ArrayList();
  private Location location;
  public AppointmentImpl(String newDescription, ArrayList newAttendees,
      Location newLocation, Date newStartDate) {
    description = newDescription;
    attendees = newAttendees;
    location = newLocation;
    startDate = newStartDate;
  }
  public Date getStartDate() {
    return startDate;
  }
  public String getDescription() {
    return description;
  }
  public ArrayList getAttendees() {
    return attendees;
  }
  public Location getLocation() {
    return location;
  }
  public void setDescription(String newDescription) {
    description = newDescription;
  }
  public void setLocation(Location newLocation) {
    location = newLocation;
  }
  public void setStartDate(Date newStartDate) {
    startDate = newStartDate;
  }
  public void setAttendees(ArrayList newAttendees) {
    if (newAttendees != null) {
      attendees = newAttendees;
    }
  }
  public void addAttendee(Contact attendee) {
    if (!attendees.contains(attendee)) {
      attendees.add(attendee);
    }
  }
  public void removeAttendee(Contact attendee) {
    attendees.remove(attendee);
  }
  public int hashCode() {
    return description.hashCode() ^ startDate.hashCode();
  }
  public boolean equals(Object object) {
    if (!(object instanceof AppointmentImpl)) {
      return false;
    }
    if (object.hashCode() != hashCode()) {
      return false;
    }
    return true;
  }
  public String toString() {
    return "  Description: " + description + EOL_STRING + "  Start Date: "
        + startDate + EOL_STRING + "  Location: " + location
        + EOL_STRING + "  Attendees: " + attendees;
  }
}
class AppointmentBook implements AppointmentTransactionParticipant {
  private static final String TRANSACTION_SERVICE_PREFIX = "transactionParticipant";
  private static final String TRANSACTION_HOSTNAME = "localhost";
  private static int index = 1;
  private String serviceName = TRANSACTION_SERVICE_PREFIX + index++;
  private HashMap appointments = new HashMap();
  private long currentTransaction;
  private Appointment currentAppointment;
  private Date updateStartDate;
  public AppointmentBook() {
    try {
      UnicastRemoteObject.exportObject(this);
      Naming.rebind(serviceName, this);
    } catch (Exception exc) {
      System.err
          .println("Error using RMI to register the AppointmentBook "
              + exc);
    }
  }
  public String getUrl() {
    return "//" + TRANSACTION_HOSTNAME + "/" + serviceName;
  }
  public void addAppointment(Appointment appointment) {
    if (!appointments.containsValue(appointment)) {
      if (!appointments.containsKey(appointment.getStartDate())) {
        appointments.put(appointment.getStartDate(), appointment);
      }
    }
  }
  public void removeAppointment(Appointment appointment) {
    if (appointments.containsValue(appointment)) {
      appointments.remove(appointment.getStartDate());
    }
  }
  public boolean join(long transactionID) {
    if (currentTransaction != 0) {
      return false;
    } else {
      currentTransaction = transactionID;
      return true;
    }
  }
  public void commit(long transactionID) throws TransactionException {
    if (currentTransaction != transactionID) {
      throw new TransactionException("Invalid TransactionID");
    } else {
      removeAppointment(currentAppointment);
      currentAppointment.setStartDate(updateStartDate);
      appointments.put(updateStartDate, currentAppointment);
    }
  }
  public void cancel(long transactionID) {
    if (currentTransaction == transactionID) {
      currentTransaction = 0;
      appointments.remove(updateStartDate);
    }
  }
  public boolean changeDate(long transactionID, Appointment appointment,
      Date newStartDate) throws TransactionException {
    if ((appointments.containsValue(appointment))
        && (!appointments.containsKey(newStartDate))) {
      appointments.put(newStartDate, null);
      updateStartDate = newStartDate;
      currentAppointment = appointment;
      return true;
    }
    return false;
  }
  public boolean changeAppointment(Appointment appointment,
      Date[] possibleDates,
      AppointmentTransactionParticipant[] participants, long transactionID) {
    try {
      for (int i = 0; i < participants.length; i++) {
        if (!participants[i].join(transactionID)) {
          return false;
        }
      }
      for (int i = 0; i < possibleDates.length; i++) {
        if (isDateAvailable(transactionID, appointment,
            possibleDates[i], participants)) {
          try {
            commitAll(transactionID, participants);
            return true;
          } catch (TransactionException exc) {
          }
        }
      }
    } catch (RemoteException exc) {
    }
    try {
      cancelAll(transactionID, participants);
    } catch (RemoteException exc) {
    }
    return false;
  }
  private boolean isDateAvailable(long transactionID,
      Appointment appointment, Date date,
      AppointmentTransactionParticipant[] participants) {
    try {
      for (int i = 0; i < participants.length; i++) {
        try {
          if (!participants[i].changeDate(transactionID, appointment,
              date)) {
            return false;
          }
        } catch (TransactionException exc) {
          return false;
        }
      }
    } catch (RemoteException exc) {
      return false;
    }
    return true;
  }
  private void commitAll(long transactionID,
      AppointmentTransactionParticipant[] participants)
      throws TransactionException, RemoteException {
    for (int i = 0; i < participants.length; i++) {
      participants[i].rumit(transactionID);
    }
  }
  private void cancelAll(long transactionID,
      AppointmentTransactionParticipant[] participants)
      throws RemoteException {
    for (int i = 0; i < participants.length; i++) {
      participants[i].cancel(transactionID);
    }
  }
  public String toString() {
    return serviceName + " " + appointments.values().toString();
  }
}
interface AppointmentTransactionParticipant extends Remote {
  public boolean join(long transactionID) throws RemoteException;
  public void commit(long transactionID) throws TransactionException,
      RemoteException;
  public void cancel(long transactionID) throws RemoteException;
  public boolean changeDate(long transactionID, Appointment appointment,
      Date newStartDate) throws TransactionException, RemoteException;
}
class TransactionException extends Exception {
  public TransactionException(String msg) {
    super(msg);
  }
}