使用Sentinel实现隔离、限流

                package
                 com.xin.sentinel.demo.entity;


                public
                class
                 User {
    
                int
                 id;
    String name;
    
                int
                 age;
    
                int
                 level;
    String address;
    String password;
    String phone;

    
                public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public User(String name) {
        this.id = -1;
        this.name = name;
    }

    public User() {
    }

    publicint getId() {
        return id;
    }

    publicvoid setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    publicint getAge() {
        return age;
    }

    publicvoid setAge(int age) {
        this.age = age;
    }

    publicint getLevel() {
        return level;
    }

    publicvoid setLevel(int level) {
        this.level = level;
    }

    public String getAddress() {
        return address;
    }

    publicvoid setAddress(String address) {
        this.address = address;
    }

    public String getPassword() {
        return password;
    }

    publicvoid setPassword(String password) {
        this.password = password;
    }

    public String getPhone() {
        return phone;
    }

    publicvoid setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ", level=" + level +
                ", address=‘" + address + ‘\‘‘ +
                ", password=‘" + password + ‘\‘‘ +
                ", phone=‘" + phone + ‘\‘‘ +
                ‘}‘;
    }
}

                package
                 com.xin.sentinel.demo.service;


                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.xin.sentinel.demo.entity.User;

                import
                 com.xin.sentinel.demo.dao.DB;

                import
                 org.springframework.stereotype.Service;


                import
                 java.util.Collections;

@Service

                public
                class
                 UserService {

    
                public
                static
                final String USER_RES = "userResource";

    public UserService(){
        // 定义热点限流的规则，对第一个参数设置 qps 限流模式，阈值为5
        FlowRule rule = new FlowRule();
        rule.setResource(USER_RES);
        // 限流类型，qps        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置阈值
        rule.setCount(4);
        // 限制哪个调用方        rule.setLimitApp(RuleConstant.LIMIT_APP_DEFAULT);
        // 基于调用关系的流量控制        rule.setStrategy(RuleConstant.STRATEGY_DIRECT);
        // 流控策略        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }

    /**
     * SphU 包含了 try-catch 风格的 API。用这种方式，当资源发生了限流之后会抛出 BlockException。
     * 这个时候可以捕捉异常，进行限流之后的逻辑处理.
     * @param uid
     * @return*/public User getUser(int uid){
        Entry entry = null;
        // 资源名可使用任意有业务语义的字符串，比如方法名、接口名或其它可唯一标识的字符串。try {
            // 流控代码
            entry = SphU.entry(USER_RES);
            // 业务代码
            User user = new User();
            user.setId(uid);
            user.setName("user-" + uid);
            DB.InsertUser(user); //长耗时的工作return user;
        }catch(BlockException e){
            // 被限流了
            System.out.println("[getUser] has been protected! Time="+System.currentTimeMillis());
        }finally {
            if(entry!=null){
                entry.exit();
            }
        }
        returnnull;
    }


    /**
     * 通过 @SentinelResource 注解定义资源并配置 blockHandler 和 fallback 函数来进行限流之后的处理
     * @param id
     * @return*/
    @SentinelResource(blockHandler = "blockHandlerForGetUser")
    public User getUserById(String id) {
        thrownew RuntimeException("getUserById command failed");
    }

    // blockHandler 函数，原方法调用被限流/降级/系统保护的时候调用public User blockHandlerForGetUser(String id, BlockException ex) {
        returnnew User("admin");
    }


}

                package
                 com.xin.sentinel.demo.controller;


                import
                 com.xin.sentinel.demo.entity.User;

                import
                 com.xin.sentinel.demo.service.UserService;

                import
                 org.springframework.beans.factory.annotation.Autowired;

                import
                 org.springframework.stereotype.Controller;

                import
                 org.springframework.web.bind.annotation.GetMapping;

                import
                 org.springframework.web.bind.annotation.RequestParam;

                import
                 org.springframework.web.bind.annotation.ResponseBody;

@Controller

                public
                class
                 Demo {

    @Autowired
    
                private
                 UserService userService;
    
                /**
                
     * 获取用户信息
     
                */
                
    @GetMapping("/getUser")
    public @ResponseBody User getUser(@RequestParam("id") int id) {
        return userService.getUser(id);
    }


}

                public
                class
                 FlowThreadDemo {

    
                private
                static AtomicInteger pass = new AtomicInteger();
    privatestatic AtomicInteger block = new AtomicInteger();
    privatestatic AtomicInteger total = new AtomicInteger();
    privatestatic AtomicInteger activeThread = new AtomicInteger();

    privatestaticvolatileboolean stop = false;
    privatestaticfinalint threadCount = 100;

    privatestaticint seconds = 60 + 40;
    privatestaticvolatileint methodBRunningTime = 2000;

    publicstaticvoid main(String[] args) throws Exception {
        System.out.println(
            "MethodA will call methodB. After running for a while, methodB becomes fast, "
                + "which make methodA also become fast ");
        tick();
        initFlowRule();

        for (int i = 0; i < threadCount; i++) {
            Thread entryThread = new Thread(new Runnable() {
                @Override
                publicvoid run() {
                    while (true) {
                        Entry methodA = null;
                        try {
                            TimeUnit.MILLISECONDS.sleep(5);
                            methodA = SphU.entry("methodA");
                            activeThread.incrementAndGet();
                            Entry methodB = SphU.entry("methodB");
                            TimeUnit.MILLISECONDS.sleep(methodBRunningTime);
                            methodB.exit();
                            pass.addAndGet(1);
                        } catch (BlockException e1) {
                            block.incrementAndGet();
                        } catch (Exception e2) {
                            // biz exception
                        } finally {
                            total.incrementAndGet();
                            if (methodA != null) {
                                methodA.exit();
                                activeThread.decrementAndGet();
                            }
                        }
                    }
                }
            });
            entryThread.setName("working thread");
            entryThread.start();
        }
    }

    privatestaticvoid initFlowRule() {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource("methodA");
        // set limit concurrent thread for ‘methodA‘ to 20
        rule1.setCount(20);
        rule1.setGrade(RuleConstant.FLOW_GRADE_THREAD);
        rule1.setLimitApp("default");

        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
    }

    privatestaticvoid tick() {
        Thread timer = new Thread(new TimerTask());
        timer.setName("sentinel-timer-task");
        timer.start();
    }

    staticclass TimerTask implements Runnable {

        @Override
        publicvoid run() {
            long start = System.currentTimeMillis();
            System.out.println("begin to statistic!!!");

            long oldTotal = 0;
            long oldPass = 0;
            long oldBlock = 0;

            while (!stop) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                long globalTotal = total.get();
                long oneSecondTotal = globalTotal - oldTotal;
                oldTotal = globalTotal;

                long globalPass = pass.get();
                long oneSecondPass = globalPass - oldPass;
                oldPass = globalPass;

                long globalBlock = block.get();
                long oneSecondBlock = globalBlock - oldBlock;
                oldBlock = globalBlock;

                System.out.println(seconds + " total qps is: " + oneSecondTotal);
                System.out.println(TimeUtil.currentTimeMillis() + ", total:" + oneSecondTotal
                    + ", pass:" + oneSecondPass
                    + ", block:" + oneSecondBlock
                    + " activeThread:" + activeThread.get());
                if (seconds-- <= 0) {
                    stop = true;
                }
                if (seconds == 40) {
                    System.out.println("method B is running much faster; more requests are allowed to pass");
                    methodBRunningTime = 20;
                }
            }

            long cost = System.currentTimeMillis() - start;
            System.out.println("time cost: " + cost + " ms");
            System.out.println("total:" + total.get() + ", pass:" + pass.get()
                + ", block:" + block.get());
            System.exit(0);
        }
    }
}