java架构之路-（dubbo专题）dubbo的基本使用

　　今天我们来说一下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));
    }
}

　　这里代码还是比较多的，比较复杂的，但是便于我们的理解和记忆。记住两个位置的关键代码。

　　①.服务端：ApplicationConfig、ProtocolConfig、RegistryConfig、ServiceConfig这四个是必须的。

　　②.调用方：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配置

　　①.添加依赖

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.4.1</version>
</dependency>

　　②.写注解，在启动类加入@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);
    }
}

　　③.写配置

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的基本使用和一些简单的配置，都是一些基础，还是很好理解的。