Natürlich will man aber, dass auch der Inhalt in der Webapplikation (welcher normalerweise dynamisch kreiert und angezeigt wird) in den Suchergebnissen der Suchmaschinenanbieter auftaucht. Um dies zu berwerkstelligen, hat Google den Google Ajax Crawling Guide für Entwickler von AJAX-basierten Webapplikation bereitgestellt.
Schritt 1: Ajax crawling scheme
Vorbereitend muss man sicherstellen, dass die Webapplikation das "AJAX crawling scheme" unterstützt. Dieses Schema besagt folgendes: Alle URL Parameter (=hash fragments) dürfen erst nach der Zeichenfolge #! auftauchen. Das heisst für eine URL:
www.example.com/myapp#parameter wird zu www.example.com/myapp#!parameterStandardmässig unterstützt eine EclipseRAP-Anwendung keine Links mit URL-Parametern.
Dies kann jedoch mit Hilfe der RWT BrowserHistory sehr einfach eingebaut werden,indem man einen Call ähnlich zu folgendem aufruft:
RWT.getBrowserHistory().createEntry( "!mystate", "Example" ); Dieser Aufruf fügt einen neuen Eintrag in die History des Browsers ein. Der Eintrag wird die folgende URL haben:
(Achtung das #-Zeichen wird automatisch eingefügt. Das ist auch richtig so.)example.com/myapp#!mystate Um für Links dieser Form auch den richtigen (dynamisch erzeugten) Inhalt zu liefern, muss noch ein BrowserHistoryListener registriert werden, welcher Änderungen in der URL abfängt und entsprechend behandelt, indem er den gewünschten Inhalt dynamisch erzeugt und im RAP Webapp anzeigt. Der Listener sollte so ähnlich aussehen:
RWT.getBrowserHistory().addBrowserHistoryListener( new BrowserHistoryListener() {
public void navigated( BrowserHistoryEvent event ) {
// show state represented by event.entryId
}
} )
; In der navigated()-Methode des Listeners kann man dann herausfinden, welche Parameter in der URL angegeben wurden, und den diesen Parametern entsprechenden Inhalt in der Webapplikation anzeigen. Auf diese Weise kann man auch "Deep links" für das Webapp zur Verfügung stellen. Ein User der eine URL der Webapp direkt mit einem Parameter aufruft, bekommt direkt die Ansicht, die er möchte.
Schritt 2: Inhalt als lesbaren HTML-Code darstellen
Nun muss man eine Version der Webapp-Seiten generieren, welche in HTML-Code dargestellt sind, damit der Crawling Bot sie lesen und nach Inhalt durchsuchen kann. Diese HTML-Dokumente nennt man auch "HTML-Snapshots", da sie im Grunde eine Momentaufnahme der Webapplikation in Form von HTML darstellen.
Im Crawling Guide von Google wird hier die Verwendung eines "headless HTML-Browser" für Java vorgeschlagen (siehe: hier).
Wem die Verwendung von dieser Methode nicht zusagt, kann das Erzeugen der HTML-Snapshots selbst in die Hand nehmen. Dabei erzeugt man für jeden möglichen Inhalt der Webapplikation (welcher dynamisch ändern kann) eine eigene HTML-Seite z.B. direkt aus Java heraus und legt Sie im Filesystem des Webservers ab.
Schritt 3: Crawler erkennen und mit den HTML-Dokumenten füttern.
Die Strategie ist wie folgt: Unser System muss die HTTP-Anfragen abfangen, und erkennen, ob es sich bei dem "Besucher" um einen realen User handelt oder um einen Google Crawling Roboter. Die wichtige Frage ist: Woran erkenne ich eine Abfrage des Google Crawling Roboter? Die hier gennante Antwort findet man im Google AJAX Crawling Guide. Man erkennt den Crawling Bot daran, dass in der URL des HTTP-Requests das Fragment #! durch das Fragment _escaped_fragment_= ersetzt wird. Bsp:
Normale Anfrage: example.com/myapp#!mystate
Crawling Bot Anfrage: example.com/myapp_escaped_fragment_=mystate
Um den Google-Bot abzufangen sollte man einen Servlet-Filter schreiben, welches alle Anfragen auf die URL der Webapplikation abfängt und nach dem escaped-fragment des Bots sucht. Das Servlet sollte auf dem produktiven Webserver laufen, auf dem auch die Webapplikation läuft (man kann das Servlet auch direkt in das selbe WAR-File exportieren wie die Webapplikation). Im web.xml File der Webapplikation muss man auch den Servlet-Filter angeben und auf die gewünschte URL ansetzen.
Der Servlet-Filter kann folgendermassen aussehen (siehe hier auch unter Punkt 3.):
public final class CrawlServlet implements Filter {
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException {
...
if ((queryString != null) && (queryString.contains("_escaped_fragment_")))
{
...
/* find the HTML-Snapshot for the desired part of the
* webapp(depending on the parameters in the querystring)
* in the filesystem (if you crated the HTML-Snapshots by
* yourself.
* OR: use HTMLUnit as a Headless Browser to generate
* the HTML-Snapshot here..
*/
//feed the HTML-Snapshot to the crawling bot
HttpServletResponse res = (HttpServletResponse) response;
res.setContentType("text/html;charset=UTF-8");
PrintWriter out = res.getWriter();
out.println(*** your HTML-Snapshot here ***);
out.close();
} else {
try {
// not an _escaped_fragment_ URL, so move up the chain of servlets
chain.doFilter(request, response);
} catch (ServletException e) {
System.err.println("Servlet exception caught: " + e);
e.printStackTrace();
}
}
...
}
}
Schritt 4: Optimieren & Testen
Um das Ganze bezüglich der Google Indexierung noch zu optimieren, sollte man eine XML-Sitemap für die Crawling-Bots zur Verfügung stellen. Die Links in der Sitemap sollten auf die verschiedenen dynamischen Inhalte eurer Seite verlinken (mithilfe der #!-URL's). Um die Generierung der Sitemap zu automatisieren helfen Java-Libraries wie diese .
Die Sitemap kann man dann im Google Webmasters Tool registrieren und überprüfen lassen.
Auch zum Testen des Crawling-Mechanismus eignet sich Google Webmaster Tools hervorrangend. Unter "Abruf wie durch Google" kann man eine Anfrage des Google Crawling-Roboter simulieren, und sieht anschliessend, was zurückgegeben wird. So kann man kontrollieren, ob der gewünschte HTML-Snapshot bei Google ankommt.
Links:
Google Webmaster Tools
StackOverFlow Anleitung zum Google Crawling für RAP
Google AJAX Crawling Guide
Offizielle Java Servlet Spezifikation
