dubbo擴展點的AOP

lmxdawn 發布于2019-08-15 15:38 / 3108人閱讀

摘要：擴展點的對的擴展點做一些切面功能的擴展從的代碼說起關鍵說明，是在里面加載的，是符合某種特征的擴展接口實現類的稱呼。

dubbo擴展點的AOP

對dubbo的擴展點做一些切面功能的擴展

從ExtensionLoader的createExtension代碼說起

    @SuppressWarnings("unchecked")
    private T createExtension(String name) {
        Class clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            
            
            Set> wrapperClasses = cachedWrapperClasses;
            //begin 
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                for (Class wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            //end 
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

關鍵說明，

cachedWrapperClasses是在loadFile里面加載的，"WrapperClass"是符合某種特征的擴展接口實現類的稱呼。例如ProtocolFilterWrapper

和ProtocolListenerWrapper。他們共同特征就是帶有Protocol接口的構造函數。

/**
 * ListenerProtocol
 *
 * @author william.liangf
 */
public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;

    public ProtocolFilterWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }

    private static  Invoker buildInvokerChain(final Invoker invoker, String key, String group) {
        Invoker last = invoker;
        List filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
        if (filters.size() > 0) {
            for (int i = filters.size() - 1; i >= 0; i--) {
                final Filter filter = filters.get(i);
                final Invoker next = last;
                last = new Invoker() {

                    public Class getInterface() {
                        return invoker.getInterface();
                    }

                    public URL getUrl() {
                        return invoker.getUrl();
                    }

                    public boolean isAvailable() {
                        return invoker.isAvailable();
                    }

                    public Result invoke(Invocation invocation) throws RpcException {
                        return filter.invoke(next, invocation);
                    }

                    public void destroy() {
                        invoker.destroy();
                    }

                    @Override
                    public String toString() {
                        return invoker.toString();
                    }
                };
            }
        }
        return last;
    }

    public int getDefaultPort() {
        return protocol.getDefaultPort();
    }

    public  Exporter export(Invoker invoker) throws RpcException {
        if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
            return protocol.export(invoker);
        }
        return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
    }

    public  Invoker refer(Class type, URL url) throws RpcException {
        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
            return protocol.refer(type, url);
        }
        return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
    }

    public void destroy() {
        protocol.destroy();
    }

}

instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)); 就是將拿到的instance放到一個包裝類中，然后經過一層包裝之后，在放到另外一個包裝類中，

通過這種方式dubbo實現了擴展點的AOP

遇到的設計模式

裝飾器模式

動態代理模式

多次使用裝飾類，實現了dubbo擴展點的AOP功能

GPU云服務器云服務器 AOP _AOP java aop php 反射 aop

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/69179.html

聊聊Dubbo - Dubbo可擴展機制實戰

摘要：今天我想聊聊的另一個很棒的特性就是它的可擴展性。的擴展機制在的官網上，描述自己是一個高性能的框架。接下來的章節中我們會慢慢揭開擴展機制的神秘面紗。擴展擴展點的實現類。的定義在配置文件中可以看到文件中定義了個的擴展實現。摘要：在Dubbo的官網上，Dubbo描述自己是一個高性能的RPC框架。今天我想聊聊Dubbo的另一個很棒的特性, 就是它的可擴展性。 Dubbo的擴展機制在Dub...

techstay 2019-08-15 18:07 評論0 收藏0
聊聊Dubbo - Dubbo可擴展機制源碼解析

摘要：什么是類那什么樣類的才是擴展機制中的類呢類是一個有復制構造函數的類，也是典型的裝飾者模式。代碼如下有一個參數是的復制構造函數有一個構造函數，參數是擴展點，所以它是一個擴展機制中的類。摘要：?在Dubbo可擴展機制實戰中，我們了解了Dubbo擴展機制的一些概念，初探了Dubbo中LoadBalance的實現，并自己實現了一個LoadBalance。是不是覺得Dubbo的擴展機制很不錯呀...

lmxdawn 2019-08-15 18:11 評論0 收藏0
dubbo擴展點機制

摘要：在中配置，以配置為例整個，最先使用的地方從里面讀取這個配置使用接口的中獲取具體的實現類中有兩個值當主線程被外部終止時，會觸發，執行的與方法通知下面的鎖操作，主線程正常走完代碼，并最終停止。 spring是如何啟動容器的常見的一種在本地使用main方法啟動spring的方法 public static void main(String[] args) throws Except...

Rindia 2019-08-15 15:26 評論0 收藏0
dubbo擴展點的IOC

摘要：屬性上篇文章中，提到在獲取擴展點接口對應的的時候，會執行私有構造函數。因為此時是，即當為時，即我們可以看出，所有非擴展點接口都會執行對應的實例的方法返回一個實例，即對象。 spring是如何獲得容器中管理的類的拿到applicationContext，就可以調用getBean方法來獲得Spring的bean對象了 public class SpringContextUtil impl...

Zoom 2019-08-15 15:26 評論0 收藏0
Dubbo SPI機制和IOC

摘要：要構建自適應實例，先要有自適應的實現類，實現類有兩種方式一種通過配置文件，一種是通過是字節碼的方式動態生成。 SPI機制 SPI，即(service provider interface)機制，有很多組件的實現，如日志、數據庫訪問等都是采用這樣的方式，一般通用組件為了提升可擴展性，基于接口編程，將操作接口形成標準規范，但是可以開放多種擴展實現，這種做法也符合開閉設計原則，使組件具有可插...

Scorpion 2019-08-15 15:48 評論0 收藏0