Per aiutare con un'applicazione che manipola e lavora da una struttura XML per produrre altre informazioni, ho creato una struttura di classe che segue da vicino la struttura XML.
Quindi, l'XML è:
<document>
<group attr1="thing">
<title>Some group of things</title>
<information>
<content />
</information>
<detail attr2="flame">
<title>Some detail</title>
<content />
</detail>
<subgroup attr1="invisible">
<title>A subgroup</title>
<information>
<content />
</information>
<detail attr2="mister">
<content />
</detail>
</subgroup>
...
</group>
<group>
<title>...</title>
<information>
<content />
</information>
<reference ref="elsewhere" />
...
</group>
...
</document>
L'elemento <reference> è un caso speciale che richiama da un <detail> corrispondente in un gruppo / sottogruppo differente.
Ho identificato praticamente un'interfaccia standard per i nodi:
interface iNode {
getTitle();
getAttr();
getInformation();
getNodes();
}
E poi ho implementato le seguenti quattro classi, e uso una factory per determinare quale classe usare per rappresentare un particolare nodo DOM XML mentre analizzo il documento:
class NodeGroup implements iNode {
getTitle() : return <title>
getAttr() : return @attr1
getInformation() : return <information>
getNodes() : return <detail> | <subgroup> | <reference>
}
class NodeSubGroup implements iNode {
getTitle() : return <title>
getAttr() : return @attr1
getInformation() : return <information>
getNodes() : return <detail> | <subgroup> | <reference>
}
class NodeDetail implements iNode {
getTitle() : return <title>
getAttr() : return @attr2
getInformation() : return child::*[not <title>]
getNodes() : return none
}
class NodeReference implements iNode {
getTitle() : return (NodeDetail:getTitle())
getAttr() : return (NodeDetail:getAttr())
getInformation() : return (NodeDetail:getInformation())
getNodes() : return none
}
Ora, è abbastanza chiaro che NodeGroup e NodeSubGroup hanno la stessa implementazione, quindi ho pensato che avrei potuto creare una superclasse con un'implementazione comune. Anche NodeDetail può estendere tale superclasse poiché implementa getTitle () nello stesso modo (e sovrascrive gli altri tre metodi).
Fatto ciò, ora ho 5 classi e 3 implementazioni (dal momento che NodeGroup e NodeSubGroup sono sottoclassi sottili ora che non sovrascrivono nulla).
La mia domanda è - faccio questo in 3 classi e faccio in modo che la factory instanzia la superclasse per <group> e <subgroup> , o tieni tutte le 5 classi, fai l'abstract della superclasse, in modo che ci sia un esplicito -una relazione tra classi e tipi di nodi XML?
Scusa - nel tentativo di non impantanarmi nel lato dell'implementazione delle cose, probabilmente ho semplificato eccessivamente gli esempi di classe qui. Sto cercando di mettere a fuoco se dovrei avere 5 classi per 5 tipi di nodi o meno - specialmente quando due tipi di nodi presentano lo stesso comportamento per tutto ciò che avrebbe bisogno di usarli. Usare la parola Interazione (anche se significativa nel contesto delle mie applicazioni) è stata anche una scelta sbagliata.
Ciascuna di queste classi istruisce un parser XML su come ottenere le informazioni rilevanti che voglio dal documento per il nodo rappresentato dall'oggetto. Alcune di queste classi manipolano anche le informazioni che il parser recupera.
