Lab 2 | Middleware Platforms CORBA Banking System |
|
Ablieferungstermin und erreichbare Punktzahl für diese Aufgabe, sowie Voraussetzungen für die Prüfungszulassung entnehmen Sie bitte http://sar.informatik.hu-berlin.de.
In dieser Aufgabe soll ein einfaches Bank-Szenario implementiert werden. Ausgangspunkt dafür sind Händler im Internet, bei denen man gegen Übergabe eines Schecks einkaufen kann.
Ein Scheck erhält man, indem man bei einer Bank ein Konto führt, für das der Scheck ausgestellt wird. Die Händler im Internet besitzen entsprechend ebenso solche Konten bei ihren Banken, auf die sie empfangene Schecks einreichen. Eine Bank muss sich bei einer Zentralbank registrieren lassen, um eine Zulassung als Geldinstitut zu bekommen. Nach welchen Kriterien diese Zulassung erfolgt, sie hier dahingestellt.
Modellieren Sie Bank, Zentralbank, Konto und Scheck als CORBA Objekte und entwerfen Sie geeignete Interfaces. Beachten Sie:
- Es gibt selbstverständlich mehrere Banken in diesem Szenario, allerdings nur eine Zentralbank. Alle diese Banken sind unabhängig voneinander, haben also keinerlei Zugriff auf Interna der anderen Banken.
- Man kann bei einer Bank ein oder mehrere Konten eröffnen. Beim Eröffnen eines Kontos kann gleichzeitig ein fester Betrag (bar) eingezahlt werden, der dem Konto sofort gutgeschrieben wird. Eröffnung und initiale Einzahlung sind als ein einziger Vorgang aufzufassen.
- Kein Unbefugter darf Zugang zu einem fremden Konto erlangen.
- Die einzige Möglichkeit, Geld auf ein Konto einzuzahlen, besteht im Einreichen eines Schecks. Insofern ist die Summe aller Kontostände in unserer Welt für eine feste Anzahl Konten konstant.
- Ein Scheck ist immer auf einen bestimmten Betrag ausgestellt, den man abfragen kann, der sich aber nicht ändern lässt. Schecks lassen sich zerreißen.
- Wenn ein Scheck eingereicht wird, wird der Kontostand des eigenen Kontos erhöht, der des ausstellenden Kontos entsprechend verringert (nicht bereits beim Ausstellen des Schecks!)
- Es könnte passieren, dass der Scheck nicht gedeckt ist (etwa wenn das Konto im Minus ist). In diesem Fall wird die Einlösung verweigert.
- Schecks dürfen sich nicht fälschen lassen. Man muss testen können, ob ein Scheck echt ist, d.h. von einer Bank ausgestellt wurde, die bei der Zentralbank registriert ist.
- Wie wird Geld von einer Bank zur anderen gebucht?
- Sie können voraussetzen, dass Objektreferenzen sicher sind, d.h. nicht erraten oder gefälscht werden können.
Implementieren Sie das von Ihnen entworfene System mit Java unter Verwendung des integrierten Java ORB.
Da die Schnittstellen der CORBA-Objekte von Ihnen zu entwickeln sind, können diese nicht in den Unit-Tests verwendet werden. Um dennoch eine Schnittstelle für den Test bereitzustellen wird das nachfolgend aufgeführte Interface BankingFacade eingeführt. Implementieren sie dieses Interface in einer Klasse BankingFacadeImpl. Diese Klasse soll die Methoden des Interfaces entsprechend der angegebenen Kommentare implementieren. Dabei wird die Anwendung nicht in Client und Server unterteilt. Stattdessen sollen die betroffenen CORBA Objekte innerhalb des gleichen Prozesses erzeugt werden. Ausnahme- und Fehlersituationen sollen, soweit nicht anders angegeben, eine BankingException auslösen.
package banking;
public class BankingException extends Exception {}
public interface BankingFacade {
/** Creates a new, not registerd bank.
* @param name Name of the bank to create.
* @return The newly created bank.
*/
Object createBank( String name ) throws BankingException;
/** Registers a bank at the central bank.
* @param bank The bank to register.
*/
void registerAtCentralBank( Object bank ) throws BankingException;
/** Retrieves a bank by name.
* @param name The name of the bank to retrieve.
* @return The bank, if exists, Otherwise null.
*/
Object getBank( String name ) throws BankingException;
/** Get a check with a certain amount.
* @param account The account from which the money will be transfered.
* @param amount The amount of money to be transfered.
* @return The check as Object.
*/
Object getCheck( Object account, double amount ) throws BankingException;
/** Deposits a check.
* @param check The check to deposit as object.
* @param account The account to transfer the money to.
*/
void depositCheck( Object check, Object account ) throws BankingException;
/** Retrieve the amount of money associated with the check.
* @param check The check object to query.
* @return The associated amount as double.
*/
double getCheckAmount( Object check ) throws BankingException;
/** Tears the check so that it could not used any more.
* @param check The check to tear.
*/
void tearCheck( Object check ) throws BankingException;
/** Checks if the check comes from a registered bank.
* @param check The check to check.
* @return true, if the bank is registerd, false otherwise.
*/
boolean isCheckAuthentic( Object check ) throws BankingException;
/** Creates a new bank acount.
* @param bank The bank which should keep the account.
* @param owner Name of the account owner.
* @param inpayment Initial inpayment done on opening.
* @return The newly created account as Object.
*/
Object createAccount( Object bank, String owner, double inpayment ) throws BankingException;
/** Query the balance of an account.
* @param account The account to query.
* @return The current account balance.
*/
double getBalance( Object account ) throws BankingException;
}
Fragestellungen
- Was geschieht beim Einlösen eines Schecks?
- Beurteilen Sie die Robustheit des Systems. Welche Probleme könnten auftreten?
Abgabe und Bewertung
Begründen Sie die von Ihnen getroffenen Design-Entscheidungen und beschreiben Sie aufgetretene Besonderheiten und Probleme. Benutzen Sie dafür eine HTML Datei mit dem Namen index.html. Stellen Sie die Struktur und Beziehungen der entworfenen Interfaces in Form eines geeigneten UML Diagramms grafisch dar und binden Sie es mit in das HTML Dokument ein.
Abzugeben sind weiterhin die Quelltexte der Lösung und ein Ant-Script mit dem Namen build.xml, das die Quellen mit den gängigen Werkzeugen automatisiert übersetzt (Bitte die Targets compile, test und clean definieren). Bitte reichen Sie die geforderten Dateien in ein ZIP Archiv gepackt ein.
Für Test und Bewertung kommt die Unit-Test-Bibliothek jUnit (www.junit.org) zum Einsatz. Die geforderte Funktionalität wird anhand von 10 Unit-Tests überprüft, von denen Ihnen vorab 5 zur Verfügung stehen.
package banking.test;
import banking.*;
import junit.framework.TestCase;
public class BankingTest extends TestCase {
BankingFacade _banking = null;
public static void main(String[] args) {
junit.textui.TestRunner.run(BankingTest.class);
}
public BankingTest(String name) {
super(name);
}
protected void setUp() throws Exception {
super.setUp();
_banking = new BankingFacadeImpl();
}
protected void tearDown() throws Exception {
super.tearDown();
_banking = null;
}
public void test1() throws Exception {
String name = "Bank of America";
Object bank = _banking.createBank(name);
assertNotNull(bank);
_banking.registerAtCentralBank(bank);
bank = _banking.getBank( name );
assertNotNull(bank);
}
public void test2() throws Exception {
double amount = 2042.35;
Object bank = _banking.createBank("Bank of America");
Object account = _banking.createAccount(bank, "John Doe", amount );
assertNotNull(account);
assertEquals( amount, _banking.getBalance(account), .005 );
double checkamount = 20.0;
Object check = _banking.getCheck( account, checkamount );
assertNotNull(check);
assertEquals( checkamount, _banking.getCheckAmount(check), .005 );
}
public void test3() throws Exception {
double amount = 2042.35;
double checkamount = 20.0;
Object bank1 = _banking.createBank("Bank of America");
Object bank2 = _banking.createBank("Royal Bank of Scotland");
_banking.registerAtCentralBank(bank1);
_banking.registerAtCentralBank(bank2);
Object accDoe = _banking.createAccount(bank1, "John Doe", amount );
Object accMjr = _banking.createAccount(bank2, "Mary Major", amount );
Object check = _banking.getCheck( accDoe, checkamount );
_banking.depositCheck( check, accMjr );
assertEquals( amount-checkamount, _banking.getBalance(accDoe), .005 );
assertEquals( amount+checkamount, _banking.getBalance(accMjr), .005 );
}
public void test4() throws Exception {
double amount = 2042.35;
double checkamount = 20.0;
Object bank = _banking.createBank("Bank of America");
Object account = _banking.createAccount(bank, "John Doe", amount );
Object check = _banking.getCheck( account, checkamount );
assertFalse( _banking.isCheckAuthentic(check) );
_banking.registerAtCentralBank(bank);
check = _banking.getCheck( account, checkamount );
assertTrue( _banking.isCheckAuthentic(check) );
}
public void test5() throws Exception {
double amount = 2042.35;
double checkamount = amount + .01;
Object bank = _banking.createBank("Bank of America");
_banking.registerAtCentralBank(bank);
Object accDoe = _banking.createAccount(bank, "John Doe", amount );
Object accMjr = _banking.createAccount(bank, "Mary Major", amount );
Object check = _banking.getCheck( accDoe, checkamount );
try {
_banking.depositCheck( check, accMjr );
fail("Deposit of an uncovered check succeeded.");
}
catch( BankingException e ) {
// Pass...
}
assertEquals( amount, _banking.getBalance(accDoe), .005 );
assertEquals( amount, _banking.getBalance(accMjr), .005 );
}
}
Hinweise
- Behandeln Sie auch Fehler- und Ausnahmesituationen entsprechend.
- Bedenke Sie, dass durch eine nebenläufige Ausführung Fehler entstehen können.
- Das Eclipse-Plugin ORB Studio 7 (http://homepage2.nifty.com/interpress/ORBstudio/) kann die Implementierung erleichtern.