【Spring Cloud】Spring Cloud使用总结

项目概要

项目环境信息

IDEA ultimate 2018.3.2
springboot 2.1.7.RELEASE
springCloud Greenwich.SR2
此处输入图片的描述

Eureka 介绍

基于netflix eureka做了二次封装
两个组件组成:

  • Eureka Server 注册中心
  • Eureka Client 服务注册

搭建Eureka Server

1、配置Eureka 的application.yml

eureka:
   client:
      serviceUrl:
          defaultZone: http://localhost:8761/eureka/
      #默认为true,是否向自己注册自己
      register-with-eureka: false 
   #关闭Eureka自我保护(生产环境要设置为true,测试环境设置为false)
   server:
     enable-self-preservation: false 
#配置服务实例名
spring:
   application:
      name: spring-cloud-eureka
#配置服务实例端口
server:
   port: 8761

注意:如果报错读取application.yml文件错误,检查Settings->File Encodings,全部设置为UTF-8
2、配置Eureka pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.practice</groupId>
    <artifactId>eureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
    </properties>

    <dependencies>
        <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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

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

</project>

3、Eureka 入口类

package com.practice.eureka;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {

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

}

4、Eureka的高可用

设置启动端口在VM options设置启动端口
-Dserver.port=8761

此处输入图片的描述
启动多个可以如下配置,相互注册
此处输入图片的描述

Eureka Server有心跳检测、健康检查、负载均衡等功能。

可以启动多个Eureka Server,互相注册(通过修改端口启动多个Eureka Server,修改注册中心地址为对方实现互相注册)
比如,启动了Eureka Server1 和 Eureka Server2
这样Eureka Client在注册到其中一台Eureka Server后(如Server1),也会同步到另一个Eureka Server。
如果Eureka Server1挂掉了,另一台Eureka Server2仍然可用,并可以发现客户端。

但是如果重新启动Eureka Client,则会发现由于Server1已经停掉了,则无法正常注册,也就无法同步到Server2

为了确保高可用,可以将Client同时注册到所有的Eureka上

-注册中心地址配置
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka,http://localhost:8762/eureka

如果超过两台以上的Eureka Server,为保证高可用,则可以设置其两两注册,同时将Client同时注册到所有Eureka Server上。

注册发现

1、客户端入口类
添加EnableDiscoveryClient,提供eureka客户端

package com.practice.client;

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

@SpringBootApplication
@EnableDiscoveryClient
public class ClientApplication {

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

}

2、Client新建application.yml

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka/
    #页面跳转后台端口前名称
#   instance:
#      hostname: product 
#客户端实例在注册中心的名称
spring:
   application:
      name: product
   # mysql数据库连接信息
   datasource:
     driver-class-name: com.mysql.jdbc.Driver
     username: root
     password: 123456
     url: jdbc:mysql://127.0.0.1:3306/springcloud_sell?characterEncoding=utf-8&useSSL=false
   # 打开jpa日志,在控制台打印
   jpa:
     show-sql: true
env: 
   dev

3、Client新建pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.practice</groupId>
    <artifactId>client</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>client</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
    </properties>

    <dependencies>
        <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-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

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

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

</project>

4、客户端书写中间实体(*)
下面的JsonProperty中的value是序列化后的名称,定义的名称是为了更好的理解属性

@Data
public class ProductVO {

    /**
     * 此处需要返回给前端name,但是表示的是类目名称,所以添加JsonProperty进行标识
     */
    @JsonProperty("name")
    private String categoryName;

    @JsonProperty("type")
    private Integer categoryType;

    @JsonProperty("foods")
    List<ProductInfoVO> productInfoVOList;
}

Ribbon实现负载均衡

1、了解Ribbon

Eureka属于客户端发现,客户端会向服务器拉取可用的服务器信息,根据负载均衡服务,命中那台服务器发送请求,整个过程都是在客户端完成,并不需要服务器的参与。

Ribbon是netflix ribbon实现的,通过springcloud的封装,轻松的面向服务的rest的模板请求,自动的转换为客户端服务调用。

RestTemplate/zuul/Feign都使用到了Ribbon

SpringCloud在结合Ribbon的负载均衡实践中,封装增加了HTTPClient和OKHttpClient 两种请求端实现,默认使用了Ribbon对Eureka的客户端发现的负载均衡client

2、Ribbon的工作原理

轮寻RoundRobinRule、随机连接RandomRule

Ribbon实现软负载均衡核心有三点

(1)服务发现:依据实例名称,把该实例下所有的实例都找出来

(2)服务选择规则:依据规则从多个规则中选择有效的服务

(3)服务监听:检测失效的服务,做到高效剔除

Ribbon主要组件

serverList (获取所有的可用服务列表)----> ServerListFilter(过滤掉一部分地址) -----> IRule从剩下的地址中选择一个实例,作为目标结果。

HTTP服务调用方式RestTemplate 操作和Feign简单对比

RestTemplate使用的三种方式

详解restTemplate操作 https://blog.csdn.net/itguangit/article/details/78825505

方式一:直接使用restTemplate,路径固定了不好修改
restTemplate对于路径的访问比较固定,如果线上部署,不好进行修改;或者是启动了多个实例,不好进行捕获和调用

RestTemplate restTemplate = new RestTemplate();
String response = restTemplate.getForObject("http://localhost:9001/msg", String.class);
log.info("response{}",response);
return response;

方式二:利用LoadBalancerClient通过应用名获取url,然后在使用restTemplate
注入LoaderBalancerClient,通过服务名称进行获取服务的ip和端口号

 @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/getProductMsg")
    public String getProductMsg(){

        // 方式二:(利用LoadBalancerClient通过应用名获取url,然后在使用restTemplate)
        RestTemplate restTemplate = new RestTemplate();
        ServiceInstance serviceInstance = loadBalancerClient.choose("PRODUCT");
        String url = String.format("http://%s:%s", serviceInstance.getHost(),serviceInstance.getPort() + "/msg");
        String response = restTemplate.getForObject(url, String.class);

        log.info("response{}",response);
        return response;
    }

方式三:通过LoadBalanced实例化restTemplate

@Component
public class RestTemplateConfig {

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

通过实例名称进行访问,随机分配一个服务

String response = restTemplate.getForObject("http://PRODUCT/msg", String.class);

Feign进行通信

  • 声明式Rest客户端(伪RPC)
  • 采用了基于接口的注解

第一步:引入pom.xml依赖

<!--应用间通信-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
</dependency>

第二步:添加EnableFeignClient注解

第三步:通过@FeignClient声明被调用的服务信息

@FeignClient(value = "product", fallback = ProductClientFallbackImpl.class )
public interface ProductClient {

    /**
     * 获取产品端的信息
     *
     * @return
     */
    @GetMapping("/msg")
    String getProductMsg();
}

通过fallback处理异常等信息

@Component
@Slf4j
public class ProductClientFallbackImpl implements ProductClient {
    /**
     * 获取产品端的信息
     *
     * @return
     */
    @Override
    public String getProductMsg() {
        log.info("返回消息接口出现问题");
        return null;
    }
}

Config配置中心

为什么需要统一配置中心?
不方便维护
配置内容安全与权限
更新配置项目需要重启

Config Server服务端配置

1、Config服务引入pom.xml

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

2、Config服务配置yml文件

spring:
  application:
    name: micro-weather-config-server
  cloud:
    config:
      server:
        git:
          ## 统一配置的仓库
          uri: https://github.com/MarkGao11520/spring-cloud-repo/
          username: xxxx
          password: xxxx
          # 拉取下来的文件防止位置
          basedir: /Users/gaowenfeng/project/idea/springcloud_sell/config/basedir
          ## 仓库路径
          search-paths: config-repo

eureka:
    # 服务的url
    service-url:
      defaultZone: http://localhost:8761/eureka/

server:
  port: 8888

配置中心需要配置远程git仓库存储配置
配置中心获取配置文件的两种方式:
/{name}-{profiles}.yml
/{label}/{name}-{profiles}.yml

name 服务名
profiles 环境
label 分支(branch)

第一种默认使用的是master分支

3、Config启动类上引入ConfigServer注解

@SpringBootApplication
@EnableEurekaClient
@EnableConfigServer
public class ConfigApplication {

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

Config Client客户端配置

1、order客户端pom.xml

<!--config配置中心-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-client</artifactId>
</dependency>

1.这里如果配置文件名称为application.xxx的话,会搞乱顺序,先找配置中心再找注册中心,这样会找不到,会导致去加载默认的8888
2. eureka.service-url的配置需要在本地,不然会找不到注册中心
bootstrap.yml中配置

# 配置规则
#所以应该叫bootstrap.yml

# /{application}/{profile}[/{label}] 
# /{application}-{profile}.yml
# /{application}-{profile}.properties
# /{label}/{application}-{profile}.yml 
# /{label}/{application}-{profile}.properties 
spring:
  application:
    # 配置规则里的{application}
    name: micro-weather-config-client
  cloud:
    config:
      # 找到配置的方式一
      # uri: http://localhost:8888
      # 配置规则里的${profile}
      # profile: bus-dev
      # 配置规则里的${label},label 是分支,不是路径!
      # label: test

      # 找到配置的方式二
      discovery:
        enabled: true
        service-id: CONFIG
      profile: test
eureka:
    # 服务的url
    service-url:
      defaultZone: http://localhost:8761/eureka/

测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class MicroWeatherConfigClientApplicationTests {

	@Value("${version}")
	private String version;

	@Test
	public void contextLoads() {
		Assert.assertEquals("1.0",version);
	}

}

配置完成之后通过

localhost:8989/order-dev.yml进行访问

通过localhost:8989/bus/refresh 进行动态刷新本地的配置信息

配置中心出现的问题:

a、springcloud 消息总线读取配置文件的两种方式

https://blog.csdn.net/qq_35275233/article/details/89074886

b、springcloud监控配置中心健康状态

https://blog.csdn.net/qq_35275233/article/details/89074380

c、SpringCloud 配置中心执行bus/refresh 出现 Full authentication is required to
access this resource

https://blog.csdn.net/qq_35275233/article/details/89074294

Spring Cloud Bus 自动刷新配置

1、添加依赖

rabbitmq 的bus依赖添加
config server 和client的版本应该对应起来才可以
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
        </dependency>

2、将bus-refresh接口暴露出去

## 变量名可能会变,利用自动提示可以找到对应的正确配置变量 (输入management.endpoints 找到默认包含一个[health,info]数组的变量,修改为"*")
management:
  endpoints:
    web:
      暴露所有接口
      expose: "*"

3、修改使用配置的客户端的地方

@RestController
@RequestMapping("/env")
@RefreshScope // 加入这个注解自动刷新配置
public class EnvController {

    @Value("${env}")
    private String env;

    @GetMapping("/print")
    public String print() {
        return env;
    }
}
}

@Data
@Component
@ConfigurationProperties("girl")
@RefreshScope // 加入这个注解自动刷新配置
public class GirlConfig {

    private String name;

    private Integer age;
}

4、使用

修改git的配置以后,POST 请求访问 "http://192.161.4:8080/actuator/bus-refresh" 即可(这个路径可能会变,具体请查阅启动日志)

5、集成WebHooks实现动态更新

在GitHub或者其他git工具上配置webhook,然后就可以实现,在git更新的时候,发送请求给我们的config服务器让其刷新配置

通过RabbitMQ给各服务发送消息

1、发送消息

/**
 * 测试给家电和水果服务发送消息
 */
@Test
public void sendOrderMqMsg() {
    amqpTemplate.convertAndSend("myOrder","computer","now:" + new Date());
}

2、设置消息监听

 /**
     * 1/测试给家电服务发送消息
     * @param message
     */
    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange("myOrder"),
            key = "computer",
            value = @Queue("computerOrder")
    ))
    public void processComputer (String message) {

          log.info("ComputerOrder:{}",message);
    }

    /**
     * 2/测试给水果服务发送消息
     * @param message
     */
    @RabbitListener(bindings = @QueueBinding(
            exchange = @Exchange("myOrder"),
            key = "fruit",
            value = @Queue("fruitOrder")
    ))
    public void processFruit (String message) {

        log.info("FruitOrder:{}",message);
    }

Spring Cloud Stream

此处输入图片的描述

官方定义stream为微服务应用构建消息驱动能力的框架,为springcloud的另一个组件

目前springcloud支持的消息中间件是RabbitMQ和Kafka
1、引入pom.xml

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

服务网关和Zuul

核心依赖

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

启动类

/**
 * Eureka 客户端启动类
 * 启用Eureka客户端
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
public class MicroWeatherEurekaClientApplication {

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

配置

spring:
  application:
    name: micro-weather-eureka-client

eureka:
    # 服务的url
    service-url:
      defaultZone: http://localhost:8761/eureka/
zuul:
  routes:
    # 将city的请求转发到应用msa-weather-city-server
    city:
      path: /city/**
      serviceId: msa-weather-city-server
    # 将data的请求转发到应用msa-weather-data-server
    data:
      path: /data/**
      serviceId: msa-weather-data-server

路由 + 过滤器 = zuul

除了spring bus外,zuul也可以实现自动刷新配置

/**
 * 实现配置的动态注入
 */
@Component
public class ZuulConfig {

    @ConfigurationProperties("zuul")
    @RefreshScope
    public ZuulProperties zuulProperties() {
        return new ZuulProperties();
    }
}

Zuul的高可用

  • 多个Zuul节点注册到Eureka Server
  • Nginx和Zuul的“混搭”

pre和post过滤器

1、访问前进行参数校验

pre-filter:请求到目标结果之前,对返回的结果进行加工,访问连接中需要添加token,进行接口加密校验

@Component
public class TokenFilter extends ZuulFilter {

    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        return PRE_DECORATION_FILTER_ORDER - 1;
    }

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

    @Override
    public Object run() {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();

        String token = request.getParameter("token");
        if (StringUtils.isEmpty(token)) {
            requestContext.setSendZuulResponse(false);
            requestContext.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
        }
        return null;
    }
}

2、post-fileter : 请求到目标结果之后,对返回的结果进行加工

@Component
public class AddResponseHeaderFilter extends ZuulFilter {

    @Override
    public String filterType() {
        return POST_TYPE;
    }

    @Override
    public int filterOrder() {
        return SEND_RESPONSE_FILTER_ORDER - 1;
    }

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

    @Override
    public Object run() {
        /**
         * 往返回的结果添加x-foo
         */
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletResponse response = requestContext.getResponse();
        response.setHeader("X-FOO", UUID.randomUUID().toString());
        return null;
    }
}

此处输入图片的描述

Zuul 限流

时机:请求被转发之前调用

令牌桶:拿到令牌的放行

此处输入图片的描述

限流过滤器

/**
 * 限流过滤器
 */

@Component
public class RateLimitFilter extends ZuulFilter {

    /**
     * guava的令牌桶算法:放入100个令牌
     */
    private static final RateLimiter RATE_LIMITER = RateLimiter.create(100);

    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        return SERVLET_DETECTION_FILTER_ORDER - 1;
    }

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

    @Override
    public Object run() {
        /**
         * tryAcquire(1, 0, TimeUnit.MICROSECONDS);
         * 取到一个令牌
         */
        if (!RATE_LIMITER.tryAcquire()) {
            throw new RateLimitException();
        }
        return null;
    }
}

参考资料:
微信点餐系统 springcloud学习笔记
dependencies与dependencyManagement的区别
springcloud(一)-集成Eureka 服务注册与发现
Springcloud(二)-拆分微服务
SpringCloud(三)-应用间通信
springcloud(四)-zuul网关与config统一配置
Springcloud-hystrix断路器实现

本博客用于技术学习,所有资源都来源于网络,部分是转发,部分是个人总结。欢迎共同学习和转载,转载请在醒目位置标明原文。如有侵权,请留言告知,及时撤除。
posted @ 2019-08-21 10:08  风动静泉  阅读(701)  评论(0编辑  收藏  举报