dubbo在项目中的应用

最新推荐文章于 2024-04-26 20:37:10 发布

zhifeng687

最新推荐文章于 2024-04-26 20:37:10 发布

阅读量1w

点赞数

分类专栏： dubbo & spring cloud

dubbo & spring cloud 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

关于dubbo的使用，我们举个简单例子：

存在2个系统，A系统和B系统，A系统调用B系统的接口获取数据，用于查询用户列表。

在上一篇博文介绍了dubbo的创建，zookeeper的创建完成后，我们可以来使用dubbo和zookeeper了？

再回顾下dubbo的架构：

所以通过此图，我们看到就是服务的提供者将服务注册到注册中心，服务的消费者从注册中心获取服务，monitor监控服务的调用。

所谓框架无非就是配置文件+java代码，所以dubbo也同理：

（1）首先看下B服务的提供者的配置文件和代码：

搭建b系统：

建立一个maven的war工程，在pom.xml中导入依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.itcast.dubbo</groupId>
    <artifactId>dubbo-b</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>war</packaging>
 
    <dependencies>
        <!-- dubbo采用spring配置方式，所以需要导入spring容器依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
        
<dependency>

        <groupId>org.apache.zookeeper</groupId>

        <artifactId>zookeeper</artifactId>

        <version>3.3.3</version>

      </dependency>

 

      <dependency>

        <groupId>com.github.sgroschupf</groupId>

        <artifactId>zkclient</artifactId>

        <version>0.1</version>

      </dependency>

      <dependency>    
        <groupId>com.alibaba</groupId>    
        <artifactId>dubbo</artifactId>          
        <version>2.5.3</version>           
       <exclusions>                
           <exclusion>                   
          <!-- 排除传递spring依赖 -->                    
         <artifactId>spring</artifactId>                    
         <groupId>org.springframework</groupId>                
         </exclusion>           
        </exclusions>        
      </dependency>    
     </dependencies>       
     <build>        
       <plugins>            
          <plugin>                
               <groupId>org.apache.tomcat.maven</groupId>               
               <artifactId>tomcat7-maven-plugin</artifactId>               
               <version>2.2</version>                
               <configuration>                    
                   <port>8081</port>                    
                   <path>/</path>               
               </configuration>            
          </plugin>        
        </plugins>    
      </build>
   </project>

　　第二步：创建user对象：注意这里一定要实现序列化，并获取序列化的序号：

 
          //关于这个的获取，直接点击小黄色图标，既可以自动生成

package cn.itcast.dubbo.pojo;
 
// 使用dubbo要求传输的对象必须实现序列化接口
public class User implements java.io.Serializable {
 
    private static final long serialVersionUID = -2668999087589887337L;<br>//关于这个的获取，直接点击小黄色图标，既可以自动生成
 
    private Long id;
 
    private String username;
 
    private String password;
 
    private Integer age;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
}

创建服务接口和服务接口的实现类：

接口为了暴露服务的：

  //创建UserService（接口）提供查询服务
package cn.itcast.dubbo.service;
 
import java.util.List;
 
import cn.itcast.dubbo.pojo.User;
 
public interface UserService {
 
    /**
     * 查询所有的用户数据
     *
     * @return
     */
    public List<User> queryAll();
 
}

 创建UserServiceImpl实现类
package cn.itcast.dubbo.service.impl;
 
import java.util.ArrayList;
import java.util.List;
 
import cn.itcast.dubbo.pojo.User;
import cn.itcast.dubbo.service.UserService;
 
public class UserServiceImpl implements UserService {
 
    /**
     * 实现查询，这里做模拟实现，不做具体的数据库查询
     */
    public List<User> queryAll() {
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setAge(10 + i);
            user.setId(Long.valueOf(i + 1));
            user.setPassword("123456");
            user.setUsername("username_" + i);
            list.add(user);
        }
        return list;
    }
 
}

下面就是dubbo的服务提供者的配置文件了：

实际项目中，相当于服务的提供者的第一步：编写配置文件dubbo-provider.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    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-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo-b-server" />
 
    <!-- 这里使用的注册中心是zookeeper -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" client="zkclient"/>
 
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />
 
    <!-- 将该接口暴露到dubbo中 -->
    <dubbo:service interface="cn.itcast.dubbo.service.UserService" ref="userServiceImpl" />
 
    <!-- 将具体的实现类加入到Spring容器中 -->
    <bean id="userServiceImpl" class="cn.itcast.dubbo.service.impl.UserServiceImpl" /><br>//监控的配置<br>                    <dubbo:monitor protocol="registry"></dubbo:monitor>
 
  
</beans>

这里spring与dubbo进行了无缝整合，所以这里进行了spring与dubbo的整合：
第二步：读取配置文件
我们需要在web.xml中将配置文件引入：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
     
    <display-name>dubbo-b</display-name>
     
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:dubbo/dubbo-*.xml</param-value>
    </context-param>
     
    <!--Spring的ApplicationContext 载入 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
     
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
 
</web-app>

<param-value>classpath:dubbo/dubbo-*.xml</param-value> 这行代码引入dubbo配置文件

第三步：配置服务消费者：
这里我们建立a的系统：
建立一个maven的jar工程：
导入依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.itcast.dubbo</groupId>
    <artifactId>dubbo-a</artifactId>
    <version>0.0.1-SNAPSHOT</version>
 
    <dependencies>
        <!-- dubbo采用spring配置方式，所以需要导入spring容器依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
 
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
            <exclusions>
                <exclusion>
                    <!-- 排除传递spring依赖 -->
                    <artifactId>spring</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
 
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.3.3</version>
        </dependency>
 
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>
</project>

　从b系统拷贝：

1.1.1. 从b系统中拷贝User对象、UserService接口到a系统

服务的消费者配置：

dubbo-consumer.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    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-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo-a-consumer" />
 
    <!-- 这里使用的注册中心是zookeeper -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" client="zkclient"/>
     
    <!-- 从注册中心中查找服务 -->
    <dubbo:reference id="userService" interface="cn.itcast.dubbo.service.UserService"/>
  
</beans>

编写测试：代码

package cn.itcast.dubbo.service;
 
import static org.junit.Assert.*;
 
import java.util.List;
 
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import cn.itcast.dubbo.pojo.User;
 
public class UserServiceTest {
 
    private UserService userService;//从这里我们可以看出，使用了dubbo后感觉调用服务是在自己的工程一样，但是其实我们是调用的b系统，因为b将服务接口暴露出来了，我们通过访问注册中心的服务接口来获取服务的实现。
 
    @Before
    public void setUp() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "classpath:dubbo/*.xml");
        this.userService = applicationContext.getBean(UserService.class);
    }
 
    @Test
    public void testQueryAll() {
        List<User> users = this.userService.queryAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
 
}

这个是dubbo的简单入门程序，具体在项目中也是同样的道理。
不过上面代码有重复，我们可以加上一个公共的maven来存放pojo和服务接口，然后ab工程添加依赖即可。
在我们的项目中，一般步骤如下；
（1）导入dubbo、zookeeper依赖
（2）在服务提供者端，编写服务接口，服务接口的实现类，编写配置文件
（3）修改web.xml读取配置文件
（4）在服务消费者，即客户端，调用服务接口，调用服务实现类，编写配置文件
这样系统间就可以互相通信，从而感觉像在本地使用一样。
使用dubbo不像httpclient一样json的转换，因为dubbo都自动进行了。

如果要模拟分布式，可以用以下方法：

模拟分布式，我们新建两个tomcat容器，一个是生产者、一个是消费者

这里写图片描述

先启动生产者，不然会报错，因为消费者需要有生产者提供服务。当然也有解决方案：

1、关闭某个服务的启动时检查：(没有提供者时报错)
<dubbo:reference interface="com.foo.BarService" check="false" />
2、关闭所有服务的启动时检查：(没有提供者时报错)  写在定义服务消费者一方
<dubbo:consumer check="false" />
3、关闭注册中心启动时检查：(注册订阅失败时报错)
<dubbo:registry check="false" />

参考：Dubbo项目配置怎么模拟分布式参考这篇文章，而且这篇文章就实现了上面所说的，

将接口层分离出去，独自成为一个工程，再被consumer工程和provider工程依赖

dubbo在项目中的应用

以上都是通过xml的方式配置dubbo provider服务和dubbo provider引用，主要使用<dubbo:service>和<dubbo:reference>

下面讲解通过注解的方式配置dubbo provider服务和dubbo provider引用，使用注解@Service和@Reference

注意，这里注解（包括@Service）使用的是dubbo扫描注解的功能，而非spring扫描注解的功能

在xml中配置dubbo扫描注解： <dubbo:annotation package="com.dubbo.provide" />

而非spring的扫描注解：<context:component-scan base-package="com.dubbo.provide"/>

通过Dubbo注解实现RPC调用

通过注解方式配置的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:dubbo="http://code.alibabatech.com/schema/dubbo"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        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-4.3.xsd">
       

   
    <!-- 提供方应用信息，用于计算依赖关系 -->  
    <dubbo:application name="dubbo_provider" />  
  
    <!-- 使用multicast广播注册中心暴露服务地址 <dubbo:registry address="multicast://224.5.6.7:1234"   
        /> -->  
  
    <!-- 使用zookeeper注册中心暴露服务地址 -->  
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />  
  
    <!-- 用dubbo协议在20880端口暴露服务 -->  
    <dubbo:protocol name="dubbo" port="20880" />  
  
    <!-- 具体的实现bean  
    <bean id="demoService" class="com.unj.dubbotest.provider.impl.DemoServiceImpl" />  
    -->  
    <!-- 声明需要暴露的服务接口   
    <dubbo:service interface="com.unj.dubbotest.provider.DemoService" ref="demoService" />  
    -->  
      
    <!-- 使用注解方式暴露接口 -->     
    <dubbo:annotation package="com.dubbo.provide" />  
      
    <!-- 加入spring注解扫描 -->  
    <!-- <context:component-scan base-package="com.dubbo.provide"/>   -->
</beans>

上面是通过 dubbo:annotation package 扫描com.dubbo.provide下的所有包,类似于spring 的 context:component-scan base-package，它会把dubbo相关注解进行扫描，这样我们就不需要在xml里面针对每个服务接口配置dubbo:service interface。

通过注解方式的服务实现类如下

package com.dubbo.provide;

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

@Service
public class DubboPro implements DubboProInterface {

    public void print() {

        System.out.println("is ok");
        
    }

}

需要注意的是Service注解是dubbo的注解，而不是spring的,它位于dubbo.jar的annotaion目录下：

消费端注解方式调用类如下：

 
package com.dubbo.consumer;

import org.springframework.stereotype.Component;

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

@Component
public class DubboConsumer{

    @Reference 
    DubboProInterface dubboProInterface;
    
    public void print(){
        System.out.println(dubboProInterface);
        dubboProInterface.print();
    }
}

通过@Reference注解,dubbo会在扫描的时候会自动帮我们代理接口（见下图）,然后通过rpc调用远程服务

参考资料：http://dubbo.io/User+Guide-zh.htm#UserGuide-zh-%E6%B3%A8%E8%A7%A3%E9%85%8D%E7%BD%AE

zhifeng687

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
dubbo在项目中的应用

关于dubbo的使用，我们举个简单例子：存在2个系统，A系统和B系统，A系统调用B系统的接口获取数据，用于查询用户列表。在上一篇博文介绍了dubbo的创建，zookeeper的创建完成后，我们可以来使用dubbo和zookeeper了？再回顾下dubbo的架构：所以通过此图，我们看到就是服务的提供者将服务注册到注册中心，服务的消费者从注册中心获取服务，monitor监控服务的调用。所谓框架无非就是...
复制链接

扫一扫