zhubaomin
2 天以前 b2abd25927c39e849e592f1abdc08879d8d35245
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
213
214
215
216
217
218
219
220
221
222
223
224
225
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";
 
    public static final String ContextComSend = "/rtuMw/com/send";
 
    public static final String ContextRtuLogFile = "/rtuMw/com/rtuLogFile";
    public static final String ContextRtuLogText = "/rtuMw/com/rtuLogText";
 
    public static final String ContextRegisterMsReceiverWebUrl = "/rtuMw/com/registerMsReceiverWebUrl";
    public static final String ContextUgTaskSend = "/rtuMw/com/upgradeRtu";
    public static final String ContextUgForceOver = "/rtuMw/com/ugForceOver";
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @return
     */
    public String get2MwUrl(Environment env) {
        return env.getProperty(pro_mw + "." + DataSourceContext.get() + "." + pro_url);
    }
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @param orgTag
     * @return
     */
    public String get2MwUrl(Environment env, String orgTag) {
        return env.getProperty(pro_mw + "." + orgTag + "." + pro_url);
    }
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @param context
     * @return
     */
    public String get2MwRequestUrl(Environment env, String context) {
        return get2MwUrl(env) + context;
    }
    /**
     * 得到向通信中间件发送数据的URL
     * @param env
     * @param orgTag
     * @param context
     * @return
     */
    public String get2MwRequestUrl(Environment env, String orgTag, String context) {
        return get2MwUrl(env, orgTag) + context;
    }
 
    /**
     * 向通信中间件发送Post请求
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param body 数据
     * @return
     */
    public 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> resEntity = null;
        try {
            // 通过Post方式调用接口
            resEntity = restTemplate.exchange(url, HttpMethod.POST, httpEntity, BaseResponse.class);
        } catch (Exception e) {
            e.printStackTrace();
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }
        if(resEntity == null){
            return BaseResponseUtils.buildError("后端系统出错,中间件调用异常");
        }else{
            return resEntity.getBody();
        }
    }
 
    /**
     * 向通信中间件发送Get请求
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @return
     */
    public BaseResponse sendGetRequest2Mw(RestTemplate restTemplate, String toMwUrl) {
        return sendGetRequest2Mw(restTemplate, toMwUrl, null);
    }
 
    /**
     * 向通信中间件发送Get请求
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param paramName 参数名称
     * @param paramValue 参数
     * @return
     */
    public 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);
    }
 
    /**
     * 向通信中间件发送Get请求
     * @param restTemplate SpringBoot的RestTemplate
     * @param toMwUrl 到通信中间件的web请求Url
     * @param params 参数集合,参数名称是key,参数是value
     * @return
     */
    public 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);
    }
 
    /**
     * 向通信中间件发送Get请求
     * @param restTemplate SpringBoot的RestTemplate
     * @param builder
     * @return
     */
    public 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
     */
    public 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
     */
    public Command createOuterTransparentCommand(String comId, String code) {
        Command com = new Command();
        com.id = comId;
        com.code = code ;
        com.type = CommandType.outerTransCommand;
        return com ;
    }
 
    /**
     * 创建内部命令
     * @param code 命令code
     * @return
     */
    public Command createInnerCommand(String code) {
        Command com = new Command();
        com.id = Command.defaultId;
        com.code = code ;
        com.type = CommandType.innerCommand;
        return com ;
    }
 
}