title: Configuring JMS Message Size in WebLogic: weblogic.socket.MaxMessageSizeExceededException
body: <p>I currently have two clients (Producer/Consumer), and I am trying to send a large file via JMS. I am successfully producing and sending the file to the JMS Server without any problems. The problem is when I try to consume the message, and I get the following exception: </p>
  
  <pre><code>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'
  &lt;Aug 24, 2012 11:25:37 AM CDT&gt; &lt;Error&gt; &lt;Socket&gt; &lt;BEA-000403&gt; &lt;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)
  </code></pre>
  
  <p>I believe this has to do with my MaxMessage size setting in WebLogic and not a code problem (but I could of course be wrong). Here are my settigns for Maximum Message Size
  <img src="https://i.stack.imgur.com/ro6Qb.png" alt="WebLogic settings"></p>
  
  <p>I am not sure why I am getting this exception since the Maximum message size for this protocol is larger than what the exception is claiming... Any thoughts?</p>
  
  <p>I have also tried adding the server start argument -Dweblogic.MaxMessageSize=200000000, but to no avail.
  <img src="https://i.stack.imgur.com/myiLS.png" alt="enter image description here"></p>
  
  <p>Here is some code of my where I set the MessageListener, and the message consumer itself.</p>
  
  <pre><code>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);
  
          }
      }
  </code></pre>
  
  <p>Here's the MessageListener:</p>
  
  <pre><code>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 &amp;&amp; !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 &amp;&amp; !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 &amp;&amp; !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 &amp;&amp; !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;
      }
  }
  </code></pre>