先上传Socket通讯相关代码 密码卡相关代码

zuoxiao

2024-03-04 4d2d9239d8915a030bb84cb2147774470b04bf27

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package com.easysocket;
 
import com.easysocket.config.EasySocketOptions;
import com.easysocket.connection.connect.SuperConnection;
import com.easysocket.connection.connect.TcpConnection;
import com.easysocket.entity.SocketAddress;
import com.easysocket.interfaces.config.IConnectionSwitchListener;
import com.easysocket.interfaces.conn.IConnectionManager;
import com.easysocket.utils.LogUtil;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * Author：Alex
 * Date：2019/6/4
 * Note：socket连接管理器
 */
public class ConnectionHolder {
 
    private volatile Map<String, IConnectionManager> mConnectionManagerMap = new HashMap<>();
 
 
    private static class InstanceHolder {
        private static final ConnectionHolder INSTANCE = new ConnectionHolder();
    }
 
    public static ConnectionHolder getInstance() {
        return InstanceHolder.INSTANCE;
    }
 
    private ConnectionHolder() {
        mConnectionManagerMap.clear();
    }
 
    /**
     * 移除某个连接
     *
     * @param socketAddress
     */
    public void removeConnection(SocketAddress socketAddress) {
        removeConnection(createKey(socketAddress));
    }
 
    public void removeConnection(String socketAddress) {
        mConnectionManagerMap.remove(socketAddress);
    }
 
    /**
     * 获取指定SocketAddress的连接，参数配置使用默认的
     *
     * @param address
     * @return
     */
    public IConnectionManager getConnection(SocketAddress address) {
        return getConnection(createKey(address));
    }
 
    public IConnectionManager getConnection(String address) {
        IConnectionManager manager = mConnectionManagerMap.get(address);
        if (manager == null) {
            return getConnection(address, EasySocketOptions.getDefaultOptions());
        } else {
            return getConnection(address, manager.getOptions());
        }
    }
 
    /**
     * 获取指定SocketAddress的连接
     *
     * @param address
     * @param socketOptions
     * @return
     */
    public IConnectionManager getConnection(SocketAddress address, EasySocketOptions socketOptions) {
        return getConnection(createKey(address),socketOptions);
    }
 
    public IConnectionManager getConnection(String address, EasySocketOptions socketOptions) {
        IConnectionManager manager = mConnectionManagerMap.get(address);
        if (manager != null) { // 有缓存
            manager.setOptions(socketOptions);
            return manager;
        } else {
            return createNewManagerAndCache(address, socketOptions);
        }
    }
 
    /**
     * 创建新的连接并缓存
     *
     * @param address
     * @param socketOptions
     * @return
     */
    private IConnectionManager createNewManagerAndCache(SocketAddress address, EasySocketOptions socketOptions) {
        SuperConnection manager = new TcpConnection(address); // 创建连接管理器
        manager.setOptions(socketOptions); // 设置参数
        // 连接主机的切换监听
        manager.setOnConnectionSwitchListener(new IConnectionSwitchListener() {
            @Override
            public void onSwitchConnectionInfo(IConnectionManager manager, SocketAddress oldAddress,
                                               SocketAddress newAddress) {
                // 切换了另外一个主机的连接，删除旧的连接和添加新的连接
                synchronized (mConnectionManagerMap) {
                    // 首先断开连接，销毁相关线程和资源
                    LogUtil.d("---> 首先断开连接，销毁相关线程和资源");
                    mConnectionManagerMap.get(createKey(oldAddress)).disconnect(false);
                    mConnectionManagerMap.remove(createKey(oldAddress));
                    mConnectionManagerMap.put(createKey(newAddress), manager);
                }
            }
        });
 
        synchronized (mConnectionManagerMap) {
            mConnectionManagerMap.put(createKey(address), manager);
        }
        return manager;
    }
 
    private IConnectionManager createNewManagerAndCache(String address, EasySocketOptions socketOptions) {
        return createNewManagerAndCache(createSocketAddress(address), socketOptions);
    }
 
    /**
     * @param socketAddress
     * @return
     */
    private String createKey(SocketAddress socketAddress) {
        return socketAddress.getIp() + ":" + socketAddress.getPort();
    }
 
    private SocketAddress createSocketAddress(String address) {
        String[] s = address.split(":");
        return new SocketAddress(s[0], Integer.parseInt(s[1]));
    }
 
}