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的基本使用和一些簡單的配置，都是一些基礎，仍是很好理解的。