Oracle AQ + jms + spring + websocket

--创建消息负荷payload

create or replace type business_queue_payload_type as object (serverCode varchar2(32), hour integer,
time varchar(16), logTime varchar2(32));

--创建队列表

begin
  dbms_aqadm.create_queue_table(
    queue_table   => 'business_queue_table',
    queue_payload_type => 'business_queue_payload_type',
    multiple_consumers => false
  );
end;

--创建并启动队列

begin
  dbms_aqadm.create_queue (
    queue_name  => 'business_queue',
    queue_table => 'business_queue_table'
  );

  dbms_aqadm.start_queue(
    queue_name  =>  'business_queue'
  );
end;

--创建存储过程

CREATE OR REPLACE PROCEDURE send_business_aq_msg (serverCode IN VARCHAR2, hour IN INTEGER, time IN VARCHAR2, logTime IN VARCHAR2) as
  r_enqueue_options DBMS_AQ.ENQUEUE_OPTIONS_T;
  r_message_properties DBMS_AQ.MESSAGE_PROPERTIES_T;
  v_message_handle RAW(16);
  o_payload business_queue_payload_type;
begin
  o_payload := business_queue_payload_type(serverCode, hour, time, logTime);

  dbms_aq.enqueue(
    queue_name  => 'business_queue',
    enqueue_options => r_enqueue_options,
    message_properties => r_message_properties,
    payload => o_payload,
    msgid => v_message_handle
  );

  commit;
end send_business_aq_msg;

--创建触发器，新插入记录后触发

CREATE OR REPLACE TRIGGER INVOKE_LOG_TR
AFTER INSERT ON M_AC_INVOKE_LOG FOR EACH ROW
DECLARE
pragma autonomous_transaction;
BEGIN
  send_business_aq_msg(:new.server_code, to_number(to_char(:new.invoke_time, 'hh24')), 
  ROUND((:new.return_time - :new.invoke_time)*24*3600,2), to_char(:new.invoke_time, 'YYYY-MM-DD hh24:mi:ss'));
END;

--停止删除队列

BEGIN
   DBMS_AQADM.STOP_QUEUE(
      queue_name => 'business_queue'
      );
   DBMS_AQADM.DROP_QUEUE(
      queue_name => 'business_queue'
      );
   DBMS_AQADM.DROP_QUEUE_TABLE(
      queue_table => 'business_queue_table'
      );
END;

需要的jar为：

app/oracle/product/12.1.0/dbhome_1/rdbms/jlib/jmscommon.jar
app/oracle/product/12.1.0/dbhome_1/jdbc/lib/ojdbc7.jar
app/oracle/product/12.1.0/dbhome_1/jlib/orai18n.jar
app/oracle/product/12.1.0/dbhome_1/jlib/jta.jar
app/oracle/product/12.1.0/dbhome_1/rdbms/jlib/aqapi_g.jar

数据类型转换类：

import java.sql.Connection;
import java.sql.SQLException;

import oracle.jdbc.internal.OracleTypes;
import oracle.jpub.runtime.MutableStruct;
import oracle.sql.Datum;
import oracle.sql.ORAData;
import oracle.sql.ORADataFactory;
import oracle.sql.STRUCT;

/**
 * 数据类型转换类
 */ 
public class QUEUE_MESSAGE_TYPE implements ORAData, ORADataFactory {
    public static final String _SQL_NAME = "QUEUE_MESSAGE_TYPE";
    public static final int _SQL_TYPECODE = OracleTypes.STRUCT;
 
    protected MutableStruct _struct;
 
    protected static int[] _sqlType =  { 12,4,12,12 };
    protected static ORADataFactory[] _factory = new ORADataFactory[4];
    protected static final QUEUE_MESSAGE_TYPE _QUEUE_MESSAGE_TYPEFactory = new QUEUE_MESSAGE_TYPE();
 
    public static ORADataFactory getORADataFactory() { 
    	return _QUEUE_MESSAGE_TYPEFactory; 
	}
    
    /* constructors */
    protected void _init_struct(boolean init) { 
    	if (init) _struct = new MutableStruct(new Object[4], _sqlType, _factory); 
	}
    
    public QUEUE_MESSAGE_TYPE() { 
    	_init_struct(true); 
	}
  
    public QUEUE_MESSAGE_TYPE(String serverCode, Integer hour, String time, String logTime) throws SQLException{ 
    	_init_struct(true);
    	setServerCode(serverCode);
    	setHour(hour);
    	setTime(time);
    	setLogTime(logTime);
    }
 
    /* ORAData interface */
    public Datum toDatum(Connection c) throws SQLException{
    	return _struct.toDatum(c, _SQL_NAME);
    }
 
 
    /* ORADataFactory interface */
    public ORAData create(Datum d, int sqlType) throws SQLException{ 
    	return create(null, d, sqlType); 
	}
  
    protected ORAData create(QUEUE_MESSAGE_TYPE o, Datum d, int sqlType) throws SQLException {
    	if (d == null) return null; 
    	if (o == null) o = new QUEUE_MESSAGE_TYPE();
    	o._struct = new MutableStruct((STRUCT) d, _sqlType, _factory);
    	return o;
    }
  
    /* accessor methods */
    public String getServerCode() throws SQLException{ 
    	return (String) _struct.getAttribute(0); 
	}
 
    public void setServerCode(String serverCode) throws SQLException { 
    	_struct.setAttribute(0, serverCode); 
	}
 
    public Integer getHour() throws SQLException{ 
    	return (Integer) _struct.getAttribute(1); 
	}
 
    public void setHour(Integer hour) throws SQLException { 
    	_struct.setAttribute(1, hour); 
	}
  
    public String getTime() throws SQLException{ 
    	return (String) _struct.getAttribute(2); 
	}
 
    public void setTime(String time) throws SQLException { 
    	_struct.setAttribute(2, time); 
	}
    
    public String getLogTime() throws SQLException{ 
    	return (String) _struct.getAttribute(3); 
	}
 
    public void setLogTime(String logTime) throws SQLException { 
    	_struct.setAttribute(3, logTime); 
	}
 
}

tomcat启动后执行代码，接收Oracle消息

import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.Session;

import oracle.jms.AQjmsAdtMessage;
import oracle.jms.AQjmsDestination;
import oracle.jms.AQjmsFactory;
import oracle.jms.AQjmsSession;

@Controller
@RequestMapping(value="")
public class BusinessMonitorController implements ApplicationListener<ContextRefreshedEvent>{

    public String username = "c##kevin";
    public String password = "a111111111";
    public String jdbcUrl = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
    public String queueName = "BUSINESS_QUEUE";

    private WebsocketDemo websocketDemo = new WebsocketDemo();

    @SuppressWarnings("unchecked")
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
	if(event.getApplicationContext().getParent() == null){//root application context 没有parent，他就是老大.  
		//需要执行的逻辑代码，当spring容器初始化完成后就会执行该方法。  
		try {
			
			//连接Oracle
			QueueConnectionFactory queueConnectionFactory = AQjmsFactory.getQueueConnectionFactory(jdbcUrl,
					new Properties());
			QueueConnection conn = queueConnectionFactory.createQueueConnection(username, password);
			AQjmsSession session = (AQjmsSession) conn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);

			conn.start();

			Queue queue = (AQjmsDestination) session.getQueue(username, queueName);
			MessageConsumer consumer = session.createConsumer(queue, null, QUEUE_MESSAGE_TYPE.getORADataFactory(), null, false);

			consumer.setMessageListener(new MessageListener() {
				@Override
				public void onMessage(Message message) {
					
					System.out.println("ok");
					AQjmsAdtMessage adtMessage = (AQjmsAdtMessage) message;
					
					try {
						QUEUE_MESSAGE_TYPE payload = (QUEUE_MESSAGE_TYPE) adtMessage.getAdtPayload();
						String serverCode = payload.getServerCode();
						Integer accessHour = payload.getHour();
						String accessTime = payload.getTime();
						String logTime = payload.getLogTime();
					} catch (Exception e) {
						e.printStackTrace();
					}
					
					//websocket向前端发送消息
					websocketDemo.sendMessageToUser(userId,message);
				}
			});
		} catch (Exception e) {
			e.printStackTrace();
		}
	}  
}

}

websocket导包

</dependency>
     	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-websocket</artifactId>
	    <version>${spring.version}</version>
	</dependency>
	<dependency>
    <groupId>javax.websocket</groupId>
    <artifactId>javax.websocket-api</artifactId>
    <version>1.0</version>
    <scope>provided</scope>
</dependency>

前端连接websocket代码

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
 
 
    <head lang="en">
        <meta charset="UTF-8">
        <title>webSocket-用户66</title>
        <script type="text/javascript">
            $(function() {
                var websocket;
                if('WebSocket' in window) {
                                        console.log("此浏览器支持websocket");
                    websocket = new WebSocket("ws://localhost:8080/residential/websocketDemo/66");
                } else if('MozWebSocket' in window) {
                    alert("此浏览器只支持MozWebSocket");
                } else {
                    alert("此浏览器只支持SockJS");
                }
                websocket.onopen = function(evnt) {
                 console.log(evnt);
                };
                websocket.onmessage = function(evnt) {
                    //处理消息
                };
                websocket.onerror = function(evnt) {};
                websocket.onclose = function(evnt) {
               		console.log("与服务器断开了链接!");
                }
                
//页面关闭执行
window.onbeforeunload = function(event) { 
		    websocket.onclose =function(){};
		    websocket.close();
		}
 
 
                function send() {
                    if(websocket != null) {
                        var message = document.getElementById('message').value;
                        console.log(message);
                        websocket.send(message);
                    } else {
                        alert('未与服务器链接.');
                    }
                }
            });
        </script>
    </head>
 
 
    <body>

    </body>
</html>

服务端连接websocket代码

package org.property.component;
 
 
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
 
 
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
 
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.socket.server.standard.SpringConfigurator;
 
 
/**
 * 
 * @Description: 给所用户所有终端推送消息
 *
 */
//websocket连接URL地址和可被调用配置
@ServerEndpoint(value="/websocketDemo/{userId}",configurator = SpringConfigurator.class)
public class WebsocketDemo {
    //日志记录      
    private Logger logger = LoggerFactory.getLogger(WebsocketDemo.class);
    //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
   
    //记录每个用户下多个终端的连接
    private static Map<Long, Set<WebsocketDemo>> userSocket = new HashMap<>();
 
    //需要session来对用户发送数据, 获取连接特征userId
    private Session session;
    private Long userId;
   
    /**
     * @Title: onOpen
     * @Description: websocekt连接建立时的操作
     * @param @param userId 用户id
     * @param @param session websocket连接的session属性
     * @param @throws IOException
     */
    @OnOpen
    public void onOpen(@PathParam("userId") Long userId,Session session) throws IOException{
        this.session = session;
        this.userId = userId;
        onlineCount++;
        //根据该用户当前是否已经在别的终端登录进行添加操作
        if (userSocket.containsKey(this.userId)) {
            logger.debug("当前用户id:{}已有其他终端登录",this.userId);
            userSocket.get(this.userId).add(this); //增加该用户set中的连接实例
        }else {
            logger.debug("当前用户id:{}第一个终端登录",this.userId);
            Set<WebsocketDemo> addUserSet = new HashSet<>();
            addUserSet.add(this);
            userSocket.put(this.userId, addUserSet);
        }
        logger.info("用户{}登录的终端个数是为{}",userId,userSocket.get(this.userId).size());
        logger.info("当前在线用户数为：{},所有终端个数为：{}",userSocket.size(),onlineCount);
    }
   
    /**
     * @Title: onClose
     * @Description: 连接关闭的操作
     */
    @OnClose
    public void onClose(){
    	onlineCount--;
        //移除当前用户终端登录的websocket信息,如果该用户的所有终端都下线了，则删除该用户的记录
        if (userSocket.get(this.userId).size() == 0) {
            userSocket.remove(this.userId);
        }else{
            userSocket.get(this.userId).remove(this);
        }
        logger.info("用户{}登录的终端个数是为{}",this.userId,userSocket.get(this.userId).size());
        logger.info("当前在线用户数为：{},所有终端个数为：{}",userSocket.size(),onlineCount);
    }
   
    /**
     * @Title: onMessage
     * @Description: 收到消息后的操作
     * @param @param message 收到的消息
     * @param @param session 该连接的session属性
     */
    @OnMessage
    public void onMessage(String message, Session session) {    
        logger.info("收到来自用户id为：{}的消息：{}",this.userId,message);
        if(session ==null)  logger.info("session null");
    }
   
    /**
     * @Title: onError
     * @Description: 连接发生错误时候的操作
     * @param @param session 该连接的session
     * @param @param error 发生的错误
     */
    @OnError
    public void onError(Session session, Throwable error){
        logger.debug("用户id为：{}的连接发送错误",this.userId);
        error.printStackTrace();
    }
   
  /**
   * @Title: sendMessageToUser
   * @Description: 发送消息给用户下的所有终端
   * @param @param userId 用户id
   * @param @param message 发送的消息
   * @param @return 发送成功返回true，反则返回false
   */
    public Boolean sendMessageToUser(Long userId,String message){
        if (userSocket.containsKey(userId)) {
            logger.info(" 给用户id为：{}的所有终端发送消息：{}",userId,message);
            for (WebsocketDemo WS : userSocket.get(userId)) {
                logger.info("sessionId为:{}",WS.session.getId());
                try {
                    WS.session.getBasicRemote().sendText(message);
                } catch (IOException e) {
                    e.printStackTrace();
                    logger.info(" 给用户id为：{}发送消息失败",userId);
                    return false;
                }
            }
            return true;
        }
        logger.info("发送错误：当前连接不包含id为：{}的用户",userId);
        return false;
    }
  
}