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,就只有一个接口,没有依赖.

导入依赖

<dependency>
            <groupId>com.cn.dubbo-parents</groupId>
            <artifactId>com.dubbo-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--导入Dubbo-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1..RELEASE</version>
        </dependency>
        <!--访问zookeeper的客户端的功能-->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>

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

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

编写spring-dubbo.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:context="http://www.springframework.org/schema/context"
       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://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!--给当前的provider 名字-->
    <dubbo:application name="dubbo-server"></dubbo:application>

    <!--配置注册中心-->
    <dubbo:registry address="XXX.XXX.XXX.XXX:2181" protocol="zookeeper"></dubbo:registry>

    <!--name是从注册中心获取的地址(固定值)-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

    <!--提供注册功能-->
    <dubbo:service interface="com.cn.zy.DubboService" ref="dubboServiceImpl"></dubbo:service>
    <bean id="dubboServiceImpl" class="com.cn.DemoServiceImpl"></bean>
    </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>

瞅一眼提供者实现类:

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

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

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

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

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

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

    resource/META-INF/spring/

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

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

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

安装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文件

只看具体的配置:

   <!--给当前的customer 名字-->
    <dubbo:application name="dubbo-customer"></dubbo:application>

    <!--配置注册中心-->
    <dubbo:registry address="XXX.XXX.XXX.XXX:2181" protocol="zookeeper"></dubbo:registry>

    <!--消费者方注解-->
    <dubbo:annotation package="com.cn.coustomer.impl.DubboCustomerServiceImpl"/>

    <!--添加执行bean-->
    <bean id="testService" class="com.cn.coustomer.impl.DubboCustomerServiceImpl"/>

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

import com.alibaba.dubbo.config.annotation.Reference;

    public class DubboCustomerServiceImpl implements DubboCustomerService {

    @Reference
    private DubboService dubboService;

        @Override
        public String customer(String str) {
            //调用提供者的功能
            String s = dubboService.serviceDemo(str);
            return s+": 我在消费者实现类中调用了...";
        }
    }

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

    public interface DubboCustomerService {
        String customer(String str);
    }

写个测试类:

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

　

result:

##SpringBoot整合dubbo (方式二)

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

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

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

　　

导入SpringBoot整合依赖包

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.springboot-dubbo-parents</groupId>
            <artifactId>proivder-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- Spring Boot Dubbo 依赖 -->
        <dependency>
            <groupId>io.dubbo.springboot</groupId>
            <artifactId>spring-boot-starter-dubbo</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

　　

配置application.properties

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

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

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

然后注解添加版本号

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

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

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

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

##消费者方实现接口

依赖和提供方是一样的

application.perpeties配置

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

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

接口:

    /**
     * @author zhangyi
     * @date 2018/12/21 14:28
     */
    public interface CustomerService {

        String customer(String s);
    }

实现类

    /**
     * @author zhangyi
     * @date 2018/12/21 14:28
     */
    @Service
    public class CustomserServiceImpl implements CustomerService {

        @Reference(version = "1.0.0")
        private DubboService dubboService;

        @Override
        public String customer(String s) {
            String c = dubboService.service("消费端调用:::后传"+s);
            return c;
        }
    }

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

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

可以写个测试类验证下

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class CustomerServiceImplApplicationTests {

        @Autowired
        private CustomerService customerService;

        @Test
        public void contextLoads() {
            String test = customerService.customer("测试注入");
            System.out.println(test);
        }

    }

　

结果输出

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