Pratique de microservice Spring Cloud pour la mise en œuvre de verrous distribués

Avec la popularité de l'architecture de microservices, de plus en plus d'équipes de développement d'entreprise commencent à utiliser Spring Cloud pour créer leurs propres systèmes de microservices. Dans un environnement distribué, la mise en œuvre de verrous distribués constitue un défi technique important. Cet article explique comment implémenter la pratique des microservices de verrouillage distribué dans le cadre Spring Cloud.

Tout d'abord, nous devons comprendre ce qu'est un verrou distribué. Le verrouillage distribué est une technologie utilisée pour protéger l'accès aux ressources partagées. Il peut garantir que plusieurs nœuds ne modifieront pas ou n'accéderont pas à la même ressource en même temps dans un environnement distribué. Dans un système de microservices, les verrous distribués peuvent protéger la lecture et l'écriture des ressources partagées et éviter la concurrence entre les ressources et l'incohérence des données.

Ensuite, nous présenterons la solution consistant à utiliser Redis pour implémenter des verrous distribués. Redis est une base de données en mémoire populaire qui prend en charge le verrouillage distribué et peut être bien intégrée au framework Spring Cloud.

Tout d'abord, nous devons ajouter la dépendance de Redis dans l'application Spring Boot. Ajoutez la dépendance suivante dans Gradle :

compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis'

Ajoutez la dépendance suivante dans Maven :

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Ajoutez le code suivant dans notre application pour configurer la connexion Redis : #🎜 🎜#

@Configuration
public class RedisConfig {

  @Bean
  JedisConnectionFactory jedisConnectionFactory() {
      RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
      redisStandaloneConfiguration.setHostName("redis");
      redisStandaloneConfiguration.setPort(6379);
      return new JedisConnectionFactory(redisStandaloneConfiguration);
  }

  @Bean
  public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
      RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      redisTemplate.setDefaultSerializer(new StringRedisSerializer());
      redisTemplate.setEnableTransactionSupport(true);
      redisTemplate.afterPropertiesSet();
      return redisTemplate;
  }
}

Ensuite, nous devons implémenter une méthode pour obtenir des verrous distribués. Cette méthode doit garantir qu'un seul nœud peut obtenir le verrou en même temps dans un environnement distribué. Ce qui suit est une implémentation simple :

@Service
public class DistributedLockService {

    @Autowired
    private RedisTemplate redisTemplate;

    public boolean acquireLock(String lockKey, String requestId, int expireTime) {

        String result = (String) redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                return commands.set(lockKey, requestId, "NX", "PX", expireTime);
            }
        });

        return result != null && result.equals("OK");
    }

    public boolean releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Boolean result = (Boolean) redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                Object nativeConnection = connection.getNativeConnection();
                Long execute = (Long) ((Jedis) nativeConnection).eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
                return execute.equals(1L);
            }
        });
        return result;
    }
}

Dans le code ci-dessus, la commande Redis set est exécutée via la méthode d'exécution de redisTemplate pour définir la paire clé-valeur. Le paramètre NX signifie qu'il est uniquement défini. lorsque la clé n'existe pas. Évitez la situation où deux threads acquièrent le verrou en même temps. Le paramètre PX représente le délai d'expiration de la clé définie. Le résultat renvoyé est OK, ce qui signifie que l'acquisition du verrou est réussie. Lors de la libération du verrou, utilisez l'implémentation du script Lua de Redis pour vous assurer que seul le thread propriétaire du verrou peut le libérer.

Enfin, nous devons utiliser des verrous distribués dans les microservices. Par exemple, en supposant que nous disposions d'un point de terminaison de microservice qui doit protéger l'accès aux ressources, nous pouvons utiliser DistributedLockService dans le contrôleur Spring MVC pour obtenir un verrou distribué afin de garantir qu'une seule requête peut accéder à la ressource en même temps.

@RestController
public class ResourceController {

  private static final String LOCK_KEY = "lock";
  private static final String LOCK_REQUEST_ID = UUID.randomUUID().toString();
  private static final int EXPIRE_TIME = 5000;

  @Autowired
  private DistributedLockService distributedLockService;

  @Autowired
  private ResourceService resourceService;

  @RequestMapping("/resource")
  public ResponseEntity<String> accessResource() {

      boolean lockAcquired = distributedLockService.acquireLock(LOCK_KEY, LOCK_REQUEST_ID, EXPIRE_TIME);

      if (lockAcquired) {
          try {
              // 访问资源
              String result = resourceService.accessResource();
              return ResponseEntity.ok(result);
          } finally {
              distributedLockService.releaseLock(LOCK_KEY, LOCK_REQUEST_ID);
          }
      } else {
          return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body("Resource is busy, please try again later.");
      }
  }
}

Le code ci-dessus obtient le verrou via DistributedLockService, accède à la ressource après avoir obtenu le verrou et libère le verrou après avoir accédé à la ressource, évitant ainsi le problème de plusieurs requêtes accédant à la ressource en même temps.

Dans l'exemple ci-dessus, nous avons implémenté le schéma de verrouillage distribué dans les microservices Spring Cloud. Cette solution peut protéger l'accès aux ressources partagées et garantir l'exactitude et la cohérence des données du système. En utilisation réelle, nous pouvons ajuster et optimiser la mise en œuvre des verrous distribués en fonction de scénarios et de besoins commerciaux spécifiques.

En bref, les verrous distribués sont un élément très important de la mise en œuvre de systèmes distribués, qui peuvent garantir l'exactitude et la cohérence des données du système. La combinaison de Spring Cloud et Redis peut bien implémenter la fonction de verrouillage distribué. Grâce à l'introduction de cet article, j'espère qu'il pourra aider tout le monde à comprendre et à appliquer la technologie de verrouillage distribué.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!