org.springframework.jms.annotation.JmsListener Java Examples

@JmsListener( destination = Topics.TRACKER_IMPORT_RULE_ENGINE_TOPIC_NAME, containerFactory = "jmsQueueListenerContainerFactory" )
public void consume( TextMessage message ) throws JMSException, IOException
{
    TrackerSideEffectDataBundle bundle = toBundle( message );

    if ( bundle == null )
    {
        return;
    }

    JobConfiguration jobConfiguration = new JobConfiguration( "", JobType.TRACKER_IMPORT_RULE_ENGINE_JOB, bundle.getAccessedBy(), true );

    bundle.setJobConfiguration( jobConfiguration );

    TrackerRuleEngineThread notificationThread = trackerRuleEngineThreadObjectFactory.getObject();

    notificationThread.setSideEffectDataBundle( bundle );

    executeJob( notificationThread );
}
 

/**
 * 接收数据卷信息
 * @author hf
 * @since 2018/7/13 17:08
 */
@JmsListener(destination = "MQ_QUEUE_VOLUME")
public void receiveVolume(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");
        ResultVO resultVO = JsonUtils.jsonToObject(map.get("data"), ResultVO.class);

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(JsonUtils.objectToJson(resultVO), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收通知消息错误，错误位置：{}，错误信息：{}", "MQConsumer.接收到消息()", e.getMessage());
        }
    }
}
 

/**
 * 接收通知信息
 * @author hf
 * @since 2018/7/13 17:08
 */
@JmsListener(destination = "MQ_QUEUE_NOTICE")
public void receiveNotice(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");
        ResultVO resultVO = JsonUtils.jsonToObject(map.get("data"), ResultVO.class);

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(JsonUtils.objectToJson(resultVO), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收通知消息错误，错误位置：{}，错误信息：{}", "MQConsumer.receiveService()", e.getMessage());
        }
    }
}
 

/**
 * 接收服务信息
 * @author hf
 * @since 2018/7/13 17:08
 */
@JmsListener(destination = "MQ_QUEUE_SERVICE")
public void receiveService(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");
        ResultVO resultVO = JsonUtils.jsonToObject(map.get("data"), ResultVO.class);

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(JsonUtils.objectToJson(resultVO), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收服务消息错误，错误位置：{}，错误信息：{}", "MQConsumer.receiveService()", e.getMessage());
        }
    }
}
 

/**
 * 接收HUB镜像信息
 * @author jitwxs
 * @since 2018/7/9 17:08
 */
@JmsListener(destination = "MQ_QUEUE_HUB_IMAGE")
public void receiveHubImage(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(map.get("data"), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收HUB镜像消息错误，错误位置：{}，错误信息：{}", "MQConsumer.receiveHubImage()", e.getMessage());
        }
    }
}
 

@JmsListener(destination = "ActiveMQ.Advisory.Connection", containerFactory = "topicJmsListenerContainerFactory", concurrency = "5-10")
public void advisoryConnection(Message msg) {
    try {
        if (msg instanceof ActiveMQMessage) {
            ActiveMQMessage aMsg = (ActiveMQMessage) msg;
            if (aMsg.getDataStructure() instanceof ConnectionInfo) {
                ConnectionInfo connectionInfo = (ConnectionInfo) aMsg.getDataStructure();
                log.info("连接信息：" + JacksonUtil.toJson(connectionInfo));
            } else if (aMsg.getDataStructure() instanceof RemoveInfo) {
                RemoveInfo removeInfo = (RemoveInfo) aMsg.getDataStructure();
                log.info("移除信息：" + JacksonUtil.toJson(removeInfo));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}
 

/**
 * 接收系统镜像信息
 * @author jitwxs
 * @since 2018/7/9 17:08
 */
@JmsListener(destination = "MQ_QUEUE_SYS_IMAGE")
public void receiveSysImage(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(map.get("data"), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收系统镜像消息错误，错误位置：{}，错误信息：{}", "MQConsumer.receiveSysImage()", e.getMessage());
        }
    }
}
 

/**
 * 接收容器信息
 * @author jitwxs
 * @since 2018/7/9 17:08
 */
@JmsListener(destination = "MQ_QUEUE_CONTAINER")
public void receiveContainer(String text) {
    if (StringUtils.isNotBlank(text)) {
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String userId = map.get("uid");

        String field = ID_PREFIX + userId;
        try {
            String sessionId = jedisClient.hget(key, field);
            if (StringUtils.isNotBlank(sessionId)) {
                webSocketServer.sendMessage(map.get("data"), sessionId);
            } else {
                throw new Exception("session未找到");
            }
        } catch (Exception e) {
            log.error("接收容器消息错误，错误位置：{}，错误信息：{}", "MQConsumer.receiveContainer()", e.getMessage());
        }
    }
}
 

/**
 * 接收邮箱注册消息
 * @author jitwxs
 * @since 2018/7/9 16:05
 */
@JmsListener(destination = "MQ_QUEUE_REGISTER")
public void receiveRegister(String text) {
    if(StringUtils.isNotBlank(text)){
        Task task = JsonUtils.jsonToObject(text, Task.class);

        Map<String, String> map = task.getData();
        String email = map.get("email");
        log.info("验证未激活邮箱，目标邮箱：{}", email);

        SysLogin login = loginService.getByEmail(email);
        if(login != null && login.getHasFreeze()) {
            loginService.deleteById(login);
        }
    }
}
 

@JmsListener(destination = JMSType.SEND_MAIL)
public void sendMail(@Payload Object obj, @Headers MessageHeaders headers, Message message, Session session) {
	log.info("recived mail: {}", obj);

	System.out.println("-------------------------");
	System.out.println("obj:" + obj);
	System.out.println("headers:" + headers);
	System.out.println("message:" + message);
	System.out.println("session:" + session);
	System.out.println("-------------------------");

	if (obj instanceof MimeMessage) {
		mailSender.send((MimeMessage) obj);
	} else {
		mailSender.send((SimpleMailMessage) obj);
	}
}
 

@JmsListener(destination = "${destination.order}")
public void receiveOrder(String orderNumber,
    @Header(JmsHeaders.MESSAGE_ID) String messageId) {
  LOGGER.info("received OrderNumber='{}' with MessageId='{}'",
      orderNumber, messageId);

  LOGGER.info("sending Status='Accepted' with CorrelationId='{}'",
      messageId);

  jmsTemplate.send(statusDestination, messageCreator -> {
    TextMessage message =
        messageCreator.createTextMessage("Accepted");
    message.setJMSCorrelationID(messageId);
    return message;
  });
}
 

@JmsListener( destination = Topics.TRACKER_IMPORT_JOB_TOPIC_NAME, containerFactory = "jmsQueueListenerContainerFactory" )
public void consume( TextMessage message ) throws JMSException, JsonProcessingException
{
    String payload = message.getText();

    TrackerMessage trackerMessage = objectMapper.readValue( payload, TrackerMessage.class );
    TrackerImportParams trackerImportParams = trackerMessage.getTrackerImportParams();

    JobConfiguration jobConfiguration = new JobConfiguration(
        "",
        JobType.TRACKER_IMPORT_JOB,
        trackerImportParams.getUserId(),
        true
    );

    jobConfiguration.setUid( trackerMessage.getUid() );
    trackerImportParams.setJobConfiguration( jobConfiguration );

    TrackerImportThread trackerImportThread = trackerImportThreadFactory.getObject();
    trackerImportThread.setTrackerImportParams( trackerImportParams );

    schedulingManager.executeJob( trackerImportThread );
}
 

@JmsListener( destination = Topics.TRACKER_IMPORT_NOTIFICATION_TOPIC_NAME, containerFactory = "jmsQueueListenerContainerFactory" )
public void consume( TextMessage message ) throws JMSException, IOException
{
    TrackerSideEffectDataBundle bundle = toBundle( message );

    if ( bundle == null )
    {
        return;
    }

    JobConfiguration jobConfiguration = new JobConfiguration( "", JobType.TRACKER_IMPORT_NOTIFICATION_JOB, bundle.getAccessedBy(), true );

    bundle.setJobConfiguration( jobConfiguration );

    TrackerNotificationThread notificationThread = trackerNotificationThreadObjectFactory.getObject();

    notificationThread.setSideEffectDataBundle( bundle );

    executeJob( notificationThread );
}
 

/**
 * JmsListener注解可以声明这个方法用于接收JMS(ActiveMQ)消息队列里的消息
 * @param message
 */
@JmsListener(destination="addtvseriesevents")
public void receiveMessage(String message) {
    if(log.isTraceEnabled()) {
        log.trace("Received <" + message + ">");
    }
}
 

@JmsListener(destination = "ActiveMQ.Advisory.Producer.Queue.test", containerFactory = "topicJmsListenerContainerFactory", concurrency = "5-10")
public void advisoryProducerQueueTest(Message msg) {
    try {
        if (msg instanceof ActiveMQMessage) {
            ActiveMQMessage aMsg = (ActiveMQMessage) msg;
            if (aMsg.getDataStructure() instanceof ProducerInfo) {
                ProducerInfo producerInfo = (ProducerInfo) aMsg.getDataStructure();
                log.info("sensorDataQueue生产者信息：" + JacksonUtil.toJson(producerInfo));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}
 

@JmsListener(destination = Application.qName)
public void receiveMessage(String msg) {
  infinityWarning();

  System.out.println();
  System.out.println("========================================");
  System.out.println("Received message is: " + msg);
  System.out.println("========================================");

}
 

@JmsListener(destination = "userQueue", containerFactory = "connectionFactory")
public void receiveMessage(User receivedUser, Message message) {
    log.info(" >> Original received message: " + message);
    log.info(" >> Received user: " + receivedUser);
    confirmationSender.sendMessage(new Confirmation(id.incrementAndGet(), "User " + receivedUser.getEmail() + " received."));

}
 

@JmsListener(destination = "com.lfz.queue.mail", containerFactory = "queueFactory")
public void onQueueMessage(String username) {
    try {
        log.info("new user:{}", username);
        myMailSender.send(username);
    } catch (Exception e) {
        log.error("on queue message error", e);
    }
}
 

@JmsListener(destination = "ActiveMQ.Advisory.Consumer.Queue.test", containerFactory = "topicJmsListenerContainerFactory", concurrency = "5-10")
public void advisoryConsumerQueueTest3(Message msg) {
    try {
        if (msg instanceof ActiveMQMessage) {
            ActiveMQMessage aMsg = (ActiveMQMessage) msg;
            if (aMsg.getDataStructure() instanceof ConsumerInfo) {
                ConsumerInfo consumerInfo = (ConsumerInfo) aMsg.getDataStructure();
                log.info("sensorDataQueue消费者信息：" + JacksonUtil.toJson(consumerInfo));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}
 

@JmsListener(destination = "${solace.jms.demoConsumerQueueJndiName}", containerFactory = "cFactory")
public void processMsg(Message<?> msg) {
	StringBuffer msgAsStr = new StringBuffer("============= Received \nHeaders:");
	MessageHeaders hdrs = msg.getHeaders();
	msgAsStr.append("\nUUID: " + hdrs.getId());
	msgAsStr.append("\nTimestamp: " + hdrs.getTimestamp());
	Iterator<String> keyIter = hdrs.keySet().iterator();
	while (keyIter.hasNext()) {
		String key = keyIter.next();
		msgAsStr.append("\n" + key + ": " + hdrs.get(key));
	}
	msgAsStr.append("\nPayload: " + msg.getPayload());
	logger.info(msgAsStr.toString());
}
 

@Override
@JmsListener(destination = "seckill", containerFactory = "containerFactory")
public void subscribeMessage(String messageContent) {
  logger.info("receive message : {}", messageContent);
  EventMessageDto message = eventFormat.getFormat().deserialize(messageContent, EventMessageDto.class);
  SecKillEvent event = eventFormat.fromMessage(message);
  eventFactories.get(event.getType()).accept(event);
}
 

@JmsListener(destination = "com.lfz.topic.ws", containerFactory = "topicFactory")
public void onTopicMessage(String message) {
    try {
        wsHandler.sendAllUser(message);
    } catch (Exception e) {
        log.error("on topic message error", e);
    }
}
 

@JmsListener(destination = "account",containerFactory = "queueListenerContainerFactory")
public void receiveQueue(byte[] message) {
    LOGGER.info("=========扣减账户信息接收到Myth框架传入的信息==========");
    final Boolean success = mythMqReceiveService.processMessage(message);
    if(success){
        //消费成功，消息出队列，否则不消费
    }
}
 

/**
 * Receive queue.
 *
 * @param message the message
 */
@JmsListener(destination = "inventory", containerFactory = "queueListenerContainerFactory")
public void receiveQueue(byte[] message) {
    LOGGER.info("=========motan扣减库存接收到Myth框架传入的信息==========");
    mythMqReceiveService.processMessage(message);

}
 

@JmsListener(destination = "account",containerFactory = "queueListenerContainerFactory")
public void receiveQueue(byte[] message) {
    LOGGER.info("=========扣减账户信息接收到Myth框架传入的信息==========");
    final Boolean success = mythMqReceiveService.processMessage(message);
    if(success){
        //消费成功，消息出队列，否则不消费
    }
}
 

/**
 * Receive queue.
 *
 * @param message the message
 */
@JmsListener(destination = "account",containerFactory = "queueListenerContainerFactory")
public void receiveQueue(byte[] message) {
    LOGGER.info("=========扣减账户信息接收到Myth框架传入的信息==========");
    final Boolean success = mythMqReceiveService.processMessage(message);
    if(success){
        //消费成功，消息出队列，否则不消费
    }
}
 

/**
 * Receive queue.
 *
 * @param message the message
 */
@JmsListener(destination = "inventory", containerFactory = "queueListenerContainerFactory")
public void receiveQueue(byte[] message) {
    LOGGER.info("=========扣减库存接收到Myth框架传入的信息==========");
    mythMqReceiveService.processMessage(message);

}
 

@JmsListener(destination = "dittooutbound/Subscriptions/fromditto",
    containerFactory = "myFactory")
public void processDittoMessage(final String message) {

  final JsonValue jsonValue = JsonFactory.readFrom(message);
  final Adaptable adaptable = ProtocolFactory.jsonifiableAdaptableFromJson(jsonValue.asObject());

  final Signal<?> actual = DITTO_PROTOCOL_ADAPTER.fromAdaptable(adaptable);

  System.out.println("Got signal from Ditto: " + actual);
}
 

@JmsListener(destination = "${destination.order}",
    containerFactory = "orderDefaultJmsListenerContainerFactory")
public void receiveOrder(String order) {
  LOGGER.info("received order='{}'", order);
  jmsTemplate.convertAndSend(status1Destination, "Accepted");
  jmsTemplate.convertAndSend(status2Destination, "Accepted");
}
 

/**
 * Scenario for "should generate tests triggered by a method": client side: must have
 * a possibility to "trigger" sending of a message to the given messageFrom server
 * side: will run the method and await upon receiving message on the output
 * messageFrom. Method triggers sending a message to a source
 */
@JmsListener(destination = "input2")
public void returnBook() {
	BookReturned bookReturned = new BookReturned("foo");
	jmsTemplate.convertAndSend("output2", "{\"bookName\":\"foo\"}", message -> {
		message.setStringProperty("BOOK-NAME", bookReturned.bookName);
		return message;
	});
}