Server interface that must extend GWT's RemoteService interface.

                    
public interface Service extends RemoteService {

    /**
     * Finds person within a range.
     */
    public Person[] findPersons(int startIndex, int maxResults);

}
                    
                

Client asynchronous interface that matches the Service interface, but returns void and has AsyncCallback<Person[]> added as a final parameter.

	Note
	The value returned from the Service interface is now the generic value passed into the AsyncCallback.

                    
public interface ServiceAsync {

    /**
     * Finds person within a range.
     */
    public void findPersons(int startIndex, int maxResults, AsyncCallback<Person[]> callback);

}
                        
                    

This class extends GwtController and implements the Service interface. The person DAO is used to get the current page of results and copies them into another Person instance that implements IsSerializable (which indicates that this is serializable by GWT RPC requests). The instance returned by the DAO can't be used because it has annotations that the GWT compiler can't convert to JavaScript.

                    
@Controller
public class ServiceController extends GwtController implements Service {

    final Logger logger = LoggerFactory.getLogger(ServiceController.class);

    private static final long serialVersionUID = -2103209407529882816L;

    @Autowired
    private PersonDao personDao = null;
    
    /**
     * Finds person within a range.
     */
    public Person[] findPersons(int startIndex, int maxResults) {
        Person[] results = null;

        List<Person> lResults = new ArrayList<Person>();

        Collection<org.springbyexample.orm.hibernate3.annotation.bean.Person> lPersons = personDao.findPersons(startIndex, maxResults);
        
        for (org.springbyexample.orm.hibernate3.annotation.bean.Person person : lPersons) {
            Person result = new Person();
            result.setId(person.getId());
            result.setFirstName(person.getFirstName());
            result.setLastName(person.getLastName());
            
            lResults.add(result);
        }

        return lResults.toArray(new Person[]{});
    }

}
                    
                

The constructor sets up the asynchronous service. The URL base is set by using GWT.getHostPageBaseURL() so the generated JavaScript can be hosted in other pages as shown in the search.jsp above. The callback is used to process the results or a failure if there is a problem with the request.

The processLinkRequest method is used to populate the table cell with the edit/delete link by making an HTTP get request to a JSP fragment with the links in the pages. This isn't the best for performance, but seemed the easiest way to leverage Spring Security's JSP tags for evaluating whether or not someone has permission to delete a record.

                    
private class PersonProvider implements SearchTableDataProvider {

    private final ServiceAsync service;
    private int lastMaxRows = -1;
    private Person[] lastPeople;
    private int lastStartRow = -1;

    /**
     * Constructor
     */
    public PersonProvider() {
        service = (ServiceAsync) GWT.create(Service.class);
        ServiceDefTarget target = (ServiceDefTarget) service;
        String moduleRelativeURL = GWT.getHostPageBaseURL() + "service.do";
        target.setServiceEntryPoint(moduleRelativeURL);
    }

    public void updateRowData(final int startRow, final int maxRows,
                              final RowDataAcceptor acceptor) {
        final StringBuffer sb = new StringBuffer();
        
        // Check the simple cache first.
        if (startRow == lastStartRow) {
            if (maxRows == lastMaxRows) {
                // Use the cached batch.
                pushResults(acceptor, startRow, lastPeople);
            }
        }

        // Fetch the data remotely.
        service.findPersons(startRow, maxRows, new AsyncCallback<Person[]>() {
            public void onFailure(Throwable caught) {
                acceptor.failed(caught);
            }

            public void onSuccess(Person[] result) {
                lastStartRow = startRow;
                lastMaxRows = maxRows;
                lastPeople = result;
                
                pushResults(acceptor, startRow, result);
            }

        });
    }

    private void pushResults(RowDataAcceptor acceptor, int startRow, Person[] people) {
        String[][] rows = new String[people.length][];
        for (int i = 0, n = rows.length; i < n; i++) {
            Person person = people[i];
            rows[i] = new String[3];
            rows[i][0] = person.getFirstName();
            rows[i][1] = person.getLastName();
            rows[i][2] = "";

            // increment by one because of table header
            int row = i + 1;
            processLinkRequest(person.getId(), acceptor, row);
        }

        String message = acceptor.accept(startRow, rows);
        dynamicTable.setStatusText(message);
    }

    private void processLinkRequest(Integer personId,
            final RowDataAcceptor acceptor, final int row) {
        String url = GWT.getHostPageBaseURL() + "fragment/search_link.htm" + 
                     "?ajaxSource=true&fragments=content&" + "id=" + personId;
        url = URL.encode(url);

        RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, url);

        try {
            Request response = rb.sendRequest(null, new RequestCallback() {
                public void onError(Request request, Throwable exception) {
                }

                public void onResponseReceived(Request request, Response response) {
                    dynamicTable.setCell(row, 2, response.getText());
                }
            });
        } catch (RequestException e) {
            Window.alert("Failed to send the request: " + e.getMessage());
        }
    }
}