hanna22
hanna22

Spring源码解析系列(7)之AOP的底层原理

Spring AOP的底层原理

前置知识：spring 使用aspectJ实现了aop，听起来好像spring的aop完全是依赖于aspectJ，其实spring对于aop的实现是通过动态代理（jdk的动态代理或者cglib的动态代理），它只是使用了aspectJ的Annotation，并没有使用它的编译器和织入器，进行注解的解析工作是Spring内部实现的，所以Spring AOP只是借助了AspectJ的注解而已。

spring AOP提供两种编程风格

@AspectJ support ------------>利用aspectj的注解

Schema-based AOP support ----------->xml aop:config 命名空间

开始源码剖析：

首先，要开启aop需要使用@EnableAspectJAutoProxy注解

@EnableAspectJAutoProxy

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 使用@import将想要注册的类注册到容器中，没有标注@Component的普通类也能被注入进来
// 导入注册器，实际上是通过调用该注册器的方法，注册beanDefinition
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;
​
    boolean exposeProxy() default false;
}

AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }
​
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
 // 注册AnnotationAwareAspectJAutoProxyCreator的beanDefinition ，主要方法     
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        //2.获取原注解也就是EnableAspectJAutoProxy上面设置的属性值
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            //3.设置proxyTargetClass属性
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
    //4.设置exposeProxy属性
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
​
    }
}

第1步注册一个AnnotationAwareAspectJAutoProxyCreator的BeanDefinition，此步骤很关键，具体看代码块3中的registerAspectJAnnotationAutoProxyCreatorIfNecessary的源码，第2、3、4步就是向AnnotationAwareAspectJAutoProxyCreator的BeanDefinition设置属性的步骤，看一下第3步和第四步设置proxyTargetClass属性和设置exposeProxy属性

registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null);
}

registerAspectJAnnotationAutoProxyCreatorIfNecessary()

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

registerOrEscalateApcAsRequired()

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    // 判断beanDefinitionMap中是否已经包含了名称为"org.springframework.aop.config.internalAutoProxyCreator"的beanDefinition
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        // 如果包含了就从容器中获取
        BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
        //5.如果名称不一样，则获取优先级，在这里我们知道cls传过来的是AnnotationAwareAspectJAutoProxyCreator这个类，
            //而这个AnnotationAwareAspectJAutoProxyCreator的优先级是最高的，如果名称不一样，则BeanClassName则会被替换成
            //AnnotationAwareAspectJAutoProxyCreator.class的名称
        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 {
        // beanDefinitionMap中没有包含名称为"org.springframework.aop.config.internalAutoProxyCreator"的beanDefinition就进行创建
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", -2147483648);
        beanDefinition.setRole(2);
      // 向容器中注入该beanDefinition
        registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
        // 返回创建好的beanDefinition
        return beanDefinition;
    }
}

forceAutoProxyCreatorToUseClassProxying(registry)

forceAutoProxyCreatorToExposeProxy(registry)

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
    
    //1.如果容器中包含AUTO_PROXY_CREATOR_BEAN_NAME的BeanDefinition，则设置proxyTargetClass属性为true，
    //该属性在创建动态代理的时候，会影响使用JDK还是CGLIB来实现动态代理
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        BeanDefinition definition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
        definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
    }
​
}
​
public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        BeanDefinition definition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
        definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
    }
​
}

看一下AnnotationAwareAspectJAutoProxyCreator类的继承关系图

Spring源码解析系列(7)之AOP的底层原理_第1张图片

到此就完成了向Spring容器中注入了一个封装了AnnotationAwareAspectJAutoProxyCreator的BeanDefinition对象，我们可以看到AnnotationAwareAspectJAutoProxyCreator间接的实现了InstantiationAwareBeanPostProcessor接口和BeanPostProcessor接口，也就是说在bean的生命周期中AnnotationAwareAspectJAutoProxyCreator也会参与进来，依据前面分析过的，InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法作为第一个被执行的后置处理器方法，postProcessAfterInstantiation()是第五个被执行的后置处理器方法；BeanPostProcessor接口postProcessBeforeInitialization方法和postProcessAfterInitialization方法是第七、八个被执行的后置处理器方法，AnnotationAwareAspectJAutoProxyCreator中只有上述postProcessBeforeInstantiation和postProcessAfterInitialization方法的具体实现。

在bean被实例化之前，调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法（实际上是调用父类AbstractAutoProxyCreator的重写方法）。我们来看：

AnnotationAwareAspectJAutoProxyCreator#postProcessBeforeInstantiation

判断要不要在此处直接生成代理对象，并返回，不进行bean的整个创建过程，直接将返回的对象，放入单例池。一般情况下，如果我们没有自己配置TargetSourceCreator，则一定会返回null。不会进入，就不详细分析了。

public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
    Object cacheKey = this.getCacheKey(beanClass, beanName);
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
​
        if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
​
    TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
​
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    } else {
        return null;
    }
}

真正代理方法的执行是在initializeBean方法中进行的，当bean经历了实例化，属性填充之后，就会来到初始化的步骤，在这里面，会调用BeanPostProcessor后置处理器的postProcessBeforeInitialization和postProcessAfterInitialization方法，代理方法的执行也是在postProcessAfterInitialization进行的。

    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
        //1.已存在bean，这个bean是没有代理之前的bean
        Object result = existingBean;
​
        Object current;
        //2.拿到所有的bena的后置处理器，依次进行遍历
        for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
            //3.执行其postProcessAfterInitialization方法
            BeanPostProcessor processor = (BeanPostProcessor)var4.next();
            current = processor.postProcessBeforeInitialization(result, beanName);
            //4.如果有其中一个返回空，则就直接返回了，不再进行遍历
            if (current == null) {
                return result;
            }
        }
​
        return result;
    }

第3步执行后置处理器的postProcessAfterInitialization方法，并将返回的current 对象赋值给result，也就是会替换原来的bean对象。而对于bean后置处理器的postProcessAfterInitialization方法，如果不做处理的话，都是直接将传递过来的bean给直接返回，而不进行任何处理。 AnnotationAwareAspectJAutoProxyCreator也是一个bean后置处理器，而AnnotationAwareAspectJAutoProxyCreator间接的继承AbstractAutoProxyCreator类，在AbstractAutoProxyCreator类中实现了postProcessAfterInitialization方法

AbstractAutoProxyCreator#postProcessAfterInitialization方法

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        //1.获取缓存键，如果beanName没有长度，则直接返回bean的class，如果不为空，
        //会判断当前bean是否为FactoryBean的子类，如果是，则在其bean名称前面添加&, 如果不是则直接返回bean的名称，
        Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
        // 从earlyProxyReferences中移出缓存key，我们看一下哪里用到了缓存key↓，==判断是否已经代理过了==，代理过了就直接返回原来的bean，如果代理过了，会在再次调用getSingleton()时，从二级缓存中获得
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return this.wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
​
    return bean;
}
​
    protected Object getCacheKey(Class beanClass, @Nullable String beanName) {
        // 判断beanName是不是空字符串，有长度，如果有就判断是不是工厂bean，如果是工厂bean，就返回&beanName，否则返回原来的beanName
        if (StringUtils.hasLength(beanName)) {
            return FactoryBean.class.isAssignableFrom(beanClass) ? "&" + beanName : beanName;
        } else {
            return beanClass;
        }
    }
private final Map earlyProxyReferences = new ConcurrentHashMap(16);
// 此方法前面分析过，会在出现循环依赖时，从三级缓存中获取暴露对象的时候调用，也就是说earlyProxyReferences里面保存的是以beanName为key，对应的bean为value的“被代理对象”，我们可以看出它的主要作用就是保存“被代理对象的”，因为前面我们在分析工厂bean的时候也分析到了，也会对工厂bean中getObject()返回的对象进行代理，那么在earlyProxyReferences里工厂bean是以&beanName，bean存在的，而他所包裹的对象是以beanName，bean的形式存在的
public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    return this.wrapIfNecessary(bean, beanName, cacheKey);
}

wrapIfNecessary()看一下具体进行代理增强的代码

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
        // 1.获取能够使用的排序后的通知数组
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
        // 2.如果数组不为null，表明需要进行代理，进入if判断
        if (specificInterceptors != DO_NOT_PROXY) {
       // 3.向已经完成通知的bean的map中添加缓存键和是否需要进行增强的标志，标志为true，表明需要进行增强，（此时还未进行增强，即将要增强了...）
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 4.创建代理对象
            Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        } else {
            // 6.在这可以看到即使不需要增强，只要经过了是否需要增强的判断，就会被添加到Map集合中，只不过标志为false
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    } else {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, @Nullable TargetSource targetSource) {
    // 1.1查找所有符合条件的并且经过排序的通知列表
    List advisors = this.findEligibleAdvisors(beanClass, beanName);
    // 1.2如果不为空，就将通知列表转为数组后返回，如果为空不进行代理返回null
    return advisors.isEmpty() ? DO_NOT_PROXY : advisors.toArray();
}
​
    // 寻找符合条件的通知对象列表
    protected List findEligibleAdvisors(Class beanClass, String beanName) {
          // 1.先看下面：有下面的分析可知，此处就是生成全部Advisor的地方了，在这就能拿到不论是注解定义还是实现Advisor接口的全部封装好的Advisor增强器，其内部主要封装了pointcut（要被增强的方法）以及advise（实际去增强的内容）
        List candidateAdvisors = this.findCandidateAdvisors();
        // 2.选择该bean能够使用的增强器列表，也就是切点所在的类是当前bean对应的类的，[此处事务的Advisor中的pointcut回去进行匹配判断，会利用AnnotationTransactionAttributeSource去检查类上是否有@Transactional注解，检查方法上是否有@Transactional注解，有就将其添加到可用的Advisor列表中]
        List eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        this.extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            // 如果可用的通知不为空就对其进行排序，排序会按照下面的规则进行排序
            /**
            -1 ExposeInvocationInterceptor#invoke
            0 事务advisor
            1.环绕增强前(around advice before)
            2.前置增强(before advice)
            3.-- 方法执行
            4.环绕增强后(around advice after)
            5.后置finally增强(after advice)
            6.后置增强/抛出增强            
            **/
            eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
        }
    // 返回排序后的可用的通知列表
        return eligibleAdvisors;
    }

看一下候选通知列表：

Spring源码解析系列(7)之AOP的底层原理_第2张图片

看一下筛选前后的：

看一下排序之后的：

看一下advisedBeans里面的内容：

Spring源码解析系列(7)之AOP的底层原理_第3张图片

findCandidateAdvisors()

protected List findCandidateAdvisors() {
    // 此步为止如果没有自定义实现Advisor接口的类，并且没有开启事务，如果开启了事务，会自动注册一个事务相关的advisor,只是通过注解进行了配置@Aspect，那就会advisors返回null
    List advisors = super.findCandidateAdvisors();
    if (this.aspectJAdvisorsBuilder != null) {
        // 此步是主要的去构建Advisor的步骤
        // 将搜索到的全部的带有Aspect注解的类中的带有@Before。@After等注解的方法，以及其切入点（要增强的方法）都封装成了Advisor，与之前搜索到了通过实现Advisor接口的形式定义的Advisor整合，获取到全部的Advisor增强器。====================重点=============================
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }
​
    return advisors;
​
}

buildAspectJAdvisors()

public List buildAspectJAdvisors() {
    // 此处获取advisor类型的beanName
    List aspectNames = this.aspectBeanNames;
    if (aspectNames == null) {
        synchronized(this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List advisors = new ArrayList();
                List aspectNames = new ArrayList();
                // 此处就是去获取全部被注册的beanName
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                String[] var18 = beanNames;
                int var19 = beanNames.length;
            // 遍历每一个beanName
                for(int var7 = 0; var7 < var19; ++var7) {
                    String beanName = var18[var7];
                    // 默认返回true
                    if (this.isEligibleBean(beanName)) {
                        Class beanType = this.beanFactory.getType(beanName, false);
                    // 判断当前类型是不是Aspect类型,就是判断是否存在Aspect注解，不存在就继续遍历下一个
                        /**
                            public boolean isAspect(Class clazz) {
              return this.hasAspectAnnotation(clazz) && !this.compiledByAjc(clazz);
                             }
                        **/
                        if (beanType != null && this.advisorFactory.isAspect(beanType)) {
                            // 找到了，就添加带有Aspect注解的beanName到aspectNames中
                            aspectNames.add(beanName);
                            // 将其封装为aspectMetadata
                            AspectMetadata amd = new AspectMetadata(beanType, beanName);
                            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                           // 解析beanName对应的类中的方法，将通知（标有注解的before、after....）和相对应的切点都封装成Advisor返回，如下图，看一下结构
                                List classAdvisors = this.advisorFactory.getAdvisors(factory);
                                if (this.beanFactory.isSingleton(beanName)) {
                               // 是单例bean将其，以及它对应的Advisor放入缓存中
                                    this.advisorsCache.put(beanName, classAdvisors);
                                } else {
                                    this.aspectFactoryCache.put(beanName, factory);
                                }
                        // 将其全部添加到Aspect列表中并返回
                                advisors.addAll(classAdvisors);
                            } else {
                                if (this.beanFactory.isSingleton(beanName)) {
                                    throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
                                }
​
                                MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                                this.aspectFactoryCache.put(beanName, factory);
                                advisors.addAll(this.advisorFactory.getAdvisors(factory));
                            }
                        }
                    }
                }
    
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
    }
    
    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    } else {
        List advisors = new ArrayList();
        Iterator var3 = aspectNames.iterator();
    
        while(var3.hasNext()) {
            String aspectName = (String)var3.next();
            List cachedAdvisors = (List)this.advisorsCache.get(aspectName);
            if (cachedAdvisors != null) {
                advisors.addAll(cachedAdvisors);
            } else {
                MetadataAwareAspectInstanceFactory factory = (MetadataAwareAspectInstanceFactory)this.aspectFactoryCache.get(aspectName);
                advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
        }
    
        return advisors;
    }
​
}

beanNamesForTypeIncludingAncestors

public static String[] beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit) {
    Assert.notNull(lbf, "ListableBeanFactory must not be null");
    // 可以看到此处传入的type是Object.class,所以result此时拿到的是全部被注册了的beanName
    String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
    // 我们的创建的bean工厂是HierarchicalBeanFactory类型的
    if (lbf instanceof HierarchicalBeanFactory) {
        HierarchicalBeanFactory hbf = (HierarchicalBeanFactory)lbf;
        // 我们没有在自己的beanFactory中添加ParentBeanFactory，所以默认为null
        if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
            String[] parentResult = beanNamesForTypeIncludingAncestors((ListableBeanFactory)hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
            result = mergeNamesWithParent(result, parentResult, hbf);
        }
    }
    // 返回全部的beanName数组
    return result;
}

AspectMetadata结构

Spring源码解析系列(7)之AOP的底层原理_第4张图片

classAdvisors的结构

Spring源码解析系列(7)之AOP的底层原理_第5张图片

至此已经获取了全部的Advisor增强器，接下来就是筛选、排序、创建代理了......

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();
    // 获取使用@EnableAspectJAutoProxy开启代理时，设置的属性，比如proxyTargetClass（是否使用目标类进行代理--cglib，默认是false，也就是说默认采用的时jdk的动态代理），exposeProxy等
    proxyFactory.copyFrom(this);
    // 判断是否使用目标类进行动态代理
    if (proxyFactory.isProxyTargetClass()) {
        if (Proxy.isProxyClass(beanClass)) {
            Class[] var6 = beanClass.getInterfaces();
            int var7 = var6.length;
​
            for(int var8 = 0; var8 < var7; ++var8) {
                Class ifc = var6[var8];
                proxyFactory.addInterface(ifc);
            }
        }
        // 判断是否应该使用动态代理，这里面是在判断beanDefinition的attributes中是否已经标志过要使用目标类进行动态代理了（一般不存在，需要手动设置）
    } else if (this.shouldProxyTargetClass(beanClass, beanName)) {
        // 如果被标记过了，就设置使用目标类进行代理
        proxyFactory.setProxyTargetClass(true);
    } else {
        // 评估代理接口：
        /**
        首先获取全部的该bean的实现接口，遍历这些接口，这些接口中只要有一个通过（!this.isConfigurationCallbackInterface(ifc) && !this.isInternalLanguageInterface(ifc) && ifc.getMethods().length > 0）判断，就表明存在合理的接口，将这些接口添加到代理工厂中，否则就将其设置为使用目标类代理
        
        **/
        this.evaluateProxyInterfaces(beanClass, proxyFactory);
    }
    // 将前面经过选择和排序的拦截器数组，以及后面解析到的拦截器等构建成统一的Advisor类型，来对对象进行增强
    Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    // 设置需要进行代理的类
    proxyFactory.setTargetSource(targetSource);
    // 空方法
    this.customizeProxyFactory(proxyFactory);
    // 用来控制代理工厂被配置之后，是否还允许修改通知
    // 默认值为false(即在代理被配置之后，不允许修改代理的配置)
    proxyFactory.setFrozen(this.freezeProxy);
    if (this.advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
​
    ClassLoader classLoader = this.getProxyClassLoader();
    if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
        classLoader = ((SmartClassLoader)classLoader).getOriginalClassLoader();
    }
    // 创建代理对象
    return proxyFactory.getProxy(classLoader);
}

我们看一下attribute的内部结构

buildAdvisors(）构建通知

protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
    // 解析全部的拦截器
    Advisor[] commonInterceptors = this.resolveInterceptorNames();
    List allInterceptors = new ArrayList();
    if (specificInterceptors != null) {
        // 添加可用的拦截器
        if (specificInterceptors.length > 0) {
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
        }
​
        if (commonInterceptors.length > 0) {
            if (this.applyCommonInterceptorsFirst) {
                allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
            } else {
                allInterceptors.addAll(Arrays.asList(commonInterceptors));
            }
        }
    }
​
    int i;
    if (this.logger.isTraceEnabled()) {
        int nrOfCommonInterceptors = commonInterceptors.length;
        i = specificInterceptors != null ? specificInterceptors.length : 0;
        this.logger.trace("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors + " common interceptors and " + i + " specific interceptors");
    }
​
    Advisor[] advisors = new Advisor[allInterceptors.size()];
​
    for(i = 0; i < allInterceptors.size(); ++i) {
        // 将上面获取到的全部拦截器都包装成Advisor类型
        advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
    }
​
    return advisors;
}
getProxy()获取代理对象

public Object getProxy(@Nullable ClassLoader classLoader) {
    // 调用返回的AopProxy的getProxy()方法获取代理对象
    return this.createAopProxy().getProxy(classLoader);
}
// 创建代理对象
protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            this.activate();
        }
        // 使用默认的aop代理工厂去创建代理对象（传入我们自己配制的proxyFactory，才能获取到我们的配置），
        return this.getAopProxyFactory().createAopProxy(this);
    }
​
    public AopProxyFactory getAopProxyFactory() {
        return this.aopProxyFactory;
    }
​
    private AopProxyFactory aopProxyFactory;
​
    public ProxyCreatorSupport() {
        // 在我们创建ProxyFactory时，会创建默认的aop代理工厂对象
        this.aopProxyFactory = new DefaultAopProxyFactory();
    } 
  
createAopProxy()创建aop代理
 
  
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    // 通过判断选择创建JDKAOP代理还是CglibAop代理
    /**
    选择的原则如下：
      optimize：用来控制通过CGLIB创建的代理是否使用激进的优化策略。除非完全了解AOP代理是如何优化，否则不推荐用户使用这个设置，目前这个属性仅用于CGLIB代理，对于JDK动态代理（缺省代理）无效。
     proxyTargetClass：这个属性为true时，目标类本身被代理而不是目标类的接口。如果这个属性值被设为true，CGLIB代理将被创建
    hasNoUserSuppliedProxyInterfaces 是否存在代理接口
    
    **/
    if (NativeDetector.inNativeImage() || !config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
        return new JdkDynamicAopProxy(config);
    } else {
        Class targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
        } else {
            // 最后或返回AopProxy类型的对象，AopProxy是一个接口，跟据选择动态代理的方式不同，会创建不同的代理对象
            return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
        }
    }
}
 
  
总结：JDK与Cglib动态代理的选择
 
  
 
   
proxyTargetClass true 目标对象实现了接口 – 使用CGLIB代理机制 目标对象没有接口(只有实现类) – 使用CGLIB代理机制 false 目标对象实现了接口 – 使用JDK动态代理机制(代理所有实现了的接口) 目标对象没有接口(只有实现类) – 使用CGLIB代理机制
 
  
 
  
看一下AopProxy的继承关系图
 
  
Spring源码解析系列(7)之AOP的底层原理_第6张图片
 
  
CglibAopProxy#getProxy
 
  
private Callback[] getCallbacks(Class rootClass) throws Exception {
    // 获取代理工厂中设置的一些属性信息
    boolean exposeProxy = this.advised.isExposeProxy();
    boolean isFrozen = this.advised.isFrozen();
    boolean isStatic = this.advised.getTargetSource().isStatic();
    // 将我们自己创建的代理工厂封装成DynamicAdvisedInterceptor类型，因为DynamicAdvisedInterceptor实现了了MethodInterceptor接口，跟据Cglib动态代理的使用原理，调用cglib中的方法时会调用MethodInterceptor接口的intercept方法
    Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);
    Object targetInterceptor;
    if (exposeProxy) {
        targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
    } else {
        targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedInterceptor(this.advised.getTargetSource());
    }
​
    Callback targetDispatcher = isStatic ? new CglibAopProxy.StaticDispatcher(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.SerializableNoOp();
    Callback[] mainCallbacks = new Callback[]{aopInterceptor, (Callback)targetInterceptor, new CglibAopProxy.SerializableNoOp(), (Callback)targetDispatcher, this.advisedDispatcher, new CglibAopProxy.EqualsInterceptor(this.advised), new CglibAopProxy.HashCodeInterceptor(this.advised)};
    Callback[] callbacks;
    if (isStatic && isFrozen) {
        Method[] methods = rootClass.getMethods();
        Callback[] fixedCallbacks = new Callback[methods.length];
        this.fixedInterceptorMap = CollectionUtils.newHashMap(methods.length);
​
        for(int x = 0; x < methods.length; ++x) {
            Method method = methods[x];
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
            fixedCallbacks[x] = new CglibAopProxy.FixedChainStaticTargetInterceptor(chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
            this.fixedInterceptorMap.put(method, x);
        }
​
        callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
        System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
        System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
        this.fixedInterceptorOffset = mainCallbacks.length;
    } else {
        callbacks = mainCallbacks;
    }
​
    return callbacks;
} 
  
CglibAopProxy#getCallbacks方法
 
  
private Callback[] getCallbacks(Class rootClass) throws Exception {
    // 获取代理工厂中设置的一些属性信息
    boolean exposeProxy = this.advised.isExposeProxy();
    boolean isFrozen = this.advised.isFrozen();
    boolean isStatic = this.advised.getTargetSource().isStatic();
    // 将我们自己创建的代理工厂封装成DynamicAdvisedInterceptor类型，因为DynamicAdvisedInterceptor实现了了MethodInterceptor接口，跟据Cglib动态代理的使用原理，调用cglib中的方法时会调用MethodInterceptor接口的intercept方法
    Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);
    Object targetInterceptor;
    if (exposeProxy) {
        targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
    } else {
        targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedInterceptor(this.advised.getTargetSource());
    }
​
    Callback targetDispatcher = isStatic ? new CglibAopProxy.StaticDispatcher(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.SerializableNoOp();
    Callback[] mainCallbacks = new Callback[]{aopInterceptor, (Callback)targetInterceptor, new CglibAopProxy.SerializableNoOp(), (Callback)targetDispatcher, this.advisedDispatcher, new CglibAopProxy.EqualsInterceptor(this.advised), new CglibAopProxy.HashCodeInterceptor(this.advised)};
    Callback[] callbacks;
    if (isStatic && isFrozen) {
        Method[] methods = rootClass.getMethods();
        Callback[] fixedCallbacks = new Callback[methods.length];
        this.fixedInterceptorMap = CollectionUtils.newHashMap(methods.length);
​
        for(int x = 0; x < methods.length; ++x) {
            Method method = methods[x];
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
            fixedCallbacks[x] = new CglibAopProxy.FixedChainStaticTargetInterceptor(chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
            this.fixedInterceptorMap.put(method, x);
        }
​
        callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
        System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
        System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
        this.fixedInterceptorOffset = mainCallbacks.length;
    } else {
        callbacks = mainCallbacks;
    }
​
    return callbacks;
} 
  
在getCallbacks中spring考虑了很多情况，但是对于我们来说，只需要理解最常用的就可以了，比如将advised属性封装在DynamicAdvisedInterceptor并加入在callbacks中，这么做的目的是什么，为什么会这么做？在前面的示例中，我们了解到CGLIB中对于方法的拦截是通过将自定义的拦截器（实现MethodInterceptor接口）加入Callback中并在调用代理的时候直接激活拦截器中的intercept方法来实现的，那么在getCallback中正是实现了这样的一个目的，DynamicAdvisedInterceptor继承自MethodInterceptor加入CallBack中后，再次调用代理时会直接调用DynamicAdvisedInterceptor中的intercept方法，所以，由此推断，对于CGLIB方式实现的代理，其核心逻辑在DynamicAdvisedInterceptor中的intercept方法，DynamicAdvisedInterceptor作为CglibAopProxy内部封装私有类，其在org.springframework.aop.framework.CglibAopProxy类中：
 
  
那我们调用代理对象的方法时，方法会被拦截，依次执行前面设置的callBack[]中的，方法拦截器的intercept（），首先会执行我们创建的封装了自定义的ProxyFactory的DynamicAdvisedInterceptor的intercept()方法，在此方法中完成我们自定义的增强逻辑。
 
  
我们看一下通知（具体的增强逻辑）的继承关系：
 
  
Spring源码解析系列(7)之AOP的底层原理_第7张图片
 
  
@Override
@Nullable
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Object target = null;
    TargetSource targetSource = this.advised.getTargetSource();
    try {
        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        // 获取代理对象
        target = targetSource.getTarget();
        Class targetClass = (target != null ? target.getClass() : null);
        // 获取拦截链，我们知道我们之前给每个需要被代理对象都创建了代理工厂，代理工厂中保存了每个被代理对象能够适配（应用的）Advisor[],但是针对于特定方法，就需要从Advisor[]中选择出能够用在此方法上的Advisor增强器，并从增强器中获取具体的增强逻辑（Advice），Interceptor拦截器就是Advice的子接口，这里面获取到的就是该method能够使用的拦截器列表。
        List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
           
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            // 如果拦截链为空则直接激活原方法
            retVal = methodProxy.invoke(target, argsToUse);
        }
        else {
            // We need to create a method invocation...
            // 调用所有拦截器的invoke()方法，以及被代理的方法，完成增强（这里面是一个递归调用proceed()方法，proceed()方法中会获取每一个拦截器链中的拦截器调用它们的invoke()方法，在invoke()方法中会调用proceed()方法）
            /**
                     现在可以看出对advisor进行排序的意义了
            1.事务拦截器会最先执行,invoke方法中又会调用invokeWithinTransaction方法（重要，后续分析）
            2.依次调用around before  原method after afterturn的invoke方法
            **/
            retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        retVal = processReturnType(proxy, target, method, retVal);
        return retVal;
    }
    finally {
        if (target != null && !targetSource.isStatic()) {
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // Restore old proxy.
            AopContext.setCurrentProxy(oldProxy);
        }
    }
} 
  
看一下该方法拦截器列表中的内容：
 
  
Spring源码解析系列(7)之AOP的底层原理_第8张图片
 
  
上述的实现与JDK方式实现代理中的invoke方法基本相同，都是首先构造链，然后封装此链进行串联调用，区别就是在JDK代理中直接构造ReflectiveMethodInvocation类，而在CGLIB代理中使用CglibMethodInvocation，CglibMethodInvocation继承自ReflectiveMethodInvocation，但是process方法没有重写。 JdkDynamicAopProxy#getProxy方法
 
  
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    //1.为给定的AOP配置确定要代理的完整接口集
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    //2.创建一个动态代理对象
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
​
}
 
  
JDKProxy的使用关键是创建自定义的InvocationHandler，而InvocationHandler中包含了需要覆盖的函数getProxy，并且JdkDynamicAopProxy还实现了InvocationHandler接口，所以，AOP的代理会调用它的invoke方法。当调用AOP 动态代理对象的方法时，就会调用它的invoke方法。
 
  
 
   
总结：
 
   
1.首先调用通过Import注册的后置处理器的..after..方法，
 
   
判断是否被代理过了，代理过了直接返回原bean
 
   
没代理过，进行代理
 
   
2.获取可用的增强器，并进行排序，排序原则如下：
 
   
/** ​ 1.环绕增强前(around advice before) ​ 2.前置增强(before advice) ​ 3.-- 方法执行 ​ 4.环绕增强后(around advice after) ​ 5.后置finally增强(after advice) ​ 6.后置增强/抛出增强 ​ **/
 
   
3.创建代理工厂，设置代理工厂的属性，比如目标代理对象，是否使用cglib动态代理
 
   
4.进行判断，选择创建AopProxy还是JDKProxy
 
   
5.调用代理的getProxy()方法：
 
   
设置拦截器，添加回调，创建代理对象
 
  
 
  
 
  
如有问题欢迎指正讨论.....
 
  
参考博文：参考了一篇文章，但是忘记链接是什么了.....sorry下次一定记得/(ㄒoㄒ)/~~
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring源码,java,spring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • 开发者关心的那些事
                                    圣子足道
ios游戏编程apple支付
                                    
    我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 
产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
    
                                
    • 
                                
  • 负载均衡器技术Nginx和F5的优缺点对比
                                    bijian1013
nginxF5
                                    
            对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。 
        目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
    
                                
    • 
                                
  • LeetCode[Math] - #9 Palindrome Number
                                    Cwind
javaAlgorithm题解LeetCodeMath
                                    
    原题链接：#9 Palindrome Number 
  
要求： 
判断一个整数是否是回文数，不要使用额外的存储空间 
  
难度：简单 
  
分析： 
题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 
注：没有看到有关负数是否可以是回文数的明确结论，例如
    
                                
    • 
                                
  • 画图板的基本实现
                                    15700786134
画图板
                                    
     要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 
首先，需要显示一个JFrame界面： 
public class DrameFrame extends JFrame {              //显示
    
                                
    • 
                                
  • linux的ps命令
                                    被触发
linux
                                    
    Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 
要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
    
                                
    • 
                                
  • Android 音乐播放器 下一曲 连续跳几首歌
                                    肆无忌惮_
android
                                    
    最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 
player.setOnCompletionListener(new OnCompletionListener() {

			@Override
			public void onCompletion(MediaPlayer mp) {
				mp.reset();
				Log.i("H
    
                                
    • 
                                
  • java导出txt文件的例子
                                    知了ing
javaservlet
                                    
    代码很简单就一个servlet,如下： 
 
package com.eastcom.servlet;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.Resu
    
                                
    • 
                                
  • Scala stack试玩, 提高第三方依赖下载速度
                                    矮蛋蛋
scalasbt
                                    
    原文地址： 
http://segmentfault.com/a/1190000002894524 
sbt下载速度实在是惨不忍睹, 需要做些配置优化 
 
下载typesafe离线包, 保存为ivy本地库 
 
wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 
解压r
    
                                
    • 
                                
  • phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。
                                    alleni123
linuxspider
                                    
    1. 首先从官网 
http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 
 
2. 安装依赖 
 
sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 
 
3. 配置环境变量 
vi /etc/profil
    
                                
    • 
                                
  • JAVA IO FileInputStream和FileOutputStream，字节流的打包输出
                                    百合不是茶
java核心思想JAVA IO操作字节流
                                    
    在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 
1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流 
  
类 FileInputStream
    
                                
    • 
                                
  • Spring基础实例（依赖注入和控制反转）
                                    bijian1013
spring
                                    
    前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 
package com.bijian.spring.base3;

public interface Weapon {

   
    void kil
    
                                
    • 
                                
  • HR看重的十大技能
                                    bijian1013
提升能力HR成长
                                    
        一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
    
                                
    • 
                                
  • 【Thrift一】Thrift编译安装
                                    bit1129
thrift
                                    
    什么是Thrift 
The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
    
                                
    • 
                                
  • 【Avro三】Hadoop MapReduce读写Avro文件
                                    bit1129
mapreduce
                                    
    Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 
这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
    
                                
    • 
                                
  • nginx定制500，502，503，504页面
                                    ronin47
nginx　错误显示
                                    
    server {
     listen 80;
     error_page  500/500.html;
     error_page  502/502.html;
     error_page  503/503.html;
     error_page  504/504.html;

     location /test {return502;}} 
配置很简单，和配
    
                                
    • 
                                
  • java-1.二叉查找树转为双向链表
                                    bylijinnan
二叉查找树
                                    
    
import java.util.ArrayList;
import java.util.List;


public class BSTreeToLinkedList {
	
	/*
把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ 
    
                                
    • 
                                
  • Netty源码学习-HTTP-tunnel
                                    bylijinnan
javanetty
                                    
    Netty关于HTTP tunnel的说明： 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 
 
这个说明有点太简略了 
 
一个完整的例子在这里： 
 
https://github.com/bylijinnan
    
                                
    • 
                                
  • JSONUtil.serialize(map)和JSON.toJSONString(map)的区别
                                    coder_xpf
jqueryjsonmapval()
                                    
     JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 
  
数据库查询出来的map有一个字段为空 
  
通过System.out.println()输出  JSONUtil.serialize(map)： {"one":"1","two":"nul
    
                                
    • 
                                
  • Hibernate缓存总结
                                    cuishikuan
开源sshjavawebhibernate缓存三大框架
                                    
    一、为什么要用Hibernate缓存？ 
Hibernate是一个持久层框架，经常访问物理数据库。 
为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 
缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。 
  
二、Hibernate缓存原理是怎样的？ 
Hibernate缓存包括两大类：Hib
    
                                
    • 
                                
  • CentOs6
                                    dalan_123
centos
                                    
    首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
    
                                
    • 
                                
  • 10款用 jquery 实现滚动条至页面底端自动加载数据效果
                                    dcj3sjt126com
JavaScript
                                    
      
无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 
无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
    
                                
    • 
                                
  • ImageButton去边框&Button或者ImageButton的背景透明
                                    dcj3sjt126com
imagebutton
                                    
    在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 
一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 
第二种方法就是将ImageButton背景改为透明，这个方法更常用 
在XML里； 
   <ImageBut
    
                                
    • 
                                
  • JSP之c:foreach
                                    eksliang
jspforearch
                                    
    原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html 
<c:forEach>标签用于通用数据循环，它有以下属性    属 性 描 述 是否必须 缺省值   items 进行循环的项目 否 无   begin 开始条件 否 0   end 结束条件 否 集合中的最后一个项目   step 步长 否 1
    
                                
    • 
                                
  • Android实现主动连接蓝牙耳机
                                    gqdy365
android
                                    
    在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 
大致可以分三步： 
 
一、扫描蓝牙设备： 
1、注册并监听广播： 
 

BluetoothAdapter.ACTION_DISCOVERY_STARTED
BluetoothDevice.ACTION_FOUND
BluetoothAdapter.ACTION_DIS
    
                                
    • 
                                
  • android学习轨迹之四：org.json.JSONException: No value for
                                    hyz301
json
                                    
    org.json.JSONException: No value for items  
在JSON解析中会遇到一种错误，很常见的错误 
  
06-21 12:19:08.714    2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
    
                                
    • 
                                
  • 干货分享：从零开始学编程 系列汇总
                                    justjavac
编程
                                    
    程序员总爱重新发明轮子，于是做了要给轮子汇总。 
 
  从零开始写个编译器吧系列 (知乎专栏)  
  从零开始写一个简单的操作系统 (伯乐在线)  
  从零开始写JavaScript框架 (图灵社区)  
  从零开始写jQuery框架 (蓝色理想 )  
  从零开始nodejs系列文章 (粉丝日志)  
  从零开始编写网络游戏 
    
                                
    • 
                                
  • jquery-autocomplete 使用手册
                                    macroli
jqueryAjax脚本
                                    
    jquery-autocomplete学习 
一、用前必备 
官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/  
当前版本：1.1 
需要JQuery版本：1.2.6 
二、使用 
<script src="./jquery-1.3.2.js" type="text/ja
    
                                
    • 
                                
  • PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改
                                    超声波
oracleplsql
                                    
    　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
    
                                
    • 
                                
  • 数据仓库数据模型之：极限存储--历史拉链表
                                    superlxw1234
极限存储数据仓库数据模型拉链历史表
                                    
    在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 
 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
    
                                
    • 
                                
  • 10点睛Spring MVC4.1-全局异常处理
                                    wiselyman
spring mvc
                                    
    10.1 全局异常处理 
 
 使用@ControllerAdvice注解来实现全局异常处理; 
 使用@ControllerAdvice的属性缩小处理范围 
  
10.2 演示 
 
 演示控制器 
  
package com.wisely.web;

import org.springframework.stereotype.Controller;
import org.spring
    
                                
    •