cmpprequest.java

短信网关发送接受平台。

import java.lang.*;
import java.net.*;
import java.io.*;

import CMPPLog;
import CMPPException;

import CMPPRequest;

import CMPPConnect;
import CMPPConnectResponse;

import CMPPActiveTest;
import CMPPActiveTestResponse;

import CMPPTerminate;
import CMPPTerminateResponse;

import CMPPSubmit;
import CMPPSubmitResponse;

import CMPPDeliver;
import CMPPDeliverResponse;

import CMPPQuery;
import CMPPQueryResponse;

import CMPPCancel;
import CMPPCancelResponse;

public class CMPPRequest extends CMPPThread
{
	//通讯层
	protected CMPPSynchronizedIO m_synio = null;
	protected CMPPAsynchronizedIO m_asynio = null;
	
	public CMPPRequest(CMPPSynchronizedIO synio,CMPPAsynchronizedIO asynio)
		throws CMPPException
	{	
		if(synio == null)
		{
			throw new CMPPException("CMPPRequest.CMPPRequest : null synchronized io !");
		}
		m_synio = synio;
		
		if(asynio == null)
		{
			throw new CMPPException("CMPPRequest.CMPPRequest : null asynchronized io !");
		}
		m_asynio = asynio;
	}
	
	public CMPPTerminateResponse request(CMPPTerminate terminate,long lTimeout)
	{
		CMPPTerminateResponse response = null;
		
		try
		{
			//检查有效性
			if(!terminate.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid terminate request !");
			}
			
			//数据打包
			terminate.wrap();
			
			//输出请求
			m_synio.write(terminate);
			
			//等待响应
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			long lStartTime = System.currentTimeMillis();
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_synio.read();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_TERMINATE_RESPONSE)
				{
					if(packet.sequence_id == terminate.sequence_id)
					{
						bReceived = true;
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : null response packet !");
			}
			
			//无效的回应
			if(packet.command_id != CMPPCommandID.CMPP_TERMINATE_RESPONSE ||
				packet.sequence_id != terminate.sequence_id)
			{
				throw new CMPPException("CMPPRequest.request : invalid terminate response !");
			}

			//获得响应数据包
			response = new CMPPTerminateResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid terminate response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}
	
	public CMPPConnectResponse request(CMPPConnect connect,long lTimeout)
	{
		CMPPConnectResponse response = null;
		
		try
		{
			//检查有效性
			if(!connect.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid connect request !");
			}
			
			//数据打包
			connect.wrap();
			
			//输出请求
			m_synio.write(connect);
			
			//等待响应
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			long lStartTime = System.currentTimeMillis();
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_synio.read();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_CONNECT_RESPONSE)
				{
					if(packet.sequence_id == connect.sequence_id)
					{
						bReceived = true;
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : null response packet !");
			}
			
			//无效的回应
			if(packet.command_id != CMPPCommandID.CMPP_CONNECT_RESPONSE ||
				packet.sequence_id != connect.sequence_id)
			{
				throw new CMPPException("CMPPRequest.request : invalid connect response !");
			}

			//获得响应数据包
			response = new CMPPConnectResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid connect response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}
	
	public CMPPActiveTestResponse request(CMPPActiveTest activetest,long lTimeout)
	{
		CMPPActiveTestResponse response = null;
		
		try
		{
			//检查有效性
			if(!activetest.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid activetest request !");
			}
			
			//数据打包
			activetest.wrap();
			
			long lStartTime = System.currentTimeMillis();
			
			//输出请求
			if(!m_asynio.write(activetest))
			{
				throw new CMPPException("CMPPRequest.request : activetest request lost !");
			}
			
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_asynio.peer();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_ACTIVETEST_RESPONSE)
				{
					if(packet.sequence_id == activetest.sequence_id)
					{
						bReceived = true;
						packet = m_asynio.read();
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : activetest request timeout !");
			}

			//获得响应数据包
			response = new CMPPActiveTestResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid activetest response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}

	public CMPPSubmitResponse request(CMPPSubmit submit,long lTimeout)
	{
		CMPPSubmitResponse response = null;
		
		try
		{
			//检查有效性
			if(!submit.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid submit request !");
			}
			
			//数据打包
			submit.wrap();
			
			long lStartTime = System.currentTimeMillis();
			
			//输出请求
			if(!m_asynio.write(submit))
			{
				throw new CMPPException("CMPPRequest.request : submit request lost !");
			}
			
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_asynio.peer();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_SUBMIT_RESPONSE)
				{
					if(packet.sequence_id == submit.sequence_id)
					{
						bReceived = true;
						packet = m_asynio.read();
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : submit request timeout !");
			}

			//获得响应数据包
			response = new CMPPSubmitResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid submit response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}
	
	public CMPPDeliverResponse request(CMPPDeliver deliver,long lTimeout)
	{
		CMPPDeliverResponse response = null;
		
		try
		{
			//检查有效性
			if(!deliver.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid deliver request !");
			}
			
			//数据打包
			deliver.wrap();
			
			long lStartTime = System.currentTimeMillis();
			
			//输出请求
			if(!m_asynio.write(deliver))
			{
				throw new CMPPException("CMPPRequest.request : deliver request lost !");
			}
			
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_asynio.peer();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_DELIVER_RESPONSE)
				{
					if(packet.sequence_id == deliver.sequence_id)
					{
						bReceived = true;
						packet = m_asynio.read();
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : deliver request timeout !");
			}

			//获得响应数据包
			response = new CMPPDeliverResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid deliver response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}
	
	public CMPPCancelResponse request(CMPPCancel cancel,long lTimeout)
	{
		CMPPCancelResponse response = null;
		
		try
		{
			//检查有效性
			if(!cancel.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid cancel request !");
			}
			
			//数据打包
			cancel.wrap();
			
			long lStartTime = System.currentTimeMillis();
			
			//输出请求
			if(!m_asynio.write(cancel))
			{
				throw new CMPPException("CMPPRequest.request : cancel request lost !");
			}
			
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_asynio.peer();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_CANCEL_RESPONSE)
				{
					if(packet.sequence_id == cancel.sequence_id)
					{
						bReceived = true;
						packet = m_asynio.read();
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : cancel request timeout !");
			}

			//获得响应数据包
			response = new CMPPCancelResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid cancel response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}

	public CMPPQueryResponse request(CMPPQuery query,long lTimeout)
	{
		CMPPQueryResponse response = null;
		
		try
		{
			//检查有效性
			if(!query.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid query request !");
			}
			
			//数据打包
			query.wrap();
			
			long lStartTime = System.currentTimeMillis();
			
			//输出请求
			if(!m_asynio.write(query))
			{
				throw new CMPPException("CMPPRequest.request : query request lost !");
			}
			
			CMPPPacket packet = null;
			boolean bReceived = false;
			
			while((System.currentTimeMillis() - lStartTime) < lTimeout)
			//等待回应
			{
				packet = m_asynio.peer();
				
				if(packet == null)
					continue;
				
				if(packet.command_id == CMPPCommandID.CMPP_QUERY_RESPONSE)
				{
					if(packet.sequence_id == query.sequence_id)
					{
						bReceived = true;
						packet = m_asynio.read();
						
						break;
					}
				}
			}
			
			if(!bReceived)
			{
				throw new CMPPException("CMPPRequest.request : query request timeout !");
			}

			//获得响应数据包
			response = new CMPPQueryResponse(packet);

			//解开数据包
			response.unwrap();
			
			//检查有效性
			if(!response.isValid())
			{
				throw new CMPPException("CMPPRequest.request : invalid query response !");
			}
			
			return response;
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPRequest.request : unexpected exit !",
				CMPPLog.LOG_CMPP_REQUEST | LogRequest.LOG_EXCEPTION);
		}
		
		return null;
	}
}