[Java] [Spring] Spring Boot 1.4-> 1.2 Downgrade Hinweis

Ich glaube nicht, dass irgendjemand dies tun würde, aber ich habe so viel gelitten, dass ich es mir notieren werde.

Über die Notation dieses Satzes

: grin: 1.4: Wie es bei 1.4 geht. : grinsen: 1.2: 1.2 ist wie es geht.

Implementierungsbeziehung

@EntityScan

:grin: 1.4: org.springframework.boot.autoconfigure.domain.EntityScan :smirk: 1.2: org.springframework.boot.orm.jpa.EntityScan

DI

: grin: 1.4: Wenn es selbstverständlich ist, wird DI ohne Hinzufügen von "@ Autowired" durchgeführt. : smirk: 1.2: Fügen wir @ Autowired hinzu.

Testbezogen

Testläufer

:grin: 1.4: @RunWith(SpringRunner.class) :smirk: 1.2: @RunWith(SpringJUnit4ClassRunner.class)

Testen mit Frühling

: grin: 1.4: Füge @ SpringBootTest hinzu : smirk: 1.2: Fügen Sie "@SpringApplicationConfiguration (classes = application classes)" hinzu

http://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/SpringApplicationConfiguration.html

Datenbankintegrationstest

: grin: 1.4: Fügen Sie der Testklasse "@ DataJpaTest" hinzu. : grinsen: 1.2: Es ist schwer.

@ DataJpaTest scheint dies zu tun.

1. Richten Sie eine In-Memory-Datenbank ein
2. Stellen Sie Ruhezustand / Federdaten / Datenquelle ein
3. Führen Sie "@ EntityScan" aus
4. Aktivieren Sie die SQL-Protokollierung

Ich dachte, ich müsste alles tun, aber es scheint in Ordnung zu sein, wenn ich das alles mache.

1. Erstellen Sie eine Anwendungskontextklasse mit @ EntityScan und @ EnableJpaRepositories.
2. Erstellen Sie eine TestEntityManager-Klasse (ab 1.4).
3. Erstellen Sie eine Bean, die "TestEntityManager" zurückgibt (ab 1.4).
4. Fügen Sie der Testklasse "@ Transactional" und "@ SpringApplicationConfiguration" hinzu.

Ich werde es in der richtigen Reihenfolge tun.

Erstellen Sie eine Anwendungskontextklasse mit "@ EntityScan", "@ EnableJpaRepositories"

TestApplication.java

@SpringBootApplication
@EnableJpaRepositories(Speicherort der Repository-Klasse)
@EntityScan(Standort der Entitätsklasse)
@EnableJpaAuditing //Dies ist diesmal irrelevant
public class TestApplication {

}

Erstellen Sie die TestEntityManager-Klasse (ab 1.4).

Die Originalquelle ist hier. https://github.com/spring-projects/spring-boot/blob/master/spring-boot-test-autoconfigure/src/main/java/org/springframework/boot/test/autoconfigure/orm/jpa/

TestEntityManager.java

public class TestEntityManager {

    private final EntityManagerFactory entityManagerFactory;

    public TestEntityManager(EntityManagerFactory entityManagerFactory) {
        Assert.notNull(entityManagerFactory, "EntityManagerFactory must not be null");
        this.entityManagerFactory = entityManagerFactory;
    }

    public <E> E persist(E entity) {
        getEntityManager().persist(entity);
        return entity;
    }

    public void flush() {
        getEntityManager().flush();
    }

    public <E> E persistAndFlush(E entity) {
        persist(entity);
        flush();
        return entity;
    }

    public void detach(Object entity) {
        getEntityManager().detach(entity);
    }

    public <E> E find(Class<E> entityClass, Object primaryKey) {
        return getEntityManager().find(entityClass, primaryKey);
    }

    public final EntityManager getEntityManager() {
        EntityManager manager = EntityManagerFactoryUtils
                .getTransactionalEntityManager(this.entityManagerFactory);
        Assert.state(manager != null, "No transactional EntityManager found");
        return manager;
    }
}

Erstellen Sie eine Bean, die "TestEntityManager" zurückgibt (ab 1.4).

TestEntityManagerConfigure.java

@Configuration
@AutoConfigureAfter(HibernateJpaAutoConfiguration.class)
public class TestEntityManagerConfigure {

    @Bean
    @ConditionalOnMissingBean
    public TestEntityManager testEntityManager(
            EntityManagerFactory entityManagerFactory) {
        return new TestEntityManager(entityManagerFactory);
    }

}

Fügen Sie der Testklasse "@ Transactional" und "@ SpringApplicationConfiguration" hinzu

MySomeRepositoryTest.java

import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = TestApplication.class)
@Transactional
public class MySomeRepositoryTest {

    @Autowired
    private MySomeRepository instance;

    @Autowired
    private TestEntityManager em;

    @Test
    public void testSomeMethod {
     // ...
    }

}

Injizieren Sie eine verspottete Instanz

: grin: 1.4: Fügen Sie der Instanzvariablen, die Sie verspotten möchten, "@ MockBean" hinzu : smirk: 1.2: Definieren Sie "@ Bean", das eine verspottete Instanz zurückgibt, und fügen Sie "@ Primary" hinzu

Für 1.4

MySomeTest.java

    @MockBean
    private MyTargetClass mock;

Für 1.2

@Profile wird hinzugefügt, sodass nur eine bestimmte @ Configuration-Klasse gültig ist.

MySomeTest.java

@ActiveProfiles("MySomeTest")
public class MySomeTest {
    @Autowired
    private MyTargetClass mock;
}

MySomeTestConfig.java

@Configuration
@Profile("MySomeTest")
public class MySomeTestConfig {
    @Bean
    @Primary
    public MyTargetClass myTargetClass() {
        return Mockito.mock(MyTargetClass.class);
    }
}

Die Reise geht weiter. .. ..

Wenn Sie etwas finden, werde ich es hinzufügen.