Group items tagged

employeeRequest();

@Service(Employee.class)

service stub

The methods in a service stub do not return entities directly

return subclasses of com.google.gwt.requestfactory.shared.Request.

This allows the methods on the interface to be invoked asynchronously with

fire(    new Receiver()

onSuccess

callers pass an AsyncCallback that implements onSuccess()

takes a Receiver which must implement onSuccess()

you can extend Receiver and override onFailure()

any constraint violations on the server

The Request type returned from each method

parameterized with the return type of the service method.

BigDecimal, BigInteger, Boolean, Byte, Enum, Character, Date, Double, Float, Integer, Long, Short, String, Void

subclass of EntityProxy

List<T> or Set<T>

methods that operate on an entity itself

return objects of type InstanceRequest rather than Reques

Server Implementations

methods defined in an

implemented in the class named

in these examples, is the entity class

server-side implementations use the domain entity types

EntityManager

createQuery

getResultList();

entityManager()

createEntityManager()

em.persist(this);

em.remove(attached

em.close();

defined in the service's

even though the implementation does not formally implement the interface in Java

name and argument list for each method

Client side methods

return Request<T>

only T on the server

EntityProxy types become the domain entity type on the server

Methods that return a Request object in the client interface are implemented as static methods on the entity

Methods that operate on a single instance of an entity, like persist() and remove(),

eturn an

in the client interface

Instance methods do not pass the instance directly, but rather via the

as they are used by the RequestFactory servlet:

constructor

findEntity

An entity's getId()

is typically auto-generated by the persistence engine (JDO, JPA, Objectify, etc.)

"find by ID" method has a special naming convention

getVersion() method is used by RequestFactory to infer if an entity has changed

backing store (JDO, JPA, etc.) is responsible for updating the version each time the object is persisted,

RequestFactoryServlet sends an UPDATE

if an entity changes as

Second, the client maintains a version cache of recently seen entities

Whenever it sees an entity whose version has changed, it fires

so that listeners can update the view

GWT.create

and initialize it with your application's EventBus

GWT.create

requestFactory.initialize

create a new entity on the client

EmployeeRequest request

EmployeeProxy newEmployee

All client-side code should use the EmployeeProxy

not the Employee entity itself

RequestFactory

on the server

on the client

easy to implement a data access layer

GWT-RPC, which is service-oriented

On the client side, RequestFactory keeps track of objects that have been modified and sends only changes

RequestFactory uses its own servlet

not designed for general purpose services like GWT-RPC

implements its

In persistence frameworks like JDO and JPA, entities are annotated with

client-side representation of an entity

known as a

hook used to indicate that an object can be managed by RequestFactory

automatically populates bean-style properties between entities on the server and the corresponding EntityProxy on the client,

extends EntityProxy

interface

reference the server-side entity being represented

It is not necessary to represent every property and method from the server-side entity in the EntityProxy

EntityProxyId returned by this method is used throughout RequestFactory-related classes

while getId() is shown in this example, most client code will want to refer to

to represent any type

often used to represent embedded object types within entities

@Embedded

Address

Address type

POJO with no persistence annotations

Address is represented as a ValueProxy

extends ValueProxy

interface

extends EntityProxy

interface

must implement each method