JAVA总结 - spring cloud alibaba

JAVA总结 - spring cloud alibaba

JAVA

• dubbo
• 注册中心
• • 一、简单dubbo服务调用示例：client + server服务
  • 二、spring boot dubbo服务调用示例
  • 三、spring cloud dubbo服务调用示例
  • 四、dubbo多注册 中心（nacos+zookeeper）
  • 五、多协议支持
  • 六、负载均衡
  • 七、集群容错
  • 八、dubbo泛化
  • 九、服务降级
  • 十、常见的配置
• dubbo服务注册流程源码分析
• dubbo服务发布流程源码分析
• • 1、dubbo服务发布 ServiceConfig.doExportUrlsFor1Protocol
  • 2、PROTOCOL：动态生成适配器类，根据传递进来的参数来选择合适的协议来发布服务。遍历registryURLs发布registry://ip:port
  • 3、RegistryProtocol.export
  • 4、doLocalExport 发布服务
  • 5、Invoker
  • 6、服务注册流程继续 【3、RegistryProtocol.export】
  • 7、服务消费流程继续

dubbo

注册中心

consul、zookeeper、eureka、nacos、redis、etcd

一、简单dubbo服务调用示例：client + server服务

.
　1.1、server-api接口

public interface ILoginFacade {
    String login(String username,String password);
}

.
　1.2、server服务

//1、pom依赖

    
        org.example
        spring-dubbo-server-api
        1.0-SNAPSHOT
    

    
        org.apache.dubbo
        dubbo
        2.7.8
    



//2、启动类
import org.apache.dubbo.container.Main;
public class App {
    public static void main(String[] args) {
        Main.main(args);
    }
}

//3、ILoginFacade 接口实现类
public class LoginServiceImpl implements ILoginFacade {
    public String login(String username, String password) {
        //写业务逻辑
        if(username.equals("admin")&&password.equals("admin")){
            return "SUCCESS";
        }
        return "FAILED";
    }
}

//4、meta-INF/spring/application.xml


    
	
     
    
    
    
    
    

.
　1.3、client服务（依赖server-api接口）

//1、pom依赖
 
     org.example
     spring-dubbo-server-api
     1.0-SNAPSHOT
 
 
     org.apache.dubbo
     dubbo
     2.7.8
 

//2、启动类
import com.sk.dubbo.server.api.ILoginFacade;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:meta-INF/spring/application.xml");
        ILoginFacade loginFacade = context.getBean(ILoginFacade.class);
        System.out.println(loginFacade.login("admin","admin"));
    }
}

//3、meta-INF/spring/application.xml配置



    


    
    
    

二、spring boot dubbo服务调用示例

.
　2.1、server-api接口

		public interface ISayHelloService {
		    String sayHello(String msg);
		}

.
　2.2、server服务

//1、pom依赖
	
        
            org.example
            spring-boot-dubbo-api
            1.0-SNAPSHOT
        
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.apache.dubbo
            dubbo-spring-boot-starter
            2.7.7
        
        
            com.alibaba.nacos
            nacos-client
            1.2.1
        
        
            org.apache.dubbo
            dubbo-dependencies-zookeeper
            2.7.7
        
    

//2、启动类
	import org.apache.dubbo.config.spring.context.annotation.DubboComponentScan;
	import org.springframework.boot.SpringApplication;
	import org.springframework.boot.autoconfigure.SpringBootApplication;
	
	@DubboComponentScan(basePackages = "com.sk.spring.boot.dubbo.server.service")
	@SpringBootApplication
	public class App {
	    public static void main(String[] args) {
	        SpringApplication.run(App.class,args);
	    }
	}

//3、实现类
//3.1、LoginImpl类
import com.sk.spring.boot.bubbo.api.ILoginFacade;
import org.apache.dubbo.config.annotation.DubboService;

@DubboService(registry = {"shanghai","hunan"},version = "1.0")
public class LoginImpl implements ILoginFacade {

    public String login(String username, String password) {
        return "[Version1.0]-账号："+username+"，密码："+password;
    }
}

//3.2、LoginImpl2 类
import com.sk.spring.boot.bubbo.api.ILoginFacade;
import org.apache.dubbo.config.annotation.DubboService;

@DubboService(registry = {"shanghai","hunan"},version = "2.0")
public class LoginImpl2 implements ILoginFacade {
    public String login(String username, String password) {
        return "[Version2.0]-账号："+username+"，密码："+password;
    }
}

//4、application.properties
spring.application.name=spring-boot-dubbo-server

dubbo.protocol.name=dubbo
dubbo.protocol.port=-1

dubbo.registries.shanghai.address=zookeeper://127.0.0.1:2181
dubbo.registries.shanghai.timeout=10000
dubbo.registries.shanghai.default=true

dubbo.registries.hunan.address=nacos://127.0.0.1:8848

.
　2.3、client服务

//1、pom依赖

    
        
            org.example
            spring-boot-dubbo-api
            1.0-SNAPSHOT
        
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.apache.dubbo
            dubbo-spring-boot-starter
            2.7.7
        
        
            com.alibaba.nacos
            nacos-client
            1.2.1
        
        
            org.apache.dubbo
            dubbo-dependencies-zookeeper
            2.7.7
        
    
    
//2、启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

//3、application.properties
spring.application.name=spring-boot-dubbo-client

dubbo.registries.shanghai.address=zookeeper://192.168.216.128:2181
dubbo.registries.shanghai.timeout=10000
dubbo.registries.shanghai.zone=shanghai
dubbo.registries.shanghai.weight=100

dubbo.registries.hunan.address=nacos://192.168.216.128:8848
dubbo.registries.hunan.weight=10
dubbo.registries.hunan.preferred=true

server.port=8888

//4、实现类
import com.sk.spring.boot.bubbo.api.ILoginFacade;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {
    @DubboReference(registry = {"shanghai","hunan"},version = "2.0")
    ILoginFacade loginFacade;

    @GetMapping("/login")
    public String login(String userName, String passWord){
        return loginFacade.login(userName,passWord);
    }
}

三、spring cloud dubbo服务调用示例

 　![在这里插入图片描述](https://img-blog.csdnimg.cn/52b6bc8ecf914af8bf36d4264f7013b3.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA56We56eR,size_20,color_FFFFFF,t_70,g_se,x_16)

.
　3.1、server-api接口 　
　3.2、server-api接口

//1、pom依赖
    
        
            org.example
            spring-cloud-dubbo-api
            1.0-SNAPSHOT
        
        
            org.springframework.boot
            spring-boot-starter
        
        
            com.alibaba.cloud
            spring-cloud-starter-dubbo
            2.2.1.RELEASE
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
            2.2.1.RELEASE
        
    

//2、启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

//3、application.properties配置
spring.application.name=spring-cloud-dubbo-server

dubbo.scan.base-packages=com.sk.spring.cloud.dubbo.server.service

dubbo.protocol.port=20882
dubbo.protocol.name=dubbo

spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

//4、实现类     
import com.sk.spring.cloud.dubbo.api.ILoginFacade;
import org.apache.dubbo.config.annotation.Service;

@Service
public class LoginImpl  implements ILoginFacade {
    public String login(String username, String password) {
        return "[Version1.0]-账号："+username+"，密码："+password;
    }
}

.
　3.3、client服务

//1、pom依赖
    
        
            org.example
            spring-cloud-dubbo-api
            1.0-SNAPSHOT
        
        
            org.springframework.boot
            spring-boot-starter
        
        
            com.alibaba.cloud
            spring-cloud-starter-dubbo
            2.2.1.RELEASE
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
            2.2.1.RELEASE
        
    
    
//2、启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

//3、application.properties配置
spring.application.name=spring-cloud-dubbo-client

spring.cloud.nacos.discovery.server-addr=192.168.216.128:8848

//4、实现类
import com.sk.spring.cloud.dubbo.api.ILoginFacade;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {

    @Reference
    ILoginFacade loginFacade;

    @GetMapping("/login")
    public String login(String userName, String passWord){
        return loginFacade.login(userName,passWord);
    }
}

四、dubbo多注册 中心（nacos+zookeeper）

 　区域优先：
 　权重：
 　优先选择：
 　版本路由：

五、多协议支持

dubbo（netty）
　 　dubbo.protocols.dubbo.name=dubbo
　 　dubbo.protocols.dubbo,port=-1
　rest（jetty）
　 　dubbo.protocols.rest.name=rest
　 　dubbo.protocols.rest,port=-1
　 　dubbo.protocols.server=jetty

六、负载均衡

Random：加权随机（默认）
　roundrobin：轮询
　一致性hash负载：
　最小活跃度：

七、集群容错

1、fialover（默认）失败重试
　 　@DubboService(cluster = “failover”,retries = 2)
　2、failfast cluster 快速失败，立马报错
　3、failsafe cluster 失败安全，出现异常直接吞掉
　4、failback cluster 失败自动恢复，定时重发
　5、forking cluster 广播发送，成功一条返回

八、dubbo泛化

@RestController
public class DemoController {

    @DubboReference(interfaceName = "com.sk.springboot.dubbo.springbootdubbosampleprovider.services.IDemoService",generic = true,check = false)
    GenericService genericService;

    @GetMapping("/demo")
    public String demo(){
        return genericService.$invoke("getTxt",new String[0],null).toString();
    }
}

入参是对象：
　

九、服务降级

    @DubboReference(registry = {"shanghai","hunan"},
            protocol = "dubbo",
            loadbalance = "consistenthash",
            mock = "com.sk.springboot.dubbo.springbootdubbosampleconsumer.MockSayHelloService",
            timeout = 500,
            cluster = "failfast")
    ISayHelloService sayHelloService;
    
 	@GetMapping("/say")
    public String say(){
        return sayHelloService.sayHello("hello sk");
    }

十、常见的配置

1、check 启动检查

		//1、服务配置：服务启动注册失败正常启动
		dubbo.registries.shanghai.check=false
		
		//2、客户端请求服务校验:false不校验依赖接口服务是否注册
	    @DubboReference(registry = {"shanghai","hunan"},
           protocol = "dubbo",
           loadbalance = "consistenthash",
           mock = "com.gupaoedu.springboot.dubbo.springbootdubbosampleconsumer.MockSayHelloService",
           timeout = 500,
           cluster = "failfast",check = true)
   		ISayHelloService sayHelloService;

.
　2、主机绑定问题

String host = findConfigedHosts(protocolConfig, registryURLs, map); 
Integer port = findConfigedPorts(protocolConfig, name, map);

在这里插入代码片

.
　 　1、查找环境变量中是否存在启动参数 [DUBBO_IP_TO_BIND] =服务注册的ip
　 　2、读取配置文件， dubbo.protocols.dubbo.host= 服务注册的ip
　 　3、InetAddress.getLocalHost().getHostAddress() 获得本机ip地址
　 　4、通过Socket去连接注册中心，从而获取本机IP
　 　5、会轮询本机的网卡，直到找到合适的IP地址
　 　6、上面获取到的ip地址是bindip，如果需要作为服务注册中心的ip，DUBBO_IP_TO_REGISTRY -dDUBBO_IP_TO_REGISTRY=ip
　 　
　3、配置优先级
　 　3.1、服务配置优先级
.
　3.2、环境配置优先级

3、序列化

4、性能调优的参数

5、Dubbo缓存文件
　 　dubbo.registries.shanghai.file=${user.home}/dubboshanghai.cache
　
　6、dubbo admin
　注意：配置校验 -> 远程配置加载 (移除定制化配置)

		dubbo.config-center.address=zookeeper://192.168.216.128:2181
		dubbo.config-center.timeout=10000

dubbo服务注册流程源码分析

   　   　1.1、服务发布代码
   　   　注解
   　   　

		@DubboService(
	       loadbalance = "random",
	       cluster = "failover",
	       retries = 2)

.
　 　注解扫描

		@DubboComponentScan(

.
　 　1.2、逻辑步骤
　 　扫描注解
　 　url驱动（url组装）
　 　注册到zookeeper
　 　启动服务（根据url配置协议、端口发布对应的服务）
　2、对应源码
　 　2.1、dubbo服务发布两种方式
　 　 　 xml形式：dubbo:servce
　 　 　 @DubboService/@Service
　 　2.2、dubbo注解的解析流程
　 　 　 DubboComponetScan：把ServiceAnnotationBeanPostProcessor注册到spring ioc

    public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry) {
    	//1、扫描basePackages包
        Set packagesToScan = this.getPackagesToScan(importingClassmetadata);
        //2、注册ServiceAnnotationBeanPostProcessor
        this.registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
        DubboBeanUtils.registerCommonBeans(registry);
    }

.
　 　 　 ServiceAnnotationBeanPostProcessor

public ServiceAnnotationBeanPostProcessor(Set packagesToScan) {
        super(packagesToScan);
    }

.
　 　 　 ServiceClassPostProcessor 继承BeanDefinitionRegistryPostProcessor

//1、bean装载完成之后，会触发这个方法
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AnnotatedBeanDefinitionRegistryUtils.registerBeans(registry, new Class[]{DubboBootstrapApplicationListener.class});
        Set resolvedPackagesToScan = this.resolvePackagesToScan(this.packagesToScan);
        if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
            this.registerServiceBeans(resolvedPackagesToScan, registry);
        } else if (this.logger.isWarnEnabled()) {
            this.logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
        }

    }

.
　 　 　 注册一个DubboBootstrapApplicationListener ：在spring容器上下文装载之后触发监听

public class DubboBootstrapApplicationListener extends OneTimeExecutionApplicationContextEventListener
        implements Ordered {

    
    public static final String BEAN_NAME = "dubboBootstrapApplicationListener";

    private final DubboBootstrap dubboBootstrap;

    public DubboBootstrapApplicationListener() {
        this.dubboBootstrap = DubboBootstrap.getInstance();
    }

    @Override
    public void onApplicationContextEvent(ApplicationContextEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }

    private void onContextRefreshedEvent(ContextRefreshedEvent event) {
        dubboBootstrap.start();
    }

    private void onContextClosedEvent(ContextClosedEvent event) {
        dubboBootstrap.stop();
    }

    @Override
    public int getOrder() {
        return LOWEST_PRECEDENCE;
    }
}

.
　 　 　 registerServiceBeans

 
    private void registerServiceBeans(Set packagesToScan, BeanDefinitionRegistry registry) {

        DubboClassPathBeanDefinitionScanner scanner =
                new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);

        BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);

        scanner.setBeanNameGenerator(beanNameGenerator);

        // refactor @since 2.7.7
        serviceAnnotationTypes.forEach(annotationType -> {
            scanner.addIncludeFilter(new AnnotationTypeFilter(annotationType));
        });

        for (String packageToScan : packagesToScan) {

            // Registers @Service Bean first
            scanner.scan(packageToScan);

            // Finds all BeanDefinitionHolders of @Service whether @ComponentScan scans or not.
            Set beanDefinitionHolders =
                    findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);

            if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {

                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    registerServiceBean(beanDefinitionHolder, registry, scanner);
                }

                if (logger.isInfoEnabled()) {
                    logger.info(beanDefinitionHolders.size() + " annotated Dubbo's @Service Components { " +
                            beanDefinitionHolders +
                            " } were scanned under package[" + packageToScan + "]");
                }

            } else {

                if (logger.isWarnEnabled()) {
                    logger.warn("No Spring Bean annotating Dubbo's @Service was found under package["
                            + packageToScan + "]");
                }

            }

        }

    }

.
　 　 　 registerServiceBean

private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry,
                                     DubboClassPathBeanDefinitionScanner scanner) {

        Class beanClass = resolveClass(beanDefinitionHolder);

        Annotation service = findServiceAnnotation(beanClass);

        
        AnnotationAttributes serviceAnnotationAttributes = getAnnotationAttributes(service, false, false);

        Class interfaceClass = resolveServiceInterfaceClass(serviceAnnotationAttributes, beanClass);

        String annotatedServiceBeanName = beanDefinitionHolder.getBeanName();

        AbstractBeanDefinition serviceBeanDefinition =
                buildServiceBeanDefinition(service, serviceAnnotationAttributes, interfaceClass, annotatedServiceBeanName);

        // ServiceBean Bean name
        String beanName = generateServiceBeanName(serviceAnnotationAttributes, interfaceClass);

        if (scanner.checkCandidate(beanName, serviceBeanDefinition)) { // check duplicated candidate bean
        	//dubbo中提供的ServiceBean注入到Spring IOC容器
            registry.registerBeanDefinition(beanName, serviceBeanDefinition);

            if (logger.isInfoEnabled()) {
                logger.info("The BeanDefinition[" + serviceBeanDefinition +
                        "] of ServiceBean has been registered with name : " + beanName);
            }

        } else {

            if (logger.isWarnEnabled()) {
                logger.warn("The Duplicated BeanDefinition[" + serviceBeanDefinition +
                        "] of ServiceBean[ bean name : " + beanName +
                        "] was be found , Did @DubboComponentScan scan to same package in many times?");
            }

        }

    }

.
　 　 　 ServiceBean的初始化阶段

public ServiceBean() {
    super();
    this.service = null;
}

//当ServiceBean初始化完成之后，会调用下面的方法.
@Override
public void afterPropertiesSet() throws Exception {
    if (StringUtils.isEmpty(getPath())) {
        if (StringUtils.isNotEmpty(beanName)
            && StringUtils.isNotEmpty(getInterface())
            && beanName.startsWith(getInterface())) {
            setPath(beanName);
        }
    }
}

.
　 　 　 DubboBootstrapApplicationListener 启动dubbo服务

//启动dubbo服务
private void onContextRefreshedEvent(ContextRefreshedEvent event) {
    dubboBootstrap.start();
}

//如果是dubbo协议，则启动netty server
public DubboBootstrap start() {
    if (started.compareAndSet(false, true)) {
        ready.set(false);
        initialize();
        if (logger.isInfoEnabled()) {
            logger.info(NAME + " is starting...");
        }
        // 1. export Dubbo Services
        exportServices();

        // Not only provider register
        if (!isOnlyRegisterProvider() || hasExportedServices()) {
            // 2. export metadataService
            exportmetadataService();
            //3. Register the local ServiceInstance if required
            registerServiceInstance();
        }

        referServices();
        if (asyncExportingFutures.size() > 0) {
            new Thread(() -> {
                try {
                    this.awaitFinish();
                } catch (Exception e) {
                    logger.warn(NAME + " exportAsync occurred an exception.");
                }
                ready.set(true);
                if (logger.isInfoEnabled()) {
                    logger.info(NAME + " is ready.");
                }
            }).start();
        } else {
            ready.set(true);
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " is ready.");
            }
        }
        if (logger.isInfoEnabled()) {
            logger.info(NAME + " has started.");
        }
    }
    return this;
}

.
　 　 　 exportServices发布dubbo服务

//遍历所有dubbo服务协议，进行服务发布
private void exportServices() {
    configManager.getServices().forEach(sc -> {
        // TODO, compatible with ServiceConfig.export()
        ServiceConfig serviceConfig = (ServiceConfig) sc;
        serviceConfig.setBootstrap(this);

        if (exportAsync) {
            ExecutorService executor = executorRepository.getServiceExporterExecutor();
            Future future = executor.submit(() -> {
                sc.export();
                exportedServices.add(sc);
            });
            asyncExportingFutures.add(future);
        } else {
            sc.export();
            exportedServices.add(sc);
        }
    });
}

   　   　  	   　  export发布

public synchronized void export() {
    if (!shouldExport()) {
        return;
    }

    if (bootstrap == null) {
        bootstrap = DubboBootstrap.getInstance();
        bootstrap.init();
    }

    checkAndUpdateSubConfigs();

    //init servicemetadata
    servicemetadata.setVersion(version);
    servicemetadata.setGroup(group);
    servicemetadata.setDefaultGroup(group);
    servicemetadata.setServiceType(getInterfaceClass());
    servicemetadata.setServiceInterfaceName(getInterface());
    servicemetadata.setTarget(getRef());

    if (shouldDelay()) {
        DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
    } else {
        doExport();
    }

    exported();
}

.
　 　 　 doExportUrls:根据开发者配置的协议列表，遍历协议列表逐项进行发布

private void doExportUrls() {
    ServiceRepository repository = ApplicationModel.getServiceRepository();
    ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
    repository.registerProvider(
        getUniqueServiceName(),
        ref,
        serviceDescriptor,
        this,
        servicemetadata
    );

    List registryURLs = ConfigValidationUtils.loadRegistries(this, true);

    for (ProtocolConfig protocolConfig : protocols) {
        String pathKey = URL.buildKey(getContextPath(protocolConfig)
                                      .map(p -> p + "/" + path)
                                      .orElse(path), group, version);
        // In case user specified path, register service one more time to map it to path.
        repository.registerService(pathKey, interfaceClass);
        // TODO, uncomment this line once service key is unified
        servicemetadata.setServiceKey(pathKey);
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

.
　 　 　 doExportUrlsFor1Protocol:生成url，根据url中配置的协议类型，调用指定协议进行服务的发布

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List registryURLs) {
    String name = protocolConfig.getName();
    if (StringUtils.isEmpty(name)) {
        name = DUBBO;
    }
    //用来存储所有的配置信息
    * dubbo:service
        dubbo:method
            dubbo:argument
    Map map = new HashMap();
    map.put(SIDE_KEY, PROVIDER_SIDE);

    ServiceConfig.appendRuntimeParameters(map);
    AbstractConfig.appendParameters(map, getMetrics());
    AbstractConfig.appendParameters(map, getApplication());
    AbstractConfig.appendParameters(map, getModule());
    // remove 'default.' prefix for configs from ProviderConfig
    // appendParameters(map, provider, Constants.DEFAULT_KEY);
    AbstractConfig.appendParameters(map, provider);
    AbstractConfig.appendParameters(map, protocolConfig);
    AbstractConfig.appendParameters(map, this);
    metadataReportConfig metadataReportConfig = getmetadataReportConfig();
    if (metadataReportConfig != null && metadataReportConfig.isValid()) {
        map.putIfAbsent(metaDATA_KEY, REMOTE_metaDATA_STORAGE_TYPE);
    }
    if (CollectionUtils.isNotEmpty(getMethods())) {
        for (MethodConfig method : getMethods()) {
            AbstractConfig.appendParameters(map, method, method.getName());
            String retryKey = method.getName() + ".retry";
            if (map.containsKey(retryKey)) {
                String retryValue = map.remove(retryKey);
                if ("false".equals(retryValue)) {
                    map.put(method.getName() + ".retries", "0");
                }
            }
            List arguments = method.getArguments();
            if (CollectionUtils.isNotEmpty(arguments)) {
                for (ArgumentConfig argument : arguments) {
                    // convert argument type
                    if (argument.getType() != null && argument.getType().length() > 0) {
                        Method[] methods = interfaceClass.getMethods();
                        // visit all methods
                        if (methods.length > 0) {
                            for (int i = 0; i < methods.length; i++) {
                                String methodName = methods[i].getName();
                                // target the method, and get its signature
                                if (methodName.equals(method.getName())) {
                                    Class[] argtypes = methods[i].getParameterTypes();
                                    // one callback in the method
                                    if (argument.getIndex() != -1) {
                                        if (argtypes[argument.getIndex()].getName().equals(argument.getType())) {
                                            AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
                                        } else {
                                            throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
                                        }
                                    } else {
                                        // multiple callbacks in the method
                                        for (int j = 0; j < argtypes.length; j++) {
                                            Class argclazz = argtypes[j];
                                            if (argclazz.getName().equals(argument.getType())) {
                                                AbstractConfig.appendParameters(map, argument, method.getName() + "." + j);
                                                if (argument.getIndex() != -1 && argument.getIndex() != j) {
                                                    throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } else if (argument.getIndex() != -1) {
                        AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
                    } else {
                        throw new IllegalArgumentException("Argument config must set index or type attribute.eg:  or ");
                    }

                }
            }
        } // end of methods for
    }

    if (ProtocolUtils.isGeneric(generic)) {
        map.put(GENERIC_KEY, generic);
        map.put(METHODS_KEY, ANY_VALUE);
    } else {
        String revision = Version.getVersion(interfaceClass, version);
        if (revision != null && revision.length() > 0) {
            map.put(REVISION_KEY, revision);
        }

        String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
        if (methods.length == 0) {
            logger.warn("No method found in service interface " + interfaceClass.getName());
            map.put(METHODS_KEY, ANY_VALUE);
        } else {
            map.put(METHODS_KEY, StringUtils.join(new HashSet(Arrays.asList(methods)), ","));
        }
    }

    
    if(ConfigUtils.isEmpty(token) && provider != null) {
        token = provider.getToken();
    }

    if (!ConfigUtils.isEmpty(token)) {
        if (ConfigUtils.isDefault(token)) {
            map.put(TOKEN_KEY, UUID.randomUUID().toString());
        } else {
            map.put(TOKEN_KEY, token);
        }
    }
    //init servicemetadata attachments
    servicemetadata.getAttachments().putAll(map);

    // export service
    String host = findConfigedHosts(protocolConfig, registryURLs, map);
    Integer port = findConfigedPorts(protocolConfig, name, map);
    URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);

    // You can customize Configurator to append extra parameters
    if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
        .hasExtension(url.getProtocol())) {
        url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
            .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
    }

    String scope = url.getParameter(SCOPE_KEY);
    // don't export when none is configured
    if (!SCOPE_NONE.equalsIgnoreCase(scope)) {

        // export to local if the config is not remote (export to remote only when config is remote)
        if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
            exportLocal(url);
        }
        // export to remote if the config is not local (export to local only when config is local)
        if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
            if (CollectionUtils.isNotEmpty(registryURLs)) {
                for (URL registryURL : registryURLs) {
                    //if protocol is only injvm ,not register
                    if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
                        continue;
                    }
                    url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
                    URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);
                    if (monitorUrl != null) {
                        url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
                    }
                    if (logger.isInfoEnabled()) {
                        if (url.getParameter(REGISTER_KEY, true)) {
                            logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                        } else {
                            logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                        }
                    }

                    // For providers, this is used to enable custom proxy to generate invoker
                    String proxy = url.getParameter(PROXY_KEY);
                    if (StringUtils.isNotEmpty(proxy)) {
                        registryURL = registryURL.addParameter(PROXY_KEY, proxy);
                    }

                    Invoker invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
                    DelegateProvidermetaDataInvoker wrapperInvoker = new DelegateProvidermetaDataInvoker(invoker, this);

                    Exporter exporter = PROTOCOL.export(wrapperInvoker);
                    exporters.add(exporter);
                }
            } else {
                if (logger.isInfoEnabled()) {
                    logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                }
                Invoker invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
                DelegateProvidermetaDataInvoker wrapperInvoker = new DelegateProvidermetaDataInvoker(invoker, this);

                Exporter exporter = PROTOCOL.export(wrapperInvoker);
                exporters.add(exporter);
            }
            
            WritablemetadataService metadataService = WritablemetadataService.getExtension(url.getParameter(metaDATA_KEY, DEFAULT_metaDATA_STORAGE_TYPE));
            if (metadataService != null) {
                metadataService.publishServiceDefinition(url);
            }
        }
    }
    this.urls.add(url);
}

.
　 　2.3、dubbo扩展点
　 　在类级别标准@SPI(RandomLoadBalance.NAME).
　 　 　 　自定义扩展点
　 　 　 　在resource/meta-INF/dubbo/ org.apache.dubbo.rpc.cluster.LoadBalance

 public class GpDefineLoadBalance extends AbstractLoadBalance{
      @Override
      protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
  
          return null;
      }
  }

.
　 　 　 　1）、指定名称扩展点
　 　 　 　内部扩展点Protocol的全路径名称， 在/meta-INF/dubbo/intenal

random=org.apache.dubbo.rpc.cluster.loadbalance.RandomLoadBalance
roundrobin=org.apache.dubbo.rpc.cluster.loadbalance.RoundRobinLoadBalance
leastactive=org.apache.dubbo.rpc.cluster.loadbalance.LeastActiveLoadBalance
consistenthash=org.apache.dubbo.rpc.cluster.loadbalance.ConsistentHashLoadBalance
shortestresponse=org.apache.dubbo.rpc.cluster.loadbalance.ShortestResponseLoadBalance

ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("name");

…
　 　 　 　源码分析：
　 　 　 　ExtensionLoader.getExtensionLoader：加载扩展点的class类型的参数，该参数必须是接口，且注解@SPI。检查通过之后，首先检查ExtensionLoader缓存中是否存在该扩展对应的ExtensionLoader，有则返回，否则创建新的ExtensionLoader负责加载扩展实现，并缓存起来。对于每一个class扩展，dubbo只会有一个对应的ExtensionLoader实例

	
	public static  ExtensionLoader getExtensionLoader(Class type) {
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                    ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }
        //缓存获取扩展类型ExtensionLoader
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
        	//2、创建扩展类型ExtensionLoader
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

	
   private ExtensionLoader(Class type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

.
　 　 　 　ExtensionLoader.getExtensionLoader(@SPI interface).getExtension：根据名字获取对应的实例

    public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        //如果name=true，表示返回一个默认的扩展点
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        final Holder