dubbo+spring+zookeeper的集成入门实例

一、启动zookeeper

　　笔者用的kafka自带的zookeeper

　　任务管理器输入bin\windows\zookeeper-server-start.bat config\zookeeper.properties开启zookeeper

　　Ctrl+c输入Y关闭服务

二、安装dubbo—admin管理控制台

　　1、打开https://github.com/apache/dubbo-admin/tree/master，下载压缩包

　　2、打开dubbo-admin-master\dubbo-admin-server\src\main\resources下的application.properties文件,确定下面地址正确

　　3、然后回到dubbo-admin-master文件夹的cmd中输入mvn clean package回车，出现BUILD SUCCESS则成功

　　　　注：笔者出现的错误提示及解决方式

错误提示：Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.21.0

//编译或打包时报错，需要在pom.xml文件中加上下面内容
　　<plugin>
　　　　<groupId>org.apache.maven.plugins</groupId>
　　　　<artifactId>maven-surefire-plugin</artifactId>
　　　　<version>2.22.2</version>
　　　　<configuration>
　　　　<testFailureIgnore>true</testFailureIgnore>
　　　　</configuration>
　　</plugin>

　　4、确定zookeeper启动已成功，否则dubbo启动失败。

　　　　将打包生成的target目录打开，然后cmd打开命令窗口，运行java -jar dubbo-admin-server-0.5.0.jar 命令即可

　　　　运行成功：

　　5、启动dubbo的控制台，在浏览器访问：http://localhost:8080，然后输入用户名和密码，均为root

三、dubbo使用实例

　　dubbo是一个远程过程调度(RPC)框架，使用zookeeper作为服务的注册中心，以及消费者通过订阅获取服务的相关地址及端口号。首先定义一个统一的接口api，供服务提供者和消费者使用。服务提供者实现这个接口api，并向zookeeper注册IP和端口，同时使用dubbo协议开发服务的接口实例，运行起来，供消费者调用。消费者同样使用dubbo协议，只需要几行配置就可以调用远程接口，获取数据。

　　3.1 统一的api

　　　　新建一个dubbo_api_demo1项目，使用maven，定义了两个接口。单独定义一个项目是为了解耦提供者和消费者，同时统一一样的接口，实现者和使用者最后没有异议。可以将这个项目作为依赖导入提供者和消费者的pom中。

　　　　HelloService:

package com.jessin.dubbo;

public interface HelloService {
    String sayHello(String name);
    String sayGoodBye(String name);
}

　　　　CalculateService:

package com.jessin.dubbo;

public interface CalculateService {
    int add(int a, int b);
    int subtract(int a, int b);
}

　　3.2 服务提供者的实现dubbo_provider_demo

　　　　同样新建一个模块dubbo_provider_demo，对两个接口进行实现，api主要是定义服务接口以及一些工具类，主要是供consumer和provider共用。

<!-- consumer和provider项目都需要添加这两个依赖。 -->
        <dependency>
            <groupId>com.jessin.dubbo</groupId>
            <artifactId>dubbo_api_demo1</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- 必须引入dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
        </dependency>

　　　　HelloServiceImpl：

package com.jessin.dubbo_provider;
import com.jessin.dubbo.HelloService;   //前提是已经导完dubbo_api_demo1d的包

public class HelloServiceImpl implements HelloService{
    public String sayHello(String name) {
        return "Hello," + name;
    }

    public String sayGoodBye(String name) {
        return "GoodBye," + name;
    }
}

　　　　CalculateServiceImpl:

package com.jessin.dubbo_provider;
import com.jessin.dubbo.CalculateService;

public class CalculateServiceImpl implements CalculateService{
    public int add(int a, int b) {
        return a+b;
    }

    public int subtract(int a, int b) {
        return a-b;
    }
}

　　　　这个项目就不需要自己在定义api接口了，直接引用api模块作为依赖即可，同时必须引入dubbo的依赖,具体pom配置如图：

<?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.jessin.dubbo_provider</groupId>
    <artifactId>dubbo_provider_demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <name>dubbo_provider</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>3.1.4.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
    </properties>

    <dependencies>
        <!-- 引用本地的其他项目或模块，版本保持跟该模块一致，保持最新-->
        <dependency>
            <groupId>com.jessin.dubbo</groupId>
            <artifactId>dubbo_api_demo1</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- 引入Spring依赖，主要是dubbo命名空间在spring配置文件中 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-asm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring end -->
        <!-- log -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- 必须引入dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
        </dependency>
        <!-- 由于我们使用zookeeper作为注册中心，所以需要操作zookeeper
                dubbo 2.6以前的版本引入zkclient操作zookeeper
                dubbo 2.6及以后的版本引入curator操作zookeeper -->
        <!-- 必须引入zkclient  -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!--  zookeeper -->
        <!--<dependency>-->
        <!--<groupId>org.apache.zookeeper</groupId>-->
        <!--<artifactId>zookeeper</artifactId>-->
        <!--<version>3.3.6</version>-->
        <!--</dependency>-->

        <!-- netty -->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.32.Final</version>
        </dependency>

        <!-- zookeeper功能组件 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.13.0</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>dubbo_provider_demo</finalName>
        <plugins>
            <!-- 非多个资源配置 start-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                    <encoding>UTF-8</encoding>
                    <failOnError>false</failOnError>
                </configuration>
            </plugin>
            <!-- 非多个资源配置 end-->
            <!--
                在target目录下将classes文件打成jar，并填写MANIFEST的入口和类路径为lib
                所有的依赖均被放到lib下
            -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.0.2</version>
                <configuration>
                    <!--要使用的打包配置.-->
                    <archive>
                        <manifest>
                            <!-- 为依赖包添加路径, 这些路径会写在MANIFEST文件的Class-Path下 -->
                            <addClasspath>true</addClasspath>
                            <!-- 这个jar所依赖的jar包添加classPath的时候的前缀，如果这个jar本身和依赖包在同一级目录，则不需要添加 -->
                            <classpathPrefix>lib/</classpathPrefix>
                            <!-- jar启动入口类 -->
                            <mainClass>com.jessin.dubbo.main.Main</mainClass>
                        </manifest>
                        <manifestEntries>
                            <!-- 在Class-Path下添加配置文件的路径 -->
                            <Class-Path>.</Class-Path>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.10</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!--outputDirectory: 项目构件输出目录，其中${project.build.directory}默认为target/-->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <overWriteReleases>false</overWriteReleases>
                            <overWriteSnapshots>false</overWriteSnapshots>
                            <overWriteIfNewer>true</overWriteIfNewer>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>
</project>

　　　　入口类Main:

　　　　　　加载了spring的配置文件app_provider.xml，然后进入IO阻塞。

public class Main {
    public static void main(String[] args) throws IOException {
        //ClassPathXmlApplicationContext:通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
        //单个
        //ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/app_provider.xml");
        //两个及以上
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"spring/app_provider.xml"});
        context.start();
        System.out.println("按任意键退出");
        //System.in.read():从键盘读出一个字符，然后返回它的Unicode码。按下Enter结束输入
        System.in.read();
    }
}

　　　　配置文件app_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://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        ">
    <!-- 应用的名字，在dubbo管理页面可以看到-->
    <dubbo:application name="dubbo_provider" />
    <!-- 指定注册中心的地址，连接zookeeper的地址及协议-->
    <dubbo:registry  protocol="zookeeper"  address="127.0.0.1:2181"  />
    <!-- 服务提供者绑定的IP及端口号，使用dubbo协议，提供给调用者（通信协议，通信端口）-->
    <dubbo:protocol name="dubbo" port="20880" />

    <!-- 根据id获取bean -->
    <!-- 在Spring的配置文件中配置bean 将id的对象交给Spring的IOC容器管理 -->
    <!-- id：bean的唯一标识  class：bean所对应类型的全类名 -->
    <bean id="helloService" class="com.jessin.dubbo.Impl.HelloServiceImpl" />
    <!-- 指定需要暴露的服务 ref：指向服务真正的实现对象  -->
    <dubbo:service interface="com.jessin.dubbo.HelloService" ref="helloService" />

    <!-- 和本地bean一样实现服务 -->
    <bean id="calculateService" class="com.jessin.dubbo.Impl.CalculateServiceImpl" />
    <!-- 指定需要暴露的服务 ref：指向服务真正的实现对象-->
    <dubbo:service interface="com.jessin.dubbo.CalculateService" ref="calculateService" />

    <!-- 监控中心协议，如果为protocol="registry"，表示从注册中心发现监控中心地址，否则直连监控中心 -->
    <!-- <dubbo:monitor protocol="registry"></dubbo:monitor> -->

</beans>

　　　　可以看到，该配置文件注册了两个服务的实现，生成了两个接口类实例并托管给spring容器，并且将具体的服务IP及端口通过zookeeper的2181端口注册到zookeeper上。

　　　　配置文件log4j.properties（必须）

log4j.rootLogger=DEBUG , stdout
log4j.logger.org.mybatis=DEBUG
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

　　3.3 消费者的实现

　　　　同样使用Maven构建一个新的项目，这里是基于spring的web项目，同样引入api依赖。
　　　　web.xml如下，分别使用了spring/app_consumer.xml、spring/mvc_consumer.xml作为业务层和web层的配置文件，访问链接前缀为/dubbo/consumer/。

　　　　web.xml详解见:https://blog.csdn.net/weixin_41544662/article/details/128147204

　　　　web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 字符编码过滤器-->
    <filter>
        <!-- 过滤器名称 -->
        <filter-name>CharacterEncodingFilter</filter-name>
        <!-- 过滤器类的包路径 可使用<init-param>标签初始化 -->
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>

    <!-- 过滤器映射 -->
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <!-- 指定过滤器作用的对象 /*：所有外部访问都需要先经过该过滤器 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 服务层和业务层 -->
    <!-- 指定持久层和业务层的配置文件：在类路径下，初始化业务层Spring容器，也是父容器 -->
    <context-param>
        <!-- 声明应用范围内的初始化参数。用于向Servlet+Context提供键值对，
        即应用程序上下文信息。后续的listener，filter在初始化时会用到这些上下文信息。
        在servlet里面可以通过getServletContext().getInitParameter(“context/param”)得到 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/spring/app_consumer.xml</param-value>
    </context-param>
    <!-- 监听器 -->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <!-- web层-->
    <servlet>
        <!-- <servlet-name>：注册的名字 -->
        <servlet-name>spring</servlet-name>
        <!-- <servlet-class>：配置的 Servlet 的全类名 -->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- init-param：用来定义参数，可有多个init-param。在servlet类中通过getInitParamenter(String name)方法访问初始化参数 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                classpath:/spring/mvc_consumer.xml
            </param-value>
        </init-param>
        <!--
        1、load-on-startup 元素标记容器是否应该在web应用程序启动的时候就加载这个servlet，(实例化并调用其init()方法)。
        2、它的值必须是一个整数，表示servlet被加载的先后顺序。
        3、如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
        4、如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，值越小，servlet的优先级越高，就越先被加载。值相同时，容器就会自己选择顺序来加载。 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- servlet-mapping：用来定义servlet所对应的URL，包含两个子元素 -->
    <servlet-mapping>
        <!-- <servlet-name>指定servlet的名称 -->
        <servlet-name>spring</servlet-name>
        <!--不能使用/*，但可以使用/crud/*，使用*.do会把后缀名去掉-->
        <!-- <url-pattern> 指定servlet所对应的URL -->
        <url-pattern>/dubbo/consumer/*</url-pattern>
    </servlet-mapping>
    
</web-app>

　　　　查看spring/app_consumer.xml，可以看到客户端如何引入远程实例，获取远程数据：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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-3.0.xsd
       http://code.alibabatech.com/schema/dubbo
       http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

        <!-- 应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
        <dubbo:application name="dubbo_consumer" />

        <!-- 向zookeeper获取服务注册的地址，同时获取rpc生成bean实例注册到spring中 -->
        <dubbo:registry protocol="zookeeper" address="" />

        <!-- 直接请求两个远程接口实例-->
        <dubbo:reference id="helloService" interface="com.jessin.dubbo.HelloService" />
        <dubbo:reference id="calculateService" interface="com.jessin.dubbo.CalculateService"/>

</beans>

　　　　这时两个接口实例helloService和calculateService就可以直接使用了，如注入到controller中。看下spring/mvc_consumer.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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
       <!-- 最基本的扫描方式:扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
       <context:component-scan base-package="com.jessin.dubbo.controller"/>

       <!-- 需要这一个配置，使得下面的json配置有效-->
       <!-- Spring3.1后的注解映射器 -->
       <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

       <!-- 完成JSON格式数据的自动转换-->
       <!-- Spring3.1后的注解适配器 -->
       <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
              <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->
              <!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关）-->
              <property name="messageConverters">
                     <!-- 为集合类型属性赋值用list标签 -->
                     <list>
                            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
                     </list>
              </property>
       </bean>

       <!-- 如果使用mvc:annotation-driven不用配置上边的两句，实际开发时使用mvc:annotation-driven -->
       <!-- <mvc:annotation-driven></mvc:annotation-driven> -->

</beans>

　　　　spring会扫描controller包下的文件的注解，完成controller的生成，以及service的自动注入

　　　　HelloController：

package com.jessin.dubbo.controller;

import com.jessin.dubbo.CalculateService;
import com.jessin.dubbo.HelloService;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.xml.ws.RequestWrapper;

@Controller
public class HelloController {
    //从配置文件中注入
    /*@Autowired 先根据类型查找，如果存在多个（Bean）再根据名称进行查找，支持属性注入、构造方法注入和Setter注入
        当一个Service有多个ServiceImpl实现时，会报错，可以用@Qualifier解决，但效率低下
    @Resource 先根据名称查找，如果（根据名称）查找不到，再根据类型进行查找，只支持属性注入和Setter注入
        当有多个Impl实现类时，可以通name快速找到    */
    @Resource
    private HelloService helloService;

    @Resource
    private CalculateService calculateService;

    @RequestMapping(value = "/hello",method = {RequestMethod.GET,RequestMethod.POST})
    //GET模式下，可以使用@PathVariable绑定输入参数
    //POST模式下，使用@RequestBody绑定请求对象，将Json、Xml协议转换成你需要的对象。
    @ResponseBody
    //@RequestParam:访问路径后必须带有参数，默认required=true，为false则非必须，通过defaultValue指定参数默认值
    public String sayHello(@RequestParam(required = false,defaultValue = "Tom")String name){
        return helloService.sayHello(name);
    }

    @RequestMapping(value = "/goodbye",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    public String sayGoodBye(@RequestParam(required = false,defaultValue = "Tome")String name){
        return helloService.sayGoodBye(name);
    }

    @RequestMapping(value = "add",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    public String add(@RequestParam("a")int a,@RequestParam("b")int b){
        int sum = calculateService.add(a,b);
        return String.format("%d + %d = %d",a,b,sum);
    }

    @RequestMapping(value = "/subtract", method = {RequestMethod.GET, RequestMethod.POST})
    @ResponseBody
    public String subtract(@RequestParam("a") int a, @RequestParam("b") int b){
        int diff = calculateService.subtract(a, b);
        return String.format("%d - %d = %d", a, b, diff);
    }
}

　　　　显然，当我们访问/dubbo/consumer/hello时，将在前端得到一个json字符串，具体配置可以看mvc_consumer.xml中的RequestMappingHandlerAdapter注入，同时必须注入RequestMappingHandlerMapping实例，除了和服务提供端一样引入dubbo、zkclient、spring依赖外，还需在pom中引入json依赖：

<!-- jason依赖 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.8.7</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.8.7</version>
</dependency>

　　　　jetty依赖：Jetty可作为一个小型的快速的可嵌入的Web服务器和Servlet容器(具有tomcat一样的作用，都可以当服务器或者说servet容器)

<build>
        <finalName>dubbo_consumer_demo</finalName>
        <plugins>
            <!-- Tomcat插件，使用jetty运行 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 注意端口是8081 -->
                    <port>8081</port>
                    <path>/</path>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.3.7.v20160115</version>
                <configuration>
                    <webApp>
                        <contextPath>/</contextPath>
                    </webApp>
                </configuration>
            </plugin>
        </plugins>
    </build>

　　四、程序运行和测试

　　　　由于服务提供者和消费者均依赖于zookeeper这里先将zookeeper启动，然后启动服务提供者，最后启动消费者，并通过浏览器调用。

　　　　利用idea自带的Maven插件进行打包

　　　　步骤是clean->compile->install->package，这里要先对被依赖的项目进行上述操作，compile是编译，install是安装到你本地的maven仓库，最后打包

　　　　启动dubbo_provider_demo

　　　　启动dubbo_consumer_demo

　　　　访问浏览器

　　　　启动控制台

　　　　访问http://localhost:8080/index.html

访问浏览器
启动控制台

访问http://localhost:8080/index.html，如下：

posted @ 2023-06-09 19:29 Billd 阅读(127) 评论(0) 收藏举报

刷新页面返回顶部

Loading

Billd