shikeying
2024-01-11 3b67e947e36133e2a40eb2737b15ea375e157ea0
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
package com.walker.tcp.protocol;
 
import com.walker.tcp.ProtocolException;
import com.walker.tcp.ProtocolResolver;
import com.walker.tcp.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public abstract class AbstractProtocolResolver<T> implements ProtocolResolver<T> {
 
    protected final transient Logger logger = LoggerFactory.getLogger(getClass());
 
    private String name;
 
//    private String feature;
    private Object feature;
 
    private String delimiter;
 
    private int order = 0;
 
    public int getOrder() {
        return order;
    }
 
    public void setOrder(int order) {
        this.order = order;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setProtocolFeature(Object feature) {
        this.feature = feature;
    }
 
    public void setDelimiter(String delimiter) {
        this.delimiter = delimiter;
    }
 
    @Override
    public String getName() {
        return this.name;
    }
 
    @Override
    public String getProtocolNum(T data, int size) throws ProtocolException {
        return this.onResolve(data, size);
    }
 
    @Override
//    public String getProtocolFeature() {
    public Object getProtocolFeature() {
        return this.feature;
    }
 
    @Override
    public String getDelimiter() {
        return this.delimiter;
    }
 
    /**
     * 解析具体数据协议编号
     * @param data
     * @return
     * @throws ProtocolException
     */
//    protected abstract String onResolve(String data, int size) throws ProtocolException;
    protected abstract String onResolve(T data, int size) throws ProtocolException;
 
    @Override
    public boolean isRequireFeatureResolve(){
        return false;
    }
 
    /**
     * 该方法为了在界面上让freemarker展示使用
     * @return
     */
    public boolean getRequireFeatureResolve(){
        return isRequireFeatureResolve();
    }
 
    private Response<?> heartBeatResponse = null;
 
    public Response<?> getHeartBeatResponse(){
        if(heartBeatResponse == null){
            heartBeatResponse = this.doCreateOneResponse();
        }
        return heartBeatResponse;
    }
 
    /**
     * 产生一个心跳响应对象
     * @return
     */
    protected abstract Response<?> doCreateOneResponse();
 
    private boolean permitNotRegisterConnect = false;
 
    public void setPermitNotRegisterConnect(boolean permitNotRegisterConnect) {
        this.permitNotRegisterConnect = permitNotRegisterConnect;
    }
 
    /**
     * 判断是否允许未注册设备连接平台,如果设置为false,那么该方法将配合:isRegistered()来限制未注册设备访问。</p>
     * 子类需要重新覆盖isReistered()方法。
     */
    public boolean isPermitNotRegisterConnect(){
        return permitNotRegisterConnect;
    }
 
    /**
     * 该方法返回是否终端设备已经再平台注册,如果不允许“未注册设备连接”的话,需要重写该方法,确认设备列表中是否注册有该设备
     * @param clientId
     * @return
     * @author 时克英
     * @date 2018-12-03
     */
    protected boolean isRegistered(String clientId){
        return true;
    }
 
    @Override
    public boolean isOnlyMatchFeature(){
        return false;
    }
}