EKP接口开发Webservice服务和Restservice服务以及定时任务Demo

• 继承com.landray.kmss.sys.webservice2.interfaces.ISysWebservice，同时在接口上使用@WebService注解将其标识为WebService接口

package com.landray.kmss.third.notify.webservice;

import com.alibaba.fastjson.JSONObject;
import com.landray.kmss.sys.webservice2.interfaces.ISysWebservice;

import javax.jws.WebService;

/**
 * 外部系统消息通知服务接口
 */
@WebService
public interface IThirdNotifyWebService extends ISysWebservice {

    /*外部系统消息通知服务接口*/
    JSONObject sendToNotifyInfo(JSONObject jsonObject) throws Exception;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 编写服务实现类

package com.landray.kmss.third.notify.webservice.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.landray.kmss.common.service.IBaseService;
import com.landray.kmss.constant.SysNotifyConstant;
import com.landray.kmss.hr.staff.model.HrStaffPersonInfo;
import com.landray.kmss.hr.staff.service.IHrStaffPersonInfoService;
import com.landray.kmss.sys.metadata.interfaces.ExtendDataServiceImp;
import com.landray.kmss.sys.notify.constant.SysNotifyConstants;
import com.landray.kmss.sys.notify.interfaces.ISysNotifyMainCoreService;
import com.landray.kmss.sys.notify.interfaces.NotifyContext;
import com.landray.kmss.third.notify.model.ThirdNotifyInfoDetails;
import com.landray.kmss.third.notify.service.IThirdNotifyInfoDetailsService;
import com.landray.kmss.third.notify.webservice.IThirdNotifyWebService;
import com.landray.kmss.web.annotation.RestApi;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static com.landray.kmss.third.notify.webservice.ThirdNotifyConstant.*;
import static com.landray.kmss.util.SpringBeanUtil.getBean;


/**
 * 外部系统消息通知服务接口
 */
@Controller
@RequestMapping(value = "/api/third-notify/thirdNotifyWebService", method = RequestMethod.POST)
@RestApi(docUrl = "/third/notify/webservice/third_notify_service_help.jsp", name = "thirdNotifyWebServiceImp", resourceKey = "third-notify:module.third.notify")
public class ThirdNotifyWebServiceImpl extends ExtendDataServiceImp implements IThirdNotifyWebService {

    /*注入外部系统消息通知信息表信息*/
    private IThirdNotifyInfoDetailsService thirdNotifyInfoDetailsService;

    public IBaseService getServiceImp() {
        if (thirdNotifyInfoDetailsService == null) {
            thirdNotifyInfoDetailsService = (IThirdNotifyInfoDetailsService) getBean("thirdNotifyInfoDetailsService");
        }
        return thirdNotifyInfoDetailsService;
    }

    /*注入消息通知*/
    private ISysNotifyMainCoreService sysNotifyMainCoreService;

    public ISysNotifyMainCoreService getSysNotifyMainCoreServiceImp() {
        if (sysNotifyMainCoreService == null) {
            sysNotifyMainCoreService = (ISysNotifyMainCoreService) getBean("sysNotifyMainCoreService");
        }
        return sysNotifyMainCoreService;
    }

    /*注入人员组织架构*/
    private IHrStaffPersonInfoService hrStaffPersonInfoService;

    public IHrStaffPersonInfoService getHrStaffPersonInfoServiceImp() {
        if (hrStaffPersonInfoService == null) {
            hrStaffPersonInfoService = (IHrStaffPersonInfoService) getBean("hrStaffPersonInfoService");
        }
        return hrStaffPersonInfoService;
    }

    /**
     * @param jsonObject
     * @return com.alibaba.fastjson.JSONObject
     * @description: 外部系统消息通知服务接口
     * @author: 王雄峰
     * @date: 2023/10/16
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    @ResponseBody
    @RequestMapping(value = "/sendToNotifyInfo", method = RequestMethod.POST)
    public JSONObject sendToNotifyInfo(@RequestBody JSONObject jsonObject) throws Exception {
        //声明最后返回消息变量
        JSONObject resultJson = new JSONObject();
        //声明返回消息的数组类型
        JSONArray resultJsonArr = new JSONArray();
        //数据校验是否有误
        boolean isError = false;
        //格式化日期
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        try {
            //判断JSON参数是否为空
            if (jsonObject != null && !jsonObject.isEmpty() && jsonObject.size() != 0) {
                //判断JSON是否包含规定的key
                if (jsonObject.containsKey("sendToNotifyInfo")) {
                    //获取规定的key值，得到JSON数组
                    JSONArray jsonArray = jsonObject.getJSONArray("sendToNotifyInfo");
                    // 数组不为空，则进行遍历，获取每一项的值
                    if (jsonArray.size() != 0 && !jsonArray.isEmpty()) {
                        //保存数据model
                        ThirdNotifyInfoDetails thirdNotifyInfoDetails = new ThirdNotifyInfoDetails();
                        JSONObject jsonItem;//每一个json数据对象变量
                        String notifySubject;//消息主题
                        String notifyContent;//消息内容
                        String notifySenderNo;//发送给对应人员的编号
                        String notifyPush;//消息推送类型，即时或者是定时
                        String notifyType;//消息推送通知方式，钉钉或者邮件通知等等
                        String notifySendTime;//定时消息通知发送时间
                        for (int i = 0; i < jsonArray.size(); i++) {
                            //重置数据校验标识
                            isError = false;
                            jsonItem = jsonArray.getJSONObject(i);
                            if (jsonItem != null && !jsonItem.isEmpty()) {
                                //消息通知主题
                                notifySubject = jsonItem.get("notifySubject").toString();
                                thirdNotifyInfoDetails.setNotifySubject(notifySubject);
                                //消息通知内容
                                notifyContent = jsonItem.get("notifyContent").toString();
                                thirdNotifyInfoDetails.setNotifyContent(notifyContent);
                                //消息通知发送人编号
                                notifySenderNo = jsonItem.get("notifySenderNo").toString();
                                if ("".equals(notifySenderNo) || notifySenderNo == "") {
                                    JSONObject resultNoJson = new JSONObject();
                                    resultNoJson.put(RETURNSTATE, ERROR);
                                    resultNoJson.put(RETURNMESSAGE, "[notifySenderNo]" + MESSAGENOTIFYSENDERNO);
                                    resultJsonArr.add(resultNoJson);
                                    isError = true;
                                } else {
                                    thirdNotifyInfoDetails.setNotifySenderNo(notifySenderNo);
                                }
                                //消息通知发送人姓名
                                thirdNotifyInfoDetails.setNotifySenderName(jsonItem.get("notifySenderName").toString());
                                //消息通知发送时间
                                notifySendTime = jsonItem.get("notifySendTime").toString();
                                //时间不为空，则校验格式
                                if (!"".equals(notifySendTime) && notifySendTime != "") {
                                    try {
                                        thirdNotifyInfoDetails.setNotifySendTime(dateFormat.parse(notifySendTime));
                                    } catch (Exception e) {
                                        JSONObject resultTimeJson = new JSONObject();
                                        resultTimeJson.put(RETURNSTATE, ERROR);
                                        resultTimeJson.put(RETURNMESSAGE, "编号：[" + notifySenderNo + "]" + MESSAGENOTIFYTIME);
                                        resultJsonArr.add(resultTimeJson);
                                        isError = true;
                                    }
                                } else {
                                    thirdNotifyInfoDetails.setNotifySendTime(null);
                                }
                                //消息通知系统来源（调用系统来源：lims系统、报告系统）
                                thirdNotifyInfoDetails.setNotifySource(jsonItem.get("notifySource").toString());
                                //消息通知推送类型（即时推送-1；定时推送-2；）
                                notifyPush = jsonItem.get("notifyPush").toString();
                                if (NOW.equals(notifyPush) || TIMED.equals(notifyPush)) {
                                    thirdNotifyInfoDetails.setNotifyPush(notifyPush);
                                } else {
                                    JSONObject resultPushJson = new JSONObject();
                                    resultPushJson.put(RETURNSTATE, ERROR);
                                    resultPushJson.put(RETURNMESSAGE, "编号：[" + notifySenderNo + "]" + MESSAGENOTIFYPUSH);
                                    resultJsonArr.add(resultPushJson);
                                    isError = true;
                                }
                                //消息通知推送方式（以哪一种通知类型进行通知：钉钉类型-1；邮件类型-2；）
                                notifyType = jsonItem.get("notifyType").toString();
                                if (DINGTALK.equals(notifyType) || EMAIL.equals(notifyType)) {
                                    thirdNotifyInfoDetails.setNotifyType(notifyType);
                                } else {
                                    JSONObject resultTypeJson = new JSONObject();
                                    resultTypeJson.put(RETURNSTATE, ERROR);
                                    resultTypeJson.put(RETURNMESSAGE, "编号：[" + notifySenderNo + "]" + MESSAGENOTIFYTYPE);
                                    resultJsonArr.add(resultTypeJson);
                                    isError = true;
                                }
                                //消息通知接收人编号
                                thirdNotifyInfoDetails.setNotifyRecipientNo(jsonItem.get("notifyRecipientNo").toString());
                                //消息通知接收人姓名
                                thirdNotifyInfoDetails.setNotifyRecipientName(jsonItem.get("notifyRecipientName").toString());
                                //消息通知创建时间（当前时间）
                                thirdNotifyInfoDetails.setNotifyCreateTime(new Date());
                                //消息通知更新时间（当前时间）
                                thirdNotifyInfoDetails.setNotifyUpdateTime(new Date());
                                //消息通知推送类型（即时推送-1；定时推送-2；）即时推送则调用推送方法，定时则保存数据，等待定时任务进行推送
                                if (NOW.equals(notifyPush) && DINGTALK.equals(notifyType) && !isError) {
                                    try {
                                        //即时发送
                                        JSONObject sendResult = this.sendTodoFromResource(notifySenderNo, notifySubject, notifyContent);
                                        if (SUCCES.equals(sendResult.getString(RETURNSTATE))) {
                                            //消息通知推送标识（未完成-0；已完成-1）
                                            thirdNotifyInfoDetails.setNotifyIsFlag("1");
                                            //发送成功保存数据
                                            getServiceImp().add(thirdNotifyInfoDetails);
                                        } else {
                                            JSONObject getSendState = new JSONObject();
                                            getSendState.put(RETURNSTATE, sendResult.getString(RETURNSTATE));
                                            getSendState.put(RETURNMESSAGE, "编号：[" + notifySenderNo + "]" + sendResult.getString(RETURNMESSAGE));
                                            resultJsonArr.add(getSendState);
                                            isError = true;
                                        }
                                    } catch (Exception e) {
                                        //声明存放异常的JSON变量
                                        JSONObject errorJson = new JSONObject();
                                        errorJson.put(RETURNSTATE, ERROR);
                                        errorJson.put(RETURNMESSAGE, "编号：[" + notifySenderNo + "]" + MESSAGESEND2);
                                        resultJsonArr.add(errorJson);
                                        isError = true;
                                        e.printStackTrace();
                                    }
                                } else if (TIMED.equals(notifyPush) && !isError) {//定时推送
                                    //消息通知推送标识（未完成-0；已完成-1）
                                    thirdNotifyInfoDetails.setNotifyIsFlag("0");
                                    getServiceImp().add(thirdNotifyInfoDetails);
                                }
                            }
                        }
                    } else {
                        //放入返回请求信息
                        resultJson.put(RETURNSTATE, ERROR);
                        resultJson.put(RETURNMESSAGE, MESSAGE4);
                        return resultJson;
                    }
                } else {
                    //放入返回请求信息
                    resultJson.put(RETURNSTATE, ERROR);
                    resultJson.put(RETURNMESSAGE, MESSAGE3);
                    return resultJson;
                }
            } else {
                //放入返回请求信息
                resultJson.put(RETURNSTATE, ERROR);
                resultJson.put(RETURNMESSAGE, MESSAGE2);
                return resultJson;
            }
        } catch (Exception e) {
            //放入返回请求信息
            resultJson.put(RETURNSTATE, ERROR);
            resultJson.put(RETURNMESSAGE, MESSAGE1);
            e.printStackTrace();
            return resultJson;
        }
        if (isError) {
            resultJson.put(RETURNSTATE, ERROR);
            resultJson.put(RETURNMESSAGE, resultJsonArr);
        } else {
            resultJson.put(RETURNSTATE, SUCCES);
            resultJson.put(RETURNMESSAGE, MESSAGESUCCES);
        }
        return resultJson;
    }


    /**
     * @param notifySenderNo
     * @param notifySubject
     * @param notifyContent
     * @return com.alibaba.fastjson.JSONObject
     * @description: 根据传递的人员编号给对应的人员OA和钉钉发送通知
     * @author: 王雄峰
     * @date: 2023/10/16
     */
    public JSONObject sendTodoFromResource(String notifySenderNo, String notifySubject, String notifyContent) {
        //声明返回消息变量
        JSONObject sendResultJson = new JSONObject();
        //默认调用成功
        sendResultJson.put(RETURNSTATE, SUCCES);
        sendResultJson.put(RETURNMESSAGE, MESSAGESEND1);
        try {
            //根据工号查询员工信息
            HrStaffPersonInfo senderInfo = getHrStaffPersonInfoServiceImp().findPersonInfoByStaffNo(notifySenderNo);
            if (senderInfo == null) {
                //查询不到对应编号的员工信息，调用失败
                sendResultJson.put(RETURNSTATE, ERROR);
                sendResultJson.put(RETURNMESSAGE, MESSAGESEND3);
                return sendResultJson;
            }
            //获取上下文
            NotifyContext notifyContext = getSysNotifyMainCoreServiceImp()
                    .getContext(null);
            //获取通知方式
            notifyContext.setNotifyType("todo");
            // 设置发布类型为“待办”（默认为待阅）
            //“待办”消息发送出去后，需要到某事件发生后才变成已办，如审批通过等
            notifyContext.setFlag(SysNotifyConstant.NOTIFY_TODOTYPE_ONCE);
            // 设置发布KEY值，为后面的删除准备
            notifyContext.setKey("thirdNotifyInfo");
            //获取通知人
            List targets = new ArrayList();
            targets.add(senderInfo.getFdOrgPerson());
            //设置发布通知人
            notifyContext.setNotifyTarget(targets);
            notifyContext.setLink("");
            notifyContext.setSubject(notifySubject);
            notifyContext.setContent(notifyContent);
            notifyContext.setParameter1(SysNotifyConstants.SUPPORT_MORETIMES_SEND_TODO);
            getSysNotifyMainCoreServiceImp().sendNotify(senderInfo, notifyContext, null);
        } catch (Exception e) {
            e.printStackTrace();
            sendResultJson.put(RETURNSTATE, ERROR);
            sendResultJson.put(RETURNMESSAGE, MESSAGESEND2);
            return sendResultJson;
        }
        return sendResultJson;
    }
}

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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304

• 添加spring bean配置

<!--外部系统消息通知WebService服务接口-->
<bean id="thirdNotifyWebService" class="com.landray.kmss.third.notify.webservice.impl.ThirdNotifyWebServiceImpl"/>
1
2

• 在功能模块中添加WebService的扩展配置，实现Web服务的扩展点

    <!--外部系统消息通知WebService服务接口-开始-->
    <extension
            point="com.landray.kmss.sys.webservice2">
        <item
                name="registry">
            <param
                    name="serviceName"
                    value="外部系统消息通知"/>
            <param
                    name="serviceClass"
                    value="com.landray.kmss.third.notify.webservice.IThirdNotifyWebService"/>
            <param
                    name="serviceBean"
                    value="thirdNotifyWebService"/>
            <param
                    name="serviceDoc"
                    value="/third/notify/webservice/third_notify_service_help.jsp"/>
        </item>
    </extension>
    <!--外部系统消息通知WebService服务接口-结束-->
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 导入并发布服务
  

定时任务

• 添加一个接口

package com.landray.kmss.third.notify.webservice;

import com.landray.kmss.common.service.IBaseService;

/**
 * 外部系统消息通知定时任务服务接口
 */
public interface IThirdNotifyJobWebService extends IBaseService {

    /*外部系统消息通知定时任务服务接口*/
    void sendToNotifyInfoJob() throws Exception;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

• 添加一个服务类，实现接口，实现接口中的方法

package com.landray.kmss.third.notify.webservice.impl;

import com.alibaba.fastjson.JSONObject;
import com.landray.kmss.common.service.BaseServiceImp;
import com.landray.kmss.common.service.IBaseService;
import com.landray.kmss.third.notify.model.ThirdNotifyInfoDetails;
import com.landray.kmss.third.notify.service.IThirdNotifyInfoDetailsService;
import com.landray.kmss.third.notify.webservice.IThirdNotifyJobWebService;
import com.landray.kmss.util.SpringBeanUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.Date;
import java.util.List;

import static com.landray.kmss.third.notify.webservice.ThirdNotifyConstant.*;
import static com.landray.kmss.util.SpringBeanUtil.getBean;

/**
 * 外部系统消息通知定时任务服务接口
 */
public class ThirdNotifyJobWebServiceImpl extends BaseServiceImp implements IThirdNotifyJobWebService {

    private static final Log logger = LogFactory.getLog(ThirdNotifyJobWebServiceImpl.class);

    /*注入外部系统消息通知信息表信息*/
    private IThirdNotifyInfoDetailsService thirdNotifyInfoDetailsService;

    public IBaseService getServiceImp() {
        if (thirdNotifyInfoDetailsService == null) {
            thirdNotifyInfoDetailsService = (IThirdNotifyInfoDetailsService) getBean("thirdNotifyInfoDetailsService");
        }
        return thirdNotifyInfoDetailsService;
    }

    private IThirdNotifyInfoDetailsService getThirdNotifyInfoDetailsService() {
        if (thirdNotifyInfoDetailsService == null)
            thirdNotifyInfoDetailsService = (IThirdNotifyInfoDetailsService) SpringBeanUtil
                    .getBean("thirdNotifyInfoDetailsService");
        return thirdNotifyInfoDetailsService;
    }

    /*注入即时发送消息通知的接口*/
    private ThirdNotifyWebServiceImpl thirdNotifyWebService;

    private ThirdNotifyWebServiceImpl getThirdNotifyWebService() {
        if (thirdNotifyWebService == null)
            thirdNotifyWebService = (ThirdNotifyWebServiceImpl) SpringBeanUtil
                    .getBean("thirdNotifyWebService");
        return thirdNotifyWebService;
    }

    /**
     * @param
     * @return void
     * @description: 外部系统消息通知定时任务服务执行方法
     * @author: 王雄峰
     * @date: 2023/10/17
     */
    @Override
    public void sendToNotifyInfoJob() throws Exception {
        try {
            //查询到需要推送的数据
            List<ThirdNotifyInfoDetails> sendDataList = getThirdNotifyInfoDetailsService().getSendJobData();
            //如果有符合条件的数据，那么进行则进行推送
            if (sendDataList.size() != 0) {
                //获取当前时间
                Date nowDate = new Date();
                for (int i = 0; i < sendDataList.size(); i++) {
                    //遍历每一条数据
                    ThirdNotifyInfoDetails infoDetails = sendDataList.get(i);
                    if (infoDetails != null) {
                        //获取当前数据中设置的定时时间与当前之前对比，如果当前时间大于数据中的时间，那么就就行推送
                        Date notifySendTime = infoDetails.getNotifySendTime();
                        //推送时间不为空，并且推送类型为钉钉推送方式
                        if (notifySendTime != null && DINGTALK.equals(infoDetails.getNotifyType())) {
                            //比较时间
                            int dateResult = nowDate.compareTo(notifySendTime);
                            //如果返回的结果小于0，则表示date1在date2之前；(date1
                            //如果返回的结果大于0，则表示date1在date2之后；(date2
                            //如果返回的结果等于0，则表示date1和date2相等
                            if (dateResult > 0 || dateResult == 0) {
                                //获取工号信息进行推送
                                String senderNo = infoDetails.getNotifySenderNo();
                                if (!"".equals(senderNo) && senderNo != "") {
                                    try {
                                        JSONObject sendResult = getThirdNotifyWebService().sendTodoFromResource(senderNo, infoDetails.getNotifySubject(), infoDetails.getNotifyContent());
                                        if (SUCCES.equals(sendResult.getString(RETURNSTATE))) {
                                            //更新标识，消息通知推送标识（未完成-0；已完成-1）
                                            infoDetails.setNotifyIsFlag("1");
                                            //更新数据的更新时间为当前时间
                                            infoDetails.setNotifyUpdateTime(nowDate);
                                            //更新数据
                                            getServiceImp().add(infoDetails);
                                        }
                                        String state = "编号：[" + senderNo + "]" + sendResult.getString(RETURNSTATE);
                                        String message = "编号：[" + senderNo + "]" + sendResult.getString(RETURNMESSAGE);
                                        logger.info("ThirdNotifyJobWebServiceImpl：外部系统消息通知定时任务服务接口调用状态：" + state + "；" + message + "；");
                                    } catch (Exception e) {
                                        logger.info("ThirdNotifyJobWebServiceImpl：外部系统消息通知定时任务服务接口调用异常");
                                        e.printStackTrace();
                                    }
                                }
                            }
                        }
                    }
                }
            } else {
                logger.info("ThirdNotifyJobWebServiceImpl：暂无需要推送的外部系统消息通知定时任务服务");
            }
        } catch (Exception e) {
            logger.info("ThirdNotifyJobWebServiceImpl：外部系统消息通知定时任务服务接口异常");
            e.printStackTrace();
        }
    }
}

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

• 查询方法接口展示

package com.landray.kmss.third.notify.service;

import com.landray.kmss.sys.metadata.interfaces.IExtendDataService;
import com.landray.kmss.third.notify.model.ThirdNotifyInfoDetails;

import java.util.List;

/**
 * 外部系统消息通知信息表 服务接口
 */
public interface IThirdNotifyInfoDetailsService extends IExtendDataService {

    /*查询到需要发送消息通知的定时任务条件数据*/
    List<ThirdNotifyInfoDetails> getSendJobData() throws Exception;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 查询方法实现类展示

package com.landray.kmss.third.notify.service.spring;

import com.landray.kmss.common.actions.RequestContext;
import com.landray.kmss.common.convertor.ConvertorContext;
import com.landray.kmss.common.dao.HQLInfo;
import com.landray.kmss.common.forms.IExtendForm;
import com.landray.kmss.common.model.IBaseModel;
import com.landray.kmss.sys.metadata.interfaces.ExtendDataServiceImp;
import com.landray.kmss.sys.notify.interfaces.ISysNotifyMainCoreService;
import com.landray.kmss.third.notify.model.ThirdNotifyInfoDetails;
import com.landray.kmss.third.notify.service.IThirdNotifyInfoDetailsService;
import com.landray.kmss.third.notify.util.ThirdNotifyUtil;
import com.landray.kmss.util.SpringBeanUtil;

import java.util.Date;
import java.util.List;

/**
 * 外部系统消息通知信息表 服务实现
 */
public class ThirdNotifyInfoDetailsServiceImp extends ExtendDataServiceImp implements IThirdNotifyInfoDetailsService {

    private ISysNotifyMainCoreService sysNotifyMainCoreService;

    public IBaseModel convertBizFormToModel(IExtendForm form, IBaseModel model, ConvertorContext context) throws Exception {
        model = super.convertBizFormToModel(form, model, context);
        if (model instanceof ThirdNotifyInfoDetails) {
            ThirdNotifyInfoDetails thirdNotifyInfoDetails = (ThirdNotifyInfoDetails) model;
        }
        return model;
    }

    public IBaseModel initBizModelSetting(RequestContext requestContext) throws Exception {
        ThirdNotifyInfoDetails thirdNotifyInfoDetails = new ThirdNotifyInfoDetails();
        thirdNotifyInfoDetails.setNotifyCreateTime(new Date());
        thirdNotifyInfoDetails.setNotifyUpdateTime(new Date());
        ThirdNotifyUtil.initModelFromRequest(thirdNotifyInfoDetails, requestContext);
        return thirdNotifyInfoDetails;
    }

    public void initCoreServiceFormSetting(IExtendForm form, IBaseModel model, RequestContext requestContext) throws Exception {
        ThirdNotifyInfoDetails thirdNotifyInfoDetails = (ThirdNotifyInfoDetails) model;
    }

    public ISysNotifyMainCoreService getSysNotifyMainCoreService() {
        if (sysNotifyMainCoreService == null) {
            sysNotifyMainCoreService = (ISysNotifyMainCoreService) SpringBeanUtil.getBean("sysNotifyMainCoreService");
        }
        return sysNotifyMainCoreService;
    }

    /*查询到需要发送消息通知的定时任务条件数据*/
    @Override
    public List<ThirdNotifyInfoDetails> getSendJobData() throws Exception {
        HQLInfo hqlInfo = new HQLInfo();
        try {
            hqlInfo.setWhereBlock("thirdNotifyInfoDetails.notifyPush = :notifyPush and thirdNotifyInfoDetails.notifyIsFlag = :notifyIsFlag");
            //消息通知推送类型（即时推送-1；定时推送-2；）即时推送则调用推送方法，定时则保存数据，等待定时任务进行推送
            hqlInfo.setParameter("notifyPush", "2");
            //消息通知推送标识（未完成-0；已完成-1）
            hqlInfo.setParameter("notifyIsFlag", "0");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this.findList(hqlInfo);
    }
}

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

• 在spring中进行service的配置

    <!--外部系统消息通知定时任务服务接口-开始-->
    <bean id="thirdNotifyJobWebService"
          class="com.landray.kmss.third.notify.webservice.impl.ThirdNotifyJobWebServiceImpl"/>
    <!--外部系统消息通知定时任务服务接口-结束-->
1
2
3
4

• 在design中配置quartz属性

    <!--外部系统消息通知定时任务服务接口-开始-->
    <quartz
            messageKey="third-notify:module.third.notify"
            jobService="thirdNotifyJobWebService"
            cronExpression="0 10 0 ? * *"
            jobMethod="sendToNotifyInfoJob"
            description="third-notify:module.third.notify.description"/>
    <!--外部系统消息通知定时任务服务接口-结束-->
1
2
3
4
5
6
7
8

• 系统配置中导入系统任务