「java熔断源码」熔断器java

admin 2023-01-11 04:45:09 508

今天给各位分享java熔断源码的知识，其中也会对熔断器java进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、java springcloud中为什么用熔断,不用异常机制？
2、自定义springcloud-gateway熔断处理
3、java 如何实现服务熔断
4、如何查看javaJDK中底层源码
5、求java学习路线图？

java springcloud中为什么用熔断,不用异常机制？

一个微服务的超时失败可能导致瀑布式连锁反映，当对某个微服务的调用失败达到一个特定的阀值(5秒之内发生20次失败是Hystrix定义的缺省值), 链路就会被处于open状态，之后所有所有对这个微服务的调用都不会被执行。

超时是靠异常捕获的，熔断是一个调度管理机制。

自定义springcloud-gateway熔断处理

一、场景

使用spring cloud gateway后，有了熔断，问题也就随之而来，服务间调用有了hystrix可以及时的排除坏接口、坏服务的问题，对系统很有帮助。但是！不是所有的接口都是极短时间内完成的，不是所有的接口都可以设置一样的超时时间的！

那么我们面临一个问题，那就是百分之99的接口都可以在1s内完美完成，但是就是那几个特殊接口，需要十几秒，几十秒的等待时间，而默认熔断的时间又只有一个。

二、分析

在前面 springcloudgateway源码解析之请求篇中我们知道请求会经过一些列的过滤器（GatewayFilter）,而springcloudgateway的降级熔断处理就是由一个特殊的过滤器来处理的，通过源码分析我们关注到HystrixGatewayFilterFactory这个类，这个类的作用就是生产GatewayFilter用的，我们看下它的实现

可以看到红框处最后构建了一个匿名的GatewayFilter对象返回，这个对象在接口请求过程中会被加载到过滤器链条中，仔细看到这里是创建了一个RouteHystrixCommand这个命令对象，最终调用command.toObservable()方法处理请求，如果超时熔断调用resumeWithFallback方法

通过源码分析 gateway在路由时可以指定HystrixCommandKey，并且对HystrixCommandKey设置超时时间

三、方案

知道网关熔断的原理就好办了,自定义熔断的过滤器配置到接口请求过程中，由过滤器来读取接口熔断配置并构建HystrixObservableCommand处理请求。

自定义一个类XXXGatewayFilterFactory继承AbstractGatewayFilterFactory，将api和对应的timeout配置化，来实现细化到具体接口的熔断配置，具体实现如下：

package org.unicorn.framework.gateway.filter;

import cn.hutool.core.collection.CollectionUtil;

import com.netflix.hystrix.HystrixCommandGroupKey;

import com.netflix.hystrix.HystrixCommandKey;

import com.netflix.hystrix.HystrixCommandProperties;

import com.netflix.hystrix.HystrixObservableCommand;

import com.netflix.hystrix.exception.HystrixRuntimeException;

import org.springframework.beans.factory.ObjectProvider;

import org.springframework.cloud.gateway.filter.GatewayFilter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;

import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;

import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;

import org.springframework.cloud.gateway.support.TimeoutException;

import org.springframework.core.annotation.AnnotatedElementUtils;

import org.springframework.http.server.reactive.ServerHttpRequest;

import org.springframework.stereotype.Component;

import org.springframework.util.AntPathMatcher;

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

import org.springframework.web.reactive.DispatcherHandler;

import org.springframework.web.server.ResponseStatusException;

import org.springframework.web.server.ServerWebExchange;

import org.springframework.web.util.UriComponentsBuilder;

import reactor.core.publisher.Mono;

import rx.Observable;

import rx.RxReactiveStreams;

import rx.Subscription;

import java.net.URI;

import java.util.Collections;

import java.util.List;

import java.util.function.Function;

/**

* @Author: xiebin

* @Description:

* @Date:Create：in 2022-07-06 9:17

@Component

public class UnicornHystrixGatewayFilterFactoryextends AbstractGatewayFilterFactory {

private static final StringNAME ="unicornHystrix";

private ObjectProviderdispatcherHandlerProvider;

private AntPathMatcherantPathMatcher;

public UnicornHystrixGatewayFilterFactory(ObjectProvider dispatcherHandlerProvider) {

super(Config.class);

this.dispatcherHandlerProvider = dispatcherHandlerProvider;

this.antPathMatcher =new AntPathMatcher();

}

@Override

public ListshortcutFieldOrder() {

return Collections.singletonList(NAME_KEY);

}

/**

* 获取服务ID

* @param exchange

* @return

public StringserviceId(ServerWebExchange exchange) {

ServerHttpRequest request = exchange.getRequest();

String path = request.getPath().pathWithinApplication().value();

try {

path = path.split("/")[1];

return path;

}catch (Exception e) {

return "default";

}

/**

* @param key

* @param timeout

* @return

private HystrixObservableCommand.SetterinitSetter(String key, Integer timeout) {

HystrixObservableCommand.Setter setter = HystrixObservableCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(key)).andCommandKey(HystrixCommandKey.Factory.asKey(key));

if (timeout !=null) {

setter.andCommandPropertiesDefaults(HystrixCommandProperties.Setter().withExecutionTimeoutInMilliseconds(timeout));

}

return setter;

}

/**

* @param exchange

* @param chain

* @param config

* @return

private UnicornRouteHystrixCommandinitUnicornRouteHystrixCommand(ServerWebExchange exchange, GatewayFilterChain chain, Config config) {

//路由配置的超时设置

List apiTimeoutList = config.getTimeouts();

ServerHttpRequest request = exchange.getRequest();

String path = request.getPath().pathWithinApplication().value();

UnicornRouteHystrixCommand command;

if (CollectionUtil.isNotEmpty(apiTimeoutList)) {

//request匹配属于那种模式

ApiHystrixTimeout apiHystrixTimeout = getApiHystrixTimeout(apiTimeoutList, path);

command =new UnicornRouteHystrixCommand(config.getFallbackUri(), exchange, chain, initSetter(apiHystrixTimeout.getApiPattern(), apiHystrixTimeout.getTimeout()));

}else {

command =new UnicornRouteHystrixCommand(config.getFallbackUri(), exchange, chain, initSetter(serviceId(exchange), null));

}

return command;

}

/**

* @param apiTimeoutList

* @param path

* @return

private ApiHystrixTimeoutgetApiHystrixTimeout(List apiTimeoutList, String path) {

for (ApiHystrixTimeout apiTimeoutPattern : apiTimeoutList) {

if (this.antPathMatcher.match(apiTimeoutPattern.getApiPattern(), path)) {

return apiTimeoutPattern;

}

ApiHystrixTimeout apiHystrixTimeout =new ApiHystrixTimeout();

apiHystrixTimeout.setApiPattern("default");

apiHystrixTimeout.timeout =null;

return apiHystrixTimeout;

}

@Override

public GatewayFilterapply(Config config) {

return (exchange, chain) - {

UnicornRouteHystrixCommand command = initUnicornRouteHystrixCommand(exchange, chain, config);

return Mono.create(s - {

Subscription sub =command.toObservable().subscribe(s::success, s::error, s::success);

s.onCancel(sub::unsubscribe);

}).onErrorResume((Function) throwable - {

if (throwableinstanceof HystrixRuntimeException) {

HystrixRuntimeException e = (HystrixRuntimeException) throwable;

HystrixRuntimeException.FailureType failureType = e.getFailureType();

switch (failureType) {

case TIMEOUT:

return Mono.error(new TimeoutException());

case COMMAND_EXCEPTION: {

Throwable cause = e.getCause();

if (causeinstanceof ResponseStatusException || AnnotatedElementUtils

.findMergedAnnotation(cause.getClass(), ResponseStatus.class) !=null) {

return Mono.error(cause);

}

default:

break;

}

return Mono.error(throwable);

}).then();

};

}

@Override

public Stringname() {

return NAME;

}

private class UnicornRouteHystrixCommandextends HystrixObservableCommand {

private final URIfallbackUri;

private final ServerWebExchangeexchange;

private final GatewayFilterChainchain;

/**

* @param fallbackUri

* @param exchange

* @param chain

public UnicornRouteHystrixCommand(URI fallbackUri, ServerWebExchange exchange, GatewayFilterChain chain, HystrixObservableCommand.Setter setter) {

super(setter);

this.fallbackUri = fallbackUri;

this.exchange = exchange;

this.chain = chain;

}

@Override

protected Observableconstruct() {

return RxReactiveStreams.toObservable(this.chain.filter(exchange));

}

@Override

protected ObservableresumeWithFallback() {

if (null ==fallbackUri) {

return super.resumeWithFallback();

}

URI uri =exchange.getRequest().getURI();

boolean encoded = ServerWebExchangeUtils.containsEncodedParts(uri);

URI requestUrl = UriComponentsBuilder.fromUri(uri)

.host(null)

.port(null)

.uri(this.fallbackUri)

.build(encoded)

.toUri();

exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, requestUrl);

ServerHttpRequest request =this.exchange.getRequest().mutate().uri(requestUrl).build();

ServerWebExchange mutated =exchange.mutate().request(request).build();

DispatcherHandler dispatcherHandler = UnicornHystrixGatewayFilterFactory.this.dispatcherHandlerProvider.getIfAvailable();

return RxReactiveStreams.toObservable(dispatcherHandler.handle(mutated));

}

public static class ApiHystrixTimeout {

public StringgetApiPattern() {

return apiPattern;

}

public void setApiPattern(String apiPattern) {

this.apiPattern = apiPattern;

}

public IntegergetTimeout() {

return timeout;

}

public void setTimeout(Integer timeout) {

this.timeout = timeout;

}

private StringapiPattern;

private Integertimeout;

}

public static class Config {

private Stringid;

private URIfallbackUri;

/**

* url - timeout ms

private Listtimeouts;

public StringgetId() {

return id;

}

public ConfigsetId(String id) {

this.id = id;

return this;

}

public URIgetFallbackUri() {

return fallbackUri;

}

public ConfigsetFallbackUri(URI fallbackUri) {

if (fallbackUri !=null !"forward".equals(fallbackUri.getScheme())) {

throw new IllegalArgumentException("Hystrix Filter currently only supports 'forward' URIs, found " + fallbackUri);

}

this.fallbackUri = fallbackUri;

return this;

}

public ListgetTimeouts() {

return timeouts;

}

public ConfigsetTimeouts(List timeouts) {

this.timeouts = timeouts;

return this;

}

配置示例

spring.cloud.gateway.default-filters[0].name=unicornHystrix

spring.cloud.gateway.default-filters[0].args.fallbackUri=forward:/defaultFallback

spring.cloud.gateway.default-filters[0].args.timeouts[0].apiPattern=/gf-oss-service//oss/part/upload

spring.cloud.gateway.default-filters[0].args.timeouts[0].timeout=100000

java 如何实现服务熔断

用length()方法、charAt方法结合for循环就行了，

package com.golden.test;

public class TestString {

public static void main(String[] args) {

String str = "你叫神马？我叫Tesson.";

for (int i = 0; i str.length(); i++) {

char item = str.charAt(i);

System.out.println(item);

}

如何查看javaJDK中底层源码

在初次使用java时，往往我们对最基本的java类会忽略对其内部基本的实现的了解，也往往不屑于了解其内部实现机制，以为它们本来就是这样子。而其实贯穿java的整个过程，所有上层的使用，都是源于对底层的扩展，所以要真正去了解这门语言，就必须得从其底层开始认真去了解它。而要深入了解，就需要更多去关注其内部的实现是怎样子的。

在使用IDE的过程中，我们经常会需要能在IDE中就可以便捷的去查看java的源码，但若没有做相关设置，一般在IDE是查看不了java源码的，此次提供在eclipse中设置查看java源码的方式。

设置步骤如下:

1.点 “window”- "Preferences" - "Java" - "Installed JRES"

2.此时"Installed JRES"右边是列表窗格，列出了系统中的 JRE 环境，选择你的JRE，然后点边上的 "Edit..."，会出现一个窗口(Edit JRE)

3.选中rt.jar文件的这一项：“c:\program files\java\jre_1.8\lib\rt.jar”

点左边的“+” 号展开它，

4.展开后，可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”, 选择你的JDK目录下的 “src.zip”文件(该文件在JDK安装目录的根目录下)

5.一路点"ok"，设置完成

设置完成后，按住ctrl键再用鼠标单击某一个jdk方法名或类名，便能看到该方法的源代码了。此外按F3也能实现。

PS：rt.jar包含了jdk的基础类库，也就是你在java

doc里面看到的所有的类的class文件；src.zip文件里面放着的正是基本类所对应的源文件（即*.java格式的文件）；同理，我们可以去网上下载各个JAVA开源框架所对应的源代码包，比如spring-src.zip，然后再按照上面的设置步骤设置，就可以查看到对应的JAVA框架源代码了。

转自：网页链接

求java学习路线图？

/*回答内容很长，能看完的少走一个月弯路，绝不抖机灵*/

提前预警：本文适合Java新手阅读(老手可在评论区给下建议)，希望大家看完能有所收获。

废话不多少了，先了解一下Java零基础入门学习路线：

第一阶段：JavaSE阶段

变量、数据类型、运算符

二进制和十进制的转化

注释、单行注释、多行注释、文本注释、注释内容和字节码的关系

标识符、关键字、驼峰原则

变量的本质、内存画图、变量声明和初始化

变量的分类和作用域（局部变量、成员变量、静态变量）

常量和Final

基本数据类型介绍

整型变量和整型常量

浮点类型、float、double

char字符型、转义字符

boolean布尔型、if语句使用要点、布尔类型占用空间问题

运算符介绍

算数运算符（二元、自增、自减）

赋值和赋值运算符

关系运算符详解

逻辑运算符、短路运算符详解

位运算符详解

字符串连接符

条件运算符（三元运算符）

运算符优先级问题

自动类型转换详解

强制类型装换详解

基本数据类型装换常见错误、溢出、L问题

使用Scanner获取键盘输入

控制语句

控制语句和实现逻辑对应

if单选结构

if_elseif_else多选结构

switch语句_IDEA更换主题

循环_while

循环_for循环_dowhile

嵌套循环

break和continue语句_标签_控制语句底层原理

写一个年薪计算机_百度查问题的秘诀（重要）

个人所得税计算器软件

方法核心详解_天才思维模型教你高手学习思维模式

方法的重载

递归结构讲解_递归头_递归体

面向对象编程-基础

面向过程和面向对象的区别

类和对象的概述

类的属性和方法

创建对象内存分析

构造方法（Construtor）及重载

对象类型的参数传递

this关键字

static关键字详解

局部代码块、构造代码块和静态代码块

package和import详解

JavaDoc生成API文档

面向对象编程-进阶

面向对象的三大特性

面向对象之【封装(Encapsulation)】

访问权限修饰符

面向对象之【继承（Inheritance）】

Object类

方法重写Override

super关键字详解

重写equals()和toString()

继承中对象创建的内存分析

面向对象之【多态（Polymorphism）】

向上转型

向下转型

instanceof运算符

编译时和运行时详解

final修饰符

抽象类和抽象方法（abstrct）

接口的定义和实现

JDK8的接口新特性

接口应用：内部类比较器Comparable

内部类详解

Java的内存管理与垃圾回收

异常机制

异常的概述

异常的执行过程与分析

try-catch-finally捕捉异常

throw抛出异常

throws声明异常

异常继承体系

运行时异常和编译异常

自定义异常

Java常用类

Wrapper包装类

自动装箱和自动拆箱

包装类的源码分析

String类的使用与内存原理

String类的源码分析

StringBuffer

StringBuilder

字符串处理类性能分析

Date类

System类

DateFormat类

Calendat类

Math类

BigInteger类和BigDecimal类

Random类

枚举类

File类

常见的面试题讲述与分析

数据结构算法

数据结构的概述

线性表

顺序表

链表

栈和队列

树

二叉树

二叉查找树

二叉平衡树

黑红树

图

冒泡排序

选择排序

递归

折半查找

集合（容器）

集合和数组的联系和区别

集合框架体系

ArrayList的使用和源码分析

集合中使用泛型

LinkedList的使用和源码分析

HashSet的使用和源码分析

哈希表及原理

TreeSet的使用和源码分析

比较器Comparable和Comparator

HashMap的使用和源码分析

TreeMap的使用和源码分析

Iterator于ListIterator

Collections工具类

旧集合类Vector、Hashtable

集合总结和选择依据

泛型接口

泛型类

泛型方法

IO流

IO流的概念

IO流的分类及其原理分析

文件流FlieInputStream、FileOutputStream

缓冲流BufferedInputStream、BufferedOutputStream

数据流ObjectInputStream、ObjectOutputStream

序列化和反序列化

转换流InputStreamReader、OutputStreamWriter

打印流PrintWrite和PrintStream

数组流ByteArrayOutputStream、ByteArrayInputStream

使用IO复制文件夹

多线程

进程和线程

线程的创建与启动

创建线程的三种方式对比

线程的生命周期

线程控制

多线程的安全问题与解决办法

线程的同步：同步代码块

线程的同步：同步方法

线程的同步：Lock锁

线程的死锁问题

线程通信

Condition

线程的完整生命周期

线程池ThreadPoolExecutor

ForkJoin框架

ThreadLocal类

网络编程

计算机网络基础知识

网络通信协议

OSI参考模型

TCP/IP参考模型

数据的封装与拆封原理解析

TCP协议

UDP协议

IP地址和端口号

URL和Socket

使用TCP编程实现登录功能

使用UDP编程实现客服系统

使用TCP编程实现文件上传

集合提升寻训练

手写ArrayList

手写单链表

手写Linkedlist

手写HashMap

手写HashSet