# transformer.transform(source, result) -> ObjectOutput



## Daishi1002 (20. Jun 2005)

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 (20. Jun 2005)

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


----------



## Daishi1002 (20. Jun 2005)

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 (20. Jun 2005)

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


----------



## KISS (20. Jun 2005)

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 (20. Jun 2005)

KISS hat gesagt.:
			
		

> das muss aber nicht immer gehen


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


----------



## KISS (20. Jun 2005)

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


----------

