Hystrix clusters and cluster monitoring turbine

Hystrix clusters and monitor the turbine

Feign , Hystrix integration of service fuse completely decoupled service degradation

After the cluster timeout settings

Hystrix clusters and monitor the turbine

Front Dashboard demo is only a stand-alone service monitoring, real projects are basically clusters, so here is a cluster monitoring turbine.

turbine is based on the Dashboard.

First put forward a cluster;

And then re-engage in a microservice-student-provider-hystrix- 1005 base microservice-student-provider-hystrix- 1004 project on

A copy of the code and configuration, and then modify several places;

1, yml configuration

---
server:
  port: 1004
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application:
    name: microservice-student
  profiles: provider-hystrix-1004

eureka:
  instance:
    hostname: localhost
    appname: microservice-student
    instance-id: microservice-student:1004
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://eureka2001.hmc.com:2001/eureka/,http://eureka2002.hmc.com:2002/eureka/,http://eureka2003.hmc.com:2003/eureka/

info:
  groupId: com.hmc.testSpringcloud
  artifactId: microservice-student-provider-hystrix-1004
  version: 1.0-SNAPSHOT
  userName: http://hmc.com
  phone: 123456

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1500

---
server:
  port: 1005
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application:
    name: microservice-student
  profiles: provider-hystrix-1005

eureka:
  instance:
    hostname: localhost
    appname: microservice-student
    instance-id: microservice-student:1005
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://eureka2001.hmc.com:2001/eureka/,http://eureka2002.hmc.com:2002/eureka/,http://eureka2003.hmc.com:2003/eureka/

info:
  groupId: com.hmc.testSpringcloud
  artifactId: microservice-student-provider-hystrix-1005
  version: 1.0-SNAPSHOT
  userName: http://hmc.com
  phone: 123456

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1500

---
server:
  port: 1006
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application:
    name: microservice-student
  profiles: provider-hystrix-1006

eureka:
  instance:
    hostname: localhost
    appname: microservice-student
    instance-id: microservice-student:1006
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://eureka2001.hmc.com:2001/eureka/,http://eureka2002.hmc.com:2002/eureka/,http://eureka2003.hmc.com:2003/eureka/

info:
  groupId: com.hmc.testSpringcloud
  artifactId: microservice-student-provider-hystrix-1006
  version: 1.0-SNAPSHOT
  userName: http://hmc.com
  phone: 123456

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1500

2, startup class configuration

package com.hmc.microservicestudentproviderhystrix;

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

@EnableCircuitBreaker
@EntityScan("com.hmc.*.*")
@EnableEurekaClient
@SpringBootApplication
public class MicroserviceStudentProviderHystrixApplication {

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

}

In this case there hystrix cluster services;

3 , our new project microservice-student-consumer-hystrix- turbine-91

Plus lower dependence pom.xml

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

4 , application.yml

Server: 
  Port: 91 is 
  context-path: / 
Eureka: 
  Client: 
    -Service-URL: 
      defaultzone: http://eureka2001.hmc.com:2001/eureka/,http://eureka2002.hmc.com:2002/eureka/, http://eureka2003.hmc.com:2003/eureka/ 
Turbine: 
  App-config: Student # microService-designated to monitor the application name 
  clusterNameExpression: " 'default'" # represents the name of the cluster to default 
the Spring: 
  the application: 
    name: turbine

1, a new startup class MicroserviceStudentConsumerHystrixTurbine91Application annotated: @EnableTurbine

package com.hmc.microservicestudentconsumerhystrixturbine91;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.cloud.netflix.turbine.EnableTurbine;

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@EnableTurbine
public class MicroserviceStudentConsumerHystrixTurbine91Application {

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

}

test:

First start three Eureka , then 10,041,005 with hystrix services are started;

microservice-student-consumer-80 this also started to facilitate testing;

Dashboard , Turbine start;

In this case HTTP: // localhost / Student / hystrix can call the service cluster;

http: // localhost: 91 / turbine.stream can monitor data, real-time ping returns data

Enter http: // localhost: 90 / hystrix into the dashboard, enter the address

Click into the cluster monitoring instruments:

Feign , Hystrix integration

The previous code, with @HystrixCommand fallbackMethod is very good, because the business code and the coupling is too high, is not conducive to maintenance, it is necessary to decouple, but we're talking about Feign Hystrix integration.

1, microservice-student-provider-hystrix project modifications

We do not have the set of the original. According to the normal logic to write;

StudentService plus a new interface method:

/**
 * 测试Hystrix服务降级
 * @return
 */
public Map<String,Object> hystrix();

StudentServiceImpl写具体实现：
@Override
public Map<String, Object> hystrix() {
    Map<String,Object> map=new HashMap<String,Object>();
    map.put("code", 200);
    map.put("info","工号【"+port+"】正在为您服务");
    return map;
}

StudentProviderController正常调用service方法：

/**
     * 测试Hystrix服务降级
     * @return
     * @throws InterruptedException
     */
    @ResponseBody
    @GetMapping(value="/hystrix")
//    @HystrixCommand(fallbackMethod="hystrixFallback")
    public Map<String,Object> hystrix() throws InterruptedException{
        Thread.sleep(100);
//        Map<String,Object> map=new HashMap<String,Object>();
//        map.put("code", 200);
//        map.put("info","工号【"+port+"】正在为您服务");
        return this.studentService.hystrix();
    }

//    public Map<String,Object> hystrixFallback() throws InterruptedException{
//        Map<String,Object> map=new HashMap<String,Object>();
//        map.put("code", 500);
//        map.put("info", "系统【"+port+"】繁忙，稍后重试");
//        return map;
//    }

2、microservice-common项目新建FallbackFactory类，解耦服务熔断服务降级

StudentClientService接口，新增getInfo方法；

/**
 * 服务熔断降级
 * @return
 */
@GetMapping(value="/student/hystrix")
public Map<String,Object> hystrix();

新建 StudentClientFallbackFactory 类，实现FallbackFactory<StudentClientService>接口；

package com.hmc.microservicecommon.service;

import com.hmc.microservicecommon.entity.Student;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
public class StudentClientFallbackFactory implements FallbackFactory<StudentClientService> {

    @Override
    public StudentClientService create(Throwable cause) {
        return new StudentClientService() {

            @Override
            public boolean save(Student student) {
                return false;
            }

            @Override
            public List<Student> list() {
                return null;
            }

            @Override
            public Map<String, Object> hystrix() {
                Map<String,Object> map=new HashMap<String,Object>();
                map.put("code", 500);
                map.put("info", "系统繁忙，稍后重试");
                return map;
            }

            @Override
            public Student get(Integer id) {
                return null;
            }

            @Override
            public boolean delete(Integer id) {
                return false;
            }

            @Override
            public String ribbon() {
                return null;
            }
        };
    }

}

StudentClientService接口的@FeignClient注解加下 fallbackFactory属性

@FeignClient(value="MICROSERVICE-STUDENT",fallbackFactory=StudentClientFallbackFactory.class)

这类我们实现了降级处理方法实现；

3、microservice-student-consumer-feign-80修改支持Hystrix

StudentConsumerFeignController新增方法调用

/**
 * Feign整合Hystrix服务熔断降级
 * @return
 * @throws InterruptedException
 */
@GetMapping(value="/hystrix")
public Map<String,Object> hystrix() throws InterruptedException{
    return studentClientService.hystrix();
}

4、microservice-student-consumer-feign-80的application.yml加上hystrix支持

feign:
  hystrix:
    enabled: true

1、microservice-student-consumer-feign-80的启动类上添加公共模块

@ComponentScan(basePackages = {"com.hmc.microservicecommon","com.hmc.microservicestudentconsumerfeign80"})

注意：

u 公共子项目与当前子项目的基包都要扫描到；

u 只指定公共子模块为基包会导致本子项目的springmvc功能失效；

u 只指定本子项目为基包会导致feign与Hystrix集成失败，从而导致服务熔断功能失效

package com.hmc.microservicestudentconsumerfeign80;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackages = {"com.hmc.microservicecommon","com.hmc.microservicestudentconsumerfeign80"})//扫描公共模块
@EnableFeignClients(value = "com.hmc.*.*")
@EnableEurekaClient
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class MicroserviceStudentConsumerFeign80Application {

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

}

测试开启三个eureka，以及带hystrix的provider，和带feign,hystrix的consummer。

测试的话，也是没问题的。0.9秒的话，返回正常信息；超过1秒的话，就返回错误提示；

集群后超时设置

上面错误是什么原因呢，咱们明明在Hystrix中的application.yml中设置了

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1500

这里因为还有一个 feign 也有一个超时时间的设置，当然feign底层是 ribbon的封装，所以直接配置ribbon，ribbon默认超时也是1秒。

所以这里都是强制要求，ribbon的超时时间要大于hystrix的超时时间，否则 hystrix自定义的超时时间毫无意义。

所以还得microservice-student-consumer-feign-80上加个 ribbon超时时间设置

ribbon:
  ReadTimeout: 10000
  ConnectTimeout: 9000

这样就完工了。可以自行测试。