spring - Transacciones y entidades de relación mapeando problemas con Neo4j OGM

spring-data-neo4j-4 neo4j-ogm

Question

Versiones utilizadas: spring-data-neo4j 4.2.0-BUILD-SNAPSHOT / neo4j-ogm 2.0.6-SNAPSHOT

Tengo problemas para obtener correctamente las entidades de relación .

Las siguientes llamadas de recuperación no devuelven resultados consistentes (ejecutados en la misma transacción):

1. session.query ("MATCH (: A) - [b: HAS_B] - (: C) CUENTA DEVUELTO (b) como conteo") devuelve 1
2. session.query ("MATCH (: A) - [b: HAS_B] - (: C) RETORNO b") devuelve correctamente la entidad de relación como un objeto RelationshipModel
3. session.query (B.class, "MATCH (: A) - [b: HAS_B] - (: C) RETORNO b") devuelve nulo!

Observación importante: cuando todas las operaciones (crear, captar) se realizan en la misma transacción, parece estar bien.

He podido implementar una solución mediante el uso de session.query (String, Map) para consultar la entidad de relación y asignarla yo mismo a mi POJO .

@NodeEntity
public class A {
    public A () {}
    public A (String name) {
        this.name = name;
    }

    @GraphId
    private Long graphId;

    private String name;

    @Relationship(type="HAS_B", direction=Relationship.OUTGOING)
    private B b;
}

@RelationshipEntity(type="HAS_B")
public class B {
    public B () {}
    public B (String name, A a, C c) {
        this.name = name;
        this.a = a;
        this.c = c;
    }

    @GraphId
    private Long graphId;

    @StartNode
    private A a;

    @EndNode
    private C c;

    private String name;
}

@NodeEntity
public class C {
    public C () {}
    public C (String name) {
        this.name = name;
    }

    @GraphId
    private Long graphId;

    private String name;
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader=AnnotationConfigContextLoader.class, classes={MyTest.TestConfiguration.class})
public class MyTest {
    @Autowired
    private MyBean myBean;

    @Configuration
    @EnableAutoConfiguration
    @EnableTransactionManagement
    @EnableNeo4jRepositories("com.nagra.ml.sp.cpm.core.repositories")
    public static class TestConfiguration {
        @Bean
        public org.neo4j.ogm.config.Configuration configuration() {
            org.neo4j.ogm.config.Configuration config = new org.neo4j.ogm.config.Configuration();
            config.driverConfiguration().setDriverClassName("org.neo4j.ogm.drivers.embedded.driver.EmbeddedDriver");
            return config;
        }
        @Bean
        public SessionFactory sessionFactory() {
            return new SessionFactory(configuration(), "com.nagra.ml.sp.cpm.model");
        }
        @Bean
        public Neo4jTransactionManager transactionManager() {
            return new Neo4jTransactionManager(sessionFactory());
        }
        @Bean
        public MyBean myBean() {
            return new MyBean();
        }
    }

    @Test
    public void alwaysFails() {
        myBean.delete();
        myBean.create("1");
        try { Thread.sleep(2000); } catch (InterruptedException e) {} //useless
        myBean.check("1"); // FAILS HERE !
    }

    @Test
    public void ok() {
        myBean.delete();
        myBean.createAndCheck("2");
    }
}

@Transactional(propagation = Propagation.REQUIRED)
public class MyBean {

    @Autowired
    private Session neo4jSession;

    public void delete() {
        neo4jSession.query("MATCH (n) DETACH DELETE n", new HashMap<>());
    }

    public void create(String suffix) {
        C c = new C("c"+suffix);
        neo4jSession.save(c);
        A a = new A("a"+suffix);
        neo4jSession.save(a);
        B bRel = new B("b"+suffix, a, c);
        neo4jSession.save(bRel);
    }

    public void check(String suffix) {
        //neo4jSession.clear(); //Not working even with this
        Number countBRels = (Number) neo4jSession.query("MATCH (:A)-[b:HAS_B]-(:C) WHERE b.name = ''b"+suffix+"'' RETURN count(b) as count", new HashMap<>()).iterator().next().get("count");
        assertEquals(1, countBRels.intValue()); // OK
        Iterable<B> bRels = neo4jSession.query(B.class, "MATCH (:A)-[b:HAS_B]-(:C) WHERE b.name = ''b"+suffix+"'' RETURN b", new HashMap<>());
        boolean relationshipFound = bRels.iterator().hasNext();
        assertTrue(relationshipFound); // FAILS HERE !
    }

    public void createAndCheck(String suffix) {
        create(suffix);
        check(suffix);
    }
}

Answer 1

Esta consulta session.query(B.class, "MATCH (:A)-[b:HAS_B]-(:C) RETURN b") devuelve solo la relación, pero no el nodo de inicio o nodo final, por lo que el OGM no puede hidratar esta . Siempre debe devolver el nodo de inicio y final junto con la relación como session.query(B.class, "MATCH (a:A)-[b:HAS_B]-(c:C) RETURN a,b,c")

La razón por la que parece funcionar cuando ambos crean y recuperan datos en la misma transacción es porque la sesión ya tiene una copia en caché de a c y, por lo tanto, b puede hidratarse con nodos de inicio y final en caché.

Answer 2

En primer lugar, actualice de OGM 2.0.6-SNAPSHOT a 2.1.0-SNAPSHOT. He notado algo de comportamiento impropio en el primero que podría ser una parte del problema.

Ahora a tu prueba. Aquí hay varias cosas que vale la pena investigar.

• Uso de @DirtiesContext : Parece que no estás tocando el contexto y si lo usas para restablecer el contexto entre las pruebas para que obtengas una nueva sesión / transacción, eso va por el camino equivocado. Simplemente use @Transactional en @Transactional lugar. El corredor de Spring JUnit tratará esto de una manera especial (ver el siguiente punto).
• Consciente de que las pruebas transaccionales se retrotraen automáticamente: Jasper tiene razón. Las pruebas de integración de primavera siempre se retrotraerán por defecto . Si quiere asegurarse de que su prueba JUnit se compromete , tendrá que @Commit it . Un buen ejemplo de cómo configurar su prueba se puede ver aquí .
• Saber cómo funcionan los proxies de transacciones de primavera. Además de toda esta confusión, debe asegurarse de no llamar simplemente al método transaccional al método transaccional en la misma clase y esperar que se aplique el comportamiento transaccional de Spring. Una rápida redacción de por qué se puede ver aquí .

Si abordas esos problemas, todo debería estar bien.