001/**
002 * Copyright (c) 2015-2022, Michael Yang 杨福海 (fuhai999@gmail.com).
003 * <p>
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 * <p>
008 * http://www.apache.org/licenses/LICENSE-2.0
009 * <p>
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package io.jboot.components.rpc.motan;
017
018import com.weibo.api.motan.config.*;
019import com.weibo.api.motan.util.MotanFrameworkUtil;
020import io.jboot.utils.ConfigUtil;
021import io.jboot.components.rpc.JbootrpcReferenceConfig;
022import io.jboot.components.rpc.JbootrpcServiceConfig;
023import io.jboot.components.rpc.RPCUtil;
024import io.jboot.utils.StrUtil;
025
026import java.util.ArrayList;
027import java.util.List;
028import java.util.Map;
029import java.util.Set;
030import java.util.concurrent.ConcurrentHashMap;
031
032/**
033 * @author michael yang (fuhai999@gmail.com)
034 * @Date: 2020/3/20
035 */
036public class MotanUtil {
037
038    private static Map<String, ProtocolConfig> protocolConfigMap = new ConcurrentHashMap<>();
039    private static Map<String, RegistryConfig> registryConfigMap = new ConcurrentHashMap<>();
040    private static Map<String, BasicRefererInterfaceConfig> baseRefererConfigMap = new ConcurrentHashMap<>();
041    private static Map<String, BasicServiceInterfaceConfig> baseServiceConfigMap = new ConcurrentHashMap<>();
042
043
044    public static void initMotan() {
045
046        //protocol 配置
047        Map<String, ProtocolConfig> protocolConfigs = configs(ProtocolConfig.class, "jboot.rpc.motan.protocol");
048        if (!protocolConfigs.isEmpty()) {
049            protocolConfigMap.putAll(protocolConfigs);
050        } else {
051            protocolConfigMap.put("default", MotanFrameworkUtil.getDefaultProtocolConfig());
052        }
053
054        //registry 配置
055        Map<String, RegistryConfig> registryConfigs = configs(RegistryConfig.class, "jboot.rpc.motan.registry");
056        if (!registryConfigs.isEmpty()) {
057            registryConfigMap.putAll(registryConfigs);
058        } else {
059            registryConfigMap.put("default", MotanFrameworkUtil.getDefaultRegistryConfig());
060        }
061
062        //methodConfig 配置
063        Map<String, MethodConfig> methodConfigs = configs(MethodConfig.class, "jboot.rpc.motan.method");
064
065
066        //baseService 配置
067        Map<String, BasicServiceInterfaceConfig> serviceConfigs = configs(BasicServiceInterfaceConfig.class, "jboot.rpc.motan.service");
068        RPCUtil.setChildConfig(serviceConfigs, methodConfigs, "jboot.rpc.motan.service", "method");
069        RPCUtil.setChildConfig(serviceConfigs, protocolConfigs, "jboot.rpc.motan.service", "protocol");
070        RPCUtil.setChildConfig(serviceConfigs, registryConfigs, "jboot.rpc.motan.service", "registry");
071
072
073        if (!serviceConfigs.isEmpty()) {
074            baseServiceConfigMap.putAll(serviceConfigs);
075        }
076
077        //baseReferer 配置
078        Map<String, BasicRefererInterfaceConfig> refererConfigs = configs(BasicRefererInterfaceConfig.class, "jboot.rpc.motan.referer");
079        RPCUtil.setChildConfig(refererConfigs, methodConfigs, "jboot.rpc.motan.referer", "method");
080        RPCUtil.setChildConfig(refererConfigs, protocolConfigs, "jboot.rpc.motan.referer", "protocol");
081        RPCUtil.setChildConfig(refererConfigs, registryConfigs, "jboot.rpc.motan.referer", "registry");
082
083        if (!refererConfigs.isEmpty()) {
084            baseRefererConfigMap.putAll(refererConfigs);
085        }
086
087
088    }
089
090
091    public static RefererConfig toRefererConfig(JbootrpcReferenceConfig jbootrpcReferenceConfig) {
092        RefererConfig refererConfig = new RefererConfig();
093        RPCUtil.copyDeclaredFields(jbootrpcReferenceConfig, refererConfig);
094
095
096        // reference consumer
097        if (jbootrpcReferenceConfig.getConsumer() != null) {
098            refererConfig.setBasicReferer(baseRefererConfigMap.get(jbootrpcReferenceConfig.getConsumer()));
099        }
100        // set default consumer
101        else {
102            for (BasicRefererInterfaceConfig baseConfig : baseRefererConfigMap.values()) {
103                if (baseConfig.isDefault() != null && baseConfig.isDefault()) {
104                    refererConfig.setBasicReferer(baseConfig);
105                }
106            }
107        }
108
109
110        //referer protocol
111        if (StrUtil.isNotBlank(jbootrpcReferenceConfig.getProtocol())) {
112            List<ProtocolConfig> protocolConfigs = new ArrayList<>();
113            Set<String> protocolNames = StrUtil.splitToSetByComma(jbootrpcReferenceConfig.getProtocol());
114            for (String protocalName : protocolNames) {
115                ProtocolConfig registryConfig = protocolConfigMap.get(protocalName);
116                if (registryConfig != null) {
117                    protocolConfigs.add(registryConfig);
118                }
119            }
120            if (!protocolConfigs.isEmpty()) {
121                refererConfig.setProtocols(protocolConfigs);
122            }
123        } else {
124            refererConfig.setProtocols(toList(protocolConfigMap));
125        }
126
127
128        //referer registry
129        if (StrUtil.isNotBlank(jbootrpcReferenceConfig.getRegistry())) {
130            List<RegistryConfig> registryConfigs = new ArrayList<>();
131            Set<String> registryNames = StrUtil.splitToSetByComma(jbootrpcReferenceConfig.getRegistry());
132            for (String registryName : registryNames) {
133                RegistryConfig registryConfig = registryConfigMap.get(registryName);
134                if (registryConfig != null) {
135                    registryConfigs.add(registryConfig);
136                }
137            }
138            if (!registryConfigs.isEmpty()) {
139                refererConfig.setRegistries(registryConfigs);
140            }
141        } else {
142            refererConfig.setRegistries(toList(registryConfigMap));
143        }
144
145
146        return refererConfig;
147    }
148
149
150    public static ServiceConfig toServiceConfig(JbootrpcServiceConfig jbootrpcServiceConfig) {
151        ServiceConfig serviceConfig = new ServiceConfig();
152        RPCUtil.copyDeclaredFields(jbootrpcServiceConfig, serviceConfig);
153
154
155        // reference consumer
156        if (jbootrpcServiceConfig.getProvider() != null) {
157            serviceConfig.setBasicService(baseServiceConfigMap.get(jbootrpcServiceConfig.getProvider()));
158        }
159        // set default consumer
160        else {
161            for (BasicServiceInterfaceConfig baseConfig : baseServiceConfigMap.values()) {
162                if (baseConfig.isDefault() != null && baseConfig.isDefault()) {
163                    serviceConfig.setBasicService(baseConfig);
164                }
165            }
166        }
167
168
169        //service protocol
170        if (StrUtil.isNotBlank(jbootrpcServiceConfig.getProtocol())) {
171            List<ProtocolConfig> protocolConfigs = new ArrayList<>();
172            Set<String> protocolNames = StrUtil.splitToSetByComma(jbootrpcServiceConfig.getProtocol());
173            for (String protocalName : protocolNames) {
174                ProtocolConfig registryConfig = protocolConfigMap.get(protocalName);
175                if (registryConfig != null) {
176                    protocolConfigs.add(registryConfig);
177                }
178            }
179            if (!protocolConfigs.isEmpty()) {
180                serviceConfig.setProtocols(protocolConfigs);
181            }
182        } else {
183            serviceConfig.setProtocols(toList(protocolConfigMap));
184        }
185
186
187        //service registry
188        if (StrUtil.isNotBlank(jbootrpcServiceConfig.getRegistry())) {
189            List<RegistryConfig> registryConfigs = new ArrayList<>();
190            Set<String> registryNames = StrUtil.splitToSetByComma(jbootrpcServiceConfig.getRegistry());
191            for (String registryName : registryNames) {
192                RegistryConfig registryConfig = registryConfigMap.get(registryName);
193                if (registryConfig != null) {
194                    registryConfigs.add(registryConfig);
195                }
196            }
197            if (!registryConfigs.isEmpty()) {
198                serviceConfig.setRegistries(registryConfigs);
199            }
200        } else {
201            serviceConfig.setRegistries(toList(registryConfigMap));
202        }
203
204
205        return serviceConfig;
206    }
207
208
209    public static BasicRefererInterfaceConfig getBaseReferer(String name) {
210        return baseRefererConfigMap.get(name);
211    }
212
213
214    public static BasicServiceInterfaceConfig getBaseService(String name) {
215        return baseServiceConfigMap.get(name);
216    }
217
218    private static <T> Map<String, T> configs(Class<T> clazz, String prefix) {
219        Map<String, T> ret = ConfigUtil.getConfigModels(clazz, prefix);
220
221        if (ret.size() > 0
222                && (clazz == BasicServiceInterfaceConfig.class || clazz == BasicRefererInterfaceConfig.class)
223                && !RPCUtil.isDefaultConfigExist(clazz, ret)) {
224
225            for (Map.Entry<String, T> entry : ret.entrySet()) {
226                if ("default".equals(entry.getKey())) {
227                    if (entry.getValue() instanceof BasicServiceInterfaceConfig) {
228                        ((BasicServiceInterfaceConfig) entry.getValue()).setDefault(true);
229                    } else if (entry.getValue() instanceof BasicRefererInterfaceConfig) {
230                        ((BasicRefererInterfaceConfig) entry.getValue()).setDefault(true);
231                    }
232                }
233            }
234        }
235        return ret;
236    }
237
238    private static <T> List<T> toList(Map<String, T> map) {
239        List<T> list = new ArrayList<>(map.size());
240        for (Map.Entry<String, T> entry : map.entrySet()) {
241            AbstractConfig config = (AbstractConfig) entry.getValue();
242            config.setId(entry.getKey());
243            list.add((T) config);
244        }
245        return list;
246    }
247}