package com.walker.tcp.support;
|
|
import com.walker.db.page.GenericPager;
|
import com.walker.infrastructure.utils.StringUtils;
|
import com.walker.security.SystemLogMan;
|
import com.walker.tcp.Connection;
|
import com.walker.tcp.ConnectionCache;
|
import com.walker.tcp.ConnectionManager;
|
import com.walker.tcp.connect.AbstractConnection;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
public abstract class AbstractConnectionManager implements ConnectionManager {
|
|
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
|
|
public static final String TIP_NULL_CONNECTION = "不能放入空connection";
|
// public static final String TIP_WARN_IDINDEX = "缓存中该连接id不存在：idList.get(i)。i = ";
|
|
private boolean multipleEngine = false;
|
|
// 连接缓存，key = sessionId, value = Connection
|
// private final Map<String, Connection> cached = new ConcurrentHashMap<>(128);
|
|
// 通道ID与绑定用户名称的对应关系，key = 绑定业务名称，value = 通道ID
|
// private Map<String, String> idNameCached = new HashMap<>(128);
|
|
// 存放连接id集合，用于分页显示
|
// private LinkedList<String> idList = new LinkedList<>();
|
// private Map<String, Integer> idIndex = new HashMap<>(128);
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
// 连接类型，时克英修改，2018-09-20
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
private Map<Integer, String> connectionTypeCache = new ConcurrentHashMap<Integer, String>();
|
|
public void setConnectionTypeMap(Map<Integer, String> connectionTypes){
|
if(connectionTypes != null){
|
this.connectionTypeCache = connectionTypes;
|
}
|
SystemLogMan.getInstance().checkMan();
|
}
|
|
public void setMultipleEngine(boolean multipleEngine) {
|
this.multipleEngine = multipleEngine;
|
}
|
|
@Override
|
public boolean isSupportMultipleEngine(){
|
return multipleEngine;
|
}
|
|
@Override
|
public void putConnection(Connection connection){
|
if(connection == null){
|
throw new IllegalArgumentException(TIP_NULL_CONNECTION);
|
}
|
|
// String id = connection.getId();
|
String name = connection.getName();
|
// 必须在认证时候才能创建缓存连接对象！
|
if(StringUtils.isEmpty(name)){
|
throw new IllegalArgumentException("connection对象未设置name属性，业务将无法使用");
|
// logger.warn("连接已设置，但还未绑定业务id，后续会有绑定操作，可忽略。");
|
}
|
|
// 2023-09-19，调整使用连接缓存对象。
|
/* if(idNameCached.get(name) != null){
|
logger.warn("终端设备在未断开连接的情况下，重新登录注册：" + name);
|
// throw new IllegalArgumentException("现有连接中已经存在该名称，无法重复缓存同名连接");
|
|
*//** 注意：这里的ID是原来老的connection的ID，不是新ID *//*
|
doRemoveCacheInfo(idNameCached.get(name), connection);
|
}
|
cached.put(id, connection);
|
idNameCached.put(name, id);*/
|
String oldId = this.connectionCache.getIdByName(name);
|
if(StringUtils.isNotEmpty(oldId)){
|
logger.warn("终端设备在未断开连接的情况下，重新登录注册：" + name + ", 删除老连接：" + oldId);
|
this.connectionCache.removeConnection(oldId);
|
}
|
this.connectionCache.putConnection(connection);
|
|
// 维护分页信息
|
// idIndex.put(id, idList.size());
|
// idList.add(id);
|
|
try {
|
this.onSaveConnection(connection);
|
} catch (Exception e) {
|
logger.error("业务调用持久化连接错误:" + e.getMessage(), e);
|
}
|
}
|
|
// /**
|
// * 从缓存中删除连接信息，包括：索引和分页信息
|
// * @param id
|
// * @param conn
|
// */
|
// private void doRemoveCacheInfo(String id, Connection conn){
|
// if(conn != null){
|
// idNameCached.remove(conn.getName());
|
// }
|
// cached.remove(id);
|
// }
|
|
@Override
|
public void updateConnection(String id, Connection connection){
|
if(connection == null){
|
throw new IllegalArgumentException(TIP_NULL_CONNECTION);
|
}
|
((AbstractConnection)connection).setLastTime(System.currentTimeMillis());
|
// 2023-09-19，调整使用连接缓存对象。
|
// cached.put(id, connection);
|
this.connectionCache.updateConnection(connection);
|
|
try {
|
this.onUpdateConnection(connection); // 2023-09-25
|
this.onUpdateLastTime(connection.getEngineId(), connection.getName(), connection.getLastTime());
|
} catch (Exception e) {
|
logger.error("业务更新持久化连接错误:" + e.getMessage(), e);
|
}
|
}
|
|
@Override
|
public void removeConnection(String id){
|
// Connection conn = cached.get(id);
|
Connection conn = this.connectionCache.getConnection(id);
|
// doRemoveCacheInfo(id, conn);
|
if(conn != null){
|
try {
|
this.onDeleteConnection(conn.getEngineId(), conn.getName());
|
} catch (Exception e) {
|
logger.error("业务删除持久化连接错误:" + e.getMessage(), e);
|
}
|
}
|
this.connectionCache.removeConnection(id);
|
}
|
|
@Override
|
public void removeConnectionByName(String name){
|
if(StringUtils.isEmpty(name)){
|
throw new IllegalArgumentException("name is required!");
|
}
|
|
// String id = idNameCached.get(name) ;
|
String id = this.connectionCache.getIdByName(name);
|
if(id == null){
|
logger.warn("根据终端名称查找通道ID错误：未找到name=" + name);
|
return;
|
}
|
|
// Connection conn = cached.get(id);
|
// doRemoveCacheInfo(id, conn);
|
this.connectionCache.removeConnection(id);
|
|
// 2023-09-25，为负载修改
|
try {
|
this.onDeleteConnection(0, name);
|
} catch (Exception e) {
|
logger.error("业务删除持久化连接错误:" + e.getMessage() + ", name=" + name, e);
|
}
|
}
|
|
@Override
|
public void updateLastTime(String id){
|
// Connection conn = cached.get(id);
|
Connection conn = this.connectionCache.getConnection(id);
|
if(conn != null){
|
((AbstractConnection)conn).setLastTime(System.currentTimeMillis());
|
}
|
}
|
|
@Override
|
public Connection getConnection(String id){
|
// return cached.get(id);
|
return this.connectionCache.getConnection(id);
|
}
|
|
@Override
|
public void putConnection(int engineId, Connection connection){
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public void updateConnection(int engineId, String id, Connection connection){
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public void removeConnection(int engineId, String id){
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public void updateLastTime(int engineId, String id){
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public Connection getConnection(int engineId, String id){
|
throw new UnsupportedOperationException();
|
}
|
|
@Deprecated
|
@Override
|
public GenericPager<Connection> queryPageConnectionList(int pageIndex, int pageSize){
|
// GenericPager<Connection> pager = ListPageContext.createGenericPager(pageIndex, pageSize, cached.size());
|
// List<Connection> datas = new ArrayList<>();
|
// long total = pager.getTotalRows();
|
//
|
// if(total > 0){
|
// long firstDataIndex = pager.getFirstRowIndexInPage();
|
// long endDataIndex = pager.getEndRowIndexPage();
|
// String id = null;
|
// for(long i=firstDataIndex; i<endDataIndex+1; i++){
|
// id = idList.get((int)i);
|
// if(StringUtils.isEmpty(id)){
|
// logger.warn(TIP_WARN_IDINDEX + i);
|
// continue;
|
// }
|
// datas.add(cached.get(id));
|
// }
|
// }
|
//
|
// pager.setDatas(datas);
|
// return pager;
|
throw new UnsupportedOperationException();
|
}
|
|
/**
|
* 负载环境中，仍然可以从服务端发送心跳，只是每个节点只发送自己连接的客户端而已。
|
* @return
|
* @date 2023-09-25
|
*/
|
@Override
|
public List<Connection> queryAllConnectionList(){
|
// List<Connection> result = new ArrayList<>();
|
// for(Connection conn : cached.values()){
|
// result.add(conn);
|
// }
|
// return result;
|
return this.connectionCache.getAllConnectionList();
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
// 根据engineId，返回某一类连接集合
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
@Override
|
public Map<Integer, String> getConnectionTypeMap(){
|
return this.connectionTypeCache;
|
}
|
|
@Override
|
public String getConnectionTypeName(int engineId){
|
return this.connectionTypeCache.get(engineId);
|
}
|
|
@Override
|
public List<Connection> queryAllConnectionListBy(int engineId){
|
List<Connection> result = new ArrayList<>();
|
// for(Connection conn : cached.values()){
|
for(Connection conn : this.connectionCache.getAllConnectionList()){
|
if(conn.getEngineId() == engineId){
|
result.add(conn);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 根据业务名称，返回连接对象。如：设备编号ID
|
* @param name
|
* @return
|
*/
|
@Override
|
public Connection getConnectionByName(String name){
|
// String id = idNameCached.get(name);
|
// if(StringUtils.isNotEmpty(id)){
|
// return cached.get(id);
|
// }
|
// return null;
|
return this.connectionCache.getConnectionByName(name);
|
}
|
|
/**
|
* 在系统创建完连接时，提供业务回调，例如：把连接数据保存到数据库中。
|
* @param connection
|
*/
|
protected abstract void onSaveConnection(Connection connection) throws Exception;
|
|
/**
|
* 在系统创建完连接时，提供业务回调
|
* @param engineId
|
* @param id
|
*/
|
protected abstract void onDeleteConnection(int engineId, String id) throws Exception;
|
|
/**
|
* 在系统创建完连接时，提供业务回调
|
* @param engineId 引擎id
|
* @param id 连接名称
|
* @param lastTime 最后一次更新时间
|
*/
|
protected abstract void onUpdateLastTime(int engineId, String id, long lastTime) throws Exception;
|
|
/**
|
* 更新底层链路连接时，触发方法，子类实现。
|
* @param connection
|
* @throws Exception
|
* @date 2023-09-25
|
*/
|
protected abstract void onUpdateConnection(Connection connection) throws Exception;
|
|
public ConnectionCache getConnectionCache() {
|
return connectionCache;
|
}
|
|
public void setConnectionCache(ConnectionCache connectionCache) {
|
this.connectionCache = connectionCache;
|
}
|
|
private ConnectionCache connectionCache;
|
}
|
