今天我们来说一下 dubbo 的基本使用, 没有什么高阶的知识, 真的超级简单易懂.
Dubbo 核心功能解释
dubbo 阿里开源的一个 SOA 服务治理框架, 从目前来看把它称作是一个 RPC 远程调用框架更为贴切. 单从 RPC 框架来说, 功能较完善, 支持多种传输和序列化方案. 所以想必大家已经知道他的核心功能了: 就是远程调用. 太多的理论知识我就不说了, 这是他的官网 http://dubbo.apache.org/en-us/ , 有时间的自己去看看吧, 我们就直接上代码吧~!
基于代码的方式 (最简单的实例)
先说一下我们的场景, 就是我们有一个用户服务, 对外提供一个接口, 可以根据我们的用户 ID 来查找我们的用户对象, 然后一个一个 client 服务想调用我们的用户服务的查找接口, 就这么简单的一个例子我们来看一下.
首先加入我们的 maven 依赖
- <!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo -->
- <dependency>
- <groupId>org.apache.dubbo</groupId>
- <artifactId>dubbo</artifactId>
- <version>2.7.3</version>
- </dependency>
用户服务:
我们先建立一个用户对象, 并且给予序列化, 必须序列化, 不然会报错, 后面会说为什么需要实例化.
- package com.simple.bean;
- import java.io.Serializable;
- public class UserBean implements Serializable {
- private Integer id;
- private String nama;
- private Integer age;
- public Integer getId() {
- return id;
- }
- public void setId(Integer id) {
- this.id = id;
- }
- public String getNama() {
- return nama;
- }
- public void setNama(String nama) {
- this.nama = nama;
- }
- public Integer getAge() {
- return age;
- }
- public void setAge(Integer age) {
- this.age = age;
- }
- @Override
- public String toString() {
- return "UserBean{" +
- "id=" + id +
- ", nama='" + nama + '\'' +
- ", age=" + age +
- '}';
- }
- public UserBean(Integer id, String nama, Integer age) {
- this.id = id;
- this.nama = nama;
- this.age = age;
- }
- }
建立一个简单的 UserService, 并且给予实现类.
- package com.simple.service;
- import com.simple.bean.UserBean;
- public interface UserService {
- UserBean getUserById(Integer id);
- }
- package com.simple.service;
- import com.simple.bean.UserBean;
- public class UserServiceImpl implements UserService {
- @Override
- public UserBean getUserById(Integer id) {
- return new UserBean(1, "张三", 18);
- }
- }
前面都是准备工作, 我们接下来看一下我们如何将我们的服务暴露出去, 并给与其它服务调用.
- package com.simple;
- import com.simple.service.UserService;
- import com.simple.service.UserServiceImpl;
- import org.apache.dubbo.config.ApplicationConfig;
- import org.apache.dubbo.config.ProtocolConfig;
- import org.apache.dubbo.config.RegistryConfig;
- import org.apache.dubbo.config.ServiceConfig;
- import java.io.IOException;
- public class ASimpleDubboServer {
- public static void main(String[] args) throws IOException {
- // 开始暴露服务
- ApplicationConfig applicationConfig = new ApplicationConfig("simple-app");// 设置服务名称
- ProtocolConfig protocolConfig = new ProtocolConfig();// 远程调用配置
- protocolConfig.setName("dubbo");
- protocolConfig.setPort(-1);
- RegistryConfig registryConfig = new RegistryConfig(RegistryConfig.NO_AVAILABLE);// 注册中心配置, RegistryConfig.NO_AVAILABLE 为不使用注册中心
- ServiceConfig serviceConfig = new ServiceConfig();// 设置服务
- serviceConfig.setInterface(UserService.class);// 给予接口
- serviceConfig.setRef(new UserServiceImpl());// 给予实例
- serviceConfig.setRegistry(registryConfig);
- serviceConfig.setProtocol(protocolConfig);
- serviceConfig.setApplication(applicationConfig);
- serviceConfig.export();
- System.out.println("服务已经暴露成功");
- System.in.read();// 禁止程序运行结束
- }
- }
我们再来看一下我们的调用端代码.
- package com.simleclient;
- import com.simple.service.UserService;
- import org.apache.dubbo.config.ApplicationConfig;
- import org.apache.dubbo.config.ReferenceConfig;
- public class ASimleClientApplication {
- public static void main(String[] args) {
- ApplicationConfig applicationConfig = new ApplicationConfig("client-app");// 设置服务名称, 不一定要和服务端一致
- ReferenceConfig referenceConfig = new ReferenceConfig();// 设置实例配置
- referenceConfig.setApplication(applicationConfig);
- referenceConfig.setInterface(UserService.class);
- referenceConfig.setUrl("dubbo://192.168.138.1:20880/com.simple.service.UserService");// 给予 URL
- UserService userService = (UserService)referenceConfig.get();// 开始调用
- System.out.println("userService.getUserById(1) =" + userService.getUserById(1));
- }
- }
这里代码还是比较多的, 比较复杂的, 但是便于我们的理解和记忆. 记住两个位置的关键代码.
1. 服务端: ApplicationConfig,ProtocolConfig,RegistryConfig,ServiceConfig 这四个是必须的.
2. 调用方: ApplicationConfig,ReferenceConfig.
也不用背, 后面的 spring 会简单很多, springBoot 会更简单. 我们先来看一下 spring xml 的配置方式是怎么做的.
Spring 配置
首先, 我们建立两个 xml 文件, 一个是 consumer.xml, 一个是 provide.xml. 看一下具体的实现和上面的基本是一个道理的.
consumer.xml
- <?xml version="1.0" encoding="UTF-8"?>
- <beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
- xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
- http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
- <dubbo:application name="spring-dubbo"/>
- <dubbo:registry address="N/A"/>
- <dubbo:reference id="userService" interface="com.spring.service.UserService" url="dubbo://127.0.0.1:20880"/>
- </beans>
provide.xml
- <?xml version="1.0" encoding="UTF-8"?>
- <beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
- xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
- http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
- <dubbo:application name="spring-dubbo"/>
- <dubbo:registry address="N/A"/>
- <dubbo:protocol name="dubbo" port="-1"/>
- <dubbo:service interface="com.spring.service.UserService" ref="userService"/>
- <bean id="userService" class="com.spring.service.UserServiceImpl"></bean>
- </beans>
服务端启动类
- package com.spring;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- import java.io.IOException;
- public class SpringServer {
- public static void main(String[] args) throws IOException {
- new ClassPathXmlApplicationContext("provide.xml");
- System.in.read();
- }
- }
请求类
- package com.spring;
- import com.spring.service.UserService;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- public class SpringClient {
- public static void main(String[] args) {
- ClassPathXmlApplicationContext context =
- new ClassPathXmlApplicationContext("consumer.xml");
- UserService userService = context.getBean(UserService.class);
- System.out.println(userService.getUserById(1));
- }
- }
说完了源代码连接的方式, 再来看 spring 的, 简直超级简单的. 每次启动会报出一个端口冲突的错误, 别在意, 会自动生成 20880 后面的端口, 在启动时添加 - Ddubbo.application.qos.enable=false 参数即可.
springboot 配置
1. 添加依赖
- <dependency>
- <groupId>org.apache.dubbo</groupId>
- <artifactId>dubbo-spring-boot-starter</artifactId>
- <version>2.7.4.1</version>
- </dependency>
2. 写注解, 在启动类加入 @EnableDubbo 注解
- package com.server;
- import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
- import org.springframework.boot.SpringApplication;
- import org.springframework.boot.autoconfigure.SpringBootApplication;
- @EnableDubbo
- @SpringBootApplication
- public class CDubboServerApplication {
- public static void main(String[] args) {
- SpringApplication.run(CDubboServerApplication.class, args);
- System.out.println("服务已开启");
- }
- }
在你的服务给予 sevice 直接, 注解需要引用 dubbo 包下的 service, 并且加入 @Component 引用为 Bean
- package com.server.service;
- import com.server.bean.UserBean;
- import org.apache.dubbo.config.annotation.Service;
- import org.springframework.stereotype.Component;
- @Component
- @Service
- public class UserServiceImpl implements UserService {
- @Override
- public UserBean getUserById(Integer id) {
- return new UserBean(1, "张三", 18);
- }
- }
3. 写配置
- dubbo.application.name=bootServer
- dubbo.registry.address=zookeeper://192.168.138.129:2181
- dubbo.protocol.name=dubbo
- dubbo.protocol.port=-1
调用方配置
- dubbo.application.name=bootClient
- dubbo.registry.address=zookeeper://192.168.138.129:2181
springboot 比起 spring 来会更简单, 接下来我们看一下一些高级的配置.
高级配置
这里的配置太多, 太多了, 我只挑几个用的比较多来说一下吧.
- ## 只引用服务, 但不提供服务
- dubbo.registry.register=false
- ## 调用方不会验证服务端是否启动, 而持续重连
- dubbo.registry.check=false
服务的分组和版本控制.
@Service(group = "",version ="")
如果调用失败, 重试次数
@Service(group = "",version ="",retries = 2)
调用策略
- @Service(group = "",version ="",retries = 2,loadbalance = "roundrobin")
- //random = 随机
- //roundrobin = 轮询
- //leastactive = 最少调用
- //consistenthash=hash 散列
超时时间
@Service(group = "",version ="",retries = 2,loadbalance = "roundrobin",timeout = 2000)
上述的配置也可以用配置文件来统一配置
- dubbo.provider.version=
- dubbo.provider.group=
- dubbo.provider.loadbalance=
- dubbo.provider.retries=
- dubbo.provider.timeout=
- ## provider 独有的线程数
- dubbo.provider.threads=
- ## 线程模型
- dubbo.provider.threadpool=
- ## fixed 固定
- ## cached 缓存
- ## limited
- ## eager
这些配置都是双向可配置的, 就是说, 服务方和调用方都可以配置的, 一般的参数都是在服务端配置, 在客户端使用, 比如我们的超时时间, 你配置了 2 秒钟, 配置在服务端, 你客户端也是需要遵循这个两秒钟超时时间的.
超时时间是按照
总结:
今天说了 dubbo 的基本使用和一些简单的配置, 都是一些基础, 还是很好理解的.
来源: https://www.cnblogs.com/cxiaocai/p/12323685.html