dubbo-youthlql-demo
├── consumer/
|  ├── consumer.iml
|  ├── pom.xml
|  └── src/
|     ├── main/
|     |  ├── java/
|     |  |  └── com/
|     |  |     └── youthlql/
|     |  |        ├── consumer/
|     |  |        |  ├── AsyncDubboConsumerDemo.java
|     |  |        |  ├── CallbackDubboConsumerDemo.java
|     |  |        |  ├── ClusterDubboConsumerDemo.java
|     |  |        |  ├── DemoServiceListenerImpl.java
|     |  |        |  ├── GenericDubboConsumerDemo.java
|     |  |        |  ├── LoadBalanceDubboConsumerDemo.java
|     |  |        |  ├── MockDubboConsumerDemo.java
|     |  |        |  ├── StubDubboConsumerDemo.java
|     |  |        |  └── TimeoutDubboConsumerDemo.java
|     |  |        ├── controller/
|     |  |        |  ├── ConsumerInterceptor.java
|     |  |        |  └── HelloController.java
|     |  |        └── DubboConsumerDemo.java
|     |  └── resources/
|     |     └── application.yml
|     └── test/
|        └── java/
├── dubbo-youthlql-demo.iml
├── interface/
|  ├── interface.iml
|  ├── pom.xml
|  └── src/
|     ├── main/
|     |  ├── java/
|     |  |  └── com/
|     |  |     └── youthlql/
|     |  |        ├── DemoService.java
|     |  |        ├── DemoServiceListener.java
|     |  |        ├── DemoServiceMock.java
|     |  |        └── DemoServiceStub.java
|     |  └── resources/
|     └── test/
|        └── java/
├── pom.xml
└── provider/
   ├── pom.xml
   ├── provider.iml
   └── src/
      ├── main/
      |  ├── java/
      |  |  └── com/
      |  |     └── youthlql/
      |  |        ├── DubboProviderDemo.java
      |  |        ├── provider/
      |  |        |  └── service/
      |  |        |     ├── AsyncDemoService.java
      |  |        |     ├── CallBackDemoService.java
      |  |        |     ├── DefaultDemoService.java
      |  |        |     ├── GenericDemoService.java
      |  |        |     ├── RestDemoService.java
      |  |        |     └── TimeoutDemoService.java
      |  |        └── UpdateBeanPostProcessors.java
      |  └── resources/
      |     ├── application.properties
      |     └── log4j.properties
      └── test/
         └── java/

	@Reference(version = "default", loadbalance = "consistenthash")
    private DemoService demoService;

@Service(version = "default",loadbalance = "consistenthash")
public class DefaultDemoService implements DemoService {
...
}

//服务端
@Service(version = "timeout", timeout = 6000)
public class TimeoutDemoService implements DemoService {
    ...
}

//消费端
@Reference(version = "timeout", loadbalance = "roundrobin",timeout = 3000)
private DemoService demoService;

@Reference(timeout = 1000, cluster = "failover")
private DemoService demoService;

@Reference(version = "timeout", timeout = 1000, mock = "fail: return 123")
private DemoService demoService;

package com.youthlql.consumer;

@EnableAutoConfiguration
public class StubDubboConsumerDemo {


    //    @Reference(version = "timeout", timeout = 1000, stub = "com.youthlql.DemoServiceStub")
    @Reference(version = "timeout", timeout = 1000, stub = "true")
    private DemoService demoService;

    public static void main(String[] args) throws IOException {
        ConfigurableApplicationContext context = SpringApplication.run(StubDubboConsumerDemo.class);

        DemoService demoService = context.getBean(DemoService.class);

        System.out.println((demoService.sayHello("周瑜")));
        
    }
}

@Reference(version = "timeout", timeout = 1000, stub = "com.youthlql.DemoServiceStub")
private DemoService demoService;

package com.youthlql;

public class DemoServiceStub implements DemoService {

    private final DemoService demoService;

    // 构造函数传入真正的远程代理对象
    public DemoServiceStub(DemoService demoService){
        this.demoService = demoService;
    }

    @Override
    public String sayHello(String name) {
        /**
         * <p>
         * 1.本地存根和服务降级有一些类似，不过本地存根比服务降级功能要强一点，比如你可以在这个
         * 地方做一些事情
         * 2.此代码在客户端（消费端）执行, 你可以在客户端做ThreadLocal本地缓存，把服务端返回的结果缓存到消费端。或预先验证参数是否合法，等等
         * </p>
         * @since 2021/8/7 - 17:41
         */
        try {
            return demoService.sayHello(name); // safe  null
        } catch (Exception e) {
            // 你可以容错，可以做任何AOP拦截事项
            return "容错数据";
        }
    }
}

package com.youthlql;

import java.util.concurrent.CompletableFuture;

public interface DemoService {
    // 同步调用方法
    String sayHello(String name);

    // 异步调用方法
    default CompletableFuture<String> sayHelloAsync(String name) {
        return null;
    };

    // 添加回调
    default String sayHello(String name, String key, DemoServiceListener listener) {
        return null;
    };
}

package com.youthlql.consumer;

@EnableAutoConfiguration
public class CallbackDubboConsumerDemo {


    @Reference(version = "callback")
    private DemoService demoService;

    public static void main(String[] args) throws IOException {
        ConfigurableApplicationContext context = SpringApplication.run(CallbackDubboConsumerDemo.class);

        DemoService demoService = context.getBean(DemoService.class);

        // 用来进行callback
        System.out.println(demoService.sayHello("周瑜", "d1", new DemoServiceListenerImpl()));
        System.out.println(demoService.sayHello("周瑜", "d2", new DemoServiceListenerImpl()));
        System.out.println(demoService.sayHello("周瑜", "d3", new DemoServiceListenerImpl()));
    }

}

package com.youthlql.consumer;

public class DemoServiceListenerImpl implements DemoServiceListener {

    @Override
    public void changed(String msg) {
        System.out.println("被回调了："+msg);
    }
}

package com.youthlql;

public interface DemoServiceListener {
    void changed(String msg);
}

package com.youthlql.provider.service;


/**
 * <p>
 * 1.通过下面sayhello的方法注释，我们可以知道DemoService的sayHello方法的index=2的参数是回调对象，
 * 这个回调对象DemoServiceListener是Dubbo给我们生成的代理对象。
 * 2.那么Dubbo怎么知道，sayhello的index=2的参数是回调对象呢?为什么不可以是普通参数呢?
 * dubbo又是怎样区分DemoService里的两个sayhello方法呢？
 * 3.全都是通过@Service注解里的methods属性来标识的。通过methods属性指定name为sayHello的方法，
 * 它的index=2的参数是回调对象。并且同时只支持callbacks = 3，3个回调，数目超过了会报错
 * 3.version = "callback"  这个字符串是可以随便写的，version = "call"也行
 * </p>
 * @author https://github.com/youthlql
 * @since 2021/8/7 - 18:32
 */
@Service(version = "callback", methods = {@Method(name = "sayHello", arguments = {@Argument(index = 2, callback = true)})}, callbacks = 3)
public class CallBackDemoService implements DemoService {

    private final Map<String, DemoServiceListener> listeners = new ConcurrentHashMap<String, DemoServiceListener>();

    public CallBackDemoService() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    for (Map.Entry<String, DemoServiceListener> entry : listeners.entrySet()) {
                        entry.getValue().changed(getChanged(entry.getKey()));
                    }
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();

    }

    public void addListener(String key, DemoServiceListener listener) {
        listeners.put(key, listener);
        listener.changed(getChanged(key)); // 发送变更通知
    }

    private String getChanged(String key) {
        return "Changed: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }

    @Override
    public String sayHello(String name) {
        return null;
    }
    
    /**
     * <p>
     * @param name
     * @param key
     * 1.上面两参数肯定都是消费端那边传过来的，第三个参数DemoServiceListener
     * 不可能是消费者那边传过来的一个空对象吧。它实际上是dubbo生成的代理对象。
     * </p>
     * @since 2021/8/7 - 18:17
     */
    @Override
    public String sayHello(String name, String key, DemoServiceListener callback) {
        System.out.println("执行了回调服务" + name);

        callback.changed("xxxx");

        listeners.put(key, callback);
        URL url = RpcContext.getContext().getUrl();
        return String.format("%s：%s, Hello, %s", url.getProtocol(), url.getPort(), name);  // 正常访问
    }

}

System.out.println(demoService.sayHello("周瑜", "d1", new DemoServiceListenerImpl1()));
System.out.println(demoService.sayHello("周瑜", "d2", new DemoServiceListenerImpl2()));
System.out.println(demoService.sayHello("周瑜", "d3", new DemoServiceListenerImpl3()));

package com.youthlql;

import java.util.concurrent.CompletableFuture;

public interface DemoService {
    // 同步调用方法
    String sayHello(String name);

    // 异步调用方法
    default CompletableFuture<String> sayHelloAsync(String name) {
        return null;
    };

    // 添加回调
    default String sayHello(String name, String key, DemoServiceListener listener) {
        return null;
    };
}

package com.youthlql.provider.service;


@Service(version = "async")
public class AsyncDemoService implements DemoService {

    @Override
    public String sayHello(String name) {
        System.out.println("执行了同步服务" + name);
        URL url = RpcContext.getContext().getUrl();
        return String.format("%s：%s, Hello, %s", url.getProtocol(), url.getPort(), name);  // 正常访问
    }

    @Override
    public CompletableFuture<String> sayHelloAsync(String name) {
        System.out.println("执行了异步服务" + name);

        return CompletableFuture.supplyAsync(() -> {
            return sayHello(name);
        });
    }
}

package com.youthlql.consumer;

@EnableAutoConfiguration
public class AsyncDubboConsumerDemo {

    @Reference(version = "async")
    private DemoService demoService;

    public static void main(String[] args) throws IOException {
        ConfigurableApplicationContext context = SpringApplication.run(AsyncDubboConsumerDemo.class);

        DemoService demoService = context.getBean(DemoService.class);

        // 调用直接返回CompletableFuture
        CompletableFuture<String> future = demoService.sayHelloAsync("异步调用");  // 5

        future.whenComplete((v, t) -> {
            if (t != null) {
                t.printStackTrace();
            } else {
                System.out.println("Response: " + v);
            }
        });

        System.out.println("结束了");

    }

}

package com.youthlql.consumer;


@EnableAutoConfiguration
public class GenericDubboConsumerDemo {


    @Reference(id = "demoService", version = "default", interfaceName = "com.youthlql.DemoService", generic = true)
    private GenericService genericService;

    public static void main(String[] args) throws IOException {
        ConfigurableApplicationContext context = SpringApplication.run(GenericDubboConsumerDemo.class);

        GenericService genericService = (GenericService) context.getBean("demoService");

        Object result = genericService.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{"周瑜"});
        System.out.println(result);


    }

}

package com.youthlql.provider.service;

import com.youthlql.DemoService;
import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.rpc.service.GenericException;
import org.apache.dubbo.rpc.service.GenericService;

@Service(interfaceName = "com.youthlql.DemoService", version = "generic")
public class GenericDemoService implements GenericService {
    
    /**
     * <p>
     * @param s 方法名字
     * @param strings 参数类型数组
     * @param objects 参数值数组
     * </p>
     * @since 2021/8/7 - 18:57
     */
    @Override
    public Object $invoke(String s, String[] strings, Object[] objects) throws GenericException {
        System.out.println("执行了generic服务");

        return "执行的方法是" + s;
    }
}

 # Spring boot application
spring.application.name=dubbo-provider-demo
server.port=8081

# Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service
dubbo.scan.base-packages=com.youthlql.provider.service
dubbo.application.name=${spring.application.name}


## Dubbo Registry
dubbo.registry.address=zookeeper://127.0.0.1:2181

# Dubbo Protocol
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20880


#dubbo.protocol.name=rest
#dubbo.protocol.port=8083

dubbo.protocols.p1.id=dubbo1
dubbo.protocols.p1.name=dubbo
dubbo.protocols.p1.port=20881
dubbo.protocols.p1.host=0.0.0.0

dubbo.protocols.p2.id=rest
dubbo.protocols.p2.name=rest
dubbo.protocols.p2.port=8083
dubbo.protocols.p2.host=0.0.0.0

#dubbo.protocols.p3.id=dubbo3
#dubbo.protocols.p3.name=dubbo
#dubbo.protocols.p3.port=20883
#dubbo.protocols.p3.host=0.0.0.0

package com.youthlql.provider.service;


@Service(version = "rest", protocol = "p2")
@Path("demo")
public class RestDemoService implements DemoService {

    @GET
    @Path("say")
    @Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_XML_UTF_8})
    @Override
    public String sayHello(@QueryParam("name") String name) {
        System.out.println("执行了rest服务" + name);

        URL url = RpcContext.getContext().getUrl();
        return String.format("%s: %s, Hello, %s", url.getProtocol(), url.getPort(), name);  // 正常访问
    }

}

package com.youthlql.provider.service;

import com.youthlql.DemoService;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.rpc.RpcContext;

import java.util.concurrent.CompletableFuture;

@Service(version = "async", protocol = "p1")
public class AsyncDemoService implements DemoService {

    @Override
    public String sayHello(String name) {
        System.out.println("执行了同步服务" + name);
        URL url = RpcContext.getContext().getUrl();
        return String.format("%s：%s, Hello, %s", url.getProtocol(), url.getPort(), name);  // 正常访问
    }

    @Override
    public CompletableFuture<String> sayHelloAsync(String name) {
        System.out.println("执行了异步服务" + name);

        return CompletableFuture.supplyAsync(() -> {
            return sayHello(name);
        });
    }
}

dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.config-center.address=

# app1的消费者只能消费所有端口为20880的服务实例
# app2的消费者只能消费所有端口为20881的服务实例
---
scope: application
force: true
runtime: true
enabled: true
key: governance-conditionrouter-consumer
conditions:
  - application=app1 => address=*:20880 # 如果你的应用是app1，那么你只能访问20880这个端口的服务
  - application=app2 => address=*:20881
...

# governance-tagrouter-provider应用增加了两个标签分组tag1和tag2
# tag1包含一个实例 127.0.0.1:20880
# tag2包含一个实例 127.0.0.1:20881
---
  force: false
  runtime: true
  enabled: true
  key: governance-tagrouter-provider
  tags:
    - name: tag1
      addresses: ["127.0.0.1:20880"]
    - name: tag2
      addresses: ["127.0.0.1:20881"]
 ...

package com.youthlql.controller;

import org.apache.dubbo.rpc.Constants;
import org.apache.dubbo.rpc.RpcContext;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;

public class ConsumerInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 测试账号
        List<String> tester = new ArrayList<>();
        tester.add("18888888888");

        //标签路由
        String account = request.getParameter("account");
        if (tester.contains(account)) {
            RpcContext.getContext().setAttachment("dubbo.tag", "tag1");
        } else {
            RpcContext.getContext().setAttachment("dubbo.tag", "tag2");
        }
        return true;
    }
}