Spring Cloud是一个可以构建云应用的框架，使用该框架可以解决应用在迁移到分布式环境时所面临的众多问题。应用的微服务化目的是旨在简化开发、部署和维护的工作量，将应用程序分解可以帮助程序开发人员一次只专注于一个问题，同时在进行系统改进时不影响其它部分的运行。

另一方面，使用微服务时也带来了一些挑战：

• 配置的外部化实现，配置改变是不需要重启服务。
• 服务是如何发现的。
• 服务在不同主机上进行部署，如何隐藏其复杂性。

在本示例中我们将建立5个微服务：配置服务、注册服务、网关服务、图书管理服务和评分服务。前三个是微服务应用所需要的服务，后两个可看做业务服务。这5个微服务可做为云应用开发的基础实现，以应对上述的挑战。

1 配置服务

开发云应用程序时会遇到一个问题，如何为我们的服务维护和分发配置。我们不可能为每个环境的程序进行配置，分散的配置会影响我们的服务水平，增加安全风险漏洞。为了解决这个问题,我们将所有的配置保存到一个Git仓库，并创建一个应用服务来管理我们所有的应用程序配置。这里将建立一个非常简单的实现。

1.1 创建

创建一个Spring Boot工程，在POM中增加一个依赖

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

1.2 主应用类

@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigApplication.class, args);
    }
}

@EnableConfigServer注解 将我们的应用变为配置服务器。

1.3 配置

在src/main/resources目录下新建application.properties文件

spring.application.name=config
server.port=8081

#配置Git仓库位置
spring.cloud.config.server.git.uri=ssh://admin@localhost:29418/Test.git
#配置仓库路径下的相对搜索位置，可以配置多个
spring.cloud.config.server.git.searchPaths=application-config
#配置为true表示启动时就克隆配置缓存到本地。
spring.cloud.config.server.git.clone-on-start=true
#访问Git仓库的用户名
spring.cloud.config.server.git.username=admin
#访问Git仓库的用户密码
spring.cloud.config.server.git.password=admin

配置服务名和端口，一个Git仓库。本例中在本机搭建了一个Git仓库。
在Windows系统下搭建本地的Git服务器，可参看教程 http://blog.csdn.net/qwer971211/article/details/71156055

2 服务发现

现在我们有了配置服务，我们需要一种方法让所有的服务都能够找到彼此。我们将通过设置EUKA服务发现器来解决这个问题。由于我们的应用程序可以在任意IP/端口组合上运行，所以我们需要一个中央地址注册表，它可以用作应用程序地址查找。

当提供新的服务时，它将与服务发现器通信并注册其地址，以便其他人能够与其通信。这样，其他应用程序可以在请求时来使用这些信息。

2.1 创建

创建一个Spring Boot工程，在POM中增加依赖

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

2.2 主应用类

@SpringBootApplication
@EnableEurekaServer
public class DiscoveryApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryApplication.class, args);
    }
}

@ EnablieUrkasever将使用Netflix Eurka配置这个服务器作为服务发现器。Spring Boot将自动检测类路径上的配置依赖性，并从配置服务器中查找配置。

2.3 配置

我们将创建2个properties文件。

在src/main/resources目录下新建bootstrap.properties文件。定义服务名和配置服务器地址。

spring.cloud.config.name=discovery
spring.cloud.config.uri=http://localhost:8081

在Git仓库里保存配置discovery.properties，应用将通过配置服务器来读取这些配置。

spring.application.name=discovery
server.port=8082

eureka.instance.hostname=localhost

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

文件名必须与spring.application.name参数相同。这里定义了Eureka服务注册器的一些参数。

2.4 将配置服务注册到服务注册器里

在配置服务的POM文件里添加依赖

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

同时在application.properties文件里增加下面这些配置

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/

这样就将配置服务做为一个微服务注册到服务注册器里供其他应用来访问。

3 服务网关

现在，我们已经解决了服务配置和发现的问题，但客户端访问所有的应用服务仍然存在问题。如果我们把所有的东西都放在一个分布式系统中，那么我们将不得不管理复杂的CORS头来允许客户端的跨域请求。我们可以通过创建网关服务器来解决这个问题。它将充当一个反向代理接管从客户机到后端服务器的请求。

网关服务器在微服务体系结构中是一个很好的应用，因为它允许所有响应源于单个主机。这将消除对CORS的需求，并给我们一个方便的地方来处理常见的问题，如身份验证。

3.1 创建

创建一个Spring Boot工程，在POM中增加依赖

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

3.2 主应用类

@SpringBootApplication
@EnableZuulProxy
@EnableEurekaClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

3.3 配置

我们将创建2个properties文件。

在src/main/resources目录下新建bootstrap.properties文件。定义服务名和配置服务器地址。

spring.cloud.config.name=gateway
spring.cloud.config.discovery.service-id=config
spring.cloud.config.discovery.enabled=true
 
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/

在Git仓库里保存配置gateway.properties，应用将通过配置服务器来读取这些配置。

spring.application.name=gateway
server.port=8080

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5

zuul.routes.book-service.path=/book-service/**
zuul.routes.book-service.sensitive-headers=Set-Cookie,Authorization
hystrix.command.book-service.execution.isolation.thread.timeoutInMilliseconds=600000

zuul.routes.rating-service.path=/rating-service/**
zuul.routes.rating-service.sensitive-headers=Set-Cookie,Authorization
hystrix.command.rating-service.execution.isolation.thread.timeoutInMilliseconds=600000

zuul.routes.discovery.path=/discovery/**
zuul.routes.discovery.sensitive-headers=Set-Cookie,Authorization
zuul.routes.discovery.url=http://localhost:8082
hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds=600000

Zuul.Router属性允许我们基于URL匹配器来路由某些请求。这里的配置告诉ZUUL将访问‘/book-service/**’中的任何请求路由到服务名为‘book-service’的应用程序。ZUUL将使用应用程序名称从服务发现器中查找主机，并将请求转发给该服务器。

4 图书服务

在微服务体系结构中，我们可以自由地做出大量的应用来满足商业目标。这里我们创建一个图书服务来处理应用程序中的相关操作。

4.1 创建

创建一个Spring Boot工程，在POM中增加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

4.2 主应用类

@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/books")
public class BookServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(BookServiceApplication.class, args);
    }
 
    private List<Book> bookList = Arrays.asList(
        new Book(1L, "Spring Cloud微服务实战", "翟永超"),
        new Book(2L, "Mastering Spring Cloud", "Piotr Mińkowski")
    );
 
    @GetMapping("")
    public List<Book> findAllBooks() {
        return bookList;
    }
 
    @GetMapping("/{bookId}")
    public Book findBook(@PathVariable Long bookId) {
        return bookList.stream().filter(b -> b.getId().equals(bookId)).findFirst().orElse(null);
    }
}

在主应用类里同时添加了REST controller，提供一些REST接口。
还有一个Book的POJO类

public class Book {
    private Long id;
    private String author;
    private String title;
 
    // standard getters and setters
}

4.3 配置

我们将创建2个properties文件。

在src/main/resources目录下新建bootstrap.properties文件。定义服务名和配置服务器地址。

spring.cloud.config.name=book-service
spring.cloud.config.discovery.service-id=config
spring.cloud.config.discovery.enabled=true
 
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/

在Git仓库里保存配置book-service.properties，应用将通过配置服务器来读取这些配置。

spring.application.name=book-service
server.port=8083

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5

4.4 运行

依次启动各个服务，在浏览器中访问http://localhost:8080/book-service/books 我们得到一个JSON对象，对象里包含了在controller里定义的2本书的信息。
需要注意的是我们并没有直接访问book service的8083端口，而是通过网关服务器的8080端口进行访问。

5 评分服务

类似于图书服务，处理应用程序中与评分相关的操作。

5.1 创建

创建一个Spring Boot工程，在POM中增加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

5.2 主应用类

@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/ratings")
public class RatingServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(RatingServiceApplication.class, args);
    }

    private List<Rating> ratingList = Arrays.asList(new Rating(1L, 1L, 2), new Rating(2L, 1L, 3), new Rating(3L, 2L, 4),
            new Rating(4L, 2L, 5));

    @GetMapping("")
    public List<Rating> findRatingsByBookId(@RequestParam Long bookId) {
        return bookId == null || bookId.equals(0L) ? Collections.emptyList()
                : ratingList.stream().filter(r -> r.getBookId().equals(bookId)).collect(Collectors.toList());
    }

    @GetMapping("/all")
    public List<Rating> findAllRatings() {
        return ratingList;
    }
}

在主应用类里同时添加了REST controller，提供一些REST接口。
还有一个Rating的POJO类

public class Rating {
    private Long id;
    private Long bookId;
    private int stars;
 
    //standard getters and setters
}

5.3 配置

我们将创建2个properties文件。

在src/main/resources目录下新建bootstrap.properties文件。定义服务名和配置服务器地址。

spring.cloud.config.name=rating-service
spring.cloud.config.discovery.service-id=config
spring.cloud.config.discovery.enabled=true

eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/

在Git仓库里保存配置rating-service.properties，应用将通过配置服务器来读取这些配置。

spring.application.name=rating-service
server.port=8084

eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5

5.4 运行

依次启动各个服务，在浏览器中访问 http://localhost:8080/rating-service/ratings/all 我们得到一个JSON对象，对象里包含了在controller里定义的评分信息。
需要注意的是我们并没有直接访问rating service的8084端口，而是通过网关服务器的8080端口进行访问。

6 总结

现在我们能够将Spring Cloud各个部分组合到一个微服务应用程序中。这构成了用来构建更复杂的应用程序的基础。