微服务治理系列一

2021-12-30  本文已影响0人  架构师老狼

响应式编程

1 spring mvc与spring webflux
2 响应式编程（Reactor 实现）
3 SpringWebflux（基于注解编程模型）
//添加用户
@Override
public Mono<Void> saveUserInfo(Mono<User> userMono) {
    return userMono.doOnNext(person -> {
        //向map集合里面放值
        int id = users.size()+1;
        users.put(id,person);
    }).thenEmpty(Mono.empty());
}

//添加
@PostMapping("/saveuser")
public Mono<Void> saveUser(@RequestBody User user) {
    Mono<User> userMono = Mono.just(user);
    return userService.saveUserInfo(userMono);
}
4 SpringWebflux（基于函数式编程模型）
public void createReactorServer() {
    //路由和handler适配
    RouterFunction<ServerResponse> route = routingFunction();
    HttpHandler httpHandler = toHttpHandler(route);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
    //创建服务器
    HttpServer httpServer = HttpServer.create();
    httpServer.handle(adapter).bindNow();
}

public RouterFunction<ServerResponse> routingFunction() {
    //创建hanler对象
    UserService userService = new UserServiceImpl();
    UserHandler handler = new UserHandler(userService);
    //设置路由
    return RouterFunctions.route(
            GET("/users/{id}").and(accept(APPLICATION_JSON)),handler::getUserById)
            .andRoute(GET("/users").and(accept(APPLICATION_JSON)),handler::getAllUsers);
}

public Mono<ServerResponse> getAllUsers(ServerRequest request) {
    //调用service得到结果
    Flux<User> users = this.userService.getAllUser();
    return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
}

public Flux<User> getAllUser() {
    return Flux.fromIterable(this.users.values());
}

网关gateway

1 核心核心概念
2 动态路由服务
cloud:
    gateway:
      discovery:
        locator:
          enabled: true #开启从注册中心动态创建路由的功能，利用微服务名称j进行路由
          #表示将请求路径的服务名配置改成小写 因为服务注册的时候，向注册中心注册时将服务名转成大写的了
           lower-case-service-id: true
3 lb负载均衡
routes:
# 认证中心
- id: ry-auth
    uri: lb://ry-auth #从注册中心获取服务，且以lb(load-balance)负载均衡方式转发
    predicates:
- Path=/auth/**
    filters:
      - CacheRequestFilter #gateway自定义filter
       - ValidateCodeFilter
       #截取路径的个数，请求/hello/HiController/aaa后端匹配到的请求路径，就会变成http://localhost:8762/HiController/aaa
       - StripPrefix=1
4 多过滤器形成chain，流不能多次读取
DataBufferFactory dataBufferFactory = exchange.getResponse().bufferFactory();
ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(exchange.getRequest()) {
    @Override
    public Flux<DataBuffer> getBody() {
        if (bytes.length > 0) {
            return Flux.just(dataBufferFactory.wrap(bytes));
        }
        return Flux.empty();
    }
};
5 gateway与sentinel限流
@Bean
 @Order(Ordered.HIGHEST_PRECEDENCE)
 public GlobalFilter sentinelGatewayFilter() {
     return new SentinelGatewayFilter();
 }

@PostConstruct
public void initGatewayRules(){
    Set<GatewayFlowRule> rules = new HashSet<>();
    rules.add(
         new GatewayFlowRule("provider_route") //路由名称，serviceid
                   .setCount(1)  //数量
                   .setIntervalSec(1) //每秒
     );
    GatewayRuleManager.loadRules(rules);
}

public class SentinelFallbackHandler implements WebExceptionHandler{
    private Mono<Void> writeResponse(ServerResponse response, ServerWebExchange exchange) {
        return ServletUtils.webFluxResponseWriter(exchange.getResponse(), "请求超过最大数，请稍候再试");
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex)    {
        if (exchange.getResponse().isCommitted()) {
            return Mono.error(ex);
        }
        if (!BlockException.isBlockException(ex)) {
            return Mono.error(ex);
        }
        return handleBlockedRequest(exchange, ex).flatMap(response -> writeResponse(response, exchange));
    }

    private Mono<ServerResponse> handleBlockedRequest(ServerWebExchange exchange, Throwable throwable) {
        return GatewayCallbackManager.getBlockHandler().handleRequest(exchange, throwable);
    }
}

断路器sentinel

1 sentinel与hystrix对比

2 流量控制

2.1 模式

2.2 效果：

3 熔断降级：

3.1 降级方式

3.2 降级策略

3 热点key

4 自定义异常

  @GetMapping("/rateLimit/customerBlockHandler")
    @SentinelResource(value = "customerBlockHandler", blockHandlerClass = CustomerBlockHandler.class, blockHandler = "handlerException2")
    public CommonResult customerBlockHandler() {
        return new CommonResult(200,"按客戶自定义",new Payment(2020L,"serial003"));
    }

public class CustomerBlockHandler {
    public static CommonResult handlerException(BlockException exception) {
        return new CommonResult(4444,"按客戶自定义,global handlerException----1");
    }
    public static CommonResult handlerException2(BlockException exception) {
        return new CommonResult(4444,"按客戶自定义,global handlerException----2");
    }
}
上一篇 下一篇

猜你喜欢

热点阅读