Spring-Boot:Spring Cloud构建微服务架构

概述：

　　从上一篇博客《Spring-boot:5分钟整合Dubbo构建分布式服务》 过度到Spring Cloud，我们将开始学习如何使用Spring Cloud 来搭建微服务。继续采用上一篇博客中所使用到的图：

　　我们先来观察一下Spring Cloud 的组成，从上图中可以发现，Spring Cloud 的服务会比Dubbo 完善太多，Spring Cloud 包括了配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、决策竞选、分布式会话和集群状态管理等一系列的服务。在后续，我们会对每一个服务进行深入研究，而在本文中，我们将快速入门Spring Cloud ，一起来看看 与Dubbo 相比，Spring Cloud 有何不同。

一、服务治理

1.1、概括

　　 服务治理，或者我们可以理解为服务注册中心，Spring Cloud 应用中可以支持多种不同的服务治理框架，如：Netflix Eureka、Consul、Zookeeper。

　　　　如上图所示，我们在使用 IDEA 进行 Spring Cloud 项目创建的时候，编辑器会提示我们选择默认则服务治理框架。

　　　　与Dubbo 相比，Spring-Cloud 提供了更加丰富的选择，而在本次学习博文中，我们将会采用 Eureka 作为服务注册中心进行开发。

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

1.2、创建“服务注册中心”

　　　　项目创建方式，可以参考《Spring-Boot:6分钟掌握SpringBoot开发》 学习如何快速搭建Spring-Boot 项目，这里只做简单的介绍：

1.3、Pom.xml

　　　　与Dubbo 不一样，Dubbo 采用Zookeeper 作为服务注册中心，因此只需要开发 Productor 和Consumer 即可，而Spring-cloud 中，需要我们独自开发一个服务治理服务（服务注册中心），但是由于Spring-boot 带来的敏捷开发，我们只需要引入：

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>

　　　　其他相关依赖，则跟Spring-Boot Web 应用类似，在这里就不细述了。

1.4、Application.properties

　　　　在默认设置下，该服务注册中心也会将自己作为客户端来尝试注册它自己，所以我们需要禁用它的客户端注册行为，只需要在 application.properties 配置文件中增加如下信息：

　　　　这里我们将服务的端口号修改为 8761 ，服务名称为 eureka-server

spring.application.name=eureka-server
server.port=8761

eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

1.5、Application.java

　　　　区别于普通的Spring Boot 项目，我们需要为启动类添加一个  @EnableEurekaServer 注解，用于标识出这个服务是 Eureka 服务：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class SpringBootCloudApplication {

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

1.6、启动项目

　　　　运行 Application.java 中的 main 方法，启动 Eureka 服务，然后访问 http://localhost:8761/：

　　　　到这里位置，我们的Spring-cloud 服务治理 以及搭建好了，相较于搭建一个Zookeeper 服务，在下认为，还是这个比较方便，毕竟 Spring-cloud-Eureka  也是基于Java 实现，你觉得呢？

二、服务提供者

　　　　下面我们创建提供服务的客户端，并向服务注册中心注册自己。本文我们主要介绍服务的注册与发现，所以我们不妨在服务提供方中尝试着提供一个接口来获取当前所有的服务信息。

　　　　当client向server注册时，它会提供一些元数据，例如主机和端口，URL，主页等。Eureka server 从每个client实例接收心跳消息。 如果心跳超时，则通常将该实例从注册server中删除。

　　　　项目创建与上述构建方式类似，大家可以参照上述方法，再创建多一个Spring Cloud 项目。

2.1、Pom.xml

　　　　Maven 依赖 与上述类似：

<?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.jaycekon</groupId>
    <artifactId>spring-boot-cloud-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot-cloud-provider</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Dalston.SR3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.2、Application.propertties

　　通过 spring.application.name 我们可以指定 服务提供者的名称，在后续配合Ribbon 中，可以通过服务名称来调用服务。

　　eureka.client.serviceUrl.defaultZone:  对应服务注册中心的配置内容，指定服务注册中心的位置

　　server.port：服务端口号

spring.application.name=eureka-client
server.port=2001
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

2.3、Application.java

　　在 Application.java 启动类中添加 @EnableDiscoveryClient 注解，该注解能激活Eureka中的DiscoveryClient实现，这样才能实现Controller中对服务信息的输出。

大家可以看出，服务治理中，是使用的 @EnableEurekaServer 注解，这里是使用的 @EnableDiscoveryClient ，从注解我们可以看出，一个适用于标识服务治理，一个是服务提供

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SpringBootCloudProviderApplication {

    public static void main(String[] args) {

        new SpringApplicationBuilder(
                SpringBootCloudProviderApplication.class)
                .web(true).run(args);
    }
}

2.4、启动项目

　　　在启动 Productor  项目前，我们需要先启动 Eureka 服务，不然 会出现TranspoertException:

com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server

　　 原因就是找不到服务注册中心。

　　按顺序启动服务后，我们可以在Eureka 中发现，Productor 已经成注册到了 Eureka 中

2.5、访问服务

　　　　我们在 Productor 中配置一个接口，提供给客户使用，具体服务如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by Jaycekon on 2017/9/20.
 */

@RestController
public class DcController {
    @Autowired
    private DiscoveryClient discoveryClient;

    @RequestMapping("/product")
    public String product(String name) {
        return "Services: " + discoveryClient.getServices() + "name :" + name;
    }

}

　　　　DiscoveryClient 用户发现Eureka 中提供的服务，我们请求 /product  接口，查看返回结果：

　　　　通过 DiscoverClient  我们可以看到，Eureka 中提供的服务

　　

三、服务消费者

　　在Spring Cloud Commons中提供了大量的与服务治理相关的抽象接口，例如上述的DiscoverClient。在这里，我们将会学习一下 LoadBalancerClient 。

　　从 LoadBalancerClient 的命名 我们可以发现，它是一个负载均衡客户端的抽象定义，接下来我们将会实现一个简单的服务。

3.1、Pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jaycekon</groupId>
    <artifactId>spring-boot-cloud-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot-cloud-consumer</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Dalston.SR3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.2、Application.properties

spring.application.name=eureka-consumer
server.port=2101
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

3.3、Application.java

package com.jaycekon.cloud;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

3.4、服务接口

　　　大家可以发现，上述的配置，跟之前的没有太多的变化，因此我也没有做解释，相信大家都是能够看得懂的，接下来，我们需要实现服务调用接口：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * Created by Jaycekon on 2017/9/20.
 */
@RestController
public class DcController {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/consumer")
    public String consumer() {
        ServiceInstance serviceInstance = loadBalancerClient.choose("eureka-client");
        String url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/product?name=jaycekon";
        System.out.println(url);
        return new RestTemplate().getForObject(url, String.class);
    }

}

　　　大家可以看到，我们这里会通过 loadBalancerClient，来获取服务的相关地址信息。

　　　LoadBalancerClient 的choose 会通过负载均衡选出一个 “eureka-client”  服务实例，然后存储在 ServicceInstance 中，然后通过接口的调用，访问服务提供者的接口调用。

3.5、启动服务

　　 项目启动顺序：Eureka-> Productor -> Consumer

　　项目启动完成后，我们访问 http://localhost:2101/consumer：

　　可以看到，通过访问Consumer ，我们已经成功调用了Productor 的服务了。

3.6、Ribbon

　　上述事例我们讲解了使用 LoadBalancerClient  作为客户端服务端负载均衡工具，在这里我们可以了解一下使用 Ribbon 作为负载均衡。

　　首先在项目依赖上，我们需要引入Ribbon 的相关依赖：

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>

　　然后在Application 中，需要添加一个配置项：

    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }

　　在创建RestTemplate 实例时，需要引用 LoadBalanced 注解。

　　在接口调用中，实现Ribbon 调用：

@RestController
public class DcController {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/consumer")
    public String consumer() {
        ServiceInstance serviceInstance = loadBalancerClient.choose("eureka-client");
        String url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/product?name=jaycekon";
        return new RestTemplate().getForObject(url, String.class);
    }

    @GetMapping("/ribbon")
    public String ribbon() {
        return restTemplate.getForObject("http://eureka-client/product?name=jaycekon", String.class);
    }

}

　　再启动项目：

　　可以看到返回的结果是一样的，这里使用  Ribbon 的好处在于，Ribbon 会自动根据 生产者的服务名，在Eureka中找到对应的服务地址与端口。

　　当Ribbon与Eureka联合使用时，ribbonServerList会被DiscoveryEnabledNIWSServerList重写，扩展成从Eureka注册中心中获取服务实例列表。同时它也会用NIWSDiscoveryPing来取代IPing，它将职责委托给Eureka来确定服务端是否已经启动。

　

总结：

　　　　Spring Cloud 的服务相对来说会比较完善，从一开始的图中我们就可以看出，Spring cloud 提供了配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、决策竞选、分布式会话和集群状态管理等一系列的服务，其中包含了多个子项目：比如：Spring Cloud Config、Spring Cloud Netflix、Spring Cloud0 CloudFoundry、Spring Cloud AWS、Spring Cloud Security、Spring Cloud Commons、Spring Cloud Zookeeper、Spring Cloud CLI等项目。博主在后续的微服务选择上，会继续研究Spring Cloud 的知识。后续会持续更新Spring Cloud 的相关博文，希望大家支持。

　　　　博文中所用的代码可以在我的 Github 中 找到：https://github.com/jaycekon

　　　　 后续会持续更新，希望大家多多支持~~~~

参考博客 http://blog.didispace.com/Spring-Boot%E5%9F%BA%E7%A1%80%E6%95%99%E7%A8%8B/

　　　　http://blog.csdn.net/forezp/article/details/70148833