springcloud必知功能使用教程

時間  2019-11-20
標籤 springcloud 功能 使用 教程 简体版
原文   原文鏈接

springcloud

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的開發便利性巧妙地簡化了分佈式系統基礎設施的開發，如服務發現註冊、配置中心、消息總線、負載均衡、斷路器、數據監控等，均可以用Spring Boot的開發風格作到一鍵啓動和部署。Spring Cloud並無重複製造輪子，它只是將目前各家公司開發的比較成熟、經得起實際考驗的服務框架組合起來，經過Spring Boot風格進行再封裝屏蔽掉了複雜的配置和實現原理，最終給開發者留出了一套簡單易懂、易部署和易維護的分佈式系統開發工具包。如今咱們一一體驗一下這些組件的功能做用。首先從服務提供者和消費者開始。javascript

Rest項目演練

  • microcloud-api 模塊，做爲公共的信息導入配置模塊；html

  • microcloud-provider-product：做爲服務提供者;java

  • microcloud-consumer：做爲微服務調用的客戶端使用;mysql

新建一個maven父項目：microcloudnginx

其中pom文件以下git

<?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>hdk</groupId>
    <artifactId>springcloud</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>microcloudapi</module>
        <module>microcloudproviderproduct</module>
        <module>microcloudconsumer</module>
    </modules>
    <properties>
        <jdk.version>1.8</jdk.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencyManagement>
    <dependencies>
    <dependency> <!-- 進行SpringCloud依賴包的導入處理 -->
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Finchley.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
    <dependency> <!-- SpringCloud離不開SpringBoot，因此必需要配置此依賴包 -->
    <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.1.2.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
    </dependencyManagement>
    <build>
        <finalName>microcloud</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${jdk.version}</source><!-- 源代碼使用的開發版本 -->
                    <target>${jdk.version}</target><!-- 須要生成的目標class文件的編譯版本 -->
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

microcloud-api

【microcloud-api】模塊，創建一個公共模板，這模塊的主要功能是提供公共處理的工具類，實體，接口等。github

pom文件以下:web

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-api</artifactId>
    <version>1.0.0</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

因爲實體對象無論是服務提供放仍是消費者都須要用到，實體對象先建立到api模塊中，建立一個Product實體
package hdk.vo;
import java.io.Serializable;
public class Product implements Serializable {

    private Long productId;
    private String productName;
    private String productDesc;

    public String getProductDesc() {
        return productDesc;
    }
    public void setProductDesc(String productDesc) {
        this.productDesc = productDesc;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public Long getProductId() {
        return productId;
    }
    public void setProductId(Long productId) {
        this.productId = productId;
    }
    @Override
    public String toString() {
        return "Product{" +
                "productId=" + productId +
                ", productName='" + productName + '\'' +
                ", productDesc='" + productDesc + '\'' +
                '}';
    }
}

因爲實體對象無論是服務提供放仍是消費者都須要用到，實體對象先建立到api模塊中，建立一個Product實體spring

package cn.hdk.vo;
import java.io.Serializable;
public class Product implements Serializable {

    private Long productId;
    private String productName;
    private String productDesc;

    public String getProductDesc() {
        return productDesc;
    }
    public void setProductDesc(String productDesc) {
        this.productDesc = productDesc;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public Long getProductId() {
        return productId;
    }
    public void setProductId(Long productId) {
        this.productId = productId;
    }
    @Override
    public String toString() {
        return "Product{" +
                "productId=" + productId +
                ", productName='" + productName + '\'' +
                ", productDesc='" + productDesc + '\'' +
                '}';
    }
}

服務提供方

建立一個Product Rest提供者的項目模塊,這個模塊對應的數據庫腳本以下sql

CREATE DATABASE springcloud CHARACTER SET UTF8 ;
USE springcloud ;
CREATE TABLE product (
prodcutId BIGINT AUTO_INCREMENT ,
productName VARCHAR(50) ,
 productDesc VARCHAR(50) ,
CONSTRAINT pk_prodcut_id PRIMARY KEY(prodcutId)
) ;

INSERT INTO product(productName,productDesc) VALUES ('電子鎖骨',database()) ;
INSERT INTO product(productName,productDesc) VALUES ('Springboot',database()) ;
INSERT INTO product(productName,productDesc) VALUES ('水錶',database()) ;
INSERT INTO product(productName,productDesc) VALUES ('門禁',database()) ;
INSERT INTO product(productName,productDesc) VALUES ('攝像頭',database()) ;

【microcloud-provider-product】模塊繼續使用mybaits對數據庫進行操做，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <version>1.0.0</version>

    <artifactId>microcloud-provider-product</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-provider-product】建立一個ProductMapper對數據庫的操做接口，這個接口方法特別簡單

package hdk.mapper;
import hdk.vo.Product;
import java.util.List;
public interface ProductMapper {
    boolean create(Product product);
    public Product findById(Long id);
    public List<Product> findAll();
}

【microcloud-provider-product】新增修改application.yml文件，追加對mybatis以及數據庫的支持

server:
 port: 8080
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.cj.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: 111111% # 數據庫鏈接密碼
logging:
  level:
hdk.mapper: debug

【microcloud-provider-product】建立修改src/main/resources/mapping/ProductMapper.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="hdk.mapper.ProductMapper">
    <select id="findById" resultType="cn.hdk.vo.Product" parameterType="long">
        select productId,productName,productDesc from product WHERE productId=#{id} ;
    </select>
    <select id="findAll" resultType="cn.hdk.vo.Product">
        SELECT productId,productName,productDesc from product;
    </select>
    <insert id="create" parameterType="cn.hdk.vo.Product">
        INSERT INTO product(productName,productDesc) VALUES (#{productName},database()) ;
    </insert>
</mapper>

【microcloud-provider-product】創建IProductService接口，並建立相關實現類

package hdk.service;
import hdk.vo.Product;
import java.util.List;
public interface IProductService {
    Product get(long id);
    boolean add(Product product);
    List<Product> list();
}


package hdk.service.impl;

import hdk.mapper.ProductMapper;
import hdk.service.IProductService;
import hdk.vo.Product;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

@Service
public class ProductServiceImpl implements IProductService {

    @Resource
    private ProductMapper productMapper;

    @Override
    public Product get(long id) {
        return productMapper.findById(id);
    }

    @Override
    public boolean add(Product product) {
        return productMapper.create(product);
    }

    @Override
    public List<Product> list() {
        return productMapper.findAll();
    }
}

【microcloud-provider-product】 定義主程序類，並定義好mapper掃描包

package hdk;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("hdk.mapper")
public class ProductApp{
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

【microcloud-provider-product】編寫單元測試

package hdk;
import hdk.service.IProductService;
import hdk.vo.Product;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

@SpringBootTest(classes = ProductApp.class)
@RunWith(SpringRunner.class)
public class ProductServiceTest {
    @Resource
    private IProductService iProductService;
    @Test
    public void testGet() {
        System.out.println(iProductService.get(1));
    }
    @Test
    public void testAdd() {
        Product dept = new Product() ;
        dept.setProductName("lison-" + System.currentTimeMillis());
        System.out.println(iProductService.add(dept));
    }
    @Test
    public void testList() {
        System.out.println(iProductService.list());
    }
}

【microcloud-provider-product】創建ProductController創建一個Rest服務類

package hdk.controller;
import hdk.service.IProductService;
import hdk.vo.Product;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
@RestController
@RequestMapping("/prodcut")
public class ProductController {

    @Resource
    private IProductService iProductService;

    @RequestMapping(value="/get/{id}")
    public Object get(@PathVariable("id") long id) {
        return this.iProductService.get(id) ;
    }
    @RequestMapping(value="/add")
    public Object add(@RequestBody Product product) {
        return this.iProductService.add(product) ;
    }
    @RequestMapping(value="/list")
    public Object list() {
        return this.iProductService.list() ;
    }
}

瀏覽器訪問：

調用get請求：localhost:8080/product/get/1

調用list請求：localhost:8080/product/list

服務消費方

建立一個maven新模塊：【microcloud-consumer】這個模塊做爲服務的消費方，調用前面的product服務

【microcloud-consumer】修改pom文件，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>microcloud-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-consumer】修改application.yml配置文件

server:

port: 80

【microcloud-consumer】建立Rest配置類，在這須要調用Rest服務，通常須要用到RestTemplate類對象

package hdk.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestConfig {
    @Bean
    public RestTemplate restTemplate() {
        return  new RestTemplate();
    }
}

【microcloud-consumer】新建一個controller，負責使用RestTemplate調用遠程的product服務

package hdk.controller;

import hdk.vo.Product;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {
    public static final String PRODUCT_GET_URL = "http://localhost:8080/prodcut/get/";
    public static final String PRODUCT_LIST_URL="http://localhost:8080/prodcut/list/";
    public static final String PRODUCT_ADD_URL = "http://localhost:8080/prodcut/add/";
    @Resource
    private RestTemplate restTemplate;

    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        Product product = restTemplate.getForObject(PRODUCT_GET_URL + id, Product.class);
        return  product;
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        List<Product> list = restTemplate.getForObject(PRODUCT_LIST_URL, List.class);
        return  list;
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        Boolean result = restTemplate.postForObject(PRODUCT_ADD_URL, product, Boolean.class);
        return  result;
    }
}

【microcloud-consumer】編寫啓動類

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ConsumerApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp.class,args);
    }
}

調用測試

新增：http://localhost/consumer/product/add?productName=lison

列表查詢：http://localhost/consumer/product/list

得到單個數據：http://localhost/consumer/product/get?id=1

SpringSecurity

前面使用了RestTemplate進行遠程接口調用，但要注意，這些Rest服務最終均可能暴露在公網的，任何人均可能調用，若是你的Rest服務屬於一些私密信息，這樣會致使信息的泄露。

若是想進行安全方面的處理，首先要在服務的提供方上進行處理。

【microcloud-provider-product】修改pom文件，追加 SpringSecurity 相關依賴信息

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
</dependency>

【microcloud-provider-product】修改application.yml配置文件，進行安全的用戶名配置

spring: 
 security:
   user:
     name: admin  # 認證用戶名
     password: hdk  # 認證密碼
     roles:
      - USER # 受權角色

在項目中訪問rest接口，localhost:8080/product/list，這個時候會要求先輸入用戶名以及密碼才能容許訪問

服務消費方處理

【microcloud-consumer】 修改RestConfig配置類，在裏面添加 HttpHeaders 的配置信息

package cn.hdk.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Base64;

@Configuration
public class RestConfig {

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

    @Bean
    public HttpHeaders getHeaders() { // 要進行一個Http頭信息配置
        HttpHeaders headers = new HttpHeaders(); // 定義一個HTTP的頭信息
        String auth = "admin:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        headers.set("Authorization", authHeader);
        return headers;
    }
}

【microcloud-consumer】 修改ConsumerProductController，在進行服務端調用的時候加上這個頭信息

package hdk.controller;


import hdk.vo.Product;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {
    public static final String PRODUCT_GET_URL = "http://localhost:8080/prodcut/get/";
    public static final String PRODUCT_LIST_URL="http://localhost:8080/prodcut/list/";
    public static final String PRODUCT_ADD_URL = "http://localhost:8080/prodcut/add/";

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private HttpHeaders httpHeaders;

    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        Product product = restTemplate.exchange(PRODUCT_GET_URL + id,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), Product.class).getBody();
        return  product;
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        List<Product> list = restTemplate.exchange(PRODUCT_LIST_URL,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), List.class).getBody();
        return  list;
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        Boolean result = restTemplate.exchange(PRODUCT_ADD_URL, HttpMethod.POST,new HttpEntity<Object>(product,httpHeaders), Boolean.class).getBody();
        return  result;
    }
}

調用測試

新增：http://localhost/consumer/product/add?productName=lison

列表查詢：http://localhost/consumer/product/list

得到單個數據：http://localhost/consumer/product/get?id=1

microcloud-security模塊

如今服務提供方只有一個Product服務，但真實的項目開發中必然有多個服務提供方，絕大多數狀況下，這些服務都會用到安全驗證，並且密碼也會同樣，若是每一個服務都單獨維護，每次密碼變更改動都會很大，因此應該單獨創建一個安全驗證的模塊

建立一個microcloud-security模塊，修改其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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <version>1.0.0</version>

    <artifactId>microcloud-security</artifactId>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

【springcloud】修改父工程pom文件，把相應的版本依賴加到裏面

<dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-security</artifactId>
            <version>1.0.0</version>
        </dependency>

【microcloud-security】創建一個統一的安全配置類，這個類負責用戶以及密碼相關的配置

package hdk.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(AuthenticationManagerBuilder auth)
            throws Exception {
                auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder()).withUser("root").password(new BCryptPasswordEncoder().encode("hdk")).roles("USER").
                        and().withUser("admin").password(new BCryptPasswordEncoder().encode("hdk")).roles("USER", "ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {


        http.httpBasic().and().authorizeRequests().anyRequest()
                .fullyAuthenticated();
        http.sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

}

【microcloud-provider-product】修改pom文件，刪除spring-boot-starter-security的依賴信息，並加入本身定義的microcloud-security依賴

<!--<dependency>-->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!--<artifactId>spring-boot-starter-security</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-security</artifactId>
        </dependency>

【microcloud-provider-product】修改application.yml，刪除與安全相關的配置項。

# security:
#   user:
#     roles:
#      - USER # 受權角色
#     name:  root
#     password:  hdk

調用測試

新增：http://localhost/consumer/product/add?productName=lison

列表查詢：http://localhost/consumer/product/list

得到單個數據：http://localhost/consumer/product/get?id=1

Eureka服務註冊與發現

Eureka 服務端

新建一個microcloud-eureka模塊，這模塊作的事情很是簡單，既啓動Eureka的服務端，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-eureka</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-eureka】修改application.yml文件，在裏面配置eureka相關信息

server:
 port: 7001
eureka:
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱

【microcloud-eureka】新增Eureka啓動類，增長Eureka服務端註解

package hdk;

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

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

在瀏覽器上執行

http://localhost:7001/

服務提供方註冊到Eureka

【microcloud-provider-product】修改pom文件，增長eureka客戶端相關信息

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

【microcloud-provider-product】修改application.yml配置文件，在者個文件中定義要註冊的eureka服務的地址

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://localhost:7001/eureka

【microcloud-provider-product】修改啓動類，在這個類上增長eureka客戶端的註解信息

package hdk;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@MapperScan("cn.hdk.mapper")
@EnableEurekaClient
public class ProductApp{
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

啓動後發現Application的名字是UNKNOWN，爲此應該爲這單獨取一個名字
【microcloud-provider-product】修改application.yml配置文件，爲這個微服務起一個名字

spring:
 application:
   name: microcloud-provider-product

【microcloud-provider-product】修改application.yml配置文件，追加主機名稱的顯示：

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: microcloud-provider-product

【microcloud-provider-product】修改application.yml配置文件

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: microcloud-provider-product
    prefer-ip-address: true #顯示IP

【microcloud-provider-product】若是想看狀態信息須要增長actuator模塊，這一塊的內容已經在講springboot的時候講過，修改pom文件，增長

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

【microcloud-provider-product】修改application.yml文件，追加info相關配置

info:
  app.name: microcloud-provider-product
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

注意：因爲在yml文件中使用了$，這個時候啓動是會報錯的，所以還須要一個maven-resources-plugin插件的支持

【microcloud】在父工程增長插件，修改pom文件

<build>
        <finalName>microcloud</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <delimiters>
                        <delimiter>$</delimiter>
                    </delimiters>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${jdk.version}</source><!-- 源代碼使用的開發版本 -->
                    <target>${jdk.version}</target><!-- 須要生成的目標class文件的編譯版本 -->
                </configuration>
            </plugin>
        </plugins>
    </build>

啓動後：

另外在關閉【microcloud-provider-product】項目後，刷新eureka發現項目還在，隔一段時間後會發現

這其實就是觸發了安全模式

【microcloud-eureka】設置服務的清理間隔時間，修改application.yml文件

server:
 port: 7001
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱

【microcloud-provider-product】修改application.yml配置

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: microcloud-provider-product
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）

因爲全部的服務都註冊到了 Eureka 之中

這樣若是配置了「lease-expiration-duration-in-seconds」此選項，

表示距離上一次發送心跳以後等待下一次發送心跳的間隔時間，若是超過了此間隔時間，則認爲該微服務已經宕機了。

【microcloud-provider-product】對於註冊到 Eureka 上的服務，能夠經過發現服務來獲取一些服務信息，修改ProductController，增長一個方法

package hdk.controller;


import cn.hdk.service.IProductService;
import cn.hdk.vo.Product;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;

@RestController
@RequestMapping("/prodcut")
public class ProductController {

    @Resource
    private IProductService iProductService;

    @Resource
    private DiscoveryClient client ; // 進行Eureka的發現服務

    @RequestMapping(value="/get/{id}")
    public Object get(@PathVariable("id") long id) {
        return this.iProductService.get(id) ;
    }
    @RequestMapping(value="/add")
    public Object add(@RequestBody Product product) {
        return this.iProductService.add(product) ;
    }
    @RequestMapping(value="/list")
    public Object list() {
        return this.iProductService.list() ;
    }


    @RequestMapping("/discover")
    public Object discover() { // 直接返回發現服務信息
        return this.client ;
    }
}

【microcloud-provider-product】修改ProductApp， 在主程序中啓用發現服務項

package hdk;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@MapperScan("cn.hdk.mapper")
@EnableEurekaClient
@EnableDiscoveryClient
public class ProductApp{
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

訪問：localhost:8080/prodcut/discover

Eureka 安全機制

通常狀況下Eureka 和服務的提供註冊者都會在一個內網環境中，但免不了在某些項目中須要讓其餘外網的服務註冊到Eureka，這個時候就有必要讓Eureka增長一套安全認證機制了，讓全部服務提供者經過安全認證後才能註冊進來

【microcloud-eureka】修改pom文件，引入SpringSecurity的依賴包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

【microcloud-eureka】 修改application.yml文件，增長用戶、密碼驗證

server:
 port: 7001
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@localhost:7001/eureka
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱

spring:
  security:
    user:
      name: admin
      password: hdk

【microcloud-provider-product】修改application.yml文件，增長驗證信息

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@localhost:7001/eureka
  instance:
    instance-id: microcloud-provider-product
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）

【microcloud-eureka】新增配置類EurekaSecurityConfig，重寫configure方法，把csrf劫持關閉

package hdk;


import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class EurekaSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
        super.configure(http);
    }
}

HA 高可用

如今的Eureka仍是單節點的狀況，若是Eureka出現了錯誤，將會致使整個集羣沒法繼續使用，這個時候就須要考慮Eureka的高可用了。

如今須要3個eureka ，每一個eureka都須要配置hostname,全部先修改hosts文件內容以下

127.0.0.1 eureka1

127.0.0.1 eureka2

127.0.0.1 eureka3

【microcloud-eureka】爲了方便操做，講microcloud-eureka項目複製兩份，分別複製爲【microcloud-eureka2】、 【microcloud-eureka2】

【microcloud-eureka】修改application.yml配置文件，修改端口以及註冊位置

server:
 port: 7001
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        #defaultZone: http://admin:hdk@localhost:7001/eureka
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka1 # 定義 Eureka 實例所在的主機名稱

spring:
  security:
    user:
      name: admin
      password: hdk

【microcloud-eureka2】修改application.yml配置文件

server:
 port: 7002
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        #defaultZone: http://admin:hdk@localhost:7001/eureka
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka2 # 定義 Eureka 實例所在的主機名稱

spring:
  security:
    user:
      name: admin
      password: hdk

【microcloud-eureka3】修改application.yml配置文件

server:
 port: 7003
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        #defaultZone: http://admin:hdk@localhost:7001/eureka
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka3 # 定義 Eureka 實例所在的主機名稱

spring:
  security:
    user:
      name: admin
      password: hdk

啓動eureka,eureka2,eureka3，進入服務的後臺查看副本

登錄http://localhost:7001/

【microcloud-provider-product】修改application.yml配置文件，配置多臺enreka的註冊

server:
 port: 8080
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.cj.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: root1234% # 數據庫鏈接密碼
 application:
   name: microcloud-provider-product
# security:
#   user:
#     roles:
#      - USER # 受權角色
#     name:  root
#     password:  hdk

logging:
  level:
    cn.hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      #defaultZone: http://admin:hdk@localhost:7001/eureka
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance:
    instance-id: microcloud-provider-product
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）

info:
  app.name: microcloud-provider-product
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

打包發佈

在項目中，須要講Eureka發佈到具體服務器上進行執行，打包部署其實和springboot裏面講的大同小異和properties文件稍微有點不一樣，對於properties文件，不一樣的環境會有不一樣的配置文件好比application-dev.properties，application-test.properties,application-pro.properties等
但若是是yml文件，全部的的配置都再同一個yml文件中

【microcloud-eureka】修改application.yml文件

spring:
  profiles:
    active:
      - dev-7001

---
server:
 port: 7001
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka1 # 定義 Eureka 實例所在的主機名稱
spring:
  profiles: dev-7001
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-eureka

---
server:
 port: 7002
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka2 # 定義 Eureka 實例所在的主機名稱
spring:
  profiles: dev-7002
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-eureka2

---
server:
 port: 7003
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance: # eureak實例定義
    hostname: eureka3 # 定義 Eureka 實例所在的主機名稱
spring:
  profiles: dev-7003
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-eureka3

【microcloud-eureka】添加一個打包插件，修改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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-eureka</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>eureka-server</finalName>
        <plugins>
            <plugin> <!-- 該插件的主要功能是進行項目的打包發佈處理 -->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration> <!-- 設置程序執行的主類 -->
                    <mainClass>cn.hdk.EurekaApp</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

【microcloud-eureka】 在pom文件所在目錄

mvn clean install package

接下來就能夠在項目的編譯目錄發現

eureka-server.jar 文件

採用默認的方式執行 eureka-server.jar那麼此時將運行在 7001 端口上：java -jar eureka-server.jar

運行其它的兩個 profile 配置：

· 運行「dev-7002」profile：java -jar eureka-server.jar --spring.profiles.active=dev-7002；

· 運行「dev-7003」profile：java -jar eureka-server.jar --spring.profiles.active=dev-7003

Ribbon負載均衡

如今服務提供方已經能夠經過Eureka進行註冊了，但對於服務的消費者，目前並無處理，對於服務的消費方，也應該鏈接上eureka，進行服務的獲取，這個時候就應該使用Ribbon這個組件了

ribbon對應的pom文件以下

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

Ribbon基本使用

【microcloud-consumer】 修改pom文件，增長eureka的支持

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-consumer】 修改RestConfig配置類，在獲取RestTemplate對象的時候加入Ribbon的配置信息

package cn.hdk.config;


import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Base64;

@Configuration
public class RestConfig {

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

    @Bean
    public HttpHeaders getHeaders() { // 要進行一個Http頭信息配置
        HttpHeaders headers = new HttpHeaders(); // 定義一個HTTP的頭信息
        String auth = "root:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        headers.set("Authorization", authHeader);
        return headers;
    }

}

【microcloud-consumer】 修改RestConfig配置類，在獲取RestTemplate對象的時候加入Ribbon的配置信息```

server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka

【microcloud-consumer】修改項目啓動類，增長Eureka客戶端的配置註解

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

【microcloud-consumer】 修改ConsumerProductController控制器

如今在eureka中註冊的服務名稱都是大寫字母：

MICROCLOUD-PROVIDER-PRODUCT

package hdk.controller;


import hdk.vo.Product;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {

    public static final String PRODUCT_GET_URL = "http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/get/";
    public static final String PRODUCT_LIST_URL="http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/list/";
    public static final String PRODUCT_ADD_URL = "http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/add/";

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private HttpHeaders httpHeaders;

    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        Product product = restTemplate.exchange(PRODUCT_GET_URL + id,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), Product.class).getBody();
        return  product;
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        List<Product> list = restTemplate.exchange(PRODUCT_LIST_URL,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), List.class).getBody();
        return  list;
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        Boolean result = restTemplate.exchange(PRODUCT_ADD_URL, HttpMethod.POST,new HttpEntity<Object>(product,httpHeaders), Boolean.class).getBody();
        return  result;
    }


}

訪問地址：http://localhost/consumer/product/list

這個時候Ribbon與Eureka已經整合成功

Ribbon負載均衡的實現

經過上面的代碼發現咱們用到了一個註解@LoadBalanced，根據這名字大概就能知道Ribbon是能夠實現負載均衡的

【microcloud-provider-product】 複製兩份

分別爲【microcloud-provider-product2】與【microcloud-provider-product3】

【springcloud數據庫】複製兩份

分別爲【springcloud2數據庫】【springcloud3數據庫】 裏面分別執行spingcloud數據庫的腳本

【microcloud-provider-product2】修改application.yml文件以下

server:
 port: 8081
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.cj.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud2?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: root1234% # 數據庫鏈接密碼
 application:
   name: microcloud-provider-product
# security:
#   user:
#     roles:
#      - USER # 受權角色
#     name:  root
#     password:  hdk

logging:
  level:
    hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      #defaultZone: http://admin:hdk@localhost:7001/eureka
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance:
    instance-id: microcloud-provider-product2
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）



info:
  app.name: microcloud-provider-product2
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

【microcloud-provider-product3】修改application.yml文件以下

server:
 port: 8082
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.cj.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud3?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: root1234% # 數據庫鏈接密碼
 application:
   name: microcloud-provider-product
# security:
#   user:
#     roles:
#      - USER # 受權角色
#     name:  root
#     password:  hdk

logging:
  level:
    cn.hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      #defaultZone: http://admin:hdk@localhost:7001/eureka
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance:
    instance-id: microcloud-provider-product3
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）



info:
  app.name: microcloud-provider-product3
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

分別啓動3個服務提供方，訪問

http://localhost:8080/product/get/1

http://localhost:8081/product/get/1

http://localhost:8082/product/get/1

確認3個服務是能正確提供訪問的

【microcloud-consumer】啓動
訪問：http://localhost/consumer/product/list

自定義Ribbon路由

前面已經使用Ribbon實現了路由，經過測試，也不難發現默認Ribbon使用的路由策略是輪詢，能夠看下源代碼BaseLoadBalancer

全局路由配置

這種負載均衡的策略其實也是能夠由用戶來修改的，若是想要去修改，可使用自定義的LoadBalance

【microcloud-consumer】 修改RestConfig

package hdk.config;


import com.netflix.loadbalancer.IRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Base64;

@Configuration
public class RestConfig {

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

    @Bean
    public HttpHeaders getHeaders() { // 要進行一個Http頭信息配置
        HttpHeaders headers = new HttpHeaders(); // 定義一個HTTP的頭信息
        String auth = "root:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        headers.set("Authorization", authHeader);
        return headers;
    }

    @Bean
    public IRule ribbonRule() { // 其中IRule就是全部規則的標準
        return new com.netflix.loadbalancer.RandomRule(); // 隨機的訪問策略
    }

}

這個時候重啓測試發現，默認的路由規則已經變成了隨機

單獨設置某個Ribbon的路由

有時候，某個消費者可能須要訪問多個多個服務提供方，而但願每一個服務提供方提供的路由規則並不相同，這個時候就不能讓Spring掃描到IRULE，須要經過@RibbonClient 來指定服務於配置的關係
【microcloud-consumer】 修改RestConfig，刪除IRULE

package cn.hdk.config;


import com.netflix.loadbalancer.IRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Base64;

@Configuration
public class RestConfig {

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

    @Bean
    public HttpHeaders getHeaders() { // 要進行一個Http頭信息配置
        HttpHeaders headers = new HttpHeaders(); // 定義一個HTTP的頭信息
        String auth = "root:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        headers.set("Authorization", authHeader);
        return headers;
    }

//    @Bean
//    public IRule ribbonRule() { // 其中IRule就是全部規則的標準
//        return new com.netflix.loadbalancer.RandomRule(); // 隨機的訪問策略
//    }

}

【microcloud-consumer】新增一個路由規則的配置類，注意這個類不該該放到SpringCloud掃描不到的位置，不然又回變成全局的IRULE，因此這個時候應該單獨使用一個新的包，着個包和啓動並不在同一個包下

package hdk.config;
import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;

public class RibbonConfig {
    @Bean
    public IRule ribbonRule() { // 其中IRule就是全部規則的標準
        return new com.netflix.loadbalancer.RandomRule(); // 隨機的訪問策略
    }
}

【microcloud-consumer】 修改啓動類，使用@RibbonClient指定配置類

package hdk;
import hdkconfig.RibbonConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.ribbon.RibbonClients;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name ="MICROCLOUD-PROVIDER-PRODUCT" ,configuration = RibbonConfig.class)
public class ConsumerApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp.class,args);
    }
}

這裏的name 只服務的名稱，若是須要有多個服務提供方，這個時候可使用@RibbonClients進行配置

服務提供方的信息獲取

在服務的消費方，也是能夠獲取到服務提供方的具體信息

【microcloud-consumer】修改ConsumerProductController

package cn.hdk.controller;


import cn.hdk.vo.Product;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {

    public static final String PRODUCT_GET_URL = "http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/get/";
    public static final String PRODUCT_LIST_URL="http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/list/";
    public static final String PRODUCT_ADD_URL = "http://MICROCLOUD-PROVIDER-PRODUCT/prodcut/add/";

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private HttpHeaders httpHeaders;

    @Resource
    private LoadBalancerClient loadBalancerClient;

    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        Product product = restTemplate.exchange(PRODUCT_GET_URL + id,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), Product.class).getBody();
        return  product;
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        ServiceInstance serviceInstance = this.loadBalancerClient.choose("MICROCLOUD-PROVIDER-PRODUCT") ;
        System.out.println(
                "【*** ServiceInstance ***】host = " + serviceInstance.getHost()
                        + "、port = " + serviceInstance.getPort()
                        + "、serviceId = " + serviceInstance.getServiceId());
        List<Product> list = restTemplate.exchange(PRODUCT_LIST_URL,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), List.class).getBody();
        return  list;
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        Boolean result = restTemplate.exchange(PRODUCT_ADD_URL, HttpMethod.POST,new HttpEntity<Object>(product,httpHeaders), Boolean.class).getBody();
        return  result;
    }

}

脫離Eureka使用Ribbon

以前所用Ribbon都是從Eureka中獲取服務並經過@LoadBalanced來實現負載均衡的，其實Ribbon也能夠脫離Eureka來使用

複製【microcloud-consumer】 成一個新的模塊【microcloud-consumer-ribbon】

【microcloud-consumer-ribbon】 修改pom文件，刪除eureka的依賴添加ribbon的依賴

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-consumer-ribbon</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--<dependency>-->
            <!--<groupId>org.springframework.cloud</groupId>-->
            <!--<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-consumer-ribbon】 修改application.yml配置文件

server:
 port: 80

ribbon:
eureka:
 enabled: false

MICROCLOUD-PROVIDER-PRODUCT:
ribbon:
  listOfServers: http://localhost:8080,http://localhost:8081,http://localhost:8082

【microcloud-consumer-ribbon】 修改 RestConfig，刪除@LoadBalanced註解

package hdk.config;


import com.netflix.loadbalancer.IRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Base64;

@Configuration
public class RestConfig {

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

    @Bean
    public HttpHeaders getHeaders() { // 要進行一個Http頭信息配置
        HttpHeaders headers = new HttpHeaders(); // 定義一個HTTP的頭信息
        String auth = "root:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        headers.set("Authorization", authHeader);
        return headers;
    }


}

【microcloud-consumer-ribbon】修改ConsumerProductController，修改服務的調用URI

package hdk.controller;


import cn.hdk.vo.Product;
import cn.xiangxue.config.RibbonConfig;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.net.URI;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {

    public static final String PRODUCT_TOPIC = "MICROCLOUD-PROVIDER-PRODUCT";

    @Resource
    private RestTemplate restTemplate;

    @Resource
    private HttpHeaders httpHeaders;

    @Resource
    private LoadBalancerClient loadBalancerClient;


    @RequestMapping("/product/list")
    public  Object listProduct() {
        ServiceInstance serviceInstance = this.loadBalancerClient.choose(PRODUCT_TOPIC) ;
        System.out.println(
                "【*** ServiceInstance ***】host = " + serviceInstance.getHost()
                        + "、port = " + serviceInstance.getPort()
                        + "、serviceId = " + serviceInstance.getServiceId());

        URI uri = URI.create(String.format("http://%s:%s/prodcut/list/" ,
                serviceInstance.getHost(), serviceInstance.getPort()));

        List<Product> list = restTemplate.exchange(uri,HttpMethod.GET,new HttpEntity<Object>(httpHeaders), List.class).getBody();
        return  list;
    }
}

​ 【microcloud-consumer-ribbon】啓動

訪問：http://localhost/consumer/product/list

Feign接口服務

前面已經學習了Ribbon,從Eureka獲取服務的實例在經過RestTemplate調用，並轉換成須要的對象

List list = restTemplate.exchange(PRODUCT_LIST_URL,HttpMethod.GET,new HttpEntity (httpHeaders), List.class).getBody();

能夠發現全部的數據調用和轉換都是由用戶直接來完成的，咱們可能不想直接訪問Rest接口，若是轉換回來的直接是對象而不須要直接使用RestTemplate進行轉換就行了，這個時候就須要使用Feign了

Feign基本使用

複製【microcloud-consumer】 成一個新的模塊【microcloud-consumer-feign】

【microcloud-consumer-feign】修改pom文件，增長對feign的支持

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-consumer-feign</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-service】，新創建一個microcloud-service模塊，這個模塊專門定義客戶端的調用接口

【microcloud-service】，修改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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-service</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-service】若是要經過Feign進行遠程調用，依然須要安全服務提供方的認證問題，不過在feign裏面已經集成了這塊功能

package hdk.feign;
import feign.auth.BasicAuthRequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FeignClientConfig {
    @Bean
    public BasicAuthRequestInterceptor getBasicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor("admin", "hdk");
    }
}

【microcloud-service】 新建一個IProductClientService接口

package cn.hdk.service;

import cn.hdk.feign.FeignClientConfig;
import cn.hdk.vo.Product;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;
@FeignClient(name = "MICROCLOUD-PROVIDER-PRODUCT",configuration = FeignClientConfig.class)
public interface IProductClientService {
    @RequestMapping("/product/get/{id}")
    public Product getProduct(@PathVariable("id")long id);

    @RequestMapping("/product/list")
    public  List<Product> listProduct() ;

    @RequestMapping("/product/add")
    public boolean addPorduct(Product product) ;

}

【microcloud-consumer-feign】 修改pom文件，引入microcloud-service 包

<dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-service</artifactId>
        </dependency>

【microcloud-consumer-feign】 因爲microcloud-service裏面已經作了安全驗證，而且後面並不直接使用RestTemplate ,刪除RestConfig.java類

【microcloud-consumer-feign】 修改ConsumerProductController，這個時候直接使用microcloud-service定義的服務就能夠了

package hdk.controller;


import hdk.service.IProductClientService;
import cn.hdk.vo.Product;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {
    @Resource
    private IProductClientService iProductClientService;

    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        return  iProductClientService.getProduct(id);
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        return iProductClientService.listProduct();
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        return  iProductClientService.addPorduct(product);
    }
    
}

【microcloud-consumer-feign】修改程序主類

package hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients("hdk.service")
public class ConsumerFeignApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerFeignApp.class,args);
    }
}

啓動測試:

http://localhost/consumer/product/list

能夠作個測試，看下是否真的如此

【microcloud-consumer-feign】修改程序主類

package hdk;

import cn.xiangxue.config.RibbonConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients("cn.hdk.service")
@RibbonClient(name ="MICROCLOUD-PROVIDER-PRODUCT" ,configuration = RibbonConfig.class)
public class ConsumerFeignApp {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerFeignApp.class,args);
    }
}

啓動測試:

http://localhost/consumer/product/list

能夠發現，如今的路由規則以及變成了隨機訪問

其餘配置

數據壓縮

前面咱們已經知道Feign之中最核心的做用就是將Rest服務的信息轉化爲接口，這其中還有其餘的一些地方應該要考慮，好比：數據的壓縮
Rest協議更多的傳輸的是文本，JSON或者XML，若是用戶發送的請求很大，這個時候有必要對數據進行壓縮處理，好在feign自己就提供了壓縮的支持
雖然Feign支持壓縮，但默認是不開啓的
再看下FeignClientEncodingProperties，能夠根據這裏面的屬性進行相關壓縮的配置

【microcloud-consumer-feign】 修改application.yml配置文件

feign:
 compression:
  request:
    enabled: true
    mime-types: # 能夠被壓縮的類型
     - text/xml
     - application/xml
     - application/json
    min-request-size: 2048 # 超過2048的字節進行壓縮

日誌配置

在構建@FeignClient註解修飾的服務客戶端時，會爲一個客戶端都建立一個feign.Logger實例，能夠利用日誌來分析Feign的請求細節，不過默認

【microcloud-consumer-feign】 修改 application.yml配置文件，增長日誌信息

logging:
 level:
  cn.hdk.service: DEBUG

【microcloud-service】修改FeignClientConfig，開啓日誌輸出

package hdk.feign;


import feign.Logger;
import feign.auth.BasicAuthRequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignClientConfig {

    @Bean
    public Logger.Level getFeignLoggerLevel() {
        return feign.Logger.Level.FULL ;
    }

    @Bean
    public BasicAuthRequestInterceptor getBasicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor("admin", "hdk");
    }
}

小結

  • 當使用 Feign 要經過接口的方法訪問 Rest 服務的時候會根據設置的服務類型發出請求，這個請求是發送給 Eureka

  • 隨後因爲配置了受權處理，因此繼續發送受權信息（「Authorization」）

其實在外面使用RestTemplate的時候也是這麼作的，能夠對應日誌的加密內容和直接訪問實際上是同樣的。

  • 在進行服務調用的時候 Feign 融合了 Ribbon 技術，因此也支持有負載均衡的處理

Feign = RestTempate + HttpHeader + Ribbon + Eureka 綜合體，使用feign大大增長了代碼的靈活程度

Hystrix 熔斷機制

在分佈式環境下，微服務之間不可避免的發生互相調用的狀況，可是沒有一個系統是能保證自身絕對正確的，在服務的調用過程當中，極可能面臨服務失敗的問題，所以須要一個公共組件可以在服務經過網絡請求訪問其餘微服務時，能對服務失效狀況下有很強的容錯能力，對微服務提供保護和監控。

Hystrix是netflix的一個開源項目，他可以在依賴服務失效的狀況下，經過隔離系統依賴的方式，防止服務的級聯失敗（服務的雪崩）

對於服務的熔斷機制，其實須要考慮兩種狀況

    1. 服務提供方存活，但調用接口報錯
    1. 服務提供方自己就出問題了

服務提供方報錯

其實這種狀況相似於異常捕獲機制，當出現異常，返回一個通用的接口報文

【microcloud-provider-product】 複製一份成爲【microcloud-provider-product-hystrix】

【microcloud-provider-product-hystrix】修改pom文件，增長 Hystrix依賴

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

【microcloud-provider-product-hystrix】 修改ProductController

package hdk.controller;

import hdk.service.IProductService;
import hdk.vo.Product;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;

@RestController
@RequestMapping("/product")
public class ProductController {

    @Resource
    private IProductService iProductService;

    @Resource
    private DiscoveryClient client ; // 進行Eureka的發現服務

    @RequestMapping(value="/get/{id}")
    @HystrixCommand(fallbackMethod = "getFallback")
    public Object get(@PathVariable("id") long id) {
        Product product = this.iProductService.get(id);
        if(product == null) {
            throw new RuntimeException("該產品已下架！") ;
        }
        return  product;
    }

    public Object  getFallback(@PathVariable("id") long id){
        Product product = new Product();
        product.setProductName("HystrixName");
        product.setProductDesc("HystrixDesc");
        product.setProductId(0L);
        return product;
    }


    @RequestMapping(value="/add")
    public Object add(@RequestBody Product product) {
        return this.iProductService.add(product) ;
    }
    @RequestMapping(value="/list")
    public Object list() {
        return this.iProductService.list() ;
    }


    @RequestMapping("/discover")
    public Object discover() { // 直接返回發現服務信息
        return this.client ;
    }
}

一旦 get()方法上拋出了錯誤的信息，那麼就認爲該服務有問題
會默認使用「@HystrixCommand」註解之中配置好的fallbackMethod 調用類中的指定方法，返回相應數據

【microcloud-provider-product-hystrix】修改啓動類，增長對熔斷的支持

package hdk;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@MapperScan("cn.hdk.mapper")
@EnableEurekaClient
@EnableDiscoveryClient
@EnableCircuitBreaker
public class ProductHystrixApp {
    public static void main(String[] args) {
        SpringApplication.run(ProductHystrixApp.class,args);
    }
}

測試：localhost:8080/product/get/100 訪問

服務器失連

在某些狀況下，服務提供方並無失效，但可能因爲網絡緣由，服務的消費方並不能調用到服務接口，在這種狀況下，直接在服務的提供方提供熔斷機制依然仍是不夠的，這方面的處理須要在服務的消費方進行服務的回退（服務的降級）處理
服務的熔斷：熔斷指的是當服務的提供方不可以使用的時候，程序不會出現異常，而會出現本地的操做調用，服務的熔斷是在服務消費方實現的，在斷網狀況下服務提供方的任何處理都是沒有意義的。

【microcloud-service】新增一個IProductClientService的失敗調用(降級處理)

package hdk.service.fallback;


import hdk.service.IProductClientService;
import hdk.vo.Product;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class IProductClientServiceFallbackFactory implements FallbackFactory<IProductClientService> {
    @Override
    public IProductClientService create(Throwable throwable) {
        return  new IProductClientService() {
            @Override
            public Product getProduct(long id) {
                Product product = new Product();
                product.setProductId(999999L);
                product.setProductName("feign-hystrixName");
                product.setProductDesc("feign-hystrixDesc");
                return  product;
            }

            @Override
            public List<Product> listProduct() {
                return null;
            }

            @Override
            public boolean addPorduct(Product product) {
                return false;
            }
        };
    }
}

【microcloud-service】 修改IProductClientService，增長fallback配置

package hdk.service;


import hdk.feign.FeignClientConfig;
import hdk.service.fallback.IProductClientServiceFallbackFactory;
import cn.hdk.vo.Product;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@FeignClient(name = "MICROCLOUD-PROVIDER-PRODUCT",configuration = FeignClientConfig.class,
fallbackFactory = IProductClientServiceFallbackFactory.class)
public interface IProductClientService {
    @RequestMapping("/product/get/{id}")
    public Product getProduct(@PathVariable("id")long id);

    @RequestMapping("/product/list")
    public  List<Product> listProduct() ;

    @RequestMapping("/product/add")
    public boolean addPorduct(Product product) ;

}

【microcloud-consumer-feign】 複製一份成爲【microcloud-consumer-hystrix】模塊

【microcloud-consumer-hystrix】 修改application.yml配置文件，啓用hystrix配置

feign:
 hystrix:
    enabled: true
 compression:
  request:
    enabled: true
    mime-types: # 能夠被壓縮的類型
     - text/xml
     - application/xml
     - application/json
    min-request-size: 2048 # 超過2048的字節進行壓縮

啓動，服務提供者

訪問：http://localhost/consumer/product/get?id=1，能正常訪問

關閉，服務提供者

訪問：http://localhost/consumer/product/get?id=1，也能正常訪問

HystrixDashboard

在hystrix裏面提供一個Dashboard（儀表盤）的功能，他是一種監控的功能，能夠利用它來進行總體服務的監控

新建一個模塊【microcloud-consumer-hystrix-dashboard】
【microcloud-consumer-hystrix-dashboard】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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-consumer-hystrix-dashboard</artifactId>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>

    </dependencies>
</project>

【microcloud-provider-product-hystrix】 pom文件確保裏面有健康檢查模塊

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

【microcloud-consumer-hystrix-dashboard】 修改application.yml配置文件

server:
  port: 9001

【microcloud-consumer-hystrix-dashboard】 建立一個啓動類

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

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

啓動運行：http://localhost:9001/hystrix

【microcloud-provider-product-hystrix】 修改applcation.yml文件

management:
  endpoints:
    web:
      exposure:
        include: '*'

【microcloud-provider-product-hystrix】啓動
訪問：localhost:8080/actuator/hystrix.stream

http://localhost:9001/hystrix 填寫信息以下
http://admin:hdk@localhost:8080/actuator/hystrix.stream

這個時候對localhost:8080的訪問均可以被監控到

Turbine

HystrixDashboard 前面已經知道了，它的主要功能是能夠對某一項微服務進行監控，但真實狀況下，不可能只對某一個服務進行監控，更多的是對不少服務進行一個總體的監控，這個時候就須要使用到turbine來完成了。

爲了演示監控多個服務模塊，這個時候新建一個模塊【microcloud-provider-user-hystrix】,爲簡單起見，這個模塊並不鏈接數據庫，也不作安全控制。

【microcloud-provider-user-hystrix】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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-provider-user-hystrix</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-api】新增一個VO類：Users

package cn.hdk.vo;
import java.io.Serializable;

public class Users implements Serializable {
    private String name;
    private int age;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

【microcloud-provider-user-hystrix】 新建一個UserController

package hdk.controller;

import hdk.vo.Users;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class UserController {
    @RequestMapping("/get/{name}")
    @HystrixCommand
    public  Object get(@PathVariable("name")String name) {
        Users users = new Users();
        users.setName(name);
        users.setAge(18);
        users.setSex("F");
        return users;
    }
}

【microcloud-provider-user-hystrix】新增啓動類

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

【microcloud-provider-user-hystrix】修改application.yml配置文件

server:
 port: 8090

spring:
 application:
   name: microcloud-provider-users


logging:
  level:
    hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance:
    instance-id: microcloud-provider-users
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）



info:
  app.name: microcloud-provider-users
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

management:
  endpoints:
    web:
      exposure:
        include: '*'

啓動後：
訪問地址：http://localhost:8090/users/get/hdk
hystrix監控地址：http://localhost:8090/actuator/hystrix.stream

前面準備工做完成後，若是想要實現 turbine 的配置，準備一個turbine模塊

新增【microcloud-consumer-turbine】模塊，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-consumer-turbine</artifactId>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-turbine</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-consumer-turbine】修改application.yml配置文件

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.turbine.EnableTurbine;

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

turbine監控地址：

啓動Dashboard: http://localhost:9001/hystrix
在Dashboard裏面填上 turbine監控地址

這時還會報錯。

【microcloud-security】若是如今須要turbine進行加密服務的訪問，那麼只能折衷處理，讓訪問/actuator/hystrix.stream與/turbine.stream這兩個地址的時候不須要用戶密碼驗證

【microcloud-security】 修改WebSecurityConfiguration

package cn.hdk.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(AuthenticationManagerBuilder auth)
            throws Exception {
                auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder()).withUser("root").password(new BCryptPasswordEncoder().encode("hdk")).roles("USER").
                        and().withUser("admin").password(new BCryptPasswordEncoder().encode("hdk")).roles("USER", "ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.httpBasic().and().authorizeRequests().anyRequest()
                .fullyAuthenticated();
        http.sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/actuator/hystrix.stream","/turbine.stream") ;
    }
}

​ turbine監控地址：http://localhost:9101/turbine.stream

啓動Dashboard: http://localhost:9001/hystrix

在Dashboard裏面填上 turbine監控地址

刷新：

http://localhost:8080/prodcut/get/1

http://localhost:8090/users/get/1

Zuul路由

前面全部的微服務都是經過Eureka找到的，可是在不少開發中爲了規範微服務的使用，提供有一個處理控制器Zuul

Zuul實際上是一個API網關，相似於設計模式裏面的Facade門面模式，他的存在就像是整個微服務的門面，全部的外部客戶端訪問都須要通過它來進行調度與過濾

基本使用

新創建一個模塊【microcloud-zuul-gateway】
【microcloud-zuul-gateway】 的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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-zuul-gateway</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-zuul-gateway】修改application.yml文件

server:
  port: 9501

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
    register-with-eureka: false

spring:
  application:
    name:  microcloud-zuul-gateway

【microcloud-zuul-gateway】 建立啓動類

package hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.web.bind.annotation.RequestMapping;

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

Zuul配置路由

前面以及簡單的使用了zuul，但你會發現訪問地址還必須知道程序的名稱，若是不知道這個名稱是沒法訪問的，但若是讓用戶知道了這名稱，那麼使用zuul就是去它的實際意義的，咱們能夠經過名稱直接調用

既然是使用代理，那麼代理的功能就是不能讓用戶看到真實的操做，屏蔽真實的調用地址，這個時候就須要本身增長zuul的路由規則配置了。

【microcloud-zuul-gateway】修改application.yml配置文件，增長路由配置

zuul:
  routes:
    microcloud-provider-users:  /users-proxy/**

這個時候就能夠經過/users-proxy 來訪問microcloud-provider-users服務

http://localhost:9501/users-proxy/users/get/1

可是還會發現，雖然如今以及開啓了路由訪問的支持，但依然經過應用程序的名稱仍是能訪問
http://localhost:9501/microcloud-provider-users/users/get/1

【microcloud-zuul-gateway】修改application.yml文件，忽略掉用戶服務的名稱

zuul:
  routes:
    microcloud-provider-users:  /users-proxy/**
  ignored-services:
    microcloud-provider-users

作完後，就能夠進行代理的安全使用，但真實狀況下，通常會有不少微服務，若是徹底按照上面的配置方式會很是的麻煩，全部最加到的作法是能夠採用一個通配符「*」的模式來統一完成。

【microcloud-zuul-gateway】修改application.yml文件

zuul:
  routes:
    microcloud-provider-users:  /users-proxy/**
  ignored-services:
    "*"

除開上面這一種訪問模式之外，在zuul中還有另一種配置方式

【microcloud-zuul-gateway】修改application.yml文件

zuul:
  routes:
    users.path: /users-proxy/**
    users.serviceId: microcloud-provider-users
  ignored-services:
    "*"

其中在配置文件中出現的users實際上是一個邏輯名稱，這個名稱主要做用是將path與serviceId綁定在一塊兒

【microcloud-zuul-gateway】若是說不想經過eureka進行訪問，對於zuul來講也是能夠實現的，可是在真實的開發環境中，基本不會使用

zuul:
  routes:
    users:
      path: /users-proxy/**
      serviceId: microcloud-provider-users
    users2:
      path: /users2-proxy/**
      url: http://localhost:8090/
  ignored-services:
    "*"

訪問：http://localhost:9501/users2-proxy/users/get/1

【microcloud-zuul-gateway】 設置公共前綴

zuul:
  routes:
    users:
      path: /users-proxy/**
      serviceId: microcloud-provider-users
    users2:
      path: /users2-proxy/**
      url: http://localhost:8090/
  ignored-services:
    "*"
  prefix: /hdk-api

一旦設置了公共前綴，因此的訪問路徑都要在前面加上前綴

http://localhost:9501/hdk-api/users-proxy/users/get/1

http://localhost:9501/hdk-api/users2-proxy/users/get/1

zuul 過濾訪問

其實zuul的功能本質上就是一個代理操做，相似於nginx，可是在真實的使用中，全部的微服務一點都有增長的認證信息，那麼就必須在其訪問以前追加認證的頭部操做，這樣的功能須要經過zuul的過去操做完成。

【microcloud-zuul-gateway】 修改application.yml配置，增長產品微服務

zuul:
  routes:
    users:
      path: /users-proxy/**
      serviceId: microcloud-provider-users
    users2:
      path: /users2-proxy/**
      url: http://localhost:8090/
    product:
      path: /product-proxy/**
      serviceId: microcloud-provider-product
  ignored-services:
    "*"
  prefix: /hdk-api

這樣直接訪問：http://localhost:9501/hdk-api/product-proxy/prodcut/get/1
這樣是訪問不到的

【microcloud-zuul-gateway】追加過濾處理

package hdk.filter;


import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;

import java.nio.charset.Charset;
import java.util.Base64;

public class AuthorizedRequestFilter extends ZuulFilter{
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }
    @Override
    public int filterOrder() {
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        RequestContext currentContext = RequestContext.getCurrentContext() ; // 獲取當前請求的上下文
        String auth = "admin:hdk"; // 認證的原始信息
        byte[] encodedAuth = Base64.getEncoder()
                .encode(auth.getBytes(Charset.forName("US-ASCII"))); // 進行一個加密的處理
        String authHeader = "Basic " + new String(encodedAuth);
        currentContext.addZuulRequestHeader("Authorization", authHeader);
        return null;
    }
}

其中filterType爲過濾的類型
在進行Zuul過濾的時候能夠設置其過濾執行的位置，那麼此時有以下幾種類型：
pre：在請求發出以前執行過濾，若是要進行訪問，確定在請求前設置頭信息
route：在進行路由請求的時候被調用；
post：在路由以後發送請求信息的時候被調用；
error：出現錯誤以後進行調用

【microcloud-zuul-gateway】創建一個配置程序類

package hdk.config;

import cn.hdk.filter.AuthorizedRequestFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class ZuulConfig {
    @Bean
    public AuthorizedRequestFilter getAuthorizedRequestFilter() {
        return new AuthorizedRequestFilter() ;
    }
}

這個時候訪問：
http://localhost:9501/hdk-api/product-proxy/prodcut/get/1
http://localhost:9501/hdk-api/users-proxy/users/get/1

這兩個服務都能正常訪問了。

Zuul安全訪問

做爲全部接口的統一門面，zuul也是能夠進行加密訪問的
【microcloud-zuul-gateway】修改pom文件，增長安全訪問模塊

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

【microcloud-zuul-gateway】修改application.yml配置文件，增長用戶配置

spring:
  application:
    name:  microcloud-zuul-gateway
  security:
    user:
      name: admin
      password: hdk

再訪問http://localhost:9501/hdk-api/users-proxy/users/get/1
這個時候就須要輸入用戶名密碼了

Feign訪問Zuul

前面學習feign的時候確實已經知道,他實際上是去eureka中獲取服務地址的，若是想使用feign來訪問zuul，首先就應該讓zuul註冊到eureka中

【microcloud-zuul-gateway】 修改application.yml文件

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@eureka1:7001/eureka,http://admin:hdk@eureka2:7002/eureka,http://admin:hdk@eureka3:7003/eureka
  instance:
    instance-id: microcloud-zuul-gateway
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5 # 若是如今超過了5秒的間隔（默認是90秒）

【microcloud-service】如今全部的服務要經過zuul的代理進行訪問，新增接口

package .hdk.service;

import hdk.feign.FeignClientConfig;
import hdk.service.fallback.IProductClientServiceFallbackFactory;
import hdk.service.fallback.IZUUlClientServiceallbackFactory;
import hdk.vo.Product;
import hdk.vo.Users;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@FeignClient(name = "MICROCLOUD-ZUUL-GATEWAY",configuration = FeignClientConfig.class,
        fallbackFactory = IZUUlClientServiceallbackFactory.class)
public interface IZUUlClientService {

    @RequestMapping("/hdk-api/product-proxy/product/get/{id}")
    public Product getProduct(@PathVariable("id")long id);

    @RequestMapping("/hdk-api/product-proxy/product/list")
    public List<Product> listProduct() ;

    @RequestMapping("/hdk-api/product-proxy/product/add")
    public boolean addPorduct(Product product) ;

    @RequestMapping("/hdk-api/users-proxy/users/get/{name}")
    public Users getUsers(@PathVariable("name")String name);
}

新增IZUUlClientServiceallbackFactory，在Zuul因爲出現網絡問題失去聯繫後進行容錯處理

package.hdk.service.fallback;


import hdk.service.IProductClientService;
import hdk.service.IZUUlClientService;
import hdk.vo.Product;
import hdk.vo.Users;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class IZUUlClientServiceallbackFactory implements FallbackFactory<IZUUlClientService> {
    @Override
    public IZUUlClientService create(Throwable throwable) {
        return  new IZUUlClientService() {
            @Override
            public Product getProduct(long id) {
                Product product = new Product();
                product.setProductId(999999L);
                product.setProductName("feign-zuulName");
                product.setProductDesc("feign-zuulDesc");
                return  product;
            }

            @Override
            public List<Product> listProduct() {
                return null;
            }

            @Override
            public boolean addPorduct(Product product) {
                return false;
            }

            @Override
            public Users getUsers(String name) {
                Users user = new Users();
                user.setSex("F");
                user.setAge(17);
                user.setName("zuul-fllback："+name);
                return user;
            }
        };
    }
}

【microcloud-consumer-hystrix】 修改ConsumerProductController，增長一個新的方法，訪問接口

package hdk.controller;


import hdk.service.IProductClientService;
import hdk.service.IZUUlClientService;
import hdk.vo.Product;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/consumer")
public class ConsumerProductController {

    @Resource
    private IProductClientService iProductClientService;

    @Resource
    private IZUUlClientService izuUlClientService;


    @RequestMapping("/product/get")
    public Object getProduct(long id) {
        return  iProductClientService.getProduct(id);
    }

    @RequestMapping("/product/list")
    public  Object listProduct() {
        return iProductClientService.listProduct();
    }

    @RequestMapping("/product/add")
    public Object addPorduct(Product product) {
        return  iProductClientService.addPorduct(product);
    }

    @RequestMapping("/product/getProductAndUser")
    public Object getProductAndUser(long id) {
        Map<String,Object> result = new HashMap();
        result.put("product",izuUlClientService.getProduct(id));
        result.put("user",izuUlClientService.getUsers(id+""));
        return  result;
    }
}

依次啓動eureka，user服務，product服務，zuul服務，customerhystrix服務

在地址欄輸入：

http://localhost/consumer/product/getProductAndUser?id=1

關閉zuul服務

http://localhost/consumer/product/getProductAndUser?id=1

發現服務降級已經開啓

Zuul熔斷

zuul是一個代理服務，但若是被代理的服務忽然斷了，這個時候zuul上面會有出錯信息，例如，中止product服務

如今服務的調用方已經作了處理，不會出現這樣的錯誤信息，但通常來講，對於zuul自己代理方，也應該進行zuul的降級處理

修改【microcloud-zuul-gateway】創建fallback回退處理類

package hdk.fallback;


import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

@Component
public class ProviderFallback implements   FallbackProvider  {
    @Override
    public String getRoute() {
        return "*";
    }

    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return new ClientHttpResponse() {

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders() ;
                headers.set("Content-Type", "text/html; charset=UTF-8");
                return headers;
            }

            @Override
            public InputStream getBody() throws IOException {
                // 響應體
                return new ByteArrayInputStream("產品微服務不可用，請稍後再試。".getBytes());
            }

            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.BAD_REQUEST;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return HttpStatus.BAD_REQUEST.value();
            }

            @Override
            public String getStatusText() throws IOException {
                return HttpStatus.BAD_REQUEST.getReasonPhrase();
            }

            @Override
            public void close() {

            }
        };
    }
}

訪問：http://localhost:9501/hdk-api/product-proxy/prodcut/get/1

getRoute：方法能夠返回服務的ID，好比‘microcloud-provider-product’，若是須要匹配所有適應 「*」

SpringCloudConfig分佈式配置中心

雖然springcloud使用springboot進行開發，節省了大量的配置文件，但每一個服務依然有本身的application.yml配置文件，並且每一個服務通常都有負載均衡，因此，這麼依賴對於配置文件的統一管理就很是有必要了

左邊這一塊咱們很熟悉，最開始有個eureka，它經過配置文件application.yml啓動，在這個配置文件裏面會指定端口，實例名，註冊地址等

對於服務提供商來講，它也須要把相關信息寫到application.yml文件中，好比數據庫配置，端口，項目名稱等，其中最重要的就就是要指定eureka的具體位置

這是前面反覆說過的，但如今是基於cloudConfig的配置中心，最開始啓動eureka的時候，eureka的具體配置就不是寫死在eureka的application.yml文件中了，這個時候也會有application.yml（bootstrap.yml）配置文件，只是這裏的配置指定的時候config的配置中心，在eureka啓動的時候讀取【配置中心】的配置，並啓動

對於服務提供商也是一樣的道理，以產品服務爲例，它的application.yml文件也不在指定具體的配置，真實須要訪問的數據庫，端口等信息也是在啓動的時候直接從【配置中心】讀取。

因此說config配置中心在其中佔據很是重要的位置，但config裏面的配置從哪來呢？實際上是從git服務器裏面來的，開發者須要把相關的配置上傳到git服務器，這裏的git服務器能夠本身搭建，也能夠直接用github，後面項目爲了方便就直接使用github了。

配置中心搭建

準備好git服務器以後，接下來就要準備配置中心了

【microcloud-config】 新建一個配置中心的服務提供模塊，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-config</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-security</artifactId>
        </dependency>
    </dependencies>

</project>

引入springcloudserver的同時，這分佈式配置中心也不是誰都能訪問的，因此增長了安全驗證模塊。
應該還記得這時候的用戶名密碼爲：admin/hdk

【microcloud-config】 新增application.yml配置文件，增長git鏈接配置信息

server:
  port: 7101

spring:
  application:
    name: microcloud-config
  cloud:
    config:
      server:
        git:
          uri: https://github.com/huangdongkui/microconfig.git

【microcloud-config】 新增啓動類

package cn.hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

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

這些工做準備完成後，爲了測試【microcloud-config】是能正確運行的，還須要上傳個配置文件到github
【GITHUB】 上傳一個application.yml

spring:
   profiles:
      active:
      - dev
---
spring:
  profiles: dev
  application:
      name: microconfig-test-dev
---
spring:
 profiles: default
 application:
      name: microconfig-test-default

準備好配置文件後啓動【microcloud-config】

NO 訪問形式 訪問路徑
1 /{application}-{profile}.yml http://localhost:7101/application-dev.ymlhttp://localhost:7101/application-default.ymlhttp://localhost:7101/application-beta.yml 不存在
2 /{application}/{profile}[/{label}] http://localhost:7101/application/dev/masterhttp://localhost:7101/application/default/master
3 /{label}/{application}-{profile}.yml http://localhost:7101/master/application-default.ymlhttp://localhost:7101/master/application-dev.yml

簡單的客戶端

如今已經成功的搭建好了配置中心，但這個時候若是隻經過url的訪問形式其實沒什麼太多的意義，最終仍是須要把github相關信息加載到客戶端上進行訪問

新增長一個【microcloud-config-client】模塊，這模塊講讀取github裏面的信息，也不作其餘的事情，只是顯示一下。

新建【microcloud-config-client】，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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-config-client</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
    </dependencies>
</project>

【github】上傳一個新的配置文件microcloud-config-client.yml，後面就經過程序來讀取這個配置

​```
spring:
   profiles:
      active:
        - dev
---
server:
  port: 8201

spring:
  profiles: dev
  application:
      name: microconfig-test-client

eureka:
 client:
  service-url:
    defaultZone: http://admin:hdk@localhost:7001/eureka
---
server:
  port: 8102

spring:
  profiles: beta
  application:
      name: microconfig-test-client

eureka:
 client:
  service-url:
    defaultZone: http://admin:hdk@localhost:7001/eureka

【microcloud-config-client】新建bootstrap.yml文件，這文件讀取配置中心的配置

spring:
 cloud:
  config:
    name: microcloud-config-client # 定義要讀取的資源文件的名稱
    profile: dev # 定義profile的 名稱
    label: master # 定義配置文件所在的分支
    uri: http://localhost:7101 # SpringCloudConfig的服務地址
    username: admin # 鏈接的用戶名
    password: hdk # 鏈接的密碼

可能有些人奇怪，爲何不直接把相關信息寫道application.yml文件之中，其實這是一種規範

  • 「application.yml」：對應的是用戶級的資源配置項；

  • 「bootstrap.yml」：對應的是系統級的資源配置，其優先級更高

【microcloud-config-client】新建application.yml文件，這文件只是簡單的配置一個應用名稱

spring:
 application:
  name: microcloud-config-client # 編寫應用的名稱

【microcloud-config-client】新建一個controller,這個controller顯示從服務器下載到的配置文件

package hdk.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigClientController {
    @Value("${spring.application.name}")
    private String applicationName;
    @Value("${eureka.client.serviceUrl.defaultZone}")
    private String eurekaServers; 
    @RequestMapping("/config")
    public String getConfig() {
        return "ApplicationName = " + this.applicationName + "、EurekaServers = "
                + this.eurekaServers;
    }
}

【microcloud-config-client】 新建一個啓動類

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

啓動配置中心，訪問，確認配置經過url是能正常訪問的。

http://localhost:7101/microcloud-config-client-beta.yml

啓動【microcloud-config-client】發現tomcat啓動了，佔用的端口就是dev的8201，訪問

http://localhost:8201/config

這個時候簡單的客戶端已經搭建完成。

Eureka與服務提供商讀取配置

有了上面這些基礎，接下來就能夠完成這個圖的功能了，這裏依然簡化一下，只考慮product產品服務與eureka

eureka與product服務的配置信息要求去配置中心獲取，因此在正式部署項目以前，先準備兩個配置，上傳到github之中

microcloud-config-eureka-client.yml，這個是eureka的配置文件，這裏就沒有考慮eureka的高可用了

spring:
  profiles:
    active:
      - dev
---
server:
 port: 7001
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@localhost:7001/eureka
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱
spring:
  profiles: dev
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-config-eureka-client
---
server:
 port: 7002
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@localhost:7002/eureka
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱
spring:
  profiles: beta
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-config-eureka-client

microcloud-config-product-client.yml，這個事對於產品服務這個服務提供商提供者的配置文件

spring:
  profiles:
    active:
      - dev
---
server:
 port: 8080
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: root1234% # 數據庫鏈接密碼
 application:
   name: microcloud-config-product-client
 profiles: dev

logging:
  level:
    cn.hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@localhost:7001/eureka
  instance:
    instance-id: microcloud-config-product-client
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）

info:
  app.name: microcloud-provider-product
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

management:
  endpoints:
    web:
      exposure:
        include: '*'
        
        
---
server:
 port: 8081
mybatis:
 mapper-locations: # 全部的mapper映射文件
 - classpath:mapping/*.xml
spring:
 datasource:
   type: com.alibaba.druid.pool.DruidDataSource # 配置當前要使用的數據源的操做類型
   driver-class-name: com.mysql.jdbc.Driver # 配置MySQL的驅動程序類
   url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 # 數據庫鏈接地址
   username: root # 數據庫用戶名
   password: root1234% # 數據庫鏈接密碼
 application:
   name: microcloud-config-product-client
 profiles: beta

logging:
  level:
    cn.hdk.mapper: debug

eureka:
  client: # 客戶端進行Eureka註冊的配置
    service-url:
      defaultZone: http://admin:hdk@localhost:7002/eureka
  instance:
    instance-id: microcloud-config-product-client
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 設置心跳的時間間隔（默認是30秒）
    lease-expiration-duration-in-seconds: 5  # 若是如今超過了5秒的間隔（默認是90秒）

info:
  app.name: microcloud-config-product-client
  company.name: hdk
  build.artifactId: $project.artifactId$
  build.modelVersion: $project.modelVersion$

management:
  endpoints:
    web:
      exposure:
        include: '*'

有了這兩個配置文件，接下來就能夠搭建eureka服務和product服務了

eureka配置

複製【microcloud-eureka】一份，修改爲爲【microcloud-config-eureka-client】，

【microcloud-config-eureka-client】 修改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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-config-eureka-client</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-config-eureka-client】建立bootstrap.yml文件，讀取配置中心eureka的配置

spring:
  cloud:
     config:
       uri:  http://localhost:7101
       name: microcloud-config-eureka-client
       profile:  beta
       label:  master
       username: admin
       password: hdk

【microcloud-config-eureka-client】 修改application.yml，刪除不須要的配置
spring:
  application:
    name: microcloud-config-eureka-client

因爲使用的是beta，它裏面指定的eureka的端口是7002
重啓後訪問：localhost:7002

product服務配置

複製【microcloud-provider-product】項目爲【microcloud-config-product-client】

【microcloud-config-product-client】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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <version>1.0.0</version>


    <artifactId>microcloud-config-product-client</artifactId>
    <dependencies>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

        <!--<dependency>-->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!--<artifactId>spring-boot-starter-security</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>

    </dependencies>

</project>

【microcloud-config-product-client】新增bootstrap.yml 文件，配置以下

spring:
  cloud:
    config:
      uri:  http://localhost:7101
      name: microcloud-config-product-client
      profile:  beta
      label:  master
      username: admin
      password: hdk

【microcloud-config-product-client】 修改application.yml文件

spring:
 application:
    name: microcloud-config-product-client

啓動product服務，訪問eureka，如今產品服務已經添加上去了。

Config配置中心高可用

如今無論是erueka仍是服務提供者都是基於SpringCloudConfig獲取配置文件的，這個時候配置中心就相當重要了，但在真實的項目環境中，不免SpringCloudConfig會出現各類問題，這個時候就須要考慮config的高可用機制了。

其實解決方式也很簡單，把SpringCloudConfig註冊到Eureka就搞定了，這個時候用戶訪問的時候不是直接從配置中心獲取配置，而是經過eureka中獲取配置中心的地址，再從配置中心獲取具體服務的參數就行。

複製【microcloud-eureka】一份，修改爲爲【microcloud-ha-config-eureka】，這個eureka不註冊具體的業務服務，只是負責config配置中心的負載均衡使用

【microcloud-ha-config-eureka】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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>microcloud-ha-config-eureka</artifactId>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>
    
</project>

【microcloud-ha-config-eureka】 修改application.yml文件

server:
 port: 7301
eureka:
  server:
    eviction-interval-timer-in-ms: 1000   #設置清理的間隔時間，然後這個時間使用的是毫秒單位（默認是60秒）
    enable-self-preservation: false #設置爲false表示關閉保護模式
  client:
    fetch-registry: false
    register-with-eureka: false
    service-url:
        defaultZone: http://admin:hdk@localhost:7301/eureka
  instance: # eureak實例定義
    hostname: localhost # 定義 Eureka 實例所在的主機名稱
spring:
  security:
    user:
      name: admin
      password: hdk
  application:
    name: microcloud-ha-config-eureka

啓動類以下

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

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

【microcloud-config】再複製兩份，總共3個配置中心，分別爲【microcloud-config2】【microcloud-config3】

【microcloud-config】【microcloud-config2】【microcloud-config3】 修改pom文件

增長eureka的支持

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

【microcloud-config】【microcloud-config2】【microcloud-config3】修改application.yml文件，增長eureka的註冊地址

server:
  port: 7101

spring:
  application:
    name: microcloud-config
  cloud:
    config:
      server:
        git:
          uri: https://github.com/hdkeud/microconfig.git

eureka:
 client:
  service-url:
    defaultZone: http://admin:hdk@localhost:7301/eureka
 instance:
  prefer-ip-address: true # 在地址欄上使用IP地址進行顯示
  instance-id: microcloud-config1

啓動eureka並啓動三個配置中心後

【microcloud-config-client】 修改pom文件，增長eureka的支持

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>microcloud-config-client</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-config-client】 修改bootstrap.yml文件，增長eureka相關配置

spring:
 cloud:
  config:
    name: microcloud-config-client # 定義要讀取的資源文件的名稱
    profile: dev # 定義profile的 名稱
    label: master # 定義配置文件所在的分支
    #uri: http://localhost:7101 # SpringCloudConfig的服務地址
    username: admin # 鏈接的用戶名
password: hdk # 鏈接的密碼
discovery:
      enabled: true   # 經過配置中心加載配置文件
      service-id: MICROCLOUD-CONFIG   # 在eureka之中註冊的服務ID
    
eureka: 
 client: 
  service-url:
    defaultZone: http://admin:hdk@localhost:7301/eureka

訪問：http://localhost:8201/config

自動刷新

在整個SpringCloudConfig設計之中，咱們已經實現了配置的統一管理，但其實還有一個問題，就是自動刷新。

嘗試修改一下【github】 microcloud-config-client.yml文件

spring:
   profiles:
      active:
        - dev
---
server:
  port: 8201

spring:
  profiles: dev
  application:
      name: microconfig-test-client2

eureka:
 client:
  service-url:
    defaultZone: http://admin:hdk@localhost:7001/eureka
---
server:
  port: 8102

spring:
  profiles: beta
  application:
      name: microconfig-test-client2

eureka:
 client:
  service-url:
    defaultZone: http://admin:hdk@localhost:7001/eureka

這裏的修改很是簡單，只是修改了下應用名稱，提交後

訪問：http://localhost:8201/config

發現配置並無修改，一直要重啓【microcloud-config-client】後纔會發現配置已經修改爲功，其實這對大多數應用沒有什麼問題，若是你定時要關注這個小問題也是有辦法處理的，在springcloud裏面能夠藉助消息總線SpringCloudBus解決這問題。

springcloudbus是基於SpringCloudStream的，SpringCloudStream的做用其實也是一種適配器模式的體現，消息中間件由不少，好比activemq，rabbitmq ，kafka，不一樣的消息中間件都會由使用上的差別，而SpringCloudStream就是爲了屏蔽各類消息中間件的差別而存在的.

與以前的架構不同的地方在於增長了消息總線，消息總線鏈接了config配置中心和各個配置中心的消費方，當配置提交到github的時候，能夠藉助/bus/refresh刷新，config配置中心再將變動的消息通知到其餘的客戶端

【github】 修改配置microcloud-config-client.yml

spring:
   profiles:
      active:
        - dev
---
server:
  port: 8201

spring:
  profiles: dev
  application:
      name: microconfig-test-client2

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
  register-with-eureka: false

info:
  app.name: microcloud-config-client-dev
  company.name: hdk
---
server:
  port: 8102

spring:
  profiles: beta
  application:
      name: microconfig-test-client2

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
  register-with-eureka: false
  
info:
  app.name: microcloud-config-client-dev
  company.name: hdk

啓動rabbitmq

登錄查看 http://localhost:15672

準備bus配置中心

新創建一個模塊【microcloud-config-bus】，這模塊是配置中心的升級版，做用也是配置中心。

【microcloud-config-bus】 修改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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-config-bus</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

</project>

【microcloud-config-bus】 修改application.yml文件，配置上git目錄，同樣鏈接上eureka,要和消息中間件通信，因此RabbitMQ的鏈接信息也配置上

server:
  port: 7201
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/hdkeud/microconfig.git
    bus:
      trace:
        enabled: true
  rabbitmq:
    host: localhost
    port: 5672    # RabbitMQ的監聽端口
    username: hdk  # 用戶名
    password: 5428325 # 密碼
  application:
    name: microcloud-config-bus

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
 instance:
    prefer-ip-address: true # 在地址欄上使用IP地址進行顯示
    instance-id: microcloud-config-bus
management:
  endpoints:
    web:
      exposure:
        include: "*"

新增啓動類

package hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

先啓動eureka，再啓動ConfigBusApp 以後訪問：

http://localhost:7301/

發現新的註冊中心已經註冊上去了。

準備新的客戶端

新創建microcloud-config-bus-client模塊，這模塊是註冊中心的客戶端，從註冊中心獲取數據，職責和【microcloud-config-client】同樣，可用基於他拷貝修改，只是增長bus相關的功能。

【microcloud-config-bus-client】 修改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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-config-bus-client</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>


</project>

【microcloud-config-bus-client】bootstrap.yml 增長rabbitmq相關信息，另外的配置和前面同樣，須要從eureka找到註冊中心，也須要找具體配置文件信息

spring:
  cloud:
    config:
      name: microcloud-config-client # 定義要讀取的資源文件的名稱
      profile: dev # 定義profile的 名稱
      label: master # 定義配置文件所在的分支
      #uri: http://localhost:7101 # SpringCloudConfig的服務地址
      username: admin # 鏈接的用戶名
      password: hdk # 鏈接的密碼
      discovery:
        enabled: true
        service-id: MICROCLOUD-CONFIG-BUS

  rabbitmq:
    host: localhost
    port: 5672    # RabbitMQ的監聽端口
    username: hdk  # 用戶名
    password: 5428325 # 密碼

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
  register-with-eureka: false

修改application.yml文件

spring:

 application:

  name: microcloud-config-client # 編寫應用的名稱

【microcloud-config-bus-client】 創建一個配置文件的映射類，這類是爲了演示使用，裏面的屬性和github的屬性一一對應，同時增長@RefreshScope，表明這個類是可用基於rabbitmq自動刷新的

package cn.hdk.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

@Component
@RefreshScope
public class InfoConfig {
    @Value("${info.app.name}")
    private String appName ;
    @Value("${info.company.name}")
    private String companyName ;

    public String getAppName() {
        return appName;
    }

    public void setAppName(String appName) {
        this.appName = appName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @Override
    public String toString() {
        return "InfoConfig{" +
                "appName='" + appName + '\'' +
                ", companyName='" + companyName + '\'' +
                '}';
    }
}

【microcloud-config-bus-client】修改ConfigClientController

package cn.hdk.controller;

import cn.hdk.config.InfoConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController

public class ConfigClientController {

    @Value("${spring.application.name}")
    private String applicationName;
    @Value("${eureka.client.serviceUrl.defaultZone}")
    private String eurekaServers;

    @Resource
    private InfoConfig infoConfig;

    @RequestMapping("/config")
    public String getConfig() {
        return "ApplicationName = " + this.applicationName + "、EurekaServers = "
                + this.eurekaServers+"、infos = " +infoConfig.toString();
    }
}

新增啓動類

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

啓動後訪問

http://localhost:8201/config，這時候已經能得到配置中心的數據

測試自動刷新

其實這裏的自動刷新只能說是半自動的。
【github】microcloud-config-client.yml，隨便修改裏面的內容，提交

spring:
   profiles:
      active:
        - dev
---
server:
  port: 8201

spring:
  profiles: dev
  application:
      name: microconfig-test-client2

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
  register-with-eureka: false

info:
  app.name: microcloud-config-client-dev
  company.name: hdk
---
server:
  port: 8102

spring:
  profiles: beta
  application:
      name: microconfig-test-client2

eureka:
 client:
  serviceUrl:
    defaultZone: http://admin:hdk@localhost:7301/eureka
  register-with-eureka: false
  
info:
  app.name: microcloud-config-client-beta
  company.name: hdkbeta

【microcloud-config-bus-client】 刷新客戶端
http://localhost:8201/config
這個時候信息並沒自動刷新，數據仍是之前的，這是覺得對應消息中間件來講，還須要給他發個消息，表明數據已經更新了。

【microcloud-config-bus】使用postman發生一條post刷新的指令
http://localhost:7201/actuator/bus-refresh

訪問http://localhost:15672，發現消息隊列裏面已經有消息傳遞了。

【microcloud-config-bus-client】 刷新客戶端

http://localhost:8201/config 發現數據已經跟新

SpringCloudStream 消息驅動

SpringCloudStream看名字就知道他和消息隊列相關，但它又不是消息隊列，準確來講它相似於硬件裏面的驅動程序，也就是前面說的適配器模式的體現
在系統開發裏面不免用到消息隊列，但各個的消息隊列又有所區別，SpringCloudStream的做用就是屏蔽各類消息隊列的區別，對消息隊列的API進行進一步的抽象，使得在springcloud裏面能更加方便的集成各類消息系統

首先來看SpringCloudStream的組成

無論是生產者仍是消費者，並不會直接和消息中間件打交道，在springcloudstream中抽象了已成binder（綁定層），有了這一層，使用者並不關心具體的消息中間件配置了，由訪問層真正的和消息隊列進行通訊

建立消息生產者

【microcloud-stream-provider】建立一個新的模塊，這模塊負責生產一個消息

【microcloud-stream-provider】 pom文件以下，映入springcloudstream的相關組件

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-stream-provider</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

【microcloud-stream-provider】 修改application.yml文件

server:
 port: 8401

spring:
  cloud:
    stream:
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          output: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
  application:
    name: microcloud-stream-provider

【microcloud-stream-provider】 定義一個消息發送接口

package hdk.service;
import cn.hdk.vo.Product;
public interface IMessageProvider {
     void send(Product product);
}

【microcloud-stream-provider】 定義接口的實現類

package hdk.service.impl;


import hdk.service.IMessageProvider;
import hdk.vo.Product;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;

import javax.annotation.Resource;

@EnableBinding(Source.class)
public class MessageProviderImpl implements IMessageProvider{
    @Resource
    private MessageChannel output;  // 消息的發送管道

    @Override
    public void send(Product product) {
        output.send(MessageBuilder.withPayload(product).build());
    }
}

【microcloud-stream-provider】 定義啓動類主程序

package hdk;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

【microcloud-stream-provider】 編寫測試類

package hdk.test;
import hdk.StreamProviderApp;
import hdk.service.IMessageProvider;
import hdk.vo.Product;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;

@SpringBootTest(classes = StreamProviderApp.class)
@RunWith(SpringRunner.class)
public class TestMessageProvider {

    @Resource
    private IMessageProvider messageProvider;

    @Test
    public void testSend() {
        Product product = new Product();
        product.setProductId(1L);
        product.setProductName("messageName");
        product.setProductDesc("desc");
        messageProvider.send(product);
    }
}

運行測試方法
RabbitMq:http://localhost:15672/

建立消息消費者

【microcloud-stream-consumer】 新建模塊

【microcloud-stream-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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-stream-consumer</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>hdk</groupId>
            <artifactId>microcloud-api</artifactId>
        </dependency>
    </dependencies>
</project>

【microcloud-stream-consumer】 修改application.yml配置文件

server:
  port: 8402

spring:
  cloud:
    stream:
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          input: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
  application:
    name: microcloud-stream-consumer

【microcloud-stream-consumer】 定義一個消息的監聽

package hdk.listener;

import hdk.vo.Product;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

@Component
@EnableBinding(Sink.class)
public class MessageListener {
    @StreamListener(Sink.INPUT)
    public void input(Message<Product> message) {
        System.err.println("【*** 消息接收 ***】" + message.getPayload());
    }
}

【microcloud-stream-consumer】 建立啓動類

package hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

啓動後，發現rabbitmq裏面已經有了一個消費者

【microcloud-stream-provider】 運行測試類

【microcloud-stream-consumer】 已經收到消息

【rabbitmq】在消息隊列中，也檢測到了這匿名隊列，能夠發現Exchange默認的類型就是TOPIC，RoutingKey咱們沒有自定，默認的就是#，會給全部的消費者發消息

自定義消息通道

【micocloud-api】修改pom文件，增長stream的支持

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
    </dependencies>
     <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
    </dependencies>

【micocloud-api】 增長管道接口

package hdk.channel;
import org.springframework.cloud.stream.annotation.Input;
import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;

public interface DefaultProcess {
    public static final String OUTPUT = "hdk_output"; // 輸出通道名稱
    public static final String INPUT = "hdk_input"; // 輸入通道名稱
    @Input(DefaultProcess.INPUT)
    public SubscribableChannel input();
    @Output(DefaultProcess.OUTPUT)
    public MessageChannel output();
}

【microcloud-stream-provider】 修改application.yml配置文件

server:
 port: 8401

spring:
  cloud:
    stream:
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          hdk_output: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
  application:
    name: microcloud-stream-provider

【microcloud-stream-consumer】 修改application.yml文件

server:
  port: 8402

spring:
  cloud:
    stream:
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          hdk_input: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
  application:
    name: microcloud-stream-consumer

【microcloud-stream-provider】 修改MessageProviderImpl發送實現類

package hdk.service.impl;
import hdk.channel.DefaultProcess;
import hdk.service.IMessageProvider;
import hdk.vo.Product;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;

import javax.annotation.Resource;

@EnableBinding(DefaultProcess.class)
public class MessageProviderImpl implements IMessageProvider{
    @Resource
    @Qualifier("hdk_output")
    private MessageChannel output;  // 消息的發送管道

    @Override
    public void send(Product product) {
        output.send(MessageBuilder.withPayload(product).build());
    }
}

【microcloud-stream-consumer】 修改MessageListener

package hdk.listener;
import hdk.channel.DefaultProcess;
import hdk.vo.Product;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

@Component
@EnableBinding(DefaultProcess.class)
public class MessageListener {
    @StreamListener(DefaultProcess.INPUT)
    public void input(Message<Product> message) {
        System.err.println("【*** 消息接收 ***】" + message.getPayload());
    }
}

完成.

分組（隊列）

Group（分組）其實就是對應rabbitmq裏面得隊列，在前面的案例中，咱們並無指定group，產生的就是一個匿名隊列。

若是啓動了多個【microcloud-stream-consumer】接收者，但並無指定group，，那麼將會產生多個匿名的消息隊列，致使多個接收者都會收到同一個消息，也就是說一個消息被重複消費了，這在某些業務場景來講是並不運行的。

這個時候就須要用到group分組了，對於不想重複消費個某消息的各個消費者必須屬於同一個組。

【microcloud-stream-consumer】 修改application.yml

server:
  port: 8403

spring:
  cloud:
    stream:
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          hdk_input: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
            group:  hdk_group
  application:
    name: microcloud-stream-consumer

這個時候服務生產者【microcloud-stream-provider】發送的任何消息都只會被同一個group的某一個消費者處理了。

RoutingKey

RoutingKey實際上是RabbitMq的概念，在RabbitMq裏面其實有好幾種Exchange，在SpringCloudStream裏面默認就是使用的最通用的Topic

若是沒有配置RoutingKey，它使用的RoutingKey其實就是#，既相似於fanout的廣播類型
其實也可使用RoutingKey來實現相似於direct類型，既然直連

【microcloud-stream-consumer】修改application.yml配置文件

server:
  port: 8402

spring:
  cloud:
    stream:
       rabbit:
        bindings:
          hdk_input:
            consumer:
              bindingRoutingKey: hdkKey # 設置一個RoutingKey信息
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          hdk_input: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
            group:  hdk_group
  application:
    name: microcloud-stream-consumer

【microcloud-stream-provider】定義 RoutingKey 的表達式配置：

server:
 port: 8401

spring:
  cloud:
    stream:
      rabbit:
         bindings:
          hdk_output:
              producer:
                routingKeyExpression: '''hdkKey'''
       binders: # 在此處配置要綁定的rabbitmq的服務信息；
          defaultRabbit: # 表示定義的名稱，用於於binding整合
            type: rabbit # 消息組件類型
            environment: # 設置rabbitmq的相關的環境配置
              spring:
                rabbitmq:
                   addresses: localhost
                   port: 5672
                   username: hdk
                   password: 123456
                   virtual-host: /
       bindings: # 服務的整合處理
          hdk_output: # 這個名字是一個通道的名稱，在分析具體源代碼的時候會進行說明
            destination: hdkExchange # 表示要使用的Exchange名稱定義
            content-type: application/json # 設置消息類型，本次爲對象json，若是是文本則設置「text/plain」
            binder: defaultRabbit # 設置要綁定的消息服務的具體設置
  application:
    name: microcloud-stream-provider

SpringCloudSleuth 鏈路跟蹤

在微服務的架構下，系統由大量服務組成，每一個服務多是由不一樣的團隊開發，開發使用不一樣的語言，部署在幾千臺服務器上，而且橫跨多個不一樣的數據中心，一次請求絕大多數狀況會涉及多個服務，在系統發生故障的時候，想要快速定位和解決問題，就須要跟蹤服務請求序列

SpringCloudSleuth使用的核心組件是Twitter推出的Zipkin監控組件，zipkin就是一個分佈式的跟蹤系統，用戶收集服務的數據

基本使用

跟蹤服務

【microcloud-sleuth】 新創建模塊，這個模塊用戶跟蹤用戶的請求，把請求的鏈路進行展現

<?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>springcloud</artifactId>
        <groupId>hdk</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microcloud-sleuth</artifactId>

   <dependencies>
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-sleuth</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-zipkin</artifactId>
       </dependency>
       <dependency>
          <groupId>io.zipkin.java</groupId>
           <artifactId>zipkin-server</artifactId>
           <version>2.9.3</version>
       </dependency>
       <dependency>
           <groupId>io.zipkin.java</groupId>
           <artifactId>zipkin-autoconfigure-ui</artifactId>
           <version>2.9.3</version>
       </dependency>
   </dependencies>
</project>

【microcloud-sleuth】修改application.yml文件

server:
  port: 8601
spring:
  application:
    name: microcloud-zipkin-server


management:
  metrics:
    web:
      server:
        auto-time-requests: false

【microcloud-sleuth】新建啓動類

package .hdk;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.internal.EnableZipkinServer;

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

客戶端配置

爲了演示鏈路追蹤，須要啓動一些列服務

1.【microcloud-eureka】，啓動這個服務的目的是讓product,users兩服務註冊到其中，後面須要zuul的調用

2.修改一下服務的pom文件，增長sleuth的支持

【microcloud-provider-user-hystrix】

【microcloud-provider-product-hystrix】

【microcloud-zuul-gateway】

【microcloud-consumer-hystrix】

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

3.修改一下服務的application.yml文件，增長zipkin的配置

【microcloud-provider-user-hystrix】

【microcloud-provider-product-hystrix】

【microcloud-zuul-gateway】

【microcloud-consumer-hystrix】

spring:
  zipkin:
    base-url: http://localhost:8601 #全部的數據提交到此服務之中
    sender:
      type: web       #提交的類型是web 服務
  sleuth:
    sampler:
      probability: 1.0 # 定義抽樣比率，默認爲0.1
  1. 依次啓動

【microcloud-eureka】

【microcloud-provider-user-hystrix】

【microcloud-provider-product-hystrix】

【microcloud-zuul-gateway】

【microcloud-consumer-hystrix】

訪問

http://localhost/consumer/product/getProductAndUser?id=1

訪問跟蹤服務：

http://localhost:8601/zipkin/dependency/

數據持久化

如今以及成功實現了一個 SpringCloudSleuth 的基本操做，但會發現，若是從新啓動【microcloud-sleuth】服務，全部的鏈路跟蹤數據都會丟失，那麼這些數據應該存儲到數據庫裏面的。
但又有另一個問題，若是請併發量特別大，對於mysql來講可能會承受不了這麼大的併發，爲了解決這個問題，可使用消息隊列緩衝處理，最後才從mq中把數據存到mysql中

源碼

https://download.csdn.net/download/wolf12/11544808

posted on 2019-08-13 16:06  wolf12 閱讀( ...) 評論( ...) 編輯 收藏

Powered by: 博客園 模板提供： 滬江博客 Copyright © 2019 wolf12
Powered by .NET Core 3.0.0 on Linux

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程