Motan-远程调用的rpc框架的负载均衡策略

article/2025/9/11 4:23:25

虽然我不会，但是偶然之间看到了Motan远程调用框架的一些内容，然后直接copy过来了，想着以后自己可能看看

集群中的loadbalance负载均衡策略

 ActiveWeightLoadBalance===="低并发优化" 负载均衡

/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;/*** "低并发优化" 负载均衡* * <pre>* 		1） 低并发度优先： referer的某时刻的call数越小优先级越高 * * 		2） 低并发referer获取策略：* 				由于Referer List可能很多，比如上百台，如果每次都要从这上百个Referer或者最低并发的几个，性能有些损耗，* 				因此 random.nextInt(list.size()) 获取一个起始的index，然后获取最多不超过MAX_REFERER_COUNT的* 				状态是isAvailable的referer进行判断activeCount.* </pre>* * @author maijunsheng* @version 创建时间：2013-6-14* */
@SpiMeta(name = "activeWeight")
public class ActiveWeightLoadBalance<T> extends AbstractLoadBalance<T> {@Overrideprotected Referer<T> doSelect(Request request) {List<Referer<T>> referers = getReferers();int refererSize = referers.size();int startIndex = ThreadLocalRandom.current().nextInt(refererSize);int currentCursor = 0;int currentAvailableCursor = 0;Referer<T> referer = null;while (currentAvailableCursor < MAX_REFERER_COUNT && currentCursor < refererSize) {Referer<T> temp = referers.get((startIndex + currentCursor) % refererSize);currentCursor++;if (!temp.isAvailable()) {continue;}currentAvailableCursor++;if (referer == null) {referer = temp;} else {if (compare(referer, temp) > 0) {referer = temp;}}}return referer;}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = getReferers();int refererSize = referers.size();int startIndex = ThreadLocalRandom.current().nextInt(refererSize);int currentCursor = 0;int currentAvailableCursor = 0;while (currentAvailableCursor < MAX_REFERER_COUNT && currentCursor < refererSize) {Referer<T> temp = referers.get((startIndex + currentCursor) % refererSize);currentCursor++;if (!temp.isAvailable()) {continue;}currentAvailableCursor++;refersHolder.add(temp);}Collections.sort(refersHolder, new LowActivePriorityComparator<T>());}private int compare(Referer<T> referer1, Referer<T> referer2) {return referer1.activeRefererCount() - referer2.activeRefererCount();}static class LowActivePriorityComparator<T> implements Comparator<Referer<T>> {@Overridepublic int compare(Referer<T> referer1, Referer<T> referer2) {return referer1.activeRefererCount() - referer2.activeRefererCount();}}}

ConfigurableWeightLoadBalance=======权重可配置的负载均衡器
/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;
import com.weibo.api.motan.util.CollectionUtil;
import com.weibo.api.motan.util.LoggerUtil;
import com.weibo.api.motan.util.MathUtil;import org.apache.commons.lang3.StringUtils;import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;/*** 权重可配置的负载均衡器** @author chengya1*/
@SpiMeta(name = "configurableWeight")
public class ConfigurableWeightLoadBalance<T> extends ActiveWeightLoadBalance<T> {@SuppressWarnings("rawtypes")private static final RefererListCacheHolder emptyHolder = new EmptyHolder();@SuppressWarnings("unchecked")private volatile RefererListCacheHolder<T> holder = emptyHolder;private String weightString;@SuppressWarnings("unchecked")@Overridepublic void onRefresh(List<Referer<T>> referers) {super.onRefresh(referers);if (CollectionUtil.isEmpty(referers)) {holder = emptyHolder;} else if (StringUtils.isEmpty(weightString)) {holder = new SingleGroupHolder<T>(referers);} else {holder = new MultiGroupHolder<T>(weightString, referers);}}@Overrideprotected Referer<T> doSelect(Request request) {if (holder == emptyHolder) {return null;}RefererListCacheHolder<T> h = this.holder;Referer<T> r = h.next();if (!r.isAvailable()) {int retryTimes = getReferers().size() - 1;for (int i = 0; i < retryTimes; i++) {r = h.next();if (r.isAvailable()) {break;}}}if (r.isAvailable()) {return r;} else {noAvailableReferer();return null;}}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {if (holder == emptyHolder) {return;}RefererListCacheHolder<T> h = this.holder;int i = 0, j = 0;while (i++ < getReferers().size()) {Referer<T> r = h.next();if (r.isAvailable()) {refersHolder.add(r);if (++j == MAX_REFERER_COUNT) {return;}}}if (refersHolder.isEmpty()) {noAvailableReferer();}}private void noAvailableReferer() {LoggerUtil.error(this.getClass().getSimpleName() + " 当前没有可用连接, pool.size=" + getReferers().size());}@Overridepublic void setWeightString(String weightString) {this.weightString = weightString;}/****************************************************************************************** ************************************************************************************* ******************************************************************************************/static abstract class RefererListCacheHolder<T> {abstract Referer<T> next();}static class EmptyHolder<T> extends RefererListCacheHolder<T> {@OverrideReferer<T> next() {return null;}}@SuppressWarnings("hiding")class SingleGroupHolder<T> extends RefererListCacheHolder<T> {private int size;private List<Referer<T>> cache;SingleGroupHolder(List<Referer<T>> list) {cache = list;size = list.size();LoggerUtil.info("ConfigurableWeightLoadBalance build new SingleGroupHolder.");}@OverrideReferer<T> next() {return cache.get(ThreadLocalRandom.current().nextInt(size));}}@SuppressWarnings("hiding")class MultiGroupHolder<T> extends RefererListCacheHolder<T> {private int randomKeySize = 0;private List<String> randomKeyList = new ArrayList<String>();private Map<String, AtomicInteger> cursors = new HashMap<String, AtomicInteger>();private Map<String, List<Referer<T>>> groupReferers = new HashMap<String, List<Referer<T>>>();MultiGroupHolder(String weights, List<Referer<T>> list) {LoggerUtil.info("ConfigurableWeightLoadBalance build new MultiGroupHolder. weights:" + weights);String[] groupsAndWeights = weights.split(",");int[] weightsArr = new int[groupsAndWeights.length];Map<String, Integer> weightsMap = new HashMap<String, Integer>(groupsAndWeights.length);int i = 0;for (String groupAndWeight : groupsAndWeights) {String[] gw = groupAndWeight.split(":");if (gw.length == 2) {Integer w = Integer.valueOf(gw[1]);weightsMap.put(gw[0], w);groupReferers.put(gw[0], new ArrayList<Referer<T>>());weightsArr[i++] = w;}}// 求出最大公约数，若不为1，对权重做除法int weightGcd = findGcd(weightsArr);if (weightGcd != 1) {for(Map.Entry<String,Integer> entry: weightsMap.entrySet()) {weightsMap.put(entry.getKey(),entry.getValue()/weightGcd);}}for (Map.Entry<String, Integer> entry : weightsMap.entrySet()) {for (int j = 0; j < entry.getValue(); j++) {randomKeyList.add(entry.getKey());}}Collections.shuffle(randomKeyList);randomKeySize = randomKeyList.size();for (String key : weightsMap.keySet()) {cursors.put(key, new AtomicInteger(0));}for (Referer<T> referer : list) {groupReferers.get(referer.getServiceUrl().getGroup()).add(referer);}}@OverrideReferer<T> next() {String group = randomKeyList.get(ThreadLocalRandom.current().nextInt(randomKeySize));AtomicInteger ai = cursors.get(group);List<Referer<T>> referers = groupReferers.get(group);return referers.get(MathUtil.getPositive(ai.getAndIncrement()) % referers.size());}// 求最大公约数private int findGcd(int n, int m) {return (n == 0 || m == 0) ? n + m : findGcd(m, n % m);}// 求最大公约数private int findGcd(int[] arr) {int i = 0;for (; i < arr.length - 1; i++) {arr[i + 1] = findGcd(arr[i], arr[i + 1]);}return findGcd(arr[i], arr[i - 1]);}}}

consistent======一致性Hash
/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;import com.weibo.api.motan.common.MotanConstants;
import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;
import com.weibo.api.motan.util.MathUtil;/*** * Use consistent hash to choose referer** @author fishermen* @version V1.0 created at: 2013-5-21*/
@SpiMeta(name = "consistent")
public class ConsistentHashLoadBalance<T> extends AbstractLoadBalance<T> {private List<Referer<T>> consistentHashReferers;@Overridepublic void onRefresh(List<Referer<T>> referers) {super.onRefresh(referers);List<Referer<T>> copyReferers = new ArrayList<Referer<T>>(referers);List<Referer<T>> tempRefers = new ArrayList<Referer<T>>();for (int i = 0; i < MotanConstants.DEFAULT_CONSISTENT_HASH_BASE_LOOP; i++) {Collections.shuffle(copyReferers);for (Referer<T> ref : copyReferers) {tempRefers.add(ref);}}consistentHashReferers = tempRefers;}@Overrideprotected Referer<T> doSelect(Request request) {int hash = getHash(request);Referer<T> ref;for (int i = 0; i < getReferers().size(); i++) {ref = consistentHashReferers.get((hash + i) % consistentHashReferers.size());if (ref.isAvailable()) {return ref;}}return null;}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = getReferers();int hash = getHash(request);for (int i = 0; i < referers.size(); i++) {Referer<T> ref = consistentHashReferers.get((hash + i) % consistentHashReferers.size());if (ref.isAvailable()) {refersHolder.add(ref);}}}private int getHash(Request request) {int hashcode;if (request.getArguments() == null || request.getArguments().length == 0) {hashcode = request.hashCode();} else {hashcode = Arrays.hashCode(request.getArguments());}return MathUtil.getPositive(hashcode);}}

localFirst===="本地服务优先" 负载均衡

/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;
import com.weibo.api.motan.util.LoggerUtil;
import com.weibo.api.motan.util.NetUtils;import java.util.*;
import java.util.concurrent.ThreadLocalRandom;/*** "本地服务优先" 负载均衡* <p>* <pre>* 		1） 本地服务优先：*   		当referers里面包含本地暴露的服务时，并此服务为available的情况下，优先使用此服务。* 			当不存在本地暴露的服务时，默认使用低并发ActiveWeight负载均衡策略** 		2） 本地服务优先获取策略：* 			对referers根据ip顺序查找本地服务，多存在多个本地服务，获取Active最小的本地服务进行服务。* 			当不存在本地服务，但是存在远程RPC服务，则根据ActivWeight获取远程RPC服务* 			当两者都存在，所有本地服务都应优先于远程服务，本地RPC服务与远程RPC服务内部则根据ActiveWeight进行** </pre>*/
@SpiMeta(name = "localFirst")
public class LocalFirstLoadBalance<T> extends AbstractLoadBalance<T> {public static final int MAX_REFERER_COUNT = 10;public static long ipToLong(final String addr) {final String[] addressBytes = addr.split("\\.");int length = addressBytes.length;if (length < 3) {return 0;}long ip = 0;try {for (int i = 0; i < 4; i++) {ip <<= 8;ip |= Integer.parseInt(addressBytes[i]);}} catch (Exception e) {LoggerUtil.warn("Warn ipToInt addr is wrong: addr=" + addr);}return ip;}@Overrideprotected Referer<T> doSelect(Request request) {List<Referer<T>> referers = getReferers();List<Referer<T>> localReferers = searchLocalReferer(referers, NetUtils.getLocalAddress().getHostAddress());if (!localReferers.isEmpty()) {referers = localReferers;}int refererSize = referers.size();Referer<T> referer = null;for (int i = 0; i < refererSize; i++) {Referer<T> temp = referers.get(i % refererSize);if (!temp.isAvailable()) {continue;}if (referer == null) {referer = temp;} else {if (compare(referer, temp) > 0) {referer = temp;}}}return referer;}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = getReferers();List<Referer<T>> localReferers = searchLocalReferer(referers, NetUtils.getLocalAddress().getHostAddress());if (!localReferers.isEmpty()) {Collections.sort(localReferers, new LowActivePriorityComparator<T>());refersHolder.addAll(localReferers);}int refererSize = referers.size();int startIndex = ThreadLocalRandom.current().nextInt(refererSize);int currentCursor = 0;int currentAvailableCursor = 0;List<Referer<T>> remoteReferers = new ArrayList<Referer<T>>();while (currentAvailableCursor < MAX_REFERER_COUNT && currentCursor < refererSize) {Referer<T> temp = referers.get((startIndex + currentCursor) % refererSize);currentCursor++;if (!temp.isAvailable() || localReferers.contains(temp)) {continue;}currentAvailableCursor++;remoteReferers.add(temp);}Collections.sort(remoteReferers, new LowActivePriorityComparator<T>());refersHolder.addAll(remoteReferers);}private List<Referer<T>> searchLocalReferer(List<Referer<T>> referers, String localhost) {List<Referer<T>> localReferers = new ArrayList<Referer<T>>();long local = ipToLong(localhost);for (Referer<T> referer : referers) {long tmp = ipToLong(referer.getUrl().getHost());if (local != 0 && local == tmp) {if (referer.isAvailable()) {localReferers.add(referer);}}}return localReferers;}private int compare(Referer<T> referer1, Referer<T> referer2) {return referer1.activeRefererCount() - referer2.activeRefererCount();}static class LowActivePriorityComparator<T> implements Comparator<Referer<T>> {@Overridepublic int compare(Referer<T> referer1, Referer<T> referer2) {return referer1.activeRefererCount() - referer2.activeRefererCount();}}
}

RandomLoadBalance=====随机
/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import java.util.List;
import java.util.concurrent.ThreadLocalRandom;import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;/*** * random load balance.** @author fishermen* @version V1.0 created at: 2013-5-21*/
@SpiMeta(name = "random")
public class RandomLoadBalance<T> extends AbstractLoadBalance<T> {@Overrideprotected Referer<T> doSelect(Request request) {List<Referer<T>> referers = getReferers();int idx = (int) (ThreadLocalRandom.current().nextDouble() * referers.size());for (int i = 0; i < referers.size(); i++) {Referer<T> ref = referers.get((i + idx) % referers.size());if (ref.isAvailable()) {return ref;}}return null;}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = getReferers();int idx = (int) (ThreadLocalRandom.current().nextDouble() * referers.size());for (int i = 0; i < referers.size(); i++) {Referer<T> referer = referers.get((i + idx) % referers.size());if (referer.isAvailable()) {refersHolder.add(referer);}}}
}

RoundRobinLoadBalance======轮询
/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;import com.weibo.api.motan.core.extension.SpiMeta;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;
import com.weibo.api.motan.util.MathUtil;/*** * Round robin loadbalance.* * @author fishermen* @version V1.0 created at: 2013-6-13*/
@SpiMeta(name = "roundrobin")
public class RoundRobinLoadBalance<T> extends AbstractLoadBalance<T> {private AtomicInteger idx = new AtomicInteger(0);@Overrideprotected Referer<T> doSelect(Request request) {List<Referer<T>> referers = getReferers();int index = getNextPositive();for (int i = 0; i < referers.size(); i++) {Referer<T> ref = referers.get((i + index) % referers.size());if (ref.isAvailable()) {return ref;}}return null;}@Overrideprotected void doSelectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = getReferers();int index = getNextPositive();for (int i = 0, count = 0; i < referers.size() && count < MAX_REFERER_COUNT; i++) {Referer<T> referer = referers.get((i + index) % referers.size());if (referer.isAvailable()) {refersHolder.add(referer);count++;}}}// get positive intprivate int getNextPositive() {return MathUtil.getPositive(idx.incrementAndGet());}
}

父类--虚负载均衡class===AbstractLoadBalance

/**  Copyright 2009-2016 Weibo, Inc.**    Licensed under the Apache License, Version 2.0 (the "License");*    you may not use this file except in compliance with the License.*    You may obtain a copy of the License at**        http://www.apache.org/licenses/LICENSE-2.0**    Unless required by applicable law or agreed to in writing, software*    distributed under the License is distributed on an "AS IS" BASIS,*    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*    See the License for the specific language governing permissions and*    limitations under the License.*/package com.weibo.api.motan.cluster.loadbalance;import com.weibo.api.motan.cluster.LoadBalance;
import com.weibo.api.motan.exception.MotanServiceException;
import com.weibo.api.motan.rpc.Referer;
import com.weibo.api.motan.rpc.Request;
import com.weibo.api.motan.util.LoggerUtil;
import com.weibo.api.motan.util.MotanFrameworkUtil;import java.util.List;/*** * loadbalance* * @author fishermen* @version V1.0 created at: 2013-5-22*/public abstract class AbstractLoadBalance<T> implements LoadBalance<T> {public static final int MAX_REFERER_COUNT = 10;private List<Referer<T>> referers;@Overridepublic void onRefresh(List<Referer<T>> referers) {// 只能引用替换，不能进行referers update。this.referers = referers;}@Overridepublic Referer<T> select(Request request) {List<Referer<T>> referers = this.referers;if (referers == null) {throw new MotanServiceException(this.getClass().getSimpleName() + " No available referers for call request:" + request);}Referer<T> ref = null;if (referers.size() > 1) {ref = doSelect(request);} else if (referers.size() == 1) {ref = referers.get(0).isAvailable() ? referers.get(0) : null;}if (ref != null) {return ref;}throw new MotanServiceException(this.getClass().getSimpleName() + " No available referers for call request:" + request);}@Overridepublic void selectToHolder(Request request, List<Referer<T>> refersHolder) {List<Referer<T>> referers = this.referers;if (referers == null) {throw new MotanServiceException(this.getClass().getSimpleName() + " No available referers for call : referers_size= 0 "+ MotanFrameworkUtil.toString(request));}if (referers.size() > 1) {doSelectToHolder(request, refersHolder);} else if (referers.size() == 1 && referers.get(0).isAvailable()) {refersHolder.add(referers.get(0));}if (refersHolder.isEmpty()) {throw new MotanServiceException(this.getClass().getSimpleName() + " No available referers for call : referers_size="+ referers.size() + " " + MotanFrameworkUtil.toString(request));}}protected List<Referer<T>> getReferers() {return referers;}@Overridepublic void setWeightString(String weightString) {LoggerUtil.info("ignore weightString:" + weightString);}protected abstract Referer<T> doSelect(Request request);protected abstract void doSelectToHolder(Request request, List<Referer<T>> refersHolder);
}

 


http://chatgpt.dhexx.cn/article/H8pvHK6h.shtml

相关文章

motan源码分析五：cluster相关

motan源码分析五：cluster相关

上一章我们分析了客户端调用服务端相关的源码&#xff0c;但是到了cluster里面的部分我们就没有分析了&#xff0c;本章将深入分析cluster和它的相关支持类。 1.clustersupport的创建过程&#xff0c;上一章的ReferConfig的initRef()方法中调用了相关的创建代码&#xff1a; fo…
阅读更多...
java 微博 开源_微博开源框架Motan初体验

java 微博 开源_微博开源框架Motan初体验

前两天&#xff0c;我在开源中国的微信公众号看到新浪微博的轻量Rpc框架——Motan开源了。上网查了下&#xff0c;才得知这个Motan来头不小&#xff0c;支撑着新浪微博的千亿调用&#xff0c;曾经在2014年的春晚中有着千亿次的调用&#xff0c;对抗了春晚的最高峰值。 什么是Mo…
阅读更多...
搭建新浪RPC框架motan Demo

搭建新浪RPC框架motan Demo

motan是新浪微博开源的RPC框架&#xff0c;github官网是&#xff1a;https://github.com/weibocom/motan 今天就先搭建一个Hello world demo&#xff0c;本demo基于motan 0.2.1版本 首先先去github下载源代码&#xff08;motan-manager报错请忽略&#xff0c;eclipse的web Mod…
阅读更多...
微博RPC框架Motan

微博RPC框架Motan

原文来自&#xff1a;http://blog.csdn.net/autfish/article/details/51374798 从14年开始就陆续看到新浪微博RPC框架Motan的介绍&#xff0c;时隔两年后&#xff0c;微博团队终于宣布开源轻量级RPC框架Motan&#xff0c;项目地址&#xff1a; https://github.com/weibocom/mot…
阅读更多...
motan rpc 接口统一异常处理

motan rpc 接口统一异常处理

1.hello word 一个Motan扩展 大概需要下面的三点&#xff1a; 实现SPI扩展点接口 package com.weibo.api.motan.filter; Spi public interface Filter {Response filter(Caller<?> caller, Request request); }业务代码实现Filter public class PlsProviderExceptionF…
阅读更多...
motan用户开发指南

motan用户开发指南

目录 基本介绍 架构概述 模块概述 配置概述 使用Motan 工程依赖 处理调用异常 配置说明 协议与连接&#xff08;motan:protocol) 介绍 Motan协议 本地调用 注册中心与服务发现(motan:registry) 介绍 使用Consul作为注册中心 使用Zookeeper作为注册中心 不使用…
阅读更多...
从motan看RPC框架设计

从motan看RPC框架设计

kris的文章开始 计算机科学领域的任何问题都可以通过增加一个间接的中间层来解决 从零开发一款RPC框架&#xff0c;说难也难说简单也简单。难的是你的设计将如何面对实际中的复杂应用场景&#xff1b;简单的是其思想可以仅仅浓缩成一行方法调用。motan是今年(2016年)新浪微博…
阅读更多...
motan与zookeeper框架

motan与zookeeper框架

新浪科技讯 2016年5月10日&#xff0c;微博方面宣布&#xff0c;支撑微博千亿调用的轻量级 RPC 框架 Motan 正式开源了。微博技术团队希望未来能有更多优秀的开源人入驻&#xff0c;并进一步完善优化。 搭建新浪RPC框架motan Demo&#xff1a;http://blog.csdn.net/linuu/arti…
阅读更多...
java rpc motan_RPC框架motan使用

java rpc motan_RPC框架motan使用

简介 motan是新浪微博开源的一套轻量级、方便使用的RPC框架 Hello World 使用的过程分为Server端和Client端&#xff0c;Server提供RCP的服务接口&#xff0c;Client端发起调用获取结果。 maven的pom文件配置 0.2.1 com.weibo motan-core ${motan.version} com.weibo motan-tra…
阅读更多...
轻量级Rpc框架设计--motan源码解析一:框架介绍及框架使用初体验

轻量级Rpc框架设计--motan源码解析一:框架介绍及框架使用初体验

一, 框架介绍 1.1 概况 motan是新浪微博开源出来的一套高性能、易于使用的分布式远程服务调用(RPC)框架。 1.2 功能 可以spring的配置方式与项目集成. 支持zookeeper服务发现组件, 实现集群环境下服务注册与发现. 保证高并发, 高负载场景下的稳定高性能, , 实现生产环境…
阅读更多...
Motan原理、使用、JavaAPI简化、为什么使用Motan

Motan原理、使用、JavaAPI简化、为什么使用Motan

前言&#xff0c;本文包括&#xff0c;rpc解释与为什么使用rpc、rpc性能对比、Motan依赖问题、Motan源码梳理、Motan功能、特点、使用。 主要中心&#xff1a;为什么使用Motan? 一、什么是RPC 官方解释&#xff1a;RPC&#xff08;Remote Procedure Call&#xff09;—远程…
阅读更多...
jplayer自动播放

jplayer自动播放

音乐网站的播放器一直都没有解决自动播放的问题&#xff0c;小哲说这样不行的&#xff0c;我也知道不可以这样&#xff0c;毕竟是自己提出要做的&#xff0c;所以要尽自己最大的能力去做好它&#xff01;本周末我一直都在围绕这个问题而研究。 我曾经想过在播放器初始化的时候…
阅读更多...
JWPlayer

JWPlayer

原文&#xff1a; http://www.cnblogs.com/yukui/archive/2009/03/12/1409469.html The JW MP3 Player (built with Adobes Flash) is the easiest way to add live music or podcasts to your website. It supports playback of a single MP3 file or an RSS, XSPF or ASX pla…
阅读更多...
今天开始写些随笔，就从Jplayer开始吧

今天开始写些随笔，就从Jplayer开始吧

今天才开始用Jplayer&#xff0c;可能有点落伍了&#xff0c;但是看到网上千篇一律的使用说明&#xff0c;开始决定把自己的使用心得分享一下&#xff0c;废话不多说&#xff0c;开始吧。 Step1&#xff1a; 官网上有具体的搭建顺序&#xff0c;URL&#xff1a;http://www.jp…
阅读更多...
关于播放器JPlayer的使用及遇到的问题

关于播放器JPlayer的使用及遇到的问题

jPlayer是一个用于控制和播放mp3文件的jQuery插件。它在后台使用Flash来播放mp3文件&#xff0c;前台播放器外观完全可以使用XHML/CSS自定义。支持&#xff1a; 有一点比较好的是&#xff0c;在支持html5的浏览器上会使用html5的标签audio或者video&#xff0c;而不支持的浏览…
阅读更多...
ijkplayer支持播放rtsp、jpeg、gif

ijkplayer支持播放rtsp、jpeg、gif

ijkplayer版本&#xff1a;k.0.8.8 编译环境&#xff1a;Ubuntu 18.04.6 LTS 使用平台&#xff1a;android 支持rtsp播放 默认的ijkplayer并不支持rtsp流的播放&#xff0c;因为在编译ffmpeg的时候并没有开启rtsp的demuxer&#xff0c;所以在编译ffmpeg的时候需要开启rtsp的d…
阅读更多...
【ijkplayer】介绍

【ijkplayer】介绍

【ijkplayer】介绍 0x1 系统架构 ijkplayer是由b站开源的播放器项目&#xff0c;底层基于ffmpeg, 支持Android和iOS。下面我们来简单介绍一下Android上的实现。 Android上的系统架构图如下。 下面分别对各个模块进行介绍&#xff1a; 0x11 ijkplayer-example app的实现&a…
阅读更多...
一款简洁的 jplayer 音乐播放器完整版

一款简洁的 jplayer 音乐播放器完整版

一款简洁 jplayer 音乐播放器&#xff0c;做音乐站很漂亮&#xff0c;直接套用就好了。 效果图&#xff1a; 部分源代码&#xff1a; <div id"lei_jplayer"></div> <div id"jp_container_1"><div class"jp-controls">…
阅读更多...
Ijkplayer Android介绍

Ijkplayer Android介绍

Ijkplayer Android目录结构 Ijkplayer Android可以将该工程导入android studio进行编译&#xff0c;当它下载好需要的资源文件&#xff08;例如sdk build tool&#xff0c;gradle等&#xff09;就可以进行编译了&#xff0c;该工程的目录结构如下图所示: 链接库&#xff1a…
阅读更多...
ijkplayer播放器

ijkplayer播放器

播放器系列 android播放器&#xff1a;MediaPlayer ExoPlayer ijkplayer_步基的博客-CSDN博客_mediacodec流程 一 概述 IJKPlayer是一款基于ffmpeg/ffplay的开源播放器&#xff0c;可支持rtmp/rtsp/hls等多种媒体协议&#xff0c;支持Android/IOS等移动平台。项目地址&#xff…
阅读更多...
推荐文章

Copyright @ 2022~2023