Foro de elhacker.net

tengo el siguiente xml


y no se como leer las etiquetas <Archivo_fuente> y  <Archivo_destino>

y lo q logre fue hacer esto 



si alguien me podia con el resto se los agradeceriaa

Hola  samirllorente,

Puedes leer tu fichero XML mediante JAXB, que es el API de Java para manejo de ficheros XML. Lo único que necesitarás es crear clases (entidades) que representen a cada etiqueta. Un ejemplo aplicado a tu XML:

Ésta clase es el Root, es decir, la etiqueta que engloba todo (<Gestion></Gestion>):

Management

package com.company.model.entities;
 
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlRootElement(name="Gestion")
@XmlAccessorType(XmlAccessType.FIELD)
public class Management {
    @XmlElement(name="Velocidad")
    private Double velocity;
    @XmlElement(name="Process")
    private List<Process> processes;
 
    public Management() {
 
    }
    public Management(Double velocity, List<Process> processes) {
    	this.velocity = velocity;
    	this.processes = processes;
    }
    public Double getVelocity() {
        return velocity;
    }
    public void setVelocity(Double velocity) {
        this.velocity = velocity;
    }
    public List<Process> getProcesses() {
        return processes;
    }
    public void setProcesses(List<Process> processes) {
        this.processes = processes;
    }
 
}

Como puedes darte cuenta hay un par de anotaciones interesantes:

• @XmlRootElement: Indica que es el elemento padre de una jerarquía.
• @XmlElement: Indica que es un elemento XML (un tag).
• @XmlAccessorType, @XmlAccessType.FIELD: La primera se usa para establecer el tipo de acceso. La segunda indica que se accederá a los valores por propiedades (y no por getters/setters).

El atributo name de las anotaciones se usa para especificar el valor que deben tener las propiedades (tags) en el XML.

Ahora veamos las entidades Process y Activity:

Process

package com.company.model.entities;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlAccessorType(XmlAccessType.FIELD)
public class Process {
    @XmlElement(name="Pid")
    private Short pid;
    @XmlElement(name="Name")
    private String name;
    @XmlElement(name="Quantum")
    private Short quantum; // ¿quántico?
    @XmlElement(name="Actividad")
    private Activity activity;
 
    public Process() {
 
    }
    public Process(Short pid, String name, Short quantum, Activity activity) {
        this.pid = pid;
        this.name = name;
        this.quantum = quantum;
        this.activity = activity;
    }
    public Short getPid() {
        return pid;
    }
    public void setPid(Short pid) {
        this.pid = pid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Short getQuantum() {
        return quantum;
    }
    public void setQuantum(Short quantum) {
        this.quantum = quantum;
    }
    public Activity getActivity() {
        return activity;
    }
    public void setActivity(Activity activity) {
        this.activity = activity;
    }
 
}

Activity

package com.company.model.entities;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 *
 * @author gus
 */
@XmlAccessorType(XmlAccessType.FIELD)
public class Activity {
    @XmlElement(name="Archivo_fuente")
    private String source;
    @XmlElement(name="Archivo_destino")
    private String target;
 
    public Activity() {
 
    }
    public Activity(String source, String target) {
        this.source = source;
        this.target = target;
    }
    public String getSource() {
        return source;
    }
    public void setSource(String source) {
        this.source = source;
    }
    public String getTarget() {
        return target;
    }
    public void setTarget(String target) {
        this.target = target;
    }
 
}

Como puedes ver, algunas etiquetas se repiten, en concreto XmlAccessorType y es para indicar que los valores se accederán por medio de las propiedades.

NOTA: Para leer un archivo XML es importante que el atributo name de las propiedades sean idénticas al nombre del tag en el XML. De lo contrario, la conversión fallará.

Ahora, veamos quien hace "la magia". Cabe aclarar que se hace un uso mínimo de Generics para que la clase se adapte a cualquier entidad:.

MarshallerUtil

package com.company.model.jaxb;
import java.io.File;
 
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
 
 
 
public class MarshallerUtil<T> {
	private static JAXBContext jaxbContext;
	private final Class<T> clazz;
 
	public MarshallerUtil(Class<T> aClazz) throws JAXBException {
		this.clazz = aClazz;
		jaxbContext = JAXBContext.newInstance(clazz);
	}
 
	public void marshal(T entity, File output) throws JAXBException {
		Marshaller marshaller = jaxbContext.createMarshaller();
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
		marshaller.marshal(entity, output);
	}
 
	public T unmarshal(File input) throws JAXBException {
		Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
		return (T) unmarshaller.unmarshal(input);
	}
 
}

Donde:

• T: Es el tipo de clase (entidad) que será trabajada por el Marshaller (transformador).
• marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);: Formatea el XML.
• marshaller.marshall(entity, file): Recibe la entidad a convertir a XML y el destino (ruta) en un objeto File.
• marshaller.unmarshal(file): Recibe la ruta del XML a convertir. Con el cast hacia T decimos que el XML se convierta a la entidad con la que se está trabajando (T = MarshallerUtil<CLASE_DE_ENTIDAD>).
  
  Por último, hagamos una prueba:
  
  Main
  
  

package com.company.main;
 
import com.company.model.entities.Activity;
import com.company.model.entities.Management;
import com.company.model.entities.Process;
import com.company.model.jaxb.MarshallerUtil;
import com.sun.istack.internal.logging.Logger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.xml.bind.JAXBException;
 
 
public class Main {
 
	public static void main(String[] args) {
            Logger logger = Logger.getLogger(Main.class);
            try {
                /*Management management = new Management();
                List<Process> processes = new ArrayList<>();
                Collections.addAll(processes,
                        new Process(new Short("1"), "Proceso 1", new Short("1"),
                            new Activity("/home/gus/Documentos/origen.txt", "home/gus/Documentos")),
                        new Process(new Short("2"), "Proceso 2", new Short("4"),
                            new Activity("/home/gus/Documentos/origen.xml", "home/gus/Documentos")),
                        new Process(new Short("3"), "Proceso 3", new Short("3"),
                            new Activity("/home/gus/Documentos/origen.sh", "home/gus/Documentos"))
                );
                management.setVelocity(100.05d);
                management.setProcesses(processes);
                MarshallerUtil<Management> marshaller = new MarshallerUtil(Management.class);
                marshaller.marshal(management, new java.io.File("/home/gus/Documentos/prueba1.xml"));*/
 
                MarshallerUtil<Management> marshaller = new MarshallerUtil(Management.class);
                Management management = marshaller
                        .unmarshal(new java.io.File("/home/gus/Documentos/prueba.xml"));
                System.out.println(management.getVelocity());
                for(Process process : management.getProcesses()) {
                    System.out.println(process.getPid());
                    System.out.println(process.getName());
                    System.out.println(process.getQuantum());
                    System.out.println(process.getActivity().getSource());
                    System.out.println(process.getActivity().getTarget());
                    System.out.println();
                }
            } catch (JAXBException e) {
                logger.warning(e.getMessage());
            }
 
	}
 
}

La parte comentada es la forma para convertir una entidad a un fichero XML.

Resultado:



¡Saludos!

 :o gracias muchas gracias, tratare de entender esto de xml porq ni ideaa, pero lo nesecitooo

Me sirvio tus sugerencias, segui con el q ya tenia, pero este me sirve de todas maneras porq tengo q hacer 3 formas distintas para un trabajos :D

asi fue como hice

Por supuesto, vale perfectamente leerlo a puro código. Yo entre ambas formas, prefiero trabajar con JAXB, por un lado porque la conversión es automática y transparente para mí, y por otro lado porque siempre es bueno trabajar con entidades  :)

Saludos y gracias por compartir el código.