[JAVA] Vergeet na opslaan in file een onderliggende vector

[semicon]

Hallo,

Voor een project op school zitten we nog met 1 lastig probleem. Het is een banksysteem en de bank wordt in een file opgeslagen. Bij het starten weeer geopend en als nieuwe bank gemaakt incl. zijn rekeningen. (rekeningen is als Vector IN Bank (allerekeningen)) MAar er is ook Transacties, en die worden opgeslagen IN Rekening ook als vector, alleen die vergeet het systeem steeds, saldo, de rekening dus, wordt wel gewoon opgeslagen!

Is dit soms een limitatie? Kan een vector in een vector niet meer uitgelezen/opgeslagen worden ofzo?

[Gonadan]

Krijg je foutmeldingen bij het opslaan of lezen?

Wat voor streams gebruik je?
Zijn je objecten allemaal serializable?
Geef je ze hetzelfde serialVersionUID?

Iets meer informatie zou handig zijn

[ Voor 3% gewijzigd door Gonadan op 12-04-2006 11:23 ]

[momania]

Als je eens wat voorbeel code geeft, denkt het wat makkelijker mee

Is de class Transactie iig wel Serializable ?

[semicon]

ja wel serializable ik post wel ff wa code, ik krijg geen foutmeldingen, anders kom ik er meestal wel uit ofzo, daarom is het zo lastig.

Het openen van de file

code:

public Bank openDeBank()
    {
        Bank b = new Bank("De HogeschoolBank");

        Vector v = null;
        File f = new File(fileName);
        if (f.exists() && f.isFile())
            v = DataBase.haalOpUitFile(fileName);

        if ( v != null )
        {
            b.setRekeningen(v); // zet die vector van alle rekeningen in de Bank
        }

        return b;
    }

en deze transactie "vergeet" het systeem dus..

code:

import java.util.*;

class Transactie implements java.io.Serializable
{
    private Date transDatum;
    private double bedrag;
    private TransactieType type;
    private Rekening tegenRekening = null;

    /**************************************************************************/
    public Transactie(TransactieType t, double b, Date d)
    {
        this.type = t;
        this.bedrag = b;
        this.transDatum = d;
    }

    public Transactie(TransactieType t, double b, Date d, Rekening tR)
    {
        this.type = t;
        this.bedrag = b;
        this.transDatum = d;
        this.tegenRekening = tR;
    }

    /* *************** Getters *************** */

    public Date getDatum()
    {
        return transDatum;
    }

    public double getBedrag()
    {
        return bedrag;
    }

    public TransactieType getType()
    {
        return type;
    }

    public Rekening getTegenRekening()
    {
        return tegenRekening;
    }

    /* *************** Setters *************** */
}

class TransactieType implements java.io.Serializable
{
    public final static TransactieType OPNAME = new TransactieType("Opname");
    public final static TransactieType STORTING = new TransactieType("Storting");
    public final static TransactieType AFBOEKING = new TransactieType("Afboeking");
    public final static TransactieType BIJBOEKING = new TransactieType("Bijboeking");

    private String typeName;

    private TransactieType(String typeName)
    {
        this.typeName = typeName;
    }

    public String toString()
    {
        return typeName;
    }
}

serialVersionUID?

serialVersionUID??

[ Voor 157% gewijzigd door semicon op 12-04-2006 11:27 ]

[Koppensneller]

semicon schreef op woensdag 12 april 2006 @ 11:24:
ja wel serializable ik post wel ff wa code, ik krijg geen foutmeldingen, anders kom ik er meestal wel uit ofzo, daarom is het zo lastig.

Het openen van de file

code:

code

en deze transactie "vergeet" het systeem dus..

code:

code

[...]


serialVersionUID??

Ja, http://www.google.nl/sear...rg.mozilla:en-US:official

[Gonadan]

Die ja


Maar dit is alleen de wrapper class en de main. Maar het daadwerkelijke opslaan en lezen heb je niet gepost

[semicon]

Duidelijk ... Mooie onderbouwing ook nou niet eigenlijk maar goe.

voor de gene die misschien wel wouden helpen met goede ingevingen.

code:

    try
        {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));
            out.writeObject(v);
            out.close();

            System.exit(1);
        }
        catch (IOException ie)
        {
            ie.printStackTrace();
            System.exit(1);
        }

[ Voor 71% gewijzigd door semicon op 12-04-2006 11:38 ]

[Gert]

Alles moet serializable zijn, dus de klasse en de attributen van die klasse. Ik neem aan dat je dus Double i.p.v. double moet gebruiken.

[Gonadan]

Gert schreef op woensdag 12 april 2006 @ 11:39:
Alles moet serializable zijn, dus de klasse en de attributen van die klasse. Ik neem aan dat je dus Double i.p.v. double moet gebruiken.

Dat is onzin.
Primitives kan je gewoon opslaan.

@TS:
aangezien je wel wàt kan inlezen zal je schrijven wel goed gaan.

Kan je nog de code posten die je gebruikt om te lezen?

semicon schreef op woensdag 12 april 2006 @ 11:37:
Duidelijk ... Mooie onderbouwing ook nou niet eigenlijk maar goe.

Als je het over die serialVersionUID hebt: elke keer als je compiled krijgen je klassen zo'n ID.
Dus als je iets opgeslagen hebt. Je hercompiled je objecten. En dan wil je het weer lezen.
Dan is er dus een andere ID en is het volgens java niet hetzelfde type object.
Met serialVersionUID kan je die ID vastpinnen zodat het altijd goed gaat.
Dit had je natuurlijk ook in die link kunnen lezen

semicon schreef op woensdag 12 april 2006 @ 11:37:
voor de gene die misschien wel wouden helpen met goede ingevingen.

Ik neem aan dat je weet hoe GoT werkt? Je wordt hier op weg geholpen. De problemen worden niet voor je opgelost.
Als jij een beetje code dumpt en vraagt of wij dat oplossen dan is dat niet helemaal de bedoeling.
Daarom vragen wij jou om code, en geven je links en hint naar de mogelijk oplossing.
Daar leer je meer van.

[ Voor 67% gewijzigd door Gonadan op 12-04-2006 11:56 ]

[semicon]

Eerst haal ik op uit die file dus, zoals die code hierboven was, en daarna:

Dit is in de Main:

code:

        OpenenController oc = new OpenenController(fileName);
        Bank b = oc.openDeBank();

Er is dan een nieuwe Bank met die gegevens uit mn file bij het starten van me applicatie.

Via een referentie in MainFrame die ik dan start: Bank deBank;
Werk ik alleen nog maar met deBank van MainFrame en hier voeg ik rekeningen aan toe.


Zo wordt bijv. een transactie toegevoegd!

code:

// IN REKENING CLASS

public void stort(Double bedrag)
    {
        if (bedrag > 0)
        {
            saldo = saldo + bedrag;
            Transactie t = new Transactie(TransactieType.STORTING, bedrag, new Date());
            transacties.add(t);
        }
    }

Maar deze onthoudt ie dus NIET terwijl de rekening zelf wel opgeslagen wordt. en die transacties.add(t); is dus een Vector ook in Rekening.

[ Voor 33% gewijzigd door semicon op 12-04-2006 11:58 ]

[Michali]

Als je je rekeningen opslaat, en die bevatten alle transacties, dan zou dat gewoon moeten werken. Is het trouwens niet een beter idee om je hele Bank object op te slaan, welke alle data bevat? Dan hoef je ook niet met die vectors te gaan kloten.

[Gonadan]

semicon schreef op woensdag 12 april 2006 @ 11:56:
Eerst haal ik op uit die file dus, zoals die code hierboven was, en daarna:

Dit is in de Main:

code:

        OpenenController oc = new OpenenController(fileName);
        Bank b = oc.openDeBank();

Er is dan een nieuwe Bank met die gegevens uit mn file bij het starten van me applicatie.

Via een referentie in MainFrame die ik dan start: Bank deBank;
Werk ik alleen nog maar met deBank van MainFrame en hier voeg ik rekeningen aan toe.


Zo wordt bijv. een transactie toegevoegd!

code:

// IN REKENING CLASS

public void stort(Double bedrag)
    {
        if (bedrag > 0)
        {
            saldo = saldo + bedrag;
            Transactie t = new Transactie(TransactieType.STORTING, bedrag, new Date());
            transacties.add(t);
        }
    }

Maar deze onthoudt ie dus NIET terwijl de rekening zelf wel opgeslagen wordt. en die transacties.add(t); is dus een Vector ook in Rekening.

Maar dit is nog steeds niet de code die het bestand leest.
Dat gebeurd in de methode 'haalOpUitFile()' denk ik

Michali schreef op woensdag 12 april 2006 @ 11:56:
Als je je rekeningen opslaat, en die bevatten alle transacties, dan zou dat gewoon moeten werken. Is het trouwens niet een beter idee om je hele Bank object op te slaan, welke alle data bevat? Dan hoef je ook niet met die vectors te gaan kloten.

Dat zou inderdaad veel makkelijker zijn.

[semicon]

Dat zou inderdaad veel makkelijker zijn.

Dit is nu gefixed, hij slaat bank op, maar weinig verschil,OF de rekeningen uti de bank, of de bank. maarja, np verder.

Hier de Database.haalop...

code:

    public static Bank haalOpUitFile(String fileName)
    {
        Bank v = null;
        try
        {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName));
            v = (Bank)in.readObject();
            in.close();
        }
        catch (IOException ie)
        {
            ie.printStackTrace();
            System.exit(1);
        }
        catch (ClassNotFoundException ce)
        {
            ce.printStackTrace();
            System.exit(2);
        }
        return v;
    }

[Gonadan]

Dit is wel vreemd trouwens:

Java:

    try
        {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));
            out.writeObject(v);
            out.close();

            System.exit(1);
        }

Waarom daar die exit? En waarom 1?

Weet je zeker dat je die transacties er wel in hebt zitten voordat je het opslaat?
Kan je dat met wat System.out.print's checken?

[ Voor 3% gewijzigd door Gonadan op 12-04-2006 12:10 ]

[Michali]

En, werkt het nu dus wel?

[semicon]

Michali schreef op woensdag 12 april 2006 @ 12:10:
En, werkt het nu dus wel?

Nee, geen verschil dus, anders opslaan/ophalen, 3 regels korter misschien.


@Gonadan : als je het programma sluit, druk je op sluiten en slaat ie je gegevens op, ik heb een overzicht venster waar ik alle transacties nog zie voordat ik erop druk, dus die transacties zitten erin. Als ik dan opnieuw open, zijn alle rekeningen opgeslagen, incl hun saldo. MAAR hun transacties zijn kwijt! het overzicht is leeg, terwijl bijgeschreven geld enzo wel opgeslagen is.

[ Voor 28% gewijzigd door semicon op 12-04-2006 12:12 ]

[Gonadan]

semicon schreef op woensdag 12 april 2006 @ 12:11:
[...]

Nee, geen verschil dus, anders opslaan/ophalen, 3 regels korter misschien.


@Gonadan : als je het programma sluit, druk je op sluiten en slaat ie je gegevens op, ik heb een overzicht venster waar ik alle transacties nog zie voordat ik erop druk, dus die transacties zitten erin. Als ik dan opnieuw open, zijn alle rekeningen opgeslagen, incl hun saldo. MAAR hun transacties zijn kwijt! het overzicht is leeg, terwijl bijgeschreven geld enzo wel opgeslagen is.

Weet je ook zeker je hetzelfde object opslaat als het object waar je die transacties in het overzicht uit haalt?

En voor een normale manier van afsluiten gebruik je System.exit(0);

[Michali]

Laat je rekening class en je bank class eens zien dan. (alleen relevante code)

[semicon]

Code voor storten?

code:

// In rekening class

    public void stort(Double bedrag)
    {
        if (bedrag > 0)
        {
            saldo = saldo + bedrag;
            Transactie t = new Transactie(TransactieType.STORTING, bedrag, new Date());
            transacties.add(t);
        }
    }

[ Voor 6% gewijzigd door semicon op 12-04-2006 13:33 ]

[Michali]

Daar heb ik niet veel aan nee. Je zult echt wat meer moeten debuggen of wat meer code moeten geven. Anders blijft het gissen en kan ik je moeilijk helpen.

[jAnO!]

spuit 11:

vector is zooooooooo 1999

[Michali]

jAnO! schreef op woensdag 12 april 2006 @ 13:58:
spuit 11:

vector is zooooooooo 1999

Helaas zijn wij verplicht dat te gebruiken op school, niet dat ik me daar aan houd

[Janoz]

Waarom zou de code voor het storten relevant zijn??? Er wordt om relevante code gevraagd. Ik heb je nog nergens code zien posten verantwoordelijk voor het wegschrijven van de transacties. Zolang je dat stuk code niet post is het nogal wiedes dat je niet zo best geholpen kunt worden. Er is dus ook geen enkele reden om degenen die je daadwerkelijk wel proberen te helpen zo af te bekken.

Ik raad je aan om de javadoc eens open te trekken en eens even gaan lezen bij objectwriter en serializable.

[semicon]

Janoz schreef op woensdag 12 april 2006 @ 14:01:
Waarom zou de code voor het storten relevant zijn??? Er wordt om relevante code gevraagd. Ik heb je nog nergens code zien posten verantwoordelijk voor het wegschrijven van de transacties. Zolang je dat stuk code niet post is het nogal wiedes dat je niet zo best geholpen kunt worden. Er is dus ook geen enkele reden om degenen die je daadwerkelijk wel proberen te helpen zo af te bekken.

Ik raad je aan om de javadoc eens open te trekken en eens even gaan lezen bij objectwriter en serializable.

Ik zal het nog maar eens zeggen dan, de transacties zitten in een vector IN rekening (dus in rekening class zit ergens private Vector alleTransacties;)

In Bank zitten alleRekeningen ook als Vector! Die worden overigens WEL opgeslagen als ik alleen Bank opsla! (dus er is ook geen relevante code voor het wegschrijven van een transactie behalve wat ik postte! Op die manier voeg ik transacties toen in de vector in rekening. En rekeningen worden in een vector in een bank gestopt. Het opslaan slaat alleen DeBank op!

Nou heb ik, na veel testen, ontdekt dat de transacties WEL opgeslagen worden, alleen java heeft een soort probleem dat hij de opgeslagen TransactieTypes ( TransactieType.OPNAME, BIJBOEKING, AFBOEKING, enz ) niet meer herkent! Als je een simpele if doet als zo:

Java:

TransactieType test = Transactie.getType(); //die levert zijn transactie type op en het gaat om een type!!
if (test == TransactieType.OPNAME)
{
    // komt ie toch hier nooit langs...
}
if (test.equals(TransactieType.OPNAME))
{
   // ook niet
}

En ja heb het ook met een simpele typecast geprobeerd, dit werkt ook niet.

Dus ik denk dat het probleem dus anders is als wij hier voorheen dachten, maar dat neemt nog niet weg dat het zo raar is dat rekeningen gewoon goed gaan en transacties (en met name hun Type!) niet. Ik zit morgen weer op school en zal nog wel wat dingen proberen anders lukt het gewoon niet

[momania]

semicon schreef op woensdag 12 april 2006 @ 20:08:
[...]
Als je een simpele if doet als zo:

Java:

TransactieType test = Transactie.getType(); //die levert zijn transactie type op en het gaat om een type!!
if (test == TransactieType.OPNAME)
{
    // komt ie toch hier nooit langs...
}
if (test.equals(TransactieType.OPNAME))
{
   // ook niet
}

En ja heb het ook met een simpele typecast geprobeerd, dit werkt ook niet.

En de waarde van transactie.getType() ? Als je die nou eens ergens logt oid. Dan kan je zien wat het is.

[Michali]

Hij heeft idd problemen met het serializen van zo'n geëmuleerde enumeratie. Na het serializen is de instantie niet meer die in TransactieType zelf zit. Hij maakt gewoon een nieuwe aan. Je moet zelf even een equals method implementeren, en puur met equals vergelijken, dan los je het probleem wel op.

[ Voor 24% gewijzigd door Michali op 12-04-2006 20:18 ]

[Janoz]

semicon schreef op woensdag 12 april 2006 @ 20:08:
Nou heb ik, na veel testen, ontdekt dat de transacties WEL opgeslagen worden, alleen java heeft een soort probleem dat hij de opgeslagen TransactieTypes ( TransactieType.OPNAME, BIJBOEKING, AFBOEKING, enz ) niet meer herkent! Als je een simpele if doet als zo:

Java:

TransactieType test = Transactie.getType(); //die levert zijn transactie type op en het gaat om een type!!
if (test == TransactieType.OPNAME)
{
    // komt ie toch hier nooit langs...
}
if (test.equals(TransactieType.OPNAME))
{
   // ook niet
}

En ja heb het ook met een simpele typecast geprobeerd, dit werkt ook niet.

Dus ik denk dat het probleem dus anders is als wij hier voorheen dachten, maar dat neemt nog niet weg dat het zo raar is dat rekeningen gewoon goed gaan en transacties (en met name hun Type!) niet. Ik zit morgen weer op school en zal nog wel wat dingen proberen anders lukt het gewoon niet

Dat is helemaal niet raar. De bug zit echt in je programma. De transactie types die bij de transacties opgeslagen zijn hebben wel hetzelfde type naam, maar zijn niet hetzelfde object. Omdat je zelf niet de equals overschreven hebt zal een equals test daarom false opleveren.

Tijdens het saven worden al je transacties keurig weggeschreven. Dit bleek dus geen probleem te zijn. Tijdens het inladen worden de inputstream uitgelezen en omgezet naar nieuwe objecten. Aangekomen bij een transactie blijkt dat daar een object 'transactietype' bij hoort. Er wordt een nieuw object geinstantieerd en aan de property type wordt de juiste waarde toegekend. Dit object is dus een nieuw object en niet 1 van de static gedefinieerde objecten.

Een mogelijke oplossing is om de equals methode te overerven en hierin implementeren dat typeName met elkaar wordt vergeleken.

edit: wat Michali zegt dus

[Robtimus]

Vergeet niet ook hashCode() te overriden.

Dus bv

Java:

public boolean equals(Object o) {
    if (o == null || o.getClass() == this.getClass()) {
        return false;
    }
    TransactieType t = (TransactieType)o;
    return this.typeName.equals(t.typeName);
}

public int hashCode() {
    return typeName.hashCode();
}

Als deze twee niet met elkaar in overeenstemming zijn (tip: check de JavaDocs voor Object, voornml equals en hashCode) dan werkt het nooit meer in oa hash tables.

Classes met elkaar vergelijken dmv == werkt wel altijd omdat er in de VM maar 1 instantie is voor elke class.