我神级欧文
我神级欧文

为何加上@Configuration注解的类会生成cglib代理？

@Configuration注解与@Component注解的区别？

首先我们来看下@Configuration这个注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {

   @AliasFor(annotation = Component.class)
   String value() default "";

   boolean proxyBeanMethods() default true;
}

可以看到其实@Configuration注解本质上也是一个@Component注解，那么这两者之间有什么不同呢？我们下面去测试一下：

@Configuration
@ComponentScan("com.zyh.learning.springsource")
public class AppConfig {

}
@Component
public class A {
    
}
AnnotationConfigApplicationContext acf = new AnnotationConfigApplicationContext(AppConfig.class);
A a = acf.getBean(A.class);
System.out.println(a);

此时A类加了一个@Component注解并且通过包扫描的方式加入到spring容器中，然后我们从spring容器就可以获取到A这个bean

可以看到A打印出来的是一个普通的Java对象的地址，而此时我们把A类上的@Component注解换成@Configuration注解

@Configuration
public class A {
    
}

 再从spring容器中获取A这个bean打印看看

神奇的是，打印出来的A的地址发生了变化，一眼看出来，发现A这个bean变成了一个由cglib创建的代理对象，所以，很明显，@Configuration注解和@Component注解都可以把对应的bean交给spring容器去管理，但是不一样的地方就在于，@Configuration注解所创建的bean是一个cglib代理对象，而@Component注解只是创建一个普通的Java对象

@Configuraton注解生成cglib代理的作用？

现在我们知道@Configuration注解和@Component注解都可以把bean放到spring容器进行管理，那么@Configuration注解把bean变成一个代理对象的作用是什么呢？我们现在看这样的一种场景：

@Component
public class AppConfig {

    @Bean
    public MyService myService() {
        MyService myService = new MyService();
        myService.setUserService(userService());
        return myService;
    }

    @Bean
    public UserService userService() {
        return new UserService();
    }
}
public class UserService {

    public UserService() {
        System.out.println("UserService...");
    }
}

我们在AppConfig配置类上加上@Component注解，然后通过@Bean注解的方式注入MyService和UserService这两个bean，并且在MyService的@Bean方法中还调用UserService的@Bean方法，现在我们来启动下spring容器看一下

可以看到UserService的@Bean方法调用了两次，创建了两个UserService实例，那我们把AppConfig配置类上的@Component注解换成@Configuration注解看下会不会不一样 

 可以看到把@Component注解换成了@Configuration注解之后，UserService的@Bean方法只调用了一次，也就是UserService实例只创建了一个，所以@Configuration注解就是为了避免用户显式地去调用@Bean方法，造成破坏了@Bean方法的bean的单例，而@Configuration注解能够做到这样避免用户显式调用@Bean方法的原理就是通过创建对应的配置类cglib代理对象去实现的，下面我们重点看一下@Configuraton注解底层是怎么通过cglib代理去实现@Bean方法不被用户显式调用

深入@Configuration注解生成cglib代理源码实现

 1.寻找加了@Configuration注解的BeanDefinition

org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanFactory

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   int factoryId = System.identityHashCode(beanFactory);
   if (this.factoriesPostProcessed.contains(factoryId)) {
      throw new IllegalStateException(
            "postProcessBeanFactory already called on this post-processor against " + beanFactory);
   }
   this.factoriesPostProcessed.add(factoryId);
   if (!this.registriesPostProcessed.contains(factoryId)) {
      // BeanDefinitionRegistryPostProcessor hook apparently not supported...
      // Simply call processConfigurationClasses lazily at this point then.
      processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
   }

   // 生成配置类cglib代理
   enhanceConfigurationClasses(beanFactory);
   beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口，而BeanDefinitionRegistryPostProcessor接口又是继承于BeanFactoryPostProcessor接口，众所周知BeanFactoryPostProcessor接口接口是一个BeanFactory的后置处理接口，也就是在BeanFactory初始化之后会调用该接口的postProcessBeanFactory方法，也就是上面的方法，其中里面会再调用enhanceConfigurationClasses方法，该方法就是生成cglib代理的关键方法

org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanFactory

/**
 * 从spring容器中找到所有候选的BeanDefinitions，候选状态由BeanDefinition的属性元数据确定（找到全配置的配置类，也就是加了@Configuration注解的配置类）
 * 然后通过{@link ConfigurationClassEnhancer}增强去对这些配置类进行cglib增强代理
 * @see ConfigurationClassEnhancer
 */
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
   Map configBeanDefs = new LinkedHashMap<>();
   // 遍历当前spring容器中所有的bd名称，这个for循环的目的就是找到所有全配置类（加了@Configuration注解的配置类）
   for (String beanName : beanFactory.getBeanDefinitionNames()) {
      // 根据bd名称获取到bd
      BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
      // 获取到CONFIGURATION_CLASS_ATTRIBUTE对应的属性值
      Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
      AnnotationMetadata annotationMetadata = null;
      MethodMetadata methodMetadata = null;
      if (beanDef instanceof AnnotatedBeanDefinition) {
         AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) beanDef;
         annotationMetadata = annotatedBeanDefinition.getMetadata();
         methodMetadata = annotatedBeanDefinition.getFactoryMethodMetadata();
      }
      if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof AbstractBeanDefinition) {
         // Configuration class (full or lite) or a configuration-derived @Bean method
         // -> eagerly resolve bean class at this point, unless it's a 'lite' configuration
         // or component class without @Bean methods.
         AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;
         if (!abd.hasBeanClass()) {
            boolean liteConfigurationCandidateWithoutBeanMethods =
                  (ConfigurationClassUtils.CONFIGURATION_CLASS_LITE.equals(configClassAttr) &&
                     annotationMetadata != null && !ConfigurationClassUtils.hasBeanMethods(annotationMetadata));
            if (!liteConfigurationCandidateWithoutBeanMethods) {
               try {
                  abd.resolveBeanClass(this.beanClassLoader);
               }
               catch (Throwable ex) {
                  throw new IllegalStateException(
                        "Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
               }
            }
         }
      }

      // 条件成立：说明这个bd对应的是一个配置类
      if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
         if (!(beanDef instanceof AbstractBeanDefinition)) {
            throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
                  beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
         }
         else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
            logger.info("Cannot enhance @Configuration bean definition '" + beanName +
                  "' since its singleton instance has been created too early. The typical cause " +
                  "is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
                  "return type: Consider declaring such methods as 'static'.");
         }
         configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
      }
   }

   // 条件成立：没有需要被增强的配置类
   if (configBeanDefs.isEmpty()) {
      // nothing to enhance -> return immediately
      return;
   }

   // 如果这个类是一个全配置类，那么就使用cglib进行代理增强，目的是防止@Bean方法的手动重复调用造成单例的破坏
   ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
   for (Map.Entry entry : configBeanDefs.entrySet()) {
      AbstractBeanDefinition beanDef = entry.getValue();
      // If a @Configuration class gets proxied, always proxy the target class
      beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
      // Set enhanced subclass of the user-specified bean class
      Class configClass = beanDef.getBeanClass();
      // 给这个全配置类创建一个cglib增强后的Class对象
      Class enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
      if (configClass != enhancedClass) {
         if (logger.isTraceEnabled()) {
            logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
                  "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
         }
         // 把cglib代理的Class对象设置到这个全配置类的bd中
         beanDef.setBeanClass(enhancedClass);
      }
   }
}

该方法的代码很多，但是做的事情很明确，就是去遍历spring容器中的所有BeanDefinition，找出扩展属性CONFIGURATION_CLASS_ATTRIBUTE对应的值等于CONFIGURATION_CLASS_FULL的BeanDefinition，那么这个属性从哪里来的呢？在执行postProcessBeanFactory方法之前，spring会去解析所有的配置类，包括包扫描，@Import的处理等等，简单来说就是会把能够给spring管理的bean对应的BeanDefinition都找出来放入到spring容器中，而这些BeanDefinition又分为两种，一种是全配置类，一种是半配置类，全配置类就是加了@Configuration注解并且proxyBeanMethods属性等于true，半配置类则是加了@Component，@ComponentScan，@Import，@ImportResource这几个注解的类（或者加了@Configuration注解但是proxyBeanMethods属性等于false），对于全配置类CONFIGURATION_CLASS_ATTRIBUTE对应的值就等于CONFIGURATION_CLASS_FULL，而对于半配置类CONFIGURATION_CLASS_ATTRIBUTE对应的值等于CONFIGURATION_CLASS_LITE。所以这里其实就是把加了@Configuration注解并且proxyBeanMethods属性等于true的BeanDefinition找出来。找出来之后需要干嘛呢？我们上面不是说了要创建对应的cglib代理吗，所以接下来需要去获取一个cglib增强之后的Class对象设置到这个BeanDefinition中了，而怎么去获取呢？这里就通过一个spring的一个cglib工具类ConfigurationClassEnhancer，该工具类封装了cglib的api，然后专门给全配置类去创建对应的cglib增强Class对象，具体增强的逻辑在ConfigurationClassEnhancer中已经定义好了，调用ConfigurationClassEnhancer的enhance方法，传入原始的Class对象就能够返回一个增强的cglib

2.创建cglib代理的Class对象 

org.springframework.context.annotation.ConfigurationClassEnhancer#enhance

public Class enhance(Class configClass, @Nullable ClassLoader classLoader) {
   if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
      if (logger.isDebugEnabled()) {
         logger.debug(String.format("Ignoring request to enhance %s as it has " +
               "already been enhanced. This usually indicates that more than one " +
               "ConfigurationClassPostProcessor has been registered (e.g. via " +
               "). This is harmless, but you may " +
               "want check your configuration and remove one CCPP if possible",
               configClass.getName()));
      }
      return configClass;
   }
   Class enhancedClass = createClass(newEnhancer(configClass, classLoader));
   if (logger.isTraceEnabled()) {
      logger.trace(String.format("Successfully enhanced %s; enhanced class name is: %s",
            configClass.getName(), enhancedClass.getName()));
   }
   return enhancedClass;
}

org.springframework.context.annotation.ConfigurationClassEnhancer#newEnhancer

/**
 * 创建一个新的CGLIB{@link Enhancer}实例
 */
private Enhancer newEnhancer(Class configSuperClass, @Nullable ClassLoader classLoader) {
   Enhancer enhancer = new Enhancer();
   enhancer.setSuperclass(configSuperClass);
   // 给配置类代理实现EnhancedConfiguration接口，该接口又继承了BeanFactoryAware接口，所以在配置类进行实例化的过程中能够回调到setBeanFactory方法
   enhancer.setInterfaces(new Class[] {EnhancedConfiguration.class});
   enhancer.setUseFactory(false);
   enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
   enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
   enhancer.setCallbackFilter(CALLBACK_FILTER);
   enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
   return enhancer;
}

 可以看到在newEnhancer方法中都是调用cglib的api，比如设置superClass为需要增强的原始Class对象，设置代理要实现的接口，设置增强逻辑Callback等等

org.springframework.context.annotation.ConfigurationClassEnhancer#createClass

private Class createClass(Enhancer enhancer) {
   Class subclass = enhancer.createClass();
   // Registering callbacks statically (as opposed to thread-local)
   // is critical for usage in an OSGi environment (SPR-5932)...
   Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
   return subclass;
}

然后最后调用enhancer的createClass方法，就可以得到一个增强后的Class对象，返回出去之后把这个增强的Class对象设置到BeanDefinition中就可以了

3.创建的cglib代理对象的增强逻辑 

（1）CallbackFilter

在创建enhancer对象时候，spring设置了一个CallbackFilter

private static class ConditionalCallbackFilter implements CallbackFilter {

   private final Callback[] callbacks;

   private final Class[] callbackTypes;

   public ConditionalCallbackFilter(Callback[] callbacks) {
      this.callbacks = callbacks;
      this.callbackTypes = new Class[callbacks.length];
      for (int i = 0; i < callbacks.length; i++) {
         this.callbackTypes[i] = callbacks[i].getClass();
      }
   }

   @Override
   public int accept(Method method) {
      for (int i = 0; i < this.callbacks.length; i++) {
         Callback callback = this.callbacks[i];
         if (!(callback instanceof ConditionalCallback) || ((ConditionalCallback) callback).isMatch(method)) {
            return i;
         }
      }
      throw new IllegalStateException("No callback available for method " + method.getName());
   }

   public Class[] getCallbackTypes() {
      return this.callbackTypes;
   }
}

 CallbackFilter的作用就是，当执行目标方法的时候会被accept方法拦截，在accpet方法会根据传入的目标方法去返回一个Callback增强，也就是通过这个CallbackFilter就可以实现调用不同的方法使用不同的增强Callback，而spring这里传的是ConditionalCallbackFilter，这个CallbackFilter在创建的时候需要传入一个Callback数组，这个Callback数组就是给accept方法去筛选具体的Callback返回的，我们下面看一下Callback数组中的Callback是哪几个

/**
 * 回调数组，根据CALLBACK_FILTER中accept方法返回的索引值去从该数组中选择对应的Callback
 */
private static final Callback[] CALLBACKS = new Callback[] {
      new BeanMethodInterceptor(),
      new BeanFactoryAwareMethodInterceptor(),
      NoOp.INSTANCE
};

spring传了三个Callback，分别是BeanMethodInterceptor，BeanFactoryAwareMethodInterceptor，NoOp.INSTANCE，最后一个NoOp.INSTANCE就是表示什么都不增强的意思，重点是BeanMethodInterceptor和BeanFactoryAwareMethodInterceptor

（2）给目标方法匹配Callback

在CallbackFilter的accpet方法中会通过每一个Callback的isMatch方法去对目标方法判断需要使用哪一个增强Callback进行增强，下面就看下BeanMethodInterceptor和BeanFactoryAwareMethodInterceptor这两个Callback的具体匹配条件

org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#isMatch

public boolean isMatch(Method candidateMethod) {
   // 方法匹配条件：调用的方法不能是Object的方法，不是setBeanFactory方法，方法上需要有@Bean注解
   return (candidateMethod.getDeclaringClass() != Object.class &&
         !BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&
         BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
}

BeanMethodInterceptor的isMatch方法的匹配条件是：调用的方法不能是Object的方法，不是BeanFactoryAware接口的setBeanFactory方法，方法上需要有@Bean注解，简单的总结就是我们写的@Bean方法

org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor#isMatch

public boolean isMatch(Method candidateMethod) {
   // 调用方法匹配条件：调用的方法是BeanFactoryAware接口的setBeanFactory方法
   return isSetBeanFactory(candidateMethod);
}
public static boolean isSetBeanFactory(Method candidateMethod) {
   return (candidateMethod.getName().equals("setBeanFactory") &&
         candidateMethod.getParameterCount() == 1 &&
         BeanFactory.class == candidateMethod.getParameterTypes()[0] &&
         BeanFactoryAware.class.isAssignableFrom(candidateMethod.getDeclaringClass()));
}

BeanFactoryAwareMethodInterceptor的isMatch方法的匹配条件则是：调用的方法是BeanFactoryAware接口的setBeanFactory方法。这里可能有人有个疑问，就是我们的配置类并没有实现BeanFactoryAware接口啊，从何而来的调用BeanFactoryAware接口的setBeanFactory方法呢？我们还是回到enhancer设置属性，看到有一个setInterfaces的属性设置，该属性就是设置代理对象需要实现的接口，而spring在这个属性中设置了EnhancedConfiguration这个接口

enhancer.setInterfaces(new Class[] {EnhancedConfiguration.class});

 但是可能有人会问，这也不是BeanFactoryAware接口呀，但是其实EnhancedConfiguration这个接口就是继承于BeanFactoryAware接口的

public interface EnhancedConfiguration extends BeanFactoryAware {
}

所以自然地cglib代理对象中自然就会有这个BeanFactoryAware接口的setBeanFactory方法了

（3）方法增强 

①BeanFactoryAwareMethodInterceptor

org.springframework.context.annotation.ConfigurationClassEnhancer.BeanFactoryAwareMethodInterceptor#intercept

public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   // 获取到属性名称为$$beanFactory的属性
   Field field = ReflectionUtils.findField(obj.getClass(), BEAN_FACTORY_FIELD);
   Assert.state(field != null, "Unable to find generated BeanFactory field");
   // 给$$beanFactory这个属性赋值，值等于BeanFactory对象
   field.set(obj, args[0]);

   // 判断配置类是否已经实现了BeanFactoryAware接口，如果实现了，那么此时还需要调用该配置类自己实现的setBeanFactory方法
   if (BeanFactoryAware.class.isAssignableFrom(ClassUtils.getUserClass(obj.getClass().getSuperclass()))) {
      return proxy.invokeSuper(obj, args);
   }
   return null;
}

我们现在已经知道了BeanFactoryAwareMethodInterceptor这个Callback增强的目标方法是BeanFactoryAware接口的setBeanFactory方法，那么setBeanFactory这个方法什么时候会被调用呢？如果大家熟知bean的生命周期的话可以知道，如果一个bean实现了BeanFactoryAware接口的话，那么在实例化的过程中会回调BeanFactoryAware接口的setBeanFactory方法，而已回调的时候会把BeanFactory对象传给setBeanFactory方法。然后在spring回调setBeanFactory方法的时候，BeanFactoryAwareMethodInterceptor这个Callback就能够拦截到，执行intercept方法中的增强逻辑。在intercept方法中做的其实就是把回调过来的BeanFactory对象赋值给属性名称为$$beanFactory的属性，那么这里可能就有人会问了，$$beanFactory这个属性哪里来的？原来的配置类也没有这个属性呀，答案就是在cglib创建代理的时候，会生成$$beanFactory这个名称的属性，是在哪里设置生成$$beanFactory这个属性的呢？我们继续回看spring在设置enhancer属性的时候，有一个strategy的属性

enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));

setStrategy属性可以设置生成代理类的class文件字节码策略，这里具体设置的策略是BeanFactoryAwareGeneratorStrategy

private static class BeanFactoryAwareGeneratorStrategy extends
      ClassLoaderAwareGeneratorStrategy {

   public BeanFactoryAwareGeneratorStrategy(@Nullable ClassLoader classLoader) {
      super(classLoader);
   }

   @Override
   protected ClassGenerator transform(ClassGenerator cg) throws Exception {
      ClassEmitterTransformer transformer = new ClassEmitterTransformer() {
         @Override
         public void end_class() {
            declare_field(Constants.ACC_PUBLIC, BEAN_FACTORY_FIELD, Type.getType(BeanFactory.class), null);
            super.end_class();
         }
      };
      return new TransformingClassGenerator(cg, transformer);
   }

}
private static final String BEAN_FACTORY_FIELD = "$$beanFactory";

可以大概地看到在BeanFactoryAwareGeneratorStrategy中做的就是给生成的代理类添加一个属性，属性名为$$beanFactory，访问域是public，属性类型是BeanFactory。那么现在就可以总结下BeanFactoryAwareMethodInterceptor这个Callback的作用了，它的作用就是在spring回调BeanFactoryAware接口的seetBeanFactory方法的时候，把回调的BeanFactory对象赋值给$$beanFactory属性，而这个属性的由来就是cglib在创建代理类的时候添加进来的

②BeanMethodInterceptor 

org.springframework.context.annotation.ConfigurationClassEnhancer.BeanMethodInterceptor#intercept

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
         MethodProxy cglibMethodProxy) throws Throwable {

   // 获取到$$beanFactory属性的值，也就是BeanFactory对象
   ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
   String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

   // Determine whether this bean is a scoped-proxy
   if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
      String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
      if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
         beanName = scopedBeanName;
      }
   }
   
   if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
         factoryContainsBean(beanFactory, beanName)) {
      Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
      if (factoryBean instanceof ScopedProxyFactoryBean) {
         // Scoped proxy factory beans are a special case and should not be further proxied
      }
      else {
         // It is a candidate FactoryBean - go ahead with enhancement
         return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
      }
   }

   // 条件成立：说明此时spring正在执行反射执行这个@Bean方法
   if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
      if (logger.isInfoEnabled() &&
            BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
         logger.info(String.format("@Bean method %s.%s is non-static and returns an object " +
                     "assignable to Spring's BeanFactoryPostProcessor interface. This will " +
                     "result in a failure to process annotations such as @Autowired, " +
                     "@Resource and @PostConstruct within the method's declaring " +
                     "@Configuration class. Add the 'static' modifier to this method to avoid " +
                     "these container lifecycle issues; see @Bean javadoc for complete details.",
               beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));
      }
      // 调用父类的原始@Bean方法返回bean实例，返回的bean实例会注册到spring容器中
      return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
   }

   // 代码来到这里说明此时的@Bean方法并不是由spring调用的，而是用户自身的代码显示调用的
   // 这种情况也就是在@Bean方法A中调用@Bean方法B，在调用@Bean方法B的时候上面的条件就不会成立，所以会执行到这里
   // 从BeanFactory中获取bean
   return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}

BeanMethodInterceptor的intercept方法比较长，关键的我们主要看最后的if判断

private boolean isCurrentlyInvokedFactoryMethod(Method method) {
   Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
   return (currentlyInvoked != null && method.getName().equals(currentlyInvoked.getName()) &&
         Arrays.equals(method.getParameterTypes(), currentlyInvoked.getParameterTypes()));
}

 在这个方法中主要就是SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod()这句代码会返回一个Method，那么这句代码的意思是什么呢？还有返回的Method又到底是什么？这里的话就要牵扯到bean实例化的时候了。我们先跳到spring在处理通过@Bean的方式实例bean的那块代码

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod

org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.Object, java.lang.reflect.Method, java.lang.Object...)

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
      @Nullable Object factoryBean, final Method factoryMethod, Object... args) {

   try {
      if (System.getSecurityManager() != null) {
         AccessController.doPrivileged((PrivilegedAction) () -> {
            ReflectionUtils.makeAccessible(factoryMethod);
            return null;
         });
      }
      else {
         ReflectionUtils.makeAccessible(factoryMethod);
      }

      Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
      try {
         // 把要执行的工厂方法放到currentlyInvokedFactoryMethod中
         currentlyInvokedFactoryMethod.set(factoryMethod);
         // 通过反射执行工厂实例的工厂方法
         Object result = factoryMethod.invoke(factoryBean, args);
         if (result == null) {
            result = new NullBean();
         }
         return result;
      }
      finally {
         if (priorInvokedFactoryMethod != null) {
            currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
         }
         else {
            currentlyInvokedFactoryMethod.remove();
         }
      }
   }
   catch (IllegalArgumentException ex) {
      throw new BeanInstantiationException(factoryMethod,
            "Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
            "args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
   }
   catch (IllegalAccessException ex) {
      throw new BeanInstantiationException(factoryMethod,
            "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
   }
   catch (InvocationTargetException ex) {
      String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
      if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
            ((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
         msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
               "declaring the factory method as static for independence from its containing instance. " + msg;
      }
      throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
   }
} 
  
在spring实例化bean的时候会通过反射去调用这个bean所在的配置类的@Bean方法，而且在调用之前会把这个@Bean方法放到currentlyInvokedFactoryMethod中，那么放进去有什么作用呢？我们可以想一下，这一步是spring实例化bean的时候才触发的，如果我们是手动的调用这个@Bean方法，那么是根本不会调用到上面的方法的，currentlyInvokedFactoryMethod中也就不会有这个@Bean方法，然后此时回到isCurrentlyInvokedFactoryMethod方法的判断中
 
  
private boolean isCurrentlyInvokedFactoryMethod(Method method) {
   Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
   return (currentlyInvoked != null && method.getName().equals(currentlyInvoked.getName()) &&
         Arrays.equals(method.getParameterTypes(), currentlyInvoked.getParameterTypes()));
}
 
  
 判断的条件是currentlyInvoked不等于空，并且当前调用的目标方法要和currentlyInvoked方法名称，参数相同。如果该方法返回true，结合上面spring实例化bean的过程可以说明当前这个@Bean方法spring正在调用，而如果返回false的话，那么就表示当前这个@Bean方法并不是由spring实例化去调用的，而是我们用户手动去调用的，此时的话就会执行resolveBeanReference方法，resolveBeanReference方法就会从spring容器中去拿这个@Bean方法方法所对应的bean并返回，resolveBeanReference方法代码如下：
 
  
private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
      ConfigurableBeanFactory beanFactory, String beanName) {

   boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
   try {
      if (alreadyInCreation) {
         beanFactory.setCurrentlyInCreation(beanName, false);
      }
      boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);
      if (useArgs && beanFactory.isSingleton(beanName)) {
         for (Object arg : beanMethodArgs) {
            if (arg == null) {
               useArgs = false;
               break;
            }
         }
      }

      // 从spring容器中获取这个bean
      Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
            beanFactory.getBean(beanName));
      if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {
         // Detect package-protected NullBean instance through equals(null) check
         if (beanInstance.equals(null)) {
            if (logger.isDebugEnabled()) {
               logger.debug(String.format("@Bean method %s.%s called as bean reference " +
                     "for type [%s] returned null bean; resolving to null value.",
                     beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),
                     beanMethod.getReturnType().getName()));
            }
            beanInstance = null;
         }
         else {
            String msg = String.format("@Bean method %s.%s called as bean reference " +
                  "for type [%s] but overridden by non-compatible bean instance of type [%s].",
                  beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),
                  beanMethod.getReturnType().getName(), beanInstance.getClass().getName());
            try {
               BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
               msg += " Overriding bean of same name declared in: " + beanDefinition.getResourceDescription();
            }
            catch (NoSuchBeanDefinitionException ex) {
               // Ignore - simply no detailed message then.
            }
            throw new IllegalStateException(msg);
         }
      }
      Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
      if (currentlyInvoked != null) {
         String outerBeanName = BeanAnnotationHelper.determineBeanNameFor(currentlyInvoked);
         // 注册两个bean之间的依赖关系
         beanFactory.registerDependentBean(beanName, outerBeanName);
      }
      return beanInstance;
   }
   finally {
      if (alreadyInCreation) {
         beanFactory.setCurrentlyInCreation(beanName, true);
      }
   }
}
 
  
关键就是调用了getBean方法从spring容器中获取这个@Bean方法对应的bean
 
  
 
  
总结
 
  
@Configuration注解能够使得加了它的对应的配置类在spring容器中是一个cglib代理bean，让配置类实例变成cglib代理实例的作用就是防止@Bean方法A又调用@Bean方法B的这种场景破坏了bean的单例性。解决这种场景的原理就是在spring实例化@Bean方法A对应的bean的时候，会通过反射调用配置类的@Bean方法A，在反射调用之前@Bean方法A放到currentlyInvokedFactoryMethod中，然后由于配置类已经是一个cglib代理对象了，所以会被BeanMethodInterceptor这个Callback进行拦截增强，此时判断到currentlyInvokedFactoryMethod中存在方法A，那么就直接执行这个@Bean方法A了，而@Bean方法A中又调用了@Bean方法B，所以此时在执行@Bean方法A的时候，@Bean方法B也会被BeanMethodInterceptor这个Callback所拦截增强，但是，此时currentlyInvokedFactoryMethod中的方法是@Bean方法A，所以isCurrentlyInvokedFactoryMethod方法判断返回的是false，也就是走resolveBeanReference方法从spring容器中去获取@Bean方法B对应的bean
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(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
    
                    
    • 
                                
  • Spring4.1新特性——Spring MVC增强
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • mysql 性能查询优化
                                    annan211
javasql优化mysql应用服务器
                                    
    

1 时间到底花在哪了？
  mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了
  检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方
  花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
    
                                
    • 
                                
  • windows系统配置
                                    cherishLC
windows
                                    
    删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： 
http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 
类似的还有pagefile.sys 
 
msconfig 配置启动项 
shutdown 定时关机 
 
ipconfig 查看网络配置 
ipconfig /flushdns
    
                                
    • 
                                
  • 人体的排毒时间
                                    Array_06
工作
                                    
    ======================== 
||  人体的排毒时间是什么时候？|| 
========================  
 
转载于： 
http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
    
                                
    • 
                                
  • ZooKeeper
                                    cugfy
zookeeper
                                    
    Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
    
                                
    • 
                                
  • 网络爬虫的乱码处理
                                    随意而生
爬虫网络
                                    
    下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
    
                                
    • 
                                
  • Xcode常用快捷键
                                    张亚雄
xcode
                                    
    一、总结的常用命令： 
 
    隐藏xcode command+h 
 
    退出xcode command+q 
 
    关闭窗口 command+w 
 
    关闭所有窗口 command+option+w 
 
    关闭当前
    
                                
    • 
                                
  • mongoDB索引操作
                                    adminjun
mongodb索引
                                    
    一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
    
                                
    • 
                                
  • 成都软件园实习那些话
                                    aijuans
成都 软件园 实习
                                    
    无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 
　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 
　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
    
                                
    • 
                                
  • Linux下FTP服务器安装及配置
                                    ayaoxinchao
linuxFTP服务器vsftp
                                    
    检测是否安装了FTP 
[root@localhost ~]# rpm -q vsftpd 
如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息 
  
安装FTP 
运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
    
                                
    • 
                                
  • 使用mongo-java-driver获取文档id和查找文档
                                    BigBird2012
driver
                                    
    注：本文所有代码都使用的mongo-java-driver实现。 
  
在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
    
                                
    • 
                                
  • JSONObject以及json串
                                    bijian1013
jsonJSONObject
                                    
    一.JAR包简介 
    要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包： 
    1.commons-lang-2.0.jar 
    2.commons-beanutils-1.7.0.jar 
    3.commons-collections-3.1.jar 
&n
    
                                
    • 
                                
  • [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性
                                    bit1129
zookeeper
                                    
    为了说明问题，看个简单的代码， 
  
    import org.apache.zookeeper.*;  
      
    import java.io.IOException;  
    import java.util.concurrent.CountDownLatch;  
    import java.util.concurrent.ThreadLocal
    
                                
    • 
                                
  • 【Scala十二】Scala核心六：Trait
                                    bit1129
scala
                                    
    Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
    
                                
    • 
                                
  • weblogic version 10.3破解
                                    ronin47
weblogic
                                    
    版本：WebLogic Server 10.3 
 
说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 
例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 
 
1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
    
                                
    • 
                                
  • 求第n个斐波那契数
                                    BrokenDreams

                                    
            今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。 
        自己试了下，搞了好久。。。基础要加强了。 
        
  &nbs
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-访问者模式-Visitor
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


import java.util.ArrayList;
import java.util.List;

interface IVisitor {
	
	//第二次分派，Visitor调用Element
	void visitConcret
    
                                
    • 
                                
  • MatConvNet的excise 3改为网络配置文件形式
                                    cherishLC
matlab
                                    
    MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 
主页：
http://www.vlfeat.org/matconvnet/ 
教程：
http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 
 
注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet：
http
    
                                
    • 
                                
  • ZK Timeout再讨论
                                    chenchao051
zookeepertimeouthbase
                                    
    http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： 
Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
    
                                
    • 
                                
  • CASE WHEN 用法介绍
                                    daizj
sqlgroup bycase when
                                    
    CASE WHEN 用法介绍 
 
1. CASE WHEN 表达式有两种形式 
 
 
--简单Case函数  
 
CASE sex  
WHEN '1' THEN '男'  
WHEN '2' THEN '女'  
ELSE '其他' END  
 
--Case搜索函数  
 
CASE 
WHEN sex = '1' THEN 
    
                                
    • 
                                
  • PHP技巧汇总:提高PHP性能的53个技巧
                                    dcj3sjt126com
PHP
                                    
    PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
    
                                
    • 
                                
  • Yii框架中CGridView的使用方法以及详细示例
                                    dcj3sjt126com
yii
                                    
    CGridView显示一个数据项的列表中的一个表。 
表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 
实例代码如下：
    
                                
    • 
                                
  • Maven项目打包成可执行Jar文件
                                    dyy_gusi
assembly
                                    
    Maven项目打包成可执行Jar文件 
在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 
1、在项目中加入插件的依赖： 
<plugin>
	
    
                                
    • 
                                
  • php常见错误
                                    geeksun
PHP
                                    
    1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
    
                                
    • 
                                
  • 修改linux的用户名
                                    hongtoushizi
linuxchange password
                                    
    Change Linux Username 
更改Linux用户名，需要修改4个系统的文件： 
/etc/passwd 
/etc/shadow 
/etc/group 
/etc/gshadow 
古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： 
vipw 
vipw -s 
vigr 
vigr -s 
  
具体的操作顺
    
                                
    • 
                                
  • 第五章 常用Lua开发库1-redis、mysql、http客户端
                                    jinnianshilongnian
nginxlua
                                    
    对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 
一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。 
  Redis客户端 
lua-resty-r
    
                                
    • 
                                
  • zkClient 监控机制实现
                                    liyonghui160com
zkClient 监控机制实现
                                    
      
       直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
    
                                
    • 
                                
  • 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句
                                    pda158
mysql
                                    
    在Mysql 众多表中查找一个表名或者字段名的 SQL 语句：   
　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name';
　　方法二：SELECT column_name from information_schema.colum
    
                                
    • 
                                
  • 程序员对英语的依赖
                                    Smile.zeng
英语程序猿
                                    
    1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 
2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 
3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 
4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 
 
以上一些问题，充分说明了英语对程序猿的重要性。骚年
    
                                
    • 
                                
  • Oracle学习笔记(8) 使用PLSQL编写触发器
                                    vipbooks
oraclesql编程活动Access
                                    
        时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！ 
    这是第八章的学习笔记，学习完第七章的子程序和包之后
    
                                
    •