微服务集成spring cloud sentinel

目录

[1. sentinel使用场景](#1. sentinel使用场景)

[2. sentinel组成](#2. sentinel组成)

[3. sentinel dashboard搭建](#3. sentinel dashboard搭建)

[4. sentinel客户端详细使用](#4. sentinel客户端详细使用)

[4.1 引入依赖](#4.1 引入依赖)

[4.2 application.properties增加dashboard注册地址](#4.2 application.properties增加dashboard注册地址)

[4.3 手动增加限流配置类](#4.3 手动增加限流配置类)

[4.4 rest接口及service类](#4.4 rest接口及service类)

[4.5 通过dashboard动态配置限流规则](#4.5 通过dashboard动态配置限流规则)

---

1. sentinel使用场景

限流、熔断、监控、动态规则配置

2. sentinel组成

由两部分组成，

第一个是dashboard监控仪表盘，单独的jar，官网下载后启动，可监控所有服务、动态发现服务、配置限流策略、熔断等；

第二个是sentinel的客户端核心包，供微服务引用，注册到dashboard仪表盘，引入相关pom及设置相关配置即可；

3. sentinel dashboard搭建

启动命令

java -Dserver.port=8400 -Dcsp.sentinel.dashboard.server=localhost:8400 -Dproject.name=hj-sentinel -Dsentinel.dashboard.auth.username=sentinel -Dsentinel.dashboard.auth.password=sentinel -jar sentinel-dashboard-1.8.6.jar

启动成功，地址栏输入localhost:8400, 如图：

4. sentinel客户端详细使用

4.1 引入依赖

<dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
   <version>2.2.5.RELEASE</version>
</dependency>

4.2 application.properties增加dashboard注册地址

spring.cloud.sentinel.transport.dashboard=localhost:8400

4.3 手动增加限流配置类

package hj.example.sampleprovider.sample.config;

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description: sentinel 限流规则配置类
 **/
@Configuration
public class SentinelRulesConfig {
    @Bean
    public void initFlowQpsRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule flowRule = new FlowRule();
        flowRule.setResource("sentinelTest");
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        flowRule.setCount(1);
        flowRule.setLimitApp("default");
        flowRule.setClusterMode(false);
        flowRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(flowRule);

        FlowRule flowRule1 = new FlowRule();
        flowRule1.setResource("sayHello");
        flowRule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        flowRule1.setCount(1);
        flowRule1.setLimitApp("default");
        flowRule1.setClusterMode(false);
        flowRule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(flowRule1);
        FlowRuleManager.loadRules(rules);
    }
}

4.4 rest接口及service类

其中sentinelTest为rest接口限流，sayHello为方法限流

package hj.example.sampleprovider.sample.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.fastjson.JSONObject;
import hj.example.sampleprovider.sample.HelloServiceImpl;
import hj.example.sampleprovider.sample.config.SentinelRulesConfig;
import org.apache.commons.lang.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Description: TODO
 **/
@RestController
public class SentinelTestController {

    @Autowired
    private HelloServiceImpl helloService;

    @RequestMapping("/testClean/{id}")
    public ResponseEntity<Object> testClean(@PathVariable("id") String id) {
        String resultStr = String.format("test clean id: %s [%s]", id, DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss ssss"));
        return new ResponseEntity<>(resultStr , HttpStatus.OK);
    }

    @RequestMapping("/testSentinelDynamicDashboard")
    public ResponseEntity<Object> testSentinelDynamicDashboard() {
        String resultStr = String.format("testSentinelDynamicDashboard [%s]", DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss sss"));
        return new ResponseEntity<>(resultStr, HttpStatus.OK);
    }

    @RequestMapping("/sayHello")
    public ResponseEntity<Object> sayHelloTest() {
        String helloStr = helloService.sayHello("sayHelloTest");
        return new ResponseEntity<>(helloStr, HttpStatus.OK);
    }

    @SentinelResource(value = "sentinelTest", blockHandler = "sentinelTestHandler")
    @RequestMapping("/sentinelTest")
    public ResponseEntity<Object> sentinelTest() {
        System.out.println(" sentinelTest :" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss sss"));
        return new ResponseEntity<>("sentinelTest ", HttpStatus.OK);
    }
    public ResponseEntity<Object>  sentinelTestHandler(BlockException e) {
        System.out.println("被限流了");
        return new ResponseEntity<>("========sentinelTestHandler 被限流了:" + JSONObject.toJSONString(e), HttpStatus.OK);
    }
}

package hj.example.sampleprovider.sample;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.fastjson.JSON;
import hj.example.sample.IHelloService;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Value;
import test.SentinelTest;

import javax.xml.bind.ValidationException;
import java.util.Date;

@DubboService
public class HelloServiceImpl implements IHelloService {

    @Value("${dubbo.application.name}")
    private String serviceName;

    @SentinelResource(value = "sayHello", blockHandler = "sayHelloBlockHandler")
    public String sayHello(String name) {
        System.out.printf("[%s]: Hello, %s%n", serviceName, name);
        return String.format("[%s]: Hello, %s", serviceName, name);
    }

    public String sayHelloBlockHandler(String name, BlockException e) throws ValidationException {
        System.out.println("sayHello 被限流了。name:" + name + ",被限流了：" + JSON.toJSONString(e));
        return "sayHello 被限流了。name:" + name + ",被限流了：" + JSON.toJSONString(e);
    }

    public void sentinelTestMethod() {
        try(Entry entry = SphU.entry("sentinelTestMethod")) {
            System.out.println("hello sentinel : " + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss sss"));
        }catch (BlockException e) {
            e.printStackTrace();
        }
    }

    public void sentinelTestHandler(BlockException e) throws ValidationException {
        e.printStackTrace();
        throw new ValidationException(e.getMessage());
    }
}

4.5 通过dashboard动态配置限流规则