Отключение от weblogic JMS

В настоящее время мое отключение от сервера JMS веб-журнала выглядит следующим образом

import java.util.Hashtable;
import javax.jms.*;
import javax.naming.*;
import javax.transaction.*;
import java.util.Vector;
import javax.rmi.PortableRemoteObject;
import clojure.java.api.Clojure;
import clojure.lang.IFn;
import org.apache.log4j.Logger;
import weblogic.jndi.*;

public class WebLogicListener implements MessageListener, ExceptionListener{
  public InitialContext ctx;
  public TopicConnectionFactory conFactory;
  public TopicConnection tCon;
  public TopicSession tSession;
  public TopicSubscriber tSub;
  public Boolean development;
  public Topic topic;
  /*clojure function objects*/
  public IFn publish;
  public IFn close;
  public IFn incrementMetric;
  public IFn logMessage;
  public IFn resync;

  public Object channel;
  public ExceptionListener exception;
  public String topicName;
  public String subName;
  public String username;
  public String password;
  public String clientId;
  public String factoryJNDI;
  public String topicJNDI;
  public Vector nms;
  public Hashtable<Object,Object> env;
  public boolean running = false;

  public WebLogicListener (String topicName, String host, String username, String password, String factoryJNDI,
                           String topicJNDI, String clientId, String subName, String ns, String fnName,
                           boolean development, Vector nms){
    this.username = username;
    this.password = password;
    this.clientId = clientId;
    this.topicName = topicName;
    this.subName = subName;
    this.development = development;
    this.topicJNDI = topicJNDI;
    this.factoryJNDI = factoryJNDI;
    this.nms = nms;
    /*Clojure interop handlers*/
    IFn chan = Clojure.var("clojure.core.async", "chan");
    resync = Clojure.var("cenx.baldr.api", "resync!");
    publish = Clojure.var(ns, fnName);
    incrementMetric = Clojure.var(ns, "log-metric");
    logMessage = Clojure.var (ns, "log-message");
    close = Clojure.var("clojure.core.async","close!");
    /*populate envrionment*/
    env = new Hashtable<Object,Object>();
    env.put(Context.PROVIDER_URL, host);
    env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
    env.put(Context.SECURITY_PRINCIPAL, username);
    env.put(Context.SECURITY_CREDENTIALS, password);
    env.put("weblogic.jndi.createIntermediateContexts", "true");
    /*open communication channel for clojure daemon*/
    channel = chan.invoke();
  }

  private void initListener() throws JMSException, NamingException{
    try{
      if (!running && !development){
        ctx = new InitialContext(env);
        topic = (Topic) ctx.lookup(topicJNDI);
        conFactory =  (TopicConnectionFactory)PortableRemoteObject.narrow(ctx.lookup(factoryJNDI), TopicConnectionFactory.class);
        tCon = (TopicConnection) conFactory.createTopicConnection();
        tCon.setExceptionListener(this);
        tCon.setClientID(clientId);
        tSession = (TopicSession) tCon.createTopicSession(false, 1);
        tSub = tSession.createDurableSubscriber(topic, subName);
        tSub.setMessageListener(this);
        tCon.start();
        running = true;
      }else{
        if (running){
          logMessage.invoke("error", String.format("Listener is already running"));
        }
        if (development){
          logMessage.invoke("info", "Running in development mode, no connection established");
        }
      }
    } catch(Exception e){
      logMessage.invoke("error", String.format("Unable to start listener \n %s", e.toString()));
    }
  }

  public void startListener(){
    if (!development && env != null){
      try {
        initListener();
      }catch(Exception e){
        logMessage.invoke("error", String.format("Unable to start Listener \n %s", e.toString()));
      }
    } else {
      if (development){
        logMessage.invoke("info", "Running in development mode, no connection established");
      }
      if (env == null){
        logMessage.invoke("error", "Environment variable is null");
      }
    }
  }

  ///Closes the JMS connection and the channel
  public void stopListener(){
    if (!development){
      try{
        tSub.close();
        tSession.close();
        tCon.close();
        incrementMetric.invoke("JMS-disconnect-count");
      }catch(Exception e){
        logMessage.invoke("error", String.format("Error while stopping the listener \n %s", e.toString()));
      }finally{
        running = false;
      }
    } else {
      logMessage.invoke("info", "Listener not started, running in development mode");
    }
  }

  public Object getChannel(){
    return channel;
  }

  //re-initializes the channel in case of error
  public void initializeChannel(){
    if (channel == null){
      IFn chan = Clojure.var("clojure.core.async", "chan");
      channel = chan.invoke();
    } else {
      logMessage.invoke("info", "Channel is already initialized");
    }
  }
  //accessors for debugging

  public void closeSubscription(){
    try{
      tSub.close();
    }catch (Exception e){
      logMessage.invoke("error", "unable to close topic subscription");
      logMessage.invoke("error", e.toString());
    }
  }

  public void closeSession(){
    try{
      tSession.unsubscribe(subName);
      tSession.close();
    }catch (Exception e){
      logMessage.invoke("error", "unable to close topic session");
      logMessage.invoke("error", e.toString());
    }
  }

  public void closeConnection(){
    try{
      tCon.close();
    }catch (Exception e){
      logMessage.invoke("error", "unable to close topic connection");
      logMessage.invoke("error", e.toString());
    }
  }

  public void closeContext(){
    try {
      ctx.close();
    }catch (Exception e){
      logMessage.invoke("error", "unable to close context");
      logMessage.invoke("error", e.toString());
    }
  }

  public Boolean isRunning(){
    return running;
  }

  public Context getContext (){
    return ctx;
  }

  public TopicConnectionFactory getFactory (){
    return conFactory;
  }

  public TopicConnection getTopicConnection (){
    return tCon;
  }

  public TopicSession getTopicSession (){
    return tSession;
  }

  public Boolean getDevelopmentMode(){
    return development;
  }

  public TopicSubscriber getTopicSubscriber (){
    return tSub;
  }

  public Topic getTopic (){
    return topic;
  }

  /*Interface methods*/

  public void onMessage(Message message){
    publish.invoke(channel, message);
  }
  /*attempt a resync after an exception connection*/
  private void resync(){
    resync.invoke(nms);
  }

  private void attemptReconnect() throws Exception{
    if (!development){
      //clean up any portions of the connection that managed to establish
      stopListener();
      //incase of stopListener exceptioning out set running to false
      running = false;
      do{
        try{
          initListener();
          if (running){
            resync();
          }
        }catch(Exception e){
          logMessage.invoke("error",
                            String.format("Unable to establish connection to JMS server \n %s", e.toString()));
        }finally{
          Thread.sleep(30000);
        }
      } while (!running);
    } else {
      logMessage.invoke("info", "Running in development mode, no connection established");
    }
  }

  public void onException(JMSException e){
    logMessage.invoke("error",
                      String.format("A JMS Exception has occurred, attempting to re-establish topic connection \n %s", e.toString()));
    try{
      incrementMetric.invoke("JMS-disconnect-count");
      attemptReconnect();
    }catch(Exception g){
      logMessage.invoke("error",
                        String.format("Unable to start Listener \n %s", g.toString()));
    }
  }

  /* Test functions */
  public void testException() throws JMSException{
    onException(new JMSException("testing exception function"));
  }

  public void testChannel (String message){
    if (development){
      publish.invoke(channel, message);
    }
  }
}

Когда я создаю соединение, я использую netstat, чтобы проверить, подключен ли сервер

netstat -an | grep 8001 tcp 0 0 ip-адрес: 59730
ip-адрес: 8001 ESTABLISHED

Затем я вызываю свой .stopListener в дополнение к методу .closeContext и возвращаюсь, чтобы снова проверить мое соединение с netstat, и получаю тот же результат

netstat -an | grep 8001 tcp 0 0 ip-адрес: 59730
ip-адрес: 8001 ESTABLISHED

Почему закрытие сеанса, подписчика и соединения не приведет к уничтожению соединения с сервером JMS. Документация, которую я нашел, не дал мне никаких объяснений, почему я не могу полностью уничтожить соединение.

ОТВЕТЫ

Ответ 1

Я не уверен, что вы правильно это подходите. Я вижу, что у вас есть прослушиватель исключений в соединении.

В weblogic слушатель будет вызываться много раз для каждого события ошибки, поэтому вам не следует делать tryReconnect для каждого вызова. Он будет вызван один раз для каждого зарегистрированного вами потребителя и один раз для каждого контролируемого соединения. Вы должны только отключиться, если исключение представляет собой ServerConnectionLost.

Кроме того, в обработчике ошибок вам нужно закрыть соединение. Если вы подключили connection.close(), это закрыло бы сессию и слушателей. Не нужно закрывать их в обратном порядке, как и вы.

И еще одно. У вас не должно быть кода "разработки" или "отладки" или "теста" в вашем производственном коде.

Эта часть, которая гласит: "if (! development && env!= null) {"... Вы не должны этого делать.

Теперь вернемся к вашему вопросу, почему фактическое соединение не закрыто. Я вижу, что вы делаете

try{
    tSub.close();
    tSession.close();
    tCon.close();
    incrementMetric.invoke("JMS-disconnect-count");
} catch...

Если tSub.close() или tSession.close() должны были быть обнулены, ваше соединение никогда не будет закрыто. Оберните каждый в независимый try/catch.