[JEE/Alg] Ontwerp datamodel voor pricing + availability

[Eelke Spaak]

Ik ben bezig met het ontwerpen en implementeren van een boekingssysteem voor de medewerkers van een reisbureau, en dat systeem moet ook gekoppeld worden aan een website, zodat klanten online kunnen boeken. Dit houdt in dat regels voor de prijzen en beschikbaarheid van verschillende reisitems (hotels, vliegtickets, huurauto's en evt. extra's) dynamisch moeten kunnen worden bepaald aan de hand van de ingevoerde gegevens van klanten (vertrekdata, passagiersleeftijden etc.). Dit heeft mij voor een lastig ontwerpprobleem gesteld. Ik werk met Hibernate, en ik heb de volgende relevante entities reeds gedefiniëerd:

TicketItem
HotelItem
RentalCarItem
ExtraItem

Een Trip bestaat uit een combinatie van deze items, plus natuurlijk klantgegevens enzo. Deze items hebben allemaal een referentie naar een StandardItem, die als het ware een template is om nieuwe reizen samen te stellen (er zit een beschrijving, plaatjes etc. aan gekoppeld). Ook heeft een StandardItem één of meerdere PricingRanges, die simpelweg een standaardprijs toekennen aan een bepaalde periode. Daarnaast kan een StandardItem één of meerdere PricingExceptions hebben.

De PricingException entity heeft de volgende relevante eigenschappen:

Java:

String className;
Map arguments;
StandardItem standardItem;

De className moet verwijzen naar een implementatie van de interface PricingExceptionProcessor:

Java:

public interface PricingExceptionProcessor
{
    /**
     * Processes the given price, and returns the new price.
     *
     * @return the new price
     * @param originalPrice the original price
     * @param arguments a map of arguments that this processor can use
     * @throws BlockBookingException in case this processor decides that the
     * booking should not be allowed, for instance on certain blackout dates.
     */
    public Money processPrice(Money originalPrice, Map arguments)
        throws BlockBookingException; // Money is een wrapper voor een decimal & een currency
    
    /**
     * Returns a textual representation of this processor, when using the given
     * arguments.
     *
     * @return the textual representation
     * @param arguments the arguments
     */
    public String toString(Map arguments);
    
    /**
     * Returns a map of possible argument keys, linked to the argument's required
     * type.
     *
     * @return the map (key ==> argument type)
     */
    public Map<String, Class> getPossibleArguments();
    
    /**
     * Returns the name of this processor, intended for graphical display.
     *
     * @return the name of this processor
     */
    public String getName();
    
    /**
     * Returns a textual description of this processor.
     *
     * @return the description
     */
    public String getDescription();
}

De methode processPrice moet dus een nieuwe prijs geven (of de boeking blokkeren) op basis van de oude prijs, maar ook op basis van de verschillende eigenschappen (vertrekdata etc.) van het item waar deze exception op wordt toegepast. Het probleem is dat de verschillende items hierboven opgesomd (TicketItem etc.) niet erven van één "TripItem" klasse o.i.d. Waarschijnlijk is dit wel nodig, realiseer ik me nu ( ), maar voordat ik grote refactorings ga doorvoeren wil ik even jullie mening hebben over dit model.

Edit: Oja, dit gaat over de inkoopprijzen van de verschillende items, maar volgens mij is dat niet relevant (verkoopprijzen gaan vergelijkbaar).

Gaat dit fijn werken, denken jullie? Of moet ik het helemaal anders aanpakken? Heeft iemand misschien ervaring met het bedenken van representaties van pricing & availability models?

[ Voor 3% gewijzigd door Eelke Spaak op 13-10-2005 12:28 ]

[Verwijderd]

Je zou het volgende boek eens moeten consulteren:
Analysis Patterns: Reusable Object Models van Martin Fowler.
Hier staan een hele hoop Object modellen uitgelegd en ook hoe je goede
objectmodellen kunt ontwerpen. Waarschijnlijk zitten er ook wel pricing en availability models in aangezien een groot deel van het boek over financiele zaken gaat.

[JKVA]

Met betrekking tot het ontwerpen van een goed systeem kan ik ook Design Patterns van Ralph Johnson aanbevelen, maar alleen als je goed vertrouwd bent met OO principes en dergelijke.

Het is namelijk vrij abstract en de patronen richten zich niet echt op een specifiek probleem, maar op vaste problemen met modelleren, gericht op schaalbaarheid, onderhoud en zo. Dus hoe je een bepaalde Exception maakt, zal je niet terugvinden

Ik heb zelf de Engelse versie en vooral de catalogus van 23 patronen (standaarden in de industrie) zorgen ervoor dat je anders denkt over modelleren.

Maar nogmaals, lees het niet als je niet vertrouwd bent met het complete OO paradigma, want dit boek gaat er vrij diep op in.

Ps. Ik heb gehoord dat de Nederlandse vertaling niet erg goed is, dus mocht je interesse hebben, ga voor de Engelse versie.

[ Voor 5% gewijzigd door JKVA op 13-10-2005 16:16 ]

[Verwijderd]

offtopic:
Ja dat is de eerste fout van dat hele boek. De design patterns beperken zich niet tot enkel OO talen

[Eelke Spaak]

Alvast bedankt voor de boekentips!

Ik ben (vind ik zelf ) wel aardig bekend met object-georiënteerd programmeren, dus ik zal er allebei eens naar kijken.

[Eelke Spaak]

Klein schopje: zijn er werkelijk geen mensen die ervaring hebben met dit soort models? Of die wellicht tips hebben met betrekking tot models die hier op lijken?

[Alarmnummer]

Je zou het volgende boek eens moeten consulteren:
Analysis Patterns: Reusable Object Models van Martin Fowler.

In Analysis patterns staat idd veel informatie over dit soort problematiek alhoewel ik niet weet of jouw probleem ook besproken wordt.

En verder zou je ook kunnen kijken naar Domain-Driven Design: Tackling Complexity in the Heart of Software
Misschien dat hier ook iets nuttigs in staat (alhoewel dat meer gaat over het opzetten van domain object modellen in het algemeen)

[ Voor 42% gewijzigd door Alarmnummer op 15-10-2005 07:38 ]