Utilisation du service Redis et Rabbitmq de fonderie cloud pivotant en tant que service vcap dans l'application de démarrage au printemps

Question

Je suis capable d'utiliser les services REDIS et RABBITMQ qui sont en mode pivotant.Pendant les services de liaison, je peux obtenir les informations d'identification et utiliser ces informations dans mon application .properties pour le projet de démarrage de printemps.

Mais cette configuration que j'utilise est codée en dur dans l'application.Properties Pour faire cette configuration dynamiquement, j'ai appris que nous pouvions utiliser les services vcap fournis par pivotal.

Vous souhaitez donc utiliser les informations d'identification d'exécution pour redis et rabbimq.

Mon code est ci-dessous pour la référence.

application.propeties

rabbitmq.host=hostname 
rabbitmq.virtual-host=vhostanme 
rabbitmq.username=username 
rabbitmq.password=password 
rabbit.mainqueue=abhi 
rabbit.errorqueue=abc 
redis.host=redishostname 
redis.port=port 
redis.password=password 

classe Ma config:

import org.springframework.beans.factory.annotation.Value; 
import org.springframework.stereotype.Component; 

@Component 
public class Config { 


    static String rabbitMqHost; 
    static String rabbitMqVHost; 
    static String rabbitMqUsername; 
    static String rabbitMqPassword; 
    static String rabbitMqMainQueue; 
    static String rabbitMqErrorQueue; 
    static String redisHost; 
    static int redisPort; 
    static String redisPassword; 


    Config() { 
    } 


    public static String getRedisHost() { 
     return redisHost; 
    } 

    public static void setRedisHost(String redisHost) { 
     Config.redisHost = redisHost; 
    } 

    public static int getRedisPort() { 
     return redisPort; 
    } 

    public static void setRedisPort(int redisPort) { 
     Config.redisPort = redisPort; 
    } 

    public static String getRedisPassword() { 
     return redisPassword; 
    } 

    public static void setRedisPassword(String redisPassword) { 
     Config.redisPassword = redisPassword; 
    } 

    public static String getRabbitMqMainQueue() { 
     return rabbitMqMainQueue; 
    } 

    public static void setRabbitMqMainQueue(String rabbitMqMainQueue) { 
     Config.rabbitMqMainQueue = rabbitMqMainQueue; 
    } 

    public static String getRabbitMqErrorQueue() { 
     return rabbitMqErrorQueue; 
    } 

    public static void setRabbitMqErrorQueue(String rabbitMqErrorQueue) { 
     Config.rabbitMqErrorQueue = rabbitMqErrorQueue; 
    } 

    public static String getRabbitMqHost() { 
     return rabbitMqHost; 
    } 

    public static void setRabbitMqHost(String rabbitMqHost) { 
     Config.rabbitMqHost = rabbitMqHost; 
    } 

    public static String getRabbitMqVHost() { 
     return rabbitMqVHost; 
    } 

    public static void setRabbitMqVHost(String rabbitMqVHost) { 
     Config.rabbitMqVHost = rabbitMqVHost; 
    } 

    public static String getRabbitMqUsername() { 
     return rabbitMqUsername; 
    } 

    public static void setRabbitMqUsername(String rabbitMqUsername) { 
     Config.rabbitMqUsername = rabbitMqUsername; 
    } 

    public static String getRabbitMqPassword() { 
     return rabbitMqPassword; 
    } 

    public static void setRabbitMqPassword(String rabbitMqPassword) { 
     Config.rabbitMqPassword = rabbitMqPassword; 
    } 

    @Value("${rabbitmq.host}") 
    public void setRabbitMqHosts(String url) { 
     setRabbitMqHost(url); 
    } 

    @Value("${rabbitmq.virtual-host}") 
    public void setRabbitMqVHosts(String url) { 
     setRabbitMqVHost(url); 
    } 

    @Value("${rabbitmq.username}") 
    public void setRabbitUsernames(String url) { 
     setRabbitMqUsername(url); 
    } 

    @Value("${rabbitmq.password}") 
    public void setRabbitPasswords(String url) { 
     setRabbitMqPassword(url); 
    } 

    @Value("${rabbit.mainqueue}") 
    public void setRabbitMainQueues(String url) { 
     setRabbitMqMainQueue(url); 
    } 

    @Value("${rabbit.errorqueue}") 
    public void setRabbitErrorQueues(String url) { 
     setRabbitMqErrorQueue(url); 
    } 

    @Value("${redis.host}") 
    public void setRedisHosts(String url) { 
     setRedisHost(url); 
    } 

    @Value("${redis.port}") 
    public void setRedisPorts(int url) { 
     setRedisPort(url); 
    } 
    @Value("${redis.password}") 
    public void setRedisPasswords(String url) { 
     setRedisPassword(url); 
    } 
} 

Ma classe MessagesConsumer dans laquelle je me sers que conguration pour faire passer un message de la file d'attente rabbitmq et enregistrez-Redis:

import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 

import javax.annotation.PostConstruct; 
import javax.jms.ConnectionFactory; 
import javax.jms.Message; 
import javax.jms.MessageConsumer; 
import javax.jms.Session; 

import org.json.JSONObject; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.context.annotation.Bean; 
import org.springframework.jms.core.JmsTemplate; 
import org.springframework.scheduling.annotation.Scheduled; 
import org.springframework.stereotype.Component; 

import com.es.consumer.config.Config; 
import com.rabbitmq.jms.admin.RMQConnectionFactory; 

import redis.clients.jedis.Jedis; 
import redis.clients.jedis.JedisShardInfo; 

@Component 
public class MessagesConsumer { 
    @Autowired 
    JmsTemplate jmsTemplate; 
    final Logger logger = LoggerFactory.getLogger(MessagesConsumer.class); 

    Jedis jedis; 

    JedisShardInfo shardInfo; 

    @PostConstruct 
    public void init() { 

     shardInfo = new JedisShardInfo(Config.getRedisHost(), Config.getRedisPort()); 
     shardInfo.setPassword(Config.getRedisPassword()); 
     jedis = new Jedis(shardInfo); 
     jedis.connect(); 
     jedis.select(2); 

    } 

    @Bean 
    ConnectionFactory connectionFactory() { 

     RMQConnectionFactory connectionFactory = new RMQConnectionFactory(); 
     connectionFactory.setUsername(Config.getRabbitMqUsername()); 
     connectionFactory.setPassword(Config.getRabbitMqPassword()); 
     connectionFactory.setVirtualHost(Config.getRabbitMqVHost()); 
     connectionFactory.setHost(Config.getRabbitMqHost()); 
     return connectionFactory; 

    } 

    @SuppressWarnings("rawtypes") 
    @Scheduled(fixedRate = 1) 
    public void readQueueAndSaveData() { 
// take message process it and save to redis as hmset 

}} 

Toute aide serait appréciable.

Answer 1

Il existe deux façons de procéder. 1) Supprimez toutes les propriétés de application.properties et écrivez un bean de configuration qui créera les beans RedisTemplate et RabbitTemplate pour vous. Les propriétés d'usine requises pour celles-ci doivent être obtenues à partir de VCAP_SERVICES. Sur CF, la variable d'environnement VCAP_SERVICES aura les informations sur les services qui sont liées à l'application. Lorsque vous appuyez sur l'application, avec Redis, le service Rabbit est lié à votre espace, alors leurs propriétés sont disponibles dans VCAP_SERVICES. Il suffit donc de faire System.getEnv("VCAP_SERVICES") dans votre code, puis d'analyser le fichier json pour obtenir les détails du service afin de créer les modèles.

2) Supprimer les propriétés de application.properties et utiliser le connecteur de nuage de printemps. Le nuage de printemps a un sous-projet appelé connecteurs de nuage de printemps qui fournissent des utilitaires pour se connecter à divers services de nuage.

http://cloud.spring.io/spring-cloud-connectors/spring-cloud-spring-service-connector.html#_rabbitmq 

Juste vous devez définir une classe qui étend AbstractCloudConfig comme ci-dessous

class CloudConfig extends AbstractCloudConfig { 
    @Bean 
    public RabbitConnectionFactory rabbitFactory() { 
     return connectionFactory().rabbitConnectionFactory("rabbit-servicename"); 
    } 

    @Bean 
    public RedisConnectionFactory redisFactory() { 
     return connectionFactory().redisConnectionFactory("redis-servicename"); 
    } 
} 

La deuxième approche est préférée si vous utilisez Spring, car cela nécessite très moins de codage et peut être commuté, à différents fournisseurs de cloud sans trop d'effort.