Skip to content

Home

Jump to bottom
Igor Avila Pereira edited this page Dec 16, 2024 · 43 revisions

Cronograma

  • 09/12 - atividade avaliada

Guia Rápido

Importante

        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
  • Por:
        <maven.compiler.source>18</maven.compiler.source>
        <maven.compiler.target>18</maven.compiler.target>

ou 20, ou 22

Vídeos

Aulas

09/12 - atividade avaliada

02/12 - Neo4j (aula 2)

Código

Links Complementares:

CSV - Disciplinas e Pré-requisitos:

CSV - Amigos e Amizades:

25/11 - Neo4j (aula 1)

-- 1ª vez
sudo docker run \
--publish=7474:7474 --publish=7687:7687 \
--volume=$HOME/neo4j/data:/data \
--env=NEO4J_AUTH=neo4j/password \
--name neo4j neo4j

-- demais vezes
sudo docker start neo4j
sudo docker exec -it neo4j bash

Obs: Acessar por http://localhost:7474/

login: neo4j e senha: password

-- criar um nó
CREATE(p:Pessoa{cpf: "111.111.111-11", nome: "joao", idade:20})
return p

-- retornar todas pessoas
MATCH(p:Pessoa) RETURN p

-- select
match(p:Pessoa) where p.cpf = "111.111.111-11"
return p

match(p:Pessoa) where p.cpf = "111.111.111-11" or ....
return p

match(p:Pessoa) where p.cpf = "111.111.111-11" and ....
return p

-- amigos dos meus amigos (eu sendo "Pedro"). Retorno: "João"
MATCH (:Pessoa{nome: "Pedro"})<-[:AMIGO]-()<-[:AMIGO]-(p) return p

-- criar uma aresta entre nodos

-- exemplo 1
MATCH (p1:Pessoa), (p2:Pessoa)
where p1.nome = "João" and p2.nome = "Maria" 
CREATE (p1)-[:AMIGO]->(p2)

-- exemplo 2
MATCH (p1:Pessoa), (p2:Pessoa)
where ID(p1) = 10 and ID(p2) = 11
CREATE (p1)-[:AMIGO]->(p2)

-- exemplo3 (criando os nodos e a aresta ao mesmo tempo)
CREATE (a:a {a: 'a'})-[r:a]->(b:a {a: 'a'})

-- aresta com atributo
MATCH (p1:Pessoa), (p2:Pessoa) 
WHERE p1.nome = "João" AND p2.nome = "Maria" 
CREATE (p1)-[:AMIGO1{desde:"19/11/2020"}]->(p2)

-- update
MATCH (p:Pessoa) where p.nome = "Pedro"
set p.nome = "Pedro silva"

-- delete o nodo
MATCH (p:Pessoa) where p.nome = "Pedro silva"
Delete p

-- deletar relacionamentos AMIGO de joão
MATCH (:Pessoa{nome: 'joao'})-[a:AMIGO]-()
DELETE a

-- delete o nodo e seus relacionamentos
MATCH (p:Pessoa) where p.nome = "Pedro silva"
detach Delete p

-- delete tudo
MATCH (n)
DETACH DELETE n

Driver JAVA-NEO4J:

<dependencies>
<dependency>
<groupId>org.neo4j.driver</groupId>
<artifactId>neo4j-java-driver</artifactId>
<version>4.4.0</version>
</dependency>
</dependencies>
package view;
import model.Pessoa;
import org.neo4j.driver.*;
import java.time.LocalDate;
import java.util.stream.Collectors;
import static org.neo4j.driver.Values.parameters;

public class App {
    public static void main(String[] args) {

        Driver driver = GraphDatabase.driver("bolt://localhost:7687",
                AuthTokens.basic("neo4j", "neo4j*"));

        Pessoa pessoa = new Pessoa("222.222.222-02", "Maria",
                LocalDate.of(1993,10,25));

        try(Session session = driver.session()){

            // Adicionando uma pessoa
            Result result = session.run("CREATE (p:Pessoa{cpf:$cpf, nome:$nome, nascimento:$nascimento})",
                    parameters("cpf", pessoa.getCpf(), "nome", pessoa.getNome(),
                            "nascimento", pessoa.getNascimento()));
            System.out.println(result.consume().counters().nodesCreated());

            // Criar um relacionamento
            Result result = session.run("MATCH (p1:Pessoa{cpf:$cpf}),(p2:Pessoa{cpf:$cpf2})" +
                    "CREATE (p1)-[:AMIGO]->(p2)",
                    parameters("cpf", "111.111.111-01", "cpf2", "222.222.222-02"));
            System.out.println(result.consume().counters().relationshipsCreated());

            // Recuperando todas as pessoas
            Result result = session.run("MATCH (p:Pessoa) RETURN p.cpf, p.nome, p.nascimento");
            System.out.println(result.stream().map(record ->
                    new Pessoa(record.get(0).asString(),
                    record.get(1).asString(),
                    record.get(2).asLocalDate()))
                    .collect(Collectors.toList()));

          // Buscando os CPFs de todos os amigos de uma pessoa
          Result result = session.run("MATCH (p:Pessoa{cpf:$cpf})-[:AMIGO]->(p2) RETURN p2",
                    parameters("cpf", "111.111.111-01"));
            result.list().forEach(r -> System.out.println(r.get(0).asNode().values()));
        } finally {
            driver.close();
        }
    }
}

Links Complementares:

Vídeos:

11/11 - Mongodb

Slides

Código

Instalação/Rodando

Material Complementar:

Outros:

  • Principais Comandos
-- Criando/Selecionar um BD
use minhaBase
-- retornar collection users
1) db.users
2) db.getCollection("users")
-- inserir
db.users.insert({"name": "codigo"}) -- legacy
db.users.insertOne({"name": "codigo"}) -- current
-- listar todos
db.users.find()
-- Update
db.users.update({"name": "Igor"},{"name": "novo"}) -- legacy
db.users.updateOne({"name": "Igor"},{$set:{"name":"Igor Pereira"}}) -- current
-- Delete
db.users.remove({"name": "codigo"}) -- legacy
db.users.deleteOne({"name": "codigo"}) -- current

Links:

MongoDB Java Driver

String uri = "mongodb://localhost:27017";
  • Instalação via Maven
    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
            <version>4.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.7</version>
        </dependency>
    </dependencies>

References:

Extras:

-- updateOne
try {
   db.users.updateOne(
      { "nome" : "max" },
      { $set: { "nome" : "maximiliano" } }
   );
} catch (e) {
   print(e);
}

-- removeOne
try {
   db.users.deleteOne( { "_id" : ObjectId("634dea8922941a787369e69a")} );
} catch (e) {
   print(e);
}

-- find 
db.users.find({"nome": "igor"})
db.users.find({nome:{$in:["igor", "erick"]}})

04/11 - Atividade Avaliada

21/10 - Redis

Introdução NoSQL + REDIS

Código Aula

Instalação

Instalação Ubuntu/Debian/Linux Mint

sudo apt-get update 
sudo apt-get install redis-server

Instalação Docker

-- 1ª vez
docker run --name redis -p 6379:6379 -d redis:latest
docker exec -it redis redis-cli
-- demais vezes
sudo docker start redis
sudo docker exec -it redis redis-cli

Client

redis-cli

Material Complementar - REDIS

Jedis

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.0</version>
</dependency>
-- 1)
JedisPool pool = new JedisPool("localhost", 6379);
try (Jedis jedis = pool.getResource()) {
  jedis.set("clientName", "Jedis");
}
-- 2) 
JedisPooled jedis = new JedisPooled("localhost", 6379);

Links:

GSON:

Gson

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.10.1</version>
</dependency>

Se usar datas (LocalDate ou LocalDateTime) será preciso serializar e deserializar:

  1. Criar um objeto Gson com GsonBuilder:
-- se for LocalDate
Gson gson = new GsonBuilder()
.registerTypeAdapter(LocalDate.class, new LocalDateTypeAdapter())
    .create();
-- se for LocalDateTime
Gson gson = new GsonBuilder()
.registerTypeAdapter(LocalDateTime.class, new LocalDateTimeTypeAdapter())
    .create();
  1. Construir uma classe concreta que implemente JsonSerializer e JsonDeserializer
  • No caso de ser LocalDate:
import java.lang.reflect.Type;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import com.google.gson.*;

public class LocalDateTypeAdapter implements JsonSerializer<LocalDate>, JsonDeserializer<LocalDate> {

  private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

  @Override
  public JsonElement serialize(final LocalDate date, final Type typeOfSrc,
      final JsonSerializationContext context) {
    return new JsonPrimitive(date.format(formatter));
  }

  @Override
  public LocalDate deserialize(final JsonElement json, final Type typeOfT,
      final JsonDeserializationContext context) throws JsonParseException {
    return LocalDate.parse(json.getAsString(), formatter);
  }
}
  • No caso de ser LocalDateTime:
import java.lang.reflect.Type;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import com.google.gson.*;

public class LocalDateTimeTypeAdapter implements JsonSerializer<LocalDateTime>, JsonDeserializer<LocalDateTime> {

  private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss");

  @Override
  public JsonElement serialize(LocalDateTime localDateTime, Type srcType,
      JsonSerializationContext context) {
    return new JsonPrimitive(formatter.format(localDateTime));
  }

  @Override
  public LocalDateTime deserialize(JsonElement json, Type typeOfT,
      JsonDeserializationContext context) throws JsonParseException {
    return LocalDateTime.parse(json.getAsString(), formatter);
  }
}
Type listType = new TypeToken<ArrayList<ArrayItem>>(){}.getType(); 
ArrayList<ArrayItem> list = gson.fromJson(jsonSource, listType);

Vídeo Complementar:

Alternativas open-source:

14/10 - JPA: Herança

Exemplo Código

obs: o código já tem um exemplo de JEDIS (driver jdbc para JAVA e Redis)

07/10 - JPA: @ManyToMany

JPA - @ManyToMany

Divulgação - Trabalho 1

Código

30/09 - JPA: @OneToMany

Código

23/09 - JPA: @OneToOne

Código

16/09 - Defesas de TCC

09/09 - Introdução

Clone this wiki locally