更改jdbc库，在我的情况下，这修复了它（如果不这样做，请尝试使用其他版本）：

<dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc7</artifactId>
    <version>12.1.0.2.0</version>
</dependency>

字符串

我们在尝试从Sping Boot 访问Oracle AQ时遇到了相同的异常。研究表明，此异常是由于数据库连接池库不允许访问Oracle AQ库所需的底层连接而引发的。（dbcp和tomcat连接池库都引发了异常，不相同但相似）
当我们从依赖项中删除数据库连接池库时，这个异常就消失了，这会导致整个应用程序没有数据库连接池的不良状态。
我们注意到，如果我们使用以下方法，则不会抛出AQjmsFactory.getQueueConnectionFactory(url, info);异常
也许解决方案中也缺少连接池，但这仅限于从AQ读取的组件。应用程序中的其他组件将具有连接池的好处。
下面是Bean定义的java配置：

@Bean
public QueueConnectionFactory connectionFactory() throws Exception {
    OracleServiceInfo serviceInfo = (OracleServiceInfo) this.cloud().getServiceInfo(NAME_PRIMARY_DS);
    Properties info = new Properties();
    String url = serviceInfo.getJdbcUrl();
    info.put("driver-name", "oracle.jdbc.OracleDriver");
    info.put("user", serviceInfo.getUserName());
    info.put("password", serviceInfo.getPassword());
    return oracle.jms.AQjmsFactory.getQueueConnectionFactory(url, info);
}
@Bean
public JmsTemplate jmsTemplate() throws Exception {
    JmsTemplate jmsTemplate = new JmsTemplate();
    jmsTemplate.setConnectionFactory(connectionFactory());
    return jmsTemplate;
}

字符串
我不知道这是否一个好的解决办法，但这肯定是一个方法，以消除问题中讨论的例外情况。

嗨，我也花了相当长的时间来使连接工作，但最后它做到了，这是如何：
首先，确保Oracle AQ队列表的有效负载未设置为RAW，而最好设置为Text：RAW.AQ$_JMS_TEXT_MESSAGE
接下来使用类似于下面的OracleAQConfiguration：

import oracle.jdbc.pool.OracleDataSource;
import oracle.jms.AQjmsFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.jms.JMSException;
import javax.jms.QueueConnectionFactory;
import javax.sql.DataSource;
import java.sql.SQLException;
@Configuration
public class OracleAQConfiguration {
    // Values are retrieved from custom added props in Spring application.properties
    @Value("${myapplication.datasource.user}")
    private String user;
    @Value("${myapplication.datasource.password}")
    private String password;
    @Value("${myapplication.datasource.connectionstring}")
    private String connectionstring;
    @Bean
    /**
     * Spring bean with the configuration details of where the Oracle database is containing the QUEUES
     */
    public DataSource dataSource() throws SQLException {
        OracleDataSource ds = new OracleDataSource();
        ds.setUser(user);
        ds.setPassword(password);
        ds.setURL(connectionstring);
        ds.setImplicitCachingEnabled(true);
        ds.setFastConnectionFailoverEnabled(true);
        return ds;
    }
    @Bean
    /**
     * The KEY component effectively connecting to the Oracle AQ system using the datasource input
     */
    public QueueConnectionFactory connectionFactory(DataSource dataSource) throws JMSException {
        return AQjmsFactory.getQueueConnectionFactory(dataSource);
    }
}

字符串
接下来使用类似于下面的JMSConfiguration。在这里，我读取和写入相同的队列，这在真实的应用程序集成场景中是不可能的。但是可以用于测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.listener.DefaultMessageListenerContainer;
import javax.jms.ConnectionFactory;
import javax.sql.DataSource;
@Configuration
public class JMSConfiguration {
    private static final String QUEUENAME_WRITE = "MYQUEUE";
    private static final String QUEUENAME_READ = "MYQUEUE";
    @Autowired
    private JMSReceiver jmsReceiver;
    @Bean
    /**
     * Spring bean to WRITE/SEND/ENQUEUE messages on a queue with a certain name
     */
    public JmsTemplate jmsTemplate(ConnectionFactory conFactory) {
        JmsTemplate jmsTemplate = new JmsTemplate();
        jmsTemplate.setDefaultDestinationName(QUEUENAME_WRITE);
        jmsTemplate.setSessionTransacted(true);
        jmsTemplate.setConnectionFactory(conFactory);
        return jmsTemplate;
    }
    /**
     * Spring bean to READ/RECEIVE/DEQUEUE messages of a queue with a certain name
     * All of this happens under a code managed transaction
     * to commit the change on Oracle (remove of the message from the queue table)
     * Reference the application custom code handling the message here
     */
    @Bean
    public DefaultMessageListenerContainer messageListenerContainer(ConnectionFactory conFactory, DataSource dataSource) {
        DefaultMessageListenerContainer dmlc = new DefaultMessageListenerContainer();
        dmlc.setDestinationName(QUEUENAME_READ);
        dmlc.setSessionTransacted(true);
        dmlc.setConnectionFactory(conFactory);
        DataSourceTransactionManager manager = new DataSourceTransactionManager();
        manager.setDataSource(dataSource);
        dmlc.setTransactionManager(manager);
        // Add here our self-written JMS Receiver
        dmlc.setMessageListener(jmsReceiver);
        return dmlc;
    }
}

型
最后，对于处理传入的JMS消息，使用类似于：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.listener.SessionAwareMessageListener;
import org.springframework.stereotype.Component;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;
@Component
public class JMSReceiver implements SessionAwareMessageListener {
    private static final Logger logger = LoggerFactory.getLogger(JMSReceiver.class);
    @Override
    public void onMessage(Message message, Session session) throws JMSException {
        // We know/assume the Queue Payload type was set to 'TextMessage'
        TextMessage txtMessage = (TextMessage) message;
        logger.info("JMS Text Message received: " + txtMessage.getText());
        // ... further implementation
    }
}

型

问题是AQ代码需要OracleConnection，但在池化时连接被 Package ，因此失败

@Bean
    public AQjmsConnectionFactory connectionFactory(@Autowired DataSource dataSource) throws Exception{
        AQjmsConnectionFactory connectionFactory=new AQjmsConnectionFactory();
        connectionFactory.setDatasource(dataSource);
        return connectionFactory;
    }
    @Bean
    public JmsTemplate jmsTemplate(@Autowired AQjmsConnectionFactory connectionFactory) throws Exception{
        JmsTemplate jmsTemplate=new JmsTemplate();
        jmsTemplate.setConnectionFactory(connectionFactory);
        return jmsTemplate;
    }
POM File:
<dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
        </dependency>
<dependency>
            <groupId>com.oracle.database.messaging</groupId>
            <artifactId>aqapi-jakarta</artifactId>
            <version>23.2.1.0</version>
</dependency>
<dependency>
    <groupId>jakarta.jms</groupId>
    <artifactId>jakarta.jms-api</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/jakarta.transaction/jakarta.transaction-api -->
<dependency>
    <groupId>jakarta.transaction</groupId>
    <artifactId>jakarta.transaction-api</artifactId>
</dependency>

字符串
//使用Spring JMS模板向Oracle AQ JMS队列发送消息的代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.jms.JMSException;
import jakarta.jms.Message;
import jakarta.jms.Session;
@Service
public class JmsUtil {
    @Autowired
    JmsTemplate jmsTemplate;
    //Send JMS message to Oracle AQ JMS queue
    public void sendMessageToJmsQueue(YourPojoClass yourPojoClass) {
        try {
            ObjectMapper mapper=new ObjectMapper();
            String pojoAsJson=mapper.writeValueAsString(yourPojoClass);
            jmsTemplate.send("YourQueueName", new MessageCreator() {
                public Message createMessage(Session session) throws JMSException{
                    return session.createTextMessage(pojoAsJson);
                }
            });
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

型