Cometd Oort集群-弹簧配置

Question

我正在尝试在我们的Comet应用程序中启用Oort和多播，下面是这示例。我现在就需要奥特。不是塞蒂那部分。但奥尔特似乎不起作用。我已经启用了cometd调试，并且没有看到Oort正在初始化。

我还通过在本地(不同端口上)运行两个Oort节点实例进行了测试，例如A和B。如果客户端连接到节点A，我将在/user/*信道上发布来自节点A的消息，然后客户端接收消息。但是如果我发布来自节点B的消息，客户端就什么也得不到。

弹簧配置：

import org.cometd.annotation.ServerAnnotationProcessor;
import org.cometd.bayeux.server.BayeuxServer;
import org.cometd.oort.Oort;
import org.cometd.oort.OortMulticastConfigServlet;
import org.cometd.oort.OortMulticastConfigurer;
import org.cometd.server.BayeuxServerImpl;
import org.cometd.server.transport.AsyncJSONTransport;
import org.cometd.server.transport.JSONTransport;
import org.cometd.websocket.server.WebSocketTransport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ServletContextAware;

import javax.annotation.PostConstruct;
import javax.servlet.ServletContext;

@Configuration
public class BayeuxInitializer implements DestructionAwareBeanPostProcessor, ServletContextAware {

    private ServerAnnotationProcessor processor;
    private ServletContext context;

    @PostConstruct
    private void init() {
        BayeuxServer bayeuxServer = bayeuxServer();
        this.processor = new ServerAnnotationProcessor(bayeuxServer);
        Oort oort = oort();
        oort.observeChannel("/user/*");
    }

    public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
        processor.processDependencies(bean);
        processor.processConfigurations(bean);
        processor.processCallbacks(bean);
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String name) throws BeansException {
        return bean;
    }

    public void postProcessBeforeDestruction(Object bean, String name) throws BeansException {
        processor.deprocessCallbacks(bean);
    }


    @Bean(initMethod = "start", destroyMethod = "stop")
    public BayeuxServer bayeuxServer() {
        BayeuxServerImpl bean = new BayeuxServerImpl();
        bean.setTransports(new WebSocketTransport(bean), new JSONTransport(bean), new AsyncJSONTransport(bean));
        bean.setOption("timeout", 60000);
        bean.setOption("ws.timeout", 60000);
        bean.setOption("maxSessionsPerBrowser", 20);
        bean.setOption(ServletContext.class.getName(), context);
        bean.setOption("cometdURLMapping", "/,/svc");
        context.setAttribute(BayeuxServer.ATTRIBUTE, bean);
        return bean;
    }

    @Bean(initMethod = "start", destroyMethod = "stop")
    public Oort oort() {
        Oort oort = new Oort(bayeuxServer(), "http://localhost:8094/comet/svc");
        context.setAttribute(Oort.OORT_ATTRIBUTE, oort);
        return oort;
    }

    @Override
    public void setServletContext(ServletContext servletContext) {
        this.context = servletContext;
    }
}

web.xml：

    <servlet>
        <servlet-name>cometd</servlet-name>
        <servlet-class>org.cometd.server.CometDServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>cometd</servlet-name>
        <url-pattern>/svc/*</url-pattern>
    </servlet-mapping>

如果我在web.xml中初始化它，Oort似乎正在工作，如下所示：

    <servlet>
        <servlet-name>cometd</servlet-name>
        <servlet-class>org.cometd.server.CometDServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>cometd</servlet-name>
        <url-pattern>/svc/*</url-pattern>
    </servlet-mapping>


    <servlet>
        <servlet-name>oort</servlet-name>
        <servlet-class>org.cometd.oort.OortMulticastConfigServlet</servlet-class>
        <init-param>
            <param-name>oort.url</param-name>
            <param-value>http://localhost:8094/comet/svc</param-value>
        </init-param>
        <init-param>
            <param-name>oort.channels</param-name>
            <param-value>/user/*</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>

但是，根据文档，如果BayeuxServer是在Spring中初始化的，那么Oort应该在Spring中初始化。所以我的问题是：

1. 我的Oort Spring配置有什么问题吗？
2. 考虑到Oort为我提供了web.xml初始化，那么这样做有什么问题(将BayeuxServer配置保存在Spring本身中)吗？
3. 示例这里只是初始化Oort对象。彗星如何知道它的多播还是静态？

cometd版本: 3.0.10

码头版本: 9.3.11

任何帮助都很感激！

Answer 1

当您通过Spring (或其他嵌入式代码)创建Oort对象时，您已经创建了一个节点，但它没有链接到其他Oort节点。

在您的代码中，您调用：

Oort oort = oort();
oort.observeChannel("/user/*");

这将创建节点，将其配置为观察来自其他节点的通道/user/*上的消息，但不将其与其他节点连接。

在链接的示例中，有一个缺失的部分，它调用：

oort.observeComet("http://cloud.cometd.org/cometd");

该调用在示例中被注释掉，因为作为一个示例，它不知道其他节点的确切URI，因此示例使用http://cloud.cometd.org/cometd，但是URI没有指向现有节点--这就是注释掉的原因。

现在，由于您希望使用多播，所以链接的示例建议使用OortMulticastConfigurer。

OortMulticastConfigurer是您在web.xml中成功使用的OortMulticastConfigServlet正在使用的东西。

让我们看看OortMulticastConfigServlet是如何使用OortMulticastConfigurer 这里的。

如您所见，OortMulticastConfigurer是创建、配置和启动的。

如果保留默认值，则最小代码为：

configurer = new OortMulticastConfigurer(oort);
configurer.start();

将这2行添加到您的BayeuxInitializer.init()方法中，您应该就可以了。