java架构之路-(dubbo专题)dubbo的基本使用

2019/04/10 10:10
阅读数 10

  今天我们来说一下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的基本使用和一些简单的配置,都是一些基础,还是很好理解的。

 

 

原文出处:https://www.cnblogs.com/cxiaocai/p/12323685.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部