spring整合dubbo[单机版]

Spring整合Dubbo,这个是用xml配置的 (方式一)
来梳理下步骤:

1. 安装zookeeper,在进行简单配置[这里使用单机模式,不用集群]
2. 创建maven项目,构建项目结构
3. 编写提供者项目
4. 安装dubbo-admin 查看服务信息
5. 编写消费者的项目

安装zookeeper

> 下载地址
https://www.apache.org/dyn/closer.cgi/zookeeper/

简单配置:

* 先在其根目录下新建一个data文件夹和一个log文件夹,这就是以后创建连接后保存的地方
* 将其根目录下的conf文件下的zoo-simple.cfg重新复制下将其命名为zoo.cfg,然后在其中将以下语句修改为你新建文件的指定路径

dataDir=/home/zookeeper/data dataLogDir=/home/zookeeper/log

创建maven项目,构建项目结构

1. 创建父工程
2. 创建一个service接口的单独的工程,这是把实现类和接口拆分了,接口作为jar包的引用提供给了提供者实现类和消费者,具体的实现类是在提供者实现类中实现的
3. 提供者接口,这里是将实现类和接口分离,单独的将接口打包成一个jar包分离出来,其他项目需要引入其jar包,才能调用
4. 这里的提供者接口的jar,就只有一个接口,没有依赖.

导入依赖

1<dependency>
2            <groupId>com.cn.dubbo-parents</groupId>
3            <artifactId>com.dubbo-service</artifactId>
4            <version>1.0-SNAPSHOT</version>
5        </dependency>
6        <!--导入Dubbo-->
7        <dependency>
8            <groupId>com.alibaba</groupId>
9            <artifactId>dubbo</artifactId>
10            <version>2.5.3</version>
11            <exclusions>
12                <exclusion>
13                    <groupId>org.springframework</groupId>
14                    <artifactId>spring</artifactId>
15                </exclusion>
16            </exclusions>
17        </dependency>
18        <dependency>
19            <groupId>org.springframework</groupId>
20            <artifactId>spring-webmvc</artifactId>
21            <version>4.1.6.RELEASE</version>
22        </dependency>
23        <!--访问zookeeper的客户端的功能-->
24        <dependency>
25            <groupId>com.101tec</groupId>
26            <artifactId>zkclient</artifactId>
27            <version>0.10</version>
28        </dependency>

注意:
这里使用的dubbo版本中依赖的spring版本是比较老的版本,会和现在的spring版本冲突,需要把老的版本去去除掉,

<exclusions> <exclusion> <groupId>org.springframework</groupId> <artifactId>spring</artifactId> </exclusion> </exclusions>

编写spring-dubbo.xml 的配置文件
　　

1<?xml version="1.0" encoding="UTF-8"?>
2    <beans xmlns="http://www.springframework.org/schema/beans"
3       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4       xmlns:context="http://www.springframework.org/schema/context"
5       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
6       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
7        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
8        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
9
10    <!--给当前的provider 名字-->
11    <dubbo:application name="dubbo-server"></dubbo:application>
12
13    <!--配置注册中心-->
14    <dubbo:registry address="XXX.XXX.XXX.XXX:2181" protocol="zookeeper"></dubbo:registry>
15
16    <!--name是从注册中心获取的地址(固定值)-->
17    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
18
19    <!--提供注册功能-->
20    <dubbo:service interface="com.cn.zy.DubboService" ref="dubboServiceImpl"></dubbo:service>
21    <bean id="dubboServiceImpl" class="com.cn.DemoServiceImpl"></bean>
22    </beans>

<pre style="color:red"> * 1\. 这里的配置文件的位置是在resource/META-INF/spring/spring-dubbo.xml,这里的路径需要自己创建,\[后面有详细说明\] * 2\. 注册中心的配置是需要指定协议:zookeeper * 3\. 配置spring的bean将接口实现类实现其接口的jar包 * 4\. 开始我在实现类上添加了@Service注解,这里不是Spring的注解是Dubbo的注解,总是报错冲突,因为这和spring提供的aop产生冲突,所以这里采用xml配置来实现 </pre>

瞅一眼提供者实现类:

1public class DemoServiceImpl implements DubboService{
2    @Override
3    public String serviceDemo(String str) {
4        return "这是提供方提供的实现类: "+str;
5    }
6    }

怎么知道他已经注册了呢?
编写测试程序:

1ClassPathXmlApplicationContext ac = new
2                ClassPathXmlApplicationContext("application-duboo.xml");
3        ac.start();
4        System.out.println("启动成功....");

这里也有个坑就是,这个程序在启动成功的时候就结束了...

那还怎么玩?写个死循环?写个线程阻塞?,,,反正不能让他挂掉

这里使用的是Dubbo提供的Main方法,调用main阻塞在这里,但是又有一个坑就是配置文件加载问题,这里的开始我们手动加载配置文件,后来使用的注解后配置文件就没有引入,这就是自动加载了,但是文件路径需要钉死在

resource/META-INF/spring/

这个目录下
具体代码像这样:

1public class DubboTest {
2    public static void main(String[] args) {
3    //        防止程序关闭
4    //        指定配置文件的路径:  META-INF/spring/***.xml
5            Main.main(args);
6        }
7    }

至此,提供者算是实现了,但是怎么查看程序运行成功的呢?

安装dubbo-admin 查看服务信息

需要使用dubbo官方提供的admin工具,这里又有个坑,待我慢慢说来因为本人是看视频教学,学习的... 额具体哪家,大家都懂的,网上的博客参差不齐,很多都无法实现,要不就是说明不全,唉,心累.

就像这个dubbo-admin一样,开始使用教程提供的war怎么也访问不了,要不就是拒绝访问,要不就是访问404,解决如下:

注意:

1. 去github下载:
[https://github.com/apache/incubator-dubbo/tree/2.5.x\](https://github.com/apache/incubator-dubbo/tree/2.5.x "Dubbo源码")
2. 我们只需要其中的一个项目dubbo-admin,在pom.xml路径下运行mvn install 命令,会一段时间会生成target目录,我们只需要其中的dubbo-admin-****.war包,也可以重命名
3. 在服务器上启动tomcat,这需要注意的是,如果你服务器上有多个tomcat注意配置tomcat端口,防止冲突,这个教程很多,一搜一大堆, 略过...
4. tomcat启动成功后访问ip:端口/dubbo文件夹名,发现可能还是错误
5. 没事,接下来,需要关闭tomcat,然后修改dubbo-admin下的WEB-INF下的dubbo.properties,修改其

    dubbo.registry.address=zookeeper://XX.XXX.XXX.XX:2181
    dubbo.admin.root.password=root
    dubbo.admin.guest.password=guest
修改成你自己服务器启动的zookeeper的端口和地址

最后启动tomcat,用户名和密码就是上面配置文件里面的的

root root [这是root用户]
guest guest [这是普通用户]

瞅一下服务治理,看有没有服务注册了:

好了,这下妥妥滴

编写消费者的项目

消费者和提供者大体上是一样的,不过消费者不需要拆分接口和实现类,在xml配置文件中有点不同,其他都一样.我们来看下

1. 导入依赖,和提供方是一样的
2. 配置xml文件

只看具体的配置:

1<!--给当前的customer 名字-->
2    <dubbo:application name="dubbo-customer"></dubbo:application>
3
4    <!--配置注册中心-->
5    <dubbo:registry address="XXX.XXX.XXX.XXX:2181" protocol="zookeeper"></dubbo:registry>
6
7    <!--消费者方注解-->
8    <dubbo:annotation package="com.cn.coustomer.impl.DubboCustomerServiceImpl"/>
9
10    <!--添加执行bean-->
11    <bean id="testService" class="com.cn.coustomer.impl.DubboCustomerServiceImpl"/>

这里添加的是消费者的实现类,使用annotation,就可以实现注解了:

1import com.alibaba.dubbo.config.annotation.Reference;
2
3    public class DubboCustomerServiceImpl implements DubboCustomerService {
4
5    @Reference
6    private DubboService dubboService;
7
8        @Override
9        public String customer(String str) {
10            //调用提供者的功能
11            String s = dubboService.serviceDemo(str);
12            return s+": 我在消费者实现类中调用了...";
13        }
14    }

使用的是@Reference是dubbo的注解,这里的消费者的提供接口,是供程序内部调用的,所以并不和dubbo调用产生联系,

1public interface DubboCustomerService {
2        String customer(String str);
3    }

写个测试类:

1public class TestService {
2    public static void main(String[] args) {
3            ApplicationContext ac = new ClassPathXmlApplicationContext("application-duboo.xml");
4            DubboCustomerServiceImpl testService = ac.getBean("testService", DubboCustomerServiceImpl.class);
5            String customer = testService.customer("我是消费者执行的实现类方法!!!");
6            System.out.println(customer);
7        }
8    }

result:

##SpringBoot整合dubbo (方式二)

###这个整合更加的简单,没有xml配置了,项目的结构和上面一致

1. 消费者方实现接口
2. 提供方拆分的接口jar
3. 提供方拆分的接口实现类

##提供方拆分的接口实现类
我们先做接口的实现类pom.xml
spring版本

1<parent>
2        <groupId>org.springframework.boot</groupId>
3        <artifactId>spring-boot-starter-parent</artifactId>
4        <version>2.1.1.RELEASE</version>
5        <relativePath/> <!-- lookup parent from repository -->
6    </parent>

导入SpringBoot整合依赖包

1<dependency>
2            <groupId>org.springframework.boot</groupId>
3            <artifactId>spring-boot-starter-web</artifactId>
4        </dependency>
5
6        <dependency>
7            <groupId>org.springframework.boot</groupId>
8            <artifactId>spring-boot-starter-test</artifactId>
9            <scope>test</scope>
10        </dependency>
11        <dependency>
12            <groupId>com.springboot-dubbo-parents</groupId>
13            <artifactId>proivder-service</artifactId>
14            <version>1.0-SNAPSHOT</version>
15        </dependency>
16        <!-- Spring Boot Dubbo 依赖 -->
17        <dependency>
18            <groupId>io.dubbo.springboot</groupId>
19            <artifactId>spring-boot-starter-dubbo</artifactId>
20            <version>1.0.0</version>
21        </dependency>
22        <dependency>
23            <groupId>log4j</groupId>
24            <artifactId>log4j</artifactId>
25            <version>1.2.17</version>
26        </dependency>

配置application.properties

1server.port=9800
2    spring.dubbo.application.name=provider
3    spring.dubbo.registry.address=zookeeper://XXX.XXX.XXX.XXX:2181
4    spring.dubbo.protocol.name=dubbo
5    spring.dubbo.protocol.port=20880
6    spring.dubbo.scan=com.providerservicerimpl.providerservicerimpl.com.zn.zy

spring.dubbo.application.name 应用名称
spring.dubbo.registry.address 注册中心地址
spring.dubbo.protocol.name 协议名称
spring.dubbo.protocol.port 协议端口
spring.dubbo.scan dubbo 服务类包目录

#注意
提供方仅仅是写了个实现类,添加了一个@Service,注意这个注解是Dubbo的注解不是Spring的注解

然后注解添加版本号

##提供方拆分的接口jar
好了,再看拆分的接口打包的jar,真的就是一个接口,啥也没有,就不说了

启动提供方项目,查看是否运行成功

admin上服务已经注册,说明我们的程序运行成功了

#注意
万里长征终于迈出第一步哦
开始在windows平台上[win7 OS]测总是没有用,要不就是超时,要不就是各种报错,无语了,这里最好在linux上运行zookeeper

##消费者方实现接口

依赖和提供方是一样的

application.perpeties配置

1server.port=9801
2    spring.dubbo.application.name=customer
3    spring.dubbo.registry.address=zookeeper://XXX.XXX.XXX.XXX:2181
4    spring.dubbo.protocol.name=dubbo
5    spring.dubbo.scan=com.customerserviceimpl.customerserviceimpl.com.cn.service.impl

这里就是普通的接口实现类操作.

接口:

1/**
2     * @author zhangyi
3     * @date 2018/12/21 14:28
4     */
5    public interface CustomerService {
6
7        String customer(String s);
8    }

实现类

1/**
2     * @author zhangyi
3     * @date 2018/12/21 14:28
4     */
5    @Service
6    public class CustomserServiceImpl implements CustomerService {
7
8        @Reference(version = "1.0.0")
9        private DubboService dubboService;
10
11        @Override
12        public String customer(String s) {
13            String c = dubboService.service("消费端调用:::后传"+s);
14            return c;
15        }
16    }

#注意
这里的@Service是Spring的注解,这是将此实现类注入到Spring容器中,方便其他类去调用,

#####还有个注解就是@Reference --- 表示依赖与在zookeeper注册中心中的版本号是1.0.0的DubboService接口,远程调用

可以写个测试类验证下

1@RunWith(SpringRunner.class)
2    @SpringBootTest
3    public class CustomerServiceImplApplicationTests {
4
5        @Autowired
6        private CustomerService customerService;
7
8
9        @Test
10        public void contextLoads() {
11            String test = customerService.customer("测试注入");
12            System.out.println(test);
13        }
14
15    }

结果输出

妥妥滴,完成

<pre > 补充下:提供者的接口全路径需要和消费者的接口全路径保持一致,不然无法调用 </pre>

spring整合dubbo[单机版]

评论区

相关推荐