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
AtomServer 2.3.4 - - 0 views
-
"AtomServer is a generic data store implemented as a RESTful web service. It is designed as a GData-style Atom Store. It is based on the following concepts and protocols; REST. REST is a design pattern. It's not a technology like SOAP or HTTP. REST is a proven design pattern for building loosely-coupled, highly-scalable applications. There are important benefits to sticking to the REST design pattern; Simple. REST is incredibly simple to define. There are just a handful of principles and well defined semantics associated with it. Scalable. REST leads to a very scalable solution by promoting a stateless protocol and allowing state to be distributed across the web. Layered. REST allows any number of intermediaries, such as proxies, gateways, and firewalls. Ultimately REST is just a web site, albeit one that adheres to a design pattern, so one can easily layer aspects such as Security, Compression, etc. on an as needed basis. Atom. Fundamentally, Atom is an XML vocabulary for describing lists of timestamped entries. These entries can be anything, although because Atom was originally conceived to replace RSS, Atom lists are Feeds, and the items in the lists are Entries. Atom is a RESTful protocol. AtomServer stands on the shoulders of giants. It is built on top of several open source projects - most notably, Apache Abdera (a Java-based Atom Publishing framework) and Spring. AtomServer is an Atom Store. Thus, it requires a relational database to run. AtomServer currently supports; PostgresSQL, SQLServer, and HSQLDB. Using HSQLDB, AtomServer requires zero configuration and can run out-of-the-box. While this configuration is suitable for many applications, those that see significant load will likely require a database with better transactional semantics, such as PostgreSQL. AtomServer is easy to use. It deploys as a simple WAR file into any Servlet container. Or alternately, can be used out-of-the-box as a standalone server, running with
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.
1More
shared by Hendy Irawan on 06 Apr 11
- No Cached
AtomPub interface for Guvnor - JBoss Community - 0 views
community.jboss.org/...AtomPubinterfaceforGuvnor
jbpm drools atompub interface Guvnor REST XML JSON HTTP API Atom
shared by Hendy Irawan on 06 Apr 11
- No Cached
-
"http://www.atompub.org/ defines a simple interface over HTTP to publish and subscribe to artifacts (files) and collections of artifacts (services/packages). AtomPub interface serves following purposes: 1: provide "feeds" for people/systems to monitor for changes: For example, user subscribes to a feed which lists contents of package or user subscribes to feed which lists changed contents in a package 2. provide the default remote api to push/pull content and meta data from the repository. This allows other applications to integrate with Guvnor by accessing repository content via atom pub programmatically."
Spring Collections (List, Set, Map, and Properties) example - 0 views
2More
Core java interview questions | Java interview questions - 1 views
-
Know about interview questions in java. Here is list of java interview questions which covers all main topics in java and categorized in basic java interview questions. -
Are you Searching Core Java interview questions? Javatpoint is providing a list of Java interview questions for freshers & experienced. There are the list of 170 core java interview questions. We assure that you will get here the 90% frequently asked interview questions and answers.
1More
How to convert ArrayList to Set in Java with Example - 0 views
-
A good quick way of converting arraylist to set in java . ough its worth noting that all those method will eat duplicates silently and size of converted set might be less than or equal to original list.
1More
Formatter (Java 2 Platform SE 5.0) - java platform format string syntax - 0 views
-
" Format String Syntax Every method which produces formatted output requires a format string and an argument list. The format string is a String which may contain fixed text and one or more embedded format specifiers."
1More
Apache Tomcat - Welcome! - 0 views
-
"Apache Tomcat is an open source software implementation of the Java Servlet and JavaServer Pages technologies. The Java Servlet and JavaServer Pages specifications are developed under the Java Community Process. Apache Tomcat is developed in an open and participatory environment and released under the Apache License version 2. Apache Tomcat is intended to be a collaboration of the best-of-breed developers from around the world. We invite you to participate in this open development project. To learn more about getting involved, click here. Apache Tomcat powers numerous large-scale, mission-critical web applications across a diverse range of industries and organizations. Some of these users and their stories are listed on the PoweredBy wiki page."
1More
Java EE 6 and Scala » Source Allies Blog - 0 views
-
Last weekend while pondering the question "Is Scala ready for the enterprise?" I decided to write a simple Java EE 6 app entirely in Scala, without using any Java. I had three main reasons for doing this: one was just to see how easy/difficult it would be to write everything in Scala (it was easy). Another was to document the process for others journeying down the same road (the entire project is on github). Finally, I wanted to identify advantages of using Scala instead of Java that are specific to Java EE apps (I found several). Background The specific app I created was an adaptation of the Books example from Chapter 10 of Beginning Java™ EE 6 Platform with GlassFish™ 3. It's a simple web app that displays a list of books in a database and lets you add new books. Although it's a pretty trivial app, it does touch on several important Java EE 6 technologies: JPA 2.0, EJB 3.1 and JSF 2.0.
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
1More
shared by Hendy Irawan on 26 Dec 10
- Cached
Apache CXF -- Index - 0 views
cxf.apache.org
java opensource framework apache cxf webservice webservices SOA soap axis axis2 xml web
shared by Hendy Irawan on 26 Dec 10
- Cached
-
Apache CXF is an open source services framework. CXF helps you build and develop services using frontend programming APIs, like JAX-WS and JAX-RS. These services can speak a variety of protocols such as SOAP, XML/HTTP, RESTful HTTP, or CORBA and work over a variety of transports such as HTTP, JMS or JBI. CXF includes a broad feature set, but it is primarily focused on the following areas: Web Services Standards Support: CXF supports a variety of web service standards including SOAP, the WS-I Basic Profile, WSDL, WS-Addressing, WS-Policy, WS-ReliableMessaging, WS-Security, WS-SecurityPolicy, WS-SecureConverstation, and WS-Trust (partial). Frontends: CXF supports a variety of "frontend" programming models. CXF implements the JAX-WS APIs (TCK compliant). CXF JAX-WS support includes some extensions to the standard that make it significantly easier to use, compared to the reference implementation: It will automatically generate code for request and response bean classes, and does not require a WSDL for simple cases. It also includes a "simple frontend" which allows creation of clients and endpoints without annotations. CXF supports both contract first development with WSDL and code first development starting from Java. For REST, CXF also supports a JAX-RS (TCK compliant) frontend. Ease of use: CXF is designed to be intuitive and easy to use. There are simple APIs to quickly build code-first services, Maven plug-ins to make tooling integration easy, JAX-WS API support, Spring 2.x XML support to make configuration a snap, and much more. Binary and Legacy Protocol Support: CXF has been designed to provide a pluggable architecture that supports not only XML but also non-XML type bindings, such as JSON and CORBA, in combination with any type of transport. To get started using CXF, check out the downloads, the user's guide, or the mailing lists to get more information!
1More
http://www.getopt.org/luke - 1 views
-
Lucene is an Open Source, mature and high-performance Java search engine. It is highly flexible, and scalable from hundreds to millions of documents. Luke is a handy development and diagnostic tool, which accesses already existing Lucene indexes and allows you to display and modify their content in several ways: * browse by document number, or by term * view documents / copy to clipboard * retrieve a ranked list of most frequent terms * execute a search, and browse the results * analyze search results * selectively delete documents from the index * reconstruct the original document fields, edit them and re-insert to the index * optimize indexes * and much more... Recent versions of Luke are also extensible through plugins and scripting. I started this project because I needed a tool like this. I decided to distribute it under Open Source license to express my gratitude to the Lucene team for creating such a high-quality product. Lucene is one of the landmark proofs that Open Source paradigm can result in high-quality and free products.
1More
FAQ How do I increase the heap size available to Eclipse? - Eclipsepedia - 0 views
-
Some JVMs put restrictions on the total amount of memory available on the heap. If you are getting OutOfMemoryErrors while running Eclipse, the VM can be told to let the heap grow to a larger amount by passing the -vmargs command to the Eclipse launcher. For example, the following command would run Eclipse with a heap size of 256MB: eclipse [normal arguments] -vmargs -Xmx256M [more VM args] The arguments after -vmargs are directly passed to the VM. Run java -X for the list of options your VM accepts. Options starting with -X are implementation-specific and may not be applicable to all VMs. You can also put the extra options in eclipse.ini.
1More
shared by Hendy Irawan on 06 Apr 11
- No Cached
Drools & jBPM: AtomPub Interface for Guvnor - 0 views
blog.athico.com/...mpub-interface-for-guvnor.html
jbpm drools atompub interface Guvnor REST XML JSON HTTP API Atom
shared by Hendy Irawan on 06 Apr 11
- No Cached
-
" Further talk about the overall approach to REST access in the Guvnor project expanded from the JIRA issue, ad hoc discussions on the dev list to Jevis Liu's "AtomPub Interface for Guvnor" proposal on the Drools community wikI. Taking off from where Michael Neale's original "Guvnor AtomPub Interface" started in 2008 and expanding into categories, metadata and other return types, this page became a rough, but working implementation specification. "
