Dubbo快速入门开发

最新推荐文章于 2023-01-16 06:00:00 发布

月哥说了算

最新推荐文章于 2023-01-16 06:00:00 发布

阅读量72

点赞数

本文链接：https://blog.csdn.net/weixin_45362084/article/details/112171630

版权

Dubbo作为一个RPC框架，其最核心的功能就是要实现跨网络的远程调用，服务提供者、服务消费者会使用共同的接口，本事例先创建一个父工程，父工程下有3个子模块，一个是接口模块，一个是服务提供者模块，一个是服务消费者模块。通过Dubbo来实现服务消费方远程调用服务提供方的方法。

实现步骤：

1. 创建父工程，基于maven,不选择任何骨架，工程名：study-dubbo
    2. 创建接口模块，在父工程的基础上，不选择任何骨架，模块名：dubbo-interface
    3. 创建服务提供者模块，在父工程的基础上，使用webapp骨架，模块名：dubbo-provider
    4. 创建消费者模块，在父工程的基础上，使用webapp骨架，模块名：dubbo-consumer

1. 创建父工程

父工程，不实现任何代码，主要是添加工程需要的库的依赖管理(DependencyManagement)，依赖管理就是解决项目中多个模块间公共依赖的版本号、scope的控制范围。本项目需要使用spring-webmvc，使用dubbo(务必2.6.2以上版本)、zookeeper及其客户端(curator-framework)依赖库。

不选择任何骨架
GroupID:com.gzy
ArtifactId:study_dubbo
project name:dubbo

工程创建完成后：
1、父工程不实现任何代码，删除 src 目录。
2、修改pom.xml，抽取版本、增加赖库依赖管理，全部内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<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>com.gzy</groupId>
    <artifactId>study-dubbo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <spring.version>5.0.5.RELEASE</spring.version>
        <dubbo.version>2.6.2</dubbo.version>
        <zookeeper.version>3.4.13</zookeeper.version>
        <curator-framework.version>4.0.1</curator-framework.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!--spring webmvc-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!--dubbo-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
            <!--zookeeper-->
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
                <version>${zookeeper.version}</version>
            </dependency>
            <!--zookeeper client-->
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-framework</artifactId>
                <version>${curator-framework.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

注意：依赖管理，仅仅配置依赖关系，不会导入具体的库依赖包，只有子模块具体需要时，才会导入jar包。

2. 创建接口模块

此模块，主要放业务接口的定义，它是服务消费者模块和服务提供者模块的公共依赖模块。

在当前父工程的基础上创建子模块
不选择任何骨架
GroupID:com.gzy
ArtifactId:dubbo-interface
moudule name:dubbo-interface

创建子模块。
2.修改pom.xml，增加打包方式。

<packaging>jar</packaging>

创建包com.gzy.service
增加业务接口。

3. 服务提供者模块

此模块是服务提供者模块，需要在容器启动时，把服务注册到zookeeper,故需要引入spring-webmvc,zookeeper及客户端依赖。

实现步骤：

创建子模块dubbo-provider，使用webapp骨架，导入依赖坐标spring-webmvc、zookeeper及客户端和编译插件tomcat7
创建java源代码目录，并增加com.gzy.service.impl包及创建UserServiceImpl实现类
业务实现类UserServiceImpl，需要实现UserService接口
创建resources资源目录，并创建spring-dubbo-provider.xml 配置文件：
- 配置dubbo的应用名称
- 配置dubbo注册中心Zookeeper地址
- 配置dubbo协议名称和服务端口
- 配置dubbo注解包扫描
- 配置spring自动扫描
- 配置需要暴露的业务接口及实例
将资料的log4j.properties配置文件拷贝到resources目录下
在web.xml文件中，配置spring监听器，指定spring配置文件加载位置
启动服务提供者

实现过程：

创建子模块dubbo-provider

在当前父工程的基础上创建子模块。
选择webapp骨架。

2.修改pom.xml文件，增加依赖库，删除build标签中的pluginManagement,新增编译插件tomcat7，端口6001。

<?xml version="1.0" encoding="UTF-8"?>

<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">
    <parent>
        <artifactId>study-dubbo</artifactId>
        <groupId>com.itheima.study.dubbo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-provider</artifactId>
    <packaging>war</packaging>
    <name>dubbo-provider</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.itheima.study.dubbo</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>dubbo-provider</finalName>

        <plugins>
            <plugin>
                <artifactId>tomcat7-maven-plugin</artifactId>
               <groupId>org.apache.tomcat.maven</groupId>
                <configuration>
                    <path>/</path>
                    <port>6001</port>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

配置web.xml

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-dubbo-provider.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

初始化java资源目录
在main下,创建子目录java(刷新maven工程),增加com.itheima.study.dubbo.service.impl包及创建UserServiceImpl实现类。

4.初始化resources目录
在main下,创建子目录resources目录，在resources目录下创建spring-dubbo-provider.xml 配置文件和log4j的配置文件。

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!-- dubbo基本配置-->
    <dubbo:application name="dubbo_provider"/>
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <dubbo:protocol name="dubbo"  port="8888"/>


    <!--spring自动扫包，使用注解时使用-->
    <context:component-scan base-package="com.gzy.service"/>
    <!-- dubbo自动扫包，注解远程Service时使用-->
    <dubbo:annotation package="com.gzy.service"/>
    <!--使用注解式开发用上面包扫描 代替下面的代码-->

    <!--构建bean对象
    <bean id="userService" class="com.gzy.service.impl.UserServiceImpl"/>
    把业务对象注册到zookeeper
    <dubbo:service interface="com.gzy.service.UserService" ref="userService"/>
    -->
</beans>

5.用注解注册bean

package com.gzy.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.gzy.service.UserService;

/**
 * @author ：gzy
 * @date ：Created in 2019/7/13
 * @description ：
 * @version: 1.0
 */
@Service
//切记要用import com.alibaba.dubbo.config.annotation.Service;下的@Service
public class UserServiceImpl implements UserService {
    @Override
    public boolean login(String uname, String password) {
        System.out.println("UserService实现类"+uname+password);
        if("admin".equals(uname)&&"123".equals(password)){
            return true;
        }
        return false;
    }
}

启动服务提供者
需要在父工程整体clean、install后，在子模块使用tomcat7插件运行

(1)、父工程clean、install

1562731771609.png

(2)、启动当前应用，启动后默认注册服务到zookeeper注册中心

1562731913108.png

(3)、检查是否注册到zookeeper

登录zookeeper客户端，直接查看ls /dubbo/com.gzy.service.UserService节点

如果 /dubbo下面没有这个节点，说明没有注册上，
如果有，内容是空，说明已经掉线
正常注册并连接在线.

注意：

消费者与提供者应用名称不能相同
如果有多个服务提供者，名称不能相同，通信端口也不能相同
只有服务提供者才会配置服务发布的协议

4.服务消费者模块

此模块是服务消费者模块，此模块基于是Web应用，需要引入spring-webmvc，需要在容器启动时，去zookeeper注册中心订阅服务,需要引入zookeeper及客户端依赖。

实现步骤：

创建子模块dubbo-consumer，使用webapp骨架，导入依赖坐标spring-webmvc、zookeeper及客户端和编译插件tomcat7
创建java源代码目录，并增加com.itheima.study.dubbo.controller包及创建UserController类
控制器类UserController，提供web方法login
创建resources资源目录，并创建spring-dubbo-consumer.xml 配置文件：
- 配置dubbo的应用名称
- 配置dubbo注册中心Zookeeper地址
- 配置dubbo协议名称和服务端口
- 配置dubbo注解包扫描
- 配置spring自动扫描
- 配置需要订阅的业务接口及引用
将资料的log4j.properties配置文件拷贝到resources目录下
在web.xml文件中，配置SpringMVC
启动服务消费者，并测试访问

修改pom.xml文件，增加依赖库，删除build标签中的pluginManagement,新增编译插件tomcat7,端口6002

<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
-->
<!-- $Id: pom.xml 642118 2008-03-28 08:04:16Z reinhard $ -->
<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/maven-v4_0_0.xsd">
    <parent>
        <artifactId>study_dubbo</artifactId>
        <groupId>com.gzy</groupId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../study_dubbo/pom.xml</relativePath>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>

    <name>dubbo_consumer</name>
    <groupId>com.gzy</groupId>
    <artifactId>dubbo_consumer</artifactId>

    <build>
        <plugins>
            <plugin>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <groupId>org.apache.tomcat.maven</groupId>
                <configuration>
                    <path>/</path>
                    <port>6002</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>com.gzy</groupId>
            <artifactId>dubbo_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
        </dependency>

    </dependencies>

</project>

初始化java资源目录

在main下,创建子目录java(刷新maven工程),增加com.gzy.controller包及创建UserController控制类(通过配置文件初始化)，该类调用远程业务UserService实现登录。

初始化resources资源目录

在main下,创建子目录resources目录，在resources目录下创建spring-dubbo-consumer.xml 配置文件和log4j的配置文件。

配置dubbo的应用名称
配置dubbo注册中心Zookeeper地址
配置dubbo注解包扫描，后续注解远程Service时使用
配置spring自动扫包，后续注解控制器相关内容使用
配置需要暴露的业务接口及实例

最终spring-dubbo-provider.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"
       xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <dubbo:application name="dubbo_consumer"/>
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>

    <!--spring自动扫包，使用注解时使用-->
    <context:component-scan base-package="com.gzy.controller"/>
    <!-- dubbo自动扫包，注解远程Service时使用-->
    <dubbo:annotation package="com.gzy.controller"/>
    <!--
    远程调用对象
    <dubbo:reference interface="com.gzy.service.UserService" id="userRefService"/>-->
    <!--初始化控制器，并把远程service 注入到controller
    <bean id="UserController" class="com.gzy.controller.UserController">-->
        <!--<property name="userService" ref="userRefService"/>-->
    <!--</bean>-->
</beans>

配置web.xml

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

注解实现订阅

package com.gzy.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.gzy.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author ：gzy
 * @date ：Created in 2019/7/13
 * @description ：
 * @version: 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {
    //一定是import com.alibaba.dubbo.config.annotation.Reference;下的@Reference
    @Reference
    private UserService userService;

//    public void setUserService(UserService userService) {
//        this.userService = userService;
//    }
    @ResponseBody
    @RequestMapping("login")
    public String test(String uname,String password){
      if(userService.login(uname,password)){
return "success";
}
return "fail";
    }
}

月哥说了算

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Dubbo快速入门开发

Dubbo作为一个RPC框架，其最核心的功能就是要实现跨网络的远程调用，服务提供者、服务消费者会使用共同的接口，本事例先创建一个父工程，父工程下有3个子模块，一个是接口模块，一个是服务提供者模块，一个是服务消费者模块。通过Dubbo来实现服务消费方远程调用服务提供方的方法。实现步骤：1. 创建父工程，基于maven,不选择任何骨架，工程名：study-dubbo 2. 创建接口模块，在...
复制链接

扫一扫