手把手教你如何玩轉Dubbo（入門到項目實踐）

情景引入

小白：嗚嗚，嗚嗚，嗚嗚，嗚嗚
我：誰呀，這麼早就鬧個不停，好好的週末還讓不讓人休息了
小白：嗚嗚，嗚嗚----------（聲音越來越大）
我：不甘心的爬起來，想一看究竟。
小白：你，你，你，怎麼就起來了呢？
我：你這麼大聲，豬都要被你叫醒來了。怎麼了，你這是，誰欺負你了嗎？
小白：是的，公司老大讓我重構公司的系統項目，因爲原來業務量不大，用的架構都比較簡單，而且還是跑單機模式，但是現在業務量來了，前期埋的坑，現在都暴露出來了，所以，公司讓我好好重構下項目。
我：那這不是挺好的嗎？可以從大局思考，提升自己的能力的機會來了。
小白：可是，之前公司一個項目就是一個服務，其中存在不同項目重複的寫輪子的情況，現在公司要求拆分，而且將基礎常用的做成中臺，服務與服務之間又要能相互調用。這可怎麼辦呢？
我：emmm，你的意思是說，現在需要按服務拆分項目，然後服務與服務之間能夠互相調用，減少重複代碼和代碼的冗餘以及提升整體架構性能是嗎？
小白：對呀，就是，現在不知道服務與服務之間該怎麼調用纔好。總不能，有一個調用請求就發一個Http請求去調用吧。這效率該多慢。
我：是的，這樣的情況就不該採取單一的Http了，不過我可以教你另外的一種方法哦。
小白：你知道其他的方法嗎？快告訴我快告訴我。。。（立馬不哭）
我：哎，起來都起來了，那就容我教你一個新知識吧。
PS：引文中出現了一個名詞：中臺。如果不明白的，建議百度一下，這個在公司還是很常見的。

問題引入

分佈式架構是現在越來越主流的模式，並且採取的也是服務與服務之間的調用，而將許多常用的服務就可以作爲中颱，方便多個服務去根據需求自由獲得理想的結果。其中服務可以簡單的理解爲一個功能模塊，比如，淘寶其中最爲主要的就有訂單模塊和商品模塊。試想，如果採取單一項目架構的方式，將商品模塊和訂單模塊都放一起，如何能撐得住雙11的購物狂潮，如果一個模塊接口掛了，那麼後續將會損失多少金錢，所以，爲了增加項目的性能，開始採取前後端分離，服務拆分，分佈式部署等等的技術。
我們來分析一個問題：
假設公司存在：A，B兩個服務，其中都有權限校驗，另外，A還會調用B服務的接口查詢某些數據庫的信息（A和B的數據庫表結構不一樣）。那麼，你此時會想到如何去處理呢？
提示：將權限校驗作爲一個C服務，誰需要誰去請求C服務的權限接口即完成權限校驗。
我們可以發現，其中關鍵的在於服務與服務之間的調度，那麼如何更好的實現這功能，Dubbo給我們提供了一個好的解決辦法。

簡介

Dubbo官網

英文官網：http://dubbo.apache.org/en-us/
中文官網：http://dubbo.apache.org/zh-cn/

Dubbo作用

Dubbo是一款高性能、輕量級的開源Java RPC框架，它提供了三大核心能力：面向接口的遠程方法調用，智能容錯和負載均衡，以及服務自動註冊和發現。（不懂？沒關係，跟着我一步步來，你就明白了）

RPC

RPC（Remote Procedure Call）：遠程過程調用
什麼叫遠程？
地方A有臺電腦服務，地方B有臺電腦服務，B調用A的服務，就叫遠程。B調用自己的服務就叫本地。
更詳細的解析，大家可以百度多瞭解瞭解。就好比我們常說的TCP/UDP/HTTP。

最簡單的Dubbo架構關係

生產者：提供服務；
消費者：消費（使用）服務；
註冊中心：服務註冊與發現，連接生產者與消費者，一般使用Zookeeper；
監控管理：對生產者與消費者的“健康”管理；

搭建項目的前置知識

開發工具

• IDEA（代碼編輯，Eclipse也可以，看心情即可）
• Mysql（數據庫，你喜歡Oracle也可以）
• Navicat（mysql數據庫可視化工具）
• Postman（模擬訪問請求工具）
• JDK，Maven，Tomcat，Zookeeper這些基本的還是安裝安裝

項目基本結構解析

正式搭建"生產者角色"環境的工程

創建父模塊

1. 打開Idea編輯器
2. 點擊創建一個新工程
   
3. 選擇Maven
   
4. 填寫項目工程基本信息
   
   
5. 大功告成
   

創建Client子模塊

1. 選中父模塊中的項目名，然後右擊，選擇new和model
   
2. 同理，選擇Maven
3. 然後填寫信息
   
4. 創建完成
   

創建Model子模塊

同創建Client子模塊

創建Service子模塊

同創建Client子模塊

父模塊和子模塊創建完成的結構

導入相關的依賴

1. client模塊導入內容

<?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>dubbofirst</artifactId>
        <groupId>com.scw.dubbo.first</groupId>
        <version>1.0.1</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>client</artifactId>
    <properties>
        <mybatis-pagehelper.version>4.1.2</mybatis-pagehelper.version>
        <lombok.version>1.16.10</lombok.version>
    </properties>

    <dependencies>
        <!--java校驗 跟 hibernate校驗-->
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>1.1.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.3.5.Final</version>
        </dependency>

        <!--for page-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>${mybatis-pagehelper.version}</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>

    </dependencies>

</project>

2. model模塊導入內容

<?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>dubbofirst</artifactId>
        <groupId>com.scw.dubbo.first</groupId>
        <version>1.0.1</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>model</artifactId>
    <properties>
        <mybatis-spring-boot.version>1.1.1</mybatis-spring-boot.version>
        <mybatis-pagehelper.version>4.1.2</mybatis-pagehelper.version>
    </properties>

    <dependencies>
        <!--api-->
        <dependency>
            <groupId>com.scw.dubbo.first</groupId>
            <artifactId>client</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

        <!--spring-mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot.version}</version>
        </dependency>

    </dependencies>

</project>

3. service模塊導入內容

<?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>dubbofirst</artifactId>
        <groupId>com.scw.dubbo.first</groupId>
        <version>1.0.1</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service</artifactId>
    <packaging>jar</packaging>

    <properties>
        <start-class>com.debug.mooc.dubbo.one.server.BootMoreApplication</start-class>

        <!--<spring-boot.version>1.3.3.RELEASE</spring-boot.version>-->
        <spring-boot.version>2.0.5.RELEASE</spring-boot.version>

        <spring-session.version>1.2.0.RELEASE</spring-session.version>
        <slf4j.version>1.7.13</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <mysql.version>5.1.37</mysql.version>
        <druid.version>1.0.16</druid.version>
        <guava.version>19.0</guava.version>
        <joda-time.version>2.9.2</joda-time.version>
        <cglib.version>3.1</cglib.version>

        <zookeeper.version>3.4.10</zookeeper.version>
        <curator.version>2.12.0</curator.version>
        <dubbo.version>2.6.4</dubbo.version>

        <resteasy.version>3.0.7.Final</resteasy.version>
        <okhttp.version>3.1.2</okhttp.version>
        <gson.version>2.6.1</gson.version>
        <httpclient.version>4.3.6</httpclient.version>

    </properties>

    <!-- 依賴管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>

        <!--model-->
        <dependency>
            <groupId>com.scw.dubbo.first</groupId>
            <artifactId>model</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

        <!--log-->
        <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>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <!--guava-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>

        <!-- time -->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>${joda-time.version}</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!--spring-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${spring-boot.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>log4j-over-slf4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- jsp 支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <!--<scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <!--<scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>curator-framework</artifactId>
                    <groupId>org.apache.curator</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>curator-client</artifactId>
                    <groupId>org.apache.curator</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-web</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>${cglib.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>asm</artifactId>
                    <groupId>org.ow2.asm</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- zookeeper start -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>${zookeeper.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-log4j12</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${curator.version}</version>
        </dependency>

        <!--dubbo rest-->
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-jaxrs</artifactId>
            <version>${resteasy.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>httpclient</artifactId>
                    <groupId>org.apache.httpcomponents</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-netty</artifactId>
            <version>${resteasy.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-client</artifactId>
            <version>${resteasy.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-jackson-provider</artifactId>
            <version>${resteasy.version}</version>
        </dependency>


        <!--for test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>${gson.version}</version>
        </dependency>

        <!-- okhttp -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>${okhttp.version}</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>dubboOne-${project.parent.version}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

4. 父模塊導入內容

<?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.scw.dubbo.first</groupId>
    <artifactId>dubbofirst</artifactId>
    <packaging>pom</packaging>
    <version>1.0.1</version>
    <modules>
        <module>client</module>
        <module>model</module>
        <module>service</module>
    </modules>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>

</project>

service模塊創建需要的配置文件

結構如下：

• applicaion.properties

# dubbo提供服務的端口
server.port=8093
#server.context-path=/dubbofirst
# dubbo上下文路徑
server.servlet.context-path=/dubbofirst
#logging
logging.path=E:\\logs\\mooc\\dubboOne\\logs
logging.file=dubboOne
logging.level.org.springframework = INFO
logging.level.com.fasterxml.jackson = INFO
logging.level.com.debug.mooc.dubbo.one = debug
#json時間解析配置
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
#spring.datasource.initialize=false
spring.datasource.initialization-mode=never
spring.jmx.enabled=false
#數據庫配置
datasource.url=jdbc:mysql://127.0.0.1:3306/dubbofirst?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
datasource.username=root
datasource.password=xxxxxxx
#mybatis
mybatis.config-location=classpath:mybatis-config.xml
mybatis.checkConfigLocation = true
mybatis.mapper-locations=classpath:mappers/*.xml
#dubbo zookeeper本地配置
dubbo.registry.address=zookeeper://127.0.0.1:2181

• dubbo.properties

dubbo.container=log4j,spring
dubbo.reference.check=false
dubbo.registry.client=curator
dubbo.application.name=dubboFirst-provider
dubbo.application.owner=debug
#dubbo提供rpc服務接口
dubbo.protocol.name=dubbo
dubbo.protocol.dubbo.port=20903
#dubbo提供rest服務接口
dubbo.protocol.name=rest
dubbo.protocol.rest.port=9013
dubbo.protocol.rest.server=tomcat
dubbo.service.loadbalance=roundrobin

• log4j.propertis

#Console Log
log4j.rootLogger=INFO,console,debug,info,warn,error

LOG_PATTERN=[%d{yyyy-MM-dd HH:mm:ss.SSS}] boot%X{context} - %5p [%t] --- %c{1}: %m%n

#A1--Print log to Console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=${LOG_PATTERN}

log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.Threshold=INFO
log4j.appender.info.File=${LOG_PATH}/${LOG_FILE}_info.log
log4j.appender.info.DatePattern='.'yyyy-MM-dd
log4j.appender.info.layout = org.apache.log4j.PatternLayout
log4j.appender.info.layout.ConversionPattern=${LOG_PATTERN}

log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.Threshold=ERROR
log4j.appender.error.File=${LOG_PATH}/${LOG_FILE}_error.log
log4j.appender.error.DatePattern='.'yyyy-MM-dd
log4j.appender.error.layout = org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern=${LOG_PATTERN}


log4j.appender.debug=org.apache.log4j.DailyRollingFileAppender
log4j.appender.debug.Threshold=DEBUG
log4j.appender.debug.File=${LOG_PATH}/${LOG_FILE}_debug.log
log4j.appender.debug.DatePattern='.'yyyy-MM-dd
log4j.appender.debug.layout = org.apache.log4j.PatternLayout
log4j.appender.debug.layout.ConversionPattern=${LOG_PATTERN}

log4j.appender.warn=org.apache.log4j.DailyRollingFileAppender
log4j.appender.warn.Threshold=WARN
log4j.appender.warn.File=${LOG_PATH}/${LOG_FILE}_warn.log
log4j.appender.warn.DatePattern='.'yyyy-MM-dd
log4j.appender.warn.layout = org.apache.log4j.PatternLayout
log4j.appender.warn.layout.ConversionPattern=${LOG_PATTERN}

• mybatis-config.xml

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- Globally enables or disables any caches configured in any mapper under this configuration -->
        <setting name="cacheEnabled" value="true"/>
        <!-- Sets the number of seconds the driver will wait for a response from the database -->
        <setting name="defaultStatementTimeout" value="3000"/>
        <!-- Enables automatic mapping from classic database column names A_COLUMN to camel case classic Java property names aColumn -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- Allows JDBC support for generated keys. A compatible driver is required.
        This setting forces generated keys to be used if set to true,
         as some drivers deny compatibility but still work -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- 設置控制檯打印sql -->
        <!--<setting name="logImpl" value="stdout_logging" />-->
    </settings>

    <!-- Continue going here -->

    <!--<typeAliases>-->
        <!--<package name="cn.com.countrygarden.ucenter.entity"/>-->
    <!--</typeAliases>-->
    <plugins>
        <!-- com.github.pagehelper爲PageHelper類所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 4.0.0以後版本可以不設置該參數 -->
            <property name="dialect" value="mysql"/>
            <!-- 該參數默認爲false -->
            <!-- 設置爲true時，會將RowBounds第一個參數offset當成pageNum頁碼使用 -->
            <!-- 和startPage中的pageNum效果一樣-->
            <property name="offsetAsPageNum" value="true"/>
            <!-- 該參數默認爲false -->
            <!-- 設置爲true時，使用RowBounds分頁會進行count查詢 -->
            <property name="rowBoundsWithCount" value="true"/>
            <!-- 設置爲true時，如果pageSize=0或者RowBounds.limit = 0就會查詢出全部的結果 -->
            <!-- （相當於沒有執行分頁查詢，但是返回結果仍然是Page類型）-->
            <property name="pageSizeZero" value="true"/>
            <!-- 3.3.0版本可用 - 分頁參數合理化，默認false禁用 -->
            <!-- 啓用合理化時，如果pageNum<1會查詢第一頁，如果pageNum>pages會查詢最後一頁 -->
            <!-- 禁用合理化時，如果pageNum<1或pageNum>pages會返回空數據 -->
            <property name="reasonable" value="false"/>
            <!-- 3.5.0版本可用 - 爲了支持startPage(Object params)方法 -->
            <!-- 增加了一個`params`參數來配置參數映射，用於從Map或ServletRequest中取值 -->
            <!-- 可以配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置映射的用默認值 -->
            <!-- 不理解該含義的前提下，不要隨便複製該配置 -->
            <!--<property name="params" value="pageNum=pageHelperStart;pageSize=pageHelperRows;"/>-->
            <!-- 支持通過Mapper接口參數來傳遞分頁參數 -->
            <property name="supportMethodsArguments" value="false"/>
            <!-- always總是返回PageInfo類型,check檢查返回類型是否爲PageInfo,none返回Page -->
            <property name="returnPageInfo" value="none"/>
        </plugin>
    </plugins>
</configuration>

• spring-jdbc.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       " >

    <!--dubbofirst -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close" primary="true" >
        <!-- 基本屬性 url、user、password -->
        <property name="url" value="${datasource.url}" />
        <property name="username" value="${datasource.username}" />
        <property name="password" value="${datasource.password}" />

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="10" />
        <property name="minIdle" value="10" />
        <property name="maxActive" value="20" />

        <!-- 配置獲取連接等待超時的時間 -->
        <property name="maxWait" value="60000" />

        <!-- 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連接，單位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />

        <!-- 配置一個連接在池中最小生存的時間，單位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />

        <property name="validationQuery" value="SELECT 1 " />
        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />

        <!-- 打開PSCache，並且指定每個連接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="true" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />

        <!-- 配置監控統計攔截的filters，去掉後監控界面sql無法統計 -->
        <property name="filters" value="stat" />
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

• spring-dubbo.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns: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:annotation package="com.scw.dubbo.first.service.dubbo" />

    <!--註冊中心zookeeper配置信息-->
    <dubbo:registry address="${dubbo.registry.address}" />

    <!--支持兩種協議的調用：rpc-dubbo協議；http協議-rest api-url調用-->
    <dubbo:protocol name="rest" threads="500" contextpath="v1" server="tomcat" accepts="500"/>
    <dubbo:protocol name="dubbo" />

    <!--消費方信息配置-->
	<dubbo:application name="dubboFirst-consume" owner="debug" organization="dubbox"/>


</beans>

本地創建Zookeeper環境

下載鏈接：https://zookeeper.apache.org/releases.html
或者
https://mirrors.tuna.tsinghua.edu.cn/apache/zookeeper/

安裝步驟：

1. 解壓文件
2. 在conf目錄複製一份zoo_sample.cfg文件，並命名爲zoo.cfg
3. 在zoo.cfg修改data的目錄，並且創建log存放的目錄，如圖所示：其中的data和log目錄需要自己創建的哦！！！！
   
4. 運行bin目錄下面的zkServicer,cmd，查看是否運行成功即可。（zookeeper默認的端口是：2181）

本地創建數據庫

創建一個數據庫，其名字要與配置文件中的配的一樣（比如我配置的是：dubbofirst）

service模塊創建項目的啓動類

BootMoreApplication：

package com.scw.dubbo.first.service;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
@ImportResource(value = {"classpath:spring/spring-jdbc.xml", "classpath:spring/spring-dubbo.xml"})
@MapperScan(basePackages = "com.scw.dubbo.first.model.mapper")
public class BootMoreApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(BootMoreApplication.class);
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(BootMoreApplication.class, args);
    }

}

Client模塊編寫統一接口返回類

統一消息返回的枚舉類

package com.scw.dubbo.first.client.enums;

/**
 * 統一接口的返回信息枚舉類
 */
public enum  StatusCode {

    Success(0,"成功"),
    Fail(-1,"失敗"),
    InvalidParams(200,"無效的參數"),
    ItemNotExist(201,"商品不存在!");

    private Integer code;
    private String msg;

    StatusCode(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

統一返回類：

package com.scw.dubbo.first.client.response;
import com.scw.dubbo.first.client.enums.StatusCode;
import java.io.Serializable;

/**
 * 統一返回類（便於統一返回信息）
 * @param <T>
 */
public class BaseResponse<T> implements Serializable{

    private Integer code;
    private String msg;
    private T data;

    public BaseResponse() {
    }

    public BaseResponse(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public BaseResponse(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public BaseResponse(StatusCode statusCode) {
        this.code = statusCode.getCode();
        this.msg = statusCode.getMsg();
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

Service模塊編寫項目環境搭建是否成功的Controller測試類

BaseController類

package com.scw.dubbo.first.service.controller;
import com.scw.dubbo.first.client.enums.StatusCode;
import com.scw.dubbo.first.client.response.BaseResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.RestController;

@RestController
public class BaseController {

    private static final Logger log= LoggerFactory.getLogger(BaseController.class);

    private static final String prefix="base";

    /**
     * 測試環境搭建是否成功
     * @param param
     * @return
     */
    @RequestMapping(value = prefix+"/test",method = RequestMethod.GET)
    public BaseResponse one(@RequestParam String param){
        BaseResponse response=new BaseResponse(StatusCode.Success);
        try {
            response.setData(param);

        }catch (Exception e){
            e.printStackTrace();
            response=new BaseResponse(StatusCode.Fail);
        }
        return response;
    }
}

啓動BootMoreApplication類，啓動項目

如果啓動項目發生錯誤，那麼就根據錯誤進行提示修改哦。。。如果認真的按照我的步驟來的話，肯定是沒問題的哈。

通過URL進行請求，判斷環境搭建是否OK

情況一：URL

原因：因爲我們在application.properties配置文件中，將端口改爲了8093，所以現在還在用原來的8080當然是不可以的啦。！！！！

情況二：URL

What，怎麼還不行，說好的是8093的呢？這是因爲我們在application.properties文件中配置了dubbo的上下文是dubbofirst，所以這個鏈接當然不行了，繼續往下面看~~~

情況三：URL

哇塞，，，，終於可以了，歷經千辛萬苦~~~~感動

備註：請大家一定要認真的研讀配置文件的內容，一定要知道是幹嘛的，是在哪裏進行使用的，因爲後續會非常多的使用到這些內容。基礎紮實才決定我們能走多遠~！

正式搭建"消費者角色"環境的工程

這個搭建與“生產者角色”的搭建過程一樣，只是在配置文件中需要修改部分內容。

1. 數據庫的連接信息（與生產者的不一樣即可）
2. dubbo的相關端口（與生產者的不一樣即可，因爲現在搭建的都是在本地進行配置和部署，所以防止端口衝突）
   因此，這個搭建就不多說了。請返回上面進行重新搭建。

項目實踐

一：商城系統調用商品系統（RPC接口）

場景描述

該場景分爲兩個角色：生產者（商品系統）和消費者（商城系統），而商城系統就通過調用商品系統而查詢到對應的商品信息而進行顯示。（備註：簡單演示消費者調用生產者的服務）

項目實戰開發

生產者代碼（不分先後，根據自己的習慣來即可）

1. 在client模塊編寫生產者服務的接口，命名IDubboItemService

package com.scw.dubbo.first.client.service;

import com.scw.dubbo.first.client.response.BaseResponse;

public interface IDubboItemService {

    /**
     * 查詢商品
     * @return
     */
    BaseResponse listItems();
}

2. 在service模塊編寫代碼，命名爲DubboItemServiceImpl

package com.scw.dubbo.first.service.dubbo;
import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.scw.dubbo.first.client.enums.StatusCode;
import com.scw.dubbo.first.client.response.BaseResponse;
import com.scw.dubbo.first.client.service.IDubboItemService;
import com.scw.dubbo.first.model.entity.ItemInfo;
import com.scw.dubbo.first.model.mapper.ItemInfoMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import javax.ws.rs.Path;
import javax.ws.rs.QueryParam;
import java.util.List;

/**
 * 通過註解將其進行發佈到註冊中心
 */
@Service(protocol = {"dubbo","rest"},validation = "true",version = "1.0",timeout = 3000)
@Path("goods/")
public class DubboItemServiceImpl implements IDubboItemService {

    private static final Logger log= LoggerFactory.getLogger(DubboItemService.class);

    @Autowired
    private ItemInfoMapper itemInfoMapper;

    /**
     * 列表查詢服務-實際的業務實現邏輯
     * @return
     */
    @Path("item/list")
    public BaseResponse listItems() {
        BaseResponse response=new BaseResponse(StatusCode.Success);
        try {
            List<ItemInfo> infos=itemInfoMapper.selectAll();
            log.info("查詢到的商品列表數據：{} ",infos);
            response.setData(infos);

        }catch (Exception e){
            log.error("列表查詢服務-實際的業務實現邏輯-發生異常：",e.fillInStackTrace());
            response=new BaseResponse(StatusCode.Fail);
        }
        return response;
    }
}

3. 編寫數據處理層Mapper映射類

package com.scw.dubbo.first.model.mapper;
import com.scw.dubbo.first.model.entity.ItemInfo;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface ItemInfoMapper {

    List<ItemInfo> selectAll();
}

4. 編寫對應Mapper類的xml文件

 <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.scw.dubbo.first.model.mapper.ItemInfoMapper" >
  <resultMap id="BaseResultMap" type="com.scw.dubbo.first.model.entity.ItemInfo" >
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="code" property="code" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="price" property="price" jdbcType="DECIMAL" />
    <result column="is_active" property="isActive" jdbcType="INTEGER" />
    <result column="create_time" property="createTime" jdbcType="TIMESTAMP" />
    <result column="update_time" property="updateTime" jdbcType="TIMESTAMP" />
  </resultMap>
  <sql id="Base_Column_List" >
    id, code, name, price, is_active, create_time, update_time
  </sql>
  <!--查詢列表-->
  <select id="selectAll" resultType="com.scw.dubbo.first.model.entity.ItemInfo">
    SELECT <include refid="Base_Column_List"/>
    FROM item_info
    WHERE is_active = 1
    ORDER BY create_time DESC
  </select>

5. ItemInfo商品對應的實體類

package com.scw.dubbo.first.model.entity;

import lombok.ToString;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

@ToString
public class ItemInfo implements Serializable{
    private Integer id;

    private String code;

    private String name;

    private BigDecimal price;

    private Integer isActive;

    private Date createTime;

    private Date updateTime;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code == null ? null : code.trim();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public Integer getIsActive() {
        return isActive;
    }

    public void setIsActive(Integer isActive) {
        this.isActive = isActive;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

6. 將對應的生產者代碼通過maven打成jar包生成依賴，便於消費者使用
   
7. 初始化數據庫的數據

/*
Navicat MySQL Data Transfer

Source Server         : mylocal
Source Server Version : 50717
Source Host           : localhost:3306
Source Database       : dubbofirst

Target Server Type    : MYSQL
Target Server Version : 50717
File Encoding         : 65001

Date: 2019-10-07 18:38:48
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `item_info`
-- ----------------------------
DROP TABLE IF EXISTS `item_info`;
CREATE TABLE `item_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵',
  `code` varchar(255) DEFAULT NULL COMMENT '商品編碼',
  `name` varchar(255) DEFAULT NULL COMMENT '名稱',
  `price` decimal(15,2) DEFAULT NULL COMMENT '銷售價',
  `is_active` int(11) DEFAULT '1' COMMENT '是否有效（1=是；0=否）',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '創建時間',
  `update_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新時間',
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_code` (`code`) USING BTREE COMMENT '商品編碼唯一'
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8 COMMENT='商品信息表';

-- ----------------------------
-- Records of item_info
-- ----------------------------
INSERT INTO `item_info` VALUES ('1', '10010', 'Java編程思想', '58.50', '1', '2019-01-13 14:07:58', null);
INSERT INTO `item_info` VALUES ('2', '10011', '由淺入深實戰分佈式中間件', '45.50', '1', '2019-01-13 14:07:59', null);
INSERT INTO `item_info` VALUES ('3', '10012', 'Dubbo實戰教程', '68.00', '1', '2019-01-13 14:07:59', null);
INSERT INTO `item_info` VALUES ('4', '10013', 'JVM深入實戰指南', '38.50', '1', '2019-01-13 14:07:59', null);
INSERT INTO `item_info` VALUES ('5', '10014', 'SpringBoot實戰', '56.50', '1', '2019-01-13 14:07:59', null);
INSERT INTO `item_info` VALUES ('6', '10015', 'SpringCloud實戰', '64.00', '1', '2019-01-13 14:07:59', null);
INSERT INTO `item_info` VALUES ('7', '10017', 'Mysql實戰指南', '75.50', '1', '2019-01-13 14:07:59', null);

消費者代碼

1. service模塊的pom.xml文件添加對生產者的依賴配置

<dependency>
            <groupId>com.scw.dubbo.first</groupId>
            <artifactId>client</artifactId>
            <version>1.0.1</version>
        </dependency>

2. 在service模塊中的spring-dubbo.xml文件添加生產者服務的配置

  <!--引入服務提供方提供的dubbo服務-url="dubbo://127.0.0.1:20903" -->
    <dubbo:reference interface="com.scw.dubbo.first.client.service.IDubboItemService" id="dubboItemService"
                     url="dubbo://127.0.0.1:20903" protocol="dubbo" version="1.0" timeout="20000">
    </dubbo:reference>

備註：其中的url如果是本地的話可以不寫，因爲在自測的時候都是在本的，而如果以後在實際項目後，我們可以設置生產者服務對應的服務器的IP地址和端口；

3. 消費者編寫調用生產者接口的業務代碼

package com.scw.dubbo.second.service.controller;
import com.google.common.collect.Maps;
import com.scw.dubbo.first.client.response.BaseResponse;
import com.scw.dubbo.first.client.service.IDubboItemService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;

@RestController
public class ItemController {

    private static final Logger log= LoggerFactory.getLogger(ItemController.class);

    private static final String prefix="item";
	//之所以能夠引入生產者中的類，就是因爲我們在pom.xml文件引入了生產者的依賴
    @Autowired
    private IDubboItemService dubboItemService;



    /**
     * 用戶商城列表查詢
     * @return
     */
    @RequestMapping(value = prefix+"/list",method = RequestMethod.GET)
    public Map<String,Object> list(){
        Map<String,Object> resMap= Maps.newHashMap();
        resMap.put("code","0");
        resMap.put("msg","成功");

        //TODO:調用服務提供方dubboFirst提供的列表查詢功能
        try {
            BaseResponse response = dubboItemService.listItems();
            if (response!=null && response.getCode().equals(0)){
                resMap.put("data",response.getData());
            }
        }catch (Exception e){
            e.printStackTrace();
            resMap.put("code","-1");
            resMap.put("msg","失敗");
        }
        return resMap;
    }

4. 啓動服務，查看結果
   當消費者要使用生產者的接口服務的時候，一定要保證生產者的服務是處於可用狀態，否則會提示無法調用連接生產者的接口。
   因此，別忘記啓動笨的的zookeeper服務哦，然後再啓動生產者服務，最後再啓動消費者服務即可；
5. 通過URL請求，查看調用結果
   
   備註：我們可以看到通過消費者確實調用到了生產者的接口，並且也達到了我們預想的結果。

二：商品系統調用訂單系統（Rest接口調用）

描述：在商品系統中，用戶可以通過商品系統進行對應商品的下單（如：淘寶商城買東西），而實際的商品訂單系統又是屬於另外一個模塊，而並非在商品系統中，所以這時候就出現一個系統調用另外一個系統的接口來完成功能。

PS：其實這個接口可以像上面的例子一樣採取RPC的調用方式，但是爲了讓大家瞭解不同的調用方式，所以這個實例就採取Rest的調用方式。大家有興趣的話，也可以將下面這個例子改成用RPC的形式喲。！

實踐流程

**備註：**下面的生產者和消費者，我就默認和上面的實例保持一樣了，所以基本的環境搭建就不重複說，就只是說如何完成這個功能，如果環境還沒搭好的，那麼就認真看看上面的例子喲。

生產者（訂單系統）

1. 數據庫設計
   MysqlDDL語句：

CREATE TABLE `order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `item_id` int(11) NOT NULL,
  `customer_name` varchar(255) NOT NULL,
  `total` int(11) NOT NULL,
  `order_time` datetime NOT NULL,
  `update_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

數據庫內容：

備註：大家主要是理解這個過程，而不是在於看數據庫的結構設計，僅僅是一個示例；

2. 訂單order實體類

package com.scw.dubbo.first.client.model;

import lombok.Data;
import lombok.ToString;

import java.io.Serializable;
import java.util.Date;

/**
 * @ Author     ：scw
 * @ Date       ：Created in 下午 4:55 2019/11/24 0024
 * @ Description：訂單實體
 * @ Modified By：
 * @Version: $version$
 */
@Data
@ToString
public class Order implements Serializable{
    //主鍵
    private Integer id;
    //商品ID
    private Integer itemId;
    //用戶名
    private String customerName;
    //商品總數量
    private Integer total;
    //下單時間
    private Date orderTime;
    //更新時間
    private Date updateTime;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getItemId() {
        return itemId;
    }

    public void setItemId(Integer itemId) {
        this.itemId = itemId;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    public Integer getTotal() {
        return total;
    }

    public void setTotal(Integer total) {
        this.total = total;
    }

    public Date getOrderTime() {
        return orderTime;
    }

    public void setOrderTime(Date orderTime) {
        this.orderTime = orderTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

3. Rest接口

package com.scw.dubbo.first.client.service;

import com.scw.dubbo.first.client.model.Order;
import com.scw.dubbo.first.client.response.BaseResponse;

/**
 * @ Author     ：scw
 * @ Date       ：Created in 下午 4:53 2019/11/24 0024
 * @ Description：訂單Rest接口
 * @ Modified By：
 * @Version: $version$
 */
public interface OrderService {

    /**
     * 客戶商品下單
     * @param order
     * @return
     */
    BaseResponse addCustomerProductOrder(Order order);

}

4. Rest接口實現類（真正提供服務的接口）

package com.scw.dubbo.first.service.rest;

import com.alibaba.dubbo.config.annotation.Service;
import com.scw.dubbo.first.client.enums.StatusCode;
import com.scw.dubbo.first.client.model.Order;
import com.scw.dubbo.first.client.response.BaseResponse;
import com.scw.dubbo.first.client.service.OrderService;

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.Date;

/**
 * @ Author     ：scw
 * @ Date       ：Created in 下午 4:59 2019/11/24 0024
 * @ Description：客戶商品下單rest接口實現類
 * @ Modified By：
 * @Version: $version$
 */
@Path("order")
@Service(protocol = {"dubbo","rest"},validation = "true",version = "1.0",timeout = 3000)
public class OrderServiceImpl implements OrderService {

    /**
     * 客戶商品下單的POST請求的接口
     * 備註：consumes和produces註解就是將其接口設置的接受類型（還有很多比如XML，都可以）
     * @param order
     * @return
     */
    @Path("/add")
    @POST
    @Consumes(value = MediaType.APPLICATION_JSON)
    @Produces(value = MediaType.APPLICATION_JSON)
    @Override
    public BaseResponse addCustomerProductOrder(Order order) {
        BaseResponse baseResponse = new BaseResponse(StatusCode.Success);
        //TODO 隨便寫一些處理邏輯，這個一般還有數據層的操作，這裏就不演示了
        if(order == null){
            baseResponse.setCode(StatusCode.Fail.getCode());
            baseResponse.setMsg("訂單數據不能爲空");
            return baseResponse;
        }
        //TODO 一些邏輯處理，這裏就不多寫了
        order.setUpdateTime(new Date());
        return baseResponse;
    }

}

5. 啓動服務，自測是否接口成功
   備註：
   大家可以下一個Postman的軟件用於發出請求，或者採取IDEA自帶的插件也是可以的。
   （1）情景如下
   
   原因解析： 很多人都不知道到底請求的時候是採取服務的上下文前綴（如：dubbofirst）還是dubbo暴露出去的上下前綴（如：v1，這個是在上面的例子配的，大家根據自己需求配置即可，我這是爲了方便），大家可以理解爲：如果當前的接口是dubbo或者rest接口那麼我們就要採取dubbo的上下文；如果是用的controller層的請求，那麼自然就是用的項目服務的上下文；
   application.properties配置文件：
   
   spring.dubbo.xml配置文件：
   
   （2）情景如下：
   
   備註： 很明顯，咱們寫的rest接口沒有問題，那麼如何給另外一個服務進行調用呢？那麼繼續往下看，let‘s go

消費者（商品系統）

1. Controller類（功能：用於本服務對外提供請求接口）

package com.scw.dubbo.second.service.controller;

import com.google.common.collect.Maps;
import com.scw.dubbo.second.client.model.OrderDto;
import com.scw.dubbo.second.service.rest.OrderServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.ws.rs.core.MediaType;
import java.util.Map;

/**
 * @ Author     ：scw
 * @ Date       ：Created in 下午 5:37 2019/11/24 0024
 * @ Description：商城系統的客戶下單請求controller
 *
 * @ Modified By：
 * @Version: $version$
 */
@RestController
public class OrderController {

    private static final Logger log= LoggerFactory.getLogger(OrderController.class);

    @Autowired
    private OrderServiceImpl orderService;

    /**
     * 客戶下訂單接口
     * 備註:consumes就是限制了前端是傳Json格式的參數，如果不加，那麼就以post請求的方式傳Key 和 value即可（原始的方式）
     * @param order
     * @return
     */
    @RequestMapping(value = "/add", method = RequestMethod.POST,consumes = MediaType.APPLICATION_JSON)
    public Map<String, Object> addCustomerOrder(@RequestBody OrderDto order){
        Map<String,Object> resMap= Maps.newHashMap();
        resMap.put("code","0");
        resMap.put("msg","成功");
        try {
            //將調用另外一個系統的接口寫在service層便於邏輯處理
            orderService.addOrder(order);
        }catch (Exception e){
            log.error("客戶下單發生異常:" + e);
        }

        return resMap ;
    }

}

2. 採用Rest調用生產者的下單服務接口OrderServiceImpl
   備註：其中示例採用的post請求是使用OKhttp對象，大家也可以採取其他的對象都是可以的哦！！

package com.scw.dubbo.second.service.rest;

import com.scw.dubbo.second.client.model.OrderDto;
import com.scw.dubbo.second.service.controller.ItemController;
import okhttp3.*;
import org.codehaus.jackson.map.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @ Author     ：scw
 * @ Date       ：Created in 下午 5:50 2019/11/24 0024
 * @ Description：調用其他服務rest接口的實現類
 * @ Modified By：
 * @Version: $version$
 */
@Service
public class OrderServiceImpl {

    //調用其他服務rest接口的請求URL
    private static final String ORDER_URL = "http:127.0.0.1:9013/v1/order/add";

    //將對象序列化的對象
    private ObjectMapper objectMapper = new ObjectMapper();

    //採取okhttp的對象來實現post請求
    private OkHttpClient okHttpClient = new OkHttpClient();

    private static final Logger log= LoggerFactory.getLogger(OrderServiceImpl.class);


    /**
     * 處理用戶下單的邏輯
     * @param orderDto
     */
    public void addOrder(OrderDto orderDto) {
        try {
            //(1)構造builder對象
            Request.Builder builder = new Request.Builder().url(ORDER_URL).header("Content-Type", "application/json");
            //(2)構造消息體
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), objectMapper.writeValueAsString(orderDto));
            //(3)構造請求
            Request request = builder.post(requestBody).build();
            //(4)發送請求
            Response response = okHttpClient.newCall(request).execute();
            //(5)打印響應內容
            log.info("響應結果爲:" + response.body().toString());
        } catch (Exception e) {

        }
    }

}

3. 啓動服務，測試結果
   （1）場景如下：
   
   原因分析： 這是因爲當前的服務是調用方，並且調用的是controller層的請求，那麼URL對應的上下文應該是系統服務，而不是dubbo的上下文。因此，應該將v2改爲dubboSecond即可（具體可以對比下面的一種場景）。
   （2）場景如下：
   
   是否會懷疑到底是不是另外一個服務提供的服務呢？那我們回到IDEA則可以看到提供服務系統成功的打印瞭如下的信息，所以成功調用另外服務的rest接口啦！
   
   哇塞。。。。。調用成功，基本流程已經打通，是不是覺得其實就和調用自己系統的方法一樣呢？so easy！！！

4. 調用post方法的優化
   備註：上面調用的方式其實很簡單，但是不夠通用，爲了系統能夠更好的調用Post和Get類型的請求，我們應該封裝一下，達到更好的優化效果！
   （後續再補啦，一下接受太多不太好，大家趕緊先去試試感覺！！！！！!！！！！）

未完待續