https://blog.csdn.net/IT_Holmes/article/details/124518330

部署ZooKeeper

详情见ZooKeeper

搭建控制台管理

  • 去Dubbo官方的Github上面下载dubbo-admin项目

git clone https://github.com/apache/dubbo-admin.git

  • 修改application.properties配置

    image.png

  • 按官方的方法来一步步启动

image.png

Production Setup

  1. Clone source code on develop branch git clone https://github.com/apache/dubbo-admin.git
  2. Specify registry address in dubbo-admin-server/src/main/resources/application.properties
  3. Build
    1. mvn clean package -Dmaven.test.skip=true
    2. 打包后可以在每个对应的target目录下，找到打包后的jar包 java -jar 包名 ：就可以执行的。
  4. Start dubbo-admin
  • mvn --projects dubbo-admin-server spring-boot:run OR
  • cd dubbo-admin-distribution/target; java -jar dubbo-admin-0.1.jar
  • 注意要启动zookeeper注册中心。
  1. Visit http://localhost:8080
  2. Default username and password is root

dubbo-admin是管理页面应该属于Monitor监视部分，就算没有也不影响整个dubbo的工作：

  • dubbo admin是dubbo的图形页面控制台,具有服务查询、服务治理的功能。

image.png

问题一：8080端口占用
zookeeper 的一些高版本中包含一个AdminServer默认的端口是8080，所以导致8080端口占用，dubbo的jar包没法启动。
解决：修改dubbo-admin-server目录下面的application.properties文件添加server.port=9980，将其端口号改为9980。对应访问页面就成http://localhost:9980/了。

问题二： zookeeper not connected
https://zhuanlan.zhihu.com/p/343204228


进入发现，在CuratorZookeeperClient类中设置了连接的超时时间

  1. int timeout = url.getParameter("timeout", 
  2.                 this.DEFAULT_CONNECTION_TIMEOUT_MS);

正确配置：

  • 修改application.properties文件

image.png

问题三：zookeeper提示包太大
https://www.iteye.com/blog/shift-alt-ctrl-1845568
原因：
客户端发送的包太大，超过jute.maxbuffer的设置，默认大小为1048575。
image.png
解决
修改jute.maxbuffer的配置，设置成50M

  • 修改zookeeper配置文件

image.png


搭建服务提供者、消费者

创建主module

创建 dubbo-demo 模块，在pom.xml引入需要的依赖

  1.     <properties>
  2.         <dubbo.version>3.0.8</dubbo.version>
  3.     </properties>
  4.     <dependencies>
  5.         <!-- JAX-RS API -->
  6.         <dependency>
  7.             <groupId>javax.ws.rs</groupId>
  8.             <artifactId>javax.ws.rs-api</artifactId>
  9.             <version>2.0</version>
  10.         </dependency>
  12.         <dependency>
  13.             <groupId>org.slf4j</groupId>
  14.             <artifactId>slf4j-api</artifactId>
  15.             <version>1.7.36</version>
  16.         </dependency>
  18.         <!-- 引入Dubbo3 -->
  19.         <dependency>
  20.             <groupId>org.apache.dubbo</groupId>
  21.             <artifactId>dubbo</artifactId>
  22.             <version>${dubbo.version}</version>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>org.apache.dubbo</groupId>
  26.             <artifactId>dubbo-dependencies-zookeeper</artifactId>
  27.             <version>${dubbo.version}</version>
  28.             <type>pom</type>
  29.         </dependency>
  30.     </dependencies>

搭建公共项目

image.png
其他服务添加相应的依赖

  1. <dependency>
  2.             <groupId>com.huang</groupId>
  3.             <artifactId>dubbo-demo-interface</artifactId>
  4.             <version>1.0-SNAPSHOT</version>
  5. </dependency>

XML方式

  • 创建dubbo-demo-xml模块，引入上面的公共项目

image.png

  • 服务提供者配置

image.png

  1. 在服务提供者项目上面创建配置文件，暴露服务 ```xml <?xml version=”1.0” encoding=”UTF-8”?>

  2. 2. 只需要导入xml文件，在spring中执行就可以了
  3. ```java
  4. package com.huang.dubbo.demo.provider;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  8. import java.io.IOException;
  10. public class XmlProviderApplication {
  11.     public static void main(String[] args) throws IOException {
  12.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-provider.xml");
  13.         context.start();
  14.         System.in.read();
  15.     }
  16. }

image.png

  • 服务消费者配置

image.png

  1. 创建consumer.xml文件，配置dubbo对应文件。 ```xml <?xml version=”1.0” encoding=”UTF-8”?>

  2. - 创建一个main方法来测试，是否能调用成功
  3. ```java
  4. package com.huang.dubbo.demo.consumer;
  6. import com.huang.dubbo.demo.DemoService;
  7. import com.huang.dubbo.demo.GreetingService;
  8. import com.huang.dubbo.demo.RestDemoService;
  9. import com.huang.dubbo.demo.TripleService;
  10. import org.springframework.context.support.ClassPathXmlApplicationContext;
  12. import java.util.concurrent.*;
  14. public class XmlConsumerApplication {
  16.     private static final int CORE_POOL_SIZE = 10;
  17.     private static final int MAX_POOL_SIZE = 100;
  18.     private static final int KEEP_ALIVE_TIME = 10;
  19.     private static final int QUEUE_CAPACITY = 200;
  21.     public static void main(String[] args) throws InterruptedException {
  22.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-consumer.xml");
  23.         context.start();
  24.         DemoService demoService = context.getBean("demoService", DemoService.class);
  25.         GreetingService greetingService = context.getBean("greetingService", GreetingService.class);
  26.         RestDemoService restDemoService = context.getBean("restDemoService", RestDemoService.class);
  27.         TripleService tripleService = context.getBean("tripleService", TripleService.class);
  29.         ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME
  30.                                                                  ,TimeUnit.SECONDS,new ArrayBlockingQueue<>(QUEUE_CAPACITY), Executors.defaultThreadFactory());
  32.         poolExecutor.execute(() -> {
  33.             while (true) {
  34.                 try {
  35.                     String greetings = greetingService.hello();
  36.                     System.out.println(greetings + " from separated thread.");
  37.                 } catch (Exception e) {
  38.                     //                    e.printStackTrace();
  39.                 }
  40.                 try {
  41.                     Thread.sleep(1000);
  42.                 } catch (InterruptedException e) {
  43.                 }
  44.             }
  45.         });
  47.         poolExecutor.execute(()->{
  48.             while (true) {
  49.                 try {
  50.                     String restResult = restDemoService.sayHello("rest");
  51.                     System.out.println(restResult + " from separated thread.");
  52.                 } catch (Exception e) {
  53.                     e.printStackTrace();
  54.                 }
  55.                 try {
  56.                     Thread.sleep(1000);
  57.                 } catch (InterruptedException e) {
  58.                 }
  59.             }
  60.         });
  62.         poolExecutor.execute(()->{
  63.             while (true) {
  64.                 try {
  65.                     String restResult = tripleService.hello();
  66.                     System.out.println(restResult + " from separated thread.");
  67.                 } catch (Exception e) {
  68.                     e.printStackTrace();
  69.                 }
  70.                 try {
  71.                     Thread.sleep(1000);
  72.                 } catch (InterruptedException e) {
  73.                 }
  74.             }
  75.         });
  77.         while (true) {
  78.             try {
  79.                 CompletableFuture<String> hello = demoService.sayHelloAsync("world");
  80.                 System.out.println("result: " + hello.get());
  82.                 String greetings = greetingService.hello();
  83.                 System.out.println("result: " + greetings);
  84.             } catch (Exception e) {
  85.                 //                e.printStackTrace();
  86.             }
  87.             Thread.sleep(5000);
  88.         }
  89.     }
  90. }

image.png

  • 控制台管理调用

image.png

注解方式

  • 创建dubbo-demo-annotation模块，引入上面的公共项目
  • 服务提供者配置

image.png

  1. 新增配置文件dubbo-provider.properties

    1. dubbo.application.name=dubbo-demo-annotation-provider
    2. dubbo.protocol.name=dubbo
    3. dubbo.protocol.port=-1

  2. 创建一个main方法来测试，是否能调用成功 ```java package com.huang.dubbo.demo.provider;

import org.apache.dubbo.config.RegistryConfig; import org.apache.dubbo.config.spring.context.annotation.EnableDubbo; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource;

public class AnnotationProviderApplication {

  1. public static void main(String[] args) throws Exception {
  2.     AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
  3.     context.start();
  4.     System.in.read();
  5. }
  7. @Configuration
  8. @EnableDubbo(scanBasePackages = "com.huang.dubbo.demo.provider")
  9. @PropertySource("classpath:/spring/dubbo-provider.properties")
  10. static class ProviderConfiguration {
  11.     @Bean
  12.     public RegistryConfig registryConfig() {
  13.         RegistryConfig registryConfig = new RegistryConfig();
  14.         registryConfig.setAddress("zookeeper://127.0.0.1:2181");
  15.         return registryConfig;
  16.     }
  17. }

}

  2. - **服务消费者配置**
  4. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/1416299/1654076914448-3720a922-0a70-45a2-aaa3-2cd61afc97ee.png#clientId=u9d41dfc5-c512-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=281&id=u3beaa577&margin=%5Bobject%20Object%5D&name=image.png&originHeight=281&originWidth=344&originalType=binary&ratio=1&rotation=0&showTitle=false&size=65165&status=done&style=none&taskId=u2c23e693-22d5-4d61-ae1f-79ebdf2ff4f&title=&width=344)
  6.    1. 新增配置文件dubbo-consumer.properties
  7. ```java
  8. dubbo.application.name=dubbo-demo-annotation-consumer
  9. dubbo.registry.address=zookeeper://127.0.0.1:2181
  10. dubbo.protocol.port=-1
  1. 添加配置文件DemoServiceComponent ```java package com.huang.dubbo.demo.consumer.comp;

import org.apache.dubbo.config.annotation.DubboReference; import com.huang.dubbo.demo.DemoService; import org.springframework.stereotype.Component;

import java.util.concurrent.CompletableFuture;

@Component(“demoServiceComponent”) public class DemoServiceComponent implements DemoService { @DubboReference private DemoService demoService;

  1. @Override
  2. public String sayHello(String name) {
  3.     return demoService.sayHello(name);
  4. }
  6. @Override
  7. public CompletableFuture<String> sayHelloAsync(String name) {
  8.     return null;
  9. }

}

  2.    3. 创建一个main方法来测试，是否能调用成功
  3. ```java
  4. package com.huang.dubbo.demo.consumer;
  6. import com.huang.dubbo.demo.DemoService;
  7. import com.huang.dubbo.demo.consumer.comp.DemoServiceComponent;
  8. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
  9. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  10. import org.springframework.context.annotation.ComponentScan;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.context.annotation.PropertySource;
  14. public class AnnotationConsumerApplication {
  16.     public static void main(String[] args) {
  17.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);
  18.         context.start();
  19.         DemoService service = context.getBean("demoServiceComponent", DemoServiceComponent.class);
  20.         String hello = service.sayHello("world");
  21.         System.out.println("result :" + hello);
  22.     }
  24.     @Configuration
  25.     @EnableDubbo(scanBasePackages = "com.huang.dubbo.demo.consumer.comp")
  26.     @PropertySource("classpath:/spring/dubbo-consumer.properties")
  27.     @ComponentScan(value = {"com.huang.dubbo.demo.consumer.comp"})
  28.     static class ConsumerConfiguration {
  30.     }
  31. }

image.png

  • 调用

image.png

SpringBoot方式

  • 创建dubbo-demo-spring-boot模块，引入上面的公共项目，并引入springboot依赖

    1. <dependency>
    2.           <groupId>org.springframework.boot</groupId>
    3.           <artifactId>spring-boot-starter</artifactId>
    4.           <version>${spring-boot.version}</version>
    5.       </dependency>
    6.       <dependency>
    7.           <groupId>org.springframework.boot</groupId>
    8.           <artifactId>spring-boot-autoconfigure</artifactId>
    9.           <version>${spring-boot.version}</version>
    10.       </dependency>
    12.       <dependency>
    13.           <groupId>org.springframework.boot</groupId>
    14.           <artifactId>spring-boot-starter-logging</artifactId>
    15.           <version>${spring-boot.version}</version>
    16.           <exclusions>
    17.               <!-- Fix the bug of log4j refer:https://github.com/apache/logging-log4j2/pull/608 -->
    18.               <exclusion>
    19.                   <groupId>org.apache.logging.log4j</groupId>
    20.                   <artifactId>log4j-api</artifactId>
    21.               </exclusion>
    22.           </exclusions>
    23.       </dependency>

  • 服务提供者配置

image.png

  1. dubbo:
  2.   application:
  3.     name: dubbo-demo-springboot-provider
  4.   protocol:
  5.     name: dubbo
  6.     port: -1
  7.   registry:
  8.     id: zk-registry
  9.     address: zookeeper://127.0.0.1:2181
  10.   config-center:
  11.     address: zookeeper://127.0.0.1:2181
  12.   metadata-report:
  13.     address: zookeeper://127.0.0.1:2181
  14. server:
  15.   port: 6060
  1. package com.huang.dubbo.demo.provider;
  3. import com.huang.dubbo.demo.DemoService;
  4. import org.apache.dubbo.config.annotation.DubboService;
  5. import org.apache.dubbo.rpc.RpcContext;
  7. @DubboService
  8. public class DemoServiceImpl implements DemoService {
  10.     @Override
  11.     public String sayHello(String name) {
  12.         System.out.println("Hello " + name + ", request from consumer: " + RpcContext.getContext().getRemoteAddress());
  13.         return "Hello " + name;
  14.     }
  15. }
  1. package com.huang.dubbo.demo.provider;
  4. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. import java.util.concurrent.CountDownLatch;
  10. @SpringBootApplication
  11. @EnableDubbo(scanBasePackages = {"com.huang.dubbo.demo.provider"})
  12. public class SpringBootProviderApplication {
  13.     public static void main(String[] args) throws InterruptedException {
  14.         SpringApplication.run(SpringBootProviderApplication.class,args);
  15.         System.out.println("dubbo service started");
  16.         new CountDownLatch(1).await();
  17.     }
  18. }
  • 服务消费者配置

image.png

  2. dubbo:
  3.   application:
  4.     name: dubbo-demo-springboot-consumer
  5.   protocol:
  6.     name: dubbo
  7.     port: -1
  8.   registry:
  9.     id: zk-registry
  10.     address: zookeeper://127.0.0.1:2181
  11.   config-center:
  12.     address: zookeeper://127.0.0.1:2181
  13.   metadata-report:
  14.     address: zookeeper://127.0.0.1:2181
  15. server:
  16.   port: 6061
  1. package com.huang.dubbo.demo.consumer;
  3. import com.huang.dubbo.demo.DemoService;
  4. import org.apache.dubbo.config.annotation.DubboReference;
  5. import org.springframework.stereotype.Service;
  7. @Service
  8. public class SpringService {
  10.     @DubboReference
  11.     private DemoService demoService;
  13.     public String doSayHello(String name) {
  14.         return demoService.sayHello(name);
  15.     }
  16. }
  1. package com.huang.dubbo.demo.consumer;
  3. import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.context.ConfigurableApplicationContext;
  8. @SpringBootApplication
  9. @EnableDubbo
  10. public class SpringBootConsumerApplication {
  11.     public static void main(String[] args) {
  12.         ConfigurableApplicationContext context = SpringApplication.run(SpringBootConsumerApplication.class, args);
  13.         SpringService application = context.getBean(SpringService.class);
  14.         String result = application.doSayHello("world");
  15.         System.out.println("result: " + result);
  16.     }
  17. }

image.png

  • 调用

image.png

监控中心(Monitor)