Typically, your repository interface will extend
Repository,
CrudRepository or
PagingAndSortingRepository.
Alternatively, if you do not want to extend Spring Data interfaces,
you can also annotate your repository interface with
@RepositoryDefinition
Group items matching
in title, tags, annotations or url
24More
1. Working with Spring Data Repositories - 0 views
-
-
It allows quick query definition by method names but also custom-tuning of these queries by introducing declared queries as needed.
-
CREATE_IF_NOT_FOUND (default)CREATE_IF_NOT_FOUND combines CREATE and USE_DECLARED_QUERY.
- ...21 more annotations...
-
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.
1More
Querydsl - 0 views
-
Querydsl is a framework which enables the construction of type-safe SQL-like queries for multiple backends including JPA, JDO and SQL in Java. Instead of writing queries as inline strings or externalizing them into XML files they are constructed via a fluent API. Code completion in IDE (all properties, methods and operations can be expanded in your favorite Java IDE) Almost no syntactically invalid queries allowed (type-safe on all levels) Domain types and properties can be referenced safely (no strings involved!) Adopts better to refactoring changes in domain types Incremental query definition is easier Querydsl is licensed under the LGPL 2.1 license.
Java Proficiency: Get a number from a string in java - 0 views
Java Proficiency: Generate permutation of string - 0 views
96More
Large scale application development and MVP - Part II - Google Web Toolkit - Google Code - 0 views
-
itself
-
-
@UiHandler("
-
presenter.onAddButtonClicked();
- ...91 more annotations...
-
onAddButtonClicked
-
eventBus.fireEvent(new AddContactEvent());
-
presenter needs to know more about the view
-
view needs to know more about the data model
-
data types are typically homogeneous within column borders
-
ColumnDefinition abstract class
-
houses the any type-specific code (this is the third party mentioned above)
-
ColumnDefinition
-
ColumnDefinition(s) would be created outside of the presenter
-
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(
-
-
With our ColumnDefinition(s) we can pass the model untouched.
-
As mentioned above we were previously dumbing down the model into a list of Strings
-
current solution
-
List<String> data
-
display.setData(data);
-
how that data type is rendered.
-
use generics
-
third party that abstracts
-
knowledge of a cell's data type
-
stringing together a list of these classes
-
providing the necessary render()
-
and isClickable()/isSelectable() override
-
ContactsViewColumnDefinitions<ContactDetails>
-
columnDefinitions = new ArrayList<ColumnDefinition<ContactDetails>>()
-
ColumnDefinition<T>
-
ContactsPresenter
-
ContactsViewImpl
-
ColumnDefinition<T> columnDefinition = columnDefinitions.get(j);
-
the presenter can pass the model untouched
-
the view has no rendering code
-
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
-
use them for rendering purposes
-
defining how to interpret user interactions
-
we're going to remove any application state from the ContactsView
-
replace the view's getSelectedRows() with a SelectionModel
-
The SelectionModel is nothing more than a wrapper around a list of model objects.
-
ContactsPresenter holds on to an instance of this class
-
onItemSelected
-
Having the ColumnDefinition create a new widget for each cell is too heavy
-
Replace our FlexTable implementation with an HTML widget
-
calling setHTML()
-
Reduce the event overhead by sinking events on the HTML widget
-
rather than the individual cells
-
update our ContactsView.ui.xml file to use a
-
HTML widget rather than a FlexTable widget.
-
<g:HTML ui:field="contactsTable">
-
Inefficiencies related to inserting new elements via DOM manipulation Overhead associated with sinking events per Widget
-
for each item ask our column definitions to render accordingly
-
each column definition
-
render itself into the StringBuilder
-
rather than passing back a full-on widget
-
calling setHTML on a HTML widget
-
rather than calling setWidget on a FlexTable.
-
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
-
instead sinking on a single container
-
ClickEvents are still wired up via our UiHandler annotations
-
get the Element that was clicked on
-
and walk the DOM until we find a parent TableCellElement
-
we can determine the row
-
shouldFirdClickEvent() and shouldFireSelectEvent()
-
to take as a parameter a TableCellElement rather than a HTMLTable.Cell.
-
faster startup times via Code Splitting.
-
runAsync() points
-
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.
-
simply grab the login code, and leave the rest for when we actually need it
-
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.
2More
StringBuffer versus String - JavaWorld - 1 views
-
The significant performance difference between these two classes is that StringBuffer is faster than String when performing simple concatenations.
-
Java Proficiency: Find duplicate charcters with occurrences in a string - 0 views
1More
Apache Commons Daemon : Java based daemons or services - 0 views
-
"Since 1994, the Java programming language evolved and became a valid tool to develop reliable and performant server applications as opposed to just applets and client applications. The major disadvantage of the Java platform is that still today the only portable way to start a Java application relies on a single point of entry: the public static void main(String[]) method. Having a single-point of entry is a valid solution for client applications, where interactively a user can command to the application to quit (which can terminate the Virtual Machine process at calling the System.exit(int) method), but in those cases where the application is not interactive (server applications) there is currently no portable way to notify the Virtual Machine of its imminent shutdown. A server application written in Java might have to perform several tasks before being able to shutdown the Virtual Machine process. For example in the case of a Servlet container, before the VM process is shut down, sessions might need to be serialized to disk, and web applications need to be destroyed. One common solution to this problem is to create (for example) a ServerSocket and wait for a particular message to be issued. When the message is received, all operations required to shut down the server applications are performed and at the end the System.exit method is called to terminate the Virtual Machine process. This method however, has several disadvantages and risks: In case of a system-wide shutdown, the Virtual Machine process may be shut down directly by the operating system without notifying the running server application. If an attacker finds out the shutdown message to send to the server and discovers a way to send this message, he can easily interrupt the server's operation, bypassing all the security restrictions implemented in the operating system. Most multi-user operating systems already have a way in which server applications are started and stopped. Under Unix based
1More
Merit Campus|Core Java Topics|Learn Java Programming|core java online training - 0 views
-
Core Java Topics - Overview Of Programming With Java, Datatypes, Variables, Operators, Control Statements, Methods - Importance, Array - Overview, Classes, Class Inheritance, Methods Overiding and Overloading, Abstract Class And Methods, Interfaces, Packages and Access Control, final, static and others, Object Oriented Concepts - Revisited, Exceptions, Generics, Strings, Exploring java.lang, Collections Framework, More Utility Classes, Input/Output: Exploring java.io, Other Core Java Topics
1More
inflector: Inflector - 0 views
-
Inflector is a Java API for forming plurals of words. The library supports English spellings, and is locale-aware so it is straightforward to customize for any language.
151More
Getting Started with RequestFactory - Google Web Toolkit - Google Code - 0 views
-
Entity Proxies
-
-
proxy types
-
entity types
- ...147 more annotations...
-
methods that return service stubs
-
one RequestFactory interface for your application
-
employeeRequest();
-
@Service(Employee.class)
-
extends RequestContext
-
extends RequestFactory
-
service stub
-
RequestFactory service stubs
-
must extend RequestContext
-
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
-
Request.fire()
-
fire( new Receiver()
-
onSuccess
-
callers pass an AsyncCallback that implements onSuccess()
-
takes a Receiver which must implement onSuccess()
-
Receiver is an abstract class having a default implementation of onFailure()
-
you can extend Receiver and override onFailure()
-
onViolation()
-
any constraint violations on the server
-
The Request type returned from each method
-
parameterized with the return type of the service method.
-
Methods that have no return value should return type Request<Void>
-
BigDecimal, BigInteger, Boolean, Byte, Enum, Character, Date, Double, Float, Integer, Long, Short, String, Void
-
subclass of EntityProxy
-
List<T> or Set<T>
-
primitive types are not supported
-
methods that operate on an entity itself
-
like persist() and remove()
-
return objects of type InstanceRequest rather than Reques
-
Server Implementations
-
methods defined in an
-
entity's service interface
-
implemented in the class named
-
@Service annotation
-
in these examples, is the entity class
-
service implementations do not directly implement the RequestContext interface
-
server-side implementations use the domain entity types
-
@Entity
-
EntityManager
-
createQuery
-
getResultList();
-
entityManager()
-
createEntityManager()
-
em.persist(this);
-
em.remove(attached
-
em.close();
-
defined in the service's
-
RequestContext interface
-
even though the implementation does not formally implement the interface in Java
-
name and argument list for each method
-
same on client and server
-
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
-
InstanceRequest
-
in the client interface
-
Instance methods do not pass the instance directly, but rather via the
-
using()
-
instance methods must be implemented as non-static methods in the entity type
-
Four special methods are required on all entities
-
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
-
find()
-
"find" plus the type's simple name
-
On the server
-
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
-
UPDATE events on the event bus
-
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
-
unlike GWT-RPC, where the same concrete type is used on both client and server
-
RequestFactory
-
designed to be used with an ORM layer like JDO or JPA
-
on the server
-
to build data-oriented (CRUD) apps with an ORM-like interface
-
on the client
-
easy to implement a data access layer
-
structure your server-side code in a data-centric way
-
GWT-RPC, which is service-oriented
-
On the client side, RequestFactory keeps track of objects that have been modified and sends only changes
-
lightweight network payloads
-
solid foundation for automatic batching and caching of requests in the future
-
RequestFactoryServlet
-
RequestFactory uses its own servlet
-
own protocol
-
not designed for general purpose services like GWT-RPC
-
implements its
-
It is designed specifically for implementing a persistence layer on both client and server.
-
In persistence frameworks like JDO and JPA, entities are annotated with
-
client-side representation of an entity
-
known as a
-
DTO (Data Transfer Object)
-
hook used to indicate that an object can be managed by RequestFactory
-
RequestFactory
-
EntityProxy interface
-
automatically populates bean-style properties between entities on the server and the corresponding EntityProxy on the client,
-
send only changes ("deltas") to the server
-
extends EntityProxy
-
interface
-
@ProxyFor
-
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
-
EntityProxy.stableId() i
-
to represent any type
-
is not required to expose an ID and version
-
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
-
AddressProxy
-
AddressProxy
-
ValueProxy can be used to pass any type to and from the server
-
RequestFactory
-
interface between your client and server code
-
RequestContext interface
-
The server-side service
-
must implement each method