title: configuring multiple Vhosts in AMQP in rabbitmq configuration spring boot
body: <p>i'm implementing a project where i have to send messages across different vhosts in rabbitmq. using SimpleRoutingConnectionFactory but get java.lang.IllegalStateException: Cannot determine target ConnectionFactory for lookup key [null]. 
  Anyone who has an idea how to implement such below is my configuration class code.</p>
  
  <pre><code>@Configuration
  @EnableRabbit
  public class RabbitMQConfiguration {
  
  @Autowired
  ConnectionProperties connect;
  
  // client1 exchanges
  @Bean
  public TopicExchange client1Exchange() {
      TopicExchange ex = new TopicExchange("ex_client1");
      ex.setAdminsThatShouldDeclare(client1());
      return ex;
  }
  
  // client2 exchange
  @Bean
  public TopicExchange client2Exchange() {
      TopicExchange ex = new TopicExchange("ex_client2");
      ex.setAdminsThatShouldDeclare(client2Admin());
      return ex;
  }
  
  @Bean
  public Queue client1Queue() {
      Queue queue = new Queue("client1_queue");
      queue.setAdminsThatShouldDeclare(client1());
      return queue;
  }
  
  @Bean
  public Binding client1Binding() {
      Binding binding = BindingBuilder.bind(client1Queue())
              .to(client1Exchange())
              .with("client1_key");
      binding.setAdminsThatShouldDeclare(client1());
      return binding;
  }
  
  
  @Bean
  public Queue client2Queue() {
      Queue queue = new Queue("client2_queue");
      queue.setAdminsThatShouldDeclare(client2());
      return queue;
  }
  
  @Bean
  public Binding client2Binding() {
      Binding binding = BindingBuilder.bind(client2Queue())
              .to(client2Exchange())
              .with("client2_key");
      binding.setAdminsThatShouldDeclare(client2());
      return binding;
  }
  
  @Bean
  @Primary
  public ConnectionFactory connectionFactory() {
      SimpleRoutingConnectionFactory connectionFactory = new SimpleRoutingConnectionFactory();
      Map&lt;Object, ConnectionFactory&gt; targetConnectionFactories = new HashMap&lt;&gt;();
      targetConnectionFactories.put("client1", client1ConnectionFactory());
      targetConnectionFactories.put("client2", client2ConnectionFactory());
      connectionFactory.setTargetConnectionFactories(targetConnectionFactories);
      return connectionFactory;
  }
  
  @Bean
  public ConnectionFactory client1ConnectionFactory() {
      CachingConnectionFactory connectionFactory = new CachingConnectionFactory(connect.getRabbitMQHost());
      connectionFactory.setVirtualHost(connect.getRabbitMQClient1VHost());
      connectionFactory.setUsername(connect.getRabbitMQClient1User());
      connectionFactory.setPassword(connect.getRabbitMQClient1Pass());
      return connectionFactory;
  }
  
  @Bean
  public ConnectionFactory client2ConnectionFactory() {
      CachingConnectionFactory connectionFactory = new CachingConnectionFactory(connect.getRabbitMQHost());
      connectionFactory.setVirtualHost(connect.getRabbitMQClient2VHost());
      connectionFactory.setUsername(connect.getRabbitClient2User());
      connectionFactory.setPassword(connect.getRabbitClient2Pass());
      return connectionFactory;
  }
  
  // You can comment all methods below and remove interface's implementation to use the default serialization / deserialization
  @Bean
  public RabbitTemplate rabbitTemplate() {
      final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
      rabbitTemplate.setMessageConverter(producerJackson2MessageConverter());
      return rabbitTemplate;
  }
  
  @Bean
  public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
      return new Jackson2JsonMessageConverter();
  }
  
  @Bean
  public MappingJackson2MessageConverter consumerJackson2MessageConverter() {
      return new MappingJackson2MessageConverter();
  }
  
  @Bean
  public DefaultMessageHandlerMethodFactory messageHandlerMethodFactory() {
      DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
      factory.setMessageConverter(consumerJackson2MessageConverter());
      return factory;
  }
  
  @Bean
  public TaskExecutor rabbitListenerExecutor() {
      int threads = Integer.valueOf(connect.getMinConsumers()) * 2; // threads = min consumers* no of queues
      final ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
      executor.setCorePoolSize(threads);
      executor.setMaxPoolSize(threads);
      executor.setThreadNamePrefix("RabbitThreadListener");
      executor.afterPropertiesSet();
      return executor;
  }
  
  @Bean
  public SimpleRabbitListenerContainerFactory myRabbitListenerContainerFactory() {
      SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
      factory.setConnectionFactory(connectionFactory());
      factory.setConcurrentConsumers(Integer.valueOf(connect.getMinConsumers()));
      factory.setPrefetchCount(Integer.valueOf(connect.getPrefetchCount()));
      factory.setTaskExecutor(rabbitListenerExecutor());
      factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
      return factory;
  }
  
  @Bean
  public RabbitAdmin client1() {
      RabbitAdmin rabbitAdmin = new RabbitAdmin(client1ConnectionFactory());
      rabbitAdmin.afterPropertiesSet();
      return rabbitAdmin;
  }
  
  @Bean
  public RabbitAdmin client2() {
      RabbitAdmin rabbitAdmin = new RabbitAdmin(client2ConnectionFactory());
      rabbitAdmin.afterPropertiesSet();
      return rabbitAdmin;
  }
  </code></pre>
  
  <p>}</p>
  
  <p>i'm getting this stacktrace</p>
  
  <pre><code>o.s.a.r.l.SimpleMessageListenerContainer - Consumer raised exception, 
  processing can restart if the connection factory supports it
  java.lang.IllegalStateException: Cannot determine target ConnectionFactory for lookup key [null]
      at org.springframework.amqp.rabbit.connection.AbstractRoutingConnectionFactory.determineTargetConnectionFactory(AbstractRoutingConnectionFactory.java:119)
      at org.springframework.amqp.rabbit.connection.AbstractRoutingConnectionFactory.createConnection(AbstractRoutingConnectionFactory.java:97)
      at org.springframework.amqp.rabbit.connection.ConnectionFactoryUtils$1.createConnection(ConnectionFactoryUtils.java:90)
      at org.springframework.amqp.rabbit.connection.ConnectionFactoryUtils.doGetTransactionalResourceHolder(ConnectionFactoryUtils.java:140)
      at org.springframework.amqp.rabbit.connection.ConnectionFactoryUtils.getTransactionalResourceHolder(ConnectionFactoryUtils.java:76)
      at org.springframework.amqp.rabbit.listener.BlockingQueueConsumer.start(BlockingQueueConsumer.java:505)
      at org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$AsyncMessageProcessingConsumer.run(SimpleMessageListenerContainer.java:1335)
      at java.lang.Thread.run(Thread.java:748)
  </code></pre>