yangys
2025-09-19 e70c88930c51c7afeb3cc2ac72fbe6fad86a942c
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
 
package org.springblade.mdm.flow.service;
 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tool.utils.DateUtil;
import org.springblade.mdm.flow.entity.MesSync;
import org.springblade.mdm.flow.mapper.MesSyncMapper;
import org.springblade.mdm.flow.props.MesInterfaceProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
/**
 * MES固化同步 处理服务
 *
 * @author yangys
 */
@Slf4j
@Service
public class MesSyncService extends ServiceImpl<MesSyncMapper, MesSync> {
    @Autowired
    private MesInterfaceProperties mesInterfaceProperties;
    /**
     * 同步数据到mes
     */
    @Transactional
    public void syncToMes(){
        List<MesSync> syncList = lambdaQuery().ne(MesSync::getStatus,MesSync.STATUS_SUCCESS)
            .lt(mesInterfaceProperties.getMaxTryTimes()>0,MesSync::getTryTimes,mesInterfaceProperties.getMaxTryTimes())
            .last("limit 100").list();
        if(syncList.isEmpty()){
            log.info("mes同步表无数据,返回。");
            return;
        }
        JSONObject bodyJson = buildRequestJson(syncList);
        int code = postData(bodyJson);
 
        int status;
        if(code == 200){
            status = MesSync.STATUS_SUCCESS;
        }else{
            status = MesSync.STATUS_FAILED;
        }
        syncList.forEach(sync->{
            sync.setStatus(codeToStatus(code));
            sync.increaseTryTimes();
        });
        updateBatchById(syncList);
    }
 
    public int postData(JSONObject bodyJson){
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
 
        // 构建JSON请求体
        String json = bodyJson.toJSONString();
 
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(mesInterfaceProperties.getOperationUpdateEndpoint()))
            .header("Content-Type", "application/json")
            .header("Accept", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();
 
        try {
            HttpResponse<String> response = client.send(
                request, HttpResponse.BodyHandlers.ofString());
 
            log.info("mes返回状态码{}",response.statusCode());
            log.info("mes返回body{}",response.body());
 
            return response.statusCode();
 
        } catch (Exception e) {
            log.error("同步失败",e);
            return 500;
        }
    }
 
    /**
     * 构建数据体
     * @param syncList 同步数据列表
     * @return 数据jsno
     */
    JSONObject buildRequestJson(List<MesSync> syncList){
        JSONObject jsonObject = new JSONObject();
 
        JSONArray dataList = new JSONArray();
        for(MesSync sync : syncList){
            dataList.add(buildOneJson(sync));
        }
        jsonObject.put("batchData", dataList);
 
        return jsonObject;
    }
 
    /**
     * 构建一条的json
     * @param sync
     * @return 同步数据json
     */
    JSONObject buildOneJson(MesSync sync){
        JSONObject item = new JSONObject();
        item.put("operationId",sync.getOperationId());
        item.put("programNo",sync.getProgramNo());
        item.put("curedTime",DateUtil.formatDateTime(sync.getCuredTime()));
 
        return item;
    }
 
    int codeToStatus(int code){
        if(code == 200){
            return MesSync.STATUS_SUCCESS;
        }else{
            return MesSync.STATUS_FAILED;
        }
    }
 
    @Transactional
    public void saveAndSync(MesSync sync){
        save(sync);
        JSONObject bodyJson = buildRequestJson(Collections.singletonList(sync));
        int code = postData(bodyJson);
 
        sync.setStatus(codeToStatus(code));
        sync.increaseTryTimes();
        updateById(sync);
    }
 
 
}