JavaEE（CDI、Hibernate）后端向Javascript客户端推送消息的简便方法咨询

嘿，这个场景我刚好有过实践经验！针对你的WildFly（JavaEE+CDI+Hibernate）+AngularJS技术栈，有几个无需额外依赖、直接打包在WAR内的简便方案可以实现后端向前端推送消息，完全符合你的需求：

方案1：JavaEE WebSocket（JSR-356）—— 双向实时通信首选 #

WildFly原生支持JSR-356 WebSocket，这是实现双向实时推送最标准的JavaEE方案，不需要额外引入任何依赖，直接在WAR内编写代码即可。

后端实现（WebSocket Endpoint） #

import javax.inject.Inject;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

@ServerEndpoint("/push/messages")
public class MessagePushEndpoint {

    // 用CDI注入你的业务服务（比如和Hibernate交互的DAO）
    @Inject
    private YourBusinessService businessService;

    // 维护在线客户端会话
    private static final Set<Session> sessions = Collections.newSetFromMap(new ConcurrentHashMap<>());

    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
        // 可以在客户端连接时推送初始化消息
        sendMessageToSession(session, "已连接到推送服务");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        // 处理前端发来的消息（如果需要双向交互）
        businessService.processClientMessage(message);
    }

    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
    }

    // 向所有在线客户端推送消息的工具方法
    public static void broadcastMessage(String message) {
        sessions.forEach(session -> sendMessageToSession(session, message));
    }

    private static void sendMessageToSession(Session session, String message) {
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            // 处理发送异常，比如移除失效会话
            sessions.remove(session);
        }
    }
}

你可以在Hibernate实体的生命周期回调（比如@PostUpdate、@PostPersist）或者CDI事件触发时，调用MessagePushEndpoint.broadcastMessage()来推送消息。

前端AngularJS实现 #

封装一个WebSocket服务，在控制器里使用：

angular.module('yourApp')
.service('WebSocketService', function($rootScope) {
    var ws;

    this.connect = function() {
        // 注意路径要和后端的ServerEndpoint对应
        ws = new WebSocket('ws://' + window.location.host + '/your-war-context/push/messages');
        
        ws.onmessage = function(event) {
            // 收到消息后广播到AngularJS作用域
            $rootScope.$broadcast('wsMessageReceived', event.data);
        };

        ws.onclose = function() {
            // 断开后自动重连（可选）
            setTimeout(() => this.connect(), 5000);
        };
    };

    this.send = function(message) {
        if (ws && ws.readyState === WebSocket.OPEN) {
            ws.send(message);
        }
    };
})
.controller('YourController', function($scope, WebSocketService) {
    WebSocketService.connect();

    $scope.$on('wsMessageReceived', function(event, message) {
        // 处理后端推送的消息，比如更新页面数据
        $scope.receivedMessage = message;
        $scope.$apply(); // 因为WebSocket回调在AngularJS作用域外，需要手动触发消化周期
    });
});

方案2：Server-Sent Events（SSE）—— 单向推送更简便 #

如果你的场景只需要后端向前端单向推送（比如数据更新提醒、系统公告），SSE会比WebSocket更简单，前端不需要处理连接状态的复杂逻辑，后端用JAX-RS（WildFly自带RESTEasy）就能实现。

后端JAX-RS资源实现 #

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import org.jboss.resteasy.annotations.SseElementType;
import org.jboss.resteasy.plugins.providers.sse.Sse;
import org.jboss.resteasy.plugins.providers.sse.SseEventSink;
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

@Path("/push/sse")
public class SsePushResource {

    @Inject
    private Sse sse;

    @GET
    @Produces(MediaType.SERVER_SENT_EVENTS)
    @SseElementType(MediaType.TEXT_PLAIN)
    public void pushMessages(SseEventSink eventSink) {
        // 将事件 sink 保存到全局容器，方便后续触发推送
        SseManager.addEventSink(eventSink);
        
        // 监听sink关闭事件，清理资源
        eventSink.close().thenRun(() -> SseManager.removeEventSink(eventSink));
    }

    // 静态工具类用于管理所有连接的sink
    public static class SseManager {
        private static final Set<SseEventSink> sinks = Collections.newSetFromMap(new ConcurrentHashMap<>());
        
        public static void addEventSink(SseEventSink sink) {
            sinks.add(sink);
        }
        
        public static void removeEventSink(SseEventSink sink) {
            sinks.remove(sink);
        }
        
        public static void broadcastMessage(String message) {
            sinks.forEach(sink -> {
                if (!sink.isClosed()) {
                    sink.send(sse.newEventBuilder().data(message).build());
                }
            });
        }
    }
}

同样，你可以在Hibernate实体回调或CDI事件中调用SseManager.broadcastMessage()来推送消息。

前端AngularJS实现 #

angular.module('yourApp')
.controller('SseController', function($scope) {
    // 创建EventSource连接
    var eventSource = new EventSource('/your-war-context/push/sse');
    
    // 监听消息事件
    eventSource.onmessage = function(event) {
        $scope.$apply(() => {
            $scope.sseMessage = event.data;
            // 更新页面数据，比如刷新列表
            $scope.refreshData();
        });
    };

    // 监听连接错误
    eventSource.onerror = function() {
        eventSource.close();
        // 可选：自动重连
        setTimeout(() => new EventSource('/your-war-context/push/sse'), 5000);
    };
});

方案3：轮询（退而求其次的选择） #

如果因为某些限制不能用WebSocket或SSE，可以用AngularJS的$interval定时调用后端REST接口拉取消息。这种方式实现最简单，但实时性差，会增加服务器压力，适合对实时性要求不高的场景：

angular.module('yourApp')
.controller('PollingController', function($scope, $http, $interval) {
    // 每5秒拉取一次消息
    $interval(() => {
        $http.get('/your-war-context/api/latest-messages')
             .then(response => {
                 $scope.latestMessages = response.data;
             });
    }, 5000);
});

总结一下：如果需要双向实时交互选WebSocket，单向推送选SSE，这两个都是JavaEE和WildFly原生支持的，完全可以打包在WAR内运行，不需要额外部署任何服务；轮询只适合低实时性场景。

内容的提问来源于stack exchange，提问作者user3133542