Java 大气框架：广播公司多次广播消息

我目前正在基于以下示例开发一个简单的多聊天室：

我的开发环境：

• Tomee Plus 1.7.2服务器
• 大气运行时版本2.4.0
• 大气cdi版本2.4.0
• JavaEE1.7
• 使用长轮询协议

在解释我的问题之前，这里是我实现的聊天室的全局机制：

用户A已连接到“chat/all”套接字。此套接字允许 发送或接收他与对话者之间的任何通知

用户A从第一个web应用发出聊天请求并等待 （弹出微调器）来自用户B的响应

用户B还连接到“chat/all”套接字。用户B检查 每次，从第二个web应用程序，如果有新的聊天请求 （来自数据库的SQL请求）。如果他发现新的请求，他可以或 我不接受这个请求

用户B接受用户A的聊天请求。此时，通过 套接字“chat/all”，用户B推送一条消息，表明他接受了此消息 要求之后，用户B连接到第二个套接字 “聊天室/1”（特定聊天室的随机id）。他正在等 （类似用户B的弹出微调器）供用户A连接到同一个微调器 插座

用户A收到此消息并连接到“chat/1”套接字。 用户A现在从服务器连接到此聊天室。 此聊天室中有两个用户，我向他们广播消息 只有用户B通知用户A已连接并关闭弹出窗口 旋转器

当我只为一个资源广播消息时，我没有问题。但当我为两个用户广播消息时，会多次调用“onMessage”方法

以下是我关于管理聊天室的代码：

@ManagedService(path = "/chat/{id_room}")
public final class ChatRoom {

 //many static final private attribute

 private static final Logger logger = LoggerFactory.getLogger(Chat.class);

 @PathParam("id_room")
 private String idChatRoom;

 private final static String CHAT = "/chat/";

 private final HashMap<Integer, List<String>> users = new HashMap<Integer, List<String>>();

 private Universe universe;

 private BroadcasterFactory broadcasterFactory = Universe.broadcasterFactory();

 private AtmosphereResourceFactory resourceFactory = Universe.resourceFactory();    

 private ChatMessageEncoderDecoder chatEncodeDecode = new ChatMessageEncoderDecoder();

@Message(encoders = { ChatMessageEncoderDecoder.class }, decoders = { ChatMessageEncoderDecoder.class })
 public final void onMessage(AtmosphereResource r, final ChatMessage message) throws UnsupportedEncodingException {
    Integer chatRoomId = !NOTIFICATION_SOCKET_ALL.equals(idChatRoom) == true ? Integer.parseInt(idChatRoom) : 0;
    [...]
    if(...) {
        [...]
    }
    else {
        roomsList.add(idChatRoom);
        boolean messageEmpty = "".equals(message.getMessage());
        boolean chatConnectedWithTwoUsers = users.get(chatRoomId).size() > 1;
        boolean chatConnectedWithOneUser = users.get(chatRoomId).size() == 1;
            if(chatConnectedWithTwoUsers && MESSAGE_EVENT.equals(message.getEvent())) { //communication between two users to the chat room id
                Users user = CDIUtil.getBean(RechercheUserService.class).getUserChat(message.getMail());
                if(user != null){
                    try {
                        List<String> listUsersFromRoom = users.get(chatRoomId);
                        message.setUsers(listUsersFromRoom);
                        message.setEvent(MESSAGE_EVENT);
                        logger.info("{} a envoyé le message {}", message.getAuthor(), message.getMessage());

                        String messageToSend = chatEncodeDecode.encode(message);
                        broadcasterFactory.lookup(CHAT + idChatRoom).broadcast(messageToSend);

                        String messageUtf8 = new String(message.getMessage().getBytes(), "UTF-8");
                        CDIUtil.getBean(MessageRoomsService.class).createMessageContents(idChatRoom, user, messageUtf8);
                    } catch (IMException e) {
                        message.setEvent(MESSAGE_NOT_REGISTER_EVENT);
                        logger.error("Impossible d'enregistrer le message de l'utilisateur");
                    }
                }
                else{
                    message.setEvent(USER_NOT_EXIST_EVENT);
                    logger.error("Utilisateur Inconnu");
                }
            }
            else if(chatConnectedWithOneUser) { //two users connected to the chat room id
                users.get(chatRoomId).add(r.uuid()); 
                logger.info("L'utilisateur {} a rejoint le chat {}", r.uuid(), idChatRoom);

                AtmosphereResource resource = resourceFactory.find(users.get(chatRoomId).get(0)); //get the first user connected to the chat room

                List<String> listUsersFromRoom = users.get(chatRoomId);
                message.setUsers(listUsersFromRoom);
                message.setEvent(CHAT_COMPLETE_EVENT);

                String messageToSend = chatEncodeDecode.encode(message);
                broadcasterFactory.lookup(CHAT + idChatRoom).broadcast(messageToSend, resource);
            }
        }
   }
}

@ManagedService（path=“/chat/{id\u room}”）
公开期末班聊天室{
//许多静态的最终私有属性
私有静态最终记录器Logger=LoggerFactory.getLogger（Chat.class）；
@PathParam（“id_房间”）
私人聊天室；
私有最终静态字符串CHAT=“/CHAT/”；
private final HashMap users=new HashMap（）；
私人宇宙；
私有广播工厂广播工厂=宇宙。广播工厂（）；
私有AtmosphereSourceFactory resourceFactory=Universe.resourceFactory（）；
私有ChatMessageEncoderDecoder chatEncodeDecode=新ChatMessageEncoderDecoder（）；
@消息（编码器={ChatMessageEncoderDecoder.class}，解码器={ChatMessageEncoderDecoder.class}）
public final void onMessage（AtmosphereResource r，final ChatMessage消息）引发不支持的DencodingException{
Integer聊天室ID=！NOTIFICATION_SOCKET_ALL.equals（idChatRoom）==true？Integer.parseInt（idChatRoom）：0；
[...]
如果（…）{
[...]
}
否则{
roomsList.add（idChatRoom）；
布尔messageEmpty=“”.equals（message.getMessage（））；
boolean chatConnectedWithTwoUsers=users.get（chatRoomId）.size（）>1；
boolean chatConnectedWithOneUser=users.get（聊天室ID）.size（）=1；
if（chatconnectedwithtwoousers&&MESSAGE_EVENT.equals（MESSAGE.getEvent（））{//两个用户之间的通信到聊天室id
Users user=CDIUtil.getBean（RechercheUserService.class）.getUserChat（message.getMail（））；
如果（用户！=null）{
试一试{
List listUsersFromRoom=users.get（聊天室ID）；
message.setUsers（listUsersFromRoom）；
message.setEvent（message_事件）；
logger.info（“{}a emissionéle message{}”，message.getAuthor（），message.getMessage（））；
字符串messageToSend=chatcodecode.encode（消息）；
广播工厂。查找（聊天室+聊天室）。广播（messageToSend）；
String messageUtf8=新字符串（message.getMessage（）.getBytes（），“UTF-8”）；
getBean（MessageRoomsService.class）.createMessageContents（idChatRoom，用户，messageUtf8）；
}捕获（IMException e）{
message.setEvent（message\u NOT\u REGISTER\u事件）；
记录器错误（“不可能记录使用信息”）；
}
}
否则{
message.setEvent（用户\不\存在\事件）；
记录程序错误（“利用数据”）；
}
}
else if（chatConnectedWithOneUser）{//两个用户连接到聊天室id
get（chatRoomId）.add（r.uuid（））；
logger.info（“L'usilisateur{}a rejoint le chat{}”，r.uuid（），idChatRoom）；
AtmosphereResource=resourceFactory.find（users.get（chatRoomId）.get（0））；//获取连接到聊天室的第一个用户
List listUsersFromRoom=users.get（聊天室ID）；
message.setUsers（listUsersFromRoom）；
message.setEvent（聊天完成事件）；
字符串messageToSend=chatcodecode.encode（消息）；
广播工厂。查找（聊天室+聊天室）。广播（messageToSend，resource）；
}
}
}
}

因此，当广播完成时，在用户界面上显示3条消息。例如，用户A发送消息“您好，我能为您做些什么？”时，用户B会看到此消息3次

我认为有三条消息，因为两个套接字上有三个资源处于活动状态。实际上，第一个套接字“chat/all”对于一个资源（用户B）始终处于活动状态，第二个套接字“chat/1”对于两个资源（用户A和用户B）始终处于活动状态。有三种资源

---

有没有人已经面临这个问题？或者有人知道如何修复它吗

我也有同样的问题..我已决定阅读此链接：

我已经在我的大气中向web.xml添加了这个init参数

<init-param>
   <param-name>org.atmosphere.cpr.AtmosphereInterceptor</param-name>
   <param-value>org.atmosphere.client.TrackMessageSizeInterceptor</param-value>
</init-param>

var request = { url: document.location.toString() + 'chat',
                contentType : "application/json",
                logLevel : 'debug',
                transport : 'long-polling' ,
                trackMessageLength : true,
                fallbackTransport: 'long-polling'};