Group items matching

in title, tags, annotations or url

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.

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.