Java 如何在应用程序启动时只启动一次参与者，而不在Play Framework中使用全局对象？

我一直听说全局对象将被弃用，在全局类的.onStart（）中放入一些代码不是一个好的做法。如果是，有什么替代方案

很多人说要使用全局对象，但这也是4年前的事了

我目前有以下需要。我在游戏中编写了一个应用程序，它使用消息队列中的消息（在我的例子中，就是NSQ（目前没有驼峰绑定到它））并将这些消息发送到正在侦听它的一组Web套接字客户端。因此，我希望消费者对每个主题初始化一次，并永远开始运行，直到应用程序本身终止。发生的情况是，当我向一个主题发送10条消息时，我只能看到5条消息，但当我在单独的普通旧Java应用程序中运行下面代码中相同的方法“startNSQConsumer（）”时，我可以看到所有10条消息。所以很明显，这与比赛有关，我不确定到底发生了什么。有什么想法吗

public class Global extends GlobalSettings {

    private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadScheduledExecutor();

    @Override
    public void onStart(Application application) {
        EXECUTOR_SERVICE.submit(() -> {
            startNSQConsumer();
        });
        super.onStart(application);
    }

    @Override
    public void onStop(Application application) {
        EXECUTOR_SERVICE.shutdown();
        super.onStop(application);
    }

    private void startNSQConsumer() {
        NSQLookup lookup = new DefaultNSQLookup();
        Configuration config = Play.application().configuration();
        List<String> topics = config.getStringList("TOPICS");
        String nsqlookupdIP = config.getString("NSQLOOKUPD_IP");
        int nsqlookupdPort = Integer.parseInt(config.getString("NSQLOOKUPD_PORT"));
        lookup.addLookupAddress(nsqlookupdIP, nsqlookupdPort);
        Logger.info("Using nsqlookup at " + nsqlookupdIP + ":" + nsqlookupdPort);
        topics.forEach((topic) -> {
            NSQConsumer consumer = new NSQConsumer(lookup, topic, topic + "_channel", (message) -> { // messages here will come from external system running on some other node
                String receivedMessage = new String(message.getMessage());
                //Logger.info(receivedMessage); // When I enable or disable this I only see 50% of the messages.
                EventBusManager.getEventBus().publish(new MsgEnvelope(topic, receivedMessage)); // broadcast message to all Actors listening on a particular topic
                message.finished();
            }, new NSQConfig(), new NSQErrorCallback() {
                @Override
                public void error(NSQException x) {
                    Logger.error("Cause: " + x.getCause() + ", Message: " + x.getMessage());
                }
            });
            consumer.start();
        });
    }
}

公共类全局扩展全局设置{
private static final EXECUTOR SERVICE EXECUTOR_SERVICE=Executors.newSingleThreadScheduledExecutor（）；
@凌驾
公共void onStart（应用程序）{
执行人服务。提交（（）->{
startNSQConsumer（）；
});
super.onStart（应用程序）；
}
@凌驾
顶部公共无效（应用程序）{
EXECUTOR_SERVICE.shutdown（）；
超级桌面（应用程序）；
}
私有void startNSQConsumer（）{
NSQLookup=新的默认NSQLookup（）；
配置配置=Play.application（）.Configuration（）；
List topics=config.getStringList（“主题”）；
字符串nsqlookupdIP=config.getString（“NSQLOOKUPD_IP”）；
int nsqlookupdPort=Integer.parseInt（config.getString（“NSQLOOKUPD_PORT”）；
addLookupAddress（NSQlookupIP、NSQlookupPort）；
Logger.info（“在“+nsqlookupdpip+”：“+nsqlookupdpport”使用nsqlookup）；
topics.forEach（（主题）->{
NSQConsumer consumer=新的NSQConsumer（查找、主题、主题+“_channel”，（消息）->{//此处的消息将来自其他节点上运行的外部系统
String receivedMessage=新字符串（message.getMessage（））；
//Logger.info（receivedMessage）；//启用或禁用此选项时，我只看到50%的消息。
EventBusManager.getEventBus（）.publish（新MSGEnDevelope（主题，receivedMessage））；//向收听特定主题的所有参与者广播消息
message.finished（）；
}，新的NSQConfig（），新的NSQErrorCallback（）{
@凌驾
公共无效错误（NSQException x）{
Logger.error（“原因：+x.getCause（）+”，消息：+x.getMessage（））；
}
});
consumer.start（）；
});
}
}

您有两个问题，我将首先回答，然后您可以重构代码，使其在没有

Global

的情况下运行，并查看问题是否仍然存在。如果是这样，那么再提出一个问题

时间表

在Playframework中，处理计划任务的最佳方法是Akka actors和Akka scheduler:

您需要将您的代码（不包括执行器服务，仅限于有效的部分）放入actor中：

@Singleton
public class NSQRunner extends UntypedActor{    
    public static final String name = "NSQRunner";

    ...

    @Override
    public void onReceive(Object msg) throws Throwable {
        if(msg instanceof NSQRunnerProtocol.StartConsumer){
            startNSQConsumer();
        } else {
            unhandled(msg);
        }

    }

    private void startNSQConsumer() {
        ...
    }
}

您可以将此参与者视为来自

Executors.newSingleThreadScheduledExecutor（）

的线程。它将在收到通知他执行此操作的消息时执行此操作-

NSQRunnerProtocol.StartConsumer

。以下是协议类：

public class NSQRunnerProtocol {
    /**
     * Start the NSQ consumer.
     *
     */
    public static class StartConsumer{}
}

现在您需要在应用程序启动时运行它

此处是调度程序任务，它将在启动后1秒后运行您的actor：

@Singleton
public class Scheduler {

    @Inject
    public Scheduler(
            final ActorSystem system, 
            final Configuration configuration, 
            @Named(NSQRunner.name) ActorRef nsqRunner) {

        system.scheduler().scheduleOnce(
                Duration.create(1, TimeUnit.SECONDS),
                nsqRunner, 
                new NSQRunnerProtocol.StartConsumer(), 
                system.dispatcher(),
                null);        
    }
}

现在您需要在应用程序中注册actor和scheduler。Play framework为此提供了模块系统，因此您需要创建一个模块类：

package my.nsq

...

public class Module extends AbstractModule implements AkkaGuiceSupport {

    @Override
    protected void configure() {
        // Bind actors.
        bindActor(NSQRunner.class, NSQRunner.name);

        // Bind scheduler, it will run on the start of application.
        bind(Scheduler.class).asEagerSingleton();
    }
}

并将其注册到

conf/application.conf

：

play.modules {
  ...
  enabled += my.nsq.Module
}

停止时

在这种情况下，如果您需要在应用程序上运行

以下是数据库访问单例的示例：

@Singleton
public class Couchbase {
    private static ALogger logger = Logger.of(Couchbase.class);

    private final Cluster cluster;
    private final Bucket bucket;

    @Inject
    public Couchbase(ApplicationLifecycle lifecycle, Configuration configuration) {
        // Read the database configuration from the setting.
        final String clusterName = configuration.getString("couchbase.cluster");
        final String bucketName = configuration.getString("couchbase.bucket.name");
        final String bucketPassword = configuration.getString("couchbase.bucket.password");

        final CouchbaseEnvironment env = DefaultCouchbaseEnvironment
                .builder()
                .queryEndpoints(1)
                .autoreleaseAfter(50000)
                .queryTimeout(20000)
                .retryStrategy(FailFastRetryStrategy.INSTANCE)
                .reconnectDelay(Delay.fixed(5, TimeUnit.SECONDS))
                .build();

        logger.debug(
                "Connect to the couche: cluster \"{}\", bucket: \"{}\"", 
                clusterName, 
                bucketName);

        // Connect.
        cluster = CouchbaseCluster.create(env, clusterName);
        bucket = cluster.openBucket(bucketName, bucketPassword);

        // Create a default index.
        bucket.bucketManager().createN1qlPrimaryIndex(true, false);

        // Special operations on the application shutdown.
        lifecycle.addStopHook(() -> {

            // Close the connection on application shutdown.
            env.shutdown();
            cluster.disconnect();

            // Couchbase close the connection synchronously 
            // so we need just return an empty CompletableFuture.
            return CompletableFuture.completedFuture(null);
        });        
    }

    /**
     * @return  the application bucket
     */
    public Bucket getBucket() {
        return bucket;
    }
}

您可以在
模块中绑定此对象
：

bind(Couchbase.class).asEagerSingleton();

然后您可以将其注入，即使是在您的演员中：

public class NSQRunner ...

    @Inject
    public NSQRunner(Couchbase couchbase){
        ...
    } 
}

你可以在singelton做你所有的事情，比如
Couchbase
，这是可能的，但我认为演员更好
 发誓。。非常感谢你！1） 没有DI框架我能做到吗？2） 因为你只安排了一次演员死后发生的事情。它会再安排一次吗？1）仅当不推荐的
Global
在您的播放版本中仍然有效时。否则，您仍然需要注入
ApplicationLifecycle
。2） 这取决于死亡的原因：在我的例子中，我想不出它会死亡的任何原因（即使在网络故障期间，消费者也不应该死亡。它应该停止处理消息）。我问这个问题的原因是，消费者部分对我的应用程序来说是最重要的，如果它停止了我的应用程序，那么我的应用程序就毫无用处了，所以我只是想确定一下。最后，我可以看到您正在使用Guice。就参与者而言，这是最好的DI框架吗？哪一个DI框架最适合参与者？最后有什么建议吗？Guice是剧本2.5的默认版本；我没有问题。您可以在
application.conf
中为参与者指定自己的策略。我从来没有这样做过，我只是创建一些简单的“父”代理，然后创建一组子代理，这样我就可以在该根代理中定义监督策略，并在子代理的所有生命周期中进行操作。您创建的NSQRunner代理的父代是系统本身吗？NSQRunner本身不创建/生成chi