1) O documento apresenta Spring Data Neo4j, um framework que simplifica o acesso a dados armazenados no banco de grafos Neo4j através do Spring Framework. 2) Spring Data cria repositórios que implementam operações CRUD e queries de forma automática, diminuindo muito o código repetitivo de acesso a dados. 3) Spring Data Neo4j mapeia objetos Java para nós e relacionamentos no Neo4j, permitindo consultas por métodos em repositórios de forma declarativa.

1. SPRING DATA
NEO4JAPRESENTADO POR IVAN QUEIROZ

2. QUEM?
Bacharel em
Sistemas de
Informação
Desenvolvedor
Java
Certificação
SCJP 5 (OCJP)
Empresa de
Telecomunicações
Blog
blog.ivanqueiroz.com
2
Atualmente
Área Jurídica

3. AGENDA
Alguns Conceitos
Framework, IoC, DI, banco de grafos e
neo4j
Spring Framework
Alta produtividade em aplicações Java
Spring Data
Simplificando o acesso aos dados
Spring Data Neo4j
Diminuindo o trabalho repetitivo
01
02
03
04
3
Quando Usar
Vantagens e desvantagens05
06Encerrando
Um longo caminho pela frente

4. 4
Alguns Conceitos
Framework, IoC, DI, banco de grafos e neo4j

5. 5
FRAMEWORK CÓDIGO BIBLIOTECA
FRAMEWORK
Facilita a construção do software por deixar que o
desenvolvedor se preocupe com o que realmente
importa

6. 6
INVERSÃO DE
CONTROLE
Ou Inversion of Control (IoC) é um padrão onde
as chamadas das ações da aplicação não são
determinados pelo desenvolvedor e o controle é
“invertido” para uma infraestrutura de software.
Também chamado carinhosamente de “Princípio de Hollywood”
(don’t call us, we’ll call you).

7. 7
INJEÇÃO DE
DEPENDÊNCIA
A dependência entre os módulos é controlada
por uma infraestrutura de software responsável
por “injetar” a mesma quando necessária.
@Controller
public class TarefasController {
private final JdbcTarefaDao dao;
@Autowired
public TarefasController(JdbcTarefaDao dao) {
this.dao = dao;
}
@RequestMapping(“adicionaTarefa”)
public void adiciona(Tarefa tarefa) {
dao.adiciona(tarefa);
// ...
}
}

8. 8
BANCO DE
GRAFOS
Armazena estruturas em formato de grafos (nó e
relacionamento), onde cada nó conhece o nó
adjacente permitindo aumentar o número de
nós sem perder performance na busca.
Tem
Filme
Roteiro Roteirista
Ator
Data de
Estréia
Atuou
Participou
TemTem
Escrito por

9. 9
NEO4J ‘O’
BANCO DE
GRAFOS
Criado pela Neo Technology em 2003 se tornou o
principal banco de grafos. É código aberto escrito
sobre a JVM (Scala e Java), é escalável, ACID tem
suporte a alta disponibilidade (enterprise). Possui
modo standalone e embedded, linguagem de
consulta própria (Cypher) e interface REST.
4J

10. 10
SPRING
FRAMEWORK
Alta produtividade em aplicações

11. 11
O QUE É ?
Framework open source em Java criado
por Rod Johnson que utiliza os
conceitos de inversão de controle e
injeção de dependência para simplificar
o desenvolvimento de aplicações
utilizando Plain Old Java Objects
(POJOs) e interfaces.
CONTAINER SPRING
No núcleo do Spring está um container que injeta (DI) e
gerencia o ciclo de vida das dependências (IoC).
CONFIGURAÇÃO FLEXÍVEL
O Spring permite que as configurações sejam por
anotações, xml, convenção ou programaticamente.
NÃO INTRUSIVO
A construção do Spring foi realizada para que a lógica de
domínio geralmente não tenha dependências do
framework.
VÁRIOS MÓDULOS DISPONÍVEIS
Além de ser compatível com o JEE o Spring possui
diversos módulos para suprir as mais diversas
necessidades.

12. 12
COMO OBTER
INFORMAÇÕES?
No endereço spring.io/projects pode-se
encontrar de forma organizada, todas as
informações necessárias para configurar e iniciar
a construção de uma aplicação utilizando os
módulos do Spring

13. 13
SPRING DATA
Simplificando o acesso a dados

14. 14
SPRING DATA
SPRING DATA
MONGODB
MongoRepository
MongoTemplate
SPRING DATA JPA
JpaRepository
SPRING DATA
NEO4J
GraphRepository
Neo4jTemplate
SPRING DATA
...
Embedded REST
JPA
JDBC
RDBMS
Mongo Java Driver
MongoDB Neo4J ...
SIMPLIFICAR
O projeto Spring Data tem como objetivo
simplificar as operações de acesso a dados
nas aplicações, diminuindo o código
escrito e mantendo a integração com todo
ambiente Spring já existente.

15. 15
MODELO DE PROGRAMAÇÃO
DO SPRING DATA
02REPOSITORY
Abstração principal do
modelo Spring Data,
gerencia a classe de
domínio e define as
operações de acesso aos
dados.
03QUERY METHODS
Métodos de consulta que
possuem uma convenção de
nome o qual o Spring Data
fornece uma implementação
em tempo de execução.
01INTERFACES
A maior parte das
implementações são
realizadas pelo Spring Data,
o desenvolvedor irá se
ocupar mais com as
definições de interfaces.
04TEMPLATES
O Spring Data fornece vários
templates (modelos) para
cuidar da alocação de
recursos e tradução de
exceções.

16. 16
PRINCIPAIS
INTERFACES
public interface CrudRepository<T,ID extends Serializable> extends Repository {
<S extends T> S save(S entity);
T findOne(ID primaryKey);
Iterable<T> findAll();
Long count();
void delete(T entity);
boolean exists(ID primaryKey);
}
REPOSITORY
Interface central da abstração do Spring Data. É uma interface de marcação para o spring poder obter
os tipos que irá trabalhar e para ajudar o desenvolvedor a descobrir outras interfaces.
public interface Repository<T,ID extends Serializable> {}
CRUD REPOSITORY
Interface que provê os métodos para as operações de Create Read Update e Delete (CRUD). Estende a
interface Repository e assim como a interface pai ela recebe o tipo da entidade e o tipo do campo id da
entidade.

17. 17
PRINCIPAIS
INTERFACES
PAGING AND SORTING REPOSITORY
Extendendo a CrudRepository existe a PagingAndSortingRepository que adiciona métodos para efetuar
facilmente as operações de paginação.
public interface PagingAndSortingRepository<T,ID extends Serializable> extends
CrudRepository<T, ID> {
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pageable);
}

18. 18
SPRING DATA NEO4J
Diminuindo o trabalho repetitivo

19. 19
OGM (Object
Graph
Mapping)
Técnica para relacionar
o objeto com o dado
que ele representa no
banco de grafos.
Objetos
CamadadeMapeamento
OGM
Banco de
Grafos

20. 20
SPRING DATA
NEO4J 4
A partir da versão 4 a
estrutura do framework
foi dividida e obteve
mais flexibilidade.
@Classe Java Anotações
@Node
Entity
@Graph
Id
Entidade
Neo4JTransactionManager Neo4JRepository
Session
Spring Data Neo4J (SDN)
SessionFactory Configuration
Spring Data Neo4J (SDN)
Neo4J Bolt Driver
Neo4J HTTP
Driver
Neo4J Embedded
Driver
Banco de Dados Gráfico Neo4J
Bolt HTTP Java

21. 21
Exemplo
SessionFactory sessionFactory = new SessionFactory("movies.domain");
Session session = sessionFactory.openSession();
Movie movie = new Movie("The Matrix", 1999);
Actor keanu = new Actor("Keanu Reeves");
keanu.actsIn(movie);
Actor carrie = new Actor("Carrie-Ann Moss");
carrie.actsIn(movie);
session.save(movie);
@NodeEntity
public class Tarefa {
@GraphId
private Long id;
private String name;
@Relationship(type = "ACTS_IN", direction = "OUTGOING")
private Set<Movie> movies = new HashSet<>();
}
Movie matrix = session.load(Movie.class,
movie.getId());
for(Actor actor : matrix.getActors()) {
System.out.println("Actor: " +
actor.getName());
}

22. 22
DAO
SIMPLES
Utilizando a abordagem tradicional do
DAO.
MODEL
public class User{
private String name;
//Get e Sets
}
DAO
public class UserDao{
private Connection con;
private Statement comando;
public List<User> findAll() {
List<User> result = new ArrayList<User>();
ResultSet rs;
try {
rs = comando.executeQuery("MATCH (n:User) RETURN
n.name");
while (rs.next()) {
User temp = new User();
temp.setName(rs.getString("n.name"));
result.add(temp);
}
return result ;
}
...

23. 23
SPRING
DATA
NEO4J
Ao criar uma interface que estende a
interface Repository, o próprio Spring
Data se encarrega de implementar os
métodos.
ENTITY
@NodeEntity
public class Movie {
@GraphId Long id;
String title;
Person director;
@Relationship(type="ACTS_IN", direction =
Relationship.INCOMING)
Set<Person> actors;
@Relationship(type = "RATED")
List<Rating> ratings;
}
REPOSITORY
public interface MovieRepository extends
Repository<Movie, Long> {}

24. 24
@NoRepositoryBean
interface BaseRepository<T, ID extends Serializable> extends Repository<T, ID> {
T findOne(ID id);
T save(T entity);
}
interface PessoaRepository extends BaseRepository<User, Long> {
User findByEmail(Email email);
}
REPOSITORY
CUSTOMIZADO
É possível personalizar os repositórios criando novos
métodos

25. 25
QUERY
METHODS
São métodos de busca declarados
na interface do repositório que são
examinados e interpretados pela
infraestrutura do Spring Data para
gerar as consultas.
public interface PersonRepository extends Repository<User, Long> {
List<Person> findByName(String name);
}
MATCH (:Actor {name:{name}}) return m

26. 26
QUERY
LOOKUPS
É como o Spring Data realiza a
busca das queries. Atualmente
existem três formas.
CREATE
01
USE_DECLARED_QUERY
02
CREATE_IF_NOT_FOUND
03
<repositories query-lookup-strategy="use-declared-query"/>

27. 27
CREATE
Quebra os query methods pelo
prefixo e o nome das propriedades
Keyword Sample Cypher snippet
And findByAgeAndMarried MATCH (person:Person)
WHERE person.age = {0} AND
person.married = {1}
RETURN person
Or findByAgeOrMarried MATCH (person:Person)
WHERE person.age = {0} OR
person.married = {1}
RETURN person

28. 28
CREATE
Acessando propriedades
transversais
Pessoa que tem um Endereco que tem um Cep
List<Pessoa> findByEnderecoCep(Cep cep);
Definindo manualmente o ponto de transversão
List<Pessoa> findByEndereco_Cep(Cep cep);

29. 29
XML CLASSE JAVA
<named-query name="User.findByLastname">
<query>MATCH (n) WHERE id(n)={0} RETURN n</query>
</named-query>
@NodeEntity
public class Movie {
@GraphId
private Long id;
private String title;
private int released;
...
REPOSITORY
@NodeEntity
public class MovieRepository extends Neo4jRepository<Movie> {
@Query(name = "MATCH (n) WHERE id(n)={0} RETURN n")
Movie getMovieFromId(Integer idOfMovie);
}
USE_DECLARED_QUERY
Utiliza apenas queries declaradas

30. 30
USE_DECLARED_QUERY
Utiliza apenas queries declaradas
@Query - Anotação
@Query("MATCH (n) WHERE id(n)={0} RETURN n")
Movie getMovieFromId(Integer idOfMovie);
@Query("MATCH (movie:Movie {title={0}}) RETURN movie")
Movie getMovieFromTitle(String movieTitle);
@Query("MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor")
Page<Actor> getActorsThatActInMovieFromTitle(String movieTitle, PageRequest page);
@Query("MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor", countQuery = "MATCH
(movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN count(*)")
Page<Actor> getActorsThatActInMovieFromTitle(String movieTitle, Pageable page);
@Query("MATCH (movie:Movie {title={0}})<-[:ACTS_IN]-(actor) RETURN actor")
Slice<Actor> getActorsThatActInMovieFromTitle(String movieTitle, Pageable page);

31. 31
LIMITANDO
RESULTADOS
User findFirstByOrderByLastnameAsc();
User findTopByOrderByAgeDesc();
Page<User> queryFirst10ByLastname(String lastname, Pageable
pageable);
Slice<User> findTop3ByLastname(String lastname, Pageable pageable);
List<User> findFirst10ByLastname(String lastname, Sort sort);
List<User> findTop10ByLastname(String lastname, Pageable pageable);

32. 32
QUANDO USAR
Vantagens e desvantagens

33. 33
VANTAGENS
Suporte a paginação, execução dinâmica de
consultas e possibilidade de utilizar código
customizado para acessar a base de dados.
Sofisticado suporte para criação de
repositórios que diminui muito código
repetitivo.
As consultas são compiladas na inicialização
do contexto Spring, facilitando a detecção
de erros de sintaxe.
Suporte a alta disponibilidade e a eventos de
persistência.

34. 34
DESVANTAGEN
S
Nomes dos métodos dos repositórios podem
se tornar grandes em longas ou complicadas
consultas.
Consulta nativa é mais performática.
A Neo4j API também é mais
performática.

35. 35
ENCERRANDO
Um longo caminho pela frente

36. 36
FONTES
SITES
● InfoQ - https://www.infoq.com/br/articles/spring-data-intro
Artigo - Spring Data: A solução mais geral para persistência?
Acessado em 09/2016
● Spring Data Neo4j reference -
http://docs.spring.io/spring-data/data-neo4j/docs/4.2.1.RELEASE/reference/html/
Acessado em 09/2016
● Spring Framework reference -
http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/
Acessado em 09/2016

37. 37
DÚVIDAS?

38. 38
OBRIGADO!
ivanqueiroz@gmail.com
@ivanqueiroz
@javabahia