在WebLogic中配置JMS消息大小：weblogic.socket.MaxMessageSizeExceededException

Question

我目前有兩個客戶端（生產者/消費者），我試圖通過JMS發送一個大文件。 我成功生成並將文件發送到JMS服務器沒有任何問題。 問題是當我嘗試使用消息時，我得到以下異常：

Aug 24, 2012 11:25:37 AM client.Client$1 onException
SEVERE: Connection to the Server has been lost, will retry in 30 seconds. weblogic.jms.common.LostServerException: java.lang.Exception: weblogic.rjvm.PeerGoneException: ; nested exception is: 
    weblogic.socket.MaxMessageSizeExceededException: Incoming message of size: '10000080' bytes exceeds the configured maximum of: '10000000' bytes for protocol: 't3'
<Aug 24, 2012 11:25:37 AM CDT> <Error> <Socket> <BEA-000403> <IOException occurred on socket: Socket[addr=127.0.0.1/127.0.0.1,port=7001,localport=51764]
 weblogic.socket.MaxMessageSizeExceededException: Incoming message of size: '10000080' bytes exceeds the configured maximum of: '10000000' bytes for protocol: 't3'.
weblogic.socket.MaxMessageSizeExceededException: Incoming message of size: '10000080' bytes exceeds the configured maximum of: '10000000' bytes for protocol: 't3'
    at weblogic.socket.BaseAbstractMuxableSocket.incrementBufferOffset(BaseAbstractMuxableSocket.java:174)
    at weblogic.rjvm.t3.MuxableSocketT3.incrementBufferOffset(MuxableSocketT3.java:351)
    at weblogic.socket.SocketMuxer.readFromSocket(SocketMuxer.java:983)
    at weblogic.socket.SocketMuxer.readReadySocketOnce(SocketMuxer.java:922)

我相信這與我在WebLogic中的MaxMessage大小設置有關，而不是代碼問題（但我當然可能是錯的）。 這是我的最大消息大小的settigns

我不知道為什么我會收到此異常，因為此協議的最大郵件大小大於異常所聲稱的...任何想法？

我也嘗試添加服務器啟動參數-Dweblogic.MaxMessageSize = 200000000，但無濟於事。

下面是我設置MessageListener的消息的代碼，以及消息使用者本身。

public boolean setClient(MessageListener listener) {

        try {
            Properties parm = new Properties();
            parm.setProperty("java.naming.factory.initial",
                    "weblogic.jndi.WLInitialContextFactory");
            parm.setProperty("java.naming.provider.url", iProps.getURL());
            parm.setProperty("java.naming.security.principal", iProps.getUser());
            parm.setProperty("java.naming.security.credentials",
                    iProps.getPassword());
            ctx = new InitialContext(parm);
            final QueueConnectionFactory connectionFactory = (QueueConnectionFactory) ctx
                    .lookup(iProps.getConFactory());
            connection = connectionFactory.createQueueConnection();
            ((WLConnection) connection)
                    .setReconnectPolicy(JMSConstants.RECONNECT_POLICY_ALL);
            ((WLConnection) connection).setReconnectBlockingMillis(30000L);
            ((WLConnection) connection).setTotalReconnectPeriodMillis(-1L);
            session = connection.createQueueSession(false,
                    Session.AUTO_ACKNOWLEDGE);
            queue = (Queue) ctx.lookup(iProps.getQueue());
            // The following code in the switch statement is the only code that
            // differs for the producer and consumer.
            switch (cType)
                {
                case PRODUCER: {
                    producer = (WLMessageProducer) session
                            .createProducer(queue);
                    // Setting to send large files is done in WebLogic
                    // Administration Console.
                    // Set
                    producer.setSendTimeout(60000L);
                    break;
                }
                case CONSUMER: {
                    consumer = session.createConsumer(queue);
                    if (listener != null) {
                        consumer.setMessageListener(listener);
                    }else{
                        log.warning("A Message listener was not set for the consumer, messages will not be acknowledged!");
                    }
                    break;
                }
                default:
                    log.info("The client type " + cType.toString()
                            + " is not currently supported!");
                    return false;
                }

            connection.setExceptionListener(new ExceptionListener() {
                @Override
                public void onException(JMSException arg0) {
                    Logger log2 = new MyLogger().getLogger("BPEL Client");
                    if (arg0 instanceof LostServerException) {
                        log2.severe("Connection to the Server has been lost, will retry in 30 seconds. "
                                + arg0.toString());
                    } else {
                        log2.severe(arg0.toString());
                    }

                }
            });
            shutdownListener = new ShutdownListener(connection, session, producer, consumer);

            connection.start();
            log.info("Successfully connected to " + iProps.getURL());
            return true;
        } catch (JMSException je) {
            log.severe("Could not connect to the WebLogic Server, will retry in 30 seconds. "
                    + je.getMessage());
            try {
                Thread.sleep(30000L);
            } catch (InterruptedException e) {
                log.warning(e.toString());
            }
            return setClient(listener);
        } catch (Exception e) {
            log.severe("Could not connect to the WebLogic Server, will retry in 30 seconds. "
                    + e.toString());
            try {
                Thread.sleep(30000L);
            } catch (InterruptedException ie) {
                log.warning(ie.toString());
            }
            return setClient(listener);

        }
    }

這是MessageListener：

public class ConsumerListener implements MessageListener {
    private Logger log;
    private File destination;
    private Execute instructions;

    public ConsumerListener(Execute instructions, File destination) {
        this.instructions = instructions;
        this.destination = destination;
        log = new MyLogger().getLogger("BPEL Client");
    }

    @Override
    public void onMessage(Message arg0) {

        try {
            if (arg0.getJMSRedelivered()) {
                log.severe("A re-delivered message has been received, and it has been ignored!"
                        + arg0.toString());
            } else {
                try {
                    if (arg0 instanceof TextMessage) {
                        consumeMessage((TextMessage) arg0);

                    } else if (arg0 instanceof BytesMessage) {
                        consumeMessage((BytesMessage) arg0);
                    } else {
                        log.warning("Currently, only TextMessages and BytesMessages are supported!");
                    }
                } catch (JMSException e) {
                    log.severe(e.toString());
                } catch (IOException e) {
                    log.severe(e.toString());
                } catch (Throwable t) {
                    log.severe(t.toString());
                }
            }
        } catch (JMSException e) {
            log.severe(e.toString());
        }
    }

    /**
     * Unwraps the JMS message received and creates a file and a control file if
     * there are instructions present.
     *
     * @param textMessage
     *            JMS message received to be consumed.
     * @throws JMSException
     * @throws IOException
     */
    protected void consumeMessage(TextMessage textMessage) throws JMSException,
            IOException {
        // ***All properties should be lowercase. for example fileName
        // should be
        // filename.***
        String fileName = textMessage.getStringProperty("filename");
        if (fileName == null || fileName.isEmpty()) {
            fileName = textMessage.getStringProperty("fileName");
        }
        if (fileName != null && !fileName.isEmpty()) {
            // Check if the
            // file name is equal to the shutdown file. If it
            // is, shutdown the consumer. This is probably not a good way to
            // do this, as the program can no longer be shutdown locally!

            // We have a file in the queue, need to create the file.
            createFile(destination.getAbsolutePath() + "\\" + fileName,
                    textMessage.getText());
            log.info("Done creating the file");
            String inst = textMessage.getStringProperty("instructions");
            // If there are instructions included, then create the
            // instruction file, and route the message based on this file.
            if (inst != null && !inst.isEmpty()) {
                // We need to rout the file.
                log.info("Instructions found, executing instructions");
                String[] tokens = fileName.split("\\.");
                String instFileName = "default.ctl";
                if (tokens.length == 2) {
                    instFileName = tokens[0] + ".ctl";
                }
                File controlFile = createFile(destination.getAbsolutePath()
                        + "\\" + instFileName, inst);
                Control control = new Control(controlFile);
                instructions.execute(control);
                log.info("Done executing instructions");
            } else {
                log.info("No instructions were found");
            }
            log.info("Done consuming message: " + textMessage.getJMSMessageID());
        }

    }

    /**
     * Unwraps the JMS message received and creates a file and a control file if
     * there are instructions present.
     *
     * @param bytesMessage
     *            The bytes payload of the message.
     * @throws JMSException
     * @throws IOException
     */
    protected void consumeMessage(BytesMessage bytesMessage)
            throws JMSException, IOException {
        // ***All properties should be lowercase. for example fileName
        // should be
        // filename.***
        log.info("CONSUME - 1");
        String fileName = bytesMessage.getStringProperty("filename");
        if (fileName == null || fileName.isEmpty()) {
            fileName = bytesMessage.getStringProperty("fileName");
        }
        if (fileName != null && !fileName.isEmpty()) {
            // Check if the
            // file name is equal to the shutdown file. If it
            // is, shutdown the consumer. This is probably not a good way to
            // do this, as the program can no longer be shutdown locally!

            // We have a file in the queue, need to create the file.
            byte[] payload = new byte[(int) bytesMessage.getBodyLength()];
            bytesMessage.readBytes(payload);
            createFile(destination.getAbsolutePath() + "\\" + fileName, payload);
            log.info("Done creating the file");
            String inst = bytesMessage.getStringProperty("instructions");
            // If there are instructions included, then create the
            // instruction file, and route the message based on this file.
            if (inst != null && !inst.isEmpty()) {
                // We need to rout the file.
                log.info("Instructions found, executing instructions");
                String[] tokens = fileName.split("\\.");
                String instFileName = "default.ctl";
                if (tokens.length == 2) {
                    instFileName = tokens[0] + ".ctl";
                }
                File controlFile = createFile(destination.getAbsolutePath()
                        + "\\" + instFileName, inst);
                Control control = new Control(controlFile);
                instructions.execute(control);
                log.info("Done executing instructions");
            } else {
                log.info("No instructions were found");
            }
            log.info("Done consuming message: "
                    + bytesMessage.getJMSMessageID());
        }

    }

    /**
     * Creates a file with the given filename (this should be an absolute path),
     * and the text that is to be contained within the file.
     *
     * @param fileName
     *            The filename including the absolute path of the file.
     * @param fileText
     *            The text to be contained within the file.
     * @return The newly created file.
     * @throws IOException
     */
    protected File createFile(String fileName, String fileText)
            throws IOException {
        File toCreate = new File(fileName);
        FileUtils.writeStringToFile(toCreate, fileText);
        return toCreate;
    }

    /**
     * Creates a file with the given filename (this should be an absolute path),
     * and the text that is to be contained within the file.
     *
     * @param fileName
     *            The filename including the absolute path of the f ile.
     * @param fileBytes
     *            The bytes to be contained within the file.
     * @return The newly created file.
     * @throws IOException
     */
    protected File createFile(String fileName, byte[] fileBytes)
            throws IOException {
        File toCreate = new File(fileName);
        FileUtils.writeByteArrayToFile(toCreate, fileBytes);
        return toCreate;
    }
}

Answer 1

您還必須從WLS控制台增加最大郵件大小，如所有托管服務器的屏幕截圖所示。

然后執行重啟，問題將得到解決。

此外，還有第二種替代解決方案。 根據Oracle Tuning WebLogic JMS Doc ：

調整MessageMaximum限制

如果推送給使用者的消息的聚合大小大於當前協議的最大消息大小（默認大小為10 MB，並使用控制台在每個WebLogic Server實例的基礎上配置，並使用Dweblogic.MaxMessageSize在每個客戶端的基礎上配置命令行屬性），郵件傳遞失敗。

在客戶端上設置最大郵件大小

發送和接收大型消息時，除WebLogic Server實例外，您可能還需要配置WebLogic客戶端。 要在客戶端上設置最大郵件大小，請使用以下命令行屬性：

-Dweblogic.MaxMessageSize

注意：此設置適用於傳遞到客戶端的所有WebLogic Server網絡數據包，而不僅僅是與JMS相關的數據包 。

編輯：

可以通過執行以下一個或多個操作來解決此問題。

• 配置系統屬性-Dweblogic.MaxMessageSize
• 使用管理員和所有托管服務器的WLS控制台增加最大郵件大小。 WLS控制台中的步驟是：server / Protocols / General
• 從WLS控制台增加最大郵件大小。 WLS控制台中的步驟是：隊列/配置/閾值和配額/最大消息大小

步驟為應用weblogic.MaxMessageSize物業

保留setDomainEnv文件的備份。 停止所有服務器。 在每個setDomainEnv文件中添加-Dweblogic.MaxMessageSize = yourValue，更具體地說，在EXTRA_JAVA_PROPERTIES行中添加。 然后首先啟動ADMIN，當ADMIN處於RUNNING狀態時，啟動MANAGED服務器。

我希望這有幫助。

Answer 2

在我的情況下，設置-Dweblogic.MaxMessageSize解決了這個問題。 我的問題是消息大小的最大限制應該是多少？ 我們無法繼續增加郵件大小來解決此問題。 除了某些其他值之外，還有什么方法可以優化此值嗎？