Dubbo之降級(jí)Mock源碼分析

限流，熔斷，降級(jí)，

通俗的講，降級(jí)可以形容為一些事件A的觸發(fā)導(dǎo)致發(fā)生取代原有事件B的事件C，而熔斷和限流就是這些事件A的其中之一。
熔斷是異常情況發(fā)生的保護(hù)措施，比如調(diào)用供應(yīng)商1的短信API失敗，改為調(diào)用供應(yīng)商2的短信API。
限流是防止異常情況發(fā)生的措施，比如搶票時(shí)候拋出的提示。
一句口訣，消費(fèi)者(使用)熔斷，提供者(使用)限流。

上面也講了熔斷和限流是觸發(fā)降級(jí)其中兩個(gè)事件，那么在dubbo中我們?nèi)绾斡|發(fā)降級(jí)(mock)？

  1. 通過服務(wù)治理觸發(fā)(dubbo-admin)
  2. 配置接口mock參數(shù)觸發(fā)

Dubbo中降級(jí)的使用

這邊的講解從通過配置接口mock參數(shù)觸發(fā)降級(jí)的方式入手，其實(shí)服務(wù)治理也是相當(dāng)于通過Override機(jī)制給接口增加了mock參數(shù)配置。

mock表達(dá)式格式

[force/fail] (return xxx |throw xxx | fail | true |default | {mockClassName} ) | false

如果表達(dá)式為false，表示不啟用降級(jí)功能
如果表達(dá)式以force為前綴，表示強(qiáng)制降級(jí)
如果表達(dá)以fail為前綴或者沒有前綴，表示失敗降級(jí)

去除force或fail前綴后，剩下的表達(dá)式表示具體的降級(jí)邏輯，邏輯如下

mock表達(dá)式 作用
true/default/fail 調(diào)用接口+Mock類對(duì)應(yīng)的方法
{mockClass} 調(diào)用${mockClass}對(duì)應(yīng)方法
return xxx 解析xxx為方法返回類型的對(duì)象返回
throw namespace...xxxException 拋出對(duì)應(yīng)xxxException異常

其中對(duì)于xxx，支持基本類型，Collection，Map以及自定義對(duì)象

具體示例如下

示例 類型
empty 返回各種類型的空實(shí)現(xiàn)
null 直接返回null
true/false 返回對(duì)應(yīng)布爾類型
`abc`,abc 根據(jù)方法返回類型解析，可能是String或枚舉
{...} 根據(jù)方法返回類型解析，可能是map或自定義對(duì)象
[...] 根據(jù)方法返回類型解析，可以是Collection中的任意一種

如何配置mock表達(dá)式

mock表達(dá)式的配置方式一共有3種

  • 通過xml或@Reference的mock字段
  • Dubbo Admin控制臺(tái)
    -在zk設(shè)置Override動(dòng)態(tài)配置

后兩種的原理都是對(duì)zk節(jié)點(diǎn)進(jìn)行操作。

首先講下第一種配置方式

<dubbo:reference id="demoService" check="false" interface="com.alibaba.dubbo.demo.DemoService" mock="return scj">
            <dubbo:parameter key="sayHello.mock" value="return scj" />
 </dubbo:reference>

因?yàn)閟pring對(duì)xml的配置是不支持引號(hào)，方括號(hào)，尖括號(hào)等符號(hào)的，滿足的格式如以下正則

private static final Pattern PATTERN_NAME_HAS_SYMBOL = Pattern.compile("[:*,\\s/\\-._0-9a-zA-Z]+");

所以通過項(xiàng)目中配置的mock行為是有限的，因此在項(xiàng)目中推薦配置失敗降級(jí)，通過一個(gè)Mock類來實(shí)現(xiàn)我們的降級(jí)邏輯。

而通過Dubbo-admin控制臺(tái)去配置mock，更適合強(qiáng)制降級(jí)的場(chǎng)景。

通過zk觸發(fā)強(qiáng)制降級(jí)示例代碼如下

create -e /dubbo/com.alibaba.dubbo.demo.DemoService/configurators/override%3a%2f%2f10.111.27.41%3a20880%2fcom.alibaba.dubbo.demo.DemoService%3fsayHello.mock%3dforce%3areturn+%60scj+mock+hhh%60%26category%3dconfigurators 1

具體這個(gè)配置是如何生效的，可以看下我寫的ZookeeperRegistry這篇文章。

源碼分析

首先是找入口，入口類為MockClusterWrapper

public class MockClusterWrapper implements Cluster {

    private Cluster cluster;

    public MockClusterWrapper(Cluster cluster) {
        this.cluster = cluster;
    }

    @Override
    public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
        return new MockClusterInvoker<T>(directory,
                this.cluster.join(directory));
    }

}

這個(gè)類是一個(gè)SPI自動(dòng)包裝類，包裝(AOP)的mock邏輯會(huì)強(qiáng)制觸發(fā)。

MockClusterWrapper的join方法會(huì)返回MockClusterInvoker，MockClusterInvoker會(huì)包裝實(shí)際cluster生成的ClusterInvoker，以此來實(shí)現(xiàn)對(duì)mock邏輯的注入。

我們看下MockClusterInvoker#invoke方法增加了什么邏輯。

public Result invoke(Invocation invocation) throws RpcException {
        Result result = null;
        //獲取directoryUrl，會(huì)包括客戶端和Configuration節(jié)點(diǎn)url的合并url
        //從method.xxx獲取參數(shù)，如果沒有，直接從xxx參數(shù)獲取
        String value = directory.getUrl().getMethodParameter(invocation.getMethodName(), Constants.MOCK_KEY, Boolean.FALSE.toString()).trim();
        if (value.length() == 0 || value.equalsIgnoreCase("false")) {
            //如果沒有mock配置，不走mock邏輯
            result = this.invoker.invoke(invocation);
        } else if (value.startsWith("force")) {
            //force開頭，強(qiáng)制進(jìn)行mock //這個(gè)force只能通過override觸發(fā)
            if (logger.isWarnEnabled()) {
                logger.info("force-mock: " + invocation.getMethodName() + " force-mock enabled , url : " + directory.getUrl());
            }
            //force:direct mock
            result = doMockInvoke(invocation, null);
        } else {
            //不是force開頭，調(diào)用失敗走mock邏輯
            try {
                result = this.invoker.invoke(invocation);
            } catch (RpcException e) {
                if (e.isBiz()) {
                    throw e;
                } else {
                    if (logger.isWarnEnabled()) {
                        logger.warn("fail-mock: " + invocation.getMethodName() + " fail-mock enabled , url : " + directory.getUrl(), e);
                    }
                    //不是force開頭，會(huì)在調(diào)用失敗后，走mock邏輯
                    result = doMockInvoke(invocation, e);
                }
            }
        }
        return result;
    }

MockClusterInvoker#invoke方法首先會(huì)通過mock配置是否為force開頭或者是否為false來判斷走強(qiáng)制降級(jí)，失敗降級(jí)還是不走降級(jí)邏輯。

  • 強(qiáng)制Mock，直接調(diào)用mock邏輯，屏蔽對(duì)提供者調(diào)用
  • 失敗Mock，會(huì)先進(jìn)行集群調(diào)用，出現(xiàn)異常后，再走mock邏輯

mock邏輯入口為doMockInvoke方法，在該方法內(nèi)封裝了一個(gè)隱藏邏輯。之前我們都認(rèn)為觸發(fā)mock是通過dubbo的override機(jī)制，但是看了這個(gè)方法后發(fā)現(xiàn)，我們可以在zk的下增加一個(gè)mock協(xié)議的提供者，也是能夠觸發(fā)mock的，并且后者的優(yōu)先級(jí)大于前者。

private Result doMockInvoke(Invocation invocation, RpcException e) {
        Result result = null;
        Invoker<T> minvoker;

        //如果有mock協(xié)議的provider 優(yōu)先使用mock provider
        List<Invoker<T>> mockInvokers = selectMockInvoker(invocation);
        if (CollectionUtils.isEmpty(mockInvokers)) {
            //使用override后的url生成mockinvoker
            minvoker = (Invoker<T>) new MockInvoker(directory.getUrl());
        } else {
            //使用mock provider
            minvoker = mockInvokers.get(0);
        }
        try {
            result = minvoker.invoke(invocation);
        } catch (RpcException me) {
            if (me.isBiz()) {
                result = new RpcResult(me.getCause());
            } else {
                throw new RpcException(me.getCode(), getMockExceptionMessage(e, me), me.getCause());
            }
        } catch (Throwable me) {
            throw new RpcException(getMockExceptionMessage(e, me), me.getCause());
        }
        return result;
    }

不管是通過何種方式設(shè)置的mock邏輯，最終在doMockInvoke我們都會(huì)拿到一個(gè)MockInvoker，關(guān)于Mock表達(dá)式的解析，mock對(duì)象的返回等邏輯都封裝在這個(gè)Invoker里。

MockInvoker的源碼解析如下，和我上面列的mock表達(dá)式配置基本一致。

final public class MockInvoker<T> implements Invoker<T> {
    private final static ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
    private final static Map<String, Invoker<?>> mocks = new ConcurrentHashMap<String, Invoker<?>>();
    private final static Map<String, Throwable> throwables = new ConcurrentHashMap<String, Throwable>();

    private final URL url;

    public MockInvoker(URL url) {
        this.url = url;
    }

    public static Object parseMockValue(String mock) throws Exception {
        return parseMockValue(mock, null);
    }

    public static Object parseMockValue(String mock, Type[] returnTypes) throws Exception {
        Object value = null;
        if ("empty".equals(mock)) {
            //如果是empty value等于對(duì)應(yīng)類型空實(shí)現(xiàn) 具體邏輯見getEmptyObject
            value = ReflectUtils.getEmptyObject(returnTypes != null && returnTypes.length > 0 ? (Class<?>) returnTypes[0] : null);
        } else if ("null".equals(mock)) {
            value = null;
        } else if ("true".equals(mock)) {
            value = true;
        } else if ("false".equals(mock)) {
            value = false;
        } else if (mock.length() >= 2 && (mock.startsWith("\"") && mock.endsWith("\"")
                || mock.startsWith("\'") && mock.endsWith("\'"))) {
            //去除前后引號(hào)
            value = mock.subSequence(1, mock.length() - 1);
        } else if (returnTypes != null && returnTypes.length > 0 && returnTypes[0] == String.class) {
            //返回類型為String類型
            value = mock;
        } else if (StringUtils.isNumeric(mock, false)) {
            //如果是數(shù)字
            value = JSON.parse(mock);
        } else if (mock.startsWith("{")) {
            //{開頭 Json反序列化解析為Map
            value = JSON.parseObject(mock, Map.class);
        } else if (mock.startsWith("[")) {
            //[開頭 Json反序列化解析為List
            value = JSON.parseObject(mock, List.class);
        } else {
            //其他 不做處理
            value = mock;
        }
        //如果returnTypes不為空 進(jìn)一步做處理
        if (ArrayUtils.isNotEmpty(returnTypes)) {
            //returnTypes[0]為目標(biāo)類型  returnTypes[1]為目標(biāo)類型的泛型類型
            value = PojoUtils.realize(value, (Class<?>) returnTypes[0], returnTypes.length > 1 ? returnTypes[1] : null);
        }
        return value;
    }

    @Override
    public Result invoke(Invocation invocation) throws RpcException {
        //獲取針對(duì)方法的mock配置
        String mock = getUrl().getParameter(invocation.getMethodName() + "." + Constants.MOCK_KEY);
        if (invocation instanceof RpcInvocation) {
            ((RpcInvocation) invocation).setInvoker(this);
        }
        //如果針對(duì)方法沒有mock配置 取接口級(jí)別的mock配置
        if (StringUtils.isBlank(mock)) {
            mock = getUrl().getParameter(Constants.MOCK_KEY);
        }

        //如果沒有mock配置拋出異常
        if (StringUtils.isBlank(mock)) {
            throw new RpcException(new IllegalAccessException("mock can not be null. url :" + url));
        }
        //標(biāo)準(zhǔn)化mock配置 方便下面匹配
        mock = normalizeMock(URL.decode(mock));
        //return 開頭
        if (mock.startsWith(Constants.RETURN_PREFIX)) {
            //去除return
            mock = mock.substring(Constants.RETURN_PREFIX.length()).trim();
            try {
                //獲取這個(gè)接口的返回類型
                Type[] returnTypes = RpcUtils.getReturnTypes(invocation);
                //mock配置反序列化為對(duì)應(yīng)類型的value
                Object value = parseMockValue(mock, returnTypes);
                return new RpcResult(value);
            } catch (Exception ew) {
                throw new RpcException("mock return invoke error. method :" + invocation.getMethodName()
                        + ", mock:" + mock + ", url: " + url, ew);
            }
        } else if (mock.startsWith(Constants.THROW_PREFIX)) { //throw 開頭
            //去除throw
            mock = mock.substring(Constants.THROW_PREFIX.length()).trim();
            //如果mock為空 ，降級(jí)為拋出RpcException
            if (StringUtils.isBlank(mock)) {
                throw new RpcException("mocked exception for service degradation.");
            } else { // user customized class
                //反序列化為用戶自定義異常
                Throwable t = getThrowable(mock);
                //用RpcException包裝自定義異常拋出
                //注意異常類型設(shè)置為業(yè)務(wù)異常
                throw new RpcException(RpcException.BIZ_EXCEPTION, t);
            }
        } else { //impl mock
            try {
                //default或者具體接口實(shí)現(xiàn)類，默認(rèn)使用接口Mock這個(gè)類實(shí)現(xiàn)mock邏輯
                Invoker<T> invoker = getInvoker(mock);
                return invoker.invoke(invocation);
            } catch (Throwable t) {
                throw new RpcException("Failed to create mock implementation class " + mock, t);
            }
        }
    }

    /**
     * 生成mock異常對(duì)象
     * @param throwstr
     * @return
     */
    public static Throwable getThrowable(String throwstr) {
        //緩存邏輯
        Throwable throwable = throwables.get(throwstr);
        if (throwable != null) {
            return throwable;
        }

        try {
            Throwable t;
            //反射獲取異常class對(duì)象
            Class<?> bizException = ReflectUtils.forName(throwstr);
            Constructor<?> constructor;
            //反射獲取異常 參數(shù)為string的構(gòu)造函數(shù)
            constructor = ReflectUtils.findConstructor(bizException, String.class);
            //創(chuàng)建異常對(duì)象
            t = (Throwable) constructor.newInstance(new Object[]{"mocked exception for service degradation."});
            //緩存大小限制1000
            if (throwables.size() < 1000) {
                throwables.put(throwstr, t);
            }
            return t;
        } catch (Exception e) {
            //如果反射出現(xiàn)異常，降級(jí)為直接返回RpcException
            throw new RpcException("mock throw error :" + throwstr + " argument error.", e);
        }
    }

    @SuppressWarnings("unchecked")
    private Invoker<T> getInvoker(String mockService) {
        //緩存
        Invoker<T> invoker = (Invoker<T>) mocks.get(mockService);
        if (invoker != null) {
            return invoker;
        }

        //反射得到接口類class對(duì)象
        Class<T> serviceType = (Class<T>) ReflectUtils.forName(url.getServiceInterface());
        //得到接口mock類對(duì)象
        T mockObject = (T) getMockObject(mockService, serviceType);
        //生成代理
        invoker = proxyFactory.getInvoker(mockObject, serviceType, url);
        //緩存大小1000
        if (mocks.size() < 10000) {
            mocks.put(mockService, invoker);
        }
        return invoker;
    }

    /**
     * 獲取serviceType對(duì)應(yīng)mock實(shí)現(xiàn)對(duì)象
     * @param mockService
     * @param serviceType
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Object getMockObject(String mockService, Class serviceType) {
        //如果mock配置為default 對(duì)應(yīng)mock實(shí)現(xiàn)類為 接口名+Mock
        //否則為指定了具體實(shí)現(xiàn)類
        if (ConfigUtils.isDefault(mockService)) {
            mockService = serviceType.getName() + "Mock";
        }

        //反射得到mock實(shí)現(xiàn)類class對(duì)象
        //注意這邊如果找不到 會(huì)拋出運(yùn)行時(shí)異常
        Class<?> mockClass = ReflectUtils.forName(mockService);
        //判斷是否實(shí)現(xiàn)了接口
        if (!serviceType.isAssignableFrom(mockClass)) {
            throw new IllegalStateException("The mock class " + mockClass.getName() +
                    " not implement interface " + serviceType.getName());
        }

        try {
            //創(chuàng)建實(shí)例
            return mockClass.newInstance();
        } catch (InstantiationException e) {
            throw new IllegalStateException("No default constructor from mock class " + mockClass.getName(), e);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
    }


    /**
     * Normalize mock string:
     *
     * <ol>
     * <li>return => return null</li>
     * <li>fail => default</li>
     * <li>force => default</li>
     * <li>fail:throw/return foo => throw/return foo</li>
     * <li>force:throw/return foo => throw/return foo</li>
     * </ol>
     *
     * @param mock mock string
     * @return normalized mock string
     */
    public static String normalizeMock(String mock) {
        if (mock == null) {
            return mock;
        }

        mock = mock.trim();

        if (mock.length() == 0) {
            return mock;
        }

        if (Constants.RETURN_KEY.equalsIgnoreCase(mock)) {
            return Constants.RETURN_PREFIX + "null";
        }

        if (ConfigUtils.isDefault(mock) || "fail".equalsIgnoreCase(mock) || "force".equalsIgnoreCase(mock)) {
            return "default";
        }

        if (mock.startsWith(Constants.FAIL_PREFIX)) {
            mock = mock.substring(Constants.FAIL_PREFIX.length()).trim();
        }

        if (mock.startsWith(Constants.FORCE_PREFIX)) {
            mock = mock.substring(Constants.FORCE_PREFIX.length()).trim();
        }

        if (mock.startsWith(Constants.RETURN_PREFIX) || mock.startsWith(Constants.THROW_PREFIX)) {
            mock = mock.replace('`', '"');
        }

        return mock;
    }

    @Override
    public URL getUrl() {
        return this.url;
    }

    @Override
    public boolean isAvailable() {
        return true;
    }

    @Override
    public void destroy() {
        //do nothing
    }

    @Override
    public Class<T> getInterface() {
        //FIXME
        return null;
    }
}

總結(jié)

  • Dubbo中的mock是用來做降級(jí)功能，通過SPI包裝類來強(qiáng)制植入mock邏輯
  • mock分為強(qiáng)制mock和失敗mock
  • 推薦在客戶端配置失敗mock邏輯，通過服務(wù)治理設(shè)置強(qiáng)制mock
  • 服務(wù)治理一般通過override讓客戶端mock邏輯生效，實(shí)際上也支持配置mock協(xié)議的provider讓mock生效，并且后者優(yōu)先級(jí)更高
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

友情鏈接更多精彩內(nèi)容