____h个人页面-阿里云开发者社区

Spring AOP 源码解析

基本概念 AOP 是面向切面｜面向方面编程的简称，Aspect-Oriented Programming。 Aspect 是一种模块化机制，是用来描述分散在对象，类，函数中的横切关注点。从关注点分离出横切关注点是面向切面的程序设计的核心概念。分离关注点使解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不在含有针对特定领域问题的代码调用，业务逻辑和特定领域的问题的关系通过切面来封装，维护，这样原本分散在整个程序中的变动就可以很好的管理起来了。基础：待增强对象或者目标对象切面：包含对基础的增强应用配置：可以看成一种编织，通过在AOP体系中提供这个配置环境，将基础和切面结合起来，从而完成切面对目标对象的编织实现 Advice（通知）：定义在连接点做什么，为切面增强提供织入接口。在Spring AOP 中，它主要描述Spring AOP 围绕方法调用而注入的切面行为。 Pointcut（切点）：决定Advice通知应该作用于哪个连接点，也就是说通过Pointcut来定义需要增强的方法集合。 Advisor（通知器）：完成对目标方法的切面增强设计（advice）和关注点的设计以后，需要一个对象把它们结合起来，完成这个作用的就是Advisor（通知器）。通过Advisor ，可以定义应该使用那个通知并在哪个关注点使用它。源码分析 ### 启动过程在Sprint Boot 启动类上加入注解 @EnableAspectJAutoProxy(proxyTargetClass = true) ，注解源码为： @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Import({AspectJAutoProxyRegistrar.class}) public @interface EnableAspectJAutoProxy { boolean proxyTargetClass() default false; boolean exposeProxy() default false; } 该注解使用 @Import 注解引入 AspectJAutoProxyRegistrar ，跟踪 AspectJAutoProxyRegistrar 类： class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { /** * Register, escalate, and configure the AspectJ auto proxy creator based on the value * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing * {@code @Configuration} class. */ @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata , BeanDefinitionRegistry registry) { /* 往容器中注入AnnotationAwareAspectJAutoProxyCreator类，bean名称为 org.springframework.aop.config.internalAutoProxyCreator */ AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); /* 读取主配置类的 EnableAspectJAutoProxy的注解的属性 */ AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class); if (enableAspectJAutoProxy != null) { if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); } if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry); } } } } 通过源码发现，AspectJAutoProxyRegistrar 类实现了ImportBeanDefinitionRegistrar 接口，在容器启动的时候会调用所有实现ImportBeanDefinitionRegistrar的 bean 的registerBeanDefinitions 方法。在方法内部：1.调用 org.springframework.aop.config.AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry) a. 在`registerAspectJAnnotationAutoProxyCreatorIfNecessary` 方法内部： public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null); } 最终调用 org.springframework.aop.config.AopConfigUtils#registerOrEscalateApcAsRequired 方法, 参数cls 为 AnnotationAwareAspectJAutoProxyCreator.class private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); if (registry.containsBeanDefinition( "org.springframework.aop.config.internalAutoProxyCreator")) { BeanDefinition apcDefinition = registry.getBeanDefinition( "org.springframework.aop.config.internalAutoProxyCreator"); if (!cls.getName().equals(apcDefinition.getBeanClassName())) { int currentPriority = findPriorityForClass( apcDefinition.getBeanClassName()); int requiredPriority = findPriorityForClass(cls); if (currentPriority < requiredPriority) { apcDefinition.setBeanClassName(cls.getName()); } } return null; } else { RootBeanDefinition beanDefinition = new RootBeanDefinition(cls); beanDefinition.setSource(source); beanDefinition.getPropertyValues().add("order", -2147483648); beanDefinition.setRole(2); registry.registerBeanDefinition( "org.springframework.aop.config.internalAutoProxyCreator", beanDefinition); return beanDefinition; } } 在方法内部，首先检查容器中是否包含名称为 org.springframework.aop.config.internalAutoProxyCreator 的bean ，容器第一次启动总不包含该bean，进入else 逻辑，创建一个 AnnotationAwareAspectJAutoProxyCreator.class的bean定义，并且注册bean的名称为AnnotationAwareAspectJAutoProxyCreator.class 2.调用org.springframework.context.annotation.AnnotationConfigUtils#attributesFor(org.springframework.core.type.AnnotatedTypeMetadata, java.lang.Class<?>) 该类主要完成读取主配置类的 EnableAspectJAutoProxy的注解的属性。主要检查 proxyTargetClass 和 exposeProxy 属性的值 AnnotationAwareAspectJAutoProxyCreator 在容器启动的过程中， AOP 向容器中注入了一个 AnnotationAwareAspectJAutoProxyCreator 的 bean ，我们来分析一下这个bean 。类的继承体系：通过类的继承体系，我们发现 AnnotationAwareAspectJAutoProxyCreator 实现了 BeanFactoryAware ，BeanClassLoaderAware， SmartInstantiationAwareBeanPostProcessor，InstantiationAwareBeanPostProcessor ， BeanPostProcessor ， BeanClassLoaderAware 等接口来介入容器启动过程容Bean的生命周期。类的接口实现：在 AnnotationAwareAspectJAutoProxyCreator的接口实现中： BeanFactoryAware接口：定义了setBeanFactory 接口，在容器启动的时候调用org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#setBeanFactory： @Override public void setBeanFactory(BeanFactory beanFactory) { // 设置容器 super.setBeanFactory(beanFactory); if (!(beanFactory instanceof ConfigurableListableBeanFactory)) { throw new IllegalArgumentException( "AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory); } initBeanFactory((ConfigurableListableBeanFactory) beanFactory); } protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 创建增强器探索工具 this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory); } 其中initBeanFactory 最终调用org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator#initBeanFactory： @Override protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 调用父类的initBeanFactory方法 super.initBeanFactory(beanFactory); if (this.aspectJAdvisorFactory == null) { // 创建Aspect增强器工厂 this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory); } // 创建一个增强器的构建器 this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory); } InstantiationAwareBeanPostProcessor接口：我们知道在spring 容器创建任意一个bean的过程中。在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean的方法中： @Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // ... 省略代码 try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } Object beanInstance = doCreateBean(beanName, mbdToUse, args); //... 省略代码 } 在调用真正创建bean的方法doCreateBean 之前，先调用了 resolveBeforeInstantiation方法。我们跟踪org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation 方法： protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // Make sure bean class is actually resolved at this point. // 当容器中存在InstantiationAwareBeanPostProcessors 时，调用InstantiationAwareBeanPostProcessors 的 postProcessBeforeInstantiation 方法和 postProcessAfterInitialization 方法 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } return bean; } 当容器中存在InstantiationAwareBeanPostProcessors的bean时 1.先调用applyBeanPostProcessorsBeforeInstantiation方法，2.然后在调用applyBeanPostProcessorsAfterInitialization 方法跟踪 applyBeanPostProcessorsBeforeInstantiation 方法 protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { // 获取容器中所有BeanPostProcessor，若BeanPostProcessor 是InstantiationAwareBeanPostProcessor ，则调用其 postProcessBeforeInstantiation 方法 for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName); if (result != null) { return result; } } } return null; } 在applyBeanPostProcessorsBeforeInstantiation 方法内部，首先获取容器中所有BeanPostProcessor，若BeanPostProcessor 是InstantiationAwareBeanPostProcessor ，则调用其 postProcessBeforeInstantiation 方法。然后我们在容器启动的时候，在容器中注册了AnnotationAwareAspectJAutoProxyCreator 并且这个bean 实现的InstantiationAwareBeanPostProcessor接口，所以在容器创建bean的时候，会触发AnnotationAwareAspectJAutoProxyCreator的applyBeanPostProcessorsBeforeInstantiation方法。这个是Spring AOP 的真正入口。接下来我们详细分析： org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation （AnnotationAwareAspectJAutoProxyCreator 继承了 AbstractAutoProxyCreator ） postProcessBeforeInstantiation 调用链：详细分析：在postProcessBeforeInstantiation 中查找所有的增强器org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation的源码如下，在容器创建任何一个bean的时候触发： public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) { //1.先获取 bean的key Object cacheKey = getCacheKey(beanClass, beanName); //2. 判断bean是否已经处理过，处理过的bean被放入targetSourcedBeans 集合中。 if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) { //3.判断是否已经包含bean的增强器 if (this.advisedBeans.containsKey(cacheKey)) { return null; } //4.判断bean类型和是否应该跳过 if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return null; } } // Create proxy here if we have a custom TargetSource. // Suppresses unnecessary default instantiation of the target bean: // The TargetSource will handle target instances in a custom fashion. TargetSource targetSource = getCustomTargetSource(beanClass, beanName); if (targetSource != null) { if (StringUtils.hasLength(beanName)) { this.targetSourcedBeans.add(beanName); } Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); // 创建代理bean Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } return null; } 1.先获取 bean的key2.判断bean是否已经处理过，处理过的bean被放入targetSourcedBeans 集合中。3.判断是否已经包含bean的增强器4.判断是否是需要增强的bean a.判断bean的类型是否为基础类：Advice，Pointcut，Advisor，AopInfrastructureBean进入isInfrastructureClass源码: protected boolean isInfrastructureClass(Class<?> beanClass) { boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass); if (retVal && logger.isTraceEnabled()) { logger.trace(""); } return retVal; } b.判断是否跳过处理，进入shouldSkip方法源码 @Override protected boolean shouldSkip(Class<?> beanClass, String beanName) { // 查找容器中所有的候选的增强器列表 List<Advisor> candidateAdvisors = findCandidateAdvisors(); // 若列表中包含当前bean的增强器，返回true for (Advisor advisor : candidateAdvisors) { if (advisor instanceof AspectJPointcutAdvisor && ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) { return true; } } return super.shouldSkip(beanClass, beanName); } 跟踪findCandidateAdvisors 方法内部： @Override protected List<Advisor> findCandidateAdvisors() { // Add all the Spring advisors found according to superclass rules. // 容器中所有实现Advisor接口的bean组件，熟悉 Spring 事物的都知道，Advisor接口是为Spring事务服务的 List<Advisor> advisors = super.findCandidateAdvisors(); // Build Advisors for all AspectJ aspects in the bean factory. // 查找容器是标注@Aspect 组件的bean ，并解析bean的标注 @Before， @After， @AfterReturning， @AfterThrowing 的方法，即查找增强器。并加入缓存中。 if (this.aspectJAdvisorsBuilder != null) { advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors()); } return advisors; } 5.后续第一次执行不到 postProcessAfterInitialization 调用链：详细过程：跟踪org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization源码： @Override public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { if (bean != null) { Object cacheKey = getCacheKey(bean.getClass(), beanName); if (this.earlyProxyReferences.remove(cacheKey) != bean) { // 必要的话，包装代理对象 return wrapIfNecessary(bean, beanName, cacheKey); } } return bean; } 进入wrapIfNecessary方法： protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { return bean; } if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { return bean; } // 判断是否生成代理对象 if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } // 获取通知和增强器 // Create proxy if we have advice. Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) { this.advisedBeans.put(cacheKey, Boolean.TRUE); // 创建代理对象 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } 跟踪getAdvicesAndAdvisorsForBean()方法最终调用：org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors： protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { // 找到候选的增强器 List<Advisor> candidateAdvisors = findCandidateAdvisors(); // 筛选可用的增强器 List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); // 扩展 extendAdvisors(eligibleAdvisors); if (!eligibleAdvisors.isEmpty()) { // 排序 eligibleAdvisors = sortAdvisors(eligibleAdvisors); } return eligibleAdvisors; } 跟踪： findCandidateAdvisors()： @Override protected List<Advisor> findCandidateAdvisors() { // Add all the Spring advisors found according to superclass rules. // 查找所有实现Advisor的接口的增强器 List<Advisor> advisors = super.findCandidateAdvisors(); // Build Advisors for all AspectJ aspects in the bean factory. if (this.aspectJAdvisorsBuilder != null) { // 查找所有Aspect ，查找容器是标注@Aspect 组件的bean ，并解析bean的标注 @Before， @After， @AfterReturning， @AfterThrowing 的方法，即查找增强器。并加入缓存中。 advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors()); } return advisors; } 跟踪：findAdvisorsThatCanApply 并最终调用：org.springframework.aop.support.AopUtils#findAdvisorsThatCanApply public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) { if (candidateAdvisors.isEmpty()) { return candidateAdvisors; } List<Advisor> eligibleAdvisors = new ArrayList<>(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) { eligibleAdvisors.add(candidate); } } boolean hasIntroductions = !eligibleAdvisors.isEmpty(); for (Advisor candidate : candidateAdvisors) { if (candidate instanceof IntroductionAdvisor) { // already processed continue; } if (canApply(candidate, clazz, hasIntroductions)) { eligibleAdvisors.add(candidate); } } return eligibleAdvisors; } 进入 canApply方法：最终调用：org.springframework.aop.support.AopUtils#canApply(org.springframework.aop.Pointcut, java.lang.Class<?>, boolean)方法： public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) { Assert.notNull(pc, "Pointcut must not be null"); if (!pc.getClassFilter().matches(targetClass)) { return false; } MethodMatcher methodMatcher = pc.getMethodMatcher(); if (methodMatcher == MethodMatcher.TRUE) { // No need to iterate the methods if we're matching any method anyway... return true; } // 创建方法匹配器 IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null; if (methodMatcher instanceof IntroductionAwareMethodMatcher) { introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher; } Set<Class<?>> classes = new LinkedHashSet<>(); if (!Proxy.isProxyClass(targetClass)) { classes.add(ClassUtils.getUserClass(targetClass)); } classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); for (Class<?> clazz : classes) { Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz); for (Method method : methods) { if (introductionAwareMethodMatcher != null ? introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) : // 匹配切面的方法 methodMatcher.matches(method, targetClass)) { return true; } } } return false; } getAdvicesAndAdvisorsForBean 方法逻辑分析结束。跟踪createProxy 方法：org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) { if (this.beanFactory instanceof ConfigurableListableBeanFactory) { AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); } // 创建代理工厂 ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.copyFrom(this); // 设置使用JDK代理还是使用CGLIB代理 if (!proxyFactory.isProxyTargetClass()) { if (shouldProxyTargetClass(beanClass, beanName)) { proxyFactory.setProxyTargetClass(true); } else { evaluateProxyInterfaces(beanClass, proxyFactory); } } // 织入增强器 Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); proxyFactory.addAdvisors(advisors); proxyFactory.setTargetSource(targetSource); customizeProxyFactory(proxyFactory); proxyFactory.setFrozen(this.freezeProxy); if (advisorsPreFiltered()) { proxyFactory.setPreFiltered(true); } // 创建代理对象，代理对象持有增强器。 return proxyFactory.getProxy(getProxyClassLoader()); } 这样 postProcessAfterInitialization 的逻辑就分析。总结在分析了Spring AOP的启动过程，总结一下总体过程： 1.setBeanFacotry 接口，在容器启动的时候，创建了 BeanFactoryAdvisorRetrievalHelperAdapter 增强器探索更具和BeanFactoryAspectJAdvisorsBuilderAdapter 增强器的构建器 2.postProcessBeforeInstantiation 接口：查找所有的切面和Advisor，并将切面的通知解析，构建成初步的增强器，加入到缓存中来。 3.postProcessAfterInitialization 接口，从缓存取出所有的将所有的增强器，创建代理工厂，并织入增强器，创建代理对象调用过程：待更新...

Spring Cloud Zuul 源码解析

Zuul 架构图 Zuul的官方文档中的架构图从架构图中可以看到 Zuul 通过Zuul Servlet 和一系列 Zuul Filter 来完成智能路由和过滤器的功能。 Zuul 工作原理概述(转) 在Zuul中，整个请求的过程是这样的，首先将请求给 ZuulServlet 处理，ZuulServlet中有一个ZuulRunner对象，该对象中初始化了RequestContext, RequestContext 作为整个请求的上下文，封装了请求的一些数据，并被所有的ZuulFilter共享。ZuulRunner 中还有 FilterProcessor ，FilterProcessor作为执行所有的ZuulFilter的管理器。FilterProcessor从 FilterLoader 中获取ZuulFilter，而ZuulFilter是被FilterFileManager所加载，并支持groovy热加载，采用了轮询的方式热加载。有了这些Filter之后，ZuulServlet首先执行的pre类型的过滤器，再执行route类型的过滤器，最后执行的是post 类型的过滤器。如果在执行这些过滤器有错误的时候则会执行error类型的过滤器。执行完这些过滤器，最终将请求的结果返回给客户端。 Zuul 启动—源码分析在程序的启动类上加@EnableZuulProxy 注解，我们可以使用Zuul 提供的功能了，该注解的源码为： @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Import({ZuulProxyMarkerConfiguration.class}) public @interface EnableZuulProxy { } 源码中，@EnableZuulProxy 引入了ZuulProxyMarkerConfiguration 配置类，跟踪ZuulProxyMarkerConfiguration 类： public class ZuulProxyMarkerConfiguration { public ZuulProxyMarkerConfiguration() { } @Bean public ZuulProxyMarkerConfiguration.Marker zuulProxyMarkerBean() { return new ZuulProxyMarkerConfiguration.Marker(); } class Marker { Marker() { } } } 在ZuulProxyMarkerConfiguration 配置类中，发现只是注册了一个ZuulProxyMarkerConfiguration.Marker的bean。我们通过分析应该会有依赖这个bean的配置类。然后我们找到了 ZuulProxyAutoConfiguration 依赖了ZuulProxyMarkerConfiguration.Marker的bean。跟踪 ZuulProxyAutoConfiguration ： @Configuration @Import({RestClientRibbonConfiguration.class, OkHttpRibbonConfiguration.class, HttpClientRibbonConfiguration.class, HttpClientConfiguration.class}) @ConditionalOnBean({Marker.class}) public class ZuulProxyAutoConfiguration extends ZuulServerAutoConfiguration { @Bean @ConditionalOnMissingBean({DiscoveryClientRouteLocator.class}) public DiscoveryClientRouteLocator discoveryRouteLocator() { return new DiscoveryClientRouteLocator(this.server.getServlet().getContextPath(), this.discovery, this.zuulProperties, this.serviceRouteMapper, this.registration); } @Bean @ConditionalOnMissingBean({PreDecorationFilter.class}) public PreDecorationFilter preDecorationFilter(RouteLocator routeLocator, ProxyRequestHelper proxyRequestHelper) { return new PreDecorationFilter(routeLocator, this.server.getServlet().getContextPath(), this.zuulProperties, proxyRequestHelper); } @Bean @ConditionalOnMissingBean({RibbonRoutingFilter.class}) public RibbonRoutingFilter ribbonRoutingFilter(ProxyRequestHelper helper, RibbonCommandFactory<?> ribbonCommandFactory) { RibbonRoutingFilter filter = new RibbonRoutingFilter(helper, ribbonCommandFactory, this.requestCustomizers); return filter; } @Bean @ConditionalOnMissingBean({SimpleHostRoutingFilter.class, CloseableHttpClient.class}) public SimpleHostRoutingFilter simpleHostRoutingFilter(ProxyRequestHelper helper, ZuulProperties zuulProperties, ApacheHttpClientConnectionManagerFactory connectionManagerFactory, ApacheHttpClientFactory httpClientFactory) { return new SimpleHostRoutingFilter(helper, zuulProperties, connectionManagerFactory, httpClientFactory); } @Bean @ConditionalOnMissingBean({SimpleHostRoutingFilter.class}) public SimpleHostRoutingFilter simpleHostRoutingFilter2(ProxyRequestHelper helper, ZuulProperties zuulProperties, CloseableHttpClient httpClient) { return new SimpleHostRoutingFilter(helper, zuulProperties, httpClient); } @Bean @ConditionalOnMissingBean({ServiceRouteMapper.class}) public ServiceRouteMapper serviceRouteMapper() { return new SimpleServiceRouteMapper(); } } 我们发现在类ZuulProxyAutoConfiguration中，引入了RestClientRibbonConfiguration, OkHttpRibbonConfiguration, HttpClientRibbonConfiguration, HttpClientConfiguration，Zuul默认是用HttpClientRibbonConfiguration做负载均衡配置，注入了DiscoveryClient、RibbonConfiguration用作负载均衡相关。注入了一些列的Filter,pre类型: PreDecorationFilter ; // 装饰 Requestroute类型: RibbonRoutingFilter , SimpleHostRoutingFilter ; // 路由Filter在ZuulProxyAutoConfiguration 的父类ZuulServerAutoConfiguration中，也引入了一些配置信息: @EnableConfigurationProperties({ZuulProperties.class}) @ConditionalOnClass({ZuulServlet.class, ZuulServletFilter.class}) @ConditionalOnBean({Marker.class}) public class ZuulServerAutoConfiguration { // 在缺失`ZuulServlet`的情况下注入`ZuulServlet` @Bean @ConditionalOnMissingBean( name = {"zuulServlet"} ) @ConditionalOnProperty( name = {"zuul.use-filter"}, havingValue = "false", matchIfMissing = true ) public ServletRegistrationBean zuulServlet() { ServletRegistrationBean<ZuulServlet> servlet = new ServletRegistrationBean(new ZuulServlet(), new String[]{this.zuulProperties.getServletPattern()}); servlet.addInitParameter("buffer-requests", "false"); return servlet; } // 在缺失`ZuulServletFilter`的情况下注入`ZuulServletFilter` @Bean @ConditionalOnMissingBean( name = {"zuulServletFilter"} ) @ConditionalOnProperty( name = {"zuul.use-filter"}, havingValue = "true", matchIfMissing = false ) public FilterRegistrationBean zuulServletFilter() { FilterRegistrationBean<ZuulServletFilter> filterRegistration = new FilterRegistrationBean(); filterRegistration.setUrlPatterns(Collections.singleton(this.zuulProperties.getServletPattern())); filterRegistration.setFilter(new ZuulServletFilter()); filterRegistration.setOrder(2147483647); filterRegistration.addInitParameter("buffer-requests", "false"); return filterRegistration; } // 注入 `ServletDetectionFilter` @Bean public ServletDetectionFilter servletDetectionFilter() { return new ServletDetectionFilter(); } // 注入 `FormBodyWrapperFilter` @Bean public FormBodyWrapperFilter formBodyWrapperFilter() { return new FormBodyWrapperFilter(); } // 注入 `DebugFilter` @Bean public DebugFilter debugFilter() { return new DebugFilter(); } // 注入 `Servlet30WrapperFilter` @Bean public Servlet30WrapperFilter servlet30WrapperFilter() { return new Servlet30WrapperFilter(); } // 注入 `SendResponseFilter` @Bean public SendResponseFilter sendResponseFilter(ZuulProperties properties) { return new SendResponseFilter(this.zuulProperties); } // 注入 `SendErrorFilter` @Bean public SendErrorFilter sendErrorFilter() { return new SendErrorFilter(); } // 注入 `SendForwardFilter` @Bean public SendForwardFilter sendForwardFilter() { return new SendForwardFilter(); } @Configuration protected static class ZuulFilterConfiguration { @Autowired private Map<String, ZuulFilter> filters; protected ZuulFilterConfiguration() { } // ZuulFilterInitializer，在初始化类中将Filter向FilterRegistry注册 @Bean public ZuulFilterInitializer zuulFilterInitializer(CounterFactory counterFactory, TracerFactory tracerFactory) { FilterLoader filterLoader = FilterLoader.getInstance(); FilterRegistry filterRegistry = FilterRegistry.instance(); return new ZuulFilterInitializer(this.filters, counterFactory, tracerFactory, filterLoader, filterRegistry); } } } 父类ZuulServerAutoConfiguration中，在缺失ZuulServlet ，ZuulServletFilter的bean的情况下，注入ZuulServlet ，ZuulServletFilter。同时也注入了其他的过滤器，pre类型: ServletDetectionFilter，DebugFilter ，Servlet30WrapperFilter ;post类型: SendResponseFilter ; // 响应处理Filterroute类型: SendForwardFilter ; // 重定向处理Filtererror类型 : SendErrorFilter ; // 错误处理Filter 初始化ZuulFilterInitializer类，通过FilterLoader 将所有的Filter 向FilterRegistry注册。我们看一下ZuulFilterInitializer类中部分代码 public class ZuulFilterInitializer { // 初始化完成后注册所有的Filter @PostConstruct public void contextInitialized() { log.info("Starting filter initializer"); TracerFactory.initialize(this.tracerFactory); CounterFactory.initialize(this.counterFactory); Iterator var1 = this.filters.entrySet().iterator(); while(var1.hasNext()) { Entry<String, ZuulFilter> entry = (Entry)var1.next(); this.filterRegistry.put((String)entry.getKey(), (ZuulFilter)entry.getValue()); } } // 销毁前移除所有注册所有的Filter @PreDestroy public void contextDestroyed() { log.info("Stopping filter initializer"); Iterator var1 = this.filters.entrySet().iterator(); while(var1.hasNext()) { Entry<String, ZuulFilter> entry = (Entry)var1.next(); this.filterRegistry.remove((String)entry.getKey()); } this.clearLoaderCache(); TracerFactory.initialize((TracerFactory)null); CounterFactory.initialize((CounterFactory)null); } } Zuul 路由-源码分析 Filter 的执行我们站在了源码的角度分析了 Zuul启动过程。接下来我们通过源码来分析，我们注入的Filter在 Zuul 在一次路由的过程是怎样的执行的。在上部分内容，我们介绍了Zuul的核心类 ZuulServlet是所有请求的入口，我们来进入 ZuulServlet的源码： public class ZuulServlet extends HttpServlet { public ZuulServlet() { } // 在初始化方法里初始化了ZuulRunner public void init(ServletConfig config) throws ServletException { super.init(config); String bufferReqsStr = config.getInitParameter("buffer-requests"); boolean bufferReqs = bufferReqsStr != null && bufferReqsStr.equals("true"); this.zuulRunner = new ZuulRunner(bufferReqs); } // 标准的Servlet的service方法 public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { try { // 调用ZuulRunner的init方法 this.init((HttpServletRequest)servletRequest, (HttpServletResponse)servletResponse); RequestContext context = RequestContext.getCurrentContext(); context.setZuulEngineRan(); try { // 调用ZuulRunner的preRoute方法 this.preRoute(); } catch (ZuulException var12) { this.error(var12); // 调用ZuulRunner的postRoute方法 this.postRoute(); return; } try { this.route(); } catch (ZuulException var13) { this.error(var13); this.postRoute(); return; } try { this.postRoute(); } catch (ZuulException var11) { this.error(var11); } } catch (Throwable var14) { this.error(new ZuulException(var14, 500, "UNHANDLED_EXCEPTION_" + var14.getClass().getName())); } finally { RequestContext.getCurrentContext().unset(); } } } 在 ZuulServlet 源码中， service方法调用 this.init(request,response) , 跟进 init(request,response)方法： void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) { this.zuulRunner.init(servletRequest, servletResponse); } 发现调用的是 ZuulServlet 持有的 ZuulRunner的 init方法，进入 ZuulRunner的 init方法： public void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) { RequestContext ctx = RequestContext.getCurrentContext(); if (this.bufferRequests) { ctx.setRequest(new HttpServletRequestWrapper(servletRequest)); } else { ctx.setRequest(servletRequest); } ctx.setResponse(new HttpServletResponseWrapper(servletResponse)); } 在 ZuulRunner的 init方法中，我们发现只是对Request，Response进行了有条件的包装。我们回退到 ZuulServlet 的方法中，在执行完 init 方法后，调用 this.preRoute() , 跟进preRoute()方法： void preRoute() throws ZuulException { this.zuulRunner.preRoute(); } 调用了 ZuulRunner的 preRoute()方法, 进入ZuulRunner.preRoute() : public void preRoute() throws ZuulException { FilterProcessor.getInstance().preRoute(); } ZuulRunner.preRoute() 中获取了一个FilterProcessor的实例并且执行了其preRoute() 方法，进入FilterProcessor.preRoute()方法： public void preRoute() throws ZuulException { try { this.runFilters("pre"); } catch (ZuulException var2) { throw var2; } catch (Throwable var3) { throw new ZuulException(var3, 500, "UNCAUGHT_EXCEPTION_IN_PRE_FILTER_" + var3.getClass().getName()); } } FilterProcessor.preRoute()方法中，执行this.runFilters()方法并且传入参数pre，进入this.runFilters()方法中： public Object runFilters(String sType) throws Throwable { if (RequestContext.getCurrentContext().debugRouting()) { Debug.addRoutingDebug("Invoking {" + sType + "} type filters"); } boolean bResult = false; //通过FilterLoader的实例获取所有pre的Filter List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType); if (list != null) { for(int i = 0; i < list.size(); ++i) { ZuulFilter zuulFilter = (ZuulFilter)list.get(i); // 执行Filter Object result = this.processZuulFilter(zuulFilter); if (result != null && result instanceof Boolean) { bResult |= (Boolean)result; } } } return bResult; } this.runFilters()方法中通过FilterLoader的实例获取所有pre类型的Filter，并调用this.processZuulFilte(Filter) 执行所有pre类型的Filter。上述分析过程中我们了解了pre类型的Filter在一次路由中优先执行，我们通过一个简单的图了加深一下这个过程这就是一个完整的Filter的执行过程，route 和 post 类型的Filter执行过程也是一致的。 Filter 路由上部分内容我们了解Filter的执行入口，这部分内容我们来了解Zuul是怎么选择路由和负载均衡的。在第一部分Zuul的启动过程中，Zuul 注入了pre类型的Filter，有PreDecorationFilter通过名字我们可以猜测，这个PreDecorationFilter是起到装饰Filter的作用，我们进入PreDecorationFilter.run()源码： public Object run() { RequestContext ctx = RequestContext.getCurrentContext(); String requestURI = this.urlPathHelper.getPathWithinApplication(ctx.getRequest()); // 获取请求路径匹配的路由信息 Route route = this.routeLocator.getMatchingRoute(requestURI); String location; if (route != null) { location = route.getLocation(); if (location != null) { // 在RequextContext中放入请求路径，路由的标识 ctx.put("requestURI", route.getPath()); ctx.put("proxy", route.getId()); if (!route.isCustomSensitiveHeaders()) { this.proxyRequestHelper.addIgnoredHeaders((String[])this.properties.getSensitiveHeaders().toArray(new String[0])); } else { this.proxyRequestHelper.addIgnoredHeaders((String[])route.getSensitiveHeaders().toArray(new String[0])); } //在RequextContext中放入该请求是否是可重试的标识 if (route.getRetryable() != null) { ctx.put("retryable", route.getRetryable()); } if (!location.startsWith("http:") && !location.startsWith("https:")) { if (location.startsWith("forward:")) { ctx.set("forward.to", StringUtils.cleanPath(location.substring("forward:".length()) + route.getPath())); ctx.setRouteHost((URL)null); return null; } //设置路由配置的ServiceId ctx.set("serviceId", location); ctx.setRouteHost((URL)null); ctx.addOriginResponseHeader("X-Zuul-ServiceId", location); } else { ctx.setRouteHost(this.getUrl(location)); ctx.addOriginResponseHeader("X-Zuul-Service", location); } } } else { log.warn("No route found for uri: " + requestURI); location = this.getForwardUri(requestURI); ctx.set("forward.to", location); } return null; } 在run方法中，获取和当前路径匹配的路由信息，将路由相关信息放入RequestContenxt中，路由信息是读取配置文件中的配置。并且放入了一个很重要的标识retryable这个就是决定我们这次请求是否可重试的开关，而这个读取配置文件中的zuul.retryable来决定的。那Zuul到底是怎么进行负载均衡的呢？我们知道Zuul负载均衡底层是通过Ribbon来实现的，并且在启动Zuul的时候，我们注入了一个RibbonRoutingFilter的过滤器。这个类很重要，它主要是完成请求的路由转发。接下来我们看下他的 run方法 public Object run() { RequestContext context = RequestContext.getCurrentContext(); this.helper.addIgnoredHeaders(new String[0]); try { RibbonCommandContext commandContext = this.buildCommandContext(context); ClientHttpResponse response = this.forward(commandContext); this.setResponse(response); return response; } catch (ZuulException var4) { throw new ZuulRuntimeException(var4); } catch (Exception var5) { throw new ZuulRuntimeException(var5); } } 在 run中可以看到，先构建了一个 RibbonCommandContext 然后通过forward()方法转发的，进入forward方法： protected ClientHttpResponse forward(RibbonCommandContext context) throws Exception { Map<String, Object> info = this.helper.debug(context.getMethod(), context.getUri(), context.getHeaders(), context.getParams(), context.getRequestEntity()); RibbonCommand command = this.ribbonCommandFactory.create(context); try { ClientHttpResponse response = (ClientHttpResponse)command.execute(); this.helper.appendDebug(info, response.getRawStatusCode(), response.getHeaders()); return response; } catch (HystrixRuntimeException var5) { return this.handleException(info, var5); } } 在 forward中可以看到，通过 RibbonCommandFactory 创建一个RibbonCommand，然后执行RibbonCommand的execute方法，这个 RibbonCommandFactory 是什么时候注入的呢？在Zuul启动的时候，在 ZuulProxyAutoConfiguration 配置类引入了HttpClientRibbonConfiguration 配置类 @Configuration @Import({RestClientRibbonConfiguration.class, OkHttpRibbonConfiguration.class, HttpClientRibbonConfiguration.class, HttpClientConfiguration.class}) @ConditionalOnBean({Marker.class}) public class ZuulProxyAutoConfiguration extends ZuulServerAutoConfiguration { } 在HttpClientRibbonConfiguration 中注入了 RibbonCommandFactory ，源码如下： @Configuration @RibbonCommandFactoryConfiguration.ConditionalOnRibbonHttpClient protected static class HttpClientRibbonConfiguration { @Autowired( required = false ) private Set<FallbackProvider> zuulFallbackProviders = Collections.emptySet(); protected HttpClientRibbonConfiguration() { } @Bean @ConditionalOnMissingBean public RibbonCommandFactory<?> ribbonCommandFactory(SpringClientFactory clientFactory, ZuulProperties zuulProperties) { return new HttpClientRibbonCommandFactory(clientFactory, zuulProperties, this.zuulFallbackProviders); } } 这个时候我们就明白了 RibbonCommandFactory 是何时注入的了，然后我们在看一下 RibbonCommandFactory.create() 创建RibbonCommand的方法： Zuul 默认使用HttpClientRibbonCommandFactory，进入到create()方法： public HttpClientRibbonCommand create(final RibbonCommandContext context) { /** *服务降级 */ FallbackProvider zuulFallbackProvider = this.getFallbackProvider(context.getServiceId()); String serviceId = context.getServiceId(); /** *负载均衡类，处理请求转发类 */ RibbonLoadBalancingHttpClient client = (RibbonLoadBalancingHttpClient)this.clientFactory.getClient(serviceId, RibbonLoadBalancingHttpClient.class); client.setLoadBalancer(this.clientFactory.getLoadBalancer(serviceId)); /** *将降级、负载，请求转发类、以及其他一些内容 *包装成HttpClientRibbonCommand(这个类继承了HystrixCommand) */ return new HttpClientRibbonCommand(serviceId, client, context, this.zuulProperties, zuulFallbackProvider, this.clientFactory.getClientConfig(serviceId)); } 在 create 方法中，分别创建了FallbackProvider ，RibbonLoadBalancingHttpClient ，从命名上我们就可以知道， FallbackProvider和熔断相关，RibbonLoadBalancingHttpClient和负载均衡相关。然后将这些作为参数创建了HttpClientRibbonCommand 。我们看一下HttpClientRibbonCommand的继承关系。从类继承关系可以看出HttpClientRibbonCommand继承了AbstractRibbonCommand，并且AbstractRibbonCommand继承了HystrixCommand这样我们就了解到HystrixCommand是如何集成进来的了。在HystrixCommand中定义了run抽象接口，并且在AbstractRibbonCommand中实现了该接口。我们回退到RibbonRoutingFilter中 protected ClientHttpResponse forward(RibbonCommandContext context) throws Exception { Map<String, Object> info = this.helper.debug(context.getMethod(), context.getUri(), context.getHeaders(), context.getParams(), context.getRequestEntity()); RibbonCommand command = this.ribbonCommandFactory.create(context); try { ClientHttpResponse response = (ClientHttpResponse)command.execute(); this.helper.appendDebug(info, response.getRawStatusCode(), response.getHeaders()); return response; } catch (HystrixRuntimeException var5) { return this.handleException(info, var5); } } 当完成了RibbonCommand 创建工作后，执行的command.execute() 方法，通过刚刚的分析我们知道了command其实指的是HttpClientRibbonCommand，同时我们也知道HttpClientRibbonCommand继承了HystrixCommand，所以当执行command.execute()时,其实执行的是HttpClientRibbonCommand的run方法。查看源码我们并没有发现run方法，但是其父类AbstractRibbonCommand实现了run方法。所以其实执行的是AbstractRibbonCommand的run方法，进入AbstractRibbonCommand的run方法： protected ClientHttpResponse run() throws Exception { RequestContext context = RequestContext.getCurrentContext(); RQ request = this.createRequest(); boolean retryableClient = this.client instanceof AbstractLoadBalancingClient && ((AbstractLoadBalancingClient)this.client).isClientRetryable((ContextAwareRequest)request); HttpResponse response; if (retryableClient) { response = (HttpResponse)this.client.execute(request, this.config); } else { response = (HttpResponse)this.client.executeWithLoadBalancer(request, this.config); } context.set("ribbonResponse", response); if (this.isResponseTimedOut() && response != null) { response.close(); } return new RibbonHttpResponse(response); } 在run 方法中，先判断是否是重试的client，通过分析，第一次执行的时候，client 为RibbonLoadBalancingHttpClient 从而会调用executeWithLoadBalancer() 方法，但是RibbonLoadBalancingHttpClient并没有executeWithLoadBalancer() 方法，查看而类继承关系图，其父类AbstractLoadBalancerAwareClient实现了executeWithLoadBalancer() ，进入AbstractLoadBalancerAwareClient.executeWithLoadBalancer()方法： public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { LoadBalancerCommand command = this.buildLoadBalancerCommand(request, requestConfig); try { return (IResponse)command.submit(new ServerOperation<T>() { public Observable<T> call(Server server) { URI finalUri = AbstractLoadBalancerAwareClient.this.reconstructURIWithServer(server, request.getUri()); ClientRequest requestForServer = request.replaceUri(finalUri); try { return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig)); } catch (Exception var5) { return Observable.error(var5); } } }).toBlocking().single(); } catch (Exception var6) { Throwable t = var6.getCause(); if (t instanceof ClientException) { throw (ClientException)t; } else { throw new ClientException(var6); } } } 在executeWithLoadBalancer 方法中，首先进入buildLoadBalancerCommand() 方法： protected LoadBalancerCommand<T> buildLoadBalancerCommand(S request, IClientConfig config) { /** * 创建一个RetryHandler，这个很重要它是用来 * 决定利用RxJava的Observable是否进行重试的标准。 */ RequestSpecificRetryHandler handler = this.getRequestSpecificRetryHandler(request, config); Builder<T> builder = LoadBalancerCommand.builder().withLoadBalancerContext(this).withRetryHandler(handler).withLoadBalancerURI(request.getUri()); this.customizeLoadBalancerCommandBuilder(request, config, builder); return builder.build(); } 在buildLoadBalancerCommand() 中通过了 getRequestSpecificRetryHandler（）获取 RequestSpecificRetryHandler 的处理类，这个是个抽象方法，在子类AbstractLoadBalancingClient中实现 public RequestSpecificRetryHandler getRequestSpecificRetryHandler(final S request, final IClientConfig requestConfig) { if (this.okToRetryOnAllOperations) { return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); } else { return !request.getContext().getMethod().equals("GET") ? new RequestSpecificRetryHandler(true, false, this.getRetryHandler(), requestConfig) : new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig); } } 在方法中我们可以看到重试的默认机制。若不配置ribbon.OkToRetryOnAllOperations=true, 默认只是连接失败和GET请求失败才会发生重试。回到executeWithLoadBalancer()方法中： public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException { LoadBalancerCommand command = this.buildLoadBalancerCommand(request, requestConfig); try { return (IResponse)command.submit(new ServerOperation<T>() { public Observable<T> call(Server server) { URI finalUri = AbstractLoadBalancerAwareClient.this.reconstructURIWithServer(server, request.getUri()); ClientRequest requestForServer = request.replaceUri(finalUri); try { return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig)); } catch (Exception var5) { return Observable.error(var5); } } }).toBlocking().single(); } catch (Exception var6) { Throwable t = var6.getCause(); if (t instanceof ClientException) { throw (ClientException)t; } else { throw new ClientException(var6); } } } 调用command.submit() ，创建了一个Observable （RxJava）并且最终会调用AbstractLoadBalancerAwareClient.execute ()方法 public RibbonApacheHttpResponse execute(RibbonApacheHttpRequest request, final IClientConfig configOverride) throws Exception { IClientConfig config = configOverride != null ? configOverride : this.config; RibbonProperties ribbon = RibbonProperties.from(config); RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(ribbon.connectTimeout(this.connectTimeout)).setSocketTimeout(ribbon.readTimeout(this.readTimeout)).setRedirectsEnabled(ribbon.isFollowRedirects(this.followRedirects)).setContentCompressionEnabled(ribbon.isGZipPayload(this.gzipPayload)).build(); request = this.getSecureRequest(request, configOverride); HttpUriRequest httpUriRequest = request.toRequest(requestConfig); HttpResponse httpResponse = ((CloseableHttpClient)this.delegate).execute(httpUriRequest); return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI()); } 在execute()方法中，我们看到创建连接并且发送了http请求并将结果返回。回退到submit()方法中，创建了Observable 会监听execute()的执行状态从而决定是否重试请求： public Observable<T> submit(final ServerOperation<T> operation) { final LoadBalancerCommand<T>.ExecutionInfoContext context = new LoadBalancerCommand.ExecutionInfoContext(); if (this.listenerInvoker != null) { try { this.listenerInvoker.onExecutionStart(); } catch (AbortExecutionException var6) { return Observable.error(var6); } } /** * 相同server重试次数，去除首次 */ final int maxRetrysSame = this.retryHandler.getMaxRetriesOnSameServer(); /** * 集群内其他server重试次数 **/ final int maxRetrysNext = this.retryHandler.getMaxRetriesOnNextServer(); /** * 创建一个Observable（RxJava） **/ Observable<T> o = (this.server == null ? this.selectServer() : Observable.just(this.server)).concatMap(new Func1<Server, Observable<T>>() { public Observable<T> call(Server server) { context.setServer(server); final ServerStats stats = LoadBalancerCommand.this.loadBalancerContext.getServerStats(server); Observable<T> o = Observable.just(server).concatMap(new Func1<Server, Observable<T>>() { public Observable<T> call(final Server server) { context.incAttemptCount(); LoadBalancerCommand.this.loadBalancerContext.noteOpenConnection(stats); if (LoadBalancerCommand.this.listenerInvoker != null) { try { LoadBalancerCommand.this.listenerInvoker.onStartWithServer(context.toExecutionInfo()); } catch (AbortExecutionException var3) { return Observable.error(var3); } } final Stopwatch tracer = LoadBalancerCommand.this.loadBalancerContext.getExecuteTracer().start(); return operation.call(server).doOnEach(new Observer<T>() { private T entity; public void onCompleted() { this.recordStats(tracer, stats, this.entity, (Throwable)null); } public void onError(Throwable e) { this.recordStats(tracer, stats, (Object)null, e); LoadBalancerCommand.logger.debug("Got error {} when executed on server {}", e, server); if (LoadBalancerCommand.this.listenerInvoker != null) { LoadBalancerCommand.this.listenerInvoker.onExceptionWithServer(e, context.toExecutionInfo()); } } public void onNext(T entity) { this.entity = entity; if (LoadBalancerCommand.this.listenerInvoker != null) { LoadBalancerCommand.this.listenerInvoker.onExecutionSuccess(entity, context.toExecutionInfo()); } } private void recordStats(Stopwatch tracerx, ServerStats statsx, Object entity, Throwable exception) { tracerx.stop(); LoadBalancerCommand.this.loadBalancerContext.noteRequestCompletion(statsx, entity, exception, tracerx.getDuration(TimeUnit.MILLISECONDS), LoadBalancerCommand.this.retryHandler); } }); } }); if (maxRetrysSame > 0) { o = o.retry(LoadBalancerCommand.this.retryPolicy(maxRetrysSame, true)); } return o; } }); if (maxRetrysNext > 0 && this.server == null) { o = o.retry(this.retryPolicy(maxRetrysNext, false)); } return o.onErrorResumeNext(new Func1<Throwable, Observable<T>>() { public Observable<T> call(Throwable e) { if (context.getAttemptCount() > 0) { if (maxRetrysNext > 0 && context.getServerAttemptCount() == maxRetrysNext + 1) { e = new ClientException(ErrorType.NUMBEROF_RETRIES_NEXTSERVER_EXCEEDED, "Number of retries on next server exceeded max " + maxRetrysNext + " retries, while making a call for: " + context.getServer(), (Throwable)e); } else if (maxRetrysSame > 0 && context.getAttemptCount() == maxRetrysSame + 1) { e = new ClientException(ErrorType.NUMBEROF_RETRIES_EXEEDED, "Number of retries exceeded max " + maxRetrysSame + " retries, while making a call for: " + context.getServer(), (Throwable)e); } } if (LoadBalancerCommand.this.listenerInvoker != null) { LoadBalancerCommand.this.listenerInvoker.onExecutionFailed((Throwable)e, context.toFinalExecutionInfo()); } return Observable.error((Throwable)e); } }); } 讲到这里，就是一次完整的路由过程了。我们大致回顾一下这个路由过程。 A.Zuul的转发是通过RibbonRoutingFilter这个Filter进行操作的。B. 在转发之前，Zuul包装请求为RibbonCommand，并且RibbonCommand继承了HystrixCommand，并且持有RibbonLoadBalancingHttpClient 和 FallbackProvider，正应为这样才使得Zuul具有了服务降级(Fallback)，和负载均衡的功能，同时HystrixCommand是具备超时时间的(默认是1s)。而且Zuul默认采用的隔离级别是信号量模式。C.在RibbonCommand的内部Zuul再次将请求包装成一个Observable，(有关RxJava的知识请参照其官方文档)。并且为Observable设置了重试次数，默认只对GET请求失败和连接失败重试。

____h个人页面-阿里云开发者社区

个人介绍

擅长的技术

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring-Boot实战｜分布式缓存-JPA的二级缓存-Redis

Spring Cloud Zuul 源码解析

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring Cloud Zuul 源码解析

Mac下HomeBrew 替换镜像和复原

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring-Boot实战｜分布式缓存-JPA的二级缓存-Redis

Spring Cloud Zuul 源码解析

Mac下HomeBrew 替换镜像和复原

RocketMQ 学习之路 | 第一章：RocketMQ 的安装与配置

微服务架构下分布式事务解决方案 | 第一章：分布式事务

Spring Cloud 学习之路 | 第一章：Eureka 服务的注册和发现

____h个人页面-阿里云开发者社区

个人介绍

擅长的技术

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring-Boot实战｜分布式缓存-JPA的二级缓存-Redis

Spring Cloud Zuul 源码解析

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring Cloud Zuul 源码解析

Mac下HomeBrew 替换镜像和复原

Spring AOP 源码解析

Mac 下 Brew 安装 Node

Mac 下 Brew 安装 MongoDB

Spring-Boot实战｜分布式缓存-JPA的二级缓存-Redis

Spring Cloud Zuul 源码解析

Mac下HomeBrew 替换镜像和复原

RocketMQ 学习之路 | 第一章 ：RocketMQ 的安装与配置

微服务架构下分布式事务解决方案 | 第一章 ： 分布式事务

Spring Cloud 学习之路 | 第一章 ：Eureka 服务的注册和发现

RocketMQ 学习之路 | 第一章：RocketMQ 的安装与配置

微服务架构下分布式事务解决方案 | 第一章：分布式事务

Spring Cloud 学习之路 | 第一章：Eureka 服务的注册和发现