SpringCloud

SpringCloud
微服务和微服务架构
- 微服务
- 微服务架构
- 微服务优缺点
- 为什么选择SpringCloud作为微服务架构
什么是SpringCloud
- SpringCloud是什么
- Dubbo和SpringCloud技术选型
- SpringCloud能干吗
Rest学习环境搭建：服务提供者
- 总项目pom配置
- 子模块springcloud-api
  - 搭建数据库环境
  - 创建实体类（必须序列化）
- 子模块 springcloud-provider-dept
Rest学习环境搭建：服务消费者
- pom文件
- config
- controller
- 启动类
- 测试
服务注册与发现
- 什么是Eureka
- 原理讲解
- 新建一个模块springcloud-eureka-7001
Eureka：服务注册-信息配置-自我保护机制
- 服务端
- 自我保护机制
- 服务端增加注册发现Controller
Eureka：集群环境配置
Eureka：CAP原则及对比Zookeeper
- CAP原则
- ACID是什么
- CAP是什么
- CAP理论的核心
Ribbon：负载均衡及Ribbon
- Ribbon是什么
- Ribbon能干嘛
- 消费者导入ribbon依赖
Ribbon:使用Ribbon实现负载均衡
Ribbon：自定义负载均衡算法
Feign负载均衡
- 简介
- Feign能干什么
- Feign集成了Ribbon
Hystrix：服务熔断
- 分布式系统面临的问题
- 服务雪崩
- 什么是Hystrix
- 能干吗
- 服务熔断
Hystrix：服务降级
Hystrix：Dashboard流监控
Zuul：路由网关
- 概述
SpringCloud config 分布式配置
- 概述
- SpringCloud Config分布式配置中心能干嘛
- SpringCloud config分布式配置中心与github整合
Config:Git环境搭建
Config：服务端连接Git配置
Config：客户端连接服务端访问远程
Config：远程配置实战测试

SpringCloud

回顾之前的知识

JavaSE
数据库
前端
Servlet
Http
Mybatis
Spring
SpringMVC
SpringBoot
Dubbo、Zookeeper、分布式基础
Maven、Git
Ajax，Json
。。。

串一下自己会的东西

这个阶段该如何学

三层架构+MVC
框架：
	Spring   IOC   AOP
	
	SpringBOOT，新一代的JavaEE开发标准，自动装配
	
	模块化~All in one
	模块化的开发====All in one  代码没变化


微服务架构4个核心问题：
	- 服务很多，客户端如何访问
	- 这么多服务？服务之间如何通信
	- 这么多服务？如何治理
	- 服务挂了怎么办
	
解决方案：
	SpringCloud  生态   SpringBoot
	1.Spring Cloud NetFlix  一站式解决方案
		api网关，zuul组件
		Feign ---HttpClient  --https通信方式，同步，阻塞
		服务注册与发现：Eureka
		熔断机制：Hystrix
	2.Apache Dubbo Zookeeper  半自动，需要整合别人的
		API：没有，找第三方组件，或者自己实现
		Dubbo
		Zookeeper
		没有：借助Hystrix
	3.Spring Cloud Alibaba  一站式解决方案，更简单
		
新概念：服务网格~Server Mesh
		istio
		
万变不离其宗
	API
	HTTP，RPC
	注册和发现
	熔断机制
	
网络不可靠

微服务和微服务架构

微服务架构是一种架构模式，或者说是以一种架构风格，它提倡将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值。服务之间采用轻量级的通信机制互相沟通，每个服务围绕着及具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言，工具对其进行构建

微服务的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底的去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库

微服务

微服务强调的是服务的大小，他关注的是某一个点，是具体解决某一个问题/提供落地对应服务的一个服务应用，狭义的看，可以看作是IDEA中的一个个微服务工程或者Module

微服务架构

微服务优缺点

优点

单一职责原则
每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求
开发简单，开发效率提高，一个服务可能就是专一的只干一件事
微服务能够被小团队单独开发，这个小团队是2~5人的开发人员组成
微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的
微服务能使用不同的语言开发
易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如jenkins，Hudson，bamboo
微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成功，无需通过合作才能体现价值
微服务允许你利用融合最新技术
微服务只是业务逻辑的代码。不会和HTML,CSS或其他界面混合
每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一数据库

缺点

开发人员要处理分布式系统的复杂性
多服务运维难度，随着服务的增加，运维的压力也在增大
系统部署依赖
服务间通信成本
数据一致性
系统集成测试
性能监控

为什么选择SpringCloud作为微服务架构

选型依据

整体解决方案和框架成熟度

社区热度

可维护性

学习曲线注解
当前各大IT公司用的微服务架构有哪些

阿里：dubbo+HFS

京东：JSF

新浪：Motan

当当网：DubboX

。。。

什么是SpringCloud

SpringCloud是什么

Spring官网：https://spring.io/

SpringCloud,基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件

SpringCloud利用SpringBoot的开发便利性，巧妙的简化了分布式系统基础设施的开发，SprinCloud为开发人员提供了快速构建分布式系统的一些工具，包括配置管理，服务发现，断路器，路由，微代理，事件总线，全局锁，决策竞选，分布式会话等等，他们都可以用SpringBoot的开发风格做到一键启动和部署

SpringCloud并没有重复造轮子，只是将目前各家公司开发的比较成熟，经得起实际考验的服务框架组合起来，通过SpringBoot风格进行再封装，屏蔽掉了复杂的配置和实现原理，最终给开发者流出了一套简单易懂，易部署和易维护的分布式系统开发工具包

SpringCloud是分布式微服务架构下的一站式解决方案，是各个微服务架构落地技术的集合体，俗称微服务全家桶

SpringBoot专注于快速方便的开发单个个体微服务

SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，为各个微服务之间提供：配置管理，服务发现，断路器，路由，微代理，事件总线，全局锁，决策竞选，分布式会话等等集成服务

SpringBoot可以离开SpringCloud独立使用，开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系

SpringBoot专注于快速，方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架

Dubbo和SpringCloud技术选型

分布式+服务治理Dubbo

目前成熟的互联网架构：应用服务拆分+消息中间件
Dubbo和SpringCloud对比

可以看一下社区活跃度

https://github.com/dubbo

https://github.com/spring-cloud

SpringCloud抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST 方式

SpringCloud能干吗

Distributed/versioned configuration 分布式/版本控制配置
Service registration and discovery 服务注册与发现
Routing 路由
Service-to-service calls 服务到服务的调用
Load balancing 负载均衡配置
Circuit Breakers 断路器
Global locks
Leadership election and cluster state
Distributed messaging 分布式消息管理

官网：https://project.spring.io/spring-cloud/

参考书：

https://springcloud.cc/spring-cloud-netflix.html
中文API文档：https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中国社区:http://springcloud.cn/
SpringCloud中文网:https://springcloud.cc/

Rest学习环境搭建：服务提供者

总项目pom配置

创建一个Maven项目，删掉src

总项目pom文件配置

注意这里是dependency management ，使用的时候还需要导入

<?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>org.company</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--打包方式 pom-->
    <packaging>pom</packaging>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.13.1</junit.version>
        <lombok.version>1.18.16</lombok.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--springcloud的依赖-->
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR9</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--springboot的依赖-->
            <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.5.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.22</version>
            </dependency>
            <!--数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.2</version>
            </dependency>
            <!--springboot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.3</version>
            </dependency>


            <!--日志测试相关的包-->
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <!--logback-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


</project>

子模块springcloud-api

新建子模块 maven项目 springcloud-api

<?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>org.company</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api</artifactId>


    <!--当前的module自己需要的依赖，如果父依赖中已经配置了版本，这里就不用写了-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

搭建数据库环境

本地创建数据库db01

再通过IDEA的Database创建表，右击数据库，可视化填写表结构，自动生成sql语句

create table dept
(
   deptno bigint auto_increment,
   dname varchar(60) null,
   db_source varchar(60) null,
   constraint dept_pk
      primary key (deptno)
)
comment '部门表';

插入数据

insert into dept(dname,db_source) values ('开发部',DATABASE());
insert into dept(dname,db_source) values ('人事部',DATABASE());
insert into dept(dname,db_source) values ('财务部',DATABASE());
insert into dept(dname,db_source) values ('市场部',DATABASE());
insert into dept(dname,db_source) values ('运维部',DATABASE());

创建实体类（必须序列化）

package com.company.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;


@Data
@Accessors(chain = true)           //链式写法
@NoArgsConstructor
public class Dept implements Serializable { //Dept  实体类   ，orm，  类表关系映射

    private Long deptno;//主键
    private String dname;

    //这个数据存在哪个数据库的字段~  微服务架构，一个服务对应一个数据库，同一个信息可能存在不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }
}

子模块 springcloud-provider-dept

创建一个maven项目springcloud-provider-dept-8001

配置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>org.company</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-dept-8001</artifactId>

    <dependencies>
        <!--我们需要拿到实体类，需要配置api module-->
        <dependency>
            <groupId>org.company</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <!--logback-core-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

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

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

        <!--jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

配置文件

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.company.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml


#spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

mybatis-config.xml(没有特殊的配置可以不写)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>


</configuration>

Dao接口和mapper.xml

package com.company.springcloud.dao;


import com.company.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface DeptDao {

    boolean addDept(Dept dept);
    Dept queryById(Long id);
    List<Dept> queryAll();
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.company.springcloud.dao.DeptDao">

    <insert id="addDept" parameterType="Dept">
        insert into dept(dname,db_source) values (#{dname},DATABASE())
    </insert>

    <select id="queryById" parameterType="Long" resultType="Dept">
        select * from dept where deptno=#{deptno}
    </select>

    <select id="queryAll"  resultType="Dept">
        select * from dept 
    </select>

</mapper>

Service 接口和实现类

package com.company.springcloud.service;

import com.company.springcloud.pojo.Dept;

import java.util.List;


public interface DeptService {


    boolean addDept(Dept dept);
    Dept queryById(Long id);
    List<Dept> queryAll();
}

接口实现类

package com.company.springcloud.service;

import com.company.springcloud.dao.DeptDao;
import com.company.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Service
public class DeptServiceImpl implements DeptService{

    @Autowired
    DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {

        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {

        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {

        return deptDao.queryAll();
    }
}

Controller类

package com.company.springcloud.controller;


//提供Restful服务

import com.company.springcloud.pojo.Dept;
import com.company.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }


    @GetMapping("/dept/list")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }

}

启动测试

出错原因：

配置文件要写对：路径要写对，尤其是mybatis，mapper，不然会出现class not found
pojo实体类属性要与数据库里的字段完全一致,否则会出现对象或属性为null

Rest学习环境搭建：服务消费者

创建maven项目：springcloud-consumer-dept-80

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>org.company</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>

    <!--实体类+web-->
    <dependencies>
        <dependency>
            <groupId>org.company</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

config

package com.company.springcloud.config;


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

@Configuration
public class ConfigBean {//@Configuration     --spring    applicationext.xml
    
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    
}

controller

package com.company.springcloud.controller;


import com.company.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    //理解：消费者不应该有service层~
    //Restful
    //RestTemplate。。。。。供我们直接调用就可以了，注册到Spring中
    //(url，实体：Map,Class<T> responseType)

    @Autowired
    private RestTemplate restTemplate;//提供多种边界访问远程http服务的方法，简单的Restful服务模板

    private static final String REST_URI_PREFIX = "http://localhost:8001";

    @RequestMapping("/consumer/dept/get")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URI_PREFIX+"/dept/add",dept,boolean.class);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URI_PREFIX+"/dept/get/"+id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URI_PREFIX+"/dept/list/",List.class);
    }

}

启动类

package com.company.springcloud;


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

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

}

测试

先启动服务提供端

再启动消费者

服务注册与发现

什么是Eureka

Eureka：怎么读
Netflix在设计Eureka时，遵循的是AP原则
Eureka是Netflix的一个子模块，也是核心模块之一，Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了。功能类似于Dubbo的注册中心，比如Zookeeper

原理讲解

Eureka的基本架构
- SpringCloud封装了Netflix公司开发的Eureka模块来实现服务注册与发现（对比Zookeeper）
- Eureka采用了C-S的架构设计，EurekaServer作为服务注册功能的服务器，他是服务注册中心
- 而系统中的其他微服务，使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑
- 和Dubbo架构对比
- Eureka 包含两个组件：Eureka Server和Eureka Client
- Eureka Server提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到
- Eureka Client是一个java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器，在应用启动后，将会向EurekaServer发送心跳（默认周期为30秒）。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉（默认周期为90秒）
三个角色
- Eureka Server：提供服务的注册与发现
- Service Provider：将自身服务注册到Eureka中，从而使消费方能够找到
- Service Consumer：服务消费方从Eureka中获取注册服务列表，从而找到消费服务

新建一个模块springcloud-eureka-7001

导入依赖
编写配置文件
开启这个功能@Enablexxxx
配置类

导包

<!--导包-->
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

配置

server:
  port: 7001


#Eureka配置
eureka:
  instance:
    hostname: localhost         #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类

package com.company.springcloud;


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


//启动之后访问 http://localhost:7001/
@SpringBootApplication
@EnableEurekaServer            //EnableEurekaServer        服务端启动类，可以接受别人注册进来
public class EurekaServer_7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7001.class,args);
    }
}

Eureka：服务注册-信息配置-自我保护机制

服务端

服务端导入eureka依赖包

<!--eureka-->
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

配置文件

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept8001  #修改eureka上的默认描述信息！

启动类开启Eureka

package com.company.springcloud;


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

//启动类
@SpringBootApplication
@EnableEurekaClient  //自动在服务启动后自动注册到Eureka中
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

测试

开启7001

开启8001

访问：http://localhost:7001/ 看到服务已经被注册到Eureka

加上监控依赖

<!--完善监控信息-->
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

配置文件

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.company.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml


#spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept8001  #修改eureka上的默认描述信息！

#info配置
info:
  app.name: ming-springcloud
  company.name: blog.mingstudy.com

重启测试

自我保护机制

某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存

默认情况下：如果EurekaServer在一定事件内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒），但是当网络分区故障发生时，微服务与Eureka之间无法正常通信，以上行为可能变的非常危险了，因为微服务本身其实是健康的，此时本不应该注销这个功能，Eureka通过自我保护机制来解决这个问题--当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式，一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任何微服务）。当网络故障恢复时，该EurekaServer节点会自动退出自我保护模式
在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例，当它收到的心跳数重新恢复到阈值以上时，该EurekaServer节点就会自动推出自我保护模式，它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例，一句话：好死不如赖活者
综上，自我保护模式是一种应对网络异常的安全保护措施，它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留），也不盲目的注销任何健康的微服务，使用自我保护模式，可以让Eureka集群更加的健壮和稳定
在SpringCloud中，可以使用eureka.server.enable-self-preservation = false 禁用保护模式【不推荐关闭自我保护机制】

服务端增加注册发现Controller

package com.company.springcloud.controller;


//提供Restful服务

import com.company.springcloud.pojo.Dept;
import com.company.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;
    
    //获取一些配置的信息，得到具体的微服务！
    @Autowired
    private DiscoveryClient client;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }


    @GetMapping("/dept/list")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }

    //注册进来的微服务~，获取一些消息
    @GetMapping("/dept/discovery")
    public Object discover(){
        //获取微服务列表的清单
        List<String> services = client.getServices();
        System.out.println("discovery=>service"+services);
        
        //得到一个具体的微服务信息，通过具体的微服务id，applicationName
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost()+"\t"+
                            instance.getPort()+"\t"+
                            instance.getUri()+"\t"+
                            instance.getServiceId()
            );
        }
        return this.client;
    }
    
}

启动类配置服务发现

package com.company.springcloud;


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
@EnableEurekaClient  //自动在服务启动后自动注册到Eureka中
@EnableDiscoveryClient  //服务发现
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

启动Eureka

启动服务端

访问http://localhost:8001/dept/discovery 获得微服务信息

Eureka：集群环境配置

创建新模块 springcloud-eureka-7002

创建新模块 springcloud-eureka-7003

把7001的pom文件依赖包复制到7002，7003

application 复制两份，修改端口号

复制启动类，修改类名称

C:\Windows\System32\drivers\etc hosts文件修改

增加以下信息：一个IP绑定三个域名

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com
127.0.0.1 eureka7003.com

配置文件

7001

server:
  port: 7001


#Eureka配置
eureka:
  instance:
    hostname: eureka7001.com        #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      #单机：defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群（关联）：
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

7002

server:
  port: 7002


#Eureka配置
eureka:
  instance:
    hostname: eureka7002.com        #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/

7003

server:
  port: 7003


#Eureka配置
eureka:
  instance:
    hostname: eureka7003.com         #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

服务端Eureka 地址修改

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.company.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml


#spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001  #修改eureka上的默认描述信息！

#info配置
info:
  app.name: ming-springcloud
  company.name: blog.mingstudy.com

测试

启动7001，7002，7003

启动8001

7001,7002,7003挂掉一个，服务还能访问

Eureka：CAP原则及对比Zookeeper

CAP原则

RDBMS （Mysql，Oracle，sqlServer）===》ACID

NoSQL（redis,mongodb）===>CAP

ACID是什么

A（Atomicity）原子性
C（Consistency）一致性
I（Isolation）隔离性
D（Durability）持久性

CAP是什么

C（Consistency）强一致性
A（Availability）可用性
P（Partition tolerance）分区容错性

CAP的三进二：CA,AP,CP

CAP理论的核心

一个分布式系统不可能同时很好的满足一致性，可用性，和分区容错性这三个需求
根据CAP原理，将NoSQL数据库分成了满足CA原则，满足CP原则和满足AP原则三大类
- CA:单点集群，满足一致性，可用性的系统，通常可扩展性较差
- CP:满足一致性，分区容错性的系统，通常性能不是特别高
- AP:满足可用性，分区容错性的系统，通常可能对一致性要求低一点

作为服务注册中心，Eureka比Zookeeper好在哪里

著名的CAP理论指出，一个分布式系统不可能同时满足C（一致性），A（可用性），P（容错性）

由于分区容错性P在分布式系统中是必须要保证的，因此我们只能在A和C之间进行权衡

Zookeeper保证的是CP
Eureka保证的是AP

Zookeeper保证的是CP

当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服务直接down掉不可用。也就是说，服务注册功能对可用性的要求高于一致性。但是zk会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader进行选举。问题在于，选举leader的时间太长，30~120s，且选举期间整个zk集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因为网络问题使得zk集群失去master节点时较大概率会发生的事件，虽然服务最终能够恢复，但是漫长的选举事件导致的注册长期不可用是不能容忍的

Eureka保证的是AP

Eureka看明白了这一点，因此在设计时就优先保证可用性，Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务，而Eureka的客户端在向某个Eureka注册时，如果发现连接失败，就会自动切换至其他节点，只要有一台Eureka还在，就能保证注册服务的可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就任务客户端与注册中心出现了网络故障，此时会出现以下几种情况

Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
Eureka仍然能够接受新服务的注册和查询要求，但是不会被同步到其他节点上（即保证当前节点依然可用）
当网络稳定时，当前实例新的注册信息会被同步到其他节点中

因此Eureka可以很好的应对因网络故障导致部分节点失去联系的情况而不会向zookeeper那样使整个注册服务瘫痪

Ribbon：负载均衡及Ribbon

Ribbon是什么

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具
简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起，Ribbon的客户端组件提供一系列完整的配置须知如：连接超时，重试等等，简单的说，就是在配置文件中列出LoadBalancer（简称LB：负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等等）去连接这些机器，我们也很容易使用Ribbon实现自定义的负载均衡算法

Ribbon能干嘛

LB，即负载均衡（Load Balance），在微服务或分布式集群中经常用的一种应用
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）
常见的负载均衡软件有Nginx，Lvs等等
dubbo，SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义
负载均衡简单分类：
- 集中式LB
  - 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx，由该设施负载把访问请求通过某种策略转发至服务的提供方
- 进程式LB
  - 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器
  - Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址

消费者导入ribbon依赖

增加pom依赖

<!--ribbon-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

        <!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

配置文件

server:
  port: 80
  
  
#Eureka配置
eureka:
  client:
    register-with-eureka: false   #不向Eureka注册自己
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

启动类加上@EnableEurekaClient

package com.company.springcloud;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//Ribbon和Eureka整合以后，客户端可以直接调用，不用关心IP地址和端口号~
@SpringBootApplication
@EnableEurekaClient  //客户端
public class DeptConsumer_80 {
    public static void main(String[] args) {

        SpringApplication.run(DeptConsumer_80.class,args);
    }

}

配置类负载均衡

package com.company.springcloud.config;


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

@Configuration
public class ConfigBean {//@Configuration     --spring    applicationext.xml
    //配置负载均衡实现
    @Bean
    @LoadBalanced //Ribbon
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }


    
    
}

控制类访问地址变更

package com.company.springcloud.controller;


import com.company.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    //理解：消费者不应该有service层~
    //Restful
    //RestTemplate。。。。。供我们直接调用就可以了，注册到Spring中
    //(url，实体：Map,Class<T> responseType)

    @Autowired
    private RestTemplate restTemplate;//提供多种边界访问远程http服务的方法，简单的Restful服务模板

    //Ribbon   ,我们这里设置的地址，应该是一个变量，通过服务名来访问
    //private static final String REST_URI_PREFIX = "http://localhost:8001";
    private static final String REST_URI_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumer/dept/get")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URI_PREFIX+"/dept/add",dept,boolean.class);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URI_PREFIX+"/dept/get/"+id,Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URI_PREFIX+"/dept/list/",List.class);
    }

}

启动7001，7002

启动8001

启动80 访问http://localhost/consumer/dept/list 获取到数据，测试通过

Ribbon:使用Ribbon实现负载均衡

复制数据库db01，创建数据库db02，db03，插入数据

创建maven项目 springcloud-provider-dept-8002,springcloud-provider-dept-8003

导入pom依赖，与8001一致

配置文件对应修改一下

三个服务的名称要一致

启动7001，8001，8002，8003

启动80

访问http://localhost/consumer/dept/list

查询结果再db01，db02，db03中轮询

Ribbon：自定义负载均衡算法

自定义MyRule，不能在启动类同一目录下，应在上一级

package com.company.myrule;


import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MingRule {


    @Bean
    public IRule myRule(){
        return new RandomRule();
    }

}

启动类加上注解@RibbonClient

package com.company.springcloud;


import com.company.myrule.MingRule;
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;

//Ribbon和Eureka整合以后，客户端可以直接调用，不用关心IP地址和端口号~
@SpringBootApplication
@EnableEurekaClient  //客户端
//在微服务启动的时候就能去加载我们自定义Ribbon类
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MingRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {

        SpringApplication.run(DeptConsumer_80.class,args);
    }

}

自定义MingRandomRule

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.company.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class MingRandomRule extends AbstractLoadBalancerRule {
    public MingRandomRule() {
    }
    
    //每个服务访问5次，换下一个服务（3个）
    
    //total=0,默认=0,如果=5，我们指向下一个服务节点
    //index=0,默认0，如果total=5，index+1,
    
    private int total=0;//被调用的次数
    private int currentIndex=0;//当前是谁在提供服务~
    

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            Server server = null;

            while(server == null) {
                if (Thread.interrupted()) {
                    return null;
                }

                List<Server> upList = lb.getReachableServers();  //获得活着的服务
                List<Server> allList = lb.getAllServers();  //获得全部的服务
                int serverCount = allList.size();
                if (serverCount == 0) {
                    return null;
                }

//                int index = this.chooseRandomInt(serverCount);  //生成区间随机数
//                server = (Server)upList.get(index);  //从活着的服务中随机获取一个
                
                //=====================================================
                
                if(total<5){
                    server = upList.get(currentIndex);
                    total++;
                }else{
                    total=0;
                    currentIndex++;
                    if(currentIndex>=upList.size()){
                        currentIndex=0;
                    }
                    server = upList.get(currentIndex);    //从活着的服务中，获取指定的服务来进行操作
                }
                
                //=====================================================
                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

与启动类不在同级目录的config

package com.company.myrule;


import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MingRule {


    @Bean
    public IRule myRule(){
        return new MingRandomRule();//默认是轮询，现在我们自定义
    }

}

Feign负载均衡

简介

feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controller调用service，SpringCloud集成了Ribbon和Eureka，可在使用Feign时提供负载均衡的http客户端

只需要创建一个接口，然后添加注解即可

feign，只要是社区，大家都习惯面向接口编程，这个是很多开发人员的规范，调用微服务访问两种方法

微服务名字（ribbon）
接口和注解（feign）

Feign能干什么

Feign旨在使编写Java Http客户端变的更容易
前面在使用Ribbon+RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法，但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它（类似于以前Dao接口上标注Mapper注解，现在是一个微服务接口上标注一个Feign注解即可）即可完成对服务提供方的接口绑定，简化了使用SpringCloudRibbon时，自动封装服务调用客户端的开发量

Feign集成了Ribbon

利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而且简单的实现了服务调用

新建module springcloud-consumer-dept-feign

把springcloud-consumer-dept-80 文件复制一份到springcloud-consumer-dept-feign

启动类不包含Ribbon自定义设置

package com.company.springcloud;


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

//Ribbon和Eureka整合以后，客户端可以直接调用，不用关心IP地址和端口号~
@SpringBootApplication
@EnableEurekaClient  //客户端
public class FeignDeptConsumer_80 {
    public static void main(String[] args) {

        SpringApplication.run(FeignDeptConsumer_80.class,args);
    }

}

导入feign依赖

<!--feign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

module springcloud-api也导入feign依赖

<!--feign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

springcloudapi 新建service层，新建DeptClienService接口

package com.company.springcloud.service;

import com.company.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;


@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {

    
    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);
    @GetMapping("/dept/list")
    public List<Dept> queryAll();

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept);
}

springcloud-consumer-dept-feign Controller

package com.company.springcloud.controller;


import com.company.springcloud.pojo.Dept;
import com.company.springcloud.service.DeptClientService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class DeptConsumerController {
    
    @Autowired
    private DeptClientService service=null;

    @RequestMapping("/consumer/dept/get")
    public boolean add(Dept dept){
        return this.service.addDept(dept);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return this.service.queryById(id);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return this.service.queryAll();
    }


}

feign启动类配置

package com.company.springcloud;


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

//Ribbon和Eureka整合以后，客户端可以直接调用，不用关心IP地址和端口号~
@SpringBootApplication
@EnableEurekaClient  //客户端
@EnableFeignClients(basePackages = {"com.company.springcloud"})

public class FeignDeptConsumer_80 {
    public static void main(String[] args) {

        SpringApplication.run(FeignDeptConsumer_80.class,args);
    }

}

启动7001，8001，8002，

启动feign，访问http://localhost/consumer/dept/list 测试通过

Hystrix：服务熔断

分布式系统面临的问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免的失败

服务雪崩

多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”、如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的”雪崩效应“

对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒中内饱和，比失败更糟糕的式，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障，这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消整个应用程序或系统

我们需要弃车保帅

什么是Hystrix

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时，异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性

“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方法返回一个服务预期的，可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方法无法处理的异常，这样就可以保证了服务调用方的线程不会被长时间，不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩

能干吗

服务降级
服务熔断
服务限流
接近实时的监控
。。。

官网资料：https://github.com/Netflix/Hystrix/wiki

服务熔断

是什么

熔断机制是对应雪崩效应的一种微服务链路保护机制

当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内20次调用失败就会启动熔断机制。熔断机制的注解是@HystrixCommand

新建模块springcloud-provider-dept-hystrix-8001

拷贝8001内容到springcloud-provider-dept-hystrix-8001

导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

controller

package com.company.springcloud.controller;


//提供Restful服务

import com.company.springcloud.pojo.Dept;
import com.company.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;


    
    @GetMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod = "hystrixGet")
    public Dept get(@PathVariable("id") Long id){
        Dept dept = deptService.queryById(id);
        if(dept==null){
            throw new RuntimeException("id=>"+id+",不存在该用户，或者信息无法找到~");
            
        }
        return dept;
    }
    
    //备选方法
    public Dept hystrixGet(@PathVariable("id") Long id){
        
        return new Dept()
                .setDeptno(id)
                .setDname("id=>"+id+"没有对应的信息，为null--@Hystrix")
                .setDb_source("no this database in MySQL");
    }

}

启动类添加支持

package com.company.springcloud;


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
@EnableEurekaClient  //自动在服务启动后自动注册到Eureka中
@EnableDiscoveryClient  //服务发现
@EnableCircuitBreaker  //添加对熔断的支持
public class DeptProviderHystrix_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix_8001.class,args);
    }
}

启动7001，7002，hystrix-8001，80

访问http://localhost/consumer/dept/get/8

得到{"deptno":8,"dname":"id=>8没有对应的信息，为null--@Hystrix","db_source":"no this database in MySQL"}

配置文件中

eureka.prefer-ip-address: true          #可以显示服务的ip地址

Hystrix：服务降级

在springcloud-api service层写fallbackfactory

package com.company.springcloud.service;

import com.company.springcloud.pojo.Dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;

//降级~
@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {

    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public Dept queryById(Long id) {
                return new Dept()
                        .setDeptno(id)
                        .setDname("id=>"+id+"没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭")
                        .setDb_source("没有数据~");
            }

            @Override
            public List<Dept> queryAll() {
                return null;
            }

            @Override
            public boolean addDept(Dept dept) {
                return false;
            }
        };
    }
}

加上fallbackfactory信息

package com.company.springcloud.service;

import com.company.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;


@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {


    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);
    @GetMapping("/dept/list")
    public List<Dept> queryAll();

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept);
}

springcloud-consumer-dept-feign 配置文件开启hystrix

server:
  port: 80

#开启降级feign.hystrix
feign:
  hystrix:
    enabled: true


#Eureka配置
eureka:
  client:
    register-with-eureka: false   #不向Eureka注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

测试

启动7001，没有hystrix的8001，dept-feign-80

访问http://localhost/consumer/dept/get/1 得到{"deptno":1,"dname":"开发部","db_source":"db01"}

关掉8001，访问得到{"deptno":1,"dname":"id=>1没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭","db_source":"没有数据~"}

服务熔断：服务端~某个服务超时或者异常，引起熔断~  保险丝~

服务降级：客户端~  从整体的网站请求负载考虑~，当某个服务熔断或者关闭之后，服务将不再被调用~
        此时在客户端，我们可以准备一个FallbackFactory，返回一个默认的值（缺省值），整体的服务水平下降了~但是，好歹能用~
        比直接挂掉强~

Hystrix：Dashboard流监控

新建模块springcloud-consumer-hystrix-dashboard

导入consumer-dept-80的依赖，依赖是一样的

增加hystrix,dashboard的依赖

<!--hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

配置文件

server:
  port: 9001

hystrix:
  dashboard:
    proxy-stream-allow-list: "*"

启动类

package com.company.springcloud;


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

@SpringBootApplication
@EnableHystrixDashboard   //开启监控
public class DeptConsumerDashBoard_9001 {

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

确保服务端有监控信息依赖

<!--完善监控信息-->
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

之前启动了7001，8001，dept-deign ，这次再启动9001

访问http://localhost:9001/hystrix 得到监控页面

springcloud-provider-hystrix-8001

在启动类增加一个servlet

package com.company.springcloud;


import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;

//启动类
@SpringBootApplication
@EnableEurekaClient  //自动在服务启动后自动注册到Eureka中
@EnableDiscoveryClient  //服务发现
@EnableCircuitBreaker  //添加对熔断的支持
public class DeptProviderHystrix_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix_8001.class,args);
    }

    //增加一个Servlet
    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
        HystrixMetricsStreamServlet hystrixMetricsStreamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(hystrixMetricsStreamServlet);
        registrationBean.addUrlMappings("/actuator/hystrix.stream");
        return registrationBean;
    }
}

测试

启动7001， 9001，hystrix-8001,

调用@HystrixCommand(fallbackMethod = "hystrixGet")接口的方法

访问http://localhost:8001/dept/get/1

再访问http://localhost:9001/hystrix 填入url http://localhost:8001/actuator/hystrix.stream 得到监控页面

Zuul：路由网关

概述

什么是zuul？

zuul包含了对请求的路由和过滤两个最主要的功能：

其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过zuul跳转后获得

注意：zuul服务最终还是会注册进Eureka

提供：代理+路由+过滤三大功能

zuul能干嘛？

路由
过滤

官方文档：https://github.com/Netflix/zuul

新建模块springcloud-zuul-9527

把dashboard的pom依赖复制到 9527

新增zuul依赖

<!--zull-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zuul</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

配置

server:
  port: 9527

spring:
  application:
    name: springcloud-zuul

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: zuul9527.com
    prefer-ip-address: true

info:
  app.name: ming-springcloud
  company.name: blog.ming.study.com

启动类开启zuul

package com.company.springcloud;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy  //开启zuul
public class ZuulApplication_9527 {

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

启动7001，hystrix8001，9527

访问http://localhost:8001/dept/get/1 得到结果

访问http://localhost:9527/springcloud-provider-dept/dept/get/1 得到的结果一致

9527增加zuul配置（隐藏真实服务名），重启

zuul:
  routes: 
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/**

访问http://localhost:9527/mydept/dept/get/1

得到相同的结果

增加zuul忽略服务，重启，原来路径访问不了

zuul:
  routes:
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/**
  ignored-services: springcloud-provider-dept  #不能再使用这个路径访问了，ignored：忽略

访问：http://localhost:9527/springcloud-provider-dept/dept/get/1

访问不了

访问http://localhost:9527/mydept/dept/get/1 能得到结果

其他设置：

zuul:
	ignored-services: "*"      #隐藏全部的
	prefix: /ming     #设置公共的前缀

SpringCloud config 分布式配置

概述

分布式系统面临的--配置文件的问题

微服务意味着要将单体应用中心的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务，由于各个服务都需要必要的配置信息才能运行，所以一套集中式的，动态的配置管理设施是必不可少的。SpringCloud提供了ConfigServer来解决这个问题，我们每一个微服务自己带着一个application.yml，那上百的配置文件要修改起来，岂不是要发疯！

什么是SpringCloud config分布式配置中心

SpringCloud config为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的环节提供了一个中心化的外部配置

SpringCloud Config分为服务端和客户端两部分

服务端也称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口

客户端则通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息，配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理，并且可以通过git客户但工具来方便的管理和访问配置内容。

SpringCloud Config分布式配置中心能干嘛

集中管理配置文件
不同环境，不同配置，动态化的配置更新，分环境部署，比如/dev /test /prod /beta /release
运行期间动态调整配置，不再需要在每个服务部署的机器上编写配置文件，服务会向配置中心统一拉去配置自己的信息
当配置发生变化时，服务不需要重启，即可感知到配置的变化，并应用新的配置
将配置信息以REST接口的形式暴露

SpringCloud config分布式配置中心与github整合

由于SpringCloud config 默认使用Git来存储配置文件（也有其他方式，比如支持SVN和本地文件），但是最推荐的还是Git，而且使用的时http/https 访问的形式

Config:Git环境搭建

coding gitee github

在gitee上新建一个仓库 springcloud-config

git客户端 git clone 远程仓库

本地仓库新建application.yml

spring:
  profiles:
    active: dev
    
---
spring:
  profiles: dev
  application:
    name: springcloud-config-dev
    
---
spring:
  profiles: test
  application:
    name: springcloud-config-test

执行命令

如果第一次输入密码出错，记得清除本地密码:git config --system --unset credential.helper

git add .
git commit -m 'first commit'
git push origin master

Config：服务端连接Git配置

新建模块springcloud-config-server-3344

导入依赖

<dependencies>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>

        <!--完善监控信息-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>



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

    </dependencies>

配置信息

server:
  port: 3344

spring:
  application:
    name: springcloud-config-server
    #连接远程仓库

  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/uxquan/springcloud-config.git   #https  不是git

启动类开启config

package com.company.springcloud;


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

@SpringBootApplication
@EnableConfigServer   //开启config
public class Config_Server_3344 {
    public static void main(String[] args) {
        SpringApplication.run(Config_Server_3344.class,args);
    }
}

启动3344

访问http://localhost:3344/application-dev.yml

访问http://localhost:3344/application-test.yml

也可以这种格式

http://localhost:3344/application/dev/master

HTTP服务具有以下格式的资源：

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

通过config-server 可以连接到git，访问其中的资源以及配置

Config：客户端连接服务端访问远程

在springcloud-config本地项目里新建config-client.yml文件

spring:
  profiles:
    active: dev
    
---
server:
  port: 8201
#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-provider-dept

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/


---
server:
  port: 8202
#spring的配置
spring:
  profiles: test
  application:
    name: springcloud-provider-dept

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

执行命令

git add .
git commit -m '2'
git push origin master

新建模块springcloud-client-3355

导入依赖 spring-cloud-starter-config

<dependencies>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.2.6.RELEASE</version>
        </dependency>


        <!--完善监控信息-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>



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

    </dependencies>

配置文件

bootstrap.yml 系统级别的配置

# 系统级别的配置

spring:
  cloud:
    config:
      name: config-client  #需要从git上读取的资源的名称，不要后缀
      profile: dev
      label: master
      uri: http://localhost:3344

application.yml 用户级别的配置

#用户级别的配置

spring:
  application:
    name: springcloud-config-client-3355

启动类

package com.company.springcloud;


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

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

写一个controller

package com.company.springcloud.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.service-url.defaultZone}")
    private String eurekaServer;
    @Value("${server.port}")
    private String port;


    @RequestMapping("/config")
    public String getConfig(){
        return "applicationName"+applicationName+
                "eurekaServer"+eurekaServer+
                "port"+port;
    }
}

启动3344，3355

访问http://localhost:3344/master/config-client-dev.yml 可以得到信息

访问http://localhost:8201/config 得到信息，默认远程的dev配置文件的端口

修改bootstrap.yml profiles为test，即远程端口为8202

# 系统级别的配置

spring:
  cloud:
    config:
      name: config-client  #需要从git上读取的资源的名称，不要后缀
      profile: test
      label: master
      uri: http://localhost:3344

Config：远程配置实战测试

本地git项目新建config-eureka.yml

spring:
  profiles:
    active: dev

---
server:
  port: 7001
  
  
#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-config-eureka
#Eureka配置
eureka:
  instance:
    hostname: eureka7001.com        #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      #单机：defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群（关联）：
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
      
      
---
server:
  port: 7001
  
#spring的配置
spring:
  profiles: test
  application:
    name: springcloud-config-eureka

#Eureka配置
eureka:
  instance:
    hostname: eureka7001.com        #Eureka服务端的实例名称
  client:
    register-with-eureka: false  #表示是否向eureka注册中心注册自己
    fetch-registry: false  #如果  fetch-registry  为false，则表示自己为注册中心
    service-url:        #监控页面~
      #单机：defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群（关联）：
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

新建config-dept.yml

数据库一个是db01，一个是db02

spring:
  profiles:
    active: dev

---

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.company.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml


#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-config-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001  #修改eureka上的默认描述信息！
    prefer-ip-address: true          #可以显示服务的ip地址

#info配置
info:
  app.name: ming-springcloud
  company.name: blog.mingstudy.com
  
  
---

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.company.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml


#spring的配置
spring:
  profiles: test
  application:
    name: springcloud-config-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db02?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

# Eureka配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001  #修改eureka上的默认描述信息！
    prefer-ip-address: true          #可以显示服务的ip地址

#info配置
info:
  app.name: ming-springcloud
  company.name: blog.mingstudy.com

执行命令

git add .
git commit -m '3'
git push origin master

新建module springcloud-config-eureka-7001

导入依赖

<!--导包-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

eureka-7001 src下的文件复制一份到config-eureka-7001

导入config依赖

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

配置文件

applciation.yml

spring:
  application:
    name: springcloud-config-eureka-7001

bootstrap.yml

# 系统级别的配置

spring:
  cloud:
    config:
      name: config-eureka  #需要从git上读取的资源的名称，不要后缀
      profile: dev
      label: master
      uri: http://localhost:3344

测试

启动3344，自测访问：http://localhost:3344/master/config-eureka-dev.yml 可以得到信息

启动config-eureka-7001 访问http://localhost:7001/ 有eureka页面，说明读到了远程信息

新建module springcloud-config-dept-8001

导入 provider-dept-8001相同的依赖

<dependencies>

    <!--eureka-->
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

    <!--完善监控信息-->
    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>


    <!--我们需要拿到实体类，需要配置api module-->
    <dependency>
        <groupId>org.company</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--数据源-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>

    <!--logback-core-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
    </dependency>

    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>

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

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

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

    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

同时拷贝src下的其他文件

导入config包

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

bootstrap.yml 查找的是db01数据库

# 系统级别的配置

spring:
  cloud:
    config:
      name: config-dept  #需要从git上读取的资源的名称，不要后缀
      profile: dev
      label: master
      uri: http://localhost:3344

application.yml

spring:
  application:
    name: springcloud-config-dept-8001

之前启动了config7001，3344启动config-8001

访问http://localhost:8001/dept/get/1 得到db01的数据

这样就可以通过远程修改配置

posted @ 2020-11-15 20:24 yourText 阅读(129) 评论(2) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

yourText

这个世界有70亿人，总有人愿意为你爬上月亮

SpringCloud

SpringCloud

微服务和微服务架构

微服务

微服务架构

微服务优缺点

为什么选择SpringCloud作为微服务架构

什么是SpringCloud

SpringCloud是什么

Dubbo和SpringCloud技术选型

SpringCloud能干吗

Rest学习环境搭建：服务提供者

总项目pom配置

子模块springcloud-api

搭建数据库环境

创建实体类（必须序列化）

子模块 springcloud-provider-dept

配置文件

Dao接口和mapper.xml

Service 接口和实现类

Controller类

启动测试

Rest学习环境搭建：服务消费者

pom文件

config

controller

启动类

测试

服务注册与发现

什么是Eureka

原理讲解

新建一个模块springcloud-eureka-7001

Eureka：服务注册-信息配置-自我保护机制

服务端

自我保护机制

服务端增加注册发现Controller

Eureka：集群环境配置

Eureka：CAP原则及对比Zookeeper

CAP原则

ACID是什么

CAP是什么

CAP理论的核心

Ribbon：负载均衡及Ribbon

Ribbon是什么

Ribbon能干嘛

消费者导入ribbon依赖

Ribbon:使用Ribbon实现负载均衡

Ribbon：自定义负载均衡算法

Feign负载均衡

简介

Feign能干什么

Feign集成了Ribbon

Hystrix：服务熔断

分布式系统面临的问题

服务雪崩

什么是Hystrix

能干吗

服务熔断

Hystrix：服务降级

Hystrix：Dashboard流监控

Zuul：路由网关

概述

SpringCloud config 分布式配置

概述

SpringCloud Config分布式配置中心能干嘛

SpringCloud config分布式配置中心与github整合

Config:Git环境搭建

Config：服务端连接Git配置

Config：客户端连接服务端访问远程

Config：远程配置实战测试

公告