Group items tagged

onAddButtonClicked

eventBus.fireEvent(new AddContactEvent());

presenter needs to know more about the view

view needs to know more about the data model

houses the any type-specific code (this is the third party mentioned above)

ColumnDefinition

we can reuse its logic regardless of what view we've attached ourself to

update our views such that we can set their ColumnDefinition(s).

setColumnDefinitions

this.columnDefinitions = columnDefinitions;

so that we can pass in

a mocked ContactsView instance when testing our ContactsPresenter

in our AppController, when we create the ContactsView,

new ContactsViewColumnDefinitions().getColumnDefinitions();

we can initialize it with the necessary ColumnDefinition(s).

contactsView.setColumnDefiniions(

As mentioned above we were previously dumbing down the model into a list of Strings

List<String> data

display.setData(data);

how that data type is rendered.

knowledge of a cell's data type

stringing together a list of these classes

providing the necessary render()

and isClickable()/isSelectable() override

columnDefinitions =      new ArrayList<ColumnDefinition<ContactDetails>>()

ColumnDefinition<T> columnDefinition = columnDefinitions.get(j);

that we would otherwise need to test. And the fun doesn't stop there.

presenter.onItemClicked(

presenter.onItemSelected

ClickEvent

cell.getCellIndex()

columnDefinition.isClickable()

SelectEvent

columnDefinition.isSelectable()

return shouldFireClickEvent;

return shouldFireSelectEvent;

respond to user interaction in different ways based upon the cell type that was clicked

we're going to remove any application state from the ContactsView

replace the view's getSelectedRows() with a SelectionModel

ContactsPresenter holds on to an instance of this class

onItemSelected

Reduce the event overhead by sinking events on the HTML widget

update our ContactsView.ui.xml file to use a

HTML widget rather than a FlexTable widget.

for each item ask our column definitions to render accordingly

This will decrease your load time, especially as your tables start to grow.

we're reducing the overhead of sinking events on per-cell widgets

ClickEvents are still wired up via our UiHandler annotations

we can determine the row

to take as a parameter a TableCellElement rather than a HTMLTable.Cell.

faster startup times via Code Splitting.

split portion of your code is purely segmented

not referenced by other parts of the app

it will be downloaded and executed at the point that it needs to run

Do we really want to download all of that code before the user even logs in?

Not really.

wrap the code that creates the ContactsView and ContactsPresenter in a runAsync() call

as optimizations such as this one become easier and easier to implement.

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

@UiField have default visibility

UIObject

DivElement

If your factory method needs arguments, those will be required as attributes.

you can define a @UiFactory method on the UiBinder's owner

annotate a constructor of CricketScores with @UiConstructor.

public interface Display

methods can be called to fill in attribute values

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.

Compile the top level module

conflict with each other during event handling

Linkers are divided into three categories, PRE, POST, and PRIMARY

one primary linker is run for a compilation

everal linkers are provided by Core.gwt.xml, which is automatically inherited by User.gwt.xml.

monolithic JavaScript file.

cross-site deployment model.

standard iframe-based

<add-linker name="xs" />

The GWT compiler

packaging its output with the Linker subsystem

re-use an existing Java API for a GWT project,

"re-root" a source path

tells the compiler to add all subfolders of com/example/myproject/jre/

to the source path

com/google/myproject/gwt/jre/java/util/UUID.java

most commonly used elements in the module XML file.

herits all the settings from the specified module

Entry points are all compiled into a single codebase

Any number of entry-point classes can be added

resources get copied into the output directory during a GWT compile.

client subpackage is implicitly added to the source path

treated as a publicly-accessible resource.

resources get copied into the output directory

the public subpackage is implicitly added to the public

For RPC, this element loads a servlet class

mounted at the specified URL path

path=

class="

URL path should be absolute

you must configure a WEB-INF/web.xml in your war directory to load any servlets needed.

n development mode,

external JavaScrip

Extends the set of values

for an existing client property

three different types of predicates are

<all>

<any>

<none>

you want to inherit at least the User module

contains all the core GWT functionality

including the EntryPoint class

widgets and panels

History feature

Internationalization

DOM programming, and more

Low-level HTTP

Use the following syntax to cause an external JavaScript file to be loaded

as if you had included it explicitly using the HTML <script

loaded before your onModuleLoad() is called.

associate external CSS files with your module

GWT.getModuleBaseURL() + "foo.css" in client code

module's public path

useful when

inheritance makes resource inclusion particularly convenient.

see the documentation for FileSet for a general overview

includes

excludes

defaultexcludes

casesensitive

By default, the patterns listed here are excluded.

<script src='myApp/myApp.nocache.js'></script>

two simultaneous connections

GWT selection script

like a normal script tag

Parsing is blocked until externalScriptZero.js is done fetching and evaluating.

myApp/myApp.nocache.js completes

the compiled scrip

begins fetching in a hidden IFRAME (this is non-blocking).

onModuleLoad() is not called yet, as we're still waiting on externalScriptOne.js

body.onload() fires

onload='alert("w00t!")

because it won't block any other script requests

<img> tags are not guaranteed to be done loading when onModuleLoad() is called

<script> tags are guaranteed to be done loading when onModuleLoad() is called

will all be called in sequence as soon as that module (and the outer document) is ready

each module's EntryPoint will be called as soon as both that module and the outer document is ready

in which their selection scripts were specified in the host page

serialVersionUID = 2L;

static final

Exception in thread "main" java.io.InvalidClassException:

As you can see, this time the deserialization didn’t go well. ObjectInputStream complained about the serialVersionUID being changed.

How does he know that it changed? If serialVersinUID is static, then it should not have been serialized in the first place, and there should be no information about the previous value 1 during the deserialization, right? Well, serialVersionUID is an exception to the rule that “static fields don’t get serialized”.

Moreover, if there is no serialVersionUID officially declared in the class to be serialized, compiler automatically adds it with a value generated based on the fields declared in the class.