[Microservicios] Explicación detallada del uso de springboot integrado neo4j

I. Introducción

En el artículo anterior aprendimos sobre el uso de neo4j en detalle, desde la construcción hasta las operaciones gramaticales relacionadas. Este artículo sigue el contenido anterior para hablar en detalle sobre cómo integrar y usar neo4j en aplicaciones springboot.

2. Datos de primavera Neo4j

Al igual que muchos otros middleware, todos proporcionan métodos similares a jpa para integrarse con springboot, como el familiar springdata-jpa, jpa para operar es, jpa para operar mongo, etc. Neo4j también proporciona un método jpa para integrarse con springboot. es decir, Spring Data Neo4j. A continuación, demostraremos cómo integrar y usar Spring Data Neo4j en springboot.

3. Preparación ambiental

Para construir el servicio neo4j por adelantado, consulte el artículo anterior para conocer los pasos de construcción detallados;

versión de arranque de primavera, 2.3.5;

Prepare un proyecto Springboot con anticipación;

4. Pasos de integración

Siga los pasos a continuación

4.1 Importar las dependencias maven necesarias

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.15</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${boot-web.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lomok.version}</version>
        </dependency>
    </dependencies>

4.2 Agregar archivo de configuración

Para obtener más configuraciones, consulte el sitio web oficial. La configuración continua básica se proporciona a continuación.

server.port=8088

spring.data.neo4j.uri= bolt://IP:7687
spring.data.neo4j.username=neo4j
spring.data.neo4j.password=neo4j

4.3 Mapeo personalizado de clases de entidades y nodos

Por ejemplo, en este caso de demostración, hay dos objetos de operación de nodo, a saber, Persona y PersonaRelación, existe una cierta relación entre los dos y luego las operaciones crudas relevantes se completan a través del programa.

Clase de persona personalizada

@Data
@Builder
@NodeEntity("person")
public class Person implements Serializable {
    @Id
    @GeneratedValue
    private Long id;

    @Property("name")
    private String name;
}

Clase de relación persona

@Data
@NoArgsConstructor
@RelationshipEntity(type = "徒弟")
public class PersonRelation implements Serializable {
    @Id
    @GeneratedValue
    private Long id;
    @StartNode
    private Person parent;
    @EndNode
    private Person child;
    @Property
    private String relation;
    
    public PersonRelation(Person parent, Person child, String relation) {
        this.parent = parent;
        this.child = child;
        this.relation = relation;
    }
}

4.4 JPA personalizado

Personalice el repositorio de los dos objetos del nodo de operación respectivamente y herede la interfaz Neo4jRepository. Los estudiantes que hayan desarrollado usando jpa deben estar familiarizados con esto.

Repositorio de personas 

public interface PersonRepository extends Neo4jRepository<Person,Long> {

    /**
     * 查询某个节点的所有子节点
     * @param pId
     * @return
     */
    @Query("Match (p:person) -[*]->(s:person) where id(p)={0} return s")
    List<Person> findChildList(Long pId);

    @Query("Match (p:person {name:{0}}) -[*]->(s:person) return s")
    List<Person> findChildList(String name);

    /**
     * 查询当前节点的父节点
     * @param name
     * @return
     */
    @Query("Match (p:person) -[*]->(s:person {name:{0}}) return p")
    List<Person> findParentList(String name);

    List<Person> findByName(String name);

}

PersonaRelaciónRepositorio

public interface PersonRelationRepository  extends Neo4jRepository<PersonRelation,Long> {

}

5. Pruebas de integración

A continuación, escriba una prueba unitaria para probar el efecto del código anterior.

5.1 Guardar datos personales y relacionales

import com.congge.entity.Person;
import com.congge.entity.PersonRelation;
import com.congge.repository.PersonRelationRepository;
import com.congge.repository.PersonRepository;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

@SpringBootTest
@RunWith(SpringRunner.class)
public class PersonTest {

    @Autowired
    private PersonRepository personRepository;

    @Autowired
    private PersonRelationRepository personRelationRepository;

    @Test
    public void testSave() {
        Person person = Person.builder().name("唐僧").build();
        Person person2 = Person.builder().name("孙悟空").build();
        Person person3 = Person.builder().name("猪八戒").build();
        Person person4 = Person.builder().name("沙僧").build();
        Person person5 = Person.builder().name("白龙马").build();
        List<Person> personList = new ArrayList<>(Arrays.asList(
                person, person2, person3, person4, person5));
        personRepository.saveAll(personList);
        System.out.println("person 数据保存成功");

        PersonRelation personRelation = new PersonRelation(person, person2, "徒弟");
        PersonRelation personRelation2 = new PersonRelation(person, person3, "徒弟");
        PersonRelation personRelation3 = new PersonRelation(person, person4, "徒弟");
        PersonRelation personRelation4 = new PersonRelation(person, person5, "徒弟");
        List<PersonRelation> personRelationList = new ArrayList<>(Arrays.asList(
                personRelation, personRelation2, personRelation3,
                personRelation4
        ));
        // 保存关系数据
        personRelationRepository.saveAll(personRelationList);
        System.out.println("person 关系数据保存成功");
    }

}

Ejecute el código anterior

Después de una ejecución exitosa, puede ir a la interfaz web para verificar los datos que acaba de guardar.

5.2 Consultar datos

@Test
    public void testDelete(){
        // 删除所有person节点
        personRepository.deleteAll();
        // 删除所有personRelation关系数据
        personRelationRepository.deleteAll();
        //根据id删除
        personRepository.deleteById(0l);
    }

    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        Iterable<Person> allPerson = personRepository.findAll();
        allPerson.forEach(item -> {
            System.out.println(item.getId());
            System.out.println(item.getName());
            System.out.println();
        });
    }

    /**
     * 根据id查询
     */
    @Test
    public void testFindById() {
        Optional<Person> personOptional = personRepository.findById(0l);
        if (personOptional.isPresent()) {
            System.out.println(personOptional.get().getName());
        }
    }

    /**
     * 分页查询
     */
    @Test
    public void testPage() {
        //设置分页、排序条件，page从0开始
        PageRequest pageRequest = PageRequest.of(1, 2, Sort.by(Sort.Order.desc("id")));
        Page<Person> page = personRepository.findAll(pageRequest);
        page.getContent().forEach(person -> {
            System.out.println(person.getId() + ":" + person.getName());
        });
    }


    @Test
    public void testFindByName() {
        List<Person> personList = personRepository.findByName("唐僧");
        for(Person p : personList){
            System.out.println(p.getName());
        }
    }

Si los métodos comúnmente utilizados en jpa aún no pueden cumplir con los requisitos, puede intentar escribir declaraciones personalizadas para su implementación.

5.3 Reglas del método personalizado JPA

Utilice las reglas en jpa para realizar consultas personalizadas. A continuación se resumen algunas reglas de uso de jpa comúnmente utilizadas. Puede usar estas API para completar el desarrollo de algunos escenarios comerciales más avanzados.

Palabra clave	Muestra	Fragmento cifrado
Después	findByLaunchDateAfter(Fecha fecha)	n.fecha de lanzamiento > fecha
Antes	findByLaunchDateBefore(Fecha fecha)	n.fecha de lanzamiento <fecha
Que contiene (cadena)	findByNameContaining(Parte del nombre de cadena)	n.nombre CONTIENE nombreParte
Que contiene (colección)	findByEmailAddressesContains(Direcciones de colección) findByEmailAddressesContains(Dirección de cadena)	CUALQUIER (campos de colección EN [direcciones] DONDE campos de colección en n. direcciones de correo electrónico) CUALQUIER (campos de colección EN la dirección DONDE campos de colección en n. direcciones de correo electrónico)
En	findByNameIn(nombres iterables)	n.nombre EN nombres
Entre	findByScoreBetween(doble mínimo, doble máximo) findByScoreBetween(rango rango)	n.score >= min AND n.score <= max Dependiendo de la definición del rango n.score >= min AND n.score <= max o n.score > min AND n.score < max
Empezando con	findByNameStartingWith(String nombreInicio)	n.nombre COMIENZA CON nombreInicio
Terminando con	findByNameEndingWith(String nombreEnd)	n.nombre TERMINA CON nombreEnd
existe	buscarPorNombreExiste()	EXISTE(n.nombre)
Verdadero	encontrarByActivatedIsTrue()	n.activado = verdadero
FALSO	encontrarByActivatedIsFalse()	NO(n.activado = verdadero)
Es	findByNameIs(nombre de cadena)	n.nombre = nombre
No nulo	buscarPorNombreNotNull()	NO (n.nombre ES NULO)
Nulo	buscarPorNombreNull()	n.nombre ES NULO
Mas grande que	findByScoreGreaterThan(doble puntuación)	n.puntuación > puntuación
Mayor que igual	findByScoreGreaterThanEqual(puntuación doble)	n.puntuación >= puntuación
Menos que	findByScoreLessThan(puntuación doble)	n.puntuación < puntuación
Menos que igual	findByScoreLessThanEqual(puntuación doble)	n.puntuación <= puntuación
Como	findByNameLike (nombre de cadena)	n.nombre =~ nombre
Diferente a	findByNameNotLike (nombre de cadena)	NO(n.nombre =~ nombre)
Cerca	findByLocationNear(Distancia distancia, Punto punto)	distancia( punto(n),punto({latitud:lat, longitud:lon}) ) < distancia
expresión regular	findByNameRegex (expresión regular de cadena)	n.nombre =~ expresión regular
Y	findByNameAndDescription (nombre de cadena, descripción de cadena)	n.nombre = nombre AND n.descripción = descripción
O	findByNameOrDescription (nombre de cadena, descripción de cadena)	n.name = nombre O n.descripción = descripción (No se puede utilizar para O propiedades anidadas)

6. Escribe al final del artículo.

Este artículo resume en detalle cómo integrar y usar neo4j en springboot y demuestra cómo usarlo a través del código. Los estudiantes que estén interesados ​​en más usos también pueden estudiarlo en profundidad.