# Reponse vom Servlet leer



## HimBromBeere (11. Jan 2013)

Malzzeit,

ich verzweifle mal wieder an einem Problem, bei welchem ich auf eure Hilfe angewiesen bin. Ich hab mir ein Servlet gebaut, welches eine DB-Anfrage durchführt und die Ergebnisse ausgibt. 


```
PrintWriter writer;
String message;
try {
	response.setCharacterEncoding("UTF-8");
	response.setContentType("text/plain");
	writer = response.getWriter();
	message = "irgend ein JSON-Objekt";
	response.setContentLength(message.getBytes().length);
	logger.debug(message);
	writer.write(message);
	writer.flush();
	writer.close();
} catch (SQLException e) {
	logger.error(e.getMessage());
	response.sendError(500, "An internal error occured due to database-problems");
} catch (IOException e) {
	logger.fatal(e.getMessage());
	response.sendError(500, "There was an error on the servers file-system which prevented him from fullfilling the request");
} catch (IllegalArgumentException e) {
	logger.error(e.getMessage());
	response.sendError(502, e.getMessage());
}
```
Funktioniert auch wunderbar, wenn ich die URL des Servlets in den Browser einhacke. Nun versuch ich, das Servlet in einer Webanwendung mittels AJAX anzusprechen (also Javascript), bekomme als Antwort auch eine schöne 200er-HTTP-Meldung, nur steht da nix mehr drin in der Antwort. Also hab ich mal serverseitig mir angschaut, was da versendet wird (darum das 
	
	
	
	





```
logger.debug
```
) und dieses als valide identifiziert. 
Nun hab ich im DragonFly nachgesehen, welche Datenpakete zum Server gehen und welche ankommen. Alle Paramater werden mittels HTTP-POST versendet, woraufhin die bereits erwähnte Antwort generiert wird und wieder beim Client landet. Dass sie auch wirklich ankommt, sehe ich anhand der Größe der empfangenden Daten sowie der vom Servlet erzeugten 
	
	
	
	





```
ContentLength
```
. Weder im DragonFly noch letzlich in der Webseite kann ich diese Daten jedoch verwenden. 
Hier mal das Skript zum Laden der Daten: 

```
reqString = "gender=Mann&reservation=&timespan=&area=&geometry=&";
		
xmlhttp.onreadystatechange = callback;
xmlhttp.open("POST", url, true);

//Send the proper header information along with the request
xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xmlhttp.setRequestHeader("Content-length", reqString.length);
xmlhttp.setRequestHeader("Connection", "close");

xmlhttp.send(reqString);
```
Das gleiche Problem tritt auf, wenn ich den POST durch ´n GET ersetze und einfach die ganzen Parameter an die URL dranhänge. So langsam gehen mir aber ehrlich gesagt die Ideen aus, woran ich noch testen soll...
Ich vermute mal, dass das ganze Thema eher eine Angelegenheit unsere Javascript-Kollegen ist und es sich aufgrund der geringen Zahl dieser Gruppe hier im Forum eher im Sande verlaufen wird, aber vlcht. gibt´s ja doch noch irgendwo einen Guru, der sich mit beiden Seiten der Web.Kommunikation auskennt und eine Vermutung hat, wo das Problem liegen könnte.


----------



## nillehammer (11. Jan 2013)

Mir fehlt in Deinem JS-Code irgendwie der Teil, der den Response verarbeitet. Laut dem Tutorial auf w3schoolz müsstest das nämlich: AJAX XMLHttpRequest Server Response


----------



## tröööt (11. Jan 2013)

einfaches simples AJAX-tutorial : Ajax Tutorial : Post to PHP File XMLHttpRequest Object Return Data Javascript - YouTube
zur not gibts noch die JQeury-lib ... finda da jetzt aber leider kein gutes tutorial


----------



## HimBromBeere (14. Jan 2013)

Danke für eure Hilfsbereitschaft.


> Mir fehlt in Deinem JS-Code irgendwie der Teil, der den Response verarbeitet.


Hab ich mir gespart, weil die offensichtlich leer ist. Das haben mir sowohl DragonFly als auch Firebug gesagt und auch wenn ich einfach per 
	
	
	
	





```
alert(response.responseText)
```
 mir die Antwort zurückgeben lasse, steht da nix. ICh schreib´s aber dennoch gerne auch noch hin:


```
function callback(response) {
	var json = JSON.parse(response.responseText);
	...
```
An Tröööts Video kann ich leider im Moment nicht zugreifen (serverrestriktionen), werd´s mir mal zu Hause ansehen...


----------



## Bleiglanz (14. Jan 2013)

```
alert(xmlhttp.responseText)
```
kommt da was?


----------



## HimBromBeere (14. Jan 2013)

Bleiglanz hat gesagt.:
			
		

> kommt da was?





			
				Himbrombeere hat gesagt.:
			
		

> wenn ich einfach per alert(response.responseText) mir die Antwort zurückgeben lasse, steht da nix


Dürfte die Frage beantworten

[EDIT]Also nix heißt in dem Fall undefined[/EDIT]


----------



## Bleiglanz (14. Jan 2013)

HimBromBeere hat gesagt.:


> Dürfte die Frage beantworten
> 
> [EDIT]Also nix heißt in dem Fall undefined[/EDIT]


Nicht direkt, ich meinte ohne callback und  JSON


----------



## HimBromBeere (14. Jan 2013)

Wenn du das etwa so meinst 

```
xmlhttp.onreadystatechange = function() {alert(xmlhttp.responseText);};
```
lautet die Antwort: die Nachrichtenbox ist vollständig leer.


----------



## Bleiglanz (15. Jan 2013)

ist wohl schwierig, wenn man davon ausgeht dass sicher was gesendet wurde


> The responseText attribute must return the result of running these steps:
> 
> If responseType is not the empty string or "text", throw an "InvalidStateError" exception and terminate these steps.
> 
> ...


ist der state wirklich LOADING oder DONE?


----------



## HimBromBeere (15. Jan 2013)

> ist der state wirklich LOADING oder DONE?


Interessanterweise nicht, den test hab ich mal rausgenommen, um zu sehen, ob dann was kommt, was natürlich nicht der Fall war. Als 
	
	
	
	





```
readyState
```
kommt immer nur ´ne 
	
	
	
	





```
1
```
 (opened) raus, obwohl ich den Request auch mittels 
	
	
	
	





```
xmlhttp.send();
```
 absende. Er kommt ja auch beim Server an, woraufhin eine Antowrt generiert und zurückgesendet wird. Der FireBug u.a. empfangen diese Antwort ja auch, denn die 
	
	
	
	





```
contentLength
```
 im responseHeader wird ja auch richtig übernommen. Aber irgendwie kann diese Antwort scheinbar nicht als solche interpretiert werden...

[EDIT]OK... zumindest readyState == 4 bekomme ich jetzt schonmal, hatte nur falsch im FireBug geschaut. Aber der 
	
	
	
	





```
xmlhttp.status
```
ist jetzt halt 0 und nicht die übliche 200. Mir wäre aber neu, dass man den Status explizit serverseitig setzen muss (also auf 200), oder doch?[/EDIT]


----------



## Bleiglanz (15. Jan 2013)

versuch mal auf Servlet-Seite response.flushBuffer();


----------



## HimBromBeere (15. Jan 2013)

So, ich hab jetzt auf der Serverseite folgendes:


```
response.setCharacterEncoding(encoding);
response.setContentType(format);
response.flushBuffer();
writer = response.getWriter();
message = "irgendein JSON-String"; 
response.setContentLength(message.getBytes().length);
logger.debug(message);
writer.write(message);
writer.flush();
writer.close();
```
Irgendeins von diesen flushes ist sicherlich eh zu viel, aber das sollte ja erstmal nicht wehtun. 
Zumindest ist das Ergebnis noch immer das selbe: 
	
	
	
	





```
readyState == 4
```
 und 
	
	
	
	





```
status == 0
```


----------



## Bleiglanz (15. Jan 2013)

flushBuffer NACH writer.close()?


----------



## HimBromBeere (15. Jan 2013)

```
response.setCharacterEncoding(encoding);
response.setContentType(format);
writer = response.getWriter();
message = this.toJSON(this.getData(dataLayer, condition.toString())).toString(); 
//response.setContentLength(message.getBytes().length);
response.setStatus(200);
logger.debug(message);
writer.write(message);
writer.flush();
writer.close();
response.flushBuffer();
```
Ergibt für mein Verständnis aber auch recht wenig Sinn. Erstens: warum sollte ich die Antwort erst übertragen, wenn der zueghörige 
	
	
	
	





```
Writer
```
längst geschlossen wurde und zweitens: die Methode 
	
	
	
	





```
flushBuffer
```
setzt natürlich einen Buffer voraus. Also muss ich den doch sicherlich irgendwo angeben, oder brauch ich gar keinen Buffer?
Wie auch immer: getestet hab ich´s trotzdem erstmal so, gebracht hat´s nix. Paradoxerweise bringt auch das Setzen des Statuscodes 
	
	
	
	





```
200
```
nichts, der state vom 
	
	
	
	





```
xmlhttp
```
-Objekt ist immer noch 
	
	
	
	





```
0
```


----------



## Bleiglanz (15. Jan 2013)

Damit ist die Phase des Herumratens vorbei 

Ich würd jetzt tatsächlich mal ein _funktionierendes_ Standardbeispiel nehmen und mit Dragonfly/FireBugs oder anderen Sniffing-Tools im Browser einen echten Unterschied zwischen deinem Code und funktionierendem Code suchen.


----------



## HimBromBeere (16. Jan 2013)

Ich muss mal ehrlich sagen, ich habe bei meiner ganzen Google-Suche nicht ein einziges Beispiel gefunden, bei welchem das 
	
	
	
	





```
flushBuffer
```
tatsächlich von Nöten gewesen wäre, da mit 
	
	
	
	





```
response.close
```
 sowieso alle enthaltenen Inhalte , die noch im Buffer sind, geschrieben werden. Da ich jedoch auch nie was in einen Buffer schreibe - wozu auch, die Datenmengen sind so gering, dass das meines Erachtens gar nicht notwendig sein sollte - sondern gleich per 
	
	
	
	





```
writer.write
```
, sollte doch die Antwort auch mit rausgehen. Das bestätigt mir ja auch der Aufruf der URL, da kommt ja das gewünschte Resultat, nur halt nicht per Aufruf im Skript...
In den Standardbeispielen (z.B. hier) wird zudem nichts anderes gemacht...


----------



## Bleiglanz (16. Jan 2013)

ja eben, das Problem liegt höchstwahrscheinlich beim Client, im Browser: du sagst ja selbst, dass die Daten dort ankommen...


----------

