Spring Data and Spring
Data Rest
1 / 47
Spring Data framework
Spring Data: https://spring.io/projects/spring-data
Spring Data’s mission is to provide a familiar and consistent,
spring-based programming model for data access while still
retaining the special traits of the underlying data store.
It makes it easy to use data access technologies, relational and
non-relational databases, map-reduce frameworks, and cloud-
based data services.
2 / 47
Features
Dynamic query derivation from repository method names
Support for transparent auditing (created, last changed)
Data Pagination
3 / 47
Most common Spring Data projects
Spring Data JPA - Spring Data repository support for JPA.
Spring Data MongoDB - Spring based, object-document support
and repositories for MongoDB.
Spring Data REST - Exports Spring Data repositories as
hypermedia-driven RESTful resources.
Spring Data Elasticsearch - Spring Data module for Elasticsearch.
4 / 47
Spring Data JPA
5 / 47
Features
Ready made CRUD provided functionality
Dynamic query derivation from repository method names
Manual queries @Query annotated queries
Support for transparent auditing (created, last changed)
Support for Querydsl predicates and thus type-safe JPA queries
Pagination support, dynamic query execution, ability to integrate
custom data access code
6 / 47
Development time
“
Start from eshop code of first lecture. Alternatively one may
wish to start from spring initilizr as an exercise.
At any case please add JPA , Postgresql , Web and
Lombok .
Next slides focus more at changes compared to the
application of the eshop application of the previous lecture.
The build.gradle ends up as follows:
7 / 47
plugins {
id 'org.springframework.boot' version '2.1.4.RELEASE'
id 'java'
}
apply plugin: 'io.spring.dependency-management'
group = 'gr.rongasa'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
configurations {
compileOnly {
extendsFrom annotationProcessor
}
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starte
implementation 'org.springframework.boot:spring-boot-starte
implementation 'org.postgresql:postgresql'
implementation 'org.springframework.boot:spring-boot-starte
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-st
}
8 / 47
Application Configuration
(Postgresql Connection and JPA)
server:
port: 9090 # Set the server's port
servlet:
context-path: /jpa # Set context path of application serve
...
9 / 47
...
spring:
application:
name: e-shop # Set the application name.
data:
jpa:
repositories:
enabled: true
datasource: # Setup datasource
hikari:
connection-timeout: 20000
maximum-pool-size: 5
url: jdbc:postgresql://localhost:5432/eshop
username: eshop
password: eshop@@@
jpa: #JPA properties
hibernate:
ddl-auto: update
show-sql: true
database: postgresql
database-platform: org.hibernate.dialect.PostgreSQL95Dialec
open-in-view: false # Significant attribute. Dont open tr
properties:
hibernate:
jdbc:
lob:
non_contextual_creation: true
10 / 47
The Domain object
package gr.rongasa.eshop.domain;
import lombok.*;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.math.BigDecimal;
@Entity
@Table
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
@Setter
public class Inventory {
@Id
@GeneratedValue
private Long id;
private String name;
private Long amount;
private String description;
private String type;
private BigDecimal cost;
} 11 / 47
Repository
import gr.rongasa.eshop.domain.Inventory;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
public interface InventoryRepository extends JpaRepository<Inve
Page<Inventory> findAllByType(Pageable pageable, String typ
Page<Inventory> findAllByName(Pageable pageable, String typ
}
12 / 47
Database Configuration
package gr.rongasa.eshop.configuration;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpa
@Configuration
@EnableJpaRepositories(basePackages = {"gr.rongasa.eshop.reposi
@Slf4j
public class DatabaseConfiguration {
@Bean
public CommandLineRunner stupidBean(){
return args -> log.info("JPA java code started");
}
}
13 / 47
Result
The conversion from Spring Data elasticSearch to spring data JPA
is done. This is what is meant with familiar and consistent model
for data layer access. Consider how few changes were made to
move from two completely different database technologies.
We could allow the concurrent existence of elasticSearch and JPA
connection
We changed domain id from String to Long. Elastic search
performs better/easier with String id while
Be careful with the @Id and from which path this is imported from.
javax.persistence.Id; is for JPA and
org.springframework.data.annotation.Id; is for non
relational databases.
14 / 47
Means of Database Queries
The repository proxy has two ways to derive a store-specific query
from the method name:
By deriving the query from the method name directly.
By using a manually defined query.
15 / 47
Query from method name
findFirst/ findTop
findAllBy or findBy
distinct
existsBy
delete
count
orderBy
asc, desc
e.g.
Page<Inventory> findAllByType(Pageable pageable, String type);
Page<Inventory> findAllByName(Pageable pageable, String type);
void deleteByType(String type);
boolean existsByType(String type);
long countByType(String type);
16 / 47
Supported method Names
keywords
Keyword Keyword Keyword Keyword
And LessThan After Like
Or LessThanEqual Before NotLike
Is, Equals GreaterThan IsNull StartingWith
Between GreaterThanEqual IsNotNull,NotNull EndingWith
Containing OrderBy Not In
NotIn True False IgnoreCase
Page<Inventory> findByTypeAndAmountGreaterThanOrderByCost(P
Optional<Inventory> findFirstByNameAndTypeOrderByCost(Strin
Page<Inventory> findDistinctTop2ByAmountLessThanOrderByAmou
Page<Inventory> findDistinctTop2ByAmountLessThanOrderByAmou
Page<Inventory> findByNameContaining(Pageable pageable, Str
Page<Inventory> findByNameEndingWith(Pageable pageable, Str17 / 47
Query
JPQL or native queries are supported in Spring data repositories
e.g.
@Query("select i from Inventory i where i.description=?1")
Inventory getInventory(String details);
@Query(value = "select * from Inventory where i.description=?1"
Inventory getInventoryByNativeQuery(String details);
@Query("select i from Inventory i where i.description=descr")
Inventory getInventoryByNamedParam(@Param("descr") String descr
18 / 47
Query
Propose to avoid Queries and even more native queries. However,
although spring data provides practically almost everything,
sometimes JPA query may be the only way.
Hard to move from one database engine to another
Less readable
More difficult to detect issues before running the application
One reason that query may be needed is when we wish to query
something like the following (entity.x=:a OR entity.x=:b)
AND (entity.y=:c OR entity.y=:d)
19 / 47
Entity Graph
*ToMany relationships are lazy fetch. This means you cannot get
i.e. the members without a transaction
Repository methods open a transaction inside method call and
close it after method exit.
EntityGraph is a performant way of eagerly fetching inner entities
after repository method returns
@Entity
public class GroupInfo {
// default fetch mode is lazy.
@ManyToMany
List<GroupMember> members = new ArrayList<GroupMember>();
…
}
@Repository
public interface GroupRepository extends CrudRepository<GroupIn
@EntityGraph(attributePaths = { "members" })
GroupInfo getByGroupName(String name);
} 20 / 47
Named Entity Graph
Instead of constructing and using EntityGraph inside repository one
create named entity graphs and then use these inside the repository
@Entity
@NamedEntityGraph(
name = "members-graph",
attributeNodes = {
@NamedAttributeNode("members")
}
)
public class GroupInfo {
// default fetch mode is lazy.
@ManyToMany
List<GroupMember> members = new ArrayList<GroupMember>();
…
}
@Repository
public interface GroupRepository extends CrudRepository<GroupIn
@EntityGraph(value = "members-graph")
GroupInfo getByGroupName(String name);
}
21 / 47
Common Mistakes/Improvements
JPA prerequisite information
@OneToOne : Eager fetch
@OneToMany : Lazy fetch
Typically relationships are bidirectional (when possibly make them
unidirectional).
Attention:
Bidirectional relationships during update and submit and first level
cache. One needs to update both directions to avoid problems.
Take special care with equals, hashCode and toString overrides at
entity level when having relationships (especially now with
lombok)
Danger of stack overflow
Danger of performance issues simply when adding just
logging
private methods annotated with transaction will not cope into
opening a transaction.
22 / 47
Common Mistakes/Improvements
Use transactions at Service level at most Avoid opening
transaction at controller.
Mapping of database entities into data transfer objects is a good
way of controlling transactions
Only get from entity what is needed
Set into entity before saving into database bidirectional
relationships
Usage of EntityGraph a good way of keeping transaction as small
as possible
When using relational database utilize database versioning and
migration tools like Liquidbase or Flyway
Don't skip this step as migrating from one version to another
will be problematic without these tools and also it is harder to
introduce these tools at a latter stage.
23 / 47
Spring Data Rest
24 / 47
Spring Data Rest is an 'extension' of Spring Data that exposes over
REST the spring data methods that exist in spring data repositories.
Impressive at first look and useful for rapid
development results.
Use it only for testing, development prototype or only
when product is really simple
If used in bigger products you bind domain model
with rest consumer. Architecturally wise this is huge
mistake that sooner or latter it will add huge
complexity.
Spring data rest is the best demonstration of
HATEOAS.
25 / 47
Spring Data Rest
Add in gradle the following dependency
implementation 'org.springframework.boot:spring-boot-starter-da
Add in all custom repository methods that you wish to expose over
rest and have method parameters the @Param annotation.
public interface GroupInfoRepository extends JpaRepository<Grou
@EntityGraph(value = "members")
Page<GroupInfo> findAllByMembersName(@Param("name") String
}
Add the spring data rest path in application.yml
data:
rest:
base-path: api
26 / 47
Spring Data Rest - HATEOAS
curl -X GET http://localhost:9090/jpa/api
Notice that spring data repositories are exposed over rest.
{
"_links": {
"groupInfoes": {
"href": "http://localhost:9090/jpa/api/groupInfoes{
"templated": true
},
"groupMembers": {
"href": "http://localhost:9090/jpa/api/groupMembers
"templated": true
},
"inventories": {
"href": "http://localhost:9090/jpa/api/inventories{
"templated": true
},
"profile": {
"href": "http://localhost:9090/jpa/api/profile"
}
}
} 27 / 47
HATEOAS/HAL
“
Spring data REST exposes all entities using
HATEOAS.
HATEOAS is a REST API architecture concept which
defines that REST resource models include
hypermedia links in such a way that clients can
navigate to the complete Rest Interface.
Clients may start from root context path and by
following hateoas link names expose the complete API.
28 / 47
Spring Data REST
"inventories": {
"href": "http://localhost:9090/jpa/api/inventories{?pag
"templated": true
},
tempalated means that page, size, sort are part of query template.
i.e. http://localhost:9090/jpa/api/inventories?
page=1&size=10&sort=id,asc
29 / 47
{
"_embedded": { "inventories": [] },
"_links": {
"first": {
"href": "http://localhost:9090/jpa/api/inventories?
},
"prev": {
"href": "http://localhost:9090/jpa/api/inventories?
},
"self": {
"href": "http://localhost:9090/jpa/api/inventories"
},
"last": {
"href": "http://localhost:9090/jpa/api/inventories?
},
"profile": {
"href": "http://localhost:9090/jpa/api/profile/inve
},
"search": {
"href": "http://localhost:9090/jpa/api/inventories/
}
},
"page": {
"size": 10,
"totalElements": 0,
"totalPages": 0,
"number": 1
}
} 30 / 47
Create new object
curl -X POST http://localhost:9090/jpa/api/inventories -H 'Cont
-d '{
"name": "book",
"amount": 10,
"description": "custom rwritten book",
"type": "book",
"cost": 10.45
}'
31 / 47
Result
{
"name": "book",
"amount": 10,
"description": "custom rwritten book",
"type": "book",
"cost": 10.45,
"_links": {
"self": {
"href": "http://localhost:9090/jpa/api/inventories/
},
"inventory": {
"href": "http://localhost:9090/jpa/api/inventories/
}
}
}
32 / 47
Update new Object
curl -X PUT \
http://localhost:9090/jpa/api/inventories/3 \
-H 'Content-Type: application/json' \
-d '{
"name": "book",
"amount": 10,
"description": "custom rwritten book",
"type": "book",
"cost": 10.45
}'
33 / 47
{
"name": "book",
"amount": 10,
"description": "custom rwritten book",
"type": "book",
"cost": 10.45,
"_links": {
"self": {
"href": "http://localhost:9090/jpa/api/inventories/
},
"inventory": {
"href": "http://localhost:9090/jpa/api/inventories/
}
}
}
34 / 47
Search Hypermedia Link
Ensure you have added in spring data custom repository method
@Param annotation at method parameters
After creating an Inventory object locate hypermedia link named
search and make a GET request. i.e.
http://localhost:9090/jpa/api/inventories/search
35 / 47
All custom methods created are exposed and can be used
{
"_links": {
"updateMediaType": {
"href": "http://localhost:9090/jpa/api/inventories/
"templated": true
},
"findByAmountIsBetween": {
"href": "http://localhost:9090/jpa/api/inventories/
"templated": true
},
"findByTypeAndAmountGreaterThanOrderByCost": {
"href": "http://localhost:9090/jpa/api/inventories/
"templated": true
},
...
"self": {
"href": "http://localhost:9090/jpa/api/inventories/
}
}
}
36 / 47
Spring Data REST Tips
And Tricks
37 / 47
You can annotate as @RestResource(exported = false) a
Repository (method or class) to define it as not exposed over web
You can configure Repositoriies (i.e. expose id) by using
RepositoryRestConfigurer
@Configuration
public class RestConfiguration {
@Bean
public RepositoryRestConfigurer repositoryRestConfigurer()
return new RepositoryRestConfigurer() {
@Override
public void configureRepositoryRestConfiguration(Re
config.exposeIdsFor(Inventory.class);
}
};
}
}
38 / 47
You can enable HAL Browser to assist with spring data rest
experience:
implementation 'org.springframework.data:spring-data-rest-hal-b
Now open the Spring Data Rest base url via browser and
check the result.
A UI regarding exposed rest methods is provided.
39 / 47
Spring Data Tips And
Tricks
40 / 47
You can load initial data via CommandLineRunner
@Component
@RequiredArgsConstructor
public class DatabaseDataInitialization implements CommandLineR
private final InventoryRepository inventoryRepository;
@Override
public void run(String... args) {
if (inventoryRepository.countByType("book")==0){
inventoryRepository.saveAll(Stream.of("Spring Boot"
.collect(Collectors.toList()));
}
}
}
41 / 47
Spring Data MongoDB
42 / 47
Lets switch this project now to NoSQL/MongoDB.
Then we have seen the same project in ElasticSearch (1st
lecture), in JPA (Postgresql) and MongoDB.
43 / 47
Prepare Dependencies
In gradle remove 'org.springframework.boot:spring-boot-starter-
data-jpa' and 'org.postgresql:postgresql' from dependencies
In gradle add 'org.springframework.boot:spring-boot-starter-data-
mongodb' as dependency
Prepare Domain model
In Domain objects replace @Entity, @Table with @Document
In Domain objects remove @GeneratedValue and
@ManyToMany, @OneToOne
In Domain objects replace id of type Long with String, BigInteger,
or ObjectID
Remove from Domain objects and repositories anything that has
to do with EntityGraph (@EntityGraph and @NamedEntityGraph)
Ensure @Id is from import org.springframework.data.annotation.Id
44 / 47
Prepare Repositories
In repositories replace JpaRepository interface with
MongoRepository
In repositories remove Modifying queries
In Repositories native queries are not considered (all queries are
native)
In Repositories modify jpa queries to match mongodb query
language
In database configuration replace EnableJpaRepositories with
EnableMongoRepositories
45 / 47
Exercise 1
Purpose: Gain experience with Spring Data and Spring Data Rest.
46 / 47
Description
You need to extend the simple Library Management System (exercise
of first lecture) and add the same information added into elasticsearch
into postgresql database. This means that it has been decided to
support two databases in parallel.
Postgresql will not be exposed over web using Spring Data Rest.
Elasticsearch database will be exposed over REST.
One extra method supported over web will be the post method
''/synch' which will synchronize all data from Postgresql to elastic
search.
From elasticSearch repositories it has been decided to expose
over rest all the get methods but hide/disable the database
modifying methods and allow modification only via the existing
controller.
It is decided to use flyway as a migration tool for JPA database.
47 / 47
