// 服务接口类
public interface SimpleDemoService {
    String sayHello(String msg);
    List<String> sayHello2(String msg);
}
// 常规的服务提供者
public class GenericProvider {
    public static void main(String[] args) throws IOException {
    	// applicationname 为 simple， 接口类型为 SimpleDemoService， 实现类为 MainSimpleDemoServiceImpl
        ServiceConfig<SimpleDemoService> serviceConfig = DubboUtil.serviceConfig("simple", SimpleDemoService.class, new MainSimpleDemoServiceImpl());

        serviceConfig.export();
        System.out.println("service is start");
        System.in.read();
    }
}

// 输出
// sayHello = MainSimpleDemoServiceImpl : generic
// sayHello2 = [MainSimpleDemoServiceImpl : generic2]
public class GenericConsumer {
    public static void main(String[] args) {
        ReferenceConfig<GenericService> referenceConfig = DubboUtil.referenceConfig("simple", GenericService.class);
        referenceConfig.setGeneric(true);
        referenceConfig.setInterface("com.dubbo.service.impl.SimpleDemoService");
        GenericService genericService = referenceConfig.get();
        // 通过 GenericService.$invoke 方法指定是泛化调用，方法名为 sayHello。参数类型为 String， 参数内容为 generic
        Object sayHello = genericService.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{"generic"});
        System.out.println("sayHello = " + sayHello);

		// 调用 sayHello2 方法
        Object sayHello2 = genericService.$invoke("sayHello2", new String[]{"java.lang.String"}, new Object[]{"generic2"});
        System.out.println("sayHello2 = " + sayHello2);
    }
}

// 服务提供者 
public class GenericProvider {
    public static void main(String[] args) throws IOException {
    	// 获取 ServiceConfig
    	// 指定 applicationname 为 simple
    	// 指定 interface 为 com.kingfish.service.impl.SimpleDemoService,
    	// 指定 Ref 为 匿名 GenericService 接口实现类
        ServiceConfig<GenericService> serviceConfig = DubboUtil.serviceConfig("simple", "com.kingfish.service.impl.SimpleDemoService", new GenericService() {
            @Override
            public Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException {
            	// 当消费者调用SimpleDemoService 服务时会进入到该方法中，根据如下判断逻辑来处理不同的方法。
                if ("sayHello".equals(method)) {
                    return "generic sayHello " + Arrays.toString(args);
                } else if ("sayHello2".equals(method)) {
                    return Lists.newArrayList("generic sayHello2 " + Arrays.toString(args));
                }
                return null;
            }
        });
		// 启用泛化
        serviceConfig.setGeneric("true");
        // 服务暴露
        serviceConfig.export();
        System.out.println("service is start");
        // 阻塞程序，防止main方法执行结束
        System.in.read();
    }
}

// 输出 
// s = generic sayHello [111]
// strings = [generic sayHello2 [222]]
public class GenericConsumer {
    public static void main(String[] args) {
    	// 获取 SimpleDemoService 的 referenceConfig 
        ReferenceConfig<SimpleDemoService> referenceConfig = DubboUtil.referenceConfig("simple", SimpleDemoService.class);
        SimpleDemoService simpleDemoService = referenceConfig.get();
        // 调用 SimpleDemoService 的方法
        String s = simpleDemoService.sayHello("111");
        System.out.println("s = " + s);
        List<String> strings = simpleDemoService.sayHello2("222");
        System.out.println("strings = " + strings);
    }
}

@Service
public class MainSimpleDemoServiceImpl implements SimpleDemoService {
    @Override
    public String sayHello(String msg) {
    	// 这里会将上下文的参数获取到并返回
        Object context = RpcContext.getContext().getAttachment("context");
        return "MainSimpleDemoServiceImpl : " + msg + " context = " + context;
    }
}

// 消费者。设置参数 context =  SimpleConsumer
public class SimpleConsumer {

    public static void main(String[] args) throws InterruptedException {
        ReferenceConfig<SimpleDemoService> referenceConfig = DubboUtil.referenceConfig("dubbo-consumer", SimpleDemoService.class);
        referenceConfig.setMonitor("http://localhost:8080");
        SimpleDemoService demoService = referenceConfig.get();
        // 消费者设置隐式参数 context = SimpleConsumer，提供者可以获取到该参数
        RpcContext.getContext().setAttachment("context", "SimpleConsumer");
        // 输出 MainSimpleDemoServiceImpl : SimpleConsumer context = SimpleConsumer
        System.out.println(demoService.sayHello("SimpleConsumer"));
    }
    
}

// 服务提供者
public class SimpleProvider {
    public static void main(String[] args) throws IOException {
        ServiceConfig<SimpleDemoService> serviceConfig = DubboUtil.serviceConfig("dubbo-provider", SimpleDemoService.class, new MainSimpleDemoServiceImpl());
        serviceConfig.export();
        System.out.println("service is start");
        System.in.read();
    }
}

    @Override
    public Result invoke(final Invocation invocation) throws RpcException {
        checkWhetherDestroyed();

        // binding attachments into invocation.
        // 获取上下文参数
        Map<String, String> contextAttachments = RpcContext.getContext().getAttachments();
        // 如果上下文参数不为空，则添加到 RpcInvocation 中。RpcInvocation会随着网络调用传递到提供者端
        if (contextAttachments != null && contextAttachments.size() != 0) {
            ((RpcInvocation) invocation).addAttachments(contextAttachments);
        }
		// 获取服务提供者列表
        List<Invoker<T>> invokers = list(invocation);
        // 初始化负载均衡策略
        LoadBalance loadbalance = initLoadBalance(invokers, invocation);
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
        // 进行调用
        return doInvoke(invocation, invokers, loadbalance);
    }

@Activate(group = Constants.CONSUMER, order = -10000)
public class ConsumerContextFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
    	// 设置上下文的信息
        RpcContext.getContext()
                .setInvoker(invoker)
                .setInvocation(invocation)
                .setLocalAddress(NetUtils.getLocalHost(), 0)
                .setRemoteAddress(invoker.getUrl().getHost(),
                        invoker.getUrl().getPort());
        if (invocation instanceof RpcInvocation) {
            ((RpcInvocation) invocation).setInvoker(invoker);
        }
        try {
            // TODO should we clear server context?
            // 清除 ServerContext
            RpcContext.removeServerContext();
            // 进行服务调用
            return invoker.invoke(invocation);
        } finally {
            // TODO removeContext? but we need to save future for RpcContext.getFuture() API. If clear attachments here, attachments will not available when postProcessResult is invoked.
            // 清除当前线程中添加的附加属性
            RpcContext.getContext().clearAttachments();
        }
    }

    @Override
    public Result onResponse(Result result, Invoker<?> invoker, Invocation invocation) {
    	// 调用返回时设置 ServerContext
        RpcContext.getServerContext().setAttachments(result.getAttachments());
        return result;
    }
}

@Activate(group = Constants.PROVIDER, order = -10000)
public class ContextFilter implements Filter {

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
    	// 获取 Invocation 中的属性添加到上下文中
        Map<String, String> attachments = invocation.getAttachments();
        if (attachments != null) {
        	// 移除一些系统参数
            attachments = new HashMap<String, String>(attachments);
            attachments.remove(Constants.PATH_KEY);
            attachments.remove(Constants.GROUP_KEY);
            attachments.remove(Constants.VERSION_KEY);
            attachments.remove(Constants.DUBBO_VERSION_KEY);
            attachments.remove(Constants.TOKEN_KEY);
            attachments.remove(Constants.TIMEOUT_KEY);
            // Remove async property to avoid being passed to the following invoke chain.
            attachments.remove(Constants.ASYNC_KEY);
            attachments.remove(Constants.TAG_KEY);
            attachments.remove(Constants.FORCE_USE_TAG);
        }
        RpcContext.getContext()
                .setInvoker(invoker)
                .setInvocation(invocation)
//                .setAttachments(attachments)  // merged from dubbox
                .setLocalAddress(invoker.getUrl().getHost(),
                        invoker.getUrl().getPort());

        // merged from dubbox
        // we may already added some attachments into RpcContext before this filter (e.g. in rest protocol)
        // 如果附加属性不为空则设置到上下文对象中。
        if (attachments != null) {
            if (RpcContext.getContext().getAttachments() != null) {
                RpcContext.getContext().getAttachments().putAll(attachments);
            } else {
                RpcContext.getContext().setAttachments(attachments);
            }
        }

        if (invocation instanceof RpcInvocation) {
            ((RpcInvocation) invocation).setInvoker(invoker);
        }
        try {
            return invoker.invoke(invocation);
        } finally {
            // IMPORTANT! For async scenario, we must remove context from current thread, so we always create a new RpcContext for the next invoke for the same thread.
            // 调用结束移除 上下文信息
            RpcContext.removeContext();
            RpcContext.removeServerContext();
        }
    }

    @Override
    public Result onResponse(Result result, Invoker<?> invoker, Invocation invocation) {
        // pass attachments to result
        // 处理结束后，向 ServerContext 中添加附件属性，Result 会随着网络请求返回给 消费者
       
        result.addAttachments(RpcContext.getServerContext().getAttachments());
        return result;
    }
}