[java] instantieren van classes vanuit een array

[Verwijderd]

Mensen ik ben momenteel bezig met een applicatie waar een xml bestand beschrijft welke classes geladen moeten worden.

Ik denk dat ik mijn probleem het beste kan uitleggen N.A.V. een stukje code:

Java:

package siriusConfig.cardDevice.desfireCommands;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

public class listNodes {
    
    class ClassAction{
        public Node xmlNode=null;       
        public ClassAction(Node xmlNode){
            super();
            this.xmlNode=xmlNode;
        }
        public final static String xmlName=null;
    }
    
    class Class1 extends ClassAction{
        public Class1(Node xmlNode) {
            super(xmlNode);         
        }
        public final static String xmlName="class1";
    }
    
    class Class2 extends ClassAction{
        public Class2(Node xmlNode) {
            super(xmlNode);         
        }
        public final static String xmlName="aapNootMies";
    }
    
    private final static ClassAction[] classList={class1,class2};
    
    private ClassAction getXmlClass(Node xmlNode){
        for(int x=0;x<classList.length;x++){
            if(xmlNode.getNodeName().startsWith(classList[x].xmlName)){
                return new classList[x](xmlNode);
            }
        }
        return null;
    }
    
    public listNodes(File xmlFile){
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            Document xmlDoc = db.parse(xmlFile);
            Element docEle = xmlDoc.getDocumentElement();
            Node child=docEle.getFirstChild();
            while(child!=null){
                if(child.getNodeType()==Node.ELEMENT_NODE){
                    System.out.println("this is node "+child.getNodeName());
                    getXmlClass(child);//de nieuwe class wordt bijv in een collectie gezet...                   
                }               
                child=child.getNextSibling();
            }
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ParserConfigurationException e) {
            e.printStackTrace();
        }   
    }
}

Het idee is dus dat de xml file een aantal nodes gedefiniert zijn bijv <class1/><aapNootMies/><class1/>
En dat daarop deze classes geinstatiert worden in bijv een arraylist....

Momenteel geeft de functie "getXmlClass" echter de fout terug dat deze "classList[x]" niet new wil maken met de volgende error

Multiple markers at this line
- Syntax error on token "]", AssignmentOperator expected after this token
- The left-hand side of an assignment must be a variable

Weet iemand of hetgeen dat ik wil doen uberhaubt mogelijk is in java?
Zou ik dit simpel kunnen herschrijven naar een werkende situatie?

Alvast bedankt!

[Verwijderd]

Je mag new niet op die manier gebruiken, maar je kunt wel reflection gebruiken om hetzelfde te doen. In plaats van

code:

return new classList[x](xmlNode);

zeg je iets in de trant van

code:

return classList[x].getConstructor(xmlNode.getClass()).newInstance(xmlNode);

Uiteraard moet je nog de nodige error handling en eventuele caching toepassen.

[ Voor 11% gewijzigd door Verwijderd op 04-05-2011 12:02 ]

[Verwijderd]

Verwijderd schreef op woensdag 04 mei 2011 @ 12:02:
Je mag new niet op die manier gebruiken, maar je kunt wel reflection gebruiken om hetzelfde te doen. In plaats van

code:

return new classList[x](xmlNode);

zeg je iets in de trant van

code:

return classList[x].getConstructor(xmlNode.getClass()).newInstance(xmlNode);

Uiteraard moet je nog de nodige error handling en eventuele caching toepassen.

Dat was Helemaal waar ik naar op zoek was: reflection.

Ik heb uiteindelijk het zo opgelost:

Java:

ClassAction action = (ClassAction) Class.forName("app.xmlClasses."+child.getNodeName()).newInstance();

Met de nodige try / catches uiteraard.
Ik gebruik nu de naam van de classes als xml node.
Dan wordt de node aan geslingert en wordt via een functie de xml node door gestuurt.

[Kwistnix]

Wat is hier dan precies de bedoeling van, want een verzameling objecten die geïnstantieerd zijn via een default constructor lijkt mij niet erg zinvol? Bevat de XML structuur ook properties van de betreffende klassen? In dat geval lijkt een oplossing met JAXB mij veel handiger namelijk.

[Killemov]

Dit schreeuwt inderdaad JAXB. Doe het dan wel "simpel" met annotations.

Waarschuwing: Uit een test met Java 1.6.0-18 is gebleken dat JAXB een class-lekkage probleem heeft. Er worden dus classes gegenereerd bij elke marshall/unmarshall die zonder specifieke settings van de jvm/garbage collector NIET meer worden vrijgegeven. In een 24/7 omgeving is dat wat mij betreft niet acceptabel.

[matthijsln]

Killemov schreef op zaterdag 07 mei 2011 @ 01:03:
Dit schreeuwt inderdaad JAXB. Doe het dan wel "simpel" met annotations.

Waarschuwing: Uit een test met Java 1.6.0-18 is gebleken dat JAXB een class-lekkage probleem heeft. Er worden dus classes gegenereerd bij elke marshall/unmarshall die zonder specifieke settings van de jvm/garbage collector NIET meer worden vrijgegeven. In een 24/7 omgeving is dat wat mij betreft niet acceptabel.

Niet bij elke marshall/unmarshall maar bij het maken van een JAXBContext, die je dus blijkbaar per context als singleton moet gebruiken waardoor dit geen probleem is. Bedankt voor de tip, wist ik trouwens nog niet, maar geen reden om JAXB niet te gebruiken IMO.

Meer informatie

[voodooless]

Misschien een keer naar Spring (of vergelijkbaar framework) kijken. Daar zit eigenlijk alles in wat je wil en de oplossing is misschien wat eleganter.

[Killemov]

voodooless schreef op zaterdag 07 mei 2011 @ 10:47:
Misschien een keer naar Spring (of vergelijkbaar framework) kijken. Daar zit eigenlijk alles in wat je wil en de oplossing is misschien wat eleganter.

Spring? Echt? Voor dit probleem? *shocked*

[matthijsln]

Killemov schreef op maandag 09 mei 2011 @ 16:28:
[...]
Spring? Echt? Voor dit probleem? *shocked*

't Is dat jij 't zegt, maar ik vroeg me dat ook af. Het is niet dat het antwoord op alle Java problemen "Spring" is natuurlijk, wat bij sommige mensen wel zo lijkt te zijn.

[YopY]

Mwa, lijkt me sterk dat er geen 'lichtgewicht' alternatieven voor Spring zijn die iets soortgelijks doen.

[matthijsln]

YopY schreef op maandag 09 mei 2011 @ 19:34:
Mwa, lijkt me sterk dat er geen 'lichtgewicht' alternatieven voor Spring zijn die iets soortgelijks doen.

Inderdaad, dat is in dit geval dus gewoon JAXBContext.newInstance()

[tweakerbee]

YopY schreef op maandag 09 mei 2011 @ 19:34:
Mwa, lijkt me sterk dat er geen 'lichtgewicht' alternatieven voor Spring zijn die iets soortgelijks doen.

Het doel is mij niet helemaal duidelijk, maar als het om remoting gaat kun je de HttpInvoker gebruiken. Je kunt natuurlijk ook met OXM aan de gang gaan.

[voodooless]

Killemov schreef op maandag 09 mei 2011 @ 16:28:
Spring? Echt? Voor dit probleem? *shocked*

Het echte "probleem" lijkt me nog helemaal niet zo duidelijk eigenlijk. In ieder geval kan ik dat uit de TS niet echt afleiden. Er staat wat de TS wil doen, niet welk probleem hij wil oplossen.

[Killemov]

voodooless schreef op dinsdag 10 mei 2011 @ 12:50:
[...]
Het echte "probleem" lijkt me nog helemaal niet zo duidelijk eigenlijk. In ieder geval kan ik dat uit de TS niet echt afleiden. Er staat wat de TS wil doen, niet welk probleem hij wil oplossen.

XML<->Java dus. Simpel.

Je kunt er ook een cursus chinees aan wijden, maar dat lijkt me dus net zo zinvol. ( Gevalletje klok/klepel/kabouter? )

[matthijsln]

tweakerbee schreef op dinsdag 10 mei 2011 @ 11:55:
[...]
Je kunt natuurlijk ook met OXM aan de gang gaan.

Als je XML wil mappen naar Java is JAXB zoals gezegd een goede keuze. OXM is een Spring wrapper voor oa. JAXB. Als je aan de slag wilt is het direct gebruiken van JAXB toch echt simpeler.

De grap is dat in die reference link wel voordelen worden genoemd, maar geen nadelen. Zo vind ik het helemaal niet "easier to configure": ik heb een hekel aan XML configuratie. Dat ik geen JAXBContext hoef te maken vind ik vervelend, want ik wil graag de JAXB API gebruiken, dank u (zoals gezegd is dit enkel JAXBContext.newInstance()).

Daarnaast zijn problemen beter te debuggen zonder Spring-wrapper laag als mogelijke oorzaak van een probleem, is het gebruiken van voorbeelden makkelijker, is de consistente interfaces eerder het moeilijker maken om een niet-gewrapte feature te gebruiken, is het bovengenoemde JAXBContect class-leak probleem mogelijk niet of lastiger op te lossen, etc.
[/rant]