当前位置: 澳门新濠3559 > 编程 > 正文

先看一下示例项目框架,服务发现与注册和运维

时间:2019-10-06 23:51来源:编程
写在前面: 使用springboot作为web框架,方便开发许多,做分布式开发,dubbo又不可少,那么怎么整合在一起呢,跟我学一遍,至少会用 注意,springboot2.0和springboot1.x与dubbo整合不一样,

写在前面:使用springboot作为web框架,方便开发许多,做分布式开发,dubbo又不可少,那么怎么整合在一起呢,跟我学一遍,至少会用注意,springboot2.0和springboot1.x与dubbo整合不一样,

澳门新濠3559 1

Apache Dubbo 是一款高性能Java RPC框架

最近项目使用了dubbo进行服务治理,搭建了一套基于注解方式的dubbo spring mvc的框架,注册中心使用zookeeper。
关于dubbo的介绍就不多说了,网上有很多可以自行搜索,直接上代码。

1.新建一个空的maven项目,作为父工程,新建moudle,,service(接口层,及实现层,没有具体分,),web(web层,springboot项目)

dubbo是什么:
dubbo是一个阿里巴巴开发的开源分布式服务框架,致力于提供高性能和透明化的RPC远程服务调用方案,是阿里巴巴集团的各成员站点的核心框架,每天为2,000 个服务提供3,000,000,000 次访问量支持。dubbo是对一个系统中应用层上的优化,后面我会在对系统中数据库层面的优化进行分享,这里我们只针对dubbo进行学习

dubbo能解决什么问题:
当网站变大后,不可避免的需要拆分应用进行服务化,以提高系统性能,开发效率等。并且要求拆分出去的每个服务可以根据需要灵活的配置它的集群数量和控制服务的粒度(服务的粒度就是说我运行的服务系统中对外发布的服务数量)

dubbo的优点:
1、使用简单
2、部署轻盈
3、方便二次开发
当当网:dubboX
京东:jd-hydra
这些都是基于dubbo二次开发的框架

由阿里巴巴开源并进入Apache孵化器,官网

项目使用的maven,采用多模块方式。先看一下示例项目框架。

项目结构如下

在学习dubbo之前我们先来了解一下分布式应用

澳门新濠3559 2

分布式应用.png

分布式应用:应用程序分布在不同计算机上,通过网络来共同完成一项任务。通常为服务端/客户端模式。
服务器/客户端又分为二端(server/client)、三端(server/middleware/client)、N端(multiple server/multiple minddle/multiple client)。也就是说分布式应用需要把服务(service)拆分出来,单独部署在一个web服务器中,controller调用service就通过网络来调用,这就形成了客户端和服务端的模式,客户端只负责运行controller代码,处理数据请求和响应;服务端只负责业务处理,数据运算等。又因为原本一个系统既需要处理用户的请求和响应,又需要处理业务流程,运行压力会比较大,从而影响整个系统的性能。现在把系统一分为二了,这就大大的提高整个系统的性能了

澳门新濠3559 3

三端分布式应用.png

澳门新濠3559 4

N端分布式应用.png

上面说到了分布式的应用分成客户端和服务端,它们各自运行在自己的服务器中,客户端的controller调用服务端的service就不是在一个应用内调用了,而是通过网络传输来调用。
这种通过网络来使controller调用远程的service的技术叫做RPC技术

澳门新濠3559 5

RPC原理.png

RPC技术是什么:
RPC(Remote Procedure Call Protocol)——远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务
RPC的原理:
就是对象的序列化、反序列化以及序列化后数据的传输,dubbo(使用二进制文件,TCP)
java领域常见的RPC框架:
Java领域里的分布式技术或者说分布式框架叫做RPC框架有:Dubbo,ZeroICE

使用分布式的模式的优点?
1.在开发上,分成了多个系统,有利于开发任务的分配,各自负责各自的系统开发。
2.在运行上,把负载压力分配到多台服务器上,提高整个系统的运行性能。
3.由于分布式开发模式是把业务或者功能以服务的形式对外发布,这样的话可以提高服务重用率

用了dubbo的优点?
拆分应用进行服务化,提高系统性能,开发效率,并且可以灵活配置服务集群数和控制服务

注册中心的作用:
1、服务端服务的注册和客户端服务的调用
2、提高系统的可用性
3、提高系统的可伸缩性
4、集中管理服务

注册中心有什么:
zookeeper:
zooKeeper是一个分布式的,开放源码的分布式应用程序协调服务,是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件,提供的功能包括:配置维护、域名服务、分布式同步、组服务等。

zookeeper的使用
虽然能提供给dubbo应用做注册中心的技术有很多,但是我们用的是zookeeper,因为它是dubbo官方推荐的技术,在springboot-dubbo中,也是默认整合了zookeeper。而且zookeeper它是Hadoop和HBase的重要组件,如果后期项目需要发展大数据业务,那么就可以无缝的接入大数据的技术。所以我们使用zookeeper作为基于dubbo框架的分布式系统的注册中心。

1,下载zookeeper运行程序
进入zookeeper官网:https://zookeeper.apache.org/下载
2,修改配置文件
zoo_sample.cfg修改成zoo.cfg(可以copy一份再修改)
# 内存数据的备份地址
dataDir=F://zookeeper-3.4.5//data

提供服务化基础功能:接口远程调用,智能负载均衡,服务发现与注册和运维治理界面等功能

澳门新濠3559 6

澳门新濠3559 7image.png

存放日志地址

 dataLogDir=F://zookeeper-3.4.5//log

3,双击bin目录下的zkServer.cmd,运行zookeeper(如果是Mac路径就不说了,启动需要到bin目录下在终端使用命令 sh zkServer.sh start)

集成SpringBoot中文说明地址

image.png

父pom如下

先使用xml方式来写一个hello world程序

这里我使用的工具是idea
先创建一个父项目(dubbo_parent),然后再创建三个模块

澳门新濠3559 8

我们重新看下项目中的结构,做出如下修改

其中dubbo-config模块管理所有项目所需的配置文件,在打包时打入对应的服务内。

<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencyManagement> <dependencies> <dependency> <!-- Import dependency management from Spring Boot --> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.0.3.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> <!--如果要把springboot工程打包成war执行,需要该jar--> <!--<dependency>--> <!--<groupId>org.springframework.boot</groupId>--> <!--<artifactId>spring-boot-legacy</artifactId>--> <!--<version>1.0.2.RELEASE</version>--> <!--</dependency>--> <dependency> <groupId>com.alibaba.boot</groupId> <artifactId>dubbo-spring-boot-starter</artifactId> <version>0.2.0</version> </dependency> <!--引入zookeeper的客户端工具--> <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient --> <dependency> <groupId>com.github.sgroschupf</groupId> <artifactId>zkclient</artifactId> <version>0.1</version> </dependency> </dependencies> </dependencyManagement>
1,创建三个项目

一个用于服务端,一个用于客户端,一个用于接口
服务端:server
客户端:client
接口:api
然后我们来修改pom.xml配置,这了api项目只是提供接口不需要继承dubbo_parent的依赖所以在api的pom.xml里取消继承的配置.
同时我们在server和client需要api的接口,所以我们需要在server,client两个项目中导入api的依赖

<dependencies>
  <dependency>
     <groupId>com.jd.dubbo</groupId>
     <artifactId>api</artifactId>
  </dependency>
</dependencies>

澳门新濠3559 9

项目关系.png

...somefun

一、项目包依赖 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.sanjinbest.dubbo</groupId>
    <artifactId>sanjinbest.dubbo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
        <module>dubbo-web</module>
        <module>dubbo-config</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <servlet.version>3.0.1</servlet.version>
        <springframework.version>4.3.7.RELEASE</springframework.version>
        <junit.version>4.12</junit.version>
        <zookeeper.version>0.2</zookeeper.version>
        <dubbo.version>2.5.4</dubbo.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- Dubbo相关 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <version>${dubbo.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!-- ZK-client -->
            <dependency>
                <groupId>com.101tec</groupId>
                <artifactId>zkclient</artifactId>
                <version>${zookeeper.version}</version>
            </dependency>

            <!-- servlet -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>

            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-core</artifactId>
                <version>1.3</version>
            </dependency>

            <!-- spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${springframework.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.mobile</groupId>
                <artifactId>spring-mobile-device</artifactId>
                <version>${spring.mobile.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${springframework.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project

web层pom

2、添加springboot相关依赖和导入dubbo相关依赖(在dubbo_parent父项目的pom.xml中添加)

springboot父项目:spring-boot-starter-parent
springbootweb相关项目spring-boot-starter-web

  <!--Spring Boot项目-->
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.1.RELEASE</version>
</parent>
<dependencies>
<!--spring-boot-web依赖-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
<!-- dubbo相关依赖 -->
 <dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>dubbo</artifactId>
  <version>2.5.3</version>
<exclusions>
  <exclusion>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
  </exclusion>
</exclusions>
  </dependency>
 <!--zookeeper-->
 <dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.2</version>
 </dependency>
 <dependency>
   <groupId>org.apache.zookeeper</groupId>
   <artifactId>zookeeper</artifactId>
   <version>3.4.5</version>
 </dependency>
 </dependencies>

......somefun-web (springboot项目 dubbo客户端)

二、dubbo服务端

 <dependencies> <dependency> <groupId>com.itzmn</groupId> <artifactId>dubbo-service</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba.boot</groupId> <artifactId>dubbo-spring-boot-starter</artifactId> </dependency> <!--引入zookeeper的客户端工具--> <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient --> <dependency> <groupId>com.github.sgroschupf</groupId> <artifactId>zkclient</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>
3、编写接口程序

澳门新濠3559 10

3.1 首先我们在domain包里创建一个HelloWorld的实体类,定义一个属性 name,提供setter,getter方法实现Serializable接口
3.2 其次我们在service包里创建一个接口定义一个抽象方法

澳门新濠3559 11

......somefun-service-system

1、服务端配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息,用于计算依赖关系 -->
    <dubbo:application name="user-provider"/>

    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry protocol="zookeeper" address="${dubbo.user.registry.server}" />

    <!-- 使用dubbo协议,所以请求响应都使用线程池管理 -->
    <dubbo:protocol name="dubbo" dispatcher="all" port="${dubbo.user.protocol.port}"/>

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:annotation/>

    <!-- 延迟加载,等待spring初始化完成后暴露服务 -->
    <dubbo:provider delay="-1" timeout="${dubbo.user.timeout}" retries="${dubbo.user.retries}" />

</beans>

这里使用的注册中心是zookeeper。

service层

4、编写服务端程序(接口实现类)和创建启动类

澳门新濠3559 12

创建服务端的启动类

@SpringBootApplication
@ImportResource("classpath:dubbo-server.xml")
public class StartApp {
    public static void main(String[] args) {
        SpringApplication.run(StartApp.class,args);
    }
}

5、编写服务端xml配置(dubbo-service.xml)

  <!--把具体的服务实现类交给spring容器管理-->
    <bean id="helloWorld" class="com.jd.dubbo.service.impl.HelloWorldServiceImpl"/>
    <!--设置应用名-->
    <dubbo:application name="dubbo-server"/>
    <!--设置RPC协议-->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!--设置注册中心地址zookeeper,register属性,默认是true,如果为true的化,就需要把发布的服务的服务地址注册到zookeeper
        如果为false,就不需要把服务的地址注册到zookeeper中
    -->
    <!--<dubbo:registry address="zookeeper://127.0.0.1:2181" register="false"/>-->

    <dubbo:registry address="zookeeper://127.0.0.1:2181" register="true" file="${user.home}/dubbo.cache"/>
    <!--发布服务-->
    <dubbo:service interface="com.jd.dubbo.service.IHelloWorldService" ref="helloWorld"/>

澳门新濠3559 13

6、编写客户端xml配置

  <!--设置应用名-->
    <dubbo:application name="dubbo-client"/>
    <!--设置注册中心地址zookeeper-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <!--引用服务-->
    <dubbo:reference interface="com.jd.dubbo.service.IHelloWorldService" id="helloWorldService"/>

澳门新濠3559 14

7、编写客户端程序(启动类)

@SpringBootApplication
@ImportResource("classpath:dubbo-client.xml")
@Controller
public class StartApp {

    @Autowired
    private IHelloWorldService helloWorldService;
    public static  void main (String[] args){
        SpringApplication.run(StartApp.class,args);
    }

    @RequestMapping("/sayHello")
    @ResponseBody
    public String sayHello(){
        HelloWorld helloWorld =helloWorldService.sayHello(new HelloWorld());
            return  helloWorld.getName();
        }
    }

澳门新濠3559 15

到这里我们通过xml的配置方式已经完成了,我们先启动服务端server再启动客服端client

澳门新濠3559 16

.........somefun-system-api (对外提供模块,提供接口和DTO)

2、服务端applicationContext.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"
       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">

    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="ignoreUnresolvablePlaceholders" value="true"/>
        <property name="locations">
            <list>
                <value>classpath*:dubbo.properties</value>
            </list>
        </property>
    </bean>
    <!-- dubbo 服务 -->
    <import resource="classpath*:dubbo/user-provider.xml"/>
    <!-- 开启注解 -->
    <context:annotation-config/>
    <!-- 自动扫描 -->
    <context:component-scan base-package="com.sanjinbest.dubbo.user" />

</beans>
 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba.boot</groupId> <artifactId>dubbo-spring-boot-starter</artifactId> </dependency> <!--引入zookeeper的客户端工具--> <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient --> <dependency> <groupId>com.github.sgroschupf</groupId> <artifactId>zkclient</artifactId> </dependency> </dependencies>

搭建电商架构(基于springboot全注解的方式构建)

基于springboot全注解的方式构建的好处
1、Springboot给我们提供了一整套开发包,导入一个依赖就能使用它给我们提供的对应的功能,提高我们的开发效率
2、减少了我们应用自己导入依赖包的数量
3、省去了繁琐的xml配置文件
4、内嵌web服务器:如tomcat,jetty,部署应用变得方便
5、用springboot整合dubbo可以很方便的开发分布式的微服务

.........somefun-system-service (springboot项目 dubbo服务提供端)

3、服务接口类

package com.sanjinbest.dubbo.user.api;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/11/3
 */
public interface IUserInfoService {

    String getName();

    int getAge();
}

这里提供了一个返回name 和 age的方法。当发布服务给第三方的时候,只需要将该接口打成jar包发布即可。

澳门新濠3559 17image.png

开发步骤:

一、创建各个工程项目

shop_parent
shop_api_goods(商品系统的api)
shop_api_order(订单系统的api)
shop_server_goods(商品系统)
shop_server_order(订单系统)
shop_client_mgrsite(后台管理系统)
shop_clinet_website(移动端接口)

澳门新濠3559 18

先创建一个父项目然后再创建其他模块,在shop_parent的pom.xml添加以下依赖

<!--Spring Boot项目-->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.5.1.RELEASE</version>
</parent>
<dependencies>
<!--spring-boot-web依赖-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
<!-- Spring Boot Dubbo 依赖 -->
<dependency>
    <groupId>io.dubbo.springboot</groupId>
    <artifactId>spring-boot-starter-dubbo</artifactId>
    <version>1.0.0</version>
  <!--剔除Dubbo内的netty,因为zookeeper中有一个-->
  <exclusions>
    <exclusion>
      <artifactId>netty</artifactId>
      <groupId>org.jboss.netty</groupId>
      </exclusion>
      </exclusions>
      </dependency>
</dependencies>
<!--管理商品之间的依赖-->
<dependencyManagement>
    <dependencies>
       <dependency>
       <groupId>com.jd.shop</groupId>
        <artifactId>shop_api_goods</artifactId>
       <version>1.0</version>
      </dependency>
      <dependency>
     <groupId>com.jd.shop</groupId>
    <artifactId>shop_api_order</artifactId>
    <version>1.0</version>
   </dependency>
 <!--阿里巴巴的druid-->
 <dependency>
   <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.0.25</version>
  </dependency>
 <!--spring-boot的mybatis依赖-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>1.2.0</version>
  </dependency>
 <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.16.18</version>
  </dependency>
</dependencies>
</dependencyManagement>
<build>
 <plugins>
     <!--用于打包和启动springBoot应用的插件-->
     <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
     </plugin>
</plugins>
</build>

二、添加项目相关依赖
1、添加springboot项目
2、添加我们需要用到的服务系统api包
3、添加springboot-web依赖
4、添加连接数据库的相关依赖
5、添加dubbo依赖
澳门新濠3559,6、创建springboot应用的启动类

1我们将web模块开发成dubbo服务消费端部分

4、接口实现类

package com.sanjinbest.dubbo.user.provider;

import com.sanjinbest.dubbo.user.api.IUserInfoService;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/11/3
 */

@com.alibaba.dubbo.config.annotation.Service
@org.springframework.stereotype.Service
public class UserInfoServiceProvider implements IUserInfoService{

    @Override
    public String getName() {
        return "sanjinbest";
    }

    @Override
    public int getAge() {
        return 29;
    }
}

这里有一个需要注意的地方,该实现类内使用了2个service注解:
@com.alibaba.dubbo.config.annotation.Service dubbo服务对外暴露服务
@org.springframework.stereotype.Service spring容器注入

在service模块新建接口,

修改pom.xml

1.在shop_api_goods(商品系统的api)shop_server_goods(商品系统)这两个模块中不需要继承shop_parent所以在他们的pom.xml中需要修改一下.
2.分别在在shop_server_goods(商品系统和shop_server_order(订单系统)中添加依赖,

 <!--shop_server_goods-->
<dependency>
   <groupId>com.jd.shop</groupId>
   <artifactId>shop_api_goods</artifactId>
 </dependency>

 <!--shop_server_order-->
<dependency>
   <groupId>com.jd.shop</groupId>
   <artifactId>shop_api_order</artifactId>
 </dependency>

<!--shop_server_order-->
 <!--shop_server_order-->
<dependencies>
  <!--mysql驱动-->
  <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
 </dependency>
    <!--阿里巴巴的druid-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
   </dependency>
 <!--spring-boot的mybatis依赖-->
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
  </dependency>
   <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
  </dependency>
</dependencies>
 <build>
   <plugins>
      <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.2</version>
        <configuration>
        <verbose>true</verbose>
        <overwrite>false</overwrite>
        </configuration>
 <dependencies>
   <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.21</version>
     </dependency>
  </dependencies>
  </plugin>
</plugins>
</build>

创建两个服务端启动类 StartApp
shop_server_goods和shop_server_order的启动类

@SpringBootApplication
@EnableTransactionManagement
@MapperScan("com.jd.server.goods.mapper")
public class StartApp {
    public static void main(String[] args) {
        SpringApplication.run(StartApp.class,args);
    }
}

三、各个服务系统整合mybatis
1、在application.properties配置文件中添加如下配置信息:(两个服务需要做部分修改,需要修改的地方下面在()里标注了)

server.port=9090(server.port=9091)
#数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/jd_shop
#MySQL驱动
spring.datasource.driverClassName=com.mysql.jdbc.Driver
#数据库账号
spring.datasource.username=root
#数据库密码
spring.datasource.password=123456
#阿里巴巴Druid连接池
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource 
#mybatis的mapper.xml配置文件路径
mybatis.mapperLocations=classpath:mapper/*.xml
#mybatis的mapper.xml配置文件domain对象别名扫描路径
mybatis.typeAliasesPackage=com.jd.api.goods.domain    
(mybatis.typeAliasesPackage=com.jd.api.order.domain   )

2、在启动类添加如下注解:(上面的启动类代码已经添加了)

//扫描mybatis接口的注解
@MapperScan("com.jd.server.goods.mapper")
//开启事务管理
@EnableTransactionManagement

2将web模块中的pom去掉 somefun-system-service 依赖(somefun-system-api 依赖不去掉,通过此模块实现远程调用 而不侵入代码)

5、dubbo本地测试启动

package mock;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/9/18
 */
public class UserProviderMock {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"classpath*:spring/applicationContext.xml"});

        System.out.println("user provider start...");
        context.start();
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

如果是线上使用,可以使用运行jar包的方式运行,下面是打jar包的配置:

<!-- 打包 -->
    <build>
        <!-- 与服务模块名称一致 -->
        <finalName>user-provider</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.0.2</version>
                <configuration>
                    <classesDirectory>${project.build.directory}/classes/</classesDirectory>
                    <archive>
                        <manifest>
                            <mainClass>com.alibaba.dubbo.container.Main</mainClass>
                            <!-- 打包时 MANIFEST.MF文件不记录的时间戳版本 -->
                            <useUniqueVersions>false</useUniqueVersions>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                        <manifestEntries>
                            <Class-Path>.</Class-Path>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <type>jar</type>
                            <includeTypes>jar</includeTypes>
                            <outputDirectory>
                                ${project.build.directory}/lib
                            </outputDirectory>
                            <excludeTransitive>false</excludeTransitive>
                            <overWriteReleases>true</overWriteReleases>
                            <overWriteSnapshots>true</overWriteSnapshots>
                            <overWriteIfNewer>true</overWriteIfNewer>
                            <stripVersion>false</stripVersion>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>../../dubbo-config/config/</directory>
            </resource>
            <!--recources文件夹下的所有文件都打进jar包-->
            <resource>
                <targetPath>${project.build.directory}/classes</targetPath>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <!-- 由于com.alibaba.dubbo.container.Main默认寻找META-INF下的applicationContext.xml,固将 applicationContext.xml文件拷贝到META-INF目录下-->
            <resource>
                <targetPath>${project.build.directory}/classes/META-INF/spring</targetPath>
                <directory>src/main/resources/spring</directory>
                <filtering>true</filtering>
                <includes>
                    <include>applicationContext.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

最后看一下dubbo的配置参数:

#服务注册中心(如果注册中心为集群,这里需要使用“,”分隔)
dubbo.user.registry.server=127.0.0.1:2181
#服务暴露端口
dubbo.user.protocol.port=20080
#请求超时时间
dubbo.user.timeout=3000
#请求失败重试次数
dubbo.user.retries=0
#客户端(如果订阅的服务为集群,这里需要使用“,”分隔)
dubbo.user.client=127.0.0.1:2181

到此,一个简单的dubbo服务就搭建好了,我们启动一下看看。
直接运行类UserProviderMock.java

澳门新濠3559 19

image.png

如果看到"user provider start..."就证明启动成功了!
下面我们来看一下dubbo的客户端。

澳门新濠3559 20image.png

四、各个服务系统整合mybatis-generator插件

1、在各个服务系统的pom文件中添加mybatis-generator插件(在pom.xml已经添加)
2、在resources目录下添加generatorConfig.xml文件(两个服务系统需要适当的修改)

澳门新濠3559 21

3将somefun-system-service模块修改为springboot项目独立运行

三、dubbo客户端

接口实现类的注解,service一定是dubbo的注解

五、各个服务系统整合dubbo发布服务程序

1、在application.properties配置文件中添加如下配置信息:

#整合dubbo
#设置应用的服务名
spring.dubbo.application.name=shop-server-goods
(spring.dubbo.application.name=shop-server-order)
#设置RPC协议
spring.dubbo.protocol.name=dubbo
#设置RPC端口号
spring.dubbo.protocol.port=20880
#设置注册中心的地址
spring.dubbo.registry.address=zookeeper://127.0.0.1:2181
#设置发布服务注解扫描的路径
spring.dubbo.scan=com.jd.server.goods.service.impl
(spring.dubbo.scan=com.jd.server.order.service.impl)

服务提供方的代码

1、dubbo客户端配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://code.alibabatech.com/schema/dubbo
       http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息,用于计算依赖关系 -->
    <dubbo:application name="fund-baby-reference"/>

    <!-- 使用zookeeper注册中心暴露服务地址,如果使用多个服务,需要配置多个客户端 -->
    <dubbo:registry id="account-client" protocol="zookeeper" address="${dubbo.user.client}" />

    <!-- 设置所有服务的启动时检查 (依赖服务不可用时会抛出异常): -->
    <dubbo:consumer check="true" />

    <dubbo:annotation/>
</beans>

然后将其import进入applicationContext.xml即可。
先跑一下单元测试。

# Spring boot applicationspring.application.name = /springboot-dubboserver.port = 9099management.port = 9091# Service versiondemo.service.version = 1.0.0# Base packages to scan Dubbo Components (e.g @Service , @Reference)dubbo.scan.basePackages = com.itzmn.dubbo.service.impl# Dubbo Config properties## ApplicationConfig Beandubbo.application.id = springboot-dubbodubbo.application.name = springboot-dubbo## ProtocolConfig Beandubbo.protocol.id = dubbodubbo.protocol.name = dubbodubbo.protocol.port = 20880## RegistryConfig Beandubbo.registry.id = my-registry1dubbo.registry.address = zookeeper://47.106.64.158:2181
六、发布一个服务(以发布商品服务为例)

1、使用mybatis-genenrator插件生成domain类、mapper接口、mapper.xml文件
2、每个domain类应该在对应的api项目中
3、在对应的api项目中创建一个服务接口

澳门新濠3559 22

4、创建服务实现类
在该实现类上贴上@Service注解,贴上了该注解就代表了该类需要发布服务

注意:
1、该注解是com.alibaba.dubbo.config.annotation包下的注解不是spring的注解
2、贴上该注解的服务实现类必须要在上面的配置项spring.dubbo.scan=xxx能够扫描到的路径下

澳门新濠3559 23

5、启动springboot应用

somefun-system-service模块

2、单元测试

package com.sanjinbest.dubbo.mock;

import com.alibaba.dubbo.config.annotation.Reference;
import com.sanjinbest.dubbo.user.api.IUserInfoService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/9/18
 */
@RunWith(SpringJUnit4ClassRunner.class)  //使用junit4进行测试
@ContextConfiguration(locations={"classpath*:spring/applicationContext.xml"}) //加载配置文件
public class MockDubbo {

    @Reference
    private IUserInfoService iUserInfoService;

    @Test
    public void test(){
        System.out.println("Hello : "   iUserInfoService.getName());
        System.out.println("age : "   iUserInfoService.getAge());
    }
}

澳门新濠3559 24

image.png

在web层的配置文件中,配置,即可,前提,要先安装zookeeper,才能进行服务的注册,然后启动即可

七、各个客户端整合dubbo引用服务程序

1、在application.properties配置文件中添加如下配置信息:

 #dubbo应用名
spring.dubbo.application.name=shop-client-mgrsite
#连接的注册中心地址                
spring.dubbo.registry.address=zookeeper://127.0.0.1:2181
#引用服务扫描的路径                
spring.dubbo.scan=com.jd.client.mgrsite.controller

pom文件

3、与spring mvc结合

完成了单元测试,在尝试与spring mvc进行结合使用。与spring mvc的结合用其实非常简单,spring mvc的配置不变,只需要将spring-mvc与dubbo配置都交给applictionContext.xml进行管理就好。
spring-mvc.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

    <!-- 开启注解 -->
    <mvc:annotation-driven/>

    <!-- 定义跳转的文件的前后缀 ,视图模式配置-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀,变成一个 可用的url地址 -->
        <property name="prefix" value="/WEB-INF/pages/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

applictionContext.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"
       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">

    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="ignoreUnresolvablePlaceholders" value="true"/>
        <property name="locations">
            <list>
                <value>classpath*:dubbo.properties</value>
            </list>
        </property>
    </bean>

    <!-- dubbo 服务客户端 -->
    <import resource="classpath*:spring/fund-baby-reference.xml" />
    <!-- spring mvc 配置 -->
    <import resource="classpath*:spring/spring-mvc.xml" />

    <!-- 开启注解 -->
    <context:annotation-config/>
    <!--自动扫描-->
    <context:component-scan base-package="com.sanjinbest.dubbo" />
</beans>

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
http://www.springmodules.org/schema/cache/springmodules-cache.xsd
http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         metadata-complete="true">

  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 此处直接加载applicationContext.xml spring-mvc.xml在applicationContext.xml内加载 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:spring/applicationContext.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <display-name>Archetype Created Web Application</display-name>

</web-app>

在看一下测试的controller和service

package com.sanjinbest.dubbo.controller;

import com.sanjinbest.dubbo.service.IndexService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/11/6
 */
@Controller
public class IndexController{

    @Autowired
    private IndexService indexService;

    @RequestMapping(value="/user",method = RequestMethod.GET)
    @ResponseBody
    public String user(){
        return indexService.userInfo();
    }

}

controller的写法没有特殊变化,主要看一下service的。

package com.sanjinbest.dubbo.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.sanjinbest.dubbo.user.api.IUserInfoService;
import org.springframework.stereotype.Service;

/**
 * <li></li>
 *
 * @author lixin
 * @create 2017/11/6
 */
@Service
public class IndexService {

    @Reference
    private IUserInfoService iUserInfoService;

    public String userInfo(){
        return iUserInfoService.getName()   ","   iUserInfoService.getAge();
    }
}

service这里注入dubbo接口,需要使用注解@Reference
启动后看一下测试结果:

澳门新濠3559 25

image.png

最后,我们看一下dubbo-admin后台。
dubbo-admin.war可以在dubbo的官网上下载,下载后放到tomcat webapps内,解压war包,修改配置文件webapps/dubbo-admin/WEB-INF/dubbo.properties
设置dubbo.registry.address参数,我使用的是本地的zookeeper。

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

启动tomcat,然后请求地址http://127.0.0.1:8080/dubbo-admin/
用户名和密码都是root。
dubbo-admin的功能有很多,就不作详细说明了,到此一个使用dubbo服务的spring mvc示例就介绍结束。
本文只对dubbo的搭建作一个初步的介绍,后续会有一些dubbo的线上使用介绍。
示例项目下载地址 : https://pan.baidu.com/s/1nvj3XpB 密码: 46vr

写的比较粗糙,可能会存在一些错误。欢迎大家反馈交流。

配置

八、引用服务(以商品controller为例)

1、创建商品的controller调用商品的服务
在该controller需要注入服务的依赖上贴上@Refrence注解,贴上该注解就可以自动的把需要引用的服务注入进来
注意:贴上该注解的服务依赖必须要在上面的配置项spring.dubbo.scan=xxx能够扫描到的路径下

@Controller
public class ProductController {

    @Reference
    IProductService productService;
    @RequestMapping("/getAllProduct")
    @ResponseBody
    public List<Product> getAllProduct() {
        return productService.getAllProduct();
    }
}

澳门新濠3559 26

 1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 5     <parent> 6         <groupId>org.springframework.boot</groupId> 7         <artifactId>spring-boot-starter-parent</artifactId> 8         <version>2.1.1.RELEASE</version> 9         <relativePath/>10     </parent>11 12     <modelVersion>4.0.0</modelVersion>13 14     <artifactId>somefun-system-service</artifactId>15     <dependencies>16         <dependency>17             <groupId>com.zhj</groupId>18             <artifactId>somefun-system-api</artifactId>19             <version>1.0-SNAPSHOT</version>20         </dependency>21 22         <dependency>23             <groupId>com.alibaba.boot</groupId>24             <artifactId>dubbo-spring-boot-starter</artifactId>25             <version>0.2.0</version> <!-- 最新的0.2.1-SNAPSHOT 可以去上边的GitHub地址中下载编译 -->26         </dependency>27 28         <!-- Dubbo -->29         <dependency>30             <groupId>com.alibaba</groupId>31             <artifactId>dubbo</artifactId>32             <version>2.6.5</version>33         </dependency>34         <!-- Spring Context Extras -->35         <dependency>36             <groupId>com.alibaba.spring</groupId>37             <artifactId>spring-context-support</artifactId>38             <version>1.0.2</version>39         </dependency>40 41     </dependencies>42 43 44 </project>
# Spring boot applicationspring.application.name = dubbo-consumer-demoserver.port = 8080management.port = 8081# Service Versiondemo.service.version = 1.0.0# Dubbo Config properties## ApplicationConfig Beandubbo.application.id = dubbo-consumer-demodubbo.application.name = dubbo-consumer-demo## ProtocolConfig Beandubbo.protocol.id = dubbodubbo.protocol.name = dubbodubbo.protocol.port = 12345

创建启动类SomefunSystemApplication

只需将服务提供者的接口jar包引入,然后注入服务即可

 1 @SpringBootApplication (scanBasePackages={"com.zhj.somefun"}) 2 public class SomefunSystemApplication { 3  4    public static void main(String[] args) { 5  6       new SpringApplicationBuilder(SomefunSystemApplication.class) 7             .web(WebApplicationType.NONE)  //非web方式运行 8             .run; 9    }10 11 }

注意,springboot2.0和springboot1.x与dubbo整合不一样,

TestServiceImpl类:

QQ交流群:552113611

注意下这时候的Service注解的包要引用 duboo中的service注解

 1 package com.zhj.somefun.system.service.impl; 2  3 import com.zhj.somefun.system.api.dto.TestDto; 4 import com.zhj.somefun.system.api.service.TestService; 5  6 import com.alibaba.dubbo.config.annotation.Service; 7  8 import java.util.ArrayList; 9 import java.util.Date;10 import java.util.List;11 12 @Service13 public class TestServiceImpl implements TestService {14 15     @Override16     public List<TestDto> getTestList() {17         List<TestDto> list = new ArrayList<>();18         TestDto dto = new TestDto();19         dto.setAge(18);20         dto.setId(1);21         dto.setName("姓名1");22         dto.setCreatedate(new Date;23         list.add;24         return list;25     }26 }

TestDto类:

要实现Serializable接口

1 public class TestDto implements Serializable{2     private Integer id;3     private String name;4 5     public Integer getId() {6         return id;7     }8     …… ……9 }

application.yml文件

 1 server: 2     port: 6666 3 spring: 4     application: 5         name: dubbo-provider-demo 6  7 dubbo: 8     application: 9         id: dubbo-provider-demo10         name: dubbo-provider-demo11     monitor:12         protocol: registry13     protocol:14         id: dubbo15         name: dubbo16         port: 1234517     registry:18         address: zookeeper://127.0.0.1:218119         id: my-registry20     scan:21         #扫描server包地址22         basePackages: com.zhj.somefun.system.service

服务消费方

我们将web模块改造成dubbo调用方

pom 引入dubbo

 1 <dependency> 2    <groupId>com.alibaba.boot</groupId> 3    <artifactId>dubbo-spring-boot-starter</artifactId> 4    <version>0.2.0</version> 5 </dependency> 6  7 <!-- Dubbo --> 8 <dependency> 9    <groupId>com.alibaba</groupId>10    <artifactId>dubbo</artifactId>11    <version>2.6.5</version>12 </dependency>13 <!-- Spring Context Extras -->14 <dependency>15    <groupId>com.alibaba.spring</groupId>16    <artifactId>spring-context-support</artifactId>17    <version>1.0.2</version>18 </dependency>

Testcontroller控制器类

注解修改为Reference注解类

 1 @RestController 2 public class Testcontroller { 3  4     @Reference 5     private TestService testService; 6  7     @GetMapping("/getlist") 8     public List<TestDto> getlist(){ 9         return testService.getTestList();10     }11 12 }

application.yml 文件

 1 dubbo: 2     application: 3         id: dubbo-consumer-demo 4         name: dubbo-consumer-demo 5     monitor: 6         protocol: registry 7     protocol: 8         id: dubbo 9         name: dubbo10         port: 1234511     registry:12         address: zookeeper://127.0.0.1:218113 server:14     port: 808015 spring:16   profiles:17     active: dev18   application:19     name: dubbo-consumer-demo

因为我们注册中心使用的是zookeeper,我们可以在网上下载最新的zookeeper文件,运行起来即可。

运行服务器提供方的项目somefun-system-service

运行消费方的项目somefun-web

访问

我们会发现已经可以返回JSON数据

[{"id":1,"name":"姓名1","age":18,"createdate":"2018-12-22T06:58:43.535 0000"}]

这说明dubbo已经可以正常运行了

我们在运行项目中的时候编译器可能会打印错误日志

com.alibaba.dubbo.rpc.RpcException: No provider available from registry 127.0.0.1:2181 for service com.alibaba.dubbo.monitor.MonitorService on consumer 192.168.1.73 use dubbo version 2.6.5, please check status of providers(disabled, not registered or in blacklist).

这个因为dubbo的监控中心没有接入 ,对于这篇代码来说暂时没有影响

这里只是介绍了最简单的springboot 接入dubbo,更新丰富的功能和详解的介绍在dubbo官网

编辑:编程 本文来源:先看一下示例项目框架,服务发现与注册和运维

关键词: 澳门新濠3559