We Keep Coding

Dispatcher has no subscribers for channel

I am trying to create a Generic eventPublisher for my microservices.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.support.MessageBuilder;
#EnableBinding(TaskEventStreams.class)
public class EventPublisher {
private final TaskEventStreams source;
#Autowired
public EventPublisher(TaskEventStreams source) {
this.source = source;
}
public void publishEvent(BaseEvent event) {
publishEvent(event, event.getTenant());
}
public void publishEvent(BaseEvent event, String key) {
source.taskEventOutput().send(
MessageBuilder
.withPayload(event)
.copyHeaders(event.getHeaders())
.setHeader("partitionKey", key)
.build());
}
}
import org.springframework.cloud.stream.annotation.Input;
import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;
public interface TaskEventStreams {
String TASK_EVENT_OUTPUT = "task-event-output";
#Output(TASK_EVENT_OUTPUT)
MessageChannel taskEventOutput();
}
Application properties
spring:
cloud:
stream:
default-binder: kafka
kafka:
binder:
brokers: localhost:9092
auto-create-topics: true
bindings:
task-event-output:
destination: tasks
group: tasks
binder: kafka
contentType: application/json
This service will only publish the events. These events then later can be consumed by other services. But when I am trying to publish the event I am getting below exception
#SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Main {
#Autowired
EventPublisher eventPublisher;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
System.out.println("Hello world!");
}
#PostConstruct
public void init() {
BaseEvent event = TaskCreatedEvent.builder().tenant("tenant").build();
eventPublisher.publishEvent(event);
}
}
Exception:
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'main': Invocation of init method failed; nested exception is org.springframework.messaging.MessageDeliveryException: Dispatcher has no subscribers for channel 'task-event-output'.; nested exception is org.springframework.integration.MessageDispatchingException: Dispatcher has no subscribers, failedMessage=GenericMessage [payload=byte[255], headers={id=06b61f95-24d8-7f35-3e57-9ae262c2ca47, partitionKey=tenant, contentType=application/json, tenant=tenant, timestamp=1675063077441}], failedMessage=GenericMessage [payload=byte[255], headers={id=06b61f95-24d8-7f35-3e57-9ae262c2ca47, partitionKey=tenant, contentType=application/json, tenant=tenant, timestamp=1675063077441}]
at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor
Is there a limitation that without consumer we cannot have producer? or am I missing something with this

#PostConstruct
public void init() {
BaseEvent event = TaskCreatedEvent.builder().tenant("tenant").build();
eventPublisher.publishEvent(event);
}
That's too early to interact with low-level resource. You really cannot send message to the broker while your application is still in a configuration phase.
See into an ApplicationRunner instead: https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.spring-application.command-line-runner

RabbitMQ connection factory not auto injecting or converting message to JSON

Im setting up the connection factory for my rabbitmq application. Ive got the beans created in the config, however for some reason the ConnectionFactory that ive passed into the RabbitTemplate doesnt seem to be creating the bean automatically as it should.
the error its saying is Could not autowire. No beans of 'ConnectionFactory' type found.
However this bean should be created automatically. It works if i create a bean of ConnectionFactory manually, but struggling to understand why it doesnt work without it.
package com.example.redistorabbit;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
#SpringBootApplication
public class RedisToRabbitApplication {
public static void main(String[] args) {
SpringApplication.run(RedisToRabbitApplication.class, args);
}
public static final String TOPIC_EXCHANGE_NAME = "covid-exchange";
public static final String QUEUE_NAME = "cases-entity";
#Bean
Queue queue(){
return new Queue(QUEUE_NAME,false);
}
#Bean
TopicExchange exchange(){
return new TopicExchange(TOPIC_EXCHANGE_NAME);
}
#Bean
Binding binding(Queue queue, TopicExchange topicExchange){
return BindingBuilder.bind(queue).to(topicExchange).with("#");
}
#Bean
public RabbitTemplate publishingRabbitTemplate(final ConnectionFactory connectionFactory) {
final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMessageConverter(jsonConverter());
rabbitTemplate.setChannelTransacted(true);
return rabbitTemplate;
}
#Bean
public Jackson2JsonMessageConverter jsonConverter() {
return new Jackson2JsonMessageConverter();
}
}
another issue i seem to have is even though i have the Jackson2JsonMessageConverter when the lisetener received and prints the message it is showing as bytes instead of a json message:
#Component
#RequiredArgsConstructor
public class Receiver {
private final CasesRepository casesRepository;
private static final Logger log = LoggerFactory.getLogger(Receiver.class);
#RabbitListener(queues = RedisToRabbitApplication.QUEUE_NAME)
public void consumeMessage(final Message message) {
log.info("received: " + message.toString());
}
}
received: (Body:'[B#1b68f46c(byte[91])'

Have you tried Injecting the Spring Object Mapper into the Jackson Message converter?
#Bean
public Jackson2JsonMessageConverter jsonConverter(ObjectMapper objectMapper) {
return new Jackson2JsonMessageConverter(objectMapper);
}

It seems the issue is with the version of spring-boot-autoconfiguration dependency, i could see the bean in the version for 2.7.3, in the JacksonAutoConfiguration class, however Intellij was still saying no bean was found. I added the following dependency:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>1.5.15.RELEASE</version>
</dependency>
and both ConnectionFactory and ObjectMapper beans have been created automatically

How to create a background job in AEM as a Cloud?

I want to create a daily background job to be executed by AEM.
I read an aem document and apache sling official site, and I thought I need two classes.
a service class that register the job to JobManager.
a consumer class that do the job.
So I tried these code, but my job was not executed.
service class
import org.apache.sling.event.jobs.JobManager;
import org.apache.sling.event.jobs.JobBuilder.ScheduleBuilder;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
#Component
public class MyJobService {
private static final Logger logger = LoggerFactory.getLogger(MyJobService.class);
#Reference
private JobManager jobManager;
public static final String JOB_TOPIC = "my/sample/jobtopic";
public void startScheduledJob() {
ScheduleBuilder scheduleBuilder = jobManager.createJob(JOB_TOPIC).schedule();
scheduleBuilder.hourly(9, 0); // execute daily at AM9:00
if (scheduleBuilder.add() == null) {
logger.error("myjobservice error");
}
}
}
job consumer class
import org.apache.sling.event.jobs.Job;
import org.apache.sling.event.jobs.consumer.JobConsumer;
import org.osgi.service.component.annotations.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
#Component(
immediate = true,
service = JobConsumer.class,
property = {
JobConsumer.PROPERTY_TOPICS + "=my/sample/jobtopic"
}
)
public class MyJobConsumer implements JobConsumer {
private static final Logger logger = LoggerFactory.getLogger(MyJobConsumer.class);
#Override
public JobResult process(Job job) {
String topic = job.getTopic();
logger.info("this message is from myjobconsumer. topic is " + topic);
return JobResult.OK;
}
}
Do I need another class or some configurations? Does My code have something wrong?

If you annotate a method with #Activate it will be called when the component starts.
#Activate
public void startScheduledJob()
I guess you want your job to run on startup.
Another option would be to let MyJobService be a servlet and call it from outside.

How to create a Spring Boot consumer for an ActiveMQ queue?

I am learning about ActiveMQ, and so far I have made a simple Spring Boot producer+consumer application (call it App1 for the purposes of this question) that communicates with a local instance of ActiveMQ and everything works as expected.
Now I am trying to run a different Spring Boot application (on the same computer but after ensuring App1 is not running) that has only a consumer (no producer), but when I start up this application, the messages in the queue (that I put using a modified App1 in which I removed the consumer portion of the application) do not get picked up. In App1, as soon as the message was published, the consumer printed out the system.out print statement, but not so in this consumer-only application. Below is my listener component class:
package com.demo.listener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
#Component
public class Consumer {
#JmsListener(destination = "testqueue")
public void consume(String message) {
System.out.println("Picked up message: " + message);
}
}
What changes would I need to make in order achieve the desired behavior?
App1 application.properties file:
spring.activemq.in-memory=false
spring.activemq.pool.enabled=false
server.port=9000
activemq.broker-url=tcp://localhost:61616
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration, org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
security.basic.enabled=false
management.security.enabled=false
App1 JmsConfig class
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.core.JmsTemplate;
#Configuration
public class JmsConfig {
#Value("${activemq.broker-url}")
private String brokerUrl;
#Bean
public Queue queue() {
return new ActiveMQQueue("testqueue");
}
#Bean
public ActiveMQConnectionFactory activeMQConnectionFactory() {
ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory();
factory.setBrokerURL(brokerUrl);
return factory;
}
#Bean
public JmsTemplate jmsTemplate() {
return new JmsTemplate(activeMQConnectionFactory());
}
}
App1 Producer class
import javax.jms.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
#RestController
#RequestMapping("/rest/publish")
public class ProducerResource {
#Autowired
JmsTemplate jmsTemplate;
#Autowired
Queue queue;
#GetMapping("/{message}")
public String publishMessage(#PathVariable("message") final String message) {
jmsTemplate.convertAndSend(queue, message);
return "Published successfully";
}
}
App1 consumer class is the same class I used in the consumer only application (listed above).

For your consumer app, you do need to add Pool connection factory & JMS message listener factory for your consumer JMStemplate to start receiving messages.
#Configuration
#EnableJms
public class ConsumerConfig {
#Value("${activemqbrokerurl}")
private String brokerUrl;
#Bean
public ActiveMQConnectionFactory activeMQConnectionFactory() {
ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory();
activeMQConnectionFactory.setBrokerURL(brokerUrl);
return activeMQConnectionFactory;
}
#Bean
public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setConnectionFactory(activeMQConnectionFactory());
factory.setConcurrency("{#setDesiredConcurrency}");
return factory;
}
}
Spring's MessagListenerContainer should be used for message consumption. This provides all the power of MDBs - efficient JMS consumption and pooling of the message listeners - but without requiring a full EJB container.You can use the activemq-pool org.apache.activemq.pool.PooledConnectionFactory for efficient pooling of the connections and sessions for your collection of consumers, or you can use the Spring JMS org.springframework.jms.connection.CachingConnectionFactory to achieve the same effect.
You can read more about it here

Why doesn't integration flow subscribe to the from channel?

To me, this appears to be just about the simplest possible spring integration example. I'm trying to learn from the si4demo. But when I run it, I get this exception:
Exception in thread "main"
org.springframework.messaging.MessageDeliveryException: Dispatcher has
no subscribers for channel 'application.inbox'.; nested exception is
org.springframework.integration.MessageDispatchingException:
Dispatcher has no subscribers
Where am I going wrong? Doesn't the defined flow create a subscription to the inbox channel?
import org.springframework.boot.SpringApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.messaging.MessageChannel;
#Configuration
#ComponentScan
#IntegrationComponentScan
public class App {
public static void main(String[] args) {
try (ConfigurableApplicationContext ctx = SpringApplication.run(App.class, args)) {
final Gateway gateway = ctx.getBean(Gateway.class);
final String rs = gateway.send("hullo");
System.out.println(rs);
}
}
private static final String INBOX = "inbox";
#MessagingGateway(defaultRequestChannel = INBOX)
public interface Gateway {
String send(String msg);
}
#Bean
public IntegrationFlow flow() {
return IntegrationFlows.from(INBOX)
.transform(p -> "world")
.get();
}
#Bean(name = INBOX)
public MessageChannel inbox() {
return new DirectChannel();
}
}

Looks like you have missed the main player - #EnableIntegraion:
Starting with version 4.0, the #EnableIntegration annotation has been introduced, to allow the registration of Spring Integration infrastructure beans (see JavaDocs). This annotation is required when only Java & Annotation configuration is used, e.g. with Spring Boot and/or Spring Integration Messaging Annotation support and Spring Integration Java DSL with no XML integration configuration.
http://docs.spring.io/spring-integration/docs/4.3.0.BUILD-SNAPSHOT/reference/html/overview.html#configuration-enable-integration