SpringCloud核心教程 | 第三篇：服务注册与发现 Eureka篇

Spring Cloud简介

Spring Cloud是一个基于Spring Boot实现的云应用开发工具，它为基于JVM的云应用开发中涉及的配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、决策竞选、分布式会话和集群状态管理等操作提供了一种简单的开发方式。

Spring Cloud包含了多个子项目（针对分布式系统中涉及的多个不同开源产品），比如：Spring Cloud Config、Spring Cloud Netflix、Spring Cloud CloudFoundry、Spring Cloud AWS、Spring Cloud Security、Spring Cloud Commons、Spring Cloud Zookeeper、Spring Cloud CLI等项目。

微服务架构

“微服务架构”在这几年非常的火热，以至于关于微服务架构相关的开源产品被反复的提及（比如： netflix、dubbo），Spring Cloud也因Spring社区的强大知名度和影响力也被广大架构师与开发者备受关注。

那么什么是“微服务架构”呢？简单的说，微服务架构就是将一个完整的应用从数据存储开始垂直拆分成多个不同的服务，每个服务都能独立部署、独立维护、独立扩展，服务与服务间通过诸如RESTful API的方式互相调用。

对于“微服务架构”，大家在互联网可以搜索到很多相关的介绍和研究文章来进行学习和了解。也可以阅读始祖Martin Fowler的《Microservices》（中文版翻译点击查看），本文不做更多的介绍和描述。

服务治理

在简单介绍了Spring Cloud和微服务架构之后，下面回归本文的主旨内容，如何使用Spring Cloud来实现服务治理。

由于Spring Cloud为服务治理做了一层抽象接口，所以在Spring Cloud应用中可以支持多种不同的服务治理框架，比如：Netflix Eureka、Consul、Zookeeper。在Spring Cloud服务治理抽象层的作用下，我们可以无缝地切换服务治理实现，并且不影响任何其他的服务注册、服务发现、服务调用等逻辑。

所以，下面我们通过Eureka这种种服务治理的实现来体会Spring Cloud这一层抽象所带来的好处。
下一篇介绍基于Consul的服务注册与调用。

Spring Cloud Eureka

首先，我们来尝试使用Spring Cloud Eureka来实现服务治理。

Spring Cloud Eureka是Spring Cloud Netflix项目下的服务治理模块。而Spring Cloud Netflix项目是Spring Cloud的子项目之一，主要内容是对netflix公司一系列开源产品的包装，它为Spring Boot应用提供了自配置的Netflix OSS整合。通过一些简单的注解，开发者就可以快速的在应用中配置一下常用模块并构建庞大的分布式系统。它主要提供的模块包括：服务发现（Eureka），断路器（Hystrix），智能路由（Zuul），客户端负载均衡（Ribbon）等。

下面，就来具体看看如何使用Spring Cloud Eureka实现服务治理，这里使用eureka-server为服务注册中心工程、eureka-provider服务提供者工程、eureka-consumer服务消费者工程。

准备工作

环境：

windows
jdk 8
maven 3.0
IDEA

构建工程

首先构建父工程，引入父工程依赖：

<?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>
    
    <parent>
        <groupId>cn.zhangbox</groupId>
        <artifactId>spring-cloud-study</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    
    <groupId>cn.zhangbox</groupId>
    <artifactId>spring-cloud-eureka</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    
    <!--子模块-->
    <modules>
        <module>eureka-server</module>
        <module>eureka-provider</module>
        <module>eureka-consumer</module>
    </modules>
    
</project>

父工程取名为：spring-cloud-eureka
构建子工程，分别创建工程名为：eureka-server、eureka-provider、eureka-consumer并在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>

    <parent>
        <groupId>cn.zhangbox</groupId>
        <artifactId>spring-cloud-eureka</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>cn.zhangbox</groupId>
    <artifactId>eureka-server</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>eureka-server</name>
    <description>Spring Cloud In Action</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- 引入eureka服务端依赖start -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
        <!-- 引入eureka服务端依赖end -->
    </dependencies>

    <!-- 添加cloud 依赖start -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 添加cloud 依赖end -->

    <!-- 添加maven构建插件start -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <!-- 添加maven构建插件end -->

</project>

<?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>

    <parent>
        <groupId>cn.zhangbox</groupId>
        <artifactId>spring-cloud-eureka</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>cn.zhangbox</groupId>
    <artifactId>eureka-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>eureka-provider</name>
    <description>this project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!-- 版本控制 -->
        <commons-lang3.version>3.4</commons-lang3.version>
        <commons-codec.version>1.10</commons-codec.version>
        <mybatis-spring-boot.version>1.2.0</mybatis-spring-boot.version>
        <lombok.version>1.16.14</lombok.version>
        <fastjson.version>1.2.41</fastjson.version>
        <druid.version>1.1.2</druid.version>
    </properties>

    <repositories>
        <!-- 阿里私服 -->
        <repository>
            <id>aliyunmaven</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
    </repositories>

    <dependencies>

        <!-- mybatis核心包 start -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot.version}</version>
        </dependency>
        <!-- mybatis核心包 end -->

        <!-- 添加eureka支持start -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!-- 添加eureka支持start -->

        <!-- SpringWEB核心包 start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- SpringWEB核心包 end -->

        <!-- Swagger核心包 start -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
        <!-- Swagger核心包 end -->

        <!-- mysql驱动核心包 start -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- mysql驱动核心包 end -->

        <!-- sprigTest核心包 start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- sprigTest核心包 end -->

        <!-- commons工具核心包 start -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec.version}</version>
        </dependency>
        <!-- commons工具核心包 end -->

        <!-- fastjson核心包 start -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!-- fastjson核心包 end -->

        <!-- druid核心包 start -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!-- druid核心包 end -->

        <!-- lombok核心包 start -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <!-- lombok核心包 end -->
    </dependencies>

    <!-- 添加cloud 依赖start -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 添加cloud 依赖end -->

    <build>
        <finalName>eureka-provider</finalName>
        <plugins>
            <!-- 添加maven构建插件start -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- 添加maven构建插件end -->
        </plugins>
    </build>

</project>

<?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>

    <parent>
        <groupId>cn.zhangbox</groupId>
        <artifactId>spring-cloud-eureka</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>cn.zhangbox</groupId>
    <artifactId>eureka-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>eureka-consumer</name>
    <description>this project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!-- 版本控制 -->
        <commons-lang3.version>3.4</commons-lang3.version>
        <commons-codec.version>1.10</commons-codec.version>
        <mybatis-spring-boot.version>1.2.0</mybatis-spring-boot.version>
        <lombok.version>1.16.14</lombok.version>
        <fastjson.version>1.2.41</fastjson.version>
        <druid.version>1.1.2</druid.version>
    </properties>

    <repositories>
        <!-- 阿里私服 -->
        <repository>
            <id>aliyunmaven</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
    </repositories>

    <dependencies>
        <!-- 添加eureka支持start -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!-- 添加eureka支持start -->

        <!-- 添加feign支持start -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
        <!-- 添加feign支持end -->

        <!-- SpringWEB核心包 start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- SpringWEB核心包 end -->

        <!-- Swagger核心包 start -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
        <!-- Swagger核心包 end -->

        <!-- sprigTest核心包 start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- sprigTest核心包 end -->

        <!-- commons工具核心包 start -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec.version}</version>
        </dependency>
        <!-- commons工具核心包 end -->

        <!-- fastjson核心包 start -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!-- fastjson核心包 end -->

        <!-- lombok核心包 start -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <!-- lombok核心包 end -->
    </dependencies>

    <!-- 添加cloud 依赖start -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!-- 添加cloud 依赖end -->

    <build>
        <finalName>eureka-provider</finalName>
        <plugins>
            <!-- 添加maven构建插件start -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- 添加maven构建插件end -->
        </plugins>
    </build>

</project>

工程构建完成。

服务注册中心工程配置

首先：在eureka-server工程下resource目录下添加application.yml文件并加入以下配置：

#工程名称
spring:
  application:
    name: eureka-server
#选择哪一个环境的配置
#这里可以在每个环境配置redis，数据库（mysql），消息（kafka）等相关的组件的配置
  profiles:
    active: dev
#配置eureka注册中心
eureka:
  #server:
    #配置关闭自我保护模式
    #enableSelfPreservation: false
    #配置Eureka Server清理无效节点的时间间隔
    #eviction-interval-timer-in-ms: 4000
  instance:
    #配置与此实例相关联的主机名，是其他实例可以用来进行请求的准确名称
    hostname: eureka-server
    #显示服务ip地址
    preferIpAddress: true
    #获取服务的ip和端口
    instanceId: ${spring.cloud.client.ipAddress}:${server.port}
  client:
    #配置不将自己注册到eureka注册中心
    register-with-eureka: false
    #配置此客户端不获取eureka服务器注册表上的注册信息
    fetch-registry: false
    serviceUrl:
          #配置默认节点有信息，这里是获取本机的ip和端口来实现，如果不配置，默认会找8761端口，这里配置的是1001端口，因此会报错
          defaultZone: http://${spring.cloud.client.ipAddress}:${server.port}/eureka/
      
#文档块区分为三个---
---
server:
  port: 1001
spring:
  profiles: dev
#日志
logging:
  config: classpath:log/logback.xml
  path: log/eureka-server

#文档块区分为三个---
---
server:
  port: 1002
spring:
  profiles: test
#日志
logging:
  config: classpath:log/logback.xml
  path: usr/eureka-server/log/eureka-server

#文档块区分为三个---
---
server:
  port: 1003
spring:
  profiles: prod
#日志
logging:
  config: classpath:log/logback.xml
  path: usr/eureka-server/log/eureka-server

这里日志的配置不在详细说明，不知道怎么配置可以参考这篇文章：
SpringBoot进阶教程 | 第二篇：日志组件logback实现日志分级打印

其次：创建核心启动类：

@EnableEurekaServer//加上此注解表示将此工程启动后为注册中心
@SpringBootApplication
public class EurekaServerApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(EurekaServerApplication.class).web(true).run(args);
    }

}

最后：启动项目
至此Eureka注册中心创建完成，浏览器输入地址：http://localhost:1001/
可以看到如下页面，表示服务启动OK

这里这看到还没有服务暴露出来，是因为还没创建服务提供者工程。

服务提供者工程配置

这里服务提供者是使用之前SpringBoot进阶教程 | 第三篇：整合Druid连接池以及Druid监控改造而来，这里一样的部分就不再重复说明，下面将说明新增的部分。
首先：修改application.yml配置为如下：

#公共配置
server:
    port: 80
    tomcat:
      uri-encoding: UTF-8
spring:
  application:
      #服务名称，更关键，使用feign进行服务消费将以此为依据
      name: eureka-provider
  #激活哪一个环境的配置文件
  profiles:
    active: dev
  #连接池配置
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 配置测试查询语句
      validationQuery: SELECT 1 FROM DUAL
      # 初始化大小，最小，最大
      initialSize: 10
      minIdle: 10
      maxActive: 200
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 180000
      testOnBorrow: false
      testWhileIdle: true
      removeAbandoned: true
      removeAbandonedTimeout: 1800
      logAbandoned: true
      # 打开PSCache，并且指定每个连接上PSCache的大小
      poolPreparedStatements: true
      maxOpenPreparedStatements: 100
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,log4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

#配置eureka获取服务地址，这里使用的是本地注册中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka/
  #配置Swagger相关信息
  instance:
      prefer-ip-address: true
      instanceId: ${spring.cloud.client.ipAddress}:${server.port}
      status-page-url: http://${spring.cloud.client.ipAddress}:${server.port}/swagger-ui.html # ${server.port}为该服务的端口号

#mybatis
mybatis:
  # 实体类扫描
  type-aliases-package: cn.zhangbox.springboot.entity
  # 配置映射文件位置
  mapper-locations: classpath:mapper/*.xml
  # 开启驼峰匹配
  mapUnderscoreToCamelCase: true

---
#开发环境配置
server:
  #端口
  port: 8080
spring:
  profiles: dev
  # 数据源配置
  datasource:
    url: jdbc:mysql://101.132.66.175:3306/student?useUnicode=true&characterEncoding=utf8&useSSL=false&tinyInt1isBit=true
    username: root
    password: 123456
#日志
logging:
  config: classpath:log/logback.xml
  path: log/eureka-provider

---
#测试环境配置
server:
  #端口
  port: 80
spring:
  profiles: test
  # 数据源配置
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/eureka-provider?useUnicode=true&characterEncoding=utf8&useSSL=false&tinyInt1isBit=true
    username: root
    password: 123456
#日志
logging:
  config: classpath:log/logback.xml
  path: /home/log/eureka-provider

---
#生产环境配置
server:
  #端口
  port: 8080
spring:
  profiles: prod
  # 数据源配置
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/eureka-provider?useUnicode=true&characterEncoding=utf8&useSSL=false&tinyInt1isBit=true
    username: root
    password: 123456
#日志
logging:
  config: classpath:log/logback.xml
  path: /home/log/eureka-provider

其次：在config目录下增加SwaggerConfig类加入以下代码：

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket userApi() {
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("cn.zhangbox.eureka.provider.controller"))//过滤的接口，有这扫描才会看到接口信息
                .paths(PathSelectors.any())
                .build();
        return docket;
    }


    private ApiInfo apiInfo() {
        return new ApiInfoBuilder().title("eureka服务端提供者接口平台").description("服务相关数据接口")
                .termsOfServiceUrl("http://www.zhang.box.cn/").contact("技术开发部")
                .license("Licence Version 1.0").licenseUrl("#").version("1.0").build();
    }

}

这里如果不会使用swagger的整合可以参考这篇文章：
SpringBoot非官方教程 | 第十一篇：SpringBoot集成swagger2，构建优雅的Restful API

接着：创建核心启动类：

@EnableDiscoveryClient //使用该注解将注册服务到eureka
@SpringBootApplication
@MapperScan("cn.zhangbox.eureka.provider.dao")//配置mybatis接口包扫描
public class EurekaProviderApplication extends SpringBootServletInitializer {

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

最后：启动项目
至此eureka-provider服务提供者创建完成，浏览器输入地址：http://localhost:1001/
可以看到如下页面，表示服务注册OK

点击Status下的ip后可以跳转看到swagger的页面并可是测试服务提供者的接口，如下：

服务消费者工程配置

这里构建的工程名为eureka-consumer,上文已经构建了工程但是没有创建目录，这里只需要在java目录下创建config、controller，service，包即可，这里服务的消费是通过feign来进行服务调用的，后面会有专门以篇文章来讲feign。
首先：在eureka-consumer工程下resource目录下添加application.yml文件并加入以下配置：

#公共配置
server:
    port: 80
    tomcat:
      uri-encoding: UTF-8
spring:
  #服务名称，更关键，使用feign进行服务消费将以此为依据
  application:
     name: eureka-consumer
  #激活哪一个环境的配置文件
  profiles:
    active: dev

#配置eureka获取服务地址，这里使用的是本地注册中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka/
  #配置instance相关信息
  instance:
      prefer-ip-address: true
      instanceId: ${spring.cloud.client.ipAddress}:${server.port}
      status-page-url: http://${spring.cloud.client.ipAddress}:${server.port}/swagger-ui.html # ${server.port}为该服务的端口号

---
#开发环境配置
server:
  #端口
  port: 8081
spring:
  profiles: dev
#日志
logging:
  config: classpath:log/logback.xml
  path: log/eureka-consumer

---
#测试环境配置
server:
  #端口
  port: 8082
spring:
  profiles: test
#日志
logging:
  config: classpath:log/logback.xml
  path: /home/log/eureka-consumer

---
#生产环境配置
server:
  #端口
  port: 8083
spring:
  profiles: prod
#日志
logging:
  config: classpath:log/logback.xml
  path: /home/log/eureka-consumer

其次：在config目录下增加SwaggerConfig类加入以下代码：

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket userApi() {
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("cn.zhangbox.eureka.consumer.controller"))//过滤的接口，有这扫描才会看到接口信息
                .paths(PathSelectors.any())
                .build();
        return docket;
    }


    private ApiInfo apiInfo() {
        return new ApiInfoBuilder().title("eureka服务端消费者接口平台").description("服务相关数据接口")
                .termsOfServiceUrl("http://www.zhang.box.cn/").contact("技术开发部")
                .license("Licence Version 1.0").licenseUrl("#").version("1.0").build();
    }

}

接着：在service包下创建StudentConsumerService类并加入以下代码：

@FeignClient(value = "eureka-provider")
public interface StudentConsumerService {

    /**
     * 查询所有的学生信息
     *
     * @param sname
     * @param age
     * @return
     */
    @RequestMapping(value = "/student/list",method = RequestMethod.GET)
    String getStudentList(@RequestParam(value = "sname") String sname, @RequestParam(value = "age") Integer age);
}

然后：在controller包下创建StudentConteroller并加入如下代码：

@Controller
@RequestMapping("/student")
@Api(value = "eureka-consumer", description = "学生查询接口")
public class StudentConteroller {
    private static final Logger LOGGER = LoggerFactory.getLogger(StudentConteroller.class);

    @Autowired
    StudentConsumerService studentService;

    /**
     * 查询所有的学生信息
     *
     * @param sname
     * @param age
     * @param modelMap
     * @return
     */
    @ResponseBody
    @GetMapping("/consumer/list")
    public String list(
            @ApiParam(value = "学生姓名") @RequestParam(required = false) String sname,
            @ApiParam(value = "年龄") @RequestParam(required = false) Integer age,
            ModelMap modelMap) {
        String json = null;
        try {
            json = studentService.getStudentList(sname, age);
        } catch (Exception e) {
            e.printStackTrace();
            modelMap.put("ren_code", "0");
            modelMap.put("ren_msg", "查询失败===>" + e);
            LOGGER.error("查询失败===>" + e);
            json = JSON.toJSONString(modelMap);
        }
        return json;
    }
}

接着：创建核心启动类：

@EnableFeignClients//开启Feign调用接口
@EnableDiscoveryClient//开启客户端服务，没有这个注解会报Feign找不到对应服务的错误
@SpringBootApplication
public class EurekaConsumerApplication extends SpringBootServletInitializer {

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

最后：启动项目
至此eureka-consumer服务提供者创建完成，浏览器输入地址：http://127.0.0.1:8081/swagger-ui.html
同样也可以点击Eureka控制台中Application为eureka-consumer后Status下的ip后可以跳转看到swagger的页面并可是测试服务消费者的接口,可以看到如下页面，并点击try it out按钮，返回了正确的学生信息数据

返回数据如下：

{
    "ren_code": "0",
    "ren_msg": "查询成功",
    "studentList": [{
        "age": "17",
        "birth": "2010-07-22",
        "dept": "王同学学习成绩很不错",
        "sex": "1",
        "sname": "王同学",
        "sno": 1
    }, {
        "age": "17",
        "birth": "2010-07-22",
        "dept": "李同学学习成绩很不错",
        "sex": "1",
        "sname": "李同学",
        "sno": 2
    }]
}

以上就是spring cloud基于eurka实现分布式服务注册与消费的整合流程，是不是很简单，你也来小试牛刀一把吧。

写在最后

欢迎关注、喜欢、和点赞后续将推出更多的Spring Cloud教程，敬请期待。

源码地址

SpringCloud核心教程 | 第三篇：服务注册与发现 Eureka篇

欢迎关注我的微信公众号获取更多更全的学习资源，视频资料，技术干货！