# Webservice und Bilder



## Robokopp (29. Nov 2012)

Also ich hab jetzt einen funktionsfähigen Server, der mir über Suchanfragen Objekte aus meiner Datenbank holt und als JSON zurückgibt.

Die Objekte sind Modelle, die man sich ähnlich wie eine Pinnwand in FB vorstellen kann (nein, es soll kein Facebookklone werden), d.h. sie sollen Bilder enthalten.

Da ich als Datenbank db4o verwende, dürfte es eigentlich kein Problem sein, Bilder direkt mit in diese Pinnwände hineinzulegen.

Mir stellt sich nur die Frage, wie ich die am besten übertrage.

Die erste Option wäre, sie direkt mit zu übertragen im JSON String als Bytearray. Ob das so klug ist weiß ich nicht.

Die zweite Option wäre, nur die Links zu den Bildern zu übermitteln, und sie dann im Clienten nachträglich zu laden. So oder so ähnlich läuft das ja mit Webseiten ab, da ist auch nur der Link zu den Bildern im HTML Code hinterlegt.

Nur weiß ich nicht, wie ich die Bilder verwalten soll. Bräuchte ich hierfür einen zweiten Server oder würde es nichts ausmachen, alles über ein und den selben Server abzuwickeln.

Wie schaffe ich Zuordnungen, so dass jedes Bild einen eindeutigen Link hat?

Würde mich über konstruktiven Rat freuen


----------



## TKausL (29. Nov 2012)

Ich würde zum abrufen entweder HTTP verwenden (Also einen Apache-Server nachinstallieren) oder aber die Arbeitsweise von HTML und dem HTT-Protokoll nachbauen. D.H. dein JSON enthällt nur eine eindeutige ID zu dem Bild. Wenn er das Bild nicht bereits geladen hat kann er unter dieser ID das Bild vom Server abrufen.


----------



## Robokopp (30. Nov 2012)

Okay und wie stelle ich dann eine Verbindung zwischen Apache und meinem Server her?Kann ich dann einfach Bilder per FTP übertragen oder kann ich den sogar mit meiner Datenbank verknüpfen?

Sry für die vlt dämlichen Fragen, hatte mit dem ganzen Webzeugs nie wirklich was am Hut^^


----------



## TKausL (30. Nov 2012)

Warum sollte dein Server eine Verbindung mit Apache herstellen? Dein Server sendet im JSON nur mit, dass das Bild 123.jpg existiert und der Client läd dieses dann selbst nach (wie der Browser). Dein Server muss dann natürlich wissen, dass dieses Bild existiert.


----------



## Robokopp (30. Nov 2012)

Weil beispielsweise auch neue Profile angelegt werden können und dazu muss ich irgendwie Bilder auf den Apache bringen, gleichzeitig davon Dann die links abfragen und in den Profilen meiner dB speichern


----------



## TKausL (30. Nov 2012)

Ähm ich habe glaube ich noch garnicht gefragt wie dein Server überhaupt funktioniert. Was genau ist der Client?


----------



## Robokopp (30. Nov 2012)

Den Client gibt es noch nicht. Ich befasse mich erstmal mit dem Server. Es soll aber mal eine Website und eine Android app als Clienten geben.

Zur Funktion an sich kann man sagen, dass einfach suchanfragen verarbeitet werden und entsprechende datenbankeinträge zurück gegeben werden in Form von json strings


Achso, die Kommunikation erfolgt über http,also einfache get requests


----------



## TKausL (30. Nov 2012)

Irgendwie muss der Browser ja wissen, was er mit dem JSON tun soll. AJAX?

Wenn du bereits mit HTTP arbeitest sollte das Bereitstellen von Bildern ja auch zu machen sein. Wenn ein Bild angefordert wird einfach nachsehen ob es existiert und dann senden?!


----------



## Robokopp (30. Nov 2012)

Er gibt es als Text aus, aber der Browser spielt doch in meinem Fall überhaupt keine Rolle. Mir geht es zur zeit um den Server. 

Ja klar, aber wenn ich jetzt nen Apache nehme muss der ja irgendwie mit den Daten meines eigentlichen Servers abgeglichen werden.


----------



## TKausL (30. Nov 2012)

Wenn dein Server doch bereits ein HTTP-Server ist sendest du entweder die Bilder auch über deinen Server oder du installierst einen Apache und schreibst dein JSON-Sender in PHP o.ä.


----------



## trääät (30. Nov 2012)

@TO

der client kann dir jetzt in diesem moment nur egal sein wenn du vorhast später eh einen eigenen zu nutzen ...

da du aber schon selbst gesagt hast das geplant ist zusätzlich zum eigenen android-app-clienten auch normal über den browser gehen zu können musst du deine server-architektur bereits jetzt entsprechend darauf anpassen und so entwickeln das es mit einem normalen browser funktioniert ...
ansonsten darfst du später mit unter fast alles komplett neu schreiben ...

eine genaue lösung kann ich dir so auch nicht nennen da ich mich mit JSON und DB4O nicht auskenne ... aber es wäre einfacher alles einfach im backend mit php zusammenzuzimmern ... dann ne ordentlich MySQL-db dran zu hängen .. und ganz normal über n browser zu arbeiten ...

wenn du da erst noch mit komplexen objekten rumhandtieren willst und es egal ist wie ein browser dann nachher damit umgehen soll und du dir DANN erst den plan machst um den browser an dein system zu hängen wird das weit aufwändiger als wenn du deine server-architektur gleich so schreibst das es passt ...


----------



## Robokopp (30. Nov 2012)

Eben nicht, weil es einfach nur ein Webservice für die datenbankanbindung ist der suchantworten als json zurück gibt. Ich will darauf keine Webseite aufbauen!


----------



## TKausL (30. Nov 2012)

Ohne Webseite wird der Browser aber nicht wissen, was er mit dem JSON-String soll


----------



## Robokopp (30. Nov 2012)

Ok um das jetzt ein für alle mal klar zu stellen, es geht hier NICHT um den Browser, der Output kann hier (quasi) egal sein! 

Mein Server gibt schon Json Strings zurück. Wie ich sie dann später interpretiere (und das ist überhaupt kein Problem!) spielt hier keine Rolle.


Mir ging es lediglich um die Handhabung von Daten in Textform und Bildern.


----------



## TKausL (30. Nov 2012)

Robokopp hat gesagt.:


> Mir ging es lediglich um die Handhabung von Daten in Textform und Bildern.



Ich verstehe nicht dein Problem. Du sagst DEIN Server ist ein HTTP-Server. Wo ist dann das Problem, auch Bildmaterial über diesen zu senden?


----------



## trääät (30. Nov 2012)

ich wiederhol mal meinen vor-poster : nur einfach mit einem JSON-string wird ein browser nicht viel anfangen können ... ergo müsstest du client-seitig ne engine haben die da was gescheites draus macht ...
und wenn dieser punkt feststeht ... du also an dein system definitiv einen browser koppeln willst ... solltest du dir dafür auf jeden fall JETZT gedanken machen ... und wenn du dann deinen clienten hast kannst du darauf aufbauend den server zusammenbasteln ...

client-server anwendungen zu entwerfen ist nicht so einfach wie das man schlicht irgendwelche technologien wild zusammen würfelt und daraus versucht was umzusetzen ... man sollte sich schon mal einen gewissen plan machen


----------



## Robokopp (1. Dez 2012)

Kann ich nicht einfach in PHP die JSON Strings genauso verarbeiten wie ich es mit Java kann?Falls das geht, versteh ich nicht ganz was ihr mir sagen wollt?
Mir ist schon klar, dass aus dem JSON String keine Webseite entsteht, und das wird und soll sie auch nicht.Hab ich auch nie behauptet. Es wird irgendwann mal eine Webseite geben, die sich den selben Webservice zu nutze macht, wie es die App tun wird.


----------



## trääät (1. Dez 2012)

sorry ... aber ich glaube wir reden bei dir gegen ne wand ...

deine aussagen :

-du hast n web-server der im backend irgendwas mit JSON abarbeitet
-es soll irgendne android-app geben die mit diesem dienst eben über JSON kommuniziert
-es soll zusätzlich eine über einen normalen browser ansprechebare website geben ...


folgerung daraus : du brauchst ein client-framework für den browser das den JSON-string des servers in eine halbwegs sinnvolle website umformt ...

logisch wäre nun eben damit zu beginnen und dann die app und den server durch dadurch notwendige anpassungen / optimierungen auszurichten ... als jetzt erst deinen server und deine app soweit fertig zu basteln und dann alles neu schreiben zu müssen um das einfachste was web-browser und -server miteinander verbindet ... nämlich HTTP normal nutzen zu können ...


anders ausgedrückt : wir verstehen dein problem nicht ... wenn du schon einen ganz stinknormalen webserver hast der über HTTP vorwiegen HTML-seiten ausliefert ... wo ist es dann überhaupt die frage wie du nachher vom webserver bilder an den webbrowser überträgst ?

alles was der webbroweser dafür braucht ist ein link zu ner resource auf dem server ...
ob du diesen über php im backend generierst oder über AJAX im client zusammenbaust und die resource dann physisch vorhanden ist oder in einer datenbank in einem web-üblichen format liegt und du diese durch einfaches auslesen und senden dem browser zugänglich machst ist völlig egal ...


oder auf den punkt gebracht : eigentlich wäre der gesamte thread unnötig gewesen wenn du vorher mal bisschen gegooglet hättest ... denn ich wette es gibt bereits fertige beispiele für das was du machen willst ...

warum du jetzt in nem java-forum fragst versteh ich irgenwie nicht


----------



## Robokopp (1. Dez 2012)

> warum du jetzt in nem java-forum fragst versteh ich irgenwie nicht



War die logische Schlussfolgerung bei einem in Java implementierten Server




> alles was der webbroweser dafür braucht ist ein link zu ner resource auf dem server ...



Und genau da liegt mein Problem, weshalb ich überhaupt diesen Thread geöffnet habe.
Bei mir gibt es kein "auf dem server", weil ich alles was mir der Server als Antwort gibt direkt aus einer Objektdatenbank beziehe.
Wie soll ich da irgendwelche Resourcen verlinken? Daher meine Frage, ob

1.Ein zweiter Server, nur für die Bilder

oder

2.Die Bilder direkt mitschicken

oder

3.Links zu Bildern, die in der Datenbank liegen mitschicken.


Hätte ich eine Ordnerhierarchie wie bei einem richtigen Webserver, dann hätte ich Pfade zu irgendwelchen Bildern, und die Frage würde sich erübrigen.In meinem Fall ist mir das allerdings nicht klar.




> oder auf den punkt gebracht : eigentlich wäre der gesamte thread unnötig gewesen wenn du vorher mal bisschen gegooglet hättest ... denn ich wette es gibt bereits fertige beispiele für das was du machen willst ...




Danke für deinen geistreichen Ratschlag


----------



## TKausL (1. Dez 2012)

Robokopp hat gesagt.:


> Und genau da liegt mein Problem, weshalb ich überhaupt diesen Thread geöffnet habe.
> Bei mir gibt es kein "auf dem server", weil ich alles was mir der Server als Antwort gibt direkt aus einer Objektdatenbank beziehe.
> Wie soll ich da irgendwelche Resourcen verlinken?



Du sagst du hast eine WEB/HTTP-Server. Dieser Empfängt POST/GET Requests. Ich verstehe immernoch nicht dein Problem dabei, die Requests zu unterscheiden zwischen Bild und Datenabfrage (JSON)...

BTW: Dein ganzes vorhaben ist in PHP mit Sicherheit 100 mal einfacher umzusetzen. Ja, PHP kann MySQL und Ja, PHP kann JSON. Denn genau dafür ist JSON (unter anderem) gemacht. Um Java-Script durch AJAX Aufrufen ohne Probleme eine Masse an Daten zu senden, ohne diese in JS nach dem empfangen mühselig entschlüsseln zu müssen. Und welche andere Sprache außer PHP wäre besser geeignet, diese (dynamischen) Daten für JS bereitzustellen?


----------



## trääät (1. Dez 2012)

ich glaub so langsam rall ich das problem

du verwendest also KEINEN normalen standard web-server ala Apache sondern hast dir irgendwas selbst zusammengebastelt und schickst die antwort dierekt als JSON raus ...
ist ja soweit noch kein problem ... nur brauchst du dann client-seitig zumindest für den normalen webbrowser eine engine die dann mit dem JSON auch was anfangen kann ...
da es ja möglich ist bilder direkt als base64 mit zuschicken (sieht dann glaub so aus : <img src="base64:abcdef..." />) ist das ja soweit kein problem ... dann lässt du dir das halt von deiner client-engine zusammenbauen ...

was jetzt vermutlich dein problem sein dürfte ist eher die unterscheidung zwischen deinem eigenen clienten und nem browser ... den dem musst du halt die komplette seite mit samt engine erstmal schicken bevor er was mit dem JSON was anfangen kann ... und das HTTP-konform umzusetzen musst du selbst schreiben ...
deiner app kanns ja egal sein weil die sich aus den JSON-daten alles zusammen baut .. incl der bilder selbst (das sollte mit ner helper-klasse machbar sein)

ich hoffe ich hab das jetzt soweit gerallt ...

ich würde dir dabei wirklich empfehlen : implementier deine server-logik lieber in PHP ... anstatt zu versuchen in java selbst irgendwas zwischen nem web- und app-server zu basteln ...

und wenn es unbedingt JAVA sein muss ... dann nimm dir gleich n application server ... da kannst du gemütlich in java schreiben und musst dich um sowas wie mal eben ne html-seite ausliefern keine gedanken machen ...


oder habe ich jetzt irgenwas an deinem problem irgendwie immer noch nicht gerallt ... weil ganz erlich : dann verstehe ich dich einfach nicht und du müsstest mal versuchen es in einer mir verständlichen art und weise zu erklären


----------



## Robokopp (1. Dez 2012)

> du verwendest also KEINEN normalen standard web-server ala Apache sondern hast dir irgendwas selbst zusammengebastelt und schickst die antwort dierekt als JSON raus ...



Erfasst



> ist ja soweit noch kein problem ... nur brauchst du dann client-seitig zumindest für den normalen webbrowser eine engine die dann mit dem JSON auch was anfangen kann ...
> da es ja möglich ist bilder direkt als base64 mit zuschicken (sieht dann glaub so aus : <img src="base64:abcdef..." />) ist das ja soweit kein problem ... dann lässt du dir das halt von deiner client-engine zusammenbauen ...




Kein Problem das umzusetzen, und genau so war es auch geplant

Das mit dem Bild direkt mitschicken als base64 war das was ich gemeint hab mit "Bild direkt mitschicken", es war die 1. Option, die ich in Betracht gezogen hatte.




```
was jetzt vermutlich dein problem sein dürfte ist eher die unterscheidung zwischen deinem eigenen clienten und nem browser ... den dem musst du halt die komplette seite mit samt engine erstmal schicken bevor er was mit dem JSON was anfangen kann ... und das HTTP-konform umzusetzen musst du selbst schreiben ...
deiner app kanns ja egal sein weil die sich aus den JSON-daten alles zusammen baut .. incl der bilder selbst (das sollte mit ner helper-klasse machbar sein)
```

Nö, schon wieder falsch verstanden.

Die API von der ich die ganze Zeit rede ist nicht dafür gedacht, per Browser aufgerufen zu werden. Es ist einfach nur ein Webservice zu meinem Datenbankserver, der halt über http zugänglich ist.

Deswegen werde ich auch sicherlich keine Engine mitschicken(wtf??)
Wenn das vom Browser aufgerufen wird, sieht der Aufrufer eben einen JSON String - pech gehabt. Vlt mache ich noch eine Art Authorization, damit die Datenbank nur über eine bestimmte Webseite und eben meine App aufgerufen werden kann und nicht durch x beliebige Nutzer per Browser





> ich würde dir dabei wirklich empfehlen : implementier deine server-logik lieber in PHP ... anstatt zu versuchen in java selbst irgendwas zwischen nem web- und app-server zu basteln ...



Wenn dann eine Mischung aus Datenbankserver + Webserver extra für die Bilder.
Was macht es für einen Sinn, wenn ich die Serverlogik in PHP schreibe? 
Ich hab den Server schon in Java geschrieben und er tut genau das was er soll, nur (um nochmal auf das eigentliche Thema zurück zu kommen, was nicht die Interpretation des JSON Strings ist) weiß ich nicht wie ich es am geschicktesten mit den Bildern handhaben soll.




> und wenn es unbedingt JAVA sein muss ... dann nimm dir gleich n application server ... da kannst du gemütlich in java schreiben und musst dich um sowas wie mal eben ne html-seite ausliefern keine gedanken machen ...



Da fängt es doch schon wieder an! Kannst du bitte einfach mal aufhören von  HTML Seiten zu reden? Darum geht es hier überhaupt nicht!! Das schreib ich jetzt schon zum gefühlten 50. mal

Es ist nur eine Schnittstelle.

Ein Beispiel, damit du ungefähr mal weißt um was es geht und ich es nicht nochmal schreiben muss

http://www.openthesaurus.de/synonyme/search?q=test&format=application/json

Eine Suchanfrage mit Rückgabe in JSON

Mehr ist es nicht und es soll auch nie eine Webseite werden und auch nicht irgendeine in PHP geschriebene Engine, die auf dem Zielbrowser läuft und den JSON String interpretiert!


Die Daten werden über meinen eigenen Server aus einer Datenbank geholt


Die Daten liegen in Objektform vor


ein Objekt sieht so aus (ist nur ein vereinfachtes Beispiel):



```
public class Pinnwand{
private String name;
private int alter;
private Image profilbild;
private Fotoalbum album;
}
```


```
public class Fotoalbum{
private ArrayList<Image> fotos;

}
```

GSON wandelt Objekte in JSON Strings über die toString() Methode des Objektes.

In meinem Fall kann ich also entscheiden zwischen "geb mir einfach nur name und alter", geb mir "name alter ein base64 kodiertes Profilbild und meinetwegen noch alle Fotos aus dem Fotoalbum"

Es besteht also erstmal garnicht die Möglichkeit, über eine sepparate Anfrage nur auf die Bilder zuzugreifen, da sie mit im Pinnwandobjekt gekapselt sind.

Die query Anfragen bei Db4o verlaufen so, dass man ein "Beispielobjekt" erzeugt und die Datenbank dann prüft, ob es ein Objekt gibt, dass Gleichheiten bei Parametern vorweist.



So jetzt nochmal zu den anderen Möglichkeiten, neben der die Bilder direkt im JSON String mitzuschicken!

1.Links in der Pinnwand statt Fotos hinterlegen, die auf Bilder in einem zweiten Server, der NUR für die Bilder zuständig ist zeigen.(Das halte ich selbst für unklug, da man immer dafür sorgen muss, dass die URL´s zu den richtigen Bildern passen)

2.Links in der Pinnwand statt Fotos hinterlegen, die auf Bilder im selben Server (mein Datenbankserver) verweisen.
(da stellt sich mir die Frage, wie ich per Link auf Fotos in meiner Objektdatenbank verweise)

Die einzige Möglichkeit die ich zur Zeit sehe, wäre für jedes Bild ein eigenes Objekt mit einer ID anzulegen, und dann die ID´s per JSON mitzugeben, anstatt irgendwelcher Links.



Ich hoffe das war jetzt verständlich genug.
Falls nicht weiß ich nicht weiter, denn ausführlicher kann ich es nicht beschreiben 



Und nochmal:

Es geht nicht um HTML Webseiten, Applikationsserver und sowas


----------



## TKausL (1. Dez 2012)

Robokopp hat gesagt.:


> (da stellt sich mir die Frage, wie ich per Link auf Fotos in meiner Objektdatenbank verweise)



Das ist doch DEINE Sache wie du das Tust. Wenn du deinen Server selbst schreibst kannst du es machen wie du willst. z.B. sendest du im JSON nur "Image":"image/12345.jpg", wobei der Client erkennen muss dass dort eine Image-URL vorliegt, unter dieser beim Server nach dem Bild nachfragt und der Server wiederum weiß wo genau dieses Bild liegt.

Damit der Server selbst alle Daten hat die er benötigt musst du beim Upload sorgen. Also beim Upload die Bilder in Ordner xyz laden, in der DB dann beim User den Pfad zum hochgeladenen IMG vermerken und schon weiß der Server wem welches Bild gehört.


----------



## Robokopp (2. Dez 2012)

Ja okay klar, aber das ginge eben nur wenn ich eigene Imageobjekte in der DB hätte, nach denen ich auch suchen kann.

So werde ich es auf jeden Fall mal versuchen.

Mir ging es eben um die Sache mit dem http: link, aber da das so eh nicht möglich ist bei der Datenbank muss ich wohl über ID´s gehen


----------



## trääät (2. Dez 2012)

> Kannst du bitte einfach mal aufhören von HTML Seiten zu reden?


ja .. würde ich gerne .. und hätte ich auch schon längst getan wenn du folgende info mal früher rausgerückt hättest


> Die API von der ich die ganze Zeit rede ist nicht dafür gedacht, per Browser aufgerufen zu werden. Es ist einfach nur ein Webservice zu meinem Datenbankserver, der halt über http zugänglich ist [...] Wenn das vom Browser aufgerufen wird, sieht der Aufrufer eben einen JSON String - pech gehabt


genau diese info war das was wir scheinbar nicht gerallt haben ... weil du es eben so nicht erklärt hast ... und erlich : es kommt auch in keinem deiner posts irgendwie ansatzweise raus das man auf sowas kommen könnte ...

durch den post der jetzt endlich mal wirklich klare angaben liefert weis ich auch endlich was sache ist und was du überhaupt umsetzen willst und wo da vielleicht dein problem sein könnte ...

und JETZT können wir beide vielleicht anfangen MIT einander zu reden anstatt AN UNS VORBEI ...

also versuche ich jetzt mal auf grund der jetzigen infos das problem zu erfassen und darauf einzugehen ...

es geht halt darum das du mit irgendeiner API eine verbindung zwischen einer datenbank über einen von dir selbstgeschriebenen ... ich nenn es trotzdem mal app-server ... und irgendeiner art und weise von client ...
die kommunikation selbst findet über JSON-strings statt mit denen sowohl server als auch client was anfangen können ...
deine frage zielte nun darauf ab wie man am besten bilder innerhalb eines "profiles" hinterlegt und diese überträgt ...

darfür würden mir spontan zwei ideen kommen

1) alles zusammen in einem riesigen object speichern und dieses dann so wie es ist aus der datenbank über json direkt an den client übertragen der sich daraus die anzeige zusammenbastelt

2) meta-verweise und getrennte objekte ...
bedeudet : du hast nicht alles in einem objekt sondern hast im profile-objekt nur eine id zu z.b. einem profil-bild-objekt ...
diese id liest dein client aus und sendet wiederum eine anfrage an den server und verlangt dieses mal nur dieses bild-objekt ... lässt es sich in irgendeiner sicheren kodierung schicken ... und bastelt es selbst in die anzeige ein ...

frage hier natürlich : unterstützt deine API auch die anfrage nach einzelnen objekten oder nur kompletten objekt-sätzen ?

was jetzt den upload und die verwaltung angeht : das muss dann halt der client machen ... und der hat halt dafür zu sorgen das dem server alle wichtigen daten in entsprechender weise gesendet werden ...
wenn man das ganze in einem objekt macht ist das ziemlich simple ... wenns mit getrennten objekten und meta-verweisen geschiet ist es nur in so fern aufwändiger das man halt nach dem upload und einfügen in die datenbank innerhalb der objekte die verweise mit den richtigen id's belegen muss wofür man in der regel auch keine objekt-datenbank nutzt sondern eher sowas wie MySQL und dort in einer zu-ordnungs-tabelle dann die verweise einträgt ...

habe ich da jetzt immer noch was falsch verstanden ? wenn ja dann sags bitte und erklär es ... und klemm dir bitte solche sprüche wie ob ich bitte mit etwas aufhören könnte obwohl mir nicht klar ist das du es so garnicht willst weil ich bisher von ausgegangen bin eben das du es willst ...
ich bin auch nur n mensch ... und wenn ich nicht mit passenden infos versorgt werde und daher auf n falsch tritt komme ... mir man das aber nicht so klar sagt wie du es jetzt endlich mal gemacht hast ... dann soll man sich darüber auch bitte nicht aufregen eben das ich es falsch verstehe


----------



## Robokopp (4. Dez 2012)

So. Ich hab das jetzt erstmal so umgesetzt, das quasi ein Bild, und zwar das Profil Bild direkt mitgeladen wird. Dann habe ich testweise mal 20 Datensätze angefragt und in einem provisorischen Clienten die Bilder raus geholt. Abgesehen davon dass es sehr langsam ist,  waren die Bilder hin und wieder an manchen stellen verzerrt  aber auch nur dann wenn er voll ausgelastet war

Als ich dann mal getestet habe, wie viele Anfragen er aushält musste ich feststellen dass bei 10-15/s (immer 20 Profile auf einmal) Schluss ist, sofern Bilder mit drin sind. Frage ich nur Objekte an in denen kein Bild hinterlegt ist, dass gibt es da keine Probleme und es geht alles sehr flott. 

Mir stellt sich langsam die frage, ob die Kombination überhaupt dafür geeignet ist. 
Möglicherweise sollte ich doch irgendwie komplett auf einen Apache umsatteln


----------



## JohannisderKaeufer (4. Dez 2012)

Das Web, HTML und so hat schon bestimmt über 20 Jahre Bestand. Daher gibt es bestimmt auch Gründe, wieso Bilder eher verlinkt, als eingebettet werden.

Bei Emails hingegen werden Dateianhänge zwar nicht eingebettet, aber angehangen was einem Einbetten gleichkommt. Hier hat man aber auch andere Anforderungen. Die wichtigste ist, daß man alles am Stück haben möchte.


Daher würde ich immer mal ein Auge darauf werfen, wie dort die Dinge gelöst wurden um das Rad nicht ständig neu zu erfinden.



Aber jetzt konkret zum Thema.
Bilder in einer Datenbank speichern halte ich per se für nicht sehr zielführend. Dafür gibt es mehrere Gründe.
Datenbank und Bilder sind damit erstmal fest auf einem Server. 
Ein einzelner Datenbankeintrag wird unnötig groß (Dateigröße - Speicherplatz).
IMHO lädt ein Dateisystem performanter Bilder/Dateien als eine DB.
Die Datenbank speichert die Bilder evtl. anders, so daß noch ein zusätzliches encoding (Base64) hinzukommt.


Wenn Bilder eingebettet werden, bringt dies weitere Nachteile.
Bilder können nicht mehr gecacht werden, außer es wird explizit verlangt eine bilderlose antwort zu liefern. 
Bei Browsern, gibt es auch exemplare, die keine Bilder anzeigen können oder wollen. Diese müßten explizit nach einer Bilderlosen Antwort fragen, was Serverseitig zu mehr komplexität führt.
Taucht ein Bild, mehrfach in einer Antwort auf, wird es auch mehrfach übertragen.
Dies könnte z.B. bei einem "Anonymen"- Profilbild (Gesicht mit Fragezeichen) der Fall sein.


Um nun Bilder separat auszuliefern, könnte ich mir folgendes vorstellen.
Die Bilder werden nicht in der DB sondern in einem Ordner abgelegt.
Ein Apache-Server oder nginx, nimmt alle Anfragen entgegen.
Ist die Anfrage "/jsonapi/..." fungiert der Apache als Proxy und leitet die Anfrage an deinen Server weiter.
Ist die Anfrage "/bilder/Dateiname.jpg" nutzt der Apache seine Dateiserverqualitäten und liefert das entsprechende Bild aus.

Wenn das Projekt dann später einmal wachsen sollte, kann man sich auch überlegen ob man sowas wie Amazon S3 oder ein anderes CDN nutzt um die Bilder dann dort abzulegen und von dort auch auszuliefern. 
Dein Server würde dann nur noch das json generieren und auf eine URL bei Amazon verweisen, die sich dann um das ausliefern der Bilder kümmern.

Andererseits könnte sich auch deine Clientsoftware überlegen, ob sie das Bild überhaupt benötigt oder ob sie was passendes im Cache hat.


----------



## Robokopp (5. Dez 2012)

Danke für die Infos

Mal angenommen ich würde es wirklich so umsetzen wie du sagst, dann müsste ich quasi ein Skript in PHP schreiben, was erstmal die URL auswertet und dann ggf auf den Javaserver weiterleitet. Wie setzt man so eine Weiterleitung bzw die Kommunikation zwischen zwei Servern in meinem Fall um?Könnte man die JSON API beibehalten, und dann einfach mittels des PHP Skripts Request Anfragen im Localhost (Sofern sich beide Server auf dem selben Rechner befinden) an den anderen Server schicken?


Weil dann müsste das Skript gar nicht so viel können. Eben nur unterscheiden zwischen Datenbankabfrage oder Bildabfrage und Ergebnis zurückgeben und ich könnte sogar meinen Javaserver fast so lassen wie bisher (gut, bis auf das speichern der URL´s zu den Bildern)


----------



## JohannisderKaeufer (7. Dez 2012)

Also ich hab hier mal ein kleines Beispiel mit einem Jetty Jetty ? Wikipedia


```
package webservicemitbildern;

import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.DefaultHandler;
import org.eclipse.jetty.server.handler.HandlerList;
import org.eclipse.jetty.server.handler.ResourceHandler;
import org.eclipse.jetty.server.nio.SelectChannelConnector;

/**
 * Created with IntelliJ IDEA.
 * Date: 07.12.12
 * Time: 09:10
 * To change this template use File | Settings | File Templates.
 */
public class FileServer {

    public static void main(String[] args) throws Exception {
        Server server = new Server();

        SelectChannelConnector connector = new SelectChannelConnector();

        connector.setPort(8081);
        server.addConnector(connector);

        ResourceHandler resourceHandler = new ResourceHandler();
        resourceHandler.setDirectoriesListed(true);
        resourceHandler.setResourceBase(System.getProperty("user.home")+"/Pictures");

        HandlerList handlers = new HandlerList();
        handlers.setHandlers(new Handler[]{resourceHandler, new DefaultHandler()});
        server.setHandler(handlers);

        server.start();
        server.join();
    }
}
```

Das wäre ein Fileserver der die Bilder bereitstellt. und auf dem post 8081 läuft.
Wenn das Bild als 1.png im Home-Verzeichnis im Ordner Pictures vorhanden ist, 
dann liefert 

```
http://localhost:8081/1.png
```
 das Bild zurück.

Auf dem gleichen Rechner würde nun auch dein json-Server laufen mit Port 8080
Dieser gibt nun zum Beispiel zurück

```
{image: "/image/1.png"}
```


Nun wird vor beide Server ein Proxy geschaltet der z.B. auf den Port 80 oder hier im Beispiel auf den Port 8000 hört.
Eine Anfrage 

```
http://localhost:8000/image/1.png
```
 wird dann intern weitergeleitet zu

```
http://localhost:8081/1.png
```

Eine Anfrage 

```
http://localhost:8000/sonstwas
```
 wird dann intern weitergeleitet zu

```
http://localhost:8080/sonstwas
```


Der entsprechende Proxy in Java würde dann so aussehen

```
package webservicemitbildern;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created with IntelliJ IDEA.
 * Date: 07.12.12
 * Time: 10:24
 * To change this template use File | Settings | File Templates.
 */
public class Proxy {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8000);
        while (true) {
            final Socket socket = serverSocket.accept();
            new Thread(new Runnable() {
                public void run() {
                    try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        String line = reader.readLine();
                        if (line.startsWith("GET /image/")) {
                            Socket client = new Socket("localhost", 8081);

                            PrintWriter writer = new PrintWriter(client.getOutputStream());
                            writer.println(line.replace("/image", ""));
                            while (reader.ready()) {
                                writer.println(reader.readLine());
                            }
                            writer.println();
                            writer.flush();

                            OutputStream outputStream = socket.getOutputStream();
                            byte[] array = new byte[4096];
                            while (client.getInputStream().read(array) != -1) {
                                outputStream.write(array);

                            }

                            outputStream.flush();
                            outputStream.close();

                            client.close();
                        } else {
                            Socket client = new Socket("localhost", 8080);
                            PrintWriter writer = new PrintWriter(client.getOutputStream());
                            writer.println(line);
                            while (reader.ready()) {
                                writer.println(reader.readLine());
                            }
                            writer.println();
                            writer.flush();
                            OutputStream outputStream = socket.getOutputStream();
                            byte[] array = new byte[4096];
                            while (client.getInputStream().read(array) != -1) {
                                outputStream.write(array);

                            }
                            outputStream.flush();
                            outputStream.close();

                            client.close();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }
}
```

Ein Apache-Webserver kann das auch. Dafür benötigt es lediglich etwas konfiguration. Stichwort hierzu mod_proxy.
Ein Apache kann auch als Fileserver dienen.
Und er kann sogar beides gleichzeitig und effizient.

PHP braucht es nicht.


----------



## Robokopp (7. Dez 2012)

Danke für die Mühe, so hab ich mir das in etwa vorgestellt, nur dass ich es wahrscheinlich wirklich so bewerkstellige, alles über PHP zu managen, welches gleich auf dem "Imageserver" läuft, denn so spar ich mir dann den eigenen Proxyserver.

So muss ich nämlich nur entweder das Bild picken vom selben Server, oder die Anfrage weiterleiten an den Datenbankserver.

dabei verwende ich dann einfach URL Tags: search? für die reine Datenbankanfrage bzw eben einfach eine Imageurl. Weiß nicht ob es nicht einfach reicht zu prüfen ob die URL search? enthält ->db Server, oder wenn nicht img Server.Wenn die url ungültig ist sollte es in etwa sowieso egal sein


----------

