How to use

AbstractRoutingConnectionFactory

in

org.springframework.amqp.rabbit.connection

/**
 * Retrieve the current target {@link ConnectionFactory}. Determines the
 * {@link #determineCurrentLookupKey() current lookup key}, performs
 * a lookup in the {@link #targetConnectionFactories} map,
 * falls back to the specified
 * {@link #defaultTargetConnectionFactory} if necessary.
 * @return The connection factory.
 * @see #determineCurrentLookupKey()
 */
protected ConnectionFactory determineTargetConnectionFactory() {
  Object lookupKey = determineCurrentLookupKey();
  ConnectionFactory connectionFactory = null;
  if (lookupKey != null) {
    connectionFactory = this.targetConnectionFactories.get(lookupKey);
  }
  if (connectionFactory == null && (this.lenientFallback || lookupKey == null)) {
    connectionFactory = this.defaultTargetConnectionFactory;
  }
  if (connectionFactory == null) {
    throw new IllegalStateException("Cannot determine target ConnectionFactory for lookup key ["
        + lookupKey + "]");
  }
  return connectionFactory;
}

@Override
public int getPort() {
  return this.determineTargetConnectionFactory().getPort();
}

private ConnectionFactory obtainTargetConnectionFactory(Expression expression, Object rootObject) {
  if (expression != null && getConnectionFactory() instanceof AbstractRoutingConnectionFactory) {
    AbstractRoutingConnectionFactory routingConnectionFactory =
        (AbstractRoutingConnectionFactory) getConnectionFactory();
    Object lookupKey;
    if (rootObject != null) {
      lookupKey = this.sendConnectionFactorySelectorExpression.getValue(this.evaluationContext, rootObject);
    }
    else {
      lookupKey = this.sendConnectionFactorySelectorExpression.getValue(this.evaluationContext);
    }
    if (lookupKey != null) {
      ConnectionFactory connectionFactory = routingConnectionFactory.getTargetConnectionFactory(lookupKey);
      if (connectionFactory != null) {
        return connectionFactory;
      }
      else if (!routingConnectionFactory.isLenientFallback()) {
        throw new IllegalStateException("Cannot determine target ConnectionFactory for lookup key ["
            + lookupKey + "]");
      }
    }
  }
  return getConnectionFactory();
}

@Test
public void testGetAddAndRemoveOperationsForTargetConnectionFactories() {
  ConnectionFactory targetConnectionFactory = Mockito.mock(ConnectionFactory.class);
  AbstractRoutingConnectionFactory routingFactory = new AbstractRoutingConnectionFactory() {
    @Override
    protected Object determineCurrentLookupKey() {
      return null;
    }
  };
  //Make sure map is initialized and doesn't contain lookup key "1"
  assertNull(routingFactory.getTargetConnectionFactory("1"));
  //Add one and make sure it's there
  routingFactory.addTargetConnectionFactory("1", targetConnectionFactory);
  assertEquals(targetConnectionFactory, routingFactory.getTargetConnectionFactory("1"));
  assertNull(routingFactory.getTargetConnectionFactory("2"));
  //Remove it and make sure it's gone
  ConnectionFactory removedConnectionFactory = routingFactory.removeTargetConnectionFactory("1");
  assertEquals(targetConnectionFactory, removedConnectionFactory);
  assertNull(routingFactory.getTargetConnectionFactory("1"));
}

@Test
public void testAbstractRoutingConnectionFactory() {
  ConnectionFactory connectionFactory1 = Mockito.mock(ConnectionFactory.class);
  ConnectionFactory connectionFactory2 = Mockito.mock(ConnectionFactory.class);
  Map<Object, ConnectionFactory> factories = new HashMap<Object, ConnectionFactory>(2);
  factories.put(Boolean.TRUE, connectionFactory1);
  factories.put(Boolean.FALSE, connectionFactory2);
  ConnectionFactory defaultConnectionFactory = Mockito.mock(ConnectionFactory.class);
  final AtomicBoolean lookupFlag = new AtomicBoolean(true);
  final AtomicInteger count = new AtomicInteger();
  AbstractRoutingConnectionFactory connectionFactory = new AbstractRoutingConnectionFactory() {
    @Override
    protected Object determineCurrentLookupKey() {
      return count.incrementAndGet() > 3 ? null : lookupFlag.getAndSet(!lookupFlag.get());
    }
  };
  connectionFactory.setDefaultTargetConnectionFactory(defaultConnectionFactory);
  connectionFactory.setTargetConnectionFactories(factories);
  for (int i = 0; i < 5; i++) {
    connectionFactory.createConnection();
  }
  verify(connectionFactory1, times(2)).createConnection();
  verify(connectionFactory2).createConnection();
  verify(defaultConnectionFactory, times(2)).createConnection();
}

@Test
public void testAddTargetConnectionFactoryAddsExistingConnectionListenersToConnectionFactory() {
  AbstractRoutingConnectionFactory routingFactory = new AbstractRoutingConnectionFactory() {
    @Override
    protected Object determineCurrentLookupKey() {
      return null;
    }
  };
  routingFactory.addConnectionListener(Mockito.mock(ConnectionListener.class));
  routingFactory.addConnectionListener(Mockito.mock(ConnectionListener.class));
  ConnectionFactory targetConnectionFactory = Mockito.mock(ConnectionFactory.class);
  routingFactory.addTargetConnectionFactory("1", targetConnectionFactory);
  verify(targetConnectionFactory,
      times(2)).addConnectionListener(any(ConnectionListener.class));
}

@Test
public void testSimpleRoutingConnectionFactory() throws InterruptedException {
  ConnectionFactory connectionFactory1 = Mockito.mock(ConnectionFactory.class);
  ConnectionFactory connectionFactory2 = Mockito.mock(ConnectionFactory.class);
  Map<Object, ConnectionFactory> factories = new HashMap<Object, ConnectionFactory>(2);
  factories.put("foo", connectionFactory1);
  factories.put("bar", connectionFactory2);
  final AbstractRoutingConnectionFactory connectionFactory = new SimpleRoutingConnectionFactory();
  connectionFactory.setTargetConnectionFactories(factories);
  ExecutorService executorService = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 3; i++) {
    final AtomicInteger count = new AtomicInteger(i);
    executorService.execute(() -> {
      SimpleResourceHolder.bind(connectionFactory, count.get() % 2 == 0 ? "foo" : "bar");
      connectionFactory.createConnection();
      SimpleResourceHolder.unbind(connectionFactory);
    });
  }
  executorService.shutdown();
  assertTrue(executorService.awaitTermination(10, TimeUnit.SECONDS));
  verify(connectionFactory1, times(2)).createConnection();
  verify(connectionFactory2).createConnection();
}

private ConnectionFactory obtainTargetConnectionFactory(Expression expression, Object rootObject) {
  if (expression != null && getConnectionFactory() instanceof AbstractRoutingConnectionFactory) {
    AbstractRoutingConnectionFactory routingConnectionFactory =
        (AbstractRoutingConnectionFactory) getConnectionFactory();
    Object lookupKey;
    if (rootObject != null) {
      lookupKey = this.sendConnectionFactorySelectorExpression.getValue(this.evaluationContext, rootObject);
    }
    else {
      lookupKey = this.sendConnectionFactorySelectorExpression.getValue(this.evaluationContext);
    }
    if (lookupKey != null) {
      ConnectionFactory connectionFactory = routingConnectionFactory.getTargetConnectionFactory(lookupKey);
      if (connectionFactory != null) {
        return connectionFactory;
      }
      else if (!routingConnectionFactory.isLenientFallback()) {
        throw new IllegalStateException("Cannot determine target ConnectionFactory for lookup key ["
            + lookupKey + "]");
      }
    }
  }
  return getConnectionFactory();
}

@Override
public String getUsername() {
  return this.determineTargetConnectionFactory().getUsername();
}

/**
 * Retrieve the current target {@link ConnectionFactory}. Determines the
 * {@link #determineCurrentLookupKey() current lookup key}, performs
 * a lookup in the {@link #targetConnectionFactories} map,
 * falls back to the specified
 * {@link #defaultTargetConnectionFactory} if necessary.
 * @return The connection factory.
 * @see #determineCurrentLookupKey()
 */
protected ConnectionFactory determineTargetConnectionFactory() {
  Object lookupKey = determineCurrentLookupKey();
  ConnectionFactory connectionFactory = null;
  if (lookupKey != null) {
    connectionFactory = this.targetConnectionFactories.get(lookupKey);
  }
  if (connectionFactory == null && (this.lenientFallback || lookupKey == null)) {
    connectionFactory = this.defaultTargetConnectionFactory;
  }
  if (connectionFactory == null) {
    throw new IllegalStateException("Cannot determine target ConnectionFactory for lookup key ["
        + lookupKey + "]");
  }
  return connectionFactory;
}

@Override
public Connection createConnection() throws AmqpException {
  return this.determineTargetConnectionFactory().createConnection();
}

@Override
public String getHost() {
  return this.determineTargetConnectionFactory().getHost();
}

@Override
public String getHost() {
  return this.determineTargetConnectionFactory().getHost();
}

@Override
public String getVirtualHost() {
  return this.determineTargetConnectionFactory().getVirtualHost();
}

@Override
public Connection createConnection() throws AmqpException {
  return this.determineTargetConnectionFactory().createConnection();
}

@Override
public String getVirtualHost() {
  return this.determineTargetConnectionFactory().getVirtualHost();
}

@Override
public String getUsername() {
  return this.determineTargetConnectionFactory().getUsername();
}

@Override
public int getPort() {
  return this.determineTargetConnectionFactory().getPort();
}