While the Java client library for Google DATA API can’t be compiled by the
GWT compiler, you can still use it in RPC Servlets with the advantage of hiding
the protocol or substituting the default authentication backend with yours.
The screenshot below shows an example of a simple GWT application made up of
a tree widget displaying my spreadsheets and their worksheets, and a grid
widget on which appears the selected worksheet.
The source code of this demo is at the bottom.
Google Data APIs are based on Atom and RSS formats and the Atom Publishing
Protocol. Since they are REST-styled, you may use them with any browser:
First we need to authenticate to the service we want to use (Google
Spreadsheets in our case) with our Google account. The easiest way is to use
the ClientLogin interface:
$ export TOKEN=`curl https://www.google.com/accounts/ClientLogin \
-d Email=cappelle.florent@gmail.com -d Passwd=$GDATA_PASSWORD \
-d accountType=HOSTED_OR_GOOGLE \
-d source=SFEIR-GWTSheets-1 \
-d service=wise | grep 'Auth=' | cut -d'=' -f2`
The service parameter is the Google service we want to use; in this case the
«wise» value stands for the spreadsheets service. If the login is successful,
the response will include a token which we will use in the next requests. Note
that in some cases the service may require a CAPTCHA challenge to be done.
Then we request the list of the spreadsheets we include our token in the
Authorization header:
$ curl -H "Authorization: GoogleLogin auth=$TOKEN" \
"http://spreadsheets.google.com/feeds/spreadsheets/private/full" > SpreadsheetList.xml
Querying and editing our spreadsheets this way (you would have to build PUT
requests with XML) would be quite inefficient. Instead of parsing XML and
building HTTP requests, you may use the Java client library which already does
this for you with the SpreadsheetService class:
1 SpreadsheetService sService;
2 sService = new SpreadsheetService("SFEIR-GWTSheets-1");
3 try
4 {
5 sService.setUserCredentials(email, password);
6 logger.info(email + " authentication successful");
7 getSession().setAttribute("sService", sService);
8 } catch (AuthenticationException e)
9 {
10 logger.log(Level.WARNING, e.getMessage());
11 thrownew AuthException(e.getMessage());
12 }
The preceding piece of code is extracted from a GWT-RPC Service method:
- The «setUserCredentials» method requests a token and stores it in the
sService object, which we store in the session for the next requests.
- If the login fails or a CAPTCHA challenge is needed, an AuthException is
thrown back to the client.
Once the user is logged in, we build a feed URL with the FeedURLFactory
class (see the following piece of code). Its «getSpreadsheetsFeedUrl» returns
the URL for the spreadsheet list feed, which then is fetched by the
SpreadsheetService object (sService).
1 List<SpreadsheetEntry> spreadsheetEntries = null;
2 FeedURLFactory factory = FeedURLFactory.getDefault();
3 SpreadsheetFeed feed;
4
5 try
6 {
7 feed = service.getFeed(factory.getSpreadsheetsFeedUrl(),
8 SpreadsheetFeed.class);
9 spreadsheetEntries = feed.getEntries();
10 getSession().setAttribute("spreadsheetEntries",
11 spreadsheetEntries);
12 } catch (IOException e) ...
The «getEntries» method returns a list of SpreadsheetEntry: Each of these
entries contains standard Atom information (author, title, etc) and a worksheet
list feed URL. However we don’t even need to build a feed URL since the
«getWorksheets» method directly returns a list of WorksheetEntry.
The SpreadSheetModel is a list of Worksheet which is returned to the GWT
client: the title and the dimensions of each worksheet are used by the tree and
the grid widgets. The cell feed URL is also needed to fetch the content of each
cell.
1 SpreadSheetModel model = new SpreadSheetModel();
2 try
3 {
4 List<WorksheetEntry> worksheetEntries =
5 entry.getWorksheets();
6 for (WorksheetEntry sheet : worksheetEntries)
7 {
8 model.add(new SpreadSheetModel.WorkSheet(
9 sheet.getTitle().getPlainText(),
10 sheet.getCellFeedUrl().toExternalForm(),
11 sheet.getRowCount(), sheet.getColCount()));
12 }
13 } catch (IOException e) ...
At the client side, the code that fills the tree widget is pretty
simple:
1 public void onSuccess(SpreadSheetModel model)
2 {
3 TreeItem item = getItem(position);
4 for (SpreadSheetModel.WorkSheet sheet : model)
5 {
6 TreeItem newItem = item.addItem(sheet.getTitle());
7 newItem.setUserObject(sheet);
8 }
9 // remove the empty child (see populate method)
10 item.getChild(0).remove();
11 item.setState(true, false);
12 }
Once the user clicks on a worksheet title in the tree, the worksheet feed
URL is given to a RPC method «fetchworksheetcells», which returns a list of
cells: the Cell class of the Google API can’t be used as it is in the client
side, so we have to copy its properties to a DTO class (WorksheetCell).
«copyProperties» of the Apache Commons Beanutils library does this in a single
line.
1 List<WorksheetCell> cells = new ArrayList<WorksheetCell>();
2 try
3 {
4 CellFeed feed = sService.getFeed(new URL(sheetFeedURL),
5 CellFeed.class);
6 List<CellEntry> cellEntries = feed.getEntries();
7 for (CellEntry entry : cellEntries)
8 {
9 Cell cell = entry.getCell();
10 WorksheetCell clonedCell = new WorksheetCell();
11 BeanUtils.copyProperties(clonedCell, cell);
12 cells.add(clonedCell);
13 }
14 } catch (MalformedURLException e) ...
Note that worksheet feeds also have a list feed, which enables relational
alike manipulation of worksheet data. Insertion, modification and deletion are
very easy with the Java client, for example the modification of a cell entry
needs two lines of code:
1 cellEntry.changeInputValueLocal(newValue);
2 cellEntry.update();
Useful Links:
Article related downloads:
Il y a un peu plus d'une semaine, Google
annonçait la sortie de Google Chrome Frame.
L'équipe GWT
vient d'
Avec la
sortie de 