streamalism.org

1. Oversikt

Spring Data Redis gir en enkel måte å integrere med Redis-forekomster.

I noen tilfeller det er mer praktisk å bruke en innebygd server enn å skape et miljø med en ekte server.

Derfor vil vi lære å sette opp og bruke den innebygde Redis-serveren.

2. Avhengigheter

La oss begynne med å legge til de nødvendige avhengighetene:

 org.springframework.boot spring-boot-starter-data-redis it.ozimov embedded-redis 0.7.2 test org.springframework.boot spring-boot-starter-test test 

De vår-støvel-start-test avhengighet inneholder alt vi trenger for å kjøre integrasjonstester.

I tillegg har innebygd-redis inneholder den innebygde serveren vi skal bruke.

3. Oppsett

Etter å ha lagt til avhengighetene, bør vi definere tilkoblingsinnstillingene mellom Redis-serveren og applikasjonen vår.

La oss begynne med å lage en klasse som vil inneholde egenskapene våre:

@Configuration offentlig klasse RedisProperties {private int redisPort; private String redisHost; offentlige RedisProperties (@Value ("$ {spring.redis.port}") int redisPort, @Value ("$ {spring.redis.host}") String redisHost) {this.redisPort = redisPort; this.redisHost = redisHost; } // getters}

Deretter bør vi lage en konfigurasjonsklasse som definerer tilkoblingen og bruker egenskapene våre:

@Configuration @EnableRedisRepositories offentlig klasse RedisConfiguration {@Bean public LettuceConnectionFactory redisConnectionFactory (RedisProperties redisProperties) {return new LettuceConnectionFactory (redisProperties.getRedisHost (), redisProperties.getRis; } @Bean public RedisTemplate redisTemplate (LettuceConnectionFactory connectionFactory) {RedisTemplate mal = ny RedisTemplate (); template.setConnectionFactory (connectionFactory); returmal; }}

Konfigurasjonen er ganske enkel. I tillegg tillater det oss å kjøre den innebygde serveren på en annen port.

Ta en titt på vår introduksjon til Spring Data Redis-artikkelen for å lære mer om Redis med Spring Boot.

4. Innebygd Redis Server

Nå konfigurerer vi den innebygde serveren og bruker den i en av testene våre.

For det første, la oss lage en application.properties filen i testressurskatalogen (src / test / resources):

spring.redis.host = localhost spring.redis.port = 6370

Etter det oppretter vi en @TestConfiguration-anmeldt klasse:

@TestConfiguration offentlig klasse TestRedisConfiguration {private RedisServer redisServer; offentlig TestRedisConfiguration (RedisProperties redisProperties) {this.redisServer = ny RedisServer (redisProperties.getRedisPort ()); } @ PostConstruct offentlig ugyldig postConstruct () {redisServer.start (); } @ PreDestroy offentlig ugyldig preDestroy () {redisServer.stop (); }}

Serveren starter når konteksten er oppe. Det starter på maskinen vår på porten som vi har definert i egenskapene våre. For eksempel kan vi nå kjøre testen uten å stoppe den faktiske Redis-serveren.

Ideelt sett vil vi starte den på den tilfeldige tilgjengelige porten, men innebygd Redis har ikke denne funksjonen ennå. Det vi kunne gjøre akkurat nå er å få den tilfeldige porten via ServerSocket API.

I tillegg vil serveren stoppe når konteksten er ødelagt.

Serveren kan også få vår egen kjørbare:

this.redisServer = ny RedisServer ("/ bane / redis", redisProperties.getRedisPort ());

Videre kan den kjørbare defineres per operativsystem:

RedisExecProvider customProvider = RedisExecProvider.defaultProvider () .override (OS.UNIX, "/ path / unix / redis") .override (OS.Windows, Architecture.x86_64, "/ path / windows / redis") .override (OS.MAC_OS_X , Architecture.x86_64, "/ path / macosx / redis") this.redisServer = ny RedisServer (customProvider, redisProperties.getRedisPort ());

Til slutt, la oss lage en test som bruker vår TestRedisConfiguration klasse:

@RunWith (SpringRunner.class) @SpringBootTest (klasser = TestRedisConfiguration.class) offentlig klasse UserRepositoryIntegrationTest {@Autowired private UserRepository userRepository; @Test offentlig ugyldig skalSaveUser_toRedis () {UUID id = UUID.randomUUID (); Brukerbruker = ny bruker (id, "navn"); Bruker lagret = userRepository.save (bruker); assertNotNull (lagret); }}

Brukeren er lagret på den innebygde Redis-serveren vår.

I tillegg måtte vi legge til manuelt TestRedisConfiguration til SpringBootTest. Som vi sa tidligere, har serveren startet før testen og stoppet etter.

5. Konklusjon

Den innebygde Redis-serveren er det perfekte verktøyet for å erstatte den faktiske serveren i testmiljøet. Vi har sett hvordan vi skal konfigurere den og hvordan du bruker den i testen.

Som alltid er koden for eksempler tilgjengelig på GitHub.