transformer.transform(source, result) -> ObjectOutput

[Daishi1002]

Hallo alle zusammen!

Ich hab folgendes Problem: Ich möchte Message Objecte per Externalizable in XML wandeln und dann an den vordefinierten ObjectOutput schicken. Daas Problem ist aber, dass "transformer.transform(source, result)" ein Object vom Typ Result erwartet und ich keine Ahnung hab, wie ich meinen ObjectOutout darauf hinbiegen kann.

So sieht das nackte (=abgespeckte) Problem aus:

Zunächst der Starter Code, der eine Message erzeugt und dann dieses erzeugte Object auf einen Stream schreiben will.

import java.io.*;

public class Starter {
    public static void main(String argv[]){
    	ObjectOutputStream out = null;
    	    	
    	Message testMessage = new Message();
			try {
				out = new ObjectOutputStream(new FileOutputStream("test.dat"));
				//out = new ObjectOutputStream(System.out);
				out.writeObject(testMessage);
				out.flush();
				out.close();
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    }
}

und die Message Klasse

import java.io.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult; 
import org.w3c.dom.*;

public class Message implements Externalizable{
	int messageId;
    static Document document;
    
    //Constructor 
    public Message(){
       	messageId = 0;}

    public void writeExternal(ObjectOutput out) throws IOException {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();    	
            try {
				DocumentBuilder builder = factory.newDocumentBuilder();
				document = builder.newDocument(); 
				//XML Structure^

				Element root = (Element) document.createElement("test");
				document.appendChild(root);
				      Element test = (Element) document.createElement("test2");
				      root.appendChild(test);

			} catch (DOMException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			} catch (ParserConfigurationException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		//DOM Tree is done, now write this to the stream	          
       try{
        	TransformerFactory tFactory =   TransformerFactory.newInstance();
        	Transformer transformer = tFactory.newTransformer();
        	transformer.setOutputProperty("indent", "yes");
        	
        	DOMSource source = new DOMSource(document);
        	StreamResult result = new StreamResult(System.out);
        	transformer.transform(source, result);
        	  
        }catch(Exception e){
        	e.printStackTrace();
        }
   }
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException{
    	//noch nix hier
    }
 }

Dabei wird im Moment das Ergebnis auf System.out geschrieben, ich will es aber auf ObjectOutput out schreiben - nur wie?

Danke und Gruß
Daishi1002

 

[KISS]

dann solltest du dem stream result auch deinen outputstream mitgeben und nicht System.out

 

[Daishi1002]

Das hab ich doch schon längst versucht - es geht nicht, weil transformer.transform(source, result) ein OutputStream erwartet, jedoch bei writeExternal ein ObjectOutput übergeben wird.

 

[Roar]

dann caste den parameter in (Object)OutputStream und übergib transform() diesen.

 

[KISS]

du koenntest ObjectOut auf ObjectOutputStream casten

StreamResult result = new StreamResult((ObjectOutputStream)out);

das muss aber nicht immer gehen
versuche mal

import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class MyOutput extends ObjectOutputStream implements ObjectOutput
{
    private final ObjectOutput f_delefated;

    public MyOutput(ObjectOutput delegated) throws IOException
    {
       super(null);
       f_delefated=delegated;
    }

    public void close() throws IOException
    {
        f_delefated.close();
    }

    public void flush() throws IOException
    {
        f_delefated.flush();
    }

    public void write(byte[] b, int off, int len) throws IOException
    {
        f_delefated.write(b, off, len);
    }

    public void write(byte[] b) throws IOException
    {
        f_delefated.write(b);
    }

    public void write(int b) throws IOException
    {
        f_delefated.write(b);
    }

    public void writeBoolean(boolean v) throws IOException
    {
        f_delefated.writeBoolean(v);
    }

    public void writeByte(int v) throws IOException
    {
        f_delefated.writeByte(v);
    }

    public void writeBytes(String s) throws IOException
    {
        f_delefated.writeBytes(s);
    }

    public void writeChar(int v) throws IOException
    {
        f_delefated.writeChar(v);
    }

    public void writeChars(String s) throws IOException
    {
        f_delefated.writeChars(s);
    }

    public void writeDouble(double v) throws IOException
    {
        f_delefated.writeDouble(v);
    }

    public void writeFloat(float v) throws IOException
    {
        f_delefated.writeFloat(v);
    }

    public void writeInt(int v) throws IOException
    {
        f_delefated.writeInt(v);
    }

    public void writeLong(long v) throws IOException
    {
        f_delefated.writeLong(v);
    }

    public void writeObject(Object obj) throws IOException
    {
        f_delefated.writeObject(obj);
    }

    public void writeShort(int v) throws IOException
    {
        f_delefated.writeShort(v);
    }

    public void writeUTF(String str) throws IOException
    {
        f_delefated.writeUTF(str);
    }
}

 

[Roar]

das muss aber nicht immer gehen

soltle aber immer gehen, da ObjectOutputStream die einzige klasse in der j2se ist, die ObjectOutput implementiert

 

[KISS]

jaja, aber wer hindert dich den dein eigenes ObjectOutput zu implementieren und das dann zu ubergeben?
also 100% sicher ist es nicht, darum der delegatorwrapper, da ist es wurscht was das objectOutput ist