Guardar valor de variables de .java en save.xml

[VicInFlames]

Muy buenas a todos,
tengo serias dudas con un proyecto en java que no acabo de comprender.

He programado un juego sobre las "Torres de Hanoi",con las clases :
-Tablero
-Disco
-Torre
-JugarTorres
aunque estas con lo de menos..

En el juego,debes especificar los movimientos que quieres hacer con los discos,de que posición a qué posición,guardando estas..
en ese caso,quiero guardar estas variables en un save.xml mediante las clases StaXParser.java,Item.java,y StaxWriter.java.. como he podido consultar en otras webs es la manera más sencilla..

He seguido los pasos necesarios,pero no consigo entender cómo adaptar el código al mío..añadir los eventos,los cambios de valores..
me es complicado ya que empecé recientemente con el mundo de Java..

necesito una extensa explicación de cómo podría solucionar mi problema,si es necesario paso mi código para facilitarlo.
A ser posible responder lo antes posible.

Agradecimientos adelantados

[Usuario Invitado]

Usa el API de Java para manejo de XML, JAXB. Con JAXB puedes transformar un objeto a XML y viceversa. Te dejo un ejemplo aplicado a tu caso:

ENTIDADES

Board:

Código (java) [Seleccionar] Expandir


/**
*
* @author Gus
*/
public class Board {
   private String name;
   private int towersNumber;
   
   public Board() {}

   public Board(String name, int towersNumber) {
       this.name = name;
       this.towersNumber = towersNumber;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getTowersNumber() {
       return towersNumber;
   }

   public void setTowersNumber(int towersNumber) {
       this.towersNumber = towersNumber;
   }

   
   
}


Tower:

Código (java) [Seleccionar] Expandir


package net.elhacker.jaxbexample.model.entities;

/**
*
* @author Gus
*/
public class Tower {
   private String name;
   private int xAxis;
   private int yAxis;
   
   public Tower() {}

   public Tower(String name, int xAxis, int yAxis) {
       this.name = name;
       this.xAxis = xAxis;
       this.yAxis = yAxis;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getxAxis() {
       return xAxis;
   }

   public void setxAxis(int xAxis) {
       this.xAxis = xAxis;
   }

   public int getyAxis() {
       return yAxis;
   }

   public void setyAxis(int yAxis) {
       this.yAxis = yAxis;
   }
   
   
}

Disc:

Código (java) [Seleccionar] Expandir


package net.elhacker.jaxbexample.model.entities;

/**
*
* @author Gus
*/
public class Disc {
   private int xAxis;
   private int yAxis;
   
   public Disc() {}

   public Disc(int xAxis, int yAxis) {
       this.xAxis = xAxis;
       this.yAxis = yAxis;
   }

   public int getxAxis() {
       return xAxis;
   }

   public void setxAxis(int xAxis) {
       this.xAxis = xAxis;
   }

   public int getyAxis() {
       return yAxis;
   }

   public void setyAxis(int yAxis) {
       this.yAxis = yAxis;
   }
   
   
}

Ahora veamos a nuestra clase que se transformará en un archivo XML:

Código (java) [Seleccionar] Expandir

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import net.elhacker.jaxbexample.model.entities.Board;
import net.elhacker.jaxbexample.model.entities.Disc;
import net.elhacker.jaxbexample.model.entities.Tower;

/**
*
* @author Gus
*/
@XmlRootElement(name="HanoiTower")
@XmlAccessorType(XmlAccessType.FIELD)
public class HanoiTower {

   @XmlElement
   public Tower tower;
   @XmlElement
   public Board board;
   @XmlElement
   public int playingTowers;
   @XmlElement
   public Disc disc;

   public HanoiTower() {
   }

   public Tower getTower() {
       return tower;
   }

   public void setTower(Tower tower) {
       this.tower = tower;
   }

   public Board getBoard() {
       return board;
   }

   public void setBoard(Board board) {
       this.board = board;
   }

   public Disc getDisc() {
       return disc;
   }

   public void setDisc(Disc disc) {
       this.disc = disc;
   }

   public int getPlayingTowers() {
       return playingTowers;
   }

   public void setPlayingTowers(int playingTowers) {
       this.playingTowers = playingTowers;
   }

}



Como puedes observar, hemos anotado la clase con @XmlRootElement. Esto indica que dicha clase será la raíz de una estructura XML. Ojo, esto no quiere decir que no puedas guardar un objeto anotado así en otro. Su atributo name es para asignarle un nombre a la raíz del XML.

@XmlAccessorType, especifica que tipo de acceso se tendrá la clase, si es por propiedades (campos) o métodos. En nuestro caso, hemos optado por que el acceso sea por medio de las propiedades: XmlAccessType.FIELD.

Las propiedades las hemos anotado con @XmlElement, esto indica que dicha propiedad será una etiqueta, y su valor se desplegará entre dicha etiqueta de apertura y la de su cierre.

Si te das cuenta aunque los objetos Board, Tower y Disc no hayan sido declarados con @XMLElement, JAXB lo hace por nosotros. Observa al final, la salida que genera JAXB.

Ahora veamos quién hace la "magia". En éste caso he creado una clase que actúe de manager para convertir de Objeto a XML y viceversa.

HanoiTowerMarshaller:

Código (java) [Seleccionar] Expandir

import java.io.File;
import java.util.logging.Logger;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
*
* @author Gus
*/
public class HanoiTowerMarshaller {
   private static JAXBContext jaxbContext;
   private static Logger logger;
           
   public HanoiTowerMarshaller() {
       try {
           jaxbContext  = JAXBContext.newInstance(HanoiTower.class);
           logger = Logger.getLogger(HanoiTowerMarshaller.class.getName());
       } catch(JAXBException ex) {
           logger.warning(ex.getMessage());
       }
   }
   
   public void marshal(HanoiTower hanoiTower) {
       try {
           File file = new File("D:\\hanoi-tower.xml");
           Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
           
           jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
           
           jaxbMarshaller.marshal(hanoiTower, file);
           jaxbMarshaller.marshal(hanoiTower, System.out);

       } catch(JAXBException ex) {
           logger.warning(ex.getMessage());
       }
   }
   
   public HanoiTower unmarshall(String filePath) {
       HanoiTower hanoiTower = null;
       try {
           File xml = new File(filePath);
           Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
           hanoiTower = (HanoiTower) jaxbUnmarshaller.unmarshal(xml);
       } catch (JAXBException ex) {
           logger.warning(ex.getMessage());
       }
       return hanoiTower;
   }
}

Primero declaramos jaxbContext y logger como propiedades porque las utilizaremos en ambos métodos de la clase.

En el constructor inicializamos jaxbContext con el método newInstance() de JAXBContext al que debemos pasarle por parámetro la clase con la que se trabajará. Como siempre vamos a a trabajar con HanoiTower, se lo indico aquí. Si vamos a trabajar con muchas clases y XML, esto debe ir en el método marshal y unmarshal ya que las clases con las que se va a trabajar son varias.

También inicializamos logger. Logger lo único que hace es crear logs para que los puedas revisar luego en caso de error o algo importante.

En el método marshall, lo primero que hacemos es crear un objeto File con la ruta recibida, esto para saber dónde guardar el XML.

Luego simplemente crea un objeto Marshaller para poder llevar a cabo la conversión. Posteriormente le asignamos una propiedad para que el código esté formateado, esto por cuestiones de legibilidad ).

Por último, utilizamos el método marshal para convertir el objeto a XML y guardarlo en la ruta a la que apunta el objeto File. También lo hacemos con System.out porque quiero ver la salida en la consola también.

El método unmarshall hace lo mismo, la diferencia es que crea un objeto Unmarshaller y utiliza el método unmarshal pasándole el objeto File que apunta a la ruta del XML a leer. Nota el cast, es necesario usarlo.

Ahora, una pequeña prueba:

JAXBExample:

Código (java) [Seleccionar] Expandir

package jaxbexample;

import net.elhacker.jaxbexample.model.entities.Board;
import net.elhacker.jaxbexample.model.entities.Disc;
import net.elhacker.jaxbexample.model.entities.Tower;
import net.elhacker.jaxbexample.model.xml.HanoiTower;
import net.elhacker.jaxbexample.model.xml.HanoiTowerMarshaller;

/**
*
* @author Gus
*/
public class JAXBExample {

   public static void main(String[] args) {
       HanoiTowerMarshaller marshaller = new HanoiTowerMarshaller();
       Board board = new Board();
Tower tower = new Tower();
Disc disc = new Disc();

board.setName("Juego 1");
board.setTowersNumber(5);
tower.setName("Torre 1");
tower.setxAxis(25);
tower.setyAxis(34);
disc.setxAxis(19);
disc.setyAxis(23);
HanoiTower hanoiTower = new HanoiTower();
hanoiTower.setBoard(board);
hanoiTower.setTower(tower);
hanoiTower.setDisc(disc);
hanoiTower.setPlayingTowers(7);
       
       marshaller.marshal(hanoiTower, "D:\\hanoi-tower.xml");
       
       HanoiTower xmlToHanoiTower = marshaller.unmarshall("D:\\hanoi-tower.xml");
       System.out.println("Datos del juego cargado:\n");
       System.out.println("Nombre del juego:");
       System.out.println(xmlToHanoiTower.getBoard().getName());
       System.out.println("Número de torres en el juego:");
       System.out.println(xmlToHanoiTower.getBoard().getTowersNumber());
       System.out.println("Nombre de la torre del jugador:");
       System.out.println(xmlToHanoiTower.getTower().getName());
       System.out.println("Coordenada X de la torre:");
       System.out.println(xmlToHanoiTower.getTower().getxAxis());
       System.out.println("Coordenada Y de la torre:");
       System.out.println(xmlToHanoiTower.getTower().getyAxis());
       System.out.println("Número de torres jugando:");
       System.out.println(xmlToHanoiTower.getPlayingTowers());
       System.out.println("Coordenada X del disco:");
       System.out.println(xmlToHanoiTower.getDisc().getxAxis());
       System.out.println("Coordenada Y del disco:");
       System.out.println(xmlToHanoiTower.getDisc().getyAxis());
   }
   
}


Salida:

Código [Seleccionar] Expandir

<HanoiTower>
   <tower>
       <name>Torre 1</name>
       <xAxis>25</xAxis>
       <yAxis>34</yAxis>
   </tower>
   <board>
       <name>Juego 1</name>
       <towersNumber>5</towersNumber>
   </board>
   <playingTowers>7</playingTowers>
   <disc>
       <xAxis>19</xAxis>
       <yAxis>23</yAxis>
   </disc>
</HanoiTower>
Datos del juego cargado:

Nombre del juego:
Juego 1
Número de torres en el juego:
5
Nombre de la torre del jugador:
Torre 1
Coordenada X de la torre:
25
Coordenada Y de la torre:
34
Número de torres jugando:
7
Coordenada X del disco:
19
Coordenada Y del disco:
23


Enjoy!

[VicInFlames]

Wooooow! xD Muchisimas gracias por la ayuda.
Quizás algo tarde..~ pero muy muy valiosa información.
Tendré que repasar algo de xml..