Collegatevi all'indirizzo http://www.google.com/apis/ seguire i passi indicati dalla pagina di google ovvero dapprima scaricare in locale la libreria di google (step 1), dopo creare un proprio account indicando un e-mail valida per ottenere la chiave che ci fa accedere al servizio (step 2).

Facciamo una nuova cartella con nome "engine" che contenga internamente una cartella "WEB-INF".  Dentro WEB-INF creiamo tre nuove cartelle una con nome "lib" un'altra "classes" e l'ultima è "tlds", non abbiamo ancora finito.Dentro la cartella classes dovrò creare altre due cartelle "bean" e "tags".

Adesso è arrivato il momento di scompattare  la libreria che google ci ha scaricato. Prendere il jar "googleapi.jar" e copiarlo dentro la nostra cartella "lib" della neonata web-application "engine".

Possiamo inoltre aiutarci per la creazione delle nostre classi consultando il javadoc che verrà scompattato insieme al tutto.

Creiamo una  classe che vada a wrappare le funzionalità delle classi di google.

package bean;

import java.io.*;

import com.google.soap.search.*;

public class SearchBean {        

// Creiamo un nuovo oggetto GoogleSearch che ci permetterà di comunicare via soap con google

GoogleSearch gs=new GoogleSearch();

// Due interi per permetterci la paginazione delle ricerche

int end;

int start;

// La query che è stata lanciata su google

String queryString            ;

//Un costruttore che prende come parametri la chiave del nostro account, l'inizio della lista dei //risultati, il massimo dei risultati attesi, la query di ricerca

            public SearchBean(String key,int startRes,int maxRes,String query){

                        // ne chiamiamo i rispettivi metodi sull'oggetto GoogleSearch

                        gs.setKey(key);

                        gs.setStartResult(startRes);

                        gs.setMaxResults(maxRes);

                        gs.setQueryString(query);

                        gs.setSafeSearch(true);

                        }                     

//a questo punto creiamo un metodo che lanci la ricerca tornandoci un oggetto google per scorrere i //risultati

            public GoogleSearchResultElement[] search(){

                        GoogleSearchResultElement[] gsre=null;;

            try{

            GoogleSearchResult gsr=gs.doSearch();

//valorizzo le variabili del bean per i metadati di informazione e ritorno il risultato della ricerca

                        end=gsr.getEndIndex();

                        start=gsr.getStartIndex();

                        queryString=gsr.getSearchQuery();

                        gsre=gsr.getResultElements();  

            }catch(Exception e){

                        e.printStackTrace();

                        }         

                         return gsre;

                        }         

// axcessor per i metadati di informazione

            public int getEnd(){

                        return end;

                        }

            public int getFirst(){

                        return start;

                        }

            public String getQuery(){

                        return queryString;

                        }

Salvo la classe dentro la cartella bean (engine/WEB-INF/classes/bean)

Adesso realizzeremo il custom tag che ci permetterà di richiamare il nostro bean per effettuare le ricerche tramite google.

package tags;

import javax.servlet.*;

import javax.servlet.jsp.JspException;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.TagSupport;

import com.google.soap.search.*;

import bean.*;

public class SearchTag extends TagSupport{

//mi dichiaro gli attributi che verranno valorizzati tramite la nostra JSP

//da quale numero della lista iniziare la rappresentazione del risultato

private String starte;

//quanti risultati massimo mi aspetto

private String maxi;

//la query di ricerca

private String query;

//i loro axcessor per essere valorizzati

public void setStarte(String starte){

            this.starte=starte;

            }

public String getStarte(){

            return starte;

            }         

public void setMaxi(String maxi){

            this.maxi=maxi;

            }

public String getMaxi(){

            return maxi;

            }

public void setQuery(String query){

            this.query=query;

            }

public String getQuery(){

            return query;

            }
 

public int doEndTag() throws JspException{

            try{

// ottengo il servlet context per poter accedere ai parametri di inizializzazione che //registrerò nel web.xml, ovvero dove ho salvato la chiave del mio account

                        ServletContext sc=pageContext.getServletContext();

                        String key=sc.getInitParameter("key");

                        JspWriter out=pageContext.getOut();

                        if("null".equalsIgnoreCase(query)||query==null)return EVAL_PAGE;

                        int max=Integer.parseInt(maxi);

                        int inizio=Integer.parseInt(starte);                   

//creo l'istanza del mio bean valorizzando il costruttore con gli attributi del custom //tag , e ne chiamo il metodo search

SearchBean sb=new SearchBean(key,inizio,max,query);

                        GoogleSearchResultElement[] gsre=sb.search();

                        if(gsre==null)return EVAL_PAGE;

                        //stampo i metadati di informazione della ricerca

                        out.println("Da "+sb.getFirst()+" a "+sb.getEnd()+", stringa di ricerca : "+sb.getQuery());

                        out.println("<br><hr><br>");

//a questo punto ciclo sulla lista dei risultati formattandoli a video come ritengo //meglio (vedi javadoc google)

                        for(int x=0;x<gsre.length;x++){

                                   out.println("<b>Titolo :</b><a href=\""+gsre[x].getURL()+"\" target=\"_BLANK\">                                                  "+gsre[x].getTitle()+"</a><br>" );

                                   out.println("<b>Descrizione :</b> "+gsre[x].getSnippet()+"<br>");

                                   out.println("<br><hr><br>");

                                   }

            }catch(Exception ex){

            ex.printStackTrace();

            }

                        return EVAL_PAGE;

            }

}

Salvo la classe dentro la cartella "tags" (engine/WEB-INF/classes/tags).

Adesso realizzeremo il nostro tld per mappare il nostro neonato custom tag:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE taglib PUBLIC

  "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"

  "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib>

    <tlibversion>1.0</tlibversion>

    <jspversion>1.1</jspversion>

    <shortname>engine</shortname>

<!--Il nostro custom tag si chiamerà search -->

 <tag>

      <name>search</name>

      <!--mappato dalla classe SearchTag dentro la cartella tags -->

<tagclass>tags.SearchTag</tagclass>

      <bodycontent>JSP</bodycontent>

      <!-- i suoi attributi sono starte, maxi e query -->

<attribute>  

      <name>starte</name>

      <required>true</required>

      <rtexprvalue>true</rtexprvalue>

</attribute>  

<attribute>  

      <name>maxi</name>

      <required>true</required>

      <rtexprvalue>true</rtexprvalue>

</attribute>  

 <attribute>  

      <name>query</name>

      <required>true</required>

      <rtexprvalue>true</rtexprvalue>

</attribute> 

  </tag>  

  </taglib>

Salviamo il file nella cartella tlds con il nome engine.tld (engine/WEB-INF/tlds)

Adesso passiamo a configurare il nostro web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app

    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"

    "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

<web-app>

<!-- inseriamo un parametro key con la chiave del nostro account nel servlet context -->

            <context-param>

                        <param-name>key</param-name>

                        <param-value>Io/jz/1QFHL/TpeOAe9cpaRyF9PjHZ/t</param-value>

            </context-param>

<!-- mappiamo la nostra libreria di custom tag con il nome engine -->

            <taglib>

                        <taglib-uri>engine</taglib-uri>

                        <taglib-location>/WEB-INF/tlds/engine.tld</taglib-location>

            </taglib>       

</web-app>

Salviamo il file con il nome web.xml dentro la cartella WEB-INF (engine/WEB-INF)

Ci rimane solo da realizzare la nostra complicatissima JSP:

<!--Instanziamoci la libreria del nostro custom tag che risponde al nome engine -->

<%@taglib uri="engine" prefix="engine"%>

<html>

<body>

<!-- creiamo un form che permetta di inviare un testo per la query di ricerca e che punti alla stessa pagina -->

<form action="#" method="post">

Ricerca :<input type="text" name="query"><br>

<input type="submit" name="Cerca" value="Cerca"><br>

</form>

<!-- a questo punto richiamiamo il nostro custom tag passandogli i parametri che servono per personalizzare il nostro motore di ricerca, stando attenti solamente che la prima volta che la pagina venga caricata non mandi in errore il nostro custom tag -->

<engine:search starte='0' maxi='10' query='<%=request.getParameter("query")==null?"null":request.getParameter("query")%>' />

</body>

</html>

Salvate il file chiamando index.jsp e salvatelo dentro la cartella engine (engine/)

A questo punto aprite una shell e mettetevi nella cartella classes e lanciare il  compilatore java passandogli nel classpath la libreria di google (javac -classpath %CLASSPATH%;..\lib\googleapi.jar tags/*.java bean/*.java).

Dopo aver corretto il centinaio di errori che il compilatore gentilmente vi mostrerà, sempre nella vostra shell tornate nella cartella engine (engine/) e realizzate il war della vostra nuova web application (jar -cvf engine.war *).

A questo punto non vi resta che buttare il vostro file engine.war che risiede nella cartella engine, dentro la cartella webapps di tomcat (o qualsiasi altro servlet engine o application server state usando) e startare il server.

http://localhost:8080/engine/index.jsp è il vostro risultato .....

Qualcuno di voi, potrebbe anche pensare di modificare il web xml inserendo più di una chiave tipo:

key1, key2, key3.. . E poi nel custom tag tramite delle costanti statiche referenziare le tre chiavi e alternare le ricerche sulle stesse, ma questo non penso sia del tutto lecito perché cosi invece di essere limitati a sole 1000 ricerche giornaliere potreste averne quante ne volete.

Fai il downLoad del file war

Ciao ... Nino Guarnacci !!!!!!!!.