dubbo分布式rpc框架用法

时间：2023-12-22 16:54:38

　　dubbo是阿里巴巴开源的分布式服务框架，致力于提供高性能和透明化的rpc远程服务调用方案，以及soa服务治理方案，如果没有分布式需求，是不需要dubbo的，分布式环境dubbo的使用架构官方给出了一张图

dubbo分布式rpc框架用法

　　图中涉及到的对象有4个：注册中心、监控管理中心、服务提供者、服务消费者，具体过程以实际项目的dubbo服务部署来介绍，如下图

dubbo分布式rpc框架用法

　　zookeeper集群作为注册中心，dubbo-admin（dubbo官方提供的管理平台）作为服务的监控管理中心，流程说明如下

  1. 首先，启动zookeeper注册中心，dubbo-admin随后启动
  2. 启动dubbo服务提供方系统，启动过程中主动向注册中心注册
  3. 启动dubbo服务消费方系统，启动过程中向注册中心订阅服务
  4. 注册中心将服务提供方信息返回给消费方
  5. 消费方远程调用dubbo服务提供方的服务

　　实际项目通常是集群方式部署，但集群也是基于单节点的，所以，下面先介绍单节点的部署，单节点的意思是只有一个zookeeper、一个dubbo服务提供方、一个dubbo服务消费方，最后会介绍集群部署

安装zookeeper注册中心

　　首先安装注册中心，以zookeeper为例，还有其他可选方案如redis，从zookeeper官方网站下载安装包：zookeeper-3.4.9.tar.gz，解压安装

tar xvf zookeeper-3.4.9.tar.gz -C /usr/java
cd /usr/java/zookeeper-3.4.9/conf
cp zoo_sample.cfg zoo.cfg

　　启动zookeeper，zoo.cfg配置了启动端口等信息，默认：2181

cd /usr/java/zookeeper-3.4.9/bin
./zkServer.sh start

安装dubbo-admin管理中心

　　从http://pan.baidu.com/s/1dDlI7aL下载dubbo-admin-2.5.4.war包，官网已经不提供下载了，将下载的包放在tomcat的webapps目录，启动tomcat自动解压该war包，然后修改配置文件

cd /usr/java/apache-tomcat-7.0.70/webapps/dubbo-admin-2.5.4/WEB-INF
vi dubbo.properties

　　修改zookeeper地址和端口（zookeeper注册中心）

dubbo.registry.address=zookeeper://172.17.210.124:2181
dubbo.admin.root.password=root
dubbo.admin.guest.password=guest

　　重启tomcat（没修改就不用重启了），访问tomcat的url+“/dubbo-admin-2.5.4”登录dubbo管理中心，账户密码：root/root

dubbo服务提供方

　　注册中心和管理中心搭建好之后，开始着手实现dubbo服务提供方

　　声明服务接口

package com.xmyself.demo.dubbo.service;
public interface TestService {
	public String test();
}

　　注意：声明的服务接口要生成一个jar包，服务消费方需要这个jar包才能调用远程的方法，因此，通常服务接口声明在独立的工程如dubbo-client中，这个工程专门打包成jar文件供消费方使用

　　服务实现类

package com.xmyself.demo.dubbo.service;
public class TestServiceImpl implements TestService {
	public String test() {
		return "dubbo is running";
	}
}

　　现在，怎么启动dubbo服务呢？整一个main方法就行

package com.xmyself.demo.dubbo.service;
public class Main {
	public static void main(String[] args) {
		// 启动容器，自动加载资源目录下的/META-INF/spring/*.xml初始化spring容器
		com.alibaba.dubbo.container.Main.main(args);
	}
}

　　我们有提到过，启动dubbo服务提供方时需要主动向注册中心注册服务，这需要依赖一些jar（说明：dubbo 2.5.3直接依赖了spring 2.5.6的全部jar）

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>dubbo</artifactId>
	<version>2.5.3</version>
</dependency>
<dependency>
	<groupId>com.101tec</groupId>
	<artifactId>zkclient</artifactId>
	<version>0.4</version>
</dependency>
<dependency>
	<groupId>org.apache.zookeeper</groupId>
	<artifactId>zookeeper</artifactId>
	<version>3.4.9</version>
</dependency>

　　除了依赖，还需要配置注册中心的信息以及提交给注册中心的信息，dubbo使用了spring，启动dubbo的过程就是初始化spring容器的过程，因此，这些配置都以xml方式提供，在src/main/java目录（包和类的根目录，即classpath）新建META-INF/spring目录，里面放一个dubbo-server.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://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://code.alibabatech.com/schema/dubbo
            http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	<!-- 提供方应用信息，用于计算依赖关系 -->
	<dubbo:application name="dubbo-test" />
	<!-- 使用zookeeper注册中心暴露服务地址 -->
	<dubbo:registry protocol="zookeeper" address="172.17.210.124:2181" />
	<!-- 用dubbo协议在20880端口暴露服务 -->
	<dubbo:protocol name="dubbo" port="20880" />
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:service interface="com.xmyself.demo.dubbo.service.TestService" ref="testService" version="0.0.1" />
	<bean id="testService" class="com.xmyself.demo.dubbo.service.TestServiceImpl" />
</beans>

　　这时候运行main方法dubbo服务提供方就启动了

　　另外，还可以有另一种方式启动（就是自己来初始化spring上下文容器，不用com.alibaba.dubbo.container.Main.main()）

public static void main(String[] args) throws Exception {
     ApplicationContext context = new ClassPathXmlApplicationContext("classpath:META-INF/spring/dubbo-server.xml");
     context.start();
     System.in.read();//阻塞
}

　　登陆dubbo管理中心，可以看到有了新的服务提供方

dubbo服务消费方

　　第一件事就是要依赖提供方提供的接口声明jar

<dependency>
	<groupId>com.xmyself</groupId>
	<artifactId>dubbo-client</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</dependency>

　　然后配置dubbo、zookeeper的依赖

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>dubbo</artifactId>
	<version>2.5.3</version>
</dependency>
<dependency>
	<groupId>com.101tec</groupId>
	<artifactId>zkclient</artifactId>
	<version>0.4</version>
</dependency>
<dependency>
	<groupId>org.apache.zookeeper</groupId>
	<artifactId>zookeeper</artifactId>
	<version>3.4.9</version>
</dependency>

　　dubbo依赖了spring2.5.6版本的所有包，如果使用新版spring，需要排除依赖，实际情况基本都会在新版的spring中初始化dubbo服务，但初始化方式完全相同

　　写一个测试类消费dubbo服务，以直接使用dubbo依赖的spring 2.5.6为例
package com.test.dubbo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.xmyself.demo.dubbo.service.TestService;
public class Test {
	public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("dubbo-client.xml");
        TestService testService = (TestService) context.getBean("testService", TestService.class);
        System.out.println(testService.test());
	}
}

　　前面也有提到，服务消费方启动时需要向注册中心订阅服务，这些配置同样配置在xml文件，在src/main/java（包和类的根目录即classpath）新建dubbo-client.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://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://code.alibabatech.com/schema/dubbo
            http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	<!-- 服务名称 -->
	<dubbo:application name="dubbo-test" />
	<!-- 注册地址 -->
	<dubbo:registry protocol="zookeeper" address="172.17.210.124:2181" />
	<!-- 服务接口 -->
	<dubbo:reference interface="com.xmyself.demo.dubbo.service.TestService" version="0.0.1" />
</beans>

　　运行main方法即启动了dubbo服务消费方

Java Service Wrapper容器

　　dubbo服务直接以main方法运行，不方便管理，找个容器让它运行比较好，tomcat是个不错的容器，但dubbo服务没必要整成web工程那么复杂

　　Java Service Wrapper小巧精悍，只有几百K大小，可以将带有main方法的jar包装成系统服务，然后再将wrapper配置成系统服务，随系统的启动而启动，非常方便

　　从Java Service Wrapper官网下载安装包：wrapper-linux-x86-64-3.5.30.tar.gz，放在/usr/file目录，然后解压

tar xvf /usr/file/wrapper-linux-x86-64-3.5.30.tar.gz -C /usr/java/
vi /usr/java/wrapper-linux-x86-64-3.5.30/conf/wrapper.conf

　　修改如下配置

wrapper.java.mainclass=com.test.dubbo.Main

# Java Classpath (include wrapper.jar)  Add class path elements as
#  needed starting from 1
wrapper.java.classpath.1=../lib/wrappertest.jar
wrapper.java.classpath.2=../lib/wrapper.jar
wrapper.java.classpath.3=/usr/file/*.jar

　　其实配置很简单，就是用来配置启动的main方法以及所需的jar包和xml文件路径

　　启动容器

cd /usr/java/wrapper-linux-x86-64-3.5.30/bin
wrapper -c ../conf/wrapper.conf

　　每次这样启动实在不方便，Java Service Wrapper其实为我们提供了启动的shell脚本，这就是位于/usr/java/wrapper-linux-x86-64-3.5.30/bin目录下的testwrapper文件，启动脚本默认用测试的conf启动，修改成wrapper.conf即可，然后将文件重命名为“wrapperService”，就能以下面的方式运行或停止dubbo服务了

./wrapperService start
./wrapperService stop
./wrapperService restart

zookeeper集群配置

　　dubbo服务提供方与消费方单个和多个没有任何区别，只有zookeeper需要为集群单独配置

　　启动多个zookeeper实例（一般是在不同机器），然后将他们配置成集群，以提供稳定可靠的注册服务，zookeeper集群的启动是以集群中半数以上机器正常启动为基准的，因此zookeeper集群通常是奇数个节点，下面以3台zookeeper节点配置集群为例

　　在三台机器上安装zookeeper，然后修改配置文件，三台机器zoo.cfg配置相同（如果要在同一台机器启动三个zookeeper实例，端口要配置不同）

tickTime=2000
initLimit=10
syncLimit=5
clientPort=2181
dataDir=/tmp/zookeeper/data
server.1=172.17.210.124:2888:3888
server.2=172.17.210.125:2888:3888
server.3=172.17.210.126:2888:3888

　　然后在每个/tmp/zookeeper/data/目录下创建一个myid文件（没有后缀名），文件内容分别为1、2、3，比如server.1=172.17.210.124:2888:3888就表示，172.17.210.124这台机器配置的myid文件内容为1，另外两台同理

　　简单说下配置“server.A=B:C:D”的意思

  • A是一个数字,表示这个是第几号服务器
  • B是这个服务器的ip地址
  • C第一个端口用来集群成员的信息交换,表示的是这个服务器与集群中的Leader服务器交换信息的端口
  • D是在leader挂掉时专门用来进行选举leader所用

　　依次启动三台服务器，这个zookeeper集群就配置好了

　　dubbo配置注册中心的时候只需要用逗号隔开多个注册中心就可以了

address="172.17.210.124:2181,172.17.210.125:2181,172.17.210.126:2181"

相关文章