菜鸟的奋斗ing
菜鸟的奋斗ing

从源码的角度深入理解spring AOP原理及流程

前言：

Spring作为java开发必用的开源框架之一，必然有它非常优秀的且不可替代的地方，其中springIOC和Aop就是设计的非常优秀的地方，今天一起来学习一下spring是如何实现AOP

AOP实现的思想：简单来讲就是使用了动态代理，对业务方法进行拦截增强（cglib或者jdk）

继续深入的思考一下如下问题：

  1. 如何创建动态代理
  2. 如何判断哪些类需要被代理增强，那些类不需要被增强
  3. 如何获取通知类
  4. ......

需要掌握的一些概念或技能：

  1. 动态代理
  2. 后置处理器
  3. Spring的注解的使用如@Import等
  4. 切面，通知、切点等aop相关的概念
  5. ......

下面开始跟大家一起学习SpringAOP

一、编写用于debug的aop的demo应用程序

1、业务类Calculator.java

@Component
public class Calculator {

    public int div(int x,int y){
        System.out.println("calculator div running...");
        return x/y;
    }
}

2、切面类LogAspects.java

@Aspect
@Component
public class LogAspects {

    @Pointcut("execution(public int cap1.Calculator.*(..))")
    public void pointCut(){}

    @Before(value = "pointCut()")
    public void logStart(JoinPoint joinPoint){
        System.out.println("start...");
        System.out.println(joinPoint.getSignature().getName());
        for(Object obj : joinPoint.getArgs()){
            System.out.println("----"+obj);
        }
        System.out.println(joinPoint.getTarget().toString());
    }

    @After(value = "pointCut()")
    public void logEnd(){
        System.out.println("end....");

    }

    @AfterReturning(value = "pointCut()",returning = "result")
    public void logReturn(Object result){
        System.out.println("return....");
        System.out.println("result = "+result);
    }

    @AfterThrowing(value = "pointCut()",throwing = "exception")
    public void logThrowing(Exception exception){
        System.out.println("throwing");
    }

    @Around(value = "pointCut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("around proceeding start....");
        Object proceed = joinPoint.proceed();
        System.out.println("around proceeding end");
        return proceed;
    }

}

3、配置类MainConfig.java

@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class MainConfig1 {

    @Bean
    public Person person(){
        return new Person();
    }
}

4、测试类Main1Test.java

public class Main1Test {

    @Test
    public void test(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MainConfig1.class);

        for (String name : app.getBeanDefinitionNames()){
            System.out.println(name);
        }
        app.getBean(Calculator.class).div(4,2);
    }
}

上面简单的程序就可以模拟springaop啦，下面开始分析springaop工作的原理

在分析之前先说一下springaop的核心的一个类：

BeanName：org.springframework.aop.config.internalAutoProxyCreator

Class：AnnotationAwareAspectJAutoProxyCreator

二、源码分析

1、准备工作---准备向springIOC容器中注入AnnotationAwareAspectJAutoProxyCreator

（1）从EnableAspectJAutoProxy开关开始

从源码的角度深入理解spring AOP原理及流程_第1张图片

 

 （2）@Import注解的使用

从源码的角度深入理解spring AOP原理及流程_第2张图片

 （3）AspectJAutoProxyRegistrar#registerBeanDefinitions()

@Override
public void registerBeanDefinitions(
      AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
       ......
}

（4）AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary()

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

（5）AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary()

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
      @Nullable Object source) {

   return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

（6）AopConfigUtils#registerOrEscalateApcAsRequired()

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry,
      @Nullable Object source) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
         int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
         int requiredPriority = findPriorityForClass(cls);
         if (currentPriority < requiredPriority) {
            apcDefinition.setBeanClassName(cls.getName());
         }
      }
      return null;
   }

   RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
   beanDefinition.setSource(source);
   beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
   beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
   return beanDefinition;
}

上面的所有工作都是为了准备向IOC容器中注入AnnotationAwareAspectJAutoProxyCreator

2、向IOC容器中注入各种bean，包括后置处理器（beanpostProcessor）和业务bean，配置bean等所有的bean，这里注意下，向IOC容器中注入bean的时候是先注入后置处理器，然后再注入普通bean，其中后置处理器也是有注入的先后顺序。后置处理器的作用就是用于拦截bean的构建，可以在bean初始化的时候做一些拦截的动作。

下面开始分析代码

（1）AnnotationConfigApplicationContext#AnnotationConfigApplicationContext()

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}

（2）AbstractApplicationContext#refresh()

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();
      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);
      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);
         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);
         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);
         // Initialize message source for this context.
         initMessageSource();
         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();
         // Initialize other special beans in specific context subclasses.
         onRefresh();
         // Check for listener beans and register them.
         registerListeners();
         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);
         // Last step: publish corresponding event.
         finishRefresh();
      }

（3）AbstractApplicationContext#registerBeanPostProcessors()先注入后置处理器

注入后置处理器和注入普通的bean的主要的流程差不多，就是时机比注入普通的bean的时机早，因为后置处理器注入成功后，所有的bean都需要经过已经注入的后置处理器进行拦截，同时后置处理器也分先后顺序，实现PriorityOrdered优先注入，其次实现Ordered，最后什么都没有实现的，这是因为实现PriorityOrdered的后置处理器优先级比较高，这种后置处理器可能需要拦截实现Ordered的后置处理器、什么都没实现的后置处理器，以及普通的bean，简单来说就是实例化任何bean都需要被已经实例化出来的后置处理器进行前后拦截。

等下会拿出和AOP相关的两个后置处理器出来分别介绍，他们分别是AnnotationAwareAspectJAutoProxyCreator和EventListenerMethodProcessor前者实现了Orderd接口，后者什么都没实现，所以再实例化EventListenerMethodProcessor时会被AnnotationAwareAspectJAutoProxyCreator进行拦截

PostProcessorRegistrationDelefate#registerBeanPostProcessors()

public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   // Register BeanPostProcessorChecker that logs an info message when
   // a bean is created during BeanPostProcessor instantiation, i.e. when
   // a bean is not eligible for getting processed by all BeanPostProcessors.
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   List priorityOrderedPostProcessors = new ArrayList<>();
   List internalPostProcessors = new ArrayList<>();
   List orderedPostProcessorNames = new ArrayList<>();
   List nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
         priorityOrderedPostProcessors.add(pp);
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
   List orderedPostProcessors = new ArrayList<>();
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // Now, register all regular BeanPostProcessors.
   List nonOrderedPostProcessors = new ArrayList<>();
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   // Finally, re-register all internal BeanPostProcessors.
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // Re-register post-processor for detecting inner beans as ApplicationListeners,
   // moving it to the end of the processor chain (for picking up proxies etc).
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

（4）AbstractBeanFactory#getBean()

@Override
public  T getBean(String name, @Nullable Class requiredType) throws BeansException {
   return doGetBean(name, requiredType, null, false);
}

（5）AbstractBeanFactory#doGetBean()

protected  T doGetBean(final String name, @Nullable final Class requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	//......
	//前面是一些校验、检查、标记、依赖注入等操作
         // Create bean instance.
         if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
               }
	//......
   }

（6）AbstractAutowireCapableBeanFactory#createBean()

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

   if (logger.isDebugEnabled()) {
      logger.debug("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;

   // Make sure bean class is actually resolved at this point, and
   // clone the bean definition in case of a dynamically resolved Class
   // which cannot be stored in the shared merged bean definition.
   Class resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }

   // Prepare method overrides.
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }

   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);
   }

   try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
         logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

这里有一个需要注意的地方：Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

这一行代码比较容易忽略，这里面就有后置处理器的拦截工作，但是当注入AnnotationAwareAspectJAutoProxyCreator时，基本上拦截的后置处理器不做任何事情，感兴趣的可以debug看一下，但是当AnnotationAwareAspectJAutoProxyCreator已经初始化好的话，注入在AnnotationAwareAspectJAutoProxyCreator后的bean会被AnnotationAwareAspectJAutoProxyCreator拦截（前置拦截），这里介绍一下EventListenerMethodProcessor，为什么要介绍它，因为该后置处理器会实例化所有的通知类Adviser。仔细看一下...

（7）AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation()

@Nullable
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.
      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;
}

重点看 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)前置处理，其实就是遍历所有已经实例化好的后置处理器进行拦截，除了AnnotationAwareAspectJAutoProxyCreator，其他的一般不做任何处理，debug可以详细查看

（8）AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation()

protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
   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;
}

 （9）AbstractAutoProxyCreator#postProcessBeforeInstantiation()

这里是看被AnnotationAwareAspectJAutoProxyCreator拦截处理的逻辑

public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
   Object cacheKey = getCacheKey(beanClass, beanName);

   if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
      if (this.advisedBeans.containsKey(cacheKey)) {
         return null;
      }
      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);
      Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
   }

   return null;
}

这里比较重要：

①会先将后面的每个bean进行标记，this.advisedBeans.put(cacheKey, Boolean.FALSE);在后面后置处理的时候如果是false就直接返回，不进行代理。

②会实例化Advisor，逻辑在shouldSkip中，看一下

（10）AspectJAutowareAdvisorAutoProxyCreator#shouldSkip()

protected boolean shouldSkip(Class beanClass, String beanName) {
   // TODO: Consider optimization by caching the list of the aspect names
   List candidateAdvisors = findCandidateAdvisors();
   for (Advisor advisor : candidateAdvisors) {
      if (advisor instanceof AspectJPointcutAdvisor &&
            ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
         return true;
      }
   }
   return super.shouldSkip(beanClass, beanName);
}

（11）AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors()

@Override
protected List findCandidateAdvisors() {
   // Add all the Spring advisors found according to superclass rules.
   List advisors = super.findCandidateAdvisors();
   // Build Advisors for all AspectJ aspects in the bean factory.
   if (this.aspectJAdvisorsBuilder != null) {
      advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
   }
   return advisors;
}

（12）BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors()

public List buildAspectJAdvisors() {
   List aspectNames = this.aspectBeanNames;

   if (aspectNames == null) {
      synchronized (this) {
         aspectNames = this.aspectBeanNames;
         if (aspectNames == null) {
            List advisors = new LinkedList<>();
            aspectNames = new LinkedList<>();
            String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                  this.beanFactory, Object.class, true, false);
            for (String beanName : beanNames) {
               if (!isEligibleBean(beanName)) {
                  continue;
               }
               // We must be careful not to instantiate beans eagerly as in this case they
               // would be cached by the Spring container but would not have been weaved.
               Class beanType = this.beanFactory.getType(beanName);
               if (beanType == null) {
                  continue;
               }
               if (this.advisorFactory.isAspect(beanType)) {
                  aspectNames.add(beanName);
                  AspectMetadata amd = new AspectMetadata(beanType, beanName);
                  if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                     MetadataAwareAspectInstanceFactory factory =
                           new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                     List classAdvisors = this.advisorFactory.getAdvisors(factory);
                     if (this.beanFactory.isSingleton(beanName)) {
                        this.advisorsCache.put(beanName, classAdvisors);
                     }
                     else {
                        this.aspectFactoryCache.put(beanName, factory);
                     }
                     advisors.addAll(classAdvisors);
                  }
                  else {
                     // Per target or per this.
                     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();
   }
   List advisors = new LinkedList<>();
   for (String aspectName : aspectNames) {
      List cachedAdvisors = this.advisorsCache.get(aspectName);
      if (cachedAdvisors != null) {
         advisors.addAll(cachedAdvisors);
      }
      else {
         MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
         advisors.addAll(this.advisorFactory.getAdvisors(factory));
      }
   }
   return advisors;
}

这里就是实例化Advisor的详细的逻辑了，看上去很多，但是逻辑也比较简单，意思就是拿到所有的bean的定义信息，然后遍历，判断类型是否是切面类（也就是我们使用了@Aspect注释的类），然后再拿到里面所有的方法进行解析（@Before、@After、@AfterReturning、@AfterThrowing、@Around），后面就不再继续了，这个时候Advisor已经全部放到集合中了。到这里Object bean = resolveBeforeInstantiation(beanName, mbdToUse);就解析完了，我们接着AbstractAutowireCapableBeanFactory#createBean后面的逻辑讲，看到Object beanInstance = doCreateBean(beanName, mbdToUse, args);

（13）AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
//.......
   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
      populateBean(beanName, mbd, instanceWrapper);
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
  //......
   return exposedObject;
}

重点看初始化bean，初始化就是给bean进行初始化，同样在初始化前后进行拦截增强

（14）AbstractAutowireCapableBeanFactory#initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
} 
  
invokerInitMethods()这是初始化的方法给bean属性赋值
 
  
applyBeanPostProcessorsBeforeInitialization()初始化之前进行拦截增强
 
  
applyBeanPostProcessorsAfterInitialization()初始化之后进行拦截
 
  
为了节省篇幅，这里就直接介绍相应的业务类的初始化拦截了（Calulator），其实所有的bean的初始化的逻辑流程都是一样的，只是部分细节不一样比如上面分析EventListenerMethodProcessor的时候做了初始化Advisor的工作，后面的操作和普通的bean没什么区别，现在主要介绍差异的部分，当初始化Calculator的时候，这个时候会调用
 
  
AnnotationAwareAspectJAutoProxyCreator后置处理器进行增强，生成一个Calculator的动态代理类，这是AOP的核心，一起看看如何生成的
 
  
（15）AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization()
 
  
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}
 
  
这里也会被所有的已经实例化的后置处理器进行拦截，我们重点看AnnotationAwareAspectJAutoProxyCreator，这个时候被拦截的类是Calculator
 
  
（16）AbstractAutoProxyCreator#postProcessAfterInitialization()
 
  
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (!this.earlyProxyReferences.contains(cacheKey)) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}
 
  
wrapIfNecessary()所有被AnnotationAwareAspectJAutoProxyCreator拦截的类都会调用该方法，如果需要对bean进行增强的话，会在这里增强，如果不需要增强的话，会直接返回，看详细逻辑
 
  
（17）AbstractAutoProxyCreator#wrapIfNecessay()
 
  
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;
}
 
  
前面两个部分，在第一次前置处理器的时候已经标记过了，所以不符合需要代理的逻辑，直接return了，而calculator走后面的逻辑，create proxy if we hava advice，如果有advisor则进行代理增强，如果没有，则不进行代理增强，前面分析显然是由advisor，所以就会走createProxy的逻辑
 
  
（18）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);

   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());
}
 
  
（19）ProxyFactory#getProxy()
 
  
public Object getProxy(@Nullable ClassLoader classLoader) {
   return createAopProxy().getProxy(classLoader);
}
 
  
（20）DefaultAopProxyFactory#createAopProxy()
 
  
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
   if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      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.");
      }
      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
         return new JdkDynamicAopProxy(config);
      }
      return new ObjenesisCglibAopProxy(config);
   }
   else {
      return new JdkDynamicAopProxy(config);
   }
}
 
  
到这里基本就结束了，会通过cglib或者jdk生成calculator的动态代理，这个时候calculator的div方法就进行了增强了
 
  
AOP介绍暂时分享到这里，如有错误欢迎指正，后面有时间再跟大家一起学习，调用calculator的div方法如何调用动态代理的方法，以及拦截连的调用和顺序等
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring)

        

            

                
    
                    
  • 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
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • 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.
    
                    
    • 
                    
  • 博客网站制作教程
                        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
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                    
  • java打印标签（机型TOSHIBA条码打印机B-EX4T）
                         嘘 
JAVAjava
                        
    java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
    
                    
    • 
                                
  • html
                                    周华华
html
                                    
    js 
 1，数组的排列 
var arr=[1,4,234,43,52,]; 
 for(var x=0;x<arr.length;x++){ 
   for(var y=x-1;y<arr.length;y++){ 
     if(arr[x]<arr[y]){ 
    &
    
                                
    • 
                                
  • 【Struts2 四】Struts2拦截器
                                    bit1129
struts2拦截器
                                    
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 
  
Struts2中自定义拦截器的步骤是：
    
                                
    • 
                                
  • make:cc 命令未找到解决方法
                                    daizj
linux命令未知make cc
                                    
    安装rz sz程序时，报下面错误： 
  
[root@slave2 src]# make posix 
cc   -O -DPOSIX -DMD=2 rz.c -o rz 
make: cc：命令未找到 
make: *** [posix] 错误 127 
  
系统：centos 6.6 
环境：虚拟机 
  
错误原因：系统未安装gcc，这个是由于在安
    
                                
    • 
                                
  • Oracle之Job应用
                                    周凡杨
oracle job
                                    
      
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。 
  
一：查看相关job信息 
   1、相关视图  
 dba_jobs  
 all_jobs  
 user_jobs  
 dba_jobs_running 包含正在运行
    
                                
    • 
                                
  • 多线程机制
                                    朱辉辉33
多线程
                                    
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 
程序、进程和线程： 
 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
                                    老A不折腾
web报表finereportjava报表报表工具
                                    
    FineReport使用中遇到的常见报错及解决办法（一） 
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
  
1、address pool is full： 
含义：地址池满，连接数超过并发数上
    
                                
    • 
                                
  • mysql rpm安装后没有my.cnf
                                    林鹤霄
没有my.cnf
                                    
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    
                                
    • 
                                
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
                                    aigo
root
                                    
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ 
  
Step 4: Run ADB command from your PC 
  
On the PC, you need install Amazon Fire ADB driver and instal
    
                                
    • 
                                
  • javascript 中var提升的典型实例
                                    alxw4616
JavaScript
                                    
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
	console.log(myname); // undefined
	var myname = 'local';
	console.log(myname); // local
};
fn()

// 上述代码实际上等同于以下代码
m
    
                                
    • 
                                
  • 定时器和获取时间的使用
                                    百合不是茶
时间的转换定时器
                                    
    定时器:定时创建任务在游戏设计的时候用的比较多 
  Timer();定时器 
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。 
  
  
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    
                                
    • 
                                
  • JDK1.5 Queue
                                    bijian1013
javathreadjava多线程Queue
                                    
    JDK1.5 Queue 
LinkedList： 
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    
                                
    • 
                                
  • http认证原理和https
                                    bijian1013
httphttps
                                    
    一.基础介绍 
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。 
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    
                                
    • 
                                
  • 【Java范型五】范型继承
                                    bit1129
java
                                    
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 
  
package com.tom.lang.generics;

public abstract class SuperGenerics<T1, T2> {
    private T1 t1;
    private T2 t2;

    public abstract void doIt(T
    
                                
    • 
                                
  • 【Nginx六】nginx.conf常用指令(Directive)
                                    bit1129
Directive
                                    
    1. worker_processes    8; 
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 
  
nobody    53879 118449  0 Apr22 ?        00:26:15 nginx: worker process          
    
                                
    • 
                                
  • lua 遍历Header头部
                                    ronin47
lua header 遍历　
                                    
     
 local headers = ngx.req.get_headers()   
 ngx.say("headers begin", "<br/>")   
 ngx.say("Host : ", he
    
                                
    • 
                                
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
                                    bylijinnan
java
                                    
    
import java.util.Arrays;

public class MinSumASumB {

	/**
	 * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
	 * 
	 * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 
	 * 例如: 
	 * int[] a = {100,99,98,1,2,3
    
                                
    • 
                                
  • redis
                                    开窍的石头
redis
                                    
    在redis的redis.conf配置文件中找到# requirepass foobared 
把它替换成requirepass 12356789 后边的12356789就是你的密码 
 
打开redis客户端输入config get requirepass 
返回 
redis 127.0.0.1:6379> config get requirepass 
1) "require
    
                                
    • 
                                
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
                                    comsci
java语言
                                    
     
 
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情 
 
 
       
    
                                
    • 
                                
  • 安装ubuntu14.04登录后花屏了怎么办
                                    cuiyadll
ubuntu
                                    
    这个情况，一般属于显卡驱动问题。 
可以先尝试安装显卡的官方闭源驱动。 
按键盘三个键：CTRL + ALT  +  F1 
进入终端，输入用户名和密码登录终端： 
安装amd的显卡驱动       
sudo  
apt-get  
install  
fglrx       
安装nvidia显卡驱动       
sudo  
ap
    
                                
    • 
                                
  • SSL 与 数字证书 的基本概念和工作原理
                                    darrenzhu
加密ssl证书密钥签名
                                    
    SSL 与 数字证书 的基本概念和工作原理 

http://www.linuxde.net/2012/03/8301.html 
 
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 
 
 
 

http://www.ibm.com/developerworks/cn/webspher
    
                                
    • 
                                
  • Ubuntu设置ip的步骤
                                    dcj3sjt126com
ubuntu
                                    
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 
转载不是错： 
Ubuntu命令行修改网络配置方法 
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 
1. 以D
    
                                
    • 
                                
  • php包管理工具推荐
                                    dcj3sjt126com
PHPComposer
                                    
    http://www.phpcomposer.com/ 
       Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。  
中文文档  
入门指南  
下载  
安装包列表   
Composer 中国镜像      
    
                                
    • 
                                
  • Gson使用四（TypeAdapter）
                                    eksliang
jsongsonGson自定义转换器gsonTypeAdapter
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例 
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    
                                
    • 
                                
  • JQM控件之Navbar和Tabs
                                    gundumw100
htmlxmlcss
                                    
    在JQM中使用导航栏Navbar是简单的。 
 
只需要将data-role="navbar"赋给div即可： 
 

<div data-role="navbar">
    <ul>
        <li><a href="#" class="ui-btn-active&qu
    
                                
    • 
                                
  • 利用归并排序算法对大文件进行排序
                                    iwindyforest
java归并排序大文件分治法Merge sort
                                    
      
归并排序算法介绍，请参照Wikipeida 
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 
基本思想： 
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 
低于限制行数的子文件直接排序 
两个排序好的子文件归并到父文件 
直到最后所有排序好的父文件归并到输入
    
                                
    • 
                                
  • iOS UIWebView URL拦截
                                    啸笑天
UIWebView
                                    
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    
                                
    • 
                                
  • 索引的碎片整理SQL语句
                                    macroli
sql
                                    
    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    
                                
    • 
                                
  • Angularjs同步操作http请求with $promise
                                    qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象
                                    
    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
      var deferred = $q.defer();
      AccountService.getProfile().then(function(res) {
  
    
                                
    • 
                                
  • hibernate联合查询问题
                                    sxj19881213
sqlHibernateHQL联合查询
                                    
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 
  
1 几个常识： 
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。 
 （2）hql的默认查询策略，在进行联合查询时，会产
    
                                
    • 
                                
  • struts2.xml
                                    wuai
struts
                                    
    <?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE struts PUBLIC 
 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 
 "http://struts.apache
    
                                
    •