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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
package com.dy.pipIrrGlobal.rtuMw;
 
import com.dy.common.multiDataSource.DataSourceContext;
import com.dy.common.mw.protocol.Command;
import com.dy.common.mw.protocol.CommandType;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.util.OrgListenerSupport;
import org.springframework.core.env.Environment;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
 
import java.util.Iterator;
import java.util.Map;
 
/**
 * @Author: liurunyu
 * @Date: 2024/10/23 11:45
 * @Description
 */
public abstract class Web2RtuMw extends OrgListenerSupport {
    /**
     * pro_mw:属性
     * tag从控制器中获取
     * key_mw:url的key
     */
    private static final String pro_mw = "mw";
    private static final String pro_url = "url";
 
    protected static final String ContextComSend = "/rtuMw/com/send";
 
    protected static final String ContextRtuLogFile = "/rtuMw/com/rtuLogFile";
    protected static final String ContextRtuLogText = "/rtuMw/com/rtuLogText";
 
    protected static final String ContextRegisterMsReceiverWebUrl = "/rtuMw/com/registerMsReceiverWebUrl";
    protected static final String ContextUgTaskSend = "/rtuMw/com/upgradeRtu";
    protected static final String ContextUgForceOver = "/rtuMw/com/ugForceOver";
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @return
     */
    protected String get2MwUrl(Environment env) {
        return env.getProperty(pro_mw + "." + DataSourceContext.get() + "." + pro_url);
    }
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @param orgTag
     * @return
     */
    protected String get2MwUrl(Environment env, String orgTag) {
        return env.getProperty(pro_mw + "." + orgTag + "." + pro_url);
    }
    /**
     * 得到向通信中间件发送强制停止升级的命令URL
     * @param env
     * @param context
     * @return
     */
    protected String get2MwRequestUrl(Environment env, String context) {
        return get2MwUrl(env) + context;
    }
    /**
     * 得到向通信中间件发送强制停止升级的命令URL
     * @param env
     * @param orgTag
     * @param context
     * @return
     */
    protected String get2MwRequestUrl(Environment env, String orgTag, String context) {
        return get2MwUrl(env, orgTag) + context;
    }
 
    /**
     * 向通信中间件发送rtu远程升级任务
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param body 请求数据
     * @return
     */
    protected BaseResponse sendPostRequest2Mw(RestTemplate restTemplate, String toMwUrl, Object body) {
        String url = UriComponentsBuilder.fromUriString(toMwUrl)
                .build()
                .toUriString();
        HttpHeaders headers = new HttpHeaders();
        HttpEntity<?> httpEntity = new HttpEntity<>(body, headers);
        ResponseEntity<BaseResponse> response = null;
        try {
            // 通过Post方式调用接口
            response = restTemplate.exchange(url, HttpMethod.POST, httpEntity, BaseResponse.class);
        } catch (Exception e) {
            e.printStackTrace();
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }
        if(response == null){
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }else{
            return response.getBody();
        }
    }
 
    /**
     * 向通信中间件发送rtu远程升级任务
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @return
     */
    protected BaseResponse sendGetRequest2Mw(RestTemplate restTemplate, String toMwUrl) {
        return sendGetRequest2Mw(restTemplate, toMwUrl, null);
    }
 
    /**
     * 向通信中间件发送rtu远程升级任务
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param paramName 参数名称
     * @param paramValue 参数
     * @return
     */
    protected BaseResponse sendGetRequest2Mw(RestTemplate restTemplate, String toMwUrl, String paramName, String paramValue) {
        String url = UriComponentsBuilder.fromUriString(toMwUrl)
                .build()
                .toUriString();
 
        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url) ;
        if(paramName != null && !paramName.trim().equals("")){
            builder.queryParam(paramName, paramValue==null?"":paramValue) ;
        }
        return sendGetRequest2Mw(restTemplate, builder);
    }
 
    /**
     * 向通信中间件发送rtu远程升级任务
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param params 参数集合,参数名称是key,参数是value
     * @return
     */
    protected BaseResponse sendGetRequest2Mw(RestTemplate restTemplate, String toMwUrl, Map<String, String> params) {
        String url = UriComponentsBuilder.fromUriString(toMwUrl)
                .build()
                .toUriString();
 
        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url) ;
        if(params != null && params.size() > 0){
            Iterator<String> it = params.keySet().iterator() ;
            String key ;
            while (it.hasNext()){
                key = it.next() ;
                builder.queryParam(key, params.get(key)) ;
            }
        }
        return sendGetRequest2Mw(restTemplate, builder);
    }
 
    /**
     * 向通信中间件发送rtu远程升级任务
     * @param restTemplate SpringBoot的RestTemplate
     * @param builder
     * @return
     */
    protected BaseResponse sendGetRequest2Mw(RestTemplate restTemplate, UriComponentsBuilder builder) {
        ResponseEntity<BaseResponse> response;
        try {
            // 通过Get方式调用接口
            response = restTemplate.exchange(builder.toUriString(),
                    HttpMethod.GET,
                    new HttpEntity<>(new HttpHeaders()),
                    BaseResponse.class);
        } catch (Exception e) {
            //e.printStackTrace();
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }
        if(response == null){
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }else{
            return response.getBody();
        }
    }
 
    /**
     * 创建外部命令(发给控制器)
     * @param code 命令code
     * @return
     */
    protected Command createOuterCommand(String comId, String code) {
        Command com = new Command();
        com.id = comId;
        com.code = code ;
        com.type = CommandType.outerCommand;
        return com ;
    }
 
    /**
     * 创建内部
     * @param code 命令code
     * @return
     */
    protected Command createInnerCommand(String code) {
        Command com = new Command();
        com.id = Command.defaultId;
        com.code = code ;
        com.type = CommandType.innerCommand;
        return com ;
    }
 
}