Wie Spring Boot Redisson integriert

Integration und Vorsichtsmaßnahmen

redisson unterstützt Redis-Umgebung, Standalone, Cluster, Sentinel, Cloud usw.

Hier sprechen wir über den Cluster-ModusWas Sie beachten müssen, ist, dass Redisson beim Start erkennt, ob der Master-/Slave-Knoten normal ist. Im Allgemeinen gibt es kein Problem mit 3 Shards, 3 Mastern und 3 Slaves, aber wenn die Testumgebung 1 Shard 1 Master ist, können 1 Slave oder 3 Master nicht gestartet werden.

Neben der Umgebung müssen Sie auch auf die Kompatibilität mit oder ohne Passwörter achten.

Manuelles Einfügen der Redisson-Konfiguration

Unter normalen Umständen hat die Produktionsumgebung ein Passwort. Wenn ein Kennwort vorhanden ist, wird empfohlen, die Redisson-Konfiguration manuell einzufügen, ohne Spring Boot zu verwenden, um die Integration zu erleichtern, da Spring Boot das Kennwort möglicherweise nicht erkennen kann.

@Configuration
public class RedissonConfiguration {
    @Value("${spring.redis.cluster.nodes}")
    private String node;
    @Value("${spring.redis.password:}")
    private String password;
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        String[] nodes = node.split(",");
        ClusterServersConfig clusterServersConfig = config.useClusterServers();
        for (String nodeAddress : nodes) {
            clusterServersConfig.addNodeAddress(prefixAddress(nodeAddress));
        }
        if (StringUtils.isNotBlank(password)) {
            clusterServersConfig.setPassword(password);
        }
        return Redisson.create(config);
    }
    private String prefixAddress(String address) {
        if (!StringUtils.isBlank(address) && !address.startsWith("redis")) {
            return "redis://" + address;
        }
        return address;
    }
}

Sie können einige Konfigurationen basierend auf Ihrer tatsächlichen Situation anpassen.

Natürlich gibt es neben dem Passwort noch einen weiteren Punkt: ob es SSL gibt? Das Unternehmen, das ich derzeit verwende, ist Amazon Cloud, und es wird SSL geben. Spring Boot ist mit Redis kompatibel Legen Sie es in der Yaml-Konfiguration fest: SSL: true, aber für Redisson Fügen Sie einfach das Präfix hinzu:

rediss:// + ip: Port oder Domänenname

Spezifische Yaml-Konfiguration

spring:
  redis:
    cluster:
      nodes: rediss://clustercfg.xxx
    password: 'xxx'
    timeout: 30000
    Ssl: true
    lettuce:
      pool:
        max-idle: 100

Verwenden Sie die

gegenseitige Ausschlussstrategie der Sperre Auf den ersten Blick sieht es so aus:

@Scheduled(cron = "${xxx:0 0 */2 * * ?}")
public void createProcess() {
    RLock lock = redisson.getLock(key);
    try {
        if (lock.tryLock()) {
           // 执行运行程序
        } else {
            log.info("createProcess 获取锁失败");
        }
    } catch (Exception e) {
        log.error("xxx", e);
    } finally {
        // 是否有锁 && 是否当前线程
        if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

Es gibt nichts. Es ist ein Problem, aber diese Rekonstruktion hat viele geplante Aufgaben, sodass sie viel vom gleichen Try-Catch-Code erfordert. Annotationsmethode

Eine der Möglichkeiten, doppelten Code zu lösen, ist

Kapselung

, jetzt ist es

Annotationsaspekt

, da ich denke, dass die Annotationsmethode flexibler istalso

/**
 * Redisson 同步锁
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedissonSyncLock {
    String pref();
    /**
     * 锁后缀，一般前缀根据业务来定，后缀是具体的场景
     */
    String keyEL();
    /**
     * 等待时长 【需要区分是互斥还是阻塞，互斥默认0就可以】
     */
    int waitSec() default 0;
}

braucht einen Aspekt

@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class RedissonSyncLockAspect {
    private final Redisson redisson;
    @Around(value = "@annotation(xxx.RedissonSyncLock)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        RedissonSyncLock redissonSyncLock = signature.getMethod().getAnnotation(RedissonSyncLock.class);
        Object[] args = joinPoint.getArgs();
        String key = SpelUtil.parseSpel(signature.getMethod(), args, redissonSyncLock.keyEL());
        RLock lock = null;
        try {
            if (StringUtils.isNotBlank(key) && !StringUtils.equals(key, "null") 
                lock = redisson.getLock(redissonSyncLock.pref().concat(key));
                if (lock.tryLock(redissonSyncLock.waitSec(), TimeUnit.SECONDS)) {
                    return joinPoint.proceed();
                }
            }
            log.info("RedissonSyncLockAspect 上锁失败 {}", key);
        } finally {
            if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

Verwendungsmethode:

@RedissonSyncLock(pref = KeyConstant.xxx, keyEL = "#bean.accountNo")
private void xxx(Bean bean){
     // 程序执行
}

Es wird tatsächlich verwendet. Es ist bequemer.

Das obige ist der detaillierte Inhalt vonWie Spring Boot Redisson integriert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!