Java 消息侦听器onMessage（）方法未从队列中删除消息

我正在实现MessageListner类的onMessgae（）方法，但它不起作用，即使我将调试点放在这个方法中，但调试器也没有放在这个方法中

使用此方法从队列接收消息。 下面是我用来接收消息的代码，但当我通过sender类发送消息时，它不会给出任何消息，消息会发送到JMS服务器，并在服务器上以这种方式显示

名称服务器目标当前消息当前消息支出消息收到JMSServer-0 AdminServer 3 15 1 2

接收器代码：

{
import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;


public class QueueReceive implements MessageListener {
    public final static String Server="t3://localhost:7001";
    public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
    public final static String JMS_FACTORY = "CF1";
    enter code here

    public final static String QUEUE = "Queue1";
    private QueueConnectionFactory qconFactory;
    private QueueConnection qcon;
    private QueueSession qsession;
    private QueueReceiver qreceiver;
    private Queue queue;
    private boolean quit = false;
    String s1 = "avanish";


    public void init(Context ctx, String queueName) throws NamingException, JMSException {
        qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
        qcon = qconFactory.createQueueConnection();
        qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
        queue = (Queue) ctx.lookup(queueName);
        qreceiver = qsession.createReceiver(queue);
        qreceiver.setMessageListener(this);
        qcon.start();
        System.out.println(qreceiver.receive());
    }

    public void close() throws JMSException {
        qreceiver.close();
        qsession.close();
        qcon.close();
    }

    public static void main(String[] args) throws Exception {
        /*if (args.length != 1) {
            System.out.println("Usage: java examples.jms.queue.QueueReceive WebLogicURL");
            return;
        }*/
        InitialContext ic = getInitialContext();
        QueueReceive qr = new QueueReceive();
        qr.init(ic, QUEUE);
        System.out.println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");
        synchronized (qr) {
            while (!qr.quit) {
                try {
                    qr.wait();
                } catch (InterruptedException ie) {
                }
            }
        }
        qr.close();
    }


    private static InitialContext getInitialContext() throws NamingException {
        Hashtable<String, String> env = new Hashtable<String, String>();
        env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
        env.put(Context.PROVIDER_URL, Server);
        return new InitialContext(env);
    }

    @Override
    public void onMessage(Message msg) {
        try {
            String msgText;
            if(msg instanceof TextMessage){
                    msgText = ((TextMessage) msg).getText();
                } 
             else{
                 msgText = msg.toString();
            }
                 System.out.println("reciver msg" + msgText);

                 if(msgText.equalsIgnoreCase("quit")){
                     synchronized (this) {
                        quit= true;
                        this.notifyAll();
                    }
                 }
            } catch (JMSException e) {
                System.err.println("Exception" + e.getMessage());
            }

        }


}

}

{
导入java.util.Hashtable；
导入javax.jms.jmsception；
导入javax.jms.Message；
导入javax.jms.MessageListener；
导入javax.jms.Queue；
导入javax.jms.QueueConnection；
导入javax.jms.QueueConnectionFactory；
导入javax.jms.QueueReceiver；
导入javax.jms.QueueSession；
导入javax.jms.Session；
导入javax.jms.TextMessage；
导入javax.naming.Context；
导入javax.naming.InitialContext；
导入javax.naming.NamingException；
公共类QueueReceive实现MessageListener{
公共最终静态字符串Server=“t3://localhost:7001”；
公共最终静态字符串JNDI_FACTORY=“weblogic.JNDI.WLInitialContextFactory”；
公共最终静态字符串JMS_FACTORY=“CF1”；
在这里输入代码
公共最终静态字符串QUEUE=“Queue1”；
专用队列连接工厂qconFactory；
专用排队连接；
私人排队会话；
专用队列接收器qreceiver；
专用队列；
private boolean quit=false；
字符串s1=“avanish”；
public void init（上下文ctx，字符串queueName）引发NamingException，JMSExException{
qconFactory=（QueueConnectionFactory）ctx.lookup（JMS\u工厂）；
qcon=qconFactory.createQueueConnection（）；
qsession=qcon.createQueueSession（false，Session.AUTO_ACKNOWLEDGE）；
queue=（queue）ctx.lookup（queueName）；
qreceiver=qsession.createReceiver（队列）；
qreceiver.setMessageListener（此）；
qcon.start（）；
System.out.println（qreceiver.receive（））；
}
public void close（）引发JMSExException{
qreceiver.close（）；
qsession.close（）；
qcon.close（）；
}
公共静态void main（字符串[]args）引发异常{
/*如果（args.length！=1）{
System.out.println（“用法：java examples.jms.queue.QueueReceive WebLogicURL”）；
返回；
}*/
InitialContext ic=getInitialContext（）；
QueueReceive qr=新的QueueReceive（）；
qr.init（ic，队列）；
println（“JMS准备接收消息（要退出，发送一条“退出”消息）”；
同步（qr）{
而（！qr.退出）{
试一试{
qr.wait（）；
}捕获（中断异常ie）{
}
}
}
qr.close（）；
}
私有静态InitialContext getInitialContext（）引发NamingException{
Hashtable env=新的Hashtable（）；
环境放置（Context.INITIAL\u Context\u工厂、JNDI\u工厂）；
环境放置（Context.PROVIDER\uURL，服务器）；
返回新的InitialContext（env）；
}
@凌驾
公共消息无效（消息消息消息）{
试一试{
字符串msgText；
if（消息实例of TextMessage）{
msgText=（（TextMessage）msg.getText（）；
} 
否则{
msgText=msg.toString（）；
}
System.out.println（“接收消息”+msgText）；
if（msgText.equalsIgnoreCase（“退出”））{
已同步（此）{
退出=真；
this.notifyAll（）；
}
}
}捕获（JME）{
System.err.println（“异常”+e.getMessage（））；
}
}
}
}

发件人代码： {

import javax.jms.jmsceception；
导入javax.jms.Queue；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.Hashtable；
导入javax.jms.*；
导入javax.jms.QueueConnection；
导入javax.jms.QueueConnectionFactory；
导入javax.jms.QueueSender；
导入javax.jms.QueueSession；
导入javax.jms.Session；
导入javax.jms.TextMessage；
导入javax.naming.Context；
导入javax.naming.InitialContext；
导入javax.naming.NamingException；
公共类队列发送{
公共最终静态字符串Server=“t3://localhost:7001”；
公共最终静态字符串JNDI_FACTORY=“weblogic.JNDI.WLInitialContextFactory”；
公共最终静态字符串JMS_FACTORY=“CF1”；
公共最终静态字符串QUEUE=“Queue1”；
//公共最终静态字符串QUEUE=“DQ”；
专用队列连接工厂qconFactory；
专用排队连接；
私人排队会话；
专用队列发送器；
专用队列；
私人短信；
public void init（上下文ctx，字符串queueName）引发NamingException，JMSExException
{
qconFactory=（QueueConnectionFactory）ctx.lookup（JMS\u工厂）；
qcon=qconFactory.createQueueConnection（）；
qsession=qcon.createQueueSession（false，Session.AUTO_ACKNOWLEDGE）；
queue=（queue）ctx.lookup（queueName）；
qsender=qsession.createSender（队列）；
msg=qsession.createTextMessage（）；
qcon.start（）；
}
公共void发送（字符串消息）引发JMSException{
msg.setText（消息）；
//msg.acknowledge（）；
qsender.setPriority（9）；
qsender.send（msg）；
}
public void close（）引发JMSExException{
qsender.close（）；
qsession.close（）；
qcon.close（）；
}
公共静态void main（字符串[]args）引发异常{
InitialContext ic=getInitialContext（）；
QueueSend qs=新建QueueSend（）；
qs.init(
    import javax.jms.JMSException;
import javax.jms.Queue;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Hashtable;

import javax.jms.*;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class QueueSend {
    public final static String Server="t3://localhost:7001";
    public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
    public final static String JMS_FACTORY = "CF1";
    public final static String QUEUE = "Queue1";
//  public final static String QUEUE = "DQ";
    private QueueConnectionFactory qconFactory;
    private QueueConnection qcon;
    private QueueSession qsession;
    private QueueSender qsender;
    private Queue queue;
    private TextMessage msg;

    public void init(Context ctx, String queueName) throws NamingException, JMSException

    {

        qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);

        qcon = qconFactory.createQueueConnection();

        qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);

        queue = (Queue) ctx.lookup(queueName);

        qsender = qsession.createSender(queue);

        msg = qsession.createTextMessage();

        qcon.start();

    }

    public void send(String message) throws JMSException {

        msg.setText(message);
        //msg.acknowledge();
        qsender.setPriority(9);
        qsender.send(msg);

    }

    public void close() throws JMSException {

        qsender.close();

        qsession.close();

        qcon.close();

    }

    public static void main(String[] args) throws Exception {


        InitialContext ic = getInitialContext();

        QueueSend qs = new QueueSend();

        qs.init(ic, QUEUE);

        readAndSend(qs);

        qs.close();

    }

    private static void readAndSend(QueueSend qs) throws IOException, JMSException

    {

        BufferedReader msgStream = new BufferedReader(new InputStreamReader(System.in));

        String line = null;

        boolean quitNow = false;

        do {

            System.out.print("Enter message (\"quit\" to quit): \n");

            line = msgStream.readLine();

            if (line != null && line.trim().length() != 0) {

                qs.send(line);

                System.out.println("JMS Message Sent: " + line + "\n");

                quitNow = line.equalsIgnoreCase("quit");

            }

        } while (!quitNow);

    }

    private static InitialContext getInitialContext()

            throws NamingException

    {

        Hashtable<String, String> env = new Hashtable<String, String>();

        env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);

        env.put(Context.PROVIDER_URL, Server);

        return new InitialContext(env);

    }

}



}

    queue = (Queue) ctx.lookup(queueName);
    qreceiver = qsession.createReceiver(queue);

   message = qreceiver.receiveNoWait();