Can't Access Atmosphere MetaBroadcaster in Spring Boot Controller

Question

I have a simple chat application set up using Spring Boot (1.3.2) and Atmosphere (2.4.2).

Here is my WebSocketConfigurer:

package com.chat.shared.websocket;

import java.util.Collections;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import org.apache.catalina.Context;
import org.apache.tomcat.websocket.server.WsSci;
import org.atmosphere.cpr.AtmosphereFramework;
import org.atmosphere.cpr.AtmosphereServlet;
import org.atmosphere.cpr.MetaBroadcaster;
import org.springframework.boot.context.embedded.ServletContextInitializer;
import org.springframework.boot.context.embedded.tomcat.TomcatContextCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.chat.privatechat.ChatChannel;

@Configuration
public class WebSocketConfigurer implements ServletContextInitializer {

  @Bean
  public TomcatEmbeddedServletContainerFactory tomcatContainerFactory() {
    TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
    factory.setTomcatContextCustomizers(Collections.singletonList(tomcatContextCustomizer()));
    return factory;
  }

  @Bean
  public TomcatContextCustomizer tomcatContextCustomizer() {
    return new TomcatContextCustomizer() {
      @Override
      public void customize(Context context) {
        context.addServletContainerInitializer(new WsSci(), null);
      }
    };
  }

  @Bean
  public AtmosphereServlet atmosphereServlet() {
    return new AtmosphereServlet();
  }

  @Bean
  public AtmosphereFramework atmosphereFramework() {
    return atmosphereServlet().framework();
  }

  @Bean
  public MetaBroadcaster metaBroadcaster() {
    AtmosphereFramework framework = atmosphereFramework();
    return framework.metaBroadcaster();
  }

  @Override
  public void onStartup(ServletContext servletContext) throws ServletException {
    configureAtmosphere(atmosphereServlet(), servletContext);
  }

  private void configureAtmosphere(AtmosphereServlet servlet, ServletContext servletContext) {
    ServletRegistration.Dynamic reg = servletContext.addServlet("atmosphereServlet", servlet);

    reg.setInitParameter("org.atmosphere.cpr.packages", ChatChannel.class.getPackage().getName());
    reg.setInitParameter("org.atmosphere.cpr.broadcasterClass", "org.atmosphere.plugin.hazelcast.HazelcastBroadcaster");
    reg.setInitParameter("org.atmosphere.cpr.broadcaster.maxProcessingThreads", "10");
    reg.setInitParameter("org.atmosphere.cpr.broadcaster.maxAsyncWriteThreads", "10");
    reg.setInitParameter("org.atmosphere.interceptor.HeartbeatInterceptor.clientHeartbeatFrequencyInSeconds", "10");
    servletContext.addListener(new org.atmosphere.cpr.SessionSupport());
    reg.addMapping("/chat/*");
    reg.setLoadOnStartup(0);
    reg.setAsyncSupported(true);
  }
}

And here is how I'm currently leveraging it in the ChatChannel:

package com.chat.privatechat;

import com.chat.privatechat.DTOs.ChatMessageDTO;
import com.chat.shared.localmessagebus.LocalMessage;
import com.chat.shared.localmessagebus.LocalMessageBus;
import org.atmosphere.config.service.Disconnect;
import org.atmosphere.config.service.Get;
import org.atmosphere.config.service.ManagedService;
import org.atmosphere.config.service.PathParam;
import org.atmosphere.config.service.Ready;
import org.atmosphere.cpr.AtmosphereResource;
import org.atmosphere.cpr.AtmosphereResourceEvent;
import org.atmosphere.cpr.AtmosphereResourceFactory;
import org.atmosphere.cpr.BroadcasterFactory;
import org.atmosphere.cpr.MetaBroadcaster;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.inject.Inject;

@ManagedService(path = "/chat/{channel: [a-zA-Z][a-zA-Z_0-9]*}")
public class ChatChannel {
  @PathParam("channel")
  private String channelUuid;

  @Inject
  private BroadcasterFactory factory;

  @Inject
  private AtmosphereResourceFactory resourceFactory;

  @Inject
  private MetaBroadcaster metaBroadcaster;

  @Get
  public void init(AtmosphereResource resource) {
    resource.getResponse().setCharacterEncoding(StandardCharsets.UTF_8.name());
  }

  @Ready
  public void onReady(final AtmosphereResource resource) {
      String userId = resource.getRequest().getHeader("userId");
      System.out.println("User " + userId + " has connected.");
  }

  @Disconnect
  public void onDisconnect(AtmosphereResourceEvent event) {
      String userId = event.getResource().getRequest().getHeader("userId");
      System.out.println("User " + userId + " has disconnected");
  }

  @org.atmosphere.config.service.Message(encoders = MessageEncoderDecoder.class, decoders = MessageEncoderDecoder.class)
  public ChatMessageDTO onMessage(ChatMessageDTO chatMessage) throws IOException {
      LocalMessageBus.manager().send(new LocalMessage<ChatMessageDTO>(chatMessage));

      return chatMessage;
  }
}

This setup works great (users in a conversation are connected to a "channel" and the messages are sent/received immediately. LocalMessageBus is a simple message bus that will eventually be replaced by a proper message broker).

Although I don't have a use case for this, I went to set up a MetaBroadcaster in my ChatController to see if I could broadcast messages from there. Unfortunately, I am not able to properly inject/reference the MetaBroadcaster as it is always null. Here's the important bits of the ChatController:

package com.chat.privatechat;

import java.util.List;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.chat.privatechat.DTOs.ChatMessageDTO;
import com.chat.privatechat.DTOs.ChatSessionInitializationDTO;
import com.chat.privatechat.DTOs.EstablishedChatSessionDTO;
import com.chat.shared.http.JSONResponseHelper;
import com.chat.user.UserService;
import com.chat.user.exceptions.IsSameUserException;
import com.chat.user.exceptions.UserNotFoundException;
import com.chat.user.strategies.UserRetrievalByIdStrategy;

@Controller
public class ChatController {
  @Autowired
  private ChatService chatService;

  @Autowired
  private BeanFactory beanFactory;

  @Autowired
  private UserService userService;

  @Inject
  private MetaBroadcaster metaBroadcaster;

  @RequestMapping(value="/api/chat/session", method=RequestMethod.PUT, produces="application/json", consumes="application/json")
  public ResponseEntity<String> establishChatSession(@RequestBody ChatSessionInitializationDTO initialChatSession) throws IsSameUserException, BeansException, UserNotFoundException { 
     ...
  }

  @RequestMapping(value="/api/chat/session/{channelUuid}", method=RequestMethod.GET, produces="application/json")
  public ResponseEntity<String> getExistingChatSessionMessages(@PathVariable("channelUuid") String channelUuid) {
    ...
  }
}

Injecting/Autowiring MetaBroadcaster nor bringing in metaBroadcaster bean from the BeanFactory work. I've searched and searched and searched without a good solution. It seems like the bean in not accessible in this Spring Controller context and I'm running out of ideas.

Thanks you for any input!

NOTE: These are the Atmosphere deps I have:

<dependency>
  <groupId>org.atmosphere</groupId>
  <artifactId>atmosphere-runtime</artifactId>
  <version>2.4.2</version>
</dependency>

<dependency>
  <groupId>org.atmosphere</groupId>
  <artifactId>atmosphere-spring</artifactId>
  <version>2.4.2</version>
</dependency>

<dependency>
  <groupId>org.webjars</groupId>
  <artifactId>atmosphere-javascript</artifactId>
  <version>2.2.3</version>
</dependency>

<dependency>
  <groupId>org.atmosphere</groupId>
  <artifactId>atmosphere-hazelcast</artifactId>
  <version>2.4.2</version>
</dependency>