# socket und sax (xml)



## jeroen (4. Nov 2008)

hi,

ich möchte einen socket server schreiben, der xml empfänge, dieses dann verarbeitet und dann entsprechend antwortet. ich wollte dazu den sax phraser verwenden, der dann den socket stream als input bekommt. 

Allerdings kommt es immer wieder zu einer verklemmung.
Hier ist mein einfacher code. Es wird der XML code gepharser und einfach damit geantwortet:

Server:

```
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;


/**
 * Minimales Beispiel für die Verwendung des SAX-Parsers in Java. Die XML Datei wird
 * eingelesen und ordentlich formatiert auf der Konsole ausgegeben.
 * DefaultHandler ist eine abstrakte Klasse, die die Interfaces ContentHandler,
 * DTDHandler, EntityResolver und ErrorHandler implementiert.
 */
public class Main extends DefaultHandler
{
	private String text;
    /**
     * Verschachtelungstiefe der Tags, wird verwendet, um das XML-Dokument
     * formatiert auszugeben. 
     */
    private int level = 0;

    /**
     * Leerer Konstruktor, die Initialisierung des Parsers erfolgt in der
     * main-Methode.
     */
    public Main()throws Exception
    {
		text = new String();
		int port = 1234;
		
		// Neuen SAX-Parser erzeugen
        SAXParserFactory factory   = SAXParserFactory.newInstance();
        SAXParser        saxParser = factory.newSAXParser();

		// Server starten 
		ServerSocket server = new ServerSocket(1234);
		System.out.println("Server gestartet on Port " + port);
		// warten auf eine neue Verbindung 
		Socket s = server.accept(); 
		// neue Verbindung ist da, wir lesen einfach aus, 
		// was sie uns so schickt und schicken dann alles in grossbuchstaben wieder zurück 
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
 
		
        // XML Datei parsen, die entsprechenden Methoden des DefaultHandler
        // werden als Callback aufgerufen.
        saxParser.parse(s.getInputStream(),this);
        
        System.out.println(text);
        
		
        out.write(text);
		out.newLine(); 
		out.flush(); 
		out.close();
		 
		server.close();
    }

    /**
     * Gibt <code>level</code> Tabs auf der Konsole aus.
     */
    public void indent()
    {
    	try
    	{
    		// Mit Tabs einrücken
	        for (int i=0;i<level;i++)
	            text += "\t";
	        	//out.write("\t");
    	}
    	catch(Exception e)
    	{
    		System.err.println(e);
    	}
    }

    /**
     * Wird am Anfang des Dokuments aufgerufen, definiert im Interface ContentHandler.
     */
    public void startDocument() throws SAXException
    {
        //out.write("Start des Dokuments");
    }

    /**
     * Wird bei jedem öffnenden Tag aufgerufen, definiert im Interface ContentHandler.
     * Bei leeren Tags wie zum Beispiel &img /& wird startElement und
     * endElement direkt hintereinander aufgerufen. Mit J2SE 1.4.2 scheint nur
     * qName gefüllt zu sein.
     *
     * @param namespaceURI URI des Namespaces für dieses Element, kann auch ein leerer String sein.
     * @param localName Lokaler Name des Elements, kann auch ein leerer String sein.
     * @param qName Qualifizierter Name (mit Namespace-Prefix) des Elements.
     * @param atts Liste der Attribute.
     */
    public void startElement(String namespaceURI, String localName,
            String qName, Attributes atts) throws SAXException
    {
        indent();
        try
        {
	        text += "<" + qName;
	
	        // Test-Code um zu sehen, was in namespaceURI und localName steht
	        // System.out.print(" " + namespaceURI);
	        // System.out.print(" " + localName);
	
	        // Attribute ausgeben
	        for( int i = 0; i < atts.getLength(); i++ )
	            text += " " + atts.getQName(i) + "=\"" + atts.getValue(i) + "\"";
	
	        text += ">";
        }
        catch(Exception e)
        {
        	System.err.println(e);
        }

        level++;
    }

    /**
     * Wird bei jedem schließenden Tag aufgerufen, definiert im Interface ContentHandler.
     *
     * @param namespaceURI URI des Namespaces für dieses Element, kann auch ein leerer String sein.
     * @param localName Lokaler Name des Elements.
     * @param qName Qualifizierter Name des Elements.
     */
    public void endElement(String namespaceURI, String localName, String qName)
    {
        level--;

        indent();
        try
        {
        	text += "</" + qName + ">";
        }
        catch(Exception e)
        {
        	System.err.println(e);
        }
    }

    /**
     * Wird immer aufgerufen, wenn Zeichen im Dokument auftauchen.
     *
     * @param ch Character Array
     * @param start Startindex der Zeichen in ch
     * @param length Länge der Zeichenkette
     */
    public void characters(char ch[], int start, int length)
    {
        String s = new String(ch,start,length).trim();
        if (s.length() > 0) {
            indent();
            try
            {
            	text += (s);
            }
            catch(Exception e)
            {
            	System.err.println(e);
            }
        }
    }

    /**
     * Wird aufgerufen, wenn Leerraum (" ", "\t", "\n", "\r") im Dokument
     * auftaucht, der für die Struktur des Dokuments nicht von Bedeutung ist. 
     *
     * @param ch Character Array
     * @param start Startindex der Zeichen in ch
     * @param length Länge der Zeichenkette
     */
    public void ignorableWhitespace(char[] ch, int start, int length)
    {
    }

    public static void main(String args[])
    {

        try 
		{
            new Main();
        }
        catch (Exception e) 
		{
            System.out.println(e);
        }
    }
}
```

Client:

```
import java.io.*;
import java.net.Socket;

public class client
{
	public static void main(String[] args)
	{
		if ( args.length == 2 )
		{
			try
			{
				// socket auf localhost port 1234 konstruieren 
				Socket s = new Socket(args[0], Integer.valueOf(args[1]) ); 
				// etwas über den socket versenden 
				BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); 
				out.write( "<AmbrosiaEx><head><typ>1</typ></head><body><a>test</a></body></AmbrosiaEx>" ); 
				// zeilenumbruch senden 
				out.newLine(); 
				out.flush();
				
				// BufferedReader konstruieren 
				BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream())); 
				// eine zeile lesen 
				String text = in.readLine();
				// und ausgeben 
				System.out.print("Received: "); 
				System.out.println(text); 

				// am ende schliessen wir alle offenen Reader und Writer, der Socket wird dabei automatisch geschlossen 
				out.close(); 
				in.close();
			}
			catch(Exception e)
			{
				System.out.println(e);
			}
		}
		else
		{
			System.out.println("java client ip port");
		}
	}
}
```

der client funktioniert ohne probleme. ich habe es mit einem server ausprobiert, der ein string empfängt und diesen wieder zurück schickt.
meine vermutung ist das der server einfach nicht antwort.

viel danke für jede hilfe.


----------



## jeroen (5. Nov 2008)

hi,

das problem ist natürlich so lösbar:


```
StringReader inStream = new StringReader( in.readLine() );
InputSource inSource = new InputSource(inStream);
```

aber das will ich ja nicht. das zwischenspeichern in einem string ist gegen das sax prinzip.


----------



## FArt (5. Nov 2008)

Baue doch mal Logging ein und schau nach, was wirklich passiert. Das ist besser als Vermutungen anstellen.

Nebenbei: ist das eine Übung oder aus dem wahren Leben? Bei zweiterem stellt sich mir die Frage, warum du das Rad neu erfindest. Es gibt so viele Kommunikationprotokolle, nimm doch was fertiges...


----------

