Java 绝地武士只会出错（P）订阅/（P）取消订阅/PING/退出在此上下文中允许

突然，当我试图发送消息时，我发现了这个错误。我不知道为什么。这已经很好地工作了一段时间，但当我试图发送消息时，它就停止工作了。有时，即使抛出错误，它也会发送消息，但在侦听器中，消息为null。我不知道为什么会这样

redis.clients.jedis.exceptions.JedisDataException: ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / PING / QUIT allowed in this context
    at redis.clients.jedis.Protocol.processError(Protocol.java:127) ~[?:?]
    at redis.clients.jedis.Protocol.process(Protocol.java:161) ~[?:?]
    at redis.clients.jedis.Protocol.read(Protocol.java:215) ~[?:?]
    at redis.clients.jedis.Connection.readProtocolWithCheckingBroken(Connection.java:340) ~[?:?]
    at redis.clients.jedis.Connection.getIntegerReply(Connection.java:265) ~[?:?]
    at redis.clients.jedis.Jedis.publish(Jedis.java:2690) ~[?:?]
    at com.cursehq.core.communicator.CoreCommunicator.sendMessage(CoreCommunicator.java:117) ~[?:?]

这是communicator类 包com.cursehq.core.communicator

import com.cursehq.core.Core;
import com.cursehq.core.api.communicator.Communicator;
import com.cursehq.core.api.communicator.listener.CommunicatorListener;
import com.cursehq.core.communicator.listeners.*;
import com.cursehq.core.communicator.message.Message;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.*;

import java.util.HashSet;
import java.util.Set;

public class CoreCommunicator implements Communicator {
    private final Set<CommunicatorListener> listeners = new HashSet<>();
    private final Gson gson = new Gson();
    private JedisPool pool;
    private String server;

    public boolean load() {
        String host = Core.getCore().getConfig().getString("redis.host");
        int port = Core.getCore().getConfig().getInt("redis.port");
        String password = Core.getCore().getConfig().getString("redis.password");
        server = Core.getCore().getConfig().getString("redis.server");

        try {
            pool = new JedisPool(new GenericObjectPoolConfig(), host, port, 20000, password);
            loadServer();
            loadListener();
            loadListeners();
            Core.log("&7Successfully connected to the redis communicator!");
        } catch (Exception e) {
            return false;
        }
        return true;
    }
    public void unload() {
        try (Jedis jedis = pool.getResource()) {
            String json = jedis.get("servers");
            Set<String> set = gson.fromJson(json, new TypeToken<Set<String>>(){}.getType());
            set.remove(server.toLowerCase());
            jedis.set("servers", gson.toJson(set));
            jedis.persist("servers");
        }
    }

    private void loadServer() {
        try (Jedis jedis = pool.getResource()) {
            Set<String> set;
            String json = jedis.get("servers");
            if (json == null)
                set = new HashSet<>();
            else
                set = gson.fromJson(json, new TypeToken<Set<String>>(){}.getType());

            set.add(server.toLowerCase());
            jedis.set("servers", gson.toJson(set));
            jedis.persist("servers");
        }
    }
    private void loadListener() {
        new Thread(() -> {
            try (Jedis jedis = pool.getResource()) {
                jedis.subscribe(new JedisPubSub() {
                    public void onMessage(String channel, String msg1) {
                        Message message = gson.fromJson(msg1, Message.class);
                        String type = message.getType();
                        String msg = message.getMessage();
                        String from = Core.getCore().getUtils().capitalize(message.getFrom());

                        listeners.stream()
                                .filter(listener -> listener.getType().equalsIgnoreCase(type))
                                .forEach(listener -> listener.onMessageReceive(msg, from));
                    }
                }, "all", server.toLowerCase());
            }
        }).start();
    }
    private void loadListeners() {
        new AnnouncementListener();
        new CommandListener();
        new RankUpdateListener();
        new ServerStatusListener();
        new StaffChatListener();
    }

    public JedisPool getPool() {
        return pool;
    }
    public String getServerName() {
        return server;
    }
    public String getServers() {
        try (Jedis jedis = pool.getResource()) {
            String json = jedis.get("servers");
            Set<String> servers = gson.fromJson(json, new TypeToken<Set<String>>(){}.getType());
            return String.join(", ", servers);
        }
    }
    public boolean serverExists(String string) {
        try (Jedis jedis = pool.getResource()) {
            Set<String> servers = gson.fromJson(jedis.get("servers"), new TypeToken<Set<String>>(){}.getType());
            return servers.contains(string.toLowerCase());
        }
    }

    public void sendMessage(String type, String msg) {
        sendMessage(type, msg, "all");
    }
    public void sendMessage(String type, String msg, String to) {
        try (Jedis jedis = pool.getResource()) {
            Message message = new Message(type, msg);
            String json = gson.toJson(message);
            jedis.publish(to.toLowerCase(), json);
        }
    }

    public Set<CommunicatorListener> getListeners() {
        return listeners;
    }
}

import com.cursehq.core.core；
导入com.cursehq.core.api.communicator.communicator；
导入com.cursehq.core.api.communicator.listener.communicator或listener；
导入com.cursehq.core.communicator.listeners.*；
导入com.cursehq.core.communicator.message.message；
导入com.google.gson.gson；
导入com.google.gson.reflect.TypeToken；
导入org.apache.commons.pool2.impl.GenericObjectPoolConfig；
导入redis.clients.jedis.*；
导入java.util.HashSet；
导入java.util.Set；
公共类CoreCommunicator实现Communicator{
私有最终集侦听器=新HashSet（）；
私有最终Gson Gson=新Gson（）；
私人游泳池；
私有字符串服务器；
公共布尔加载（）{
String host=Core.getCore（）.getConfig（）.getString（“redis.host”）；
int port=Core.getCore（）.getConfig（）.getInt（“redis.port”）；
字符串密码=Core.getCore（）.getConfig（）.getString（“redis.password”）；
server=Core.getCore（）.getConfig（）.getString（“redis.server”）；
试一试{
pool=new-spool（新的GenericObjectPoolConfig（），主机，端口，20000，密码）；
loadServer（）；
loadListener（）；
loadListeners（）；
log（&7成功连接到redis通信器！”）；
}捕获（例外e）{
返回false；
}
返回true；
}
公众假期{
试试看（绝地武士=pool.getResource（））{
字符串json=jedis.get（“服务器”）；
Set=gson.fromJson（json，newTypeToken（）{}.getType（））；
set.remove（server.toLowerCase（））；
set（“服务器”，gson.toJson（set））；
绝地武士。坚持（“服务器”）；
}
}
私有void loadServer（）{
试试看（绝地武士=pool.getResource（））{
集合；
字符串json=jedis.get（“服务器”）；
if（json==null）
set=新的HashSet（）；
其他的
set=gson.fromJson（json，newTypeToken（）{}.getType（））；
set.add（server.toLowerCase（））；
set（“服务器”，gson.toJson（set））；
绝地武士。坚持（“服务器”）；
}
}
私有void loadListener（）{
新线程（（）->{
试试看（绝地武士=pool.getResource（））{
绝地武士订阅{
消息上的公共void（字符串通道，字符串msg1）{
Message Message=gson.fromJson（msg1，Message.class）；
字符串类型=message.getType（）；
字符串msg=message.getMessage（）；
字符串from=Core.getCore（）.getUtils（）.capitalize（message.getFrom（））；
listeners.stream（）
.filter（侦听器->侦听器.getType（）.equalsIgnoreCase（类型））
.forEach（listener->listener.onMessageReceive（msg，from））；
}
}，“全部”，server.toLowerCase（））；
}
}).start（）；
}
私有void加载侦听器（）{
new AnnouncementListener（）；
新命令侦听器（）；
新的RankupDataListener（）；
新建ServerStatusListener（）；
新StaffChatListener（）；
}
公共池{
回流池；
}
公共字符串getServerName（）{
返回服务器；
}
公共字符串getServers（）{
试试看（绝地武士=pool.getResource（））{
字符串json=jedis.get（“服务器”）；
Set servers=gson.fromJson（json，new-TypeToken（）{}.getType（））；
返回字符串。连接（“，”，服务器）；
}
}
公共布尔服务器存在（字符串）{
试试看（绝地武士=pool.getResource（））{
Set servers=gson.fromJson（jedis.get（“servers”），new-TypeToken（）{}.getType（））；
返回servers.contains（string.toLowerCase（））；
}
}
公共无效发送消息（字符串类型，字符串消息）{
发送消息（类型，消息，“全部”）；
}
public void sendMessage（字符串类型、字符串消息、字符串收件人）{
试试看（绝地武士=pool.getResource（））{
消息消息=新消息（类型，消息）；
字符串json=gson.toJson（消息）；
publish（to.toLowerCase（），json）；
}
}
公共集getListeners（）{
返回听众；
}
}

如果有人知道可能导致此错误的原因，请分享