Spring Ioc 之 Bean的加載（二）
在上篇文章中Spring Ioc 之 Bean的加載（一），咱們分析了Spring Ioc中Bean的加載 doGetBean() 方法的
2.2從緩存中獲取單例bean和2.3獲取最終的bean實例對象兩個步驟，咱們接着分析餘下幾個步驟。
直接上代碼：java
//真正實現向IOC容器獲取Bean的功能，也是觸發依賴注入功能的地方
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//根據指定的名稱獲取被管理Bean的名稱，剝離指定名稱中對容器的相關依賴
// 若是指定的是別名，將別名轉換爲規範的Bean名稱
<1> final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 從緩存中獲取已被建立過的單例Bean
<2> Object sharedInstance = getSingleton(beanName);
//若是緩存中有
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//注意：BeanFactory是管理容器中Bean的工廠
// FactoryBean是建立建立對象的工廠Bean，二者之間有區別
//獲取給定Bean的實例對象，該對象要麼是 bean 實例自己，要麼就是 FactoryBean 建立的 Bean 對象
//（爲何要再次獲取呢，由於上面獲取的sharedInstance不必定是完整的）
<3> bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 由於 Spring 只解決單例模式下的循環依賴，在原型模式下若是存在循環依賴則會拋出異常。
<4> if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
//能在當前的BeanFactory中獲取的所須要的Bean，若是不能則委託當前容器
//的父級容器去查找，若是仍是找不到則沿着容器的繼承體系向父級容器查找
BeanFactory parentBeanFactory = getParentBeanFactory();
//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//解析指定Bean名稱的原始名稱
String nameToLookup = originalBeanName(name);
// 若爲 AbstractBeanFactory 類型，委託父類處理
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
//委派父級容器根據指定名稱和顯式的參數查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
//委派父級容器根據指定名稱和類型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 建立的Bean是否須要進行類型驗證，通常不須要
<5> if (!typeCheckOnly) {
//向容器標記指定的Bean已經被建立
markBeanAsCreated(beanName);
}
try {
//從容器中獲取 beanName 相應的 GenericBeanDefinition 對象，並將其轉換爲 RootBeanDefinition 對象
// 主要解決Bean繼承時子類合併父類公共屬性問題
<6> final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 檢查給定的合併的 BeanDefinition (是否爲抽象類)
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 處理所依賴的 bean @DependsOn()
// 獲取當前Bean全部依賴Bean的名稱
<7> String[] dependsOn = mbd.getDependsOn();
//若是有依賴
if (dependsOn != null) {
for (String dep : dependsOn) {
//校驗該依賴是否已經註冊過給當前 Bean
if (isDependent(beanName, dep)) {
//已註冊，拋出異常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//沒有，則先註冊依賴的bean
registerDependentBean(dep, beanName);
//遞歸調用getBean()，先生成依賴的bean
getBean(dep);
}
}
// Create bean instance.
//建立單例Bean
<8> if (mbd.isSingleton()) {
//這裏使用了一個匿名內部類，建立Bean實例對象，而且註冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//建立一個指定Bean實例對象，若是有父級繼承，則合併子類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//顯式地從容器單例模式Bean緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//建立多例Bean
else if (mbd.isPrototype()) {
//原型模式(Prototype)是每次都會建立一個新的對象
Object prototypeInstance = null;
try {
//加載前置處理，默認的功能是註冊當前建立的原型對象
beforePrototypeCreation(beanName);
//建立指定Bean對象實例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//加載後置處理，默認的功能告訴IOC容器指定Bean的原型對象再也不建立
afterPrototypeCreation(beanName);
}
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//要建立的Bean既不是Singleton也不是Prototype
//如：request、session、application等生命週期
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//這裏又使用了一個匿名內部類，獲取一個指定生命週期範圍的實例
Object scopedInstance = scope.get(beanName, () -> {
//前置處理
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
//後置處理
afterPrototypeCreation(beanName);
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
//對建立的Bean實例對象進行類型檢查
<9> if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
代碼很長，須要一些耐心，下面咱們來逐步分析這段代碼：spring
-
<1>處：具體分析，見
2.1獲取原始beanName緩存 -
<2>處: 具體分析，見
2.2從緩存中獲取單例beansession -
<3>處: 具體分析，見
2.3獲取最終的bean實例對象app -
<4>處: 具體分析，見
2.4原型模式依賴檢查(Prototype)和從 parentBeanFactory 獲取 Beanide -
<5>處: 具體分析，見
2.5標記bean爲已建立或即將建立ui -
<6>處: 具體分析，見
2.6獲取BeanDefinitionthis -
<7>處: 具體分析，見
2.7bean依賴處理.net -
<8>處: 具體分析，見
2.8不一樣做用域bean的實例化prototype -
<9>處: 具體分析，見
2.9類型轉換
2.四、原型模式依賴檢查(Prototype)和從 parentBeanFactory 獲取 Bean
原型模式依賴檢查，對應代碼以下：
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
跟蹤進去：
/** Names of beans that are currently in creation */
private final ThreadLocal<Object> prototypesCurrentlyInCreation =
new NamedThreadLocal<>("Prototype beans currently in creation");
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
//從ThreadLocal中取出正在建立的prototype
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null &&
(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}
Spring 只處理單例模式下得循環依賴，對於原型模式的循環依賴直接拋出異常。
Spring會把正在建立的原型模式Bean存入ThreadLoacl，在這裏經過ThreadLoacl來判斷當前Bean是否已經建立。
從 parentBeanFactory 獲取 Bean，對應代碼以下：
// Check if bean definition exists in this factory.
//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
//能在當前的BeanFactory中獲取的所須要的Bean，若是不能則委託當前容器
//的父級容器去查找，若是仍是找不到則沿着容器的繼承體系向父級容器查找
BeanFactory parentBeanFactory = getParentBeanFactory();
//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//解析指定Bean名稱的原始名稱
String nameToLookup = originalBeanName(name);
// 若爲 AbstractBeanFactory 類型，委託父類處理
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
//委派父級容器根據指定名稱和顯式的參數查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
//委派父級容器根據指定名稱和類型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
若是當前容器緩存中沒有相對應的 BeanDefinition 對象，則會嘗試從父類工廠（parentBeanFactory）中加載，而後再去遞歸調用 getBean(...) 方法
2.五、標記bean爲已建立或即將建立
對應代碼以下：
//建立的Bean是否須要進行類型驗證，通常不須要
if (!typeCheckOnly) {
//向容器標記指定的Bean已經被建立
markBeanAsCreated(beanName);
}
typeCheckOnly是doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly)方法中的一個參數，通常這個參數傳的都是false
接着追蹤markBeanAsCreated()方法：
protected void markBeanAsCreated(String beanName) {
// 沒有建立
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
// 再次檢查一次：DCL 雙重校驗
if (!this.alreadyCreated.contains(beanName)) {
clearMergedBeanDefinition(beanName);
// 添加到已建立 bean 集合中
this.alreadyCreated.add(beanName);
}
}
}
}
這裏用到了單例模式中耳熟能詳的雙重校驗
2.六、獲取BeanDefinition
對應代碼以下：
//從容器中獲取 beanName 相應的 GenericBeanDefinition 對象，並將其轉換爲 RootBeanDefinition 對象 //主要解決Bean繼承時子類合併父類公共屬性問題 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 檢查給定的合併的 BeanDefinition (是否爲抽象類) checkMergedBeanDefinition(mbd, beanName, args);
這段代碼註釋很詳細，就很少解釋了。
2.七、bean依賴處理
對應代碼以下：
// Guarantee initialization of beans that the current bean depends on.
// 處理所依賴的 bean @DependsOn()
//獲取當前Bean全部依賴Bean的名稱
<1> String[] dependsOn = mbd.getDependsOn();
//若是有依賴
if (dependsOn != null) {
for (String dep : dependsOn) {
//校驗該依賴是否已經註冊過給當前 Bean
<2> if (isDependent(beanName, dep)) {
//已註冊，拋出異常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//沒有，則先註冊依賴的bean
<3> registerDependentBean(dep, beanName);
//遞歸調用getBean()，先生成依賴的bean
<4> getBean(dep);
}
}
在spring中有一個@DependsOn註解，它的做用是依賴加載，好比A對象要在B對象加載以後才能加載，那麼能夠在A上面加@DependsOn(value = "B")註解，就能夠達到咱們的要求。
其實@DependsOn實現的原理就是上面這段代碼。
-
<1>、經過咱們前面從IoC容器中拿到的
BeanDefinition，調用mbd.getDependsOn()方法，獲取當前bean全部的依賴。 -
<2>、遍歷這些依賴，判斷此依賴是否已註冊給當前的Bean
-
<3>、沒有，則先註冊依賴的Bean
-
<4>、遞歸調用getBean()，先生成依賴的bean
<2>、遍歷這些依賴，判斷此依賴是否已註冊給當前的Bean
代碼:
// 保存的是bean與其依賴的映射關係：B - > A
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//保存的是bean與其依賴的映射關係：A - > B
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
// 獲取當前原始 beanName
String canonicalName = canonicalName(beanName);
// 獲取該bean依賴的其餘bean集合
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
return false;
}
// 存在，則證實該依賴已經註冊到bean中
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
// 遞歸檢測依賴
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
這段代碼很簡單，主要就是經過dependentBeanMap獲取當前bean對應的全部依賴dependentBeans，而後判斷是否已註冊，接着遞歸檢查依賴的Bean有沒有依賴，若是有，就遞歸調用isDependent()檢查
<3>、沒有，則先註冊依賴的Bean
若是沒有註冊依賴的Bean到該 Bean，則執行註冊registerDependentBean(dep, beanName)：
// 保存的是bean與其依賴的映射關係：B - > A
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//保存的是bean與其依賴的映射關係：A - > B
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
//爲指定的Bean注入依賴的Bean
public void registerDependentBean(String beanName, String dependentBeanName) {
// A quick check for an existing entry upfront, avoiding synchronization...
//獲取原始beanName
String canonicalName = canonicalName(beanName);
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
return;
}
// No entry yet -> fully synchronized manipulation of the dependentBeans Set
//先從容器中：bean名稱-->所有依賴Bean名稱集合找查找給定名稱Bean的依賴Bean
synchronized (this.dependentBeanMap) {
//獲取給定名稱Bean的全部依賴Bean名稱
dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
//爲Bean設置依賴Bean信息
dependentBeans = new LinkedHashSet<>(8);
this.dependentBeanMap.put(canonicalName, dependentBeans);
}
//把映射關係存入集合
dependentBeans.add(dependentBeanName);
}
//從容器中：bean名稱-->指定名稱Bean的依賴Bean集合找查找給定名稱Bean的依賴Bean
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
if (dependenciesForBean == null) {
dependenciesForBean = new LinkedHashSet<>(8);
this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
}
//把映射關係存入集合
dependenciesForBean.add(canonicalName);
}
}
套用上面的例子，若是 A @DependsOn(value = "B") ，也就是說A依賴於B，那麼該方法registerDependentBean(dep, beanName)中，參數 dep 就是B，beanName 就是A。
這段代碼中其實就是把bean之間的依賴關係註冊到兩個map中。
-
dependentBeanMap 存入(B,A)
-
dependenciesForBeanMap 存入(A,B)
<4>、遞歸調用getBean(dep)，先生成依賴的bean
到了這一步，遞歸調用getBean(beanName)方法也就是doGetBean(beanName)重走當前流程，來先實例化依賴的Bean。等依賴的Bean實例化以後，當前bean再接着往下執行。
2.八、不一樣做用域bean的實例化
代碼：
// Create bean instance.
//建立單例Bean
if (mbd.isSingleton()) {
//這裏使用了一個匿名內部類，建立Bean實例對象，而且註冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//建立一個指定Bean實例對象，若是有父級繼承，則合併子類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//顯式地從容器單例模式Bean緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//建立多例Bean
else if (mbd.isPrototype()) {
//原型模式(Prototype)是每次都會建立一個新的對象
Object prototypeInstance = null;
try {
//加載前置處理，默認的功能是註冊當前建立的原型對象
beforePrototypeCreation(beanName);
//建立指定Bean對象實例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//加載後置處理，默認的功能告訴IOC容器指定Bean的原型對象再也不建立
afterPrototypeCreation(beanName);
}
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//要建立的Bean既不是Singleton也不是Prototype
//如：request、session、application等生命週期
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//這裏又使用了一個匿名內部類，獲取一個指定生命週期範圍的實例
Object scopedInstance = scope.get(beanName, () -> {
//前置處理
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
//後置處理
afterPrototypeCreation(beanName);
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
這段代碼很明顯，分紅了3個部分：
-
singleton Bean實例化
-
Prototype Bean實例化
-
其餘類型 Bean 實例化(session,request等)
咱們先來看singleton Bean實例化：
if (mbd.isSingleton()) {
//這裏使用了一個匿名內部類，建立Bean實例對象，而且註冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//建立一個指定Bean實例對象，若是有父級繼承，則合併子類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//顯式地從容器單例模式Bean緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(sharedInstance, name,beanName, mbd);
}
Spring Bean 的做用域默認爲 singleton 。還有其餘做用域，如 prototype、request、session 等。
不一樣的做用域會有不一樣的初始化策略。
詳見Spring Ioc 之 Bean的加載（三）：各個 scope 的 Bean 建立。
2.九、類型轉換
代碼：
// Check if required type matches the type of the actual bean instance.
//對建立的Bean實例對象進行類型檢查
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
//執行轉換
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
// 轉換失敗，拋異常
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
requiredType是 getBean() 方法可傳入的一個參數，便可以根據指定的 beanName 和 requiredType 來獲取Bean。
可是通常狀況下是不須要類型檢查的，requiredType通常爲null，如getBean(beanName)
當requiredType不爲null的時候走這段邏輯。
總結：
至此，spring加載Bean也就是 getBean() 咱們大體分析完了，以後會再寫幾篇文章對其中有些步驟進行詳細介紹。
參考： 芋道源碼
相關文章
- 1. spring ioc之bean的加載流程（二）
- 2. Spring IOC 之 加載 Bean
- 3. Spring IoC bean 的加載
- 4. Spring Ioc 之 Bean的加載（四）：createBean()
- 5. spring ioc之bean的加載流程（一）
- 6. Spring Ioc 之 Bean的加載（一）
- 7. 【死磕 Spring】----- IOC 之 加載 Bean
- 8. Spring-IoC之加載Bean源碼分析
- 9. Spring Ioc 之 Bean的加載（三）：各個 scope 的 Bean 建立
- 10. Spring IOC(二) bean加載及bean依賴設置
- 更多相關文章...
- • Spring Bean的生命週期 - Spring教程
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他進程嵌入到qt FindWindow獲得窗口句柄 報錯無法鏈接的外部符號 [email protected] 無法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的應用-TOPK問題
- 6. 實例演示ElasticSearch索引查詢term,match,match_phase,query_string之間的區別
- 7. 數學基礎知識 集合
- 8. amazeUI 復擇框問題解決
- 9. 揹包問題理解
- 10. 算數平均-幾何平均不等式的證明,從麥克勞林到柯西
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. spring ioc之bean的加載流程（二）
- 2. Spring IOC 之 加載 Bean
- 3. Spring IoC bean 的加載
- 4. Spring Ioc 之 Bean的加載（四）：createBean()
- 5. spring ioc之bean的加載流程（一）
- 6. Spring Ioc 之 Bean的加載（一）
- 7. 【死磕 Spring】----- IOC 之 加載 Bean
- 8. Spring-IoC之加載Bean源碼分析
- 9. Spring Ioc 之 Bean的加載（三）：各個 scope 的 Bean 建立
- 10. Spring IOC(二) bean加載及bean依賴設置