Zzzj_1233
Zzzj_1233

Spring-Cloud源码：@RefreshScope

文章目录

  • 第一部分：@RefreshScope生成代理
    • 1. @RefreshScope注解
    • 2. 扫描@RefreshScope注解
    • 3. AnnotationConfigUtils.applyScopedProxyMode
    • 4. ScopedProxyCreator.createScopedProxy
    • 5. ScopedProxyFactoryBean
      • 5.1 `#getObject`
      • 5.2 `#setBeanFactory`
      • 5.3 LockedScopedProxyFactoryBean
      • 5.4 LockedScopedProxyFactoryBean#setBeanFactory
      • 5.5 LockedScopedProxyFactoryBean#invoke
    • 6. 小结
  • 第二部分：@RefreshScope的原始bean是如何刷新的
    • 1. IOC容器获取Scope类型的Bean
    • 2. RefreshScope
    • 3. BeanLifecycleWrapper
        • 3.1 BeanLifecycleWrapper的成员属性
        • 3.2 getBean方法
    • 4. desotry方法
    • 5. 小结
  • 第三部分：如何触发动态刷新
    • 1. RefreshEventListener
    • 2. 如何刷新Environment
      • 2.1 ContextRefresher#refresh
      • 2.2 ContextRefresher#refreshEnvironment
      • 2.3 ContextRefresher#addConfigFilesToEnvironment
    • 3. 谁发布了RefreshEvent事件
      • 3.1 以Nacos为例
  • 总结

本文并不打算讲述@RefreshScope注解如何使用。相反，我们将关注使用@RefreshScope注解的实现原理

第一部分：@RefreshScope生成代理

前置知识

  1. 被@RefreshScope注解标记的class，最终会向容器中注入两个BeanDefinition，一个是原始class对应的BeanDefinition，另一个是原始class对应的代理的BeanDefinition
  2. 原始class对应的BeanDefinition会被设置为不可注入，假设class名为Person，当Person被依赖注入到别的对象时，实际上注入的是代理对象
  3. 执行代理对象的任意方法时，代理对象通过beanFactory去获取Person未被代理的bean （ 也就是那个不可被注入的BeanDefinition对应的bean ），通过bean去执行方法。
    相当于代理是一个委托人，所有方法的执行都委托给：1. spring容器获取到bean 2. 通过bean去执行方法
  4. 重点就在于：每次执行方法时的bean都是从spring容器中重新获取的

1. @RefreshScope注解

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Scope("refresh")
@Documented
public @interface RefreshScope {
	ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;
}

可以看到，@RefreshScope注解上使用了@Scope注解, 对应的value为"refresh"

如此，一旦某个类被@RefreshScope所标注，spring扫描到这个类时，就可以扫描到@Scope注解，并且得到value为"refresh"

2. 扫描@RefreshScope注解

=================================================================

跟踪扫描注解的代码前，先有一个认知

Spring在扫描到被@Scope标注的类时, 会生成一个额外的 BeanDefinition

这个BeanDefinition的beanClass为ScopedProxyFactoryBean

=================================================================

doScan方法位于ClassPathBeanDefinitionScanner类中，Spring基于backPackages扫描组件就是通过这个方法实现的

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		
		for (String basePackage : basePackages) {
			
			// 1. 扫描后得到 { BeanDefinition } 集合
			// 具体的扫描逻辑在 { findCandidateComponents } 方法中, 这里就不深究了
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			
			for (BeanDefinition candidate : candidates) {
				
				// 2. 扫描 { BeanDefinition  } 上的 { @Scope } 注解
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				
				// { scopeMetadata.getScopeName() } 就是 { @Scope.value() }
				candidate.setScope(scopeMetadata.getScopeName());
				
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				
				// 3. 核心方法, 这个方法里, spring创建了另一个 { BeanDefinition } 并且注入到容器中
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
						
				beanDefinitions.add(definitionHolder);
				
				// 4. 将 { AnnotationConfigUtils.applyScopedProxyMode } 方法
				// 返回的 { BeanDefinition } 注入到容器中
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
		
		return beanDefinitions;
	}

下面继续跟踪AnnotationConfigUtils.applyScopedProxyMode

3. AnnotationConfigUtils.applyScopedProxyMode

	static BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
	
		// 1. 获取 { proxyMode }
		// 无论是 { @RefreshScope } 还是 { @Scope } 注解都有一个 { proxyMode() } 属性
		// 对应的类型就是 { ScopedProxyMode }  , 默认值为 { TARGET_CLASS }
		ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
		
		// 2. 如果手动设置为NO了, 那么不启用代理, 这种case很少见
		if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
			return definition;
		}
		
		boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
		
		// 3. 转而调用 { ScopedProxyCreator.createScopedProxy }
		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
	}

下面继续跟踪ScopedProxyCreator.createScopedProxy

4. ScopedProxyCreator.createScopedProxy

	public static BeanDefinitionHolder createScopedProxy(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry, boolean proxyTargetClass) {

		return ScopedProxyUtils.createScopedProxy(definitionHolder, registry, proxyTargetClass);
	}

没做啥事，直接调用了ScopedProxyUtils.createScopedProxy

ScopedProxyUtils.createScopedProxy是一个非常核心的方法，这个方法主要做了三件事

  1. 创建代理的BeanDefinition
  2. 将原始的BeanDefinition设置为不可注入
  3. 注册代理的BeanDefinition到Spring容器中。在Spring的下一个生命周期，这些BeanDefinition将被创建为Bean
	public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition,
			BeanDefinitionRegistry registry, boolean proxyTargetClass) {

		String originalBeanName = definition.getBeanName();
		BeanDefinition targetDefinition = definition.getBeanDefinition();
		String targetBeanName = getTargetBeanName(originalBeanName);

		// 1. 创建代理的 { BeanDefinition }, 对应的beanClass为 { ScopedProxyFactoryBean.class }
		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
		proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
		proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
		proxyDefinition.setSource(definition.getSource());
		proxyDefinition.setRole(targetDefinition.getRole());
		
		// 2. 设置 { targetBeanName }, 为原始 { BeanDefinition } 的 beanName
		
		// !!!很重要，因为到时候需要基于 { targetBeanName } 从spring容器中获取原始的bean
		proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
		
		if (proxyTargetClass) {
			targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
		}
		else {
			proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
		}

		proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
		proxyDefinition.setPrimary(targetDefinition.isPrimary());
		
		if (targetDefinition instanceof AbstractBeanDefinition) {
			proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
		}

		// 3. 为原始 { BeanDefinition } 设置为不可注入
		// 如此, 这个 { BeanDefinition } 创建出来的bean就无法被依赖注入了
		targetDefinition.setAutowireCandidate(false);
		targetDefinition.setPrimary(false);

		// 4. 注册原始的 { BeanDefinition } 到IOC容器中
		registry.registerBeanDefinition(targetBeanName, targetDefinition);
	
		// 5. 将 { proxyBeanDefinition } 包装成 { BeanDefinitionHolder }
		// 在第二步的 { doScan } 方法中, 会将这里 return的 { proxyBeanDefinition } 注册到IOC容器中
		return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
	}

经历以上步骤后，每个被@RefrehScope注解标注的class，会生成两个BeanDefinition注册到容器中

假设有一个Person的class

@RefreshScope
@Component
class Person {
	// ...
}

当这个class被扫描后，就会出现如下图的情况

Spring-Cloud源码：@RefreshScope_第1张图片

Spring容器的下一个生命周期，就会将容器中的BeanDefinition初始化为Bean

接下来看看ScopedProxyFactoryBean的逻辑

5. ScopedProxyFactoryBean

Spring-Cloud源码：@RefreshScope_第2张图片

  • ScopedProxyFactoryBean是一个FactoryBean, Spring通过调用FactoryBean的getObject()方法获取bean
  • ScopedProxyFactoryBean还实现了BeanFactoryAware接口，那么Spring将会回调setBeanFactory方法,并且传递BeanFactory作为参数

5.1 #getObject

	@Override
	public Object getObject() {
		if (this.proxy == null) {
			throw new FactoryBeanNotInitializedException();
		}
		return this.proxy;
	}

getObject()方法直接将proxy属性返回，而proxy属性在setBeanFactory方法中初始化

5.2 #setBeanFactory

	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
	
		ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;
		
		// 1. 给 { scopedTargetSource } 赋值 { beanFactory }
		this.scopedTargetSource.setBeanFactory(beanFactory);

		ProxyFactory pf = new ProxyFactory();
		pf.copyFrom(this);
		
		// 2. 给 { proxyFactory } 赋值 { targetSource }
		pf.setTargetSource(this.scopedTargetSource);

		Assert.notNull(this.targetBeanName, "Property 'targetBeanName' is required");

		ScopedObject scopedObject = new DefaultScopedObject(cbf, this.scopedTargetSource.getTargetBeanName());
		
		pf.addAdvice(new DelegatingIntroductionInterceptor(scopedObject));

		pf.addInterface(AopInfrastructureBean.class);
		
		// 3. 创建代理
		this.proxy = pf.getProxy(cbf.getBeanClassLoader());
	}

这里又使用到了ProxyFactory 来创建代理

  • 关于ProxyFactory 的使用，可以查看这篇文章ProxyFactory使用
  • 关于ProxyFactory 的源码，可以查看这篇文章ProxyFactory源码

注释1和注释2，一直在提及scopedTargetSource

scopedTargetSource 是ScopedProxyFactoryBean的成员属性

对应的class为SimpleBeanTargetSource

public class SimpleBeanTargetSource extends AbstractBeanFactoryBasedTargetSource {

	@Override
	public Object getTarget() throws Exception {
		return getBeanFactory().getBean(getTargetBeanName());
	}

}

只需要关注getTarget方法，其逻辑为：每次都从beanFactory中根据beanName获取bean

那么这个beanName是什么呢？

还记得在ScopedProxyUtils.createScopedProxy方法中给ScopedProxyFactoryBean的BeanDefinition中设置了beanName

跳转回顾ScopedProxyUtils.createScopedProxy方法

  1. scopedTargetSource 被赋值给了proxyFactory
  2. ProxyFactory创建出来的代理对象实现了Adviced接口
  3. Adviced接口就具有获取targetSource的能力
  4. 在接下来：LockedScopedProxyFactoryBean就会将代理对象转换为Adviced, 然后获取targetSource，实际上就是scopedTargetSource
  5. 再调用targetSource的getTarget()方法，根据上面的代码可知，getTarget()方法将从Spring容器中获取bean，这一点非常重要，暂且有个印象

5.3 LockedScopedProxyFactoryBean

GenericScope是RefreshScope的父类

GenericScope同时还是一个BeanDefinitionRegistryPostProcessor

Spring会回调GenericScope的postProcessBeanDefinitionRegistry方法

GenericScope在postProcessBeanDefinitionRegistry将ScopedProxyFactoryBean的BeanDefinition替换为了LockedScopedProxyFactoryBean

LockedScopedProxyFactoryBean是ScopedProxyFactoryBean的子类

这块内容本应该在下面提及，但是LockedScopedProxyFactoryBean重写了ScopedProxyFactoryBean的setBeanFactory方法

Spring-Cloud源码：@RefreshScope_第3张图片

5.4 LockedScopedProxyFactoryBean#setBeanFactory

@Override
public void setBeanFactory(BeanFactory beanFactory) {
	
	// 1. 先调用父类的 { setBeanFactory }
	super.setBeanFactory(beanFactory);
	
	// 2. 获取proxy对象
	Object proxy = getObject();
	
	// 3. 强制转换为 { Advised } , 并且添加一个 "advice" { this }
	if (proxy instanceof Advised) {
		Advised advised = (Advised) proxy;
		
		// 插入在索引为0的位置
		advised.addAdvice(0, this);
	}
}

LockedScopedProxyFactoryBean实现了MethodInterceptor方法，是一个Advice

那么，执行代理对象的任何方法时，都会首先执行LockedScopedProxyFactoryBean的invoke方法

5.5 LockedScopedProxyFactoryBean#invoke

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
	Method method = invocation.getMethod();
	
	// equals / hashCode / toString ... 直接执行方法
	if (AopUtils.isEqualsMethod(method) || AopUtils.isToStringMethod(method)
			|| AopUtils.isHashCodeMethod(method)
			|| isScopedObjectGetTargetObject(method)) {
		return invocation.proceed();
	}

	// 1. 获取代理对象
	Object proxy = getObject();
	
	// 2. 获取读写锁, 读写锁的创建逻辑会在分析 { RefreshScope } 的源码时提及
	ReadWriteLock readWriteLock = this.scope.getLock(this.targetBeanName);
	
	Lock lock = readWriteLock.readLock();
	
	// 3. 上读锁
	lock.lock();
	
	try {
		// 4. 强制转换为 { adviced }
		Advised advised = (Advised) proxy;
		
		ReflectionUtils.makeAccessible(method);
		
		// 5. 反射执行方法
		
		// 第一个参数：要执行的方法
	
		// 第二个参数：{ dvised.getTargetSource().getTarget() } 这里很关键
		// 还记得 5.2 分析 { setBeanFactory } 方法创建代理时提及的吗
		// 这里的 { getTarget } 方法会从spring容器中获取bean
		
		// 第三个参数：方法参数
		return ReflectionUtils.invokeMethod(method,
				advised.getTargetSource().getTarget(),
				invocation.getArguments());
	}
	catch (UndeclaredThrowableException e) {
		throw e.getUndeclaredThrowable();
	}
	finally {
		lock.unlock();
	}
}

跳转回顾getTarget()方法

6. 小结

1~5步，主要分析了以下逻辑

  1. @Refresh注解标注的class被Spring扫描后，会向容器中注入两个BeanDefinition，一个是原始的Bean的BeanDefinition，另一个是ScopedProxyFactoryBean的BeanDefinition
  2. 原始的bean被设置为不可注入，ScopedProxyFactoryBean被赋值targetBeanName属性，对应原始的Bean的BeanName ，使ScopedProxyFactoryBean具有从Spring容器中根据BeanName获取原始Bean的能力
  3. RefreshScope会在Spring容器创建Bean之前，将容器中BeanDefinition为ScopedProxyFactoryBean替换为LockedScopedProxyFactoryBean
  4. LockedScopedProxyFactoryBean是一个FactoryBean，其getObject方法会返回一个代理。假设有一个Person类使用了@RefreshScope注解，另外一个类依赖Spring注入Person类的实例，实际上注入的是getObject方法返回的代理对象
  5. 执行代理对象的任何方法时，代理对象都会从Spring容器中根据BeanName获取原始Bean来执行

关键点就在于，每次执行方法都是从Spring容器中获取的bean来执行方法

Spring-Cloud源码：@RefreshScope_第4张图片

第二部分：@RefreshScope的原始bean是如何刷新的

1. IOC容器获取Scope类型的Bean

我们已经知道了实际上注入的是代理对象，而代理对象会通过IOC容器获取原始bean去执行方法

根据第一部分扫描Bean时可知，原始Bean是一个Scope类型的Bean

Spring容器中只有单例的Bean会被缓存！！！
Spring容器中只有单例的Bean会被缓存！！！
Spring容器中只有单例的Bean会被缓存！！！

也就是说，代理对象每次获取原始的Bean，都会执行下面的逻辑

Spring-Cloud源码：@RefreshScope_第5张图片

if (mbd.isSingleton()) {
	// 获取单例Bean
	// ...
}
else if (mbd.isPrototype()) {
	// 获取多例Bean
	// ...
}

else {
	// 1. 获取 { beanDefinition } 的 { scope } 属性
	String scopeName = mbd.getScope();
	
	// 2. 根据 { scope } 属性找到对应的 { Scope } 对象
	
	// 例如 scope = "refresh"对应的就是 { RefreshScope }

	final Scope scope = this.scopes.get(scopeName);

	// 3. 调用 { scope }	 对象的 { get } 方法创建bean
	
	// 第一个参数是 { beanName } : bean的名称, 
	
	// !!!第二个参数是 { ObjectFactory } : bean创建工厂, 拥有创建bean的能力
	
	Object scopedInstance = scope.get(beanName, () -> {
		beforePrototypeCreation(beanName);
		try {
			return createBean(beanName, mbd, args);
		}
		finally {
			afterPrototypeCreation(beanName);
		}
	});
	bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}

Spring根据BeanDefinition创建对象时

如果BeanDenifition既不是单例也不是多态的，那么根据BeanDenifition的scope属性来创建对象

而@Scope(value = "refresh") ， 对应的 Scope 就是 RefreshScope

当前RefreshScope指定是类，而不是注解

也就是说，Spring将创建bean委托给了RefreshScope

2. RefreshScope

根据上一步的分析，Spring调用了Scope对象的get(beanName, obejctFactory)方法

这个方法位于RefreshScope的父类GenericScope

RefreshScope并没有重写这个方法，所以跟踪父类的get方法

	public Object get(String name, ObjectFactory<?> objectFactory) {
		
		// 1. 创建BeanLifecycleWrapper 
		BeanLifecycleWrapper value = new BeanLifecycleWrapper(name, objectFactory);
		
		// 2. 放入cache中
		this.cache.put(name, value);
		
		// 3. 每个 { beanName } 都有一把读写锁
		
		// 在Locked
		this.locks.putIfAbsent(name, new ReentrantReadWriteLock());
		try {
			// 4. 调用 { BeanLifecycleWrapper#getBean } 方法, 创建一个对象
			return value.getBean();
		}
		catch (RuntimeException e) {
			this.errors.put(name, e);
			throw e;
		}
	}

	@Override
	public Object get(String name, ObjectFactory<?> objectFactory) {
		
		// 1. 创建BeanLifecycleWrapper, 并且放入缓存中
		
		// 这个put方法被封装了一层, 其实里面调用的是 { putIfAbsent }
		
		// 也就是说, 只有cache不存在的时候才会put进去
	
		// Spring其实这里写的不太好, 每次都new了一个新的 { BeanLifecycleWrapper }, 却不一定能用上
		BeanLifecycleWrapper value = this.cache.put(name,
				new BeanLifecycleWrapper(name, objectFactory));
		
		// 2. 每个 { beanName } 都有一把读写锁
		// 在 { LockedScopedProxyFactoryBean } 的 { invoke } 方法中就使用了读锁
		this.locks.putIfAbsent(name, new ReentrantReadWriteLock());
		
		try {
			// 3. 调用 { BeanLifecycleWrapper#getBean } 方法, 创建一个对象
			return value.getBean();
		}
		catch (RuntimeException e) {
			this.errors.put(name, e);
			throw e;
		}
	}

值得注意的是：

RefreshScope对象是单例的，也就是说，所有scope为refresh的对象

都是由RefreshScope对象创建的，那么也就全都保存在了RefreshScope对象的cache属性中

可以看到，RefreshScope做了这些事情

  1. 创建BeanLifecycleWrapper
  2. 保存cache
  3. 为beanName创建ReentrantReadWriteLock
  4. 调用BeanLifecycleWrapper的getBean方法

继续跟踪BeanLifecycleWrapper

3. BeanLifecycleWrapper

3.1 BeanLifecycleWrapper的成员属性
class BeanLifecycleWrapper {
	
	// 1. beanName
	private final String name;
	
	// 2. bean创建工厂, 就是步骤二调用 { get } 方法时的第二个参数
	private final ObjectFactory<?> objectFactory;
		
	// 3. bean的实例, 通过 { objectFactory } 创建得到, 一开始为 { null }
	private Object bean;
	
	// 4. bean销毁前的回调, 如果为 { null } , 那么bean无需被销毁
	private Runnable callback;
	
}
3.2 getBean方法
public Object getBean() {
	if (this.bean == null) {
		// 双重检测锁
		synchronized (this.name) {
			if (this.bean == null) {
				
				// 调用objectFactory的getObject()方法创建bean
				this.bean = this.objectFactory.getObject();
			}
		}
	}
	return this.bean;
}

  1. 就是调用了objectFactory的getBean方法
    objectFactory就是IOC容器创建bean时的第二个参数，跳转回顾第二个参数

  2. 将对象赋值给this.bean属性，下次再调用getBean()方法时直接返回this.bean

Spring-Cloud源码：@RefreshScope_第6张图片

那么如果，将某个BeanName在Cache中的BeanLifecycleWrapper移除掉

下次再调用getBean方法时，这个对象就会通过objectFactory#getObject重新创建一次

所以，GenericScope有一个destroy方法，就可以清除缓存

4. desotry方法

	@Override
	public void destroy() {
		List<Throwable> errors = new ArrayList<Throwable>();
		
		// 看这里：清空缓存
		Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();
		
		for (BeanLifecycleWrapper wrapper : wrappers) {
			try {
				Lock lock = this.locks.get(wrapper.getName()).writeLock();
				lock.lock();
				try {
					wrapper.destroy();
				}
				finally {
					lock.unlock();
				}
			}
			catch (RuntimeException e) {
				errors.add(e);
			}
		}
		if (!errors.isEmpty()) {
			throw wrapIfNecessary(errors.get(0));
		}
		this.errors.clear();
	}

那我们接下来应该去寻找哪里调用了destory方法，应该就是动态刷新的入口点了

5. 小结

  1. 已知代理对象每次执行方法时，都会从Spring容器中获取原始Bean
  2. 原始Bean属于Scope类型，并不会被缓存，每次都会调用RefreshScope对象的get方法获取
  3. RefreshScope 有一个cache属性，Refresh使用cache通过beanName获取BeanLifecycleWrapper，再调用BeanLifecycleWrapper的getBean方法获取对象
  4. 一旦RefreshScope 的cache被清除，再次获取bean的时候，无法命中缓存，就会重新创建BeanLifecycleWrapper，也就会再次调用objectFactory#getObject创建Bean
  5. objectFactory#getObject创建Bean的时候会使用Spring的Environment中的属性为Bean的属性赋值

第三部分：如何触发动态刷新

1. RefreshEventListener

RefreshEventListener是一个ApplicationListener

一旦接收到RefreshEvent，就会调用ContextRefresher的refresh方法

ContextRefresher先重新刷新上下文，再调用RefreshScope的refreshAll方法

在refreshAll方法中调用了destory方法：清空缓存
Spring-Cloud源码：@RefreshScope_第7张图片

那么就还剩下了最后两个疑问

  1. ContextRefresher是如何刷新environment的
  2. 是谁发布了RefreshEvent事件

2. 如何刷新Environment

2.1 ContextRefresher#refresh

public synchronized Set<String> refresh() {

	// 刷新environment
	Set<String> keys = refreshEnvironment();
	
	// this.scope 就是 refreshScope
	this.scope.refreshAll();
	                                                                                                                       
	return keys;
}

2.2 ContextRefresher#refreshEnvironment

public synchronized Set<String> refreshEnvironment() {
	
	// 忽略：为EnvironmentChangeEvent做准备的
	Map<String, Object> before = extract(
			this.context.getEnvironment().getPropertySources());
	
	// 核心方法：就是在这里更新了ApplicationContext的environment属性
	addConfigFilesToEnvironment();
	
	Set<String> keys = changes(before,
			extract(this.context.getEnvironment().getPropertySources())).keySet();
	
	this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
	
	return keys;
}

2.3 ContextRefresher#addConfigFilesToEnvironment

	/* For testing. */ ConfigurableApplicationContext addConfigFilesToEnvironment() {
		ConfigurableApplicationContext capture = null;
		
		// 1. 保存当前的environment
		StandardEnvironment environment = copyEnvironment(
				this.context.getEnvironment());
	
		// 2. 创建一个SpringApplicationBuilder, 用于创建SpringApplication
		SpringApplicationBuilder builder = new SpringApplicationBuilder(Empty.class)
				.bannerMode(Mode.OFF).web(WebApplicationType.NONE)
				// !!! 设置environment
				.environment(environment);
		
		// 3. 
		// - 添加BootstrapApplicationListener读取bootstrap.yml
		// - 添加ConfigFileApplicationListener读取application.yml
		builder.application()
				.setListeners(Arrays.asList(new BootstrapApplicationListener(),
						new ConfigFileApplicationListener()));
		
		// 4. 启动SpringBootApplication
		// 启动完成后,  这个environment对象就有最新的值了
		capture = builder.run();
		
		// 5. target是当前contenxt的environment
		MutablePropertySources target = this.context.getEnvironment()
				.getPropertySources();
				
		String targetName = null;
		
		// 6. 进行比较
		for (PropertySource<?> source : environment.getPropertySources()) {
			String name = source.getName();
			
			if (target.contains(name)) {
				targetName = name;
			}
			
			// standardSources包含了一些不需要更新的属性集合
			if (!this.standardSources.contains(name)) {
				
				// 当前context有这个key对应的值, 那么替换为最新的
				if (target.contains(name)) {
					target.replace(name, source);
				}
				else {
					// 没有则新增
					if (targetName != null) {
						target.addAfter(targetName, source);
					}
					else {
						target.addFirst(source);
						targetName = name;
					}
				}
			}
		}
		return capture;
	}

为什么重新启动一个SpringBootApplication，Environment里就有最新的值了呢？

以Nacos为例

PropertySourceBootstrapConfiguration位于spring.factories文件中，会被SpringBootApplication加载到

通过SpringBoot回调initialize，initialize通过PropertySourceLocator加载属性，放入到environment中

而Nacos的AutoConfiguration则注入了NacosPropertySourceLocator到容器中

NacosPropertySourceLocator通过网络链接到nacos，读取配置信息，最终被放入到了environment中

这一块属于nacos-config的实现细节，本篇就不深究了

=====================================================================

只需要知道一个结论

重新启动的SpringBootApplication的environment具有最新的属性，ContextRefresher进行比较后，给当前context的environment赋最新的值

=====================================================================

3. 谁发布了RefreshEvent事件

3.1 以Nacos为例

在NacosContextRefresher#registerNacosListener方法中

	private void registerNacosListener(final String groupKey, final String dataKey) {
		String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey);
		
		// 监听器, configServer长轮询nacos-server
		// 一旦监听到配置变更, 就会回调listener的 { innerReceive } 方法
		Listener listener = listenerMap.computeIfAbsent(key,
				lst -> new AbstractSharedListener() {
					@Override
					public void innerReceive(String dataId, String group,
							String configInfo) {
						refreshCountIncrement();
						nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo);

						// !!! 发布RefreshEvent事件
						applicationContext.publishEvent(
								new RefreshEvent(this, null, "Refresh Nacos config"));

					}
				});
		try {
			
			// 注册listener, 启用长轮询监听
			configService.addListener(dataKey, groupKey, listener);
		}
		catch (NacosException e) {
			log.warn(String.format(
					"register fail for nacos listener ,dataId=[%s],group=[%s]", dataKey,
					groupKey), e);
		}
	}

这块属于Nacos-Config的源码，就不深究了

总结

  1. @RefreshScope注解标注的class，会生成两个BeanDefinition
    • 一个是LockedScopedProxyFactoryBean ：用于生成代理对象
    • 一个是class对应的BeanDefinition，我们暂成为原始BeanDefinition ：用于生成原始Bean
  2. 原始Bean是不可被注入的，实际上注入的都是代理Bean
  3. 代理Bean执行方法时，都是通过applicationContext获取原始Bean来执行的
  4. 原始Bean是一个Scope类型的Bean，applicationContext通过RefreshScope对象来获取原型Bean
  5. RefreshScope具有缓存机制
  6. 一旦缓存被清除，原始Bean就会重新被创建
  7. 一旦发布了RefreshEvent事件
    1. ContextRefresh就会通过创建一个新的SpringApplication来更新environment，赋最新值
    2. ContextRefresh会调用RefreshScope清空缓存

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

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
  • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
  • SpringMVC设置全局异常处理器 水岸齐天 javaspring
    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • springboot集成logback-spring.xml文件 RT_0114 SpringBootspringbootspringlogback
    彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
  • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
  • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ideeclipsejava
    报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
  • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
  • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • Azkaban各种类型的Job编写 __元昊__
    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
  • java基础相关面试题详细总结 。。。。。96 java开发语言
    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
  • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
  • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
  • 程序员开发技术整理 laizhixue 学习前端框架
    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
  • javascript的数据类型及转换 田小田txt
    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
  • java线程之Lock的使用 dimdark
    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解 爱跑步的程序员~ 刷题蓝桥杯省赛
    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
  • Java学习笔记04：Java_数组 JasonYangQ Javajava
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
  • 【设计模式】Java 设计模式之桥接模式（Bridge） 新手村长 Java设计模式设计模式java桥接模式
    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
  • Websocket服务监听收发消息 beiback Java服务器问题websocket网络协议网络
    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java 计算机程序老哥
    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
  • jQuery 跨域访问的三种方式 No 'Access-Control-Allow-Origin' header is present on the reque qiaolevip 每天进步一点点学习永无止境跨域众观千象
    XMLHttpRequest cannot load http://v.xxx.com. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:63342' is therefore not allowed access. test.html:1
  • mysql 分区查询优化 annan211 java分区优化mysql
    分区查询优化 引入分区可以给查询带来一定的优势，但同时也会引入一些bug. 分区最大的优点就是优化器可以根据分区函数来过滤掉一些分区，通过分区过滤可以让查询扫描更少的数据。 所以，对于访问分区表来说，很重要的一点是要在where 条件中带入分区，让优化器过滤掉无需访问的分区。 可以通过查看explain执行计划，是否携带 partitions
  • MYSQL存储过程中使用游标 chicony Mysql存储过程
    DELIMITER $$ DROP PROCEDURE IF EXISTS getUserInfo $$ CREATE PROCEDURE getUserInfo(in date_day datetime)-- -- 实例-- 存储过程名为：getUserInfo-- 参数为：date_day日期格式:2008-03-08--    BEGINdecla
  • mysql 和 sqlite 区别 Array_06 sqlite
    转载： http://www.cnblogs.com/ygm900/p/3460663.html mysql 和 sqlite 区别 SQLITE是单机数据库。功能简约，小型化，追求最大磁盘效率 MYSQL是完善的服务器数据库。功能全面，综合化，追求最大并发效率 MYSQL、Sybase、Oracle等这些都是试用于服务器数据量大功能多需要安装，例如网站访问量比较大的。而sq
  • pinyin4j使用 oloz pinyin4j
    首先需要pinyin4j的jar包支持；jar包已上传至附件内 方法一:把汉字转换为拼音；例如：编程转换后则为biancheng      /** * 将汉字转换为全拼 * @param src 你的需要转换的汉字 * @param isUPPERCASE 是否转换为大写的拼音； true:转换为大写；fal
  • 微博发送私信 随意而生 微博
    在前面文章中说了如和获取登陆时候所需要的cookie，现在只要拿到最后登陆所需要的cookie，然后抓包分析一下微博私信发送界面 http://weibo.com/message/history?uid=****&name=**** 可以发现其发送提交的Post请求和其中的数据， 让后用程序模拟发送POST请求中的数据，带着cookie发送到私信的接入口，就可以实现发私信的功能了。
  • jsp 香水浓 jsp
    JSP初始化     容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。如果您需要执行自定义的JSP初始化任务，复写jspInit()方法就行了 JSP执行     这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。     当JSP网页完成初始化后
  • 在 Windows 上安装 SVN Subversion 服务端 AdyZhang SVN
    在 Windows 上安装 SVN Subversion 服务端2009-09-16高宏伟哈尔滨市道里区通达街291号   最佳阅读效果请访问原地址：http://blog.donews.com/dukejoe/archive/2009/09/16/1560917.aspx   现在的Subversion已经足够稳定，而且已经进入了它的黄金时段。我们看到大量的项目都在使
  • android开发中如何使用 alertDialog从listView中删除数据？ aijuans android
    我现在使用listView展示了很多的配置信息，我现在想在点击其中一条的时候填出 alertDialog,点击确认后就删除该条数据，（ ArrayAdapter ，ArrayList，listView 全部删除），我知道在 下面的onItemLongClick 方法中 参数 arg2  是选中的序号，但是我不知道如何继续处理下去 1 2 3
  • jdk-6u26-linux-x64.bin 安装 baalwolf linux
    1.上传安装文件(jdk-6u26-linux-x64.bin) 2.修改权限 [root@localhost ~]# ls -l /usr/local/jdk-6u26-linux-x64.bin 3.执行安装文件 [root@localhost ~]# cd /usr/local [root@localhost local]# ./jdk-6u26-linux-x64.bin&nbs
  • MongoDB经典面试题集锦 BigBird2012 mongodb
    1.什么是NoSQL数据库？NoSQL和RDBMS有什么区别？在哪些情况下使用和不使用NoSQL数据库？ NoSQL是非关系型数据库，NoSQL = Not Only SQL。 关系型数据库采用的结构化的数据，NoSQL采用的是键值对的方式存储数据。 在处理非结构化/半结构化的大数据时；在水平方向上进行扩展时；随时应对动态增加的数据项时可以优先考虑使用NoSQL数据库。 在考虑数据库的成熟
  • JavaScript异步编程Promise模式的6个特性 bijian1013 JavaScriptPromise
            Promise是一个非常有价值的构造器，能够帮助你避免使用镶套匿名方法，而使用更具有可读性的方式组装异步代码。这里我们将介绍6个最简单的特性。         在我们开始正式介绍之前，我们想看看Javascript Promise的样子： var p = new Promise(function(r
  • [Zookeeper学习笔记之八]Zookeeper源代码分析之Zookeeper.ZKWatchManager bit1129 zookeeper
    ClientWatchManager接口 //接口的唯一方法materialize用于确定那些Watcher需要被通知 //确定Watcher需要三方面的因素1.事件状态 2.事件类型 3.znode的path public interface ClientWatchManager { /** * Return a set of watchers that should
  • 【Scala十五】Scala核心九：隐式转换之二 bit1129 scala
    隐式转换存在的必要性，   在Java Swing中，按钮点击事件的处理，转换为Scala的的写法如下：   val button = new JButton button.addActionListener( new ActionListener { def actionPerformed(event: ActionEvent) {
  • Android JSON数据的解析与封装小Demo ronin47
    转自：http://www.open-open.com/lib/view/open1420529336406.html package com.example.jsondemo; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject;    impor
  • [设计]字体创意设计方法谈 brotherlamp UIui自学ui视频ui教程ui资料
      从古至今，文字在我们的生活中是必不可少的事物，我们不能想象没有文字的世界将会是怎样。在平面设计中，UI设计师在文字上所花的心思和功夫最多，因为文字能直观地表达UI设计师所的意念。在文字上的创造设计，直接反映出平面作品的主题。 如设计一幅戴尔笔记本电脑的广告海报，假设海报上没有出现“戴尔”两个文字，即使放上所有戴尔笔记本电脑的图片都不能让人们得知这些电脑是什么品牌。只要写上“戴尔笔
  • 单调队列-用一个长度为k的窗在整数数列上移动，求窗里面所包含的数的最大值 bylijinnan java算法面试题
    import java.util.LinkedList; /* 单调队列 滑动窗口 单调队列是这样的一个队列：队列里面的元素是有序的，是递增或者递减 题目：给定一个长度为N的整数数列a(i),i=0,1,...,N-1和窗长度k. 要求：f(i) = max{a(i-k+1),a(i-k+2),..., a(i)},i = 0,1,...,N-1 问题的另一种描述就
  • struts2处理一个form多个submit chiangfai struts2
    web应用中，为完成不同工作，一个jsp的form标签可能有多个submit。如下代码： <s:form action="submit" method="post" namespace="/my"> <s:textfield name="msg" label="叙述：">
  • shell查找上个月，陷阱及野路子 chenchao051 shell
    date -d "-1 month" +%F     以上这段代码，假如在2012/10/31执行，结果并不会出现你预计的9月份，而是会出现八月份，原因是10月份有31天，9月份30天，所以-1 month在10月份看来要减去31天，所以直接到了8月31日这天，这不靠谱。     野路子解决：假设当天日期大于15号
  • mysql导出数据中文乱码问题 daizj mysql中文乱码导数据
    解决mysql导入导出数据乱码问题方法： １、进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+----------------------------------------+ | Variable_name&nbs
  • SAE部署Smarty出现：Uncaught exception 'SmartyException' with message 'unable to write dcj3sjt126com PHPsmartysae
      对于SAE出现的问题：Uncaught exception 'SmartyException' with message 'unable to write file...。 官方给出了详细的FAQ：http://sae.sina.com.cn/?m=faqs&catId=11#show_213 解决方案为：   01 $path 
  • 《教父》系列台词 dcj3sjt126com
    Your love is also your weak point. 你的所爱同时也是你的弱点。   If anything in this life is certain, if history has taught us anything, it is that you can kill anyone.   不顾家的人永远不可能成为一个真正的男人。 &
  • mongodb安装与使用 dyy_gusi mongo
    一.MongoDB安装和启动,widndows和linux基本相同 1.下载数据库,     linux:mongodb-linux-x86_64-ubuntu1404-3.0.3.tgz 2.解压文件,并且放置到合适的位置     tar -vxf mongodb-linux-x86_64-ubun
  • Git排除目录 geeksun git
    在Git的版本控制中，可能有些文件是不需要加入控制的，那我们在提交代码时就需要忽略这些文件，下面讲讲应该怎么给Git配置一些忽略规则。   有三种方法可以忽略掉这些文件，这三种方法都能达到目的，只不过适用情景不一样。 1.  针对单一工程排除文件 这种方式会让这个工程的所有修改者在克隆代码的同时，也能克隆到过滤规则，而不用自己再写一份，这就能保证所有修改者应用的都是同一
  • Ubuntu 创建开机自启动脚本的方法 hongtoushizi ubuntu
    转载自： http://rongjih.blog.163.com/blog/static/33574461201111504843245/ Ubuntu 创建开机自启动脚本的步骤如下： 1) 将你的启动脚本复制到 /etc/init.d目录下 以下假设你的脚本文件名为 test。   2) 设置脚本文件的权限 $ sudo chmod 755
  • 第八章 流量复制/AB测试/协程 jinnianshilongnian nginxluacoroutine
    流量复制 在实际开发中经常涉及到项目的升级，而该升级不能简单的上线就完事了，需要验证该升级是否兼容老的上线，因此可能需要并行运行两个项目一段时间进行数据比对和校验，待没问题后再进行上线。这其实就需要进行流量复制，把流量复制到其他服务器上，一种方式是使用如tcpcopy引流；另外我们还可以使用nginx的HttpLuaModule模块中的ngx.location.capture_multi进行并发
  • 电商系统商品表设计 lkl
    DROP TABLE IF EXISTS `category`; -- 类目表 /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `category` ( `id` int(11) NOT NUL
  • 修改phpMyAdmin导入SQL文件的大小限制 pda158 sqlmysql
    　用phpMyAdmin导入mysql数据库时，我的10M的 数据库不能导入，提示mysql数据库最大只能导入2M。 　　 phpMyAdmin数据库导入出错： 　　You probably tried to upload too large file. Please refer to documentation for ways to workaround this limit.
  • Tomcat性能调优方案 Sobfist apachejvmtomcat应用服务器
    一、操作系统调优 对于操作系统优化来说，是尽可能的增大可使用的内存容量、提高CPU的频率，保证文件系统的读写速率等。经过压力测试验证，在并发连接很多的情况下，CPU的处理能力越强，系统运行速度越快。。 【适用场景】 任何项目。 二、Java虚拟机调优 应该选择SUN的JVM，在满足项目需要的前提下，尽量选用版本较高的JVM，一般来说高版本产品在速度和效率上比低版本会有改进。 J
  • SQLServer学习笔记 vipbooks 数据结构xml
    1、create database school 创建数据库school 2、drop database school 删除数据库school 3、use school 连接到school数据库，使其成为当前数据库 4、create table class(classID int primary key identity not null) 创建一个名为class的表，其有一
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他