package com.zy.common.HslCommunication.Core.Net.NetworkBase;
|
|
import com.zy.common.HslCommunication.BasicFramework.SoftBasic;
|
import com.zy.common.HslCommunication.Core.IMessage.INetMessage;
|
import com.zy.common.HslCommunication.Core.Net.StateOne.AlienSession;
|
import com.zy.common.HslCommunication.Core.Transfer.ByteTransformHelper;
|
import com.zy.common.HslCommunication.Core.Transfer.IByteTransform;
|
import com.zy.common.HslCommunication.Core.Types.OperateResult;
|
import com.zy.common.HslCommunication.Core.Types.OperateResultExOne;
|
import com.zy.common.HslCommunication.Core.Types.OperateResultExTwo;
|
import com.zy.common.HslCommunication.StringResources;
|
|
import java.lang.reflect.ParameterizedType;
|
import java.net.Socket;
|
import java.util.concurrent.locks.Lock;
|
import java.util.concurrent.locks.ReentrantLock;
|
|
/**
|
* 双模式的客户端基类，
|
* @param <TNetMessage> 消息类的类型
|
* @param <TTransform> 转换类的类型
|
*/
|
public class NetworkDoubleBase<TNetMessage extends INetMessage ,TTransform extends IByteTransform> extends NetworkBase
|
{
|
/**
|
* 默认的无参构造函数
|
*/
|
public NetworkDoubleBase( )
|
{
|
queueLock = new ReentrantLock(); // 实例化数据访问锁
|
byteTransform = getInstanceOfTTransform(); // 实例化数据转换规则
|
connectionId = SoftBasic.GetUniqueStringByGuidAndRandom( );
|
}
|
|
|
|
private TTransform byteTransform; // 数据变换的接口
|
private String ipAddress = "127.0.0.1"; // 连接的IP地址
|
private int port = 10000; // 端口号
|
private int connectTimeOut = 10000; // 连接超时时间设置
|
private int receiveTimeOut = 10000; // 数据接收的超时时间
|
private boolean isPersistentConn = false; // 是否处于长连接的状态
|
private Lock queueLock = null; // 数据访问的同步锁
|
private boolean IsSocketError = false; // 指示长连接的套接字是否处于错误的状态
|
private boolean isUseSpecifiedSocket = false; // 指示是否使用指定的网络套接字访问数据
|
private String connectionId = ""; // 当前连接
|
|
|
|
private TTransform getInstanceOfTTransform( )
|
{
|
ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
|
Class<TTransform> type = (Class<TTransform>) superClass.getActualTypeArguments()[1];
|
try
|
{
|
return type.newInstance();
|
}
|
catch (Exception e)
|
{
|
throw new RuntimeException(e);
|
}
|
}
|
|
|
private TNetMessage getInstanceOfTNetMessage( )
|
{
|
ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
|
Class<TNetMessage> type = (Class<TNetMessage>) superClass.getActualTypeArguments()[0];
|
try
|
{
|
return type.newInstance();
|
}
|
catch (Exception e)
|
{
|
// Oops, no default constructor
|
throw new RuntimeException(e);
|
}
|
}
|
|
|
|
|
/**
|
* 获取数据变换机制
|
* @return
|
*/
|
public TTransform getByteTransform( ){
|
return byteTransform;
|
}
|
|
/**
|
* 设置数据变换机制
|
* @param transform 数据变换
|
*/
|
public void setByteTransform(TTransform transform)
|
{
|
byteTransform = transform;
|
}
|
|
/**
|
* 获取连接的超时时间
|
*/
|
public int getConnectTimeOut( ){
|
return connectTimeOut;
|
}
|
|
/**
|
* 设置连接的超时时间
|
* @param connectTimeOut 超时时间，单位是秒
|
*/
|
public void setConnectTimeOut(int connectTimeOut) {
|
this.connectTimeOut = connectTimeOut;
|
}
|
|
|
/**
|
* 获取接收服务器反馈的时间，如果为负数，则不接收反馈
|
* @return
|
*/
|
public int getReceiveTimeOut( ){
|
return receiveTimeOut;
|
}
|
|
/**
|
* 设置接收服务器反馈的时间，如果为负数，则不接收反馈
|
* @param receiveTimeOut
|
*/
|
public void setReceiveTimeOut(int receiveTimeOut){
|
this.receiveTimeOut = receiveTimeOut;
|
}
|
|
|
/**
|
* 获取服务器的IP地址
|
* @return Ip地址信息
|
*/
|
public String getIpAddress() {
|
return ipAddress;
|
}
|
|
|
/**
|
* 设置服务器的IP地址
|
* @param ipAddress IP地址
|
*/
|
public void setIpAddress(String ipAddress) {
|
if(!ipAddress.isEmpty()){
|
this.ipAddress = ipAddress;
|
}
|
}
|
|
|
/**
|
* 获取服务器的端口
|
* @return 端口
|
*/
|
public int getPort() {
|
return port;
|
}
|
|
|
/**
|
* 设置服务器的端口号
|
* @param port 端口号
|
*/
|
public void setPort(int port) {
|
this.port = port;
|
}
|
|
/**
|
* 当前连接的唯一ID号，默认为长度20的guid码加随机数组成，也可以自己指定
|
* @return
|
*/
|
public String getConnectionId() {
|
return connectionId;
|
}
|
|
/**
|
* 设置当前的连接ID
|
* @param connectionId
|
*/
|
public void setConnectionId(String connectionId) {
|
this.connectionId = connectionId;
|
}
|
|
|
|
/**
|
* 当前的异形连接对象，如果设置了异性连接的话
|
*/
|
public AlienSession AlienSession = null;
|
|
|
|
/**
|
* 在读取数据之前可以调用本方法将客户端设置为长连接模式，相当于跳过了ConnectServer的结果验证，对异形客户端无效
|
*/
|
public void SetPersistentConnection( )
|
{
|
isPersistentConn = true;
|
}
|
|
|
/**
|
* 切换短连接模式到长连接模式，后面的每次请求都共享一个通道
|
* @return 返回连接结果，如果失败的话（也即IsSuccess为False），包含失败信息
|
*/
|
public OperateResult ConnectServer( )
|
{
|
isPersistentConn = true;
|
OperateResult result = new OperateResult( );
|
|
// 重新连接之前，先将旧的数据进行清空
|
CloseSocket(CoreSocket);
|
|
OperateResultExOne<Socket> rSocket = CreateSocketAndInitialication( );
|
|
if (!rSocket.IsSuccess)
|
{
|
IsSocketError = true; // 创建失败
|
rSocket.Content = null;
|
result.Message = rSocket.Message;
|
}
|
else
|
{
|
CoreSocket = rSocket.Content; // 创建成功
|
result.IsSuccess = true;
|
if(LogNet != null) LogNet.WriteDebug( toString( ), StringResources.Language.NetEngineStart() );
|
}
|
|
return result;
|
}
|
|
|
|
/**
|
* 使用指定的套接字创建异形客户端
|
* @param session 会话
|
* @return 通常都为成功
|
*/
|
public OperateResult ConnectServer( AlienSession session )
|
{
|
isPersistentConn = true;
|
isUseSpecifiedSocket = true;
|
|
|
if (session != null)
|
{
|
if(AlienSession != null ) CloseSocket(AlienSession.getSocket());
|
|
if (connectionId.isEmpty())
|
{
|
connectionId = session.getDTU();
|
}
|
|
if (connectionId == session.getDTU())
|
{
|
CoreSocket = session.getSocket();
|
IsSocketError = false;
|
AlienSession = session;
|
return InitializationOnConnect( session.getSocket() );
|
}
|
else
|
{
|
IsSocketError = true;
|
return new OperateResult( );
|
}
|
}
|
else
|
{
|
IsSocketError = true;
|
return new OperateResult( );
|
}
|
}
|
|
|
|
/**
|
* 在长连接模式下，断开服务器的连接，并切换到短连接模式
|
* @return 关闭连接，不需要查看IsSuccess属性查看
|
*/
|
public OperateResult ConnectClose( )
|
{
|
OperateResult result = new OperateResult( );
|
isPersistentConn = false;
|
|
queueLock.lock();
|
|
// 额外操作
|
result = ExtraOnDisconnect( CoreSocket );
|
// 关闭信息
|
if(CoreSocket != null ) CloseSocket(CoreSocket);
|
CoreSocket = null;
|
|
queueLock.unlock();
|
|
if(LogNet != null ) LogNet.WriteDebug( toString( ), StringResources.Language.NetEngineClose() );
|
return result;
|
}
|
|
|
/**
|
* 在连接的时候进行初始化
|
* @param socket 网络套接字
|
* @return 结果类对象
|
*/
|
protected OperateResult InitializationOnConnect( Socket socket ) {
|
return OperateResult.CreateSuccessResult();
|
}
|
|
|
/**
|
* 在将要和服务器进行断开的情况下额外的操作
|
* @param socket 网络套接字
|
* @return 结果类对象
|
*/
|
protected OperateResult ExtraOnDisconnect( Socket socket ) {
|
return OperateResult.CreateSuccessResult();
|
}
|
|
|
/***************************************************************************************
|
*
|
* 主要的数据交互分为4步
|
* 1. 连接服务器，或是获取到旧的使用的网络信息
|
* 2. 发送数据信息
|
* 3. 接收反馈的数据信息
|
* 4. 关闭网络连接，如果是短连接的话
|
*
|
**************************************************************************************/
|
|
|
/**
|
* 获取本次操作的可用的网络套接字
|
* @return 是否成功，如果成功，使用这个套接字
|
*/
|
private OperateResultExOne<Socket> GetAvailableSocket( ) {
|
// 是否处于长连接的状态
|
if (isPersistentConn) {
|
// 如果是异形模式
|
if (isUseSpecifiedSocket) {
|
// 指示长连接的套接字是否处于错误的状态
|
if(IsSocketError) {
|
OperateResultExOne<Socket> rSocket = new OperateResultExOne<>();
|
rSocket.Message = "连接不可用";
|
return rSocket;
|
} else {
|
return OperateResultExOne.CreateSuccessResult( CoreSocket );
|
}
|
} else {
|
// 长连接模式
|
if (IsSocketError || CoreSocket == null) {
|
OperateResult connect = ConnectServer( );
|
if (!connect.IsSuccess) {
|
IsSocketError = true;
|
OperateResultExOne<Socket> rSocket = new OperateResultExOne<>();
|
rSocket.Message = connect.Message;
|
rSocket.ErrorCode = connect.ErrorCode;
|
return rSocket;
|
} else {
|
IsSocketError = false;
|
return OperateResultExOne.CreateSuccessResult( CoreSocket );
|
}
|
} else {
|
return OperateResultExOne.CreateSuccessResult( CoreSocket );
|
}
|
}
|
|
} else {
|
// 短连接模式
|
return CreateSocketAndInitialication( );
|
}
|
}
|
|
|
|
/**
|
* 连接并初始化网络套接字
|
* @return 最终的连接对象
|
*/
|
private OperateResultExOne<Socket> CreateSocketAndInitialication( )
|
{
|
OperateResultExOne<Socket> result = CreateSocketAndConnect( ipAddress , port , connectTimeOut );
|
if (result.IsSuccess)
|
{
|
// 初始化
|
OperateResult initi = InitializationOnConnect( result.Content );
|
if (!initi.IsSuccess)
|
{
|
CloseSocket(result.Content);
|
result.IsSuccess = initi.IsSuccess;
|
result.CopyErrorFromOther( initi );
|
}
|
}
|
return result;
|
}
|
|
|
/**
|
* 在其他指定的套接字上，使用报文来通讯，传入需要发送的消息，返回一条完整的数据指令
|
* @param socket 指定的套接字
|
* @param send 发送的完整的报文信息
|
* @return 接收的完整的报文信息
|
*/
|
public OperateResultExOne<byte[]> ReadFromCoreServer( Socket socket, byte[] send )
|
{
|
OperateResultExOne<byte[]> result = new OperateResultExOne<byte[]>( );
|
|
OperateResultExTwo<byte[], byte[]> read = ReadFromCoreServerBase( socket, send );
|
if (read.IsSuccess)
|
{
|
result.IsSuccess = read.IsSuccess;
|
result.Content = new byte[read.Content1.length + read.Content2.length];
|
if (read.Content1.length > 0) System.arraycopy(read.Content1,0,result.Content,0,read.Content1.length);
|
if (read.Content2.length > 0) System.arraycopy(read.Content2,0,result.Content,read.Content1.length,read.Content2.length);
|
}
|
else
|
{
|
result.CopyErrorFromOther( read );
|
}
|
return result;
|
}
|
|
|
|
/**
|
* 使用底层的数据报文来通讯，传入需要发送的消息，返回一条完整的数据指令
|
* @param send 发送的完整的报文信息
|
* @return 接收的完整的报文信息
|
*/
|
public OperateResultExOne<byte[]> ReadFromCoreServer( byte[] send )
|
{
|
OperateResultExOne<byte[]> result = new OperateResultExOne<byte[]>( );
|
// string tmp1 = BasicFramework.SoftBasic.ByteToHexString( send, '-' );
|
|
queueLock.lock( );
|
|
// 获取有用的网络通道，如果没有，就建立新的连接
|
OperateResultExOne<Socket> resultSocket = GetAvailableSocket( );
|
if (!resultSocket.IsSuccess)
|
{
|
IsSocketError = true;
|
if (AlienSession != null) AlienSession.setIsStatusOk( false);
|
queueLock.unlock();
|
result.CopyErrorFromOther( resultSocket );
|
return result;
|
}
|
|
OperateResultExOne<byte[]> read = ReadFromCoreServer( resultSocket.Content, send );
|
|
if (read.IsSuccess)
|
{
|
IsSocketError = false;
|
result.IsSuccess = read.IsSuccess;
|
result.Content = read.Content;
|
// string tmp2 = BasicFramework.SoftBasic.ByteToHexString( result.Content ) ;
|
}
|
else
|
{
|
IsSocketError = true;
|
if (AlienSession != null) AlienSession.setIsStatusOk(false);
|
result.CopyErrorFromOther( read );
|
}
|
|
queueLock.unlock();
|
if (!isPersistentConn) CloseSocket(resultSocket.Content );
|
return result;
|
}
|
|
|
/**
|
* 使用底层的数据报文来通讯，传入需要发送的消息，返回最终的数据结果，被拆分成了头子节和内容字节信息
|
* @param socket 网络套接字
|
* @param send 发送的数据
|
* @return 结果对象
|
*/
|
protected OperateResultExTwo<byte[], byte[]> ReadFromCoreServerBase(Socket socket, byte[] send )
|
{
|
OperateResultExTwo<byte[], byte[]> result = new OperateResultExTwo<byte[], byte[]>( );
|
// LogNet?.WriteDebug( ToString( ), "Command: " + BasicFramework.SoftBasic.ByteToHexString( send ) );
|
TNetMessage netMsg = getInstanceOfTNetMessage();
|
netMsg.setSendBytes(send);
|
|
// 发送数据信息
|
OperateResult resultSend = Send( socket, send );
|
if (!resultSend.IsSuccess)
|
{
|
CloseSocket(socket);
|
result.CopyErrorFromOther( resultSend );
|
return result;
|
}
|
|
// 接收超时时间大于0时才允许接收远程的数据
|
if (receiveTimeOut >= 0)
|
{
|
// 接收数据信息
|
OperateResultExOne<TNetMessage> resultReceive = ReceiveMessage(socket, receiveTimeOut, netMsg);
|
if (!resultReceive.IsSuccess)
|
{
|
CloseSocket(socket );
|
result.CopyErrorFromOther( resultReceive );
|
// result.Message = "Receive data timeout: " + receiveTimeOut;
|
return result;
|
}
|
|
// 复制结果
|
result.Content1 = resultReceive.Content.getHeadBytes();
|
result.Content2 = resultReceive.Content.getContentBytes();
|
}
|
|
result.IsSuccess = true;
|
return result;
|
}
|
|
|
|
/**
|
* 返回表示当前对象的字符串
|
* @return
|
*/
|
@Override
|
public String toString( ) {
|
return "NetworkDoubleBase<TNetMessage>";
|
}
|
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Boolean> GetBoolResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetBoolResultFromBytes( result, byteTransform);
|
}
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Byte> GetByteResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetByteResultFromBytes( result, byteTransform );
|
}
|
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Short> GetInt16ResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetInt16ResultFromBytes( result, byteTransform );
|
}
|
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Integer> GetInt32ResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetInt32ResultFromBytes( result, byteTransform );
|
}
|
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Long> GetInt64ResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetInt64ResultFromBytes( result, byteTransform );
|
}
|
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Float> GetSingleResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetSingleResultFromBytes( result, byteTransform );
|
}
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<Double> GetDoubleResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetDoubleResultFromBytes( result, byteTransform );
|
}
|
|
|
/**
|
* 将指定的OperateResult类型转化
|
* @param result 原始的类型
|
* @return 转化后的类型
|
*/
|
protected OperateResultExOne<String> GetStringResultFromBytes( OperateResultExOne<byte[]> result )
|
{
|
return ByteTransformHelper.GetStringResultFromBytes( result, byteTransform );
|
}
|
|
|
|
}
|
