Hur använder man Shed Lock med H2-databas för testning?

När det kommer till att testa applikationer som kräver distribuerad låsning är Shed Lock ett kraftfullt verktyg som effektivt kan integreras med en H2-databas. Som leverantör av Shed Lock har jag bevittnat de utmaningar och möjligheter som följer med att implementera och testa sådana låsmekanismer. I det här blogginlägget kommer jag att guida dig genom processen att använda Shed Lock med en H2-databas för teständamål.

Förstå Shed Lock

Shed Lock är ett bibliotek som tillhandahåller distribuerade lås för schemalagda uppgifter i Java-applikationer. Det säkerställer att en viss uppgift endast utförs en gång i flera instanser av en applikation, vilket förhindrar tävlingsförhållanden och andra samtidiga problem. Detta är avgörande i distribuerade system där flera noder kan försöka utföra samma uppgift samtidigt.

Kärnkonceptet bakom Shed Lock är enkelt: det använder en databas för att lagra låsinformation. När en uppgift är på väg att köras försöker den få ett lås i databasen. Om låset är tillgängligt fortsätter uppgiften; annars väntar den eller hoppar över utförandet. Denna mekanism säkerställer att endast en instans av uppgiften kan köras åt gången.

6-3 6-4

Varför använda H2 Database för testning?

H2-databasen är en databas i minnet som är lätt, snabb och enkel att installera. Det kräver ingen separat serverprocess, vilket gör den idealisk för testmiljöer. När du testar Shed Lock kan du använda en H2-databas för att snabbt skapa en testmiljö utan att behöva hantera ett fullfjädrat databassystem.

Konfigurera projektet

För att börja använda Shed Lock med en H2-databas måste du först ställa in ett Java-projekt. Du kan använda ett byggverktyg som Maven eller Gradle. Här är ett exempel på hur man lägger till nödvändiga beroenden till ett Maven-projekt:

<dependencies> <dependency> <groupId>net.javacrumbs.shedlock</groupId> <artifactId>shedlock-spring</artifactId> <version>4.44.0</version> </dependency> <dependency> <groupId>net.javacrumbs.shedlock</groupId> <artifactId>shedlock-provider-jdbc-template</artifactId> <version>4.44.0</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.214</version> <dependency> </version> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> </dependencies>

Konfigurera H2-databasen

När beroenden har lagts till måste du konfigurera H2-databasen. I en Spring Boot-applikation kan du göra detta iapplikationsegenskaperellerapplication.ymlfil. Här är ett exempel påapplikationsegenskaper:

spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=lösenord spring.h2.console.enabled=true

Dessa egenskaper konfigurerar H2-databasen att köras i ett minnesläge. Despring.h2.console.enabled=trueegenskapen aktiverar H2-konsolen, vilket kan vara användbart för felsökning.

Konfigurera Shed Lock

Därefter måste du konfigurera Shed Lock för att använda H2-databasen som låsleverantör. Du kan göra detta genom att skapa en konfigurationsklass:

importera net.javacrumbs.shedlock.core.LockProvider; importera net.javacrumbs.shedlock.provider.jdbc.template.JdbcTemplateLockProvider; import net.javacrumbs.shedlock.spring.annotation.EnableSchedulerLock; importera org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; importera org.springframework.jdbc.core.JdbcTemplate; importera javax.sql.DataSource; @Configuration @EnableSchedulerLock(defaultLockAtMostFor = "PT30S") public class ShedLockConfig { @Bean public LockProvider lockProvider(DataSource dataSource) { return new JdbcTemplateLockProvider( JdbcTemplateLockProvider.Configuration.withJdbcT) JdbcTemplate(dataSource)) .usingDbTime() .build() ); } }

I den här konfigurationsklassen definierar vi enLockProviderböna som använderJdbcTemplateLockProvidermed H2-datakällan. De@EnableSchedulerLockanteckning aktiverar Shed Lock-funktionen i Spring-applikationen.

Skapa en schemalagd uppgift

Låt oss nu skapa en enkel schemalagd uppgift som använder Shed Lock. Här är ett exempel:

import net.javacrumbs.shedlock.spring.annotation.SchedulerLock; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class ScheduledTask { @Scheduled(fixedRate = 5000) @SchedulerLock(name = "scheduledTask", lockAtMostFor = "PT10S", lockAtLeastFor = "PT5S") public void runTask() { System.out.println("Task körs..."); } }

De@Schemalagtanteckning definierar schemat för uppgiften, och@SchedulerLockanteckning säkerställer att uppgiften endast utförs en gång i flera instanser. Denamnattribut av@SchedulerLockanteckning används för att identifiera låset ochlockAtMostForochlockAtLeastForattribut definierar den maximala och lägsta varaktigheten för vilken låset hålls.

Testar installationen

För att testa installationen kan du köra Spring Boot-applikationen. Du bör se uppgiften köra med det angivna intervallet, och låsmekanismen bör se till att den bara körs en gång. Du kan också använda H2-konsolen för att verifiera låsposterna i databasen.

Avancerade testscenarier

Utöver grundläggande testning kanske du vill testa mer avancerade scenarier, som utgångsdatum för lås, samtidig åtkomst och felhantering. Du kan använda testramverk som JUnit och Mockito för att simulera dessa scenarier.

Till exempel kan du skriva ett enhetstest för att verifiera att låset släpps efterlockAtMostForvaraktighet:

import net.javacrumbs.shedlock.core.LockConfiguration; importera net.javacrumbs.shedlock.core.LockProvider; import net.javacrumbs.shedlock.core.SimpleLock; importera org.junit.jupiter.api.Test; importera org.springframework.beans.factory.annotation.Autowired; importera org.springframework.boot.test.context.SpringBootTest; importera java.time.Duration; importera java.time.Instant; importera statisk org.junit.jupiter.api.Assertions.assertNotNull; importera statisk org.junit.jupiter.api.Assertions.assertNull; @SpringBootTest public class LockExpirationTest { @Autowired private LockProvider lockProvider; @Test public void testLockExpiration() { LockConfiguration lockConfig = new LockConfiguration(Instant.now(), "testLock", Duration.ofSeconds(5)); SimpleLock lock = lockProvider.lock(lockConfig); assertNotNull(lås, "Lås bör förvärvas"); försök { Thread.sleep(6000); } catch (InterruptedException e) { e.printStackTrace(); } SimpleLock newLock = lockProvider.lock(lockConfig); assertNotNull(newLock, "Lås bör vara tillgängligt efter utgången"); } }

Slutsats

Att använda Shed Lock med en H2-databas för testning är ett enkelt och effektivt sätt att säkerställa att dina distribuerade låsmekanismer är korrekta. Genom att följa stegen som beskrivs i det här blogginlägget kan du snabbt ställa in en testmiljö och testa olika scenarier för att säkerställa att din applikation fungerar som förväntat.

Om du är intresserad av att köpa Shed Lock-lösningar eller har några frågor om att integrera Shed Lock med din applikation, är vi här för att hjälpa dig. Oavsett om du behöverDörrlås för skjulför fysisk säkerhet ellerQuarter Turn Lockför specifik åtkomstkontroll, eller till och medUtomhuslåsför externa applikationer kan vårt team av experter ge dig de bästa lösningarna. Kontakta oss för att starta en upphandlingsdiskussion och hitta rätt produkter för dina behov.