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
package com.java110.event.listener.common;
 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.util.Assert;
import com.java110.utils.util.ProtocolUtil;
import com.java110.utils.util.StringUtil;
import com.java110.core.context.AppContext;
import com.java110.entity.order.BusiOrder;
import com.java110.event.app.AppListener;
import com.java110.event.app.common.AppCommonEvent;
import com.java110.event.method.CommonDispatchAfterMethod;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
 
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
 
/**
 * 公用调度侦听
 *
 *
 * Created by wuxw on 2017/9/15.
 */
@Component
public class CommonDispatchListener implements AppListener<AppCommonEvent> {
 
 
    /**
     * 保存服务信息,一般启动时加载
     */
    private final static Map<String,String> services = new HashMap<String,String>();
 
    private final static String QUEYR_DATA = "1";//查询数据,完整数据
 
    private final static String QUERY_NEED_DELETE_DATA = "2"; //查询需要作废的数据报文
 
 
    /**
     * 添加服务,一般启动时加载,不会有并发问题
     * @param boActionType
     * @param service
     */
    public static void addService(String boActionType,String service){
        services.put(boActionType,service);
    }
 
    @Autowired
    private RestTemplate restTemplate;
 
    @Autowired
    private CommonDispatchAfterMethod commonDispatchAfterMethod;
 
 
    /**
     * 数据受理
     * @param event the event to respond to
     */
    @Override
    public void soDataService(AppCommonEvent event) {
        AppContext context = event.getContext();
        JSONArray dataInfos = event.getData();
 
        JSONObject infoJson = new JSONObject();
        infoJson.put("data",dataInfos.toJSONString());
 
 
        String bo_action_type  = context.getBo_action_type();
 
        String service_url = services.get(bo_action_type);
 
        if(StringUtil.isEmpty(service_url) || !service_url.contains("@@") || !service_url.contains("##")){
            throw new IllegalArgumentException("服务配置错误,["+bo_action_type+"]不存在 ,配置格式为 A::B##M@@C@@D");
        }
 
        String[] service_urls = service_url.split("@@")[0].split("##");
 
        if(service_urls == null || service_urls.length != 2){
            throw new IllegalArgumentException("服务配置错误,["+bo_action_type+"]配置错误,配置格式为 A::B##M@@C@@D");
        }
        service_url = service_urls[0];
        String after_method = service_urls[1];
 
        String returnObj = restTemplate.postForObject(service_url,null,String.class,infoJson);
 
        JSONObject returnObjTmp = JSONObject.parseObject(returnObj);
 
        Assert.notNull(returnObjTmp,"用户服务没有相应,请检查服务是否正常,请求报文:"+returnObj);
        //受理不成功
        if(!returnObjTmp.containsKey(ProtocolUtil.RESULT_CODE)
                || !ProtocolUtil.RETURN_MSG_SUCCESS.equals(returnObjTmp.getString(ProtocolUtil.RESULT_CODE))){
            throw new IllegalArgumentException(service_url+"受理失败,失败原因:" + (returnObjTmp.containsKey(ProtocolUtil.RESULT_MSG)
                    ?"未知原因":returnObjTmp.getString(ProtocolUtil.RESULT_MSG)) + "请求报文:"+returnObj);
        }
 
        //根据配置查询是否需要 调用方法处理,比如将返回的商户ID 刷新原前报文中 的商户ID的值
        if(!"0".equals(after_method) && !StringUtil.isEmpty(after_method)){
 
            try {
                Class clazz = commonDispatchAfterMethod.getClass();
 
                Method method = clazz.getDeclaredMethod(after_method,new Class[]{AppContext.class,JSONArray.class,JSONObject.class});
 
                method.invoke(commonDispatchAfterMethod,context,dataInfos,returnObjTmp.getJSONObject(ProtocolUtil.RESULT_INFO));
 
            }catch (Exception e){
                throw new IllegalArgumentException("服务配置错误,["+bo_action_type+"]配置错误,配置格式为 A::B##M@@C@@D,配置的method 在类"+commonDispatchAfterMethod.getClass()
                        +"中没有找到方法" + after_method);
            }
        }
    }
 
    @Override
    public JSONObject queryDataInfo(AppCommonEvent event) {
        return queryCommonDataInfo(event,QUEYR_DATA);
    }
 
    @Override
    public JSONObject queryNeedDeleteDataInfo(AppCommonEvent event){
        return queryCommonDataInfo(event,QUERY_NEED_DELETE_DATA);
    }
 
    /**
     * 公用查询
     * @param event
     * @param queryFlag
     * @return
     * @throws Exception
     */
    private JSONObject queryCommonDataInfo(AppCommonEvent event,String queryFlag) {
 
        AppContext context = event.getContext();
 
        BusiOrder busiOrder = (BusiOrder) context.getReqObj();
 
        String bo_action_type  = context.getBo_action_type();
 
        String service_url = services.get(bo_action_type);
 
        if(StringUtil.isEmpty(service_url) || !service_url.contains("@@")){
            throw new IllegalArgumentException("服务配置错误,["+bo_action_type+"]不存在 ,配置格式为 A::B@@C@@D");
        }
 
        String[] urls = service_url.split("@@");
 
        if(urls.length != 3){
            throw new IllegalArgumentException("服务配置错误,["+bo_action_type+"] 配置为"+service_url+",应该配置格式为 A::B@@C@@D");
        }
 
        service_url = QUEYR_DATA.equals(queryFlag) ? urls[1] : urls[2];
 
        String returnObj = restTemplate.postForObject(service_url,null,String.class,JSONObject.toJSONString(busiOrder));
 
        JSONObject returnObjTmp = JSONObject.parseObject(returnObj);
 
        Assert.notNull(returnObjTmp,"用户服务没有相应,请检查服务是否正常,请求报文:"+returnObjTmp);
        //受理不成功
        if(!returnObjTmp.containsKey(ProtocolUtil.RESULT_CODE)
                || !ProtocolUtil.RETURN_MSG_SUCCESS.equals(returnObjTmp.getString(ProtocolUtil.RESULT_CODE))){
            return JSONObject.parseObject("{'errorInfo':"+returnObjTmp.getString(ProtocolUtil.RESULT_MSG)+"}");
        }
        return returnObjTmp.getJSONObject(ProtocolUtil.RESULT_INFO);
 
    }
 
 
    public RestTemplate getRestTemplate() {
        return restTemplate;
    }
 
    public void setRestTemplate(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
 
 
    public CommonDispatchAfterMethod getCommonDispatchAfterMethod() {
        return commonDispatchAfterMethod;
    }
 
    public void setCommonDispatchAfterMethod(CommonDispatchAfterMethod commonDispatchAfterMethod) {
        this.commonDispatchAfterMethod = commonDispatchAfterMethod;
    }
}