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

the first By acts as delimiter to indicate the start of the actual criteria

The mechanism strips the prefixes find…By, read…By, and get…By from the method and starts parsing the rest of it

you can define conditions on entity properties and concatenate them with And and Or

The introducing clause can contain further expressions such as a Distinct to set a distinct flag

List<Person> findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname); // Enables the distinct flag for the query List<Person> findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname); List<Person> findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname); // Enabling ignoring case for an individual property List<Person> findByLastnameIgnoreCase(String lastname); // Enabling ignoring case for all suitable properties List<Person> findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname); // Enabling static ORDER BY for a query List<Person> findByLastnameOrderByFirstnameAsc(String lastname); List<Person> findByLastnameOrderByFirstnameDesc(String lastname);

You can combine property expressions with AND and OR. You also get support for operators such as Between, LessThan, GreaterThan, Like for the property expressions

AllIgnoreCase

IgnoreCase

The resolution algorithm starts with interpreting the entire part (AddressZipCode) as the property and checks the domain class for a property with that name (uncapitalized). If the algorithm succeeds it uses that property. If not, the algorithm splits up the source at the camel case parts from the right side into a head and a tail and tries to find the corresponding property, in our example, AddressZip and Code.

he infrastructure will recognize certain specific types like Pageable and Sort to apply pagination and sorting to your queries dynamically

Pageable

Sort sort

The first method allows you to pass an org.springframework.data.domain.Pageable instance to the query method to dynamically add paging to your statically defined query. Sorting options are handled through the Pageable instance too

<repositories base-package="com.acme.repositories" />

Spring is instructed to scan com.acme.repositories and all its subpackages for interfaces extending Repository or one of its subinterfaces. For each interface found, the infrastructure registers the persistence technology-specific FactoryBean to create the appropriate proxies that handle invocations of the query methods. Each bean is registered under a bean name that is derived from the interface name, so an interface of UserRepository would be registered under userRepository

This postfix defaults to Impl.Example 1.12. Configuration example<repositories base-package="com.acme.repository" /> <repositories base-package="com.acme.repository" repository-impl-postfix="FooBar" />The first configuration example will try to look up a class com.acme.repository.UserRepositoryImpl to act as custom repository implementation, where the second example will try to lookup com.acme.repository.UserRepositoryFoo

To exclude an interface that extends Repository from being instantiated as a repository instance, you can either annotate it with @NoRepositoryBean or move it outside of the configured base-package.

]In general, the integration support is enabled by using the @EnableSpringDataWebSupport annotation in your JavaConfig configuration class.

@Configuration @EnableWebMvc @EnableSpringDataWebSupport class WebConfiguration { }

In case you need multiple Pageables or Sorts to be resolved from the request (for multiple tables, for example) you can use Spring's @Qualifier annotation to distinguish one from another

Spring HATEOAS ships with a representation model class PagedResources that allows enrichting the content of a Page instance with the necessary Page metadata as well as links to let the clients easily navigate the pages.