要按id将RabbitMQ的消息分组以同步处理，可以使用RabbitMQ的消息确认机制来实现。下面是一个示例代码，展示了如何使用RabbitMQ的Java客户端库来实现分组处理：

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class RabbitMQGroupingExample {
    private static final String EXCHANGE_NAME = "message_exchange";
    private static final String QUEUE_NAME = "message_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接和通道
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明交换机和队列
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 设置消息处理器
        Map messageHandlers = new HashMap<>();
        messageHandlers.put("group1", new Group1MessageHandler());
        messageHandlers.put("group2", new Group2MessageHandler());

        // 消费消息
        channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String messageId = properties.getMessageId();
                MessageHandler messageHandler = messageHandlers.get(messageId);

                if (messageHandler != null) {
                    String message = new String(body, "UTF-8");
                    messageHandler.handleMessage(message);
                }

                // 手动确认消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }

    // 定义消息处理器接口
    interface MessageHandler {
        void handleMessage(String message);
    }

    // 分组1的消息处理器
    static class Group1MessageHandler implements MessageHandler {
        @Override
        public void handleMessage(String message) {
            System.out.println("Group 1: " + message);
            // 在这里处理分组1的消息
        }
    }

    // 分组2的消息处理器
    static class Group2MessageHandler implements MessageHandler {
        @Override
        public void handleMessage(String message) {
            System.out.println("Group 2: " + message);
            // 在这里处理分组2的消息
        }
    }
}

在上面的代码示例中，我们首先创建了一个连接和通道，并声明了一个交换机和一个队列。然后，我们定义了一个消息处理器接口 MessageHandler，并分别实现了两个不同分组的消息处理器 Group1MessageHandler 和 Group2MessageHandler。接下来，我们将消息处理器与其对应的分组关联起来，并使用 basicConsume() 方法来消费队列中的消息。在消息处理的回调函数中，我们首先根据消息的id获取对应的消息处理器，然后调用 handleMessage() 方法处理消息。最后，我们使用 basicAck() 方法手动确认处理完的消息。

请注意，上述示例中的代码只是一个简单的示例，实际上在生产环境中需要考虑更多的错误处理和异常情况。