Java MQTT.setClientId方法代码示例

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test// (timeout=60 * 1000)
    public void canDetectTheMQTTProtocol() throws Exception {

        DetectingGateway gateway = createGateway();

        // Lets establish a connection....
        MQTT mqtt = new MQTT();
        mqtt.setHost("localhost", gateway.getBoundPort());
        mqtt.setClientId("myclientid");
//        mqtt.setVersion("3.1.1");
        mqtt.setUserName("broker0/chirino");
        mqtt.setConnectAttemptsMax(1);

        org.fusesource.mqtt.client.BlockingConnection connection = mqtt.blockingConnection();
        connection.connect();

        assertEquals(1, gateway.getSuccessfulConnectionAttempts());
        assertEquals(1, gateway.getConnectedClients().length);
        assertConnectedToBroker(0);
        connection.kill();
    }
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
private MQTT newClient(MqttLinkConfig config) {
	MQTT client = new MQTT();
	client.setClientId(config.getClientId());
	client.setHost(URIs.newURI(connectionPrefix(config) + "://"
			+ config.getHost() + ":" + config.getPort()));
	String user = config.getUser();
	if (!Strings.nullOrEmpty(user)) {
		client.setUserName(user);
	}
	String password = config.getPassword();
	if (!Strings.nullOrEmpty(password)) {
		client.setPassword(password);
	}
	return client;

}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
        MQTT client = new MQTT();
        client.setHost("tcp://raspberrypi.local:1883");
        client.setClientId("fusesourcepublisher");
        BlockingConnection connection = client.blockingConnection();

        connection.connect();

        connection.publish("testack", "Hello".getBytes(), QoS.AT_LEAST_ONCE, false);

    while(true){
        Thread.sleep(2000);
    }
        //connection.disconnect();

}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
private MQTT createMQTTSslConnection(String clientId, boolean clean) throws Exception {
   MQTT mqtt = new MQTT();
   mqtt.setConnectAttemptsMax(1);
   mqtt.setReconnectAttemptsMax(0);
   mqtt.setTracer(createTracer());
   mqtt.setHost("ssl://localhost:" + port);
   if (clientId != null) {
      mqtt.setClientId(clientId);
   }
   mqtt.setCleanSession(clean);

   SSLContext ctx = SSLContext.getInstance("TLS");
   ctx.init(new KeyManager[0], new TrustManager[]{new DefaultTrustManager()}, new SecureRandom());
   mqtt.setSslContext(ctx);
   return mqtt;
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
protected static MQTT mqttClient(String host, int port) {
	MQTT client = new MQTT();
	client.setCleanSession(true);
	client.setClientId("amc-" + Thread.currentThread().getId() + "-"
			+ System.currentTimeMillis());
	client.setHost(URIs.newURI("tcp://" + host + ":" + port));
	return client;
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Override
public void setup(OperatorContext context)
{
  try {
    client = new MQTT();
    if (mqttClientConfig.getClientId() != null) {
      client.setClientId(mqttClientConfig.getClientId());
    }
    client.setCleanSession(mqttClientConfig.isCleanSession());
    client.setConnectAttemptsMax(mqttClientConfig.getConnectAttemptsMax());
    client.setHost(mqttClientConfig.getHost(), mqttClientConfig.getPort());
    client.setKeepAlive(mqttClientConfig.getKeepAliveInterval());
    if (mqttClientConfig.getPassword() != null) {
      client.setPassword(mqttClientConfig.getPassword());
    }
    if (mqttClientConfig.getUserName() != null) {
      client.setUserName(mqttClientConfig.getUserName());
    }
    if (mqttClientConfig.getWillMessage() != null) {
      client.setWillMessage(mqttClientConfig.getWillMessage());
      client.setWillQos(mqttClientConfig.getWillQos());
      client.setWillRetain(mqttClientConfig.isWillRetain());
      client.setWillTopic(mqttClientConfig.getWillTopic());
    }
    connection = client.blockingConnection();
    connection.connect();
  } catch (Throwable t) {
    throw new RuntimeException(t);
  }
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
private MQTT createMQTTTcpConnection(String clientId, boolean clean) throws Exception {
   MQTT mqtt = new MQTT();
   mqtt.setConnectAttemptsMax(1);
   mqtt.setReconnectAttemptsMax(0);
   mqtt.setTracer(createTracer());
   mqtt.setVersion("3.1.1");
   if (clientId != null) {
      mqtt.setClientId(clientId);
   }
   mqtt.setCleanSession(clean);
   mqtt.setHost("localhost", port);
   return mqtt;
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test(timeout = 30 * 1000)
public void testValidZeroLengthClientId() throws Exception {
   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId("");
   mqtt.setCleanSession(true);

   BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();
   connection.disconnect();
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test(timeout = 60 * 1000)
public void testAnycastAddressWorksWithMQTT() throws Exception {
   String anycastAddress = "foo/bar";

   getServer().addAddressInfo(new AddressInfo(SimpleString.toSimpleString("foo.bar"), RoutingType.ANYCAST));
   String clientId = "testMqtt";

   Topic[] mqttSubscription = new Topic[]{new Topic(anycastAddress, QoS.AT_LEAST_ONCE)};

   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId(clientId);
   BlockingConnection connection1 = mqtt.blockingConnection();
   connection1.connect();
   connection1.subscribe(mqttSubscription);

   MQTT mqtt2 = createMQTTConnection();
   mqtt2.setClientId(clientId + "2");
   BlockingConnection connection2 = mqtt2.blockingConnection();
   connection2.connect();
   connection2.subscribe(mqttSubscription);

   String message1 = "TestMessage1";
   String message2 = "TestMessage2";

   connection1.publish(anycastAddress, message1.getBytes(), QoS.AT_LEAST_ONCE, false);
   connection2.publish(anycastAddress, message2.getBytes(), QoS.AT_LEAST_ONCE, false);

   assertNotNull(connection1.receive(1000, TimeUnit.MILLISECONDS));
   assertNull(connection1.receive(1000, TimeUnit.MILLISECONDS));

   assertNotNull(connection2.receive(1000, TimeUnit.MILLISECONDS));
   assertNull(connection2.receive(1000, TimeUnit.MILLISECONDS));
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test(timeout = 60 * 1000)
public void testPingKeepsInactivityMonitorAlive() throws Exception {
   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId("foo");
   mqtt.setKeepAlive((short) 2);
   final BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();

   assertTrue("KeepAlive didn't work properly", Wait.waitFor(() -> connection.isConnected()));

   connection.disconnect();
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test
public void testRetainedMessagesAreCorrectlyFormedAfterRestart() throws Exception {
   String clientId = "testMqtt";
   String address = "testAddress";
   String payload = "This is a test message";

   // Create address
   getServer().addAddressInfo(new AddressInfo(SimpleString.toSimpleString(address), RoutingType.MULTICAST));

   // Send MQTT Retain Message
   Topic[] mqttTopic = new Topic[]{new Topic(address, QoS.AT_LEAST_ONCE)};

   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId(clientId);
   BlockingConnection connection1 = mqtt.blockingConnection();
   connection1.connect();
   connection1.publish(address, payload.getBytes(), QoS.AT_LEAST_ONCE, true);

   getServer().fail(false);
   getServer().start();
   waitForServerToStart(getServer());

   MQTT mqtt2 = createMQTTConnection();
   mqtt2.setClientId(clientId + "2");
   BlockingConnection connection2 = mqtt2.blockingConnection();
   connection2.connect();
   connection2.subscribe(mqttTopic);

   Message message = connection2.receive(5000, TimeUnit.MILLISECONDS);
   assertEquals(payload, new String(message.getPayload()));
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Ignore
@Test(timeout = 60 * 1000)
// TODO Make dollar topics configurable in code base.
public void testPublishDollarTopics() throws Exception {
   MQTT mqtt = createMQTTConnection();
   final String clientId = "publishDollar";
   mqtt.setClientId(clientId);
   mqtt.setKeepAlive((short) 2);
   BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();

   final String DOLLAR_TOPIC = "$TopicA";
   connection.subscribe(new Topic[]{new Topic(DOLLAR_TOPIC, QoS.EXACTLY_ONCE)});
   connection.publish(DOLLAR_TOPIC, DOLLAR_TOPIC.getBytes(), QoS.EXACTLY_ONCE, true);

   Message message = connection.receive(10, TimeUnit.SECONDS);
   assertNull("Publish enabled for $ Topics by default", message);
   connection.disconnect();

   stopBroker();
   protocolConfig = "transport.publishDollarTopics=true";
   startBroker();

   mqtt = createMQTTConnection();
   mqtt.setClientId(clientId);
   mqtt.setKeepAlive((short) 2);
   connection = mqtt.blockingConnection();
   connection.connect();

   connection.subscribe(new Topic[]{new Topic(DOLLAR_TOPIC, QoS.EXACTLY_ONCE)});
   connection.publish(DOLLAR_TOPIC, DOLLAR_TOPIC.getBytes(), QoS.EXACTLY_ONCE, true);

   message = connection.receive(10, TimeUnit.SECONDS);
   assertNotNull(message);
   message.ack();
   assertEquals("Message body", DOLLAR_TOPIC, new String(message.getPayload()));

   connection.disconnect();
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
public void doTestJmsMapping(String destinationName) throws Exception {
   // start up jms consumer
   Connection jmsConn = cf.createConnection();
   Session session = jmsConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
   Destination dest = session.createQueue(destinationName);
   MessageConsumer consumer = session.createConsumer(dest);
   jmsConn.start();

   // set up mqtt producer
   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId("foo3");
   mqtt.setKeepAlive((short) 2);
   final BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();

   int messagesToSend = 5;

   // publish
   for (int i = 0; i < messagesToSend; ++i) {
      connection.publish("test/foo", "hello world".getBytes(), QoS.AT_LEAST_ONCE, false);
   }

   connection.disconnect();

   for (int i = 0; i < messagesToSend; i++) {

      javax.jms.Message message = consumer.receive(2 * 1000);
      assertNotNull(message);
      assertTrue(message instanceof BytesMessage);
      BytesMessage bytesMessage = (BytesMessage) message;

      int length = (int) bytesMessage.getBodyLength();
      byte[] buffer = new byte[length];
      bytesMessage.readBytes(buffer);
      assertEquals("hello world", new String(buffer));
   }

   jmsConn.close();
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test(timeout = 30 * 10000)
public void testSubscribeMultipleTopics() throws Exception {

   byte[] payload = new byte[1024 * 32];
   for (int i = 0; i < payload.length; i++) {
      payload[i] = '2';
   }

   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId("MQTT-Client");
   mqtt.setCleanSession(false);

   final BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();

   Topic[] topics = {new Topic("Topic/A", QoS.EXACTLY_ONCE), new Topic("Topic/B", QoS.EXACTLY_ONCE)};
   Topic[] wildcardTopic = {new Topic("Topic/#", QoS.AT_LEAST_ONCE)};
   connection.subscribe(wildcardTopic);

   for (Topic topic : topics) {
      connection.publish(topic.name().toString(), payload, QoS.AT_LEAST_ONCE, false);
   }

   int received = 0;
   for (int i = 0; i < topics.length; ++i) {
      Message message = connection.receive();
      assertNotNull(message);
      received++;
      payload = message.getPayload();
      String messageContent = new String(payload);
      LOG.info("Received message from topic: " + message.getTopic() + " Message content: " + messageContent);
      message.ack();
   }

   assertEquals("Should have received " + topics.length + " messages", topics.length, received);
}
 

import org.fusesource.mqtt.client.MQTT; //导入方法依赖的package包/类
@Test(timeout = 30 * 1000)
public void testDefaultKeepAliveWhenClientSpecifiesZero() throws Exception {
   stopBroker();
   protocolConfig = "transport.defaultKeepAlive=2000";
   startBroker();

   MQTT mqtt = createMQTTConnection();
   mqtt.setClientId("foo");
   mqtt.setKeepAlive((short) 0);
   final BlockingConnection connection = mqtt.blockingConnection();
   connection.connect();

   assertTrue("KeepAlive didn't work properly", Wait.waitFor(() -> connection.isConnected()));
}