If you are using the Spring Framework and have no restrictions regarding that, we recommend to use spring-data-jpa via devon4j-starter-spring-data-jpa that brings advanced integration (esp. for QueryDSL).
The benefits of spring-data are (for examples and explanations see next sections):
-
All you need is one single repository interface for each entity. No need for a separate implementation or other code artifacts like XML descriptors,
NamedQueries
class, etc. -
You have all information together in one place (the repository interface) that actually belong together (where as in the classic approach you have the static queries in an XML file, constants to them in
NamedQueries
class and referencing usages in DAO implementation classes). -
Static queries are most simple to realize as you do not need to write any method body. This means you can develop faster.
-
Support for paging is already build-in. Again for static query method the is nothing you have to do except using the paging objects in the signature.
-
Still you have the freedom to write custom implementations via default methods within the repository interface (e.g. for dynamic queries).
For each entity «Entity»Entity
an interface is created with the name «Entity»Repository
extending DefaultRepository
.
Such repository is the analogy to a Data-Access-Object (DAO) used in the classic approach or when spring-data is not an option.
The following example shows how to write such a repository:
public interface ExampleRepository extends DefaultRepository<ExampleEntity> {
@Query("SELECT example FROM ExampleEntity example" //
+ " WHERE example.name = :name")
List<ExampleEntity> findByName(@Param("name") String name);
@Query("SELECT example FROM ExampleEntity example" //
+ " WHERE example.name = :name")
Page<ExampleEntity> findByNamePaginated(@Param("name") String name, Pageable pageable);
default Page<ExampleEntity> findByCriteria(ExampleSearchCriteriaTo criteria) {
ExampleEntity alias = newDslAlias();
JPAQuery<ExampleEntity> query = newDslQuery(alias);
String name = criteria.getName();
if ((name != null) && !name.isEmpty()) {
QueryUtil.get().whereString(query, $(alias.getName()), name, criteria.getNameOption());
}
return QueryUtil.get().findPaginated(criteria.getPageable(), query, false);
}
}
This ExampleRepository
has the following features:
-
CRUD support from spring-data (see JavaDoc for details).
-
Support for QueryDSL integration, paging and more as well as locking via GenericRepository
-
A static query method
findByName
to find allExampleEntity
instances from DB that have the given name. Please note the@Param
annotation that links the method parameter with the variable inside the query (:name
). -
The same with pagination support via
findByNamePaginated
method. -
A dynamic query method
findByCriteria
showing the QueryDSL and paging integration into spring-data provided by devon.
You can also read the JUnit test-case DefaultRepositoryTest that is testing an example FooRepository.
In case you need auditing, you only need to extend DefaultRevisionedRepository
instead of DefaultRepository
. The auditing methods can be found in GenericRevisionedRepository.
In case you want to switch to or add spring-data support to your devon application all you need is this maven dependency:
<!-- Starter for consuming REST services -->
<dependency>
<groupId>com.devonfw.java.starters</groupId>
<artifactId>devon4j-starter-spring-data-jpa</artifactId>
</dependency>
Spring-data also has some drawbacks:
-
Some kind of magic behind the scenes that are not so easy to understand. So in case you want to extend all your repositories without providing the implementation via a default method in a parent repository interface you need to deep-dive into spring-data. We assume that you do not need that and hope what spring-data and devon already provides out-of-the-box is already sufficient.
-
The spring-data magic also includes guessing the query from the method name. This is not easy to understand and especially to debug. Our suggestion is not to use this feature at all and either provide a
@Query
annotation or an implementation via default method.