Guardar en fichero

[sanlajela]

Hola,

Tengo un parseador de XML en el que obtengo una serie de datos y los voy metiendo en una lista. Quisiera guardarlos en un fichero de texto. ¿Cual sería la mejor forma de hacerlo?

Tengo esto:

Código:

private String message = null;
	private String instanceId = null;
	private List<String> sourcePath = new ArrayList<String>();
	private List<String> sourceLine = new ArrayList<String>();
	
	private Map<String, Object[]> bugs = new HashMap<String, Object[]>(1,1);

Aquí uso bugs.put

Código:

public void endElement (String uri, String localName, String qName) {
		if(inBugCollectionZone){
			if(inBugInstanceZone){
				if(LONG_MESSAGE.equals(qName)){
					inLongMessage = false;
				}
				
			}
			else if(BUG_INSTANCE.equals(qName)){
				inBugInstanceZone = false;
				bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message});
				clearBugsValues();
			}
		}

y en el main voy recorriendo para ir guardando cada instancia leída en el XML.

Código:

for(String id : rsp.getBugs().keySet()){
			Object[] bugsValues = rsp.getBugs().get(id);
			List<String> paths = (List<String>)bugsValues[0];
			List<String> lines = (List<String>)bugsValues[1];
			System.out.println("id:" + id + " " + paths + " " + lines +  " " + bugsValues[2]);
		}

Por pantalla me muestra algo así (id, path,línea,mensaje error):

Código:

id:8fd7fgsfdhsd88833sd [com/da/service/GetDepositCancelInfo.java [64] Method com/da/service/GetDepositCancelInfo.java invokes inefficient new Integer(int) constructor; use Integer.valueOf(int) instead

Quiero llevarme esta info a un fichero de texto y necesito una ayuda para saber como...

Gracias!

[Fuzzylog]

Tienes aqui las lecciones del amigo chui que siempre son útiles

http://chuwiki.chuidiang.org/index.p...cheros_en_Java


la clave está aquí
pw.println("Linea " + i);
Que sustituirías por esto
pw.println("id:" + id + " " + paths + " " + lines + " " + bugsValues[2]);

[sanlajela]

Gracias Fuzzylog por contestar.

Planteo la duda de otro modo para intentar hacerme entender.

Lo que realmente necesito es guardar el ArrayList en un objeto, creandome un nuevo bean, para más tarde guardar esos resultados en un fichero de texto.

Tengo esto:

public void endElement (String uri, String localName, String qName) {
if(inBugCollectionZone){
if(inBugInstanceZone){
if(LONG_MESSAGE.equals(qName)){
inLongMessage = false;
}

}
else if(BUG_INSTANCE.equals(qName)){
inBugInstanceZone = false;
bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message});
clearBugsValues();
}
}

Donde ahora estoy usando bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message});
debería ir algo como bugs.put(instanceId, new nombreNuevaClase (); es decir, una nueva instancia del bean.

Creo una nueva clase (bean) donde almaceno la información rescatada del parseo del XML. La llamaré SonarBugs. Cómo debería implementar esta clase?

Mil gracias de nuevo...

[sanlajela]

Le doy un empujón

[Fuzzylog]

Pues no termino de ver claro como quieres exactamente que sea el interior del bean al que te refieres.

Si estoy bien encaminado podrias crear tantos atributos de tipo ArrayList<String> como necesites, y si son de tamaño indeterminado pues los inicializas directamente al declararlo
private ArrayList<String> lista1 = new ArrayList<String>();
etc.
luego sus getters y setters

Finalmente cuando quieras añadir un valor a la lista haces tuBean.getLista1().add(tuString); o si prefieres setear el ArrayList completo usa tuBean.setLista1(tuArrayList);

[Xerelo]

Yo tampoco te entiendo, y la mejor forma de guardar datos en forma de texto es precisamente xml, si ya tienes el xml ¿por qué no lo guardas tal cual?

Para trabajar con xml tienes un montón de librerías para elegir

JAXB, XStream, XMLBeans

[sanlajela]

Hola,

Entiendo perfectamente que no me sigáis...al tener muy pocos conocimientos de programación Java no se explicarme bien.

Volviendo al código original, el resultado del parseo entiendo que se está metiendo en Object[] (linea bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message}) ); ¿cierto? El resultado se está imprimiendo por pantalla y viene a ser esto:


id:8fd7fgsfdhsd88833sd [com/da/service/GetDepositCancelInfo.java [64] Method com/da/service/GetDepositCancelInfo.java invokes inefficient new Integer(int) constructor; use Integer.valueOf(int) instead

Para intentar simplificar todo un poco, la pregunta es, ¿cómo haríais para guardar estos resultados y luego meterlos en un fichero?

La aplicación será un inspector que automáticamente lanzará un análisis de código sobre unos fuentes, obtenemos unos resultados en .XML y lo que necesito es cada vez que termina el análisis, leer el xml con el resultado de la inspección y volcarlo a un fichero de texto con un formato especial.

Mil gracias de nuevo...

[Xerelo]

La aplicación será un inspector que automáticamente lanzará un análisis de código sobre unos fuentes, obtenemos unos resultados en .XML y lo que necesito es cada vez que termina el análisis, leer el xml con el resultado de la inspección y volcarlo a un fichero de texto con un formato especial.

Repito lo que ya he dicho, obtienes unos resultados en .xml y quieres guardarlos ¿no? Pues xml es texto plano y se utiliza precisamente (entre otras cosas) para guardar datos en ficheros de texto de forma cómoda.

Así que si tienes el xml como String, simplemente guárdalo en fichero, como harías con cualquier otro texto.

Y si vas a trabajar con xml, te recomiendo que investigues alguna de las implemetaciones que he puesto, siendo XStream la más sencilla y JAXB la oficial de Java.

[sanlajela]

Xerelo, lo que me propones no me vale. El fichero de texto que espera una aplicación tercera, es de un formato específico, no puede ser el xml que me deja la inspección de código como resultado.

[Fuzzylog]

A ver, voy a tratar de hacerme entender, porque esto parece un diálogo de besugos.

Supongo que ya tendrás el código para leer el xml.

Creo que lo que estás haciendo es que cada vez que lea una linea del xml con una etiqueta determinada generas un registro que luego necesitas volcar al texto plano.

si es <nombreEtiqueta>textoContenido</nombreEtiqueta> o:
<nombreEtiqueta>
textoContenido
</nombreEtiqueta>
me da igual, tendrás que saber tú como extraer ese textoContenido bien usando replaces y trims (caso1) o bien leyendo la siguiente linea al inicio de la etiqueta (caso 2).

Partamos del caso que ya tienes un String tuTexto = textoContenido; y que no es el unico, tienes también <nombreEtiqueta2>textoContenido2</nombreEtiqueta2> y por tanto String tuTexto2 = textoContenido2; para una etiqueta diferente.

¿Ahora como vas a construir el objeto que lleve todos los posibles textoContenido y textoContenido2?

PIENSA EN ESTO => ¿los textoContenido y textoContenido2 van a ser independientes? En ese caso te valdria con hacer lo que te dije mas arriba. Tener un único objeto con 2 arrayList ya inilializados, hacer get del arraylist correspondiente y añadirle el textoContenido1 y textoContenido2 segun proceda. Al final te quedará el objeto con esas dos listas de textos que luego usarás para generar el txt.

Si textoContenido va a depender de textoContenido2, es decir que para cada registro de textoContenido2 vayan a existir varios registros relacionados de textoContenido, entonces crearias un objeto con un String y un ArrayList, y lo rellenarias con el String siendo el textoContenido2 y el conjunto de textoContenido volcado al arrayList. Como tendrás un mogollón de casos de este tipo, tendrás que crear un ArrayList para contener al conjunto de estos objetos, y por tanto será el ArrayList de objetos lo que uses para generar el txt.

[Xerelo]

Da igual que no sean xml con el mismo formato, para convertir un xml a otro xml puedes usar xslt

http://java.dzone.com/articles/using...t-produce-html

Si no te sirviera o se te hace complicado, lo normal es que usaras alguna de las librerías para pasar de xml a objeto, convertir ese objeto a uno correspondiente al nuevo formato, y volver a utilizar la librería para convertirlo en xml.

[sanlajela]

Lo primero, da de nuevo las gracias a los dos por el interés en ayudarme.

Fuzzylog, me alegra tu respuestas porque por fin he captado bien la idea, lo tengo, tengo el mapa mental. Ahora el problema está en que no se como reflejarlo sobre el papel, mejor dicho no se bien como tirar el código.

Empezaría así?

Crearme nueva objeto
-SonarBugs.java
Declaro
private String bugInstance[]; //donde iría cada instancia de un mismo bug encontrado en un fuente
private ArrayList<String> bugCollection; //donde iría el conjunto de instancias anteriormente descritos.

...y seguiría...¿cómo?

[Fuzzylog]

SonarBugs.java tendrá entonces
private String bugInstance; //donde iría UNA instancia de un mismo bug encontrado en una fuente
private List<String> bugCollection = new ArrayList<String>; //donde iría el conjunto de instancias anteriormente descritos

Cuando estés procesando el xml te pueden pasar dos cosas, que se repitan los bugs o que no se repitan.

Si no se repiten es el caso mas facil
Creas un List<SonarBugs> listaBugs = new ArrayList<SonarBugs>();
encuentras un bug
SonarBugs bug = new SonarBugs();
bug.setBugInstance("el texto que corresponda a tu bug");
y vas introduciendo los otros Strings en bugCollection.

Si se pueden repetir a lo largo del xml, iriamos a un metodo mas complejo, en el que deberiamos recorrer listaBugs comprobando si existe un bugInstance igual al encontrado y en caso afirmativo añadiendo los String en bugCollection para ese objeto, y creando un nuevo objeto y añadiendolo al listado en caso de que no exista.

Un ejemplo de un xml real con bugs y mostrar los datos que se sacarian podría ayudar a mejorar la explicación.

[sanlajela]

Por problemas de confidencialidad tengo que ponerte un ejemplo encontrado en la red (imagen png) de un xml igual al que yo obtengo.

Cada bug encontrado se enmarca dentro de <BugInstance>. Puedo tener muchos bugs encontrados en cada análisis, logicamente. Un dato más; un bug puede ser encontrado en
varias líneas por lo que puede haber varios <SourceLine> dentro de cada <BugInstance>.

Luego, rescato ciertos datos que me interesan (el path, línea donde se produce el error, mensaje de error,etc) y los muestro por pantalla con este resultado.

id:8fd7fgsfdhsd88833sd [com/da/service/GetDepositCancelInfo.java [64] Method com/da/service/GetDepositCancelInfo.java invokes inefficient new Integer(int) constructor; use Integer.valueOf(int) instead

[URL="http://www.javatips.net/static/images/findBugs_xml.png"]Imagen de XML ejemplo [/URL]

[Fuzzylog]

Pues eso genera un objeto BugInstance con su type o id o como quieras llamarle para identificarlo y una lista de sourceline que vayas a copiar. Por lo que veo el sourcepath lo puedes extraer a partir del texto de sourceline por lo que no tendrías que guardarlo por separado sino un método que lo extraiga de ese sourceline.

Por cada BugInstance que encuentres lo metes en un List<BugInstance> y con ese listado construiras la salida formateada en el fichero de texto.

[sanlajela]

Entendido Fuzzylog. Se que es muy descarado y "tener morro", pero puedes traducirlo en código?

El actual código que tengo para leer el XML es este...Cómo sería el SonarBugs.java?

BugSaxSonarParser.java

package example;
import java.util.List;
import java.util.Map;
import java.util.jar.Attributes;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.HashMap;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

import com.sun.org.apache.xerces.internal.parsers.SAXPars er;


public class BugsSaxParserSonar extends DefaultHandler{

private static final String BUG_COLLECTION = "BugCollection";
private static final String BUG_INSTANCE = "BugInstance";
private static final String LONG_MESSAGE = "LongMessage";
...
private static final String PATH_PROP = "sourcepath";
private static final String LINE_PROP = "start";

private boolean inBugCollectionZone = false;
private boolean inBugInstanceZone = false;
private boolean inLongMessage = false;
...

private String message = null;
private String instanceId = null;
private List<String> sourcePath = new ArrayList<String>();
private List<String> sourceLine = new ArrayList<String>();

private Map<String, Object[]> bugs = new HashMap<String, Object[]>(1,1);

private Pattern folderPattern = null;

public BugsSaxParserSonar (String folderPatterString){
folderPattern = Pattern.compile(folderPatterString);
}

public void startElement (String uri, String localName, String qName, Attributes attributes) {
if(inBugCollectionZone){
if(inBugInstanceZone){
if(LONG_MESSAGE.equals(qName)){
inLongMessage = true;
}
else if(inClass == false && inMethod == false && inField == false) && SOURCE_LINE.equals(qName)){
inSourceLine = true;
sourcePath.add(attributes.getValue(PATH_PROP));
sourceLine.add(attributes.getValue(LINE_PROP));
}
}
else if(BUG_INSTANCE.equals(qName)){
instanceId = attributes.getValue(INSTANCE_HASH);
inBugInstanceZone = true;
}
}
else if (BUG_COLLECTION.equals(qName)){
inBugCollectionZone = true;
}
}


public void characters (char ch[], int start, int length) throws SAXException {
if(inBugCollectionZone){
if(inBugInstanceZone){
if(inLongMessage){
if(message == null){
message = "";

}
message += new String(ch, start, length);
}
}
}
}

public void endElement (String uri, String localName, String qName) {
if(inBugCollectionZone){
if(inBugInstanceZone){
if(LONG_MESSAGE.equals(qName)){
inLongMessage = false;
}

}
else if(BUG_INSTANCE.equals(qName)){
inBugInstanceZone = false;
bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message});
clearBugsValues();
}
}
else if (BUG_COLLECTION.equals(qName)){
inBugCollectionZone = false;
}
}

private void clearBugsValues(){

inBugCollectionZone = false;
inBugInstanceZone = false;
inLongMessage = false;
...

}

public Map<String, Object[]> getBugs() {
return bugs;
}

public String getWorkingDirectory() {
return workingDirectory;
}

public void setWorkingDirectory(String workingDirectory) {
this.workingDirectory = workingDirectory;
}


public static void main(String[] args){
BugsSaxParserSonar rsp = new BugsSaxParserSonar("/?(DD|DS)/");
try{
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
sp.parse("D:/tmp/findbugs-result.xml", rsp);
}catch(ParseConfigurationException e){
System.err.println("error de parseo en XML");
}catch(SAXException e2){
e2.printStackTrace();
System.err.println("error de sax : " + e2.getMessage());
}catch(Exception e3){
System.err.println("error de io : " + e3.getMessage());
}
for(String id : rsp.getBugs().keySet()){
Object[] bugsValues = rsp.getBugs().get(id);
List<String> paths = (List<String>)bugsValues[0];
List<String> lines = (List<String>)bugsValues[1];
System.out.println("id:" + id + " " + paths + " " + lines + " " + bugsValues[2]);
}
}

}

[Fuzzylog]

Es que en ese codigo ya no necesitas crear ningun objeto porque lo tienes de otra manera

bugs.put(instanceId, new Object[]{new ArrayList<String>(sourcePath), new ArrayList<String>(sourceLine), message});

tienes el HashMap bugs y a partir de ahi ya sacas la informacion que necesitas :|


Asi que lo unico que necesitas es crear el fichero de texto donde lo vas a guardar (algo parecido a esto)
BufferedWriter out = new BufferedWriter(new FileWriter("file.txt"));

=> https://www.google.es/#output=search...w=1280&bih=834

y luego donde tienes tus system.out con la información lo sustituyes por un
out.write("loquetienesenelsystemout" + "\n");