Java TransportConfiguration类代码示例

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private <T extends HornetQConnectionFactory> T createEmbeddedConnectionFactory(
		Class<T> factoryClass) throws Exception {
	try {
		TransportConfiguration transportConfiguration = new TransportConfiguration(
				InVMConnectorFactory.class.getName(),
				this.properties.getEmbedded().generateTransportParameters());
		ServerLocator serviceLocator = HornetQClient
				.createServerLocatorWithoutHA(transportConfiguration);
		Constructor<T> constructor = factoryClass
				.getDeclaredConstructor(HornetQProperties.class, ServerLocator.class);
		return BeanUtils.instantiateClass(constructor, this.properties,
				serviceLocator);
	}
	catch (NoClassDefFoundError ex) {
		throw new IllegalStateException("Unable to create InVM "
				+ "HornetQ connection, ensure that hornet-jms-server.jar "
				+ "is in the classpath", ex);
	}
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
@Bean
public MessageListenerContainer hornetQMessageListenerContainer() {
	Map<String, Object> map = new HashMap<String, Object>();
       map.put(TransportConstants.HOST_PROP_NAME, hornetq_host);  
       map.put(TransportConstants.PORT_PROP_NAME, hornetq_port);
	TransportConfiguration transportConfiguration =new TransportConfiguration(
			NettyConnectorFactory.class.getName(), map);
	
	HornetQConnectionFactory hornetQConnectionFactory = HornetQJMSClient.createConnectionFactoryWithoutHA(
			JMSFactoryType.CF, transportConfiguration);
	
	DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
	container.setConnectionFactory((ConnectionFactory) hornetQConnectionFactory);
	container.setDestination(HornetQJMSClient.createTopic(IMConstant.GATEWAY_USERREGISTER_TOPIC));
	container.setPubSubDomain(true);
	container.setPubSubNoLocal(true);
	container.setMessageListener(userRegisterListener);
	container.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
	return container;
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private <T extends HornetQConnectionFactory> T createEmbeddedConnectionFactory(
		Class<T> factoryClass) throws Exception {
	try {
		TransportConfiguration transportConfiguration = new TransportConfiguration(
				InVMConnectorFactory.class.getName(),
				this.properties.getEmbedded().generateTransportParameters());
		ServerLocator serviceLocator = HornetQClient
				.createServerLocatorWithoutHA(transportConfiguration);
		return factoryClass.getConstructor(ServerLocator.class)
				.newInstance(serviceLocator);
	}
	catch (NoClassDefFoundError ex) {
		throw new IllegalStateException("Unable to create InVM "
				+ "HornetQ connection, ensure that hornet-jms-server.jar "
				+ "is in the classpath", ex);
	}
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
/**
 * check if another instance of ioFabric is running
 *
 * @return boolean
 */
private static boolean isAnotherInstanceRunning() {
	Map<String, Object> connectionParams = new HashMap<>();
	connectionParams.put("port", 55555);
	connectionParams.put("host", "localhost");

	ServerLocator serverLocator = HornetQClient.createServerLocatorWithoutHA(
			new TransportConfiguration(NettyConnectorFactory.class.getName(), connectionParams));
	try {
		sf = serverLocator.createSessionFactory();
	} catch (Exception e) {
		return false;
	}

	return true;
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
public static <T extends HornetQConnectionFactory> T fromAuthorities(
        @NonNull Class<T> factoryClass, @NonNull String authorities) throws Exception {
    List<TransportConfiguration> configs = Arrays.stream(authorities.split(",")).map(
            String::toLowerCase).map(String::trim).map(TransportConfigurations::fromAuthority)
            .collect(Collectors.toList());

    Constructor<T> constructor = factoryClass.getConstructor(boolean.class,
            TransportConfiguration[].class);
    return constructor.newInstance(true, Iterables.toArray(configs,
            TransportConfiguration.class));
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
public static TransportConfiguration fromAuthority(@NonNull String authority) {
    String[] hostAndPort = authority.split(":");
    checkArgument(hostAndPort.length == 2);
    checkArgument(!hostAndPort[0].isEmpty());
    checkArgument(!hostAndPort[1].isEmpty());
    return new TransportConfiguration(NettyConnectorFactory.class.getName(), ImmutableMap.of(
            TransportConstants.HOST_PROP_NAME, hostAndPort[0],
            TransportConstants.PORT_PROP_NAME, hostAndPort[1]));
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
@Test
public void mustCreateTransportConfigurationsAccordingToAuthorities() throws Exception {
    ClusteredHornetQProperties twoAuthorities = new ClusteredHornetQProperties();
    twoAuthorities.setAuthorities("foo:8888,bar:9999");
    ClusteredHornetQConnectionFactoryFactory uut = spy(
            new ClusteredHornetQConnectionFactoryFactory(mockBeanFactory, twoAuthorities));
    HornetQConnectionFactory connectionFactory = uut.createConnectionFactory(factoryClass);
    TransportConfiguration[] staticConnectors = connectionFactory.getStaticConnectors();
    assertEquals(2, staticConnectors.length);
    assertEquals("foo", staticConnectors[0].getParams().get("host"));
    assertEquals("8888", staticConnectors[0].getParams().get("port"));
    assertEquals("bar", staticConnectors[1].getParams().get("host"));
    assertEquals("9999", staticConnectors[1].getParams().get("port"));
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
@Test
public void fromAuthorityGoodCase() throws Exception {
    TransportConfiguration transportConfiguration = TransportConfigurations.fromAuthority(
            "somehost:12345");
    assertEquals("somehost", transportConfiguration.getParams().get("host"));
    assertEquals("12345", transportConfiguration.getParams().get("port"));
    assertEquals(NettyConnectorFactory.class.getName(), transportConfiguration
            .getFactoryClassName());
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
@Test
public void mustContainTransportConfigurationToOneGivenAuthority() throws Exception {
    HornetQConnectionFactory connectionFactory = HornetQConnectionFactories.fromAuthorities(
            HornetQConnectionFactory.class, "somehost:12345");
    TransportConfiguration[] staticConnectors = connectionFactory.getStaticConnectors();
    assertEquals(1, staticConnectors.length);
    assertEquals("somehost", staticConnectors[0].getParams().get("host"));
    assertEquals("12345", staticConnectors[0].getParams().get("port"));
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
@Test
public void mustContainTransportConfigurationToTwoGivenAuthorities() throws Exception {
    HornetQConnectionFactory connectionFactory = HornetQConnectionFactories.fromAuthorities(
            HornetQConnectionFactory.class, "foo:8888,bar:9999");
    TransportConfiguration[] staticConnectors = connectionFactory.getStaticConnectors();
    assertEquals(2, staticConnectors.length);
    assertEquals("foo", staticConnectors[0].getParams().get("host"));
    assertEquals("8888", staticConnectors[0].getParams().get("port"));
    assertEquals("bar", staticConnectors[1].getParams().get("host"));
    assertEquals("9999", staticConnectors[1].getParams().get("port"));
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
public Configuration createConfiguration() {
	ConfigurationImpl configuration = new ConfigurationImpl();
	configuration.setSecurityEnabled(false);
	configuration.setPersistenceEnabled(this.properties.isPersistent());

	String dataDir = getDataDir();

	// HORNETQ-1302
	configuration.setJournalDirectory(dataDir + "/journal");

	if (this.properties.isPersistent()) {
		configuration.setJournalType(JournalType.NIO);
		configuration.setLargeMessagesDirectory(dataDir + "/largemessages");
		configuration.setBindingsDirectory(dataDir + "/bindings");
		configuration.setPagingDirectory(dataDir + "/paging");
	}

	TransportConfiguration transportConfiguration = new TransportConfiguration(
			InVMAcceptorFactory.class.getName(),
			this.properties.generateTransportParameters());
	configuration.getAcceptorConfigurations().add(transportConfiguration);

	// HORNETQ-1143
	if (this.properties.isDefaultClusterPassword()) {
		logger.debug("Using default HornetQ cluster password: "
				+ this.properties.getClusterPassword());
	}

	configuration.setClusterPassword(this.properties.getClusterPassword());
	return configuration;
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private <T extends HornetQConnectionFactory> T createNativeConnectionFactory(
		Class<T> factoryClass) throws Exception {
	Map<String, Object> params = new HashMap<String, Object>();
	params.put(TransportConstants.HOST_PROP_NAME, this.properties.getHost());
	params.put(TransportConstants.PORT_PROP_NAME, this.properties.getPort());
	TransportConfiguration transportConfiguration = new TransportConfiguration(
			NettyConnectorFactory.class.getName(), params);
	Constructor<T> constructor = factoryClass.getDeclaredConstructor(
			HornetQProperties.class, boolean.class, TransportConfiguration[].class);
	return BeanUtils.instantiateClass(constructor, this.properties, false,
			new TransportConfiguration[] { transportConfiguration });
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private TransportConfiguration assertInVmConnectionFactory(
		HornetQConnectionFactory connectionFactory) {
	TransportConfiguration transportConfig = getSingleTransportConfiguration(
			connectionFactory);
	assertThat(transportConfig.getFactoryClassName())
			.isEqualTo(InVMConnectorFactory.class.getName());
	return transportConfig;
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private TransportConfiguration assertNettyConnectionFactory(
		HornetQConnectionFactory connectionFactory, String host, int port) {
	TransportConfiguration transportConfig = getSingleTransportConfiguration(
			connectionFactory);
	assertThat(transportConfig.getFactoryClassName())
			.isEqualTo(NettyConnectorFactory.class.getName());
	assertThat(transportConfig.getParams().get("host")).isEqualTo(host);
	assertThat(transportConfig.getParams().get("port")).isEqualTo(port);
	return transportConfig;
}
 

import org.hornetq.api.core.TransportConfiguration; //导入依赖的package包/类
private TransportConfiguration getSingleTransportConfiguration(
		HornetQConnectionFactory connectionFactory) {
	TransportConfiguration[] transportConfigurations = connectionFactory
			.getServerLocator().getStaticTransportConfigurations();
	assertThat(transportConfigurations.length).isEqualTo(1);
	return transportConfigurations[0];
}