21.2 A Bank Server

Example 21-1 defined a RemoteBank interface and a bank client program. Example 21-2 is a RemoteBankServer class that implements the RemoteBank interface and acts as a server for the Bank.Client program. This class includes a main( ) method so it can be run as a standalone program. This method creates a RemoteBankServer object and registers it with Naming.rebind( ), so that clients can look it up. It reads the system property bankname to determine what name to use to register the bank, but uses the name FirstRemote by default. (This is the same name that the Bank.Client uses by default as well.)

RemoteBankServer implements the RemoteBank interface, so it provides implementations for all remote methods defined by that interface. It also defines some utility methods that are not remote methods, but that are used by the remote methods. Note that RemoteBankServer includes an inner Account class that stores all the information about a single bank account. It maintains a hashtable that maps from account names to Account objects. The various remote methods look up the named account, verify the password, and operate on the account in some way. Any RMI remote object must be able to handle multiple, concurrent method invocations because multiple clients can be using the object at the same time. RemoteBankServer uses synchronized methods and synchronized statements to prevent two clients from opening, closing, or modifying the same account at the same time.

Before you can run this RemoteBankServer program, you must compile it, generate stub and skeleton classes, and start the rmiregistry service (if it is not already running). You might do all this with commands like the following (on a Unix system). Note the -d argument to rmic : it tells the RMI compiler where to put the stub and skeleton classes. Assuming the RemoteBankServer.class file is in the current directory, the usage shown here puts the generated classes in the same directory.

% javac RemoteBankServer.java % rmic -d ../../../../ je3.rmi.RemoteBankServer % rmiregistry & % java je3.rmi.RemoteBankServer FirstRemote is open and ready for customers.

Note that Example 21-2 contains a fatal flaw: if the bank server crashes, all bank account data is lost, which is likely to result in angry customers! Example 21-3 is another implementation of the RemoteBank interface; this implementation uses a database to store account data in a more persistent way.

Example 21-2. RemoteBankServer.java

package je3.rmi; import java.rmi.*; import java.rmi.server.*; import java.util.*; import je3.rmi.Bank.*; /**  * This class implements the remote methods defined by the RemoteBank  * interface.  It has a serious shortcoming, though: all account data is  * lost when the server goes down.  **/ public class RemoteBankServer extends UnicastRemoteObject implements RemoteBank {     /**       * This nested class stores data for a single account with the bank       **/     class Account {         String password;                      // account password         int balance;                          // account balance         List transactions = new ArrayList( );  // account transaction history         Account(String password) {             this.password = password;             transactions.add("Account opened at " + new Date( ));         }     }          /**       * This hashtable stores all open accounts and maps from account name      * to Account object.  Methods that use this object will be synchronized      * to prevent concurrent access by more than one thread.      **/     Map accounts = new HashMap( );          /**      * This constructor doesn't do anything, but because the superclass       * constructor throws an exception, the exception must be declared here      **/     public RemoteBankServer( ) throws RemoteException { super( ); }          /**       * Open a bank account with the specified name and password       * This method is synchronized to make it thread safe, since it       * manipulates the accounts hashtable.      **/     public synchronized void openAccount(String name, String password)         throws RemoteException, BankingException     {         // Check if there is already an account under that name         if (accounts.get(name) != null)              throw new BankingException("Account already exists.");         // Otherwise, it doesn't exist, so create it.         Account acct = new Account(password);         // And register it         accounts.put(name, acct);     }          /**      * This internal method is not a remote method.  Given a name and password      * it checks to see if an account with that name and password exists.  If      * so, it returns the Account object.  Otherwise, it throws an exception.      * This method is synchronized because it uses the accounts hashtable.      **/     synchronized Account verify(String name, String password)         throws BankingException     {         Account acct = (Account)accounts.get(name);         if (acct == null) throw new BankingException("No such account");         if (!password.equals(acct.password))             throw new BankingException("Invalid password");         return acct;     }          /**       * Close the named account.  This method is synchronized to make it       * thread safe, since it manipulates the accounts hashtable.      **/     public synchronized FunnyMoney closeAccount(String name, String password)         throws RemoteException, BankingException     {         Account acct;         acct = verify(name, password);         accounts.remove(name);         // Before changing the balance or transactions of any account, we first         // have to obtain a lock on that account to be thread safe.         synchronized (acct) {             int balance = acct.balance;             acct.balance = 0;             return new FunnyMoney(balance);         }     }          /** Deposit the specified FunnyMoney to the named account */     public void deposit(String name, String password, FunnyMoney money)          throws RemoteException, BankingException     {         Account acct = verify(name, password);         synchronized(acct) {              acct.balance += money.amount;              acct.transactions.add("Deposited " + money.amount +                                    " on " + new Date( ));         }     }          /** Withdraw the specified amount from the named account */     public FunnyMoney withdraw(String name, String password, int amount)         throws RemoteException, BankingException     {         Account acct = verify(name, password);         synchronized(acct) {             if (acct.balance < amount)                  throw new BankingException("Insufficient Funds");             acct.balance -= amount;             acct.transactions.add("Withdrew " + amount + " on "+new Date( ));             return new FunnyMoney(amount);         }     }          /** Return the current balance in the named account */     public int getBalance(String name, String password)         throws RemoteException, BankingException     {         Account acct = verify(name, password);         synchronized(acct) { return acct.balance; }     }          /**       * Return a Vector of strings containing the transaction history      * for the named account      **/     public List getTransactionHistory(String name, String password)         throws RemoteException, BankingException     {         Account acct = verify(name, password);         synchronized(acct) { return acct.transactions; }     }          /**      * The main program that runs this RemoteBankServer.      * Create a RemoteBankServer object and give it a name in the registry.      * Read a system property to determine the name, but use "FirstRemote"      * as the default name.  This is all that is necessary to set up the      * service.  RMI takes care of the rest.      **/     public static void main(String[  ] args) {         try {             // Create a bank server object             RemoteBankServer bank = new RemoteBankServer( );             // Figure out what to name it             String name = System.getProperty("bankname", "FirstRemote");             // Name it that             Naming.rebind(name, bank);             // Tell the world we're up and running             System.out.println(name + " is open and ready for customers.");         }         catch (Exception e) {             System.err.println(e);             System.err.println("Usage: java [-Dbankname=<name>] " +                             "je3.rmi.RemoteBankServer");             System.exit(1); // Force exit because there may be RMI threads         }     } }