下面是一个简单的Java代码实现集群环境搭建websocket的示例：

1. 创建WebSocket服务器

在每个节点上创建WebSocket服务器，监听指定的端口，并通过负载均衡器将请求分发到不同的节点上。

public class WebSocketServer {
    private static Set<Session> sessions = new HashSet<>();

    public static void main(String[] args) throws Exception {
        Server server = new Server(new InetSocketAddress("localhost", 8080));
        server.start();

        System.out.println("WebSocket server started on port 8080");

        while (true) {
            Thread.sleep(Long.MAX_VALUE);
        }
    }

    @ServerEndpoint("/websocket")
    public static class WebSocket {
        @OnOpen
        public void onOpen(Session session) {
            sessions.add(session);
            System.out.println("New client connected: " + session.getId());
        }

        @OnClose
        public void onClose(Session session) {
            sessions.remove(session);
            System.out.println("Client disconnected: " + session.getId());
        }

        @OnMessage
        public void onMessage(String message, Session session) throws IOException {
            System.out.println("Received message: " + message);
            sendMessageToAll(message);
        }

        private void sendMessageToAll(String message) throws IOException {
            for (Session session : sessions) {
                session.getBasicRemote().sendText(message);
            }
        }
    }
}

1. 配置负载均衡器

在负载均衡器（如nginx）的配置文件中添加以下内容：

upstream websocket {
  server node1.example.com:8080;
  server node2.example.com:8080;
  server node3.example.com:8080;
}

server {
  listen 80;

  location /websocket {
    proxy_pass http://websocket;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
  }
}

此配置将请求转发至三个节点的WebSocket服务器，以实现负载均衡。

1. 配置Redis

使用redis作为缓存数据库，并在每个节点上安装redis。在WebSocket服务器的配置文件中添加以下内容：

@Bean
public RedisTemplate<String, Object> redisTemplate() {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory());
    template.setDefaultSerializer(new StringRedisSerializer());
    return template;
}

@Bean
public RedisConnectionFactory connectionFactory() {
    RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
            .master("mymaster")
            .sentinel("127.0.0.1", 26379)
            .sentinel("127.0.0.1", 26380)
            .sentinel("127.0.0.1", 26381);

    return new LettuceConnectionFactory(sentinelConfig);
}

@Bean
public ChannelTopic topic() {
    return new ChannelTopic("websocket");
}

@Bean
public MessageListenerAdapter listenerAdapter() {
    return new MessageListenerAdapter(new RedisMessageListener());
}

@Bean
public RedisMessageListenerContainer container() {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory());
    container.addMessageListener(listenerAdapter(), topic());
    return container;
}

public static class RedisMessageListener {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private SimpMessagingTemplate messagingTemplate;

    @Autowired
    private ChannelTopic topic;

    @SuppressWarnings("unchecked")
    public void onMessage(String message) {
        Map<String, Object> map = (Map<String, Object>) redisTemplate.opsForValue().get("websocket");
        if (map != null) {
            List<Session> sessions = (List<Session>) map.get("sessions");
            for (Session session : sessions) {
                messagingTemplate.convertAndSendToUser(session.getId(), "/queue/messages", message);
            }
        }
    }
}

此配置使用Redis作为缓存数据库，存储每个节点上的WebSocket连接信息。当有新消息时，将消息发送至Redis中，其他节点通过监听Redis消息来更新连接信息和推送消息。

通过以上步骤，即可实现基本的集群环境下的WebSocket应用程序。