public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
     
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

	int ROLE_APPLICATION = 0;

	int ROLE_SUPPORT = 1;

	int ROLE_INFRASTRUCTURE = 2;
	
	void setParentName(@Nullable String parentName);

	@Nullable
	String getParentName();
	
	void setBeanClassName(@Nullable String beanClassName);//设置bean的className

	@Nullable
	String getBeanClassName();

	void setScope(@Nullable String scope);//设置bean的scope属性

	@Nullable
	String getScope();

	void setLazyInit(boolean lazyInit);//设置lazyInit
	
	boolean isLazyInit();//

	void setDependsOn(@Nullable String... dependsOn);
	
	//省略了其他方法
}

public interface BeanFactory {

	/**
	 * 通过name获取容器中管理的bean
	 * @param name bean的name
	 * @return bean的一个实例
	 */
	Object getBean(String name) throws BeansException;
	
	<T> T getBean(String name, @Nullable Class<T> requiredType)throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;
     
    <T> T getBean(Class<T> requiredType) throws BeansException;
     
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    
    boolean containsBean(String name);//是否包含某个bean
      
    //是否是单 模式
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    //是否是原型模式
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    //省略了其他方法
}

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	String getId();

	String getApplicationName();
	
	String getDisplayName();

	long getStartupDate();

	ApplicationContext getParent();
	
	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

//使用FileSystemXmlApplicationContext加载配置文件
ApplicationContext context=new FileSystemXmlApplicationContext("classpath*:/spring/applicationContext.xml");
//ClassPathXmlApplicationContext加载
//ApplicationContext context=new ClassPathXmlApplicationContext("classpath*:/spring/applicationContext.xml");
//从容器中获取bean
Student student= (Stuedent) context.getBean("student");//根据id从配置文件中获取bean
student.getName();

public FileSystemXmlApplicationContext {
   }

   public FileSystemXmlApplicationContext(ApplicationContext parent) {
       super(parent);
   }

   /** 
    * 构造函数：需要传入XML资源文件的路径 
    */
   public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
       this(new String[]{configLocation}, true, (ApplicationContext)null);
   }
   
   /** 
    * 构造函数：传入多个资源文件 
    */
   public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
       this(configLocations, true, (ApplicationContext)null);
   }

   /** 
    * 构造函数 
    * @param configLocations 资源文件数组 
    * @param parent 双亲IoC容器 
    */
   public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
       this(configLocations, true, parent);
   }
   
   /** 
    * 构造函数 
    * @param configLocations 资源文件路径 
    * @param refresh 是否调用refresh方法载入BeanDefinition 
    */ 
   public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
       this(configLocations, refresh, (ApplicationContext)null);
   }

   /** 
    * 构造函数,其他构造函数最终调用的都是该函数
    * @param configLocations 资源文件路径 
    * @param refresh 是否调用refresh方法载入BeanDefinition 
    */ 
   public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
       super(parent);
       this.setConfigLocations(configLocations);
       if(refresh) {
           this.refresh();//分析容器初始化的一个重要入口
       }

   }
   /**
    * 通过资源文件路径获取Resource对象,返回的是一个FileSystemResource对象，通过这个对象可以进行相关I/O操作，完成BeanDefinition定位 
    * @param path 资源文件路径 
    * @return Resource spring中的资源对象 
    */ 
   protected Resource getResourceByPath(String path) {
       if(path.startsWith("/")) {
           path = path.substring(1);
       }

       return new FileSystemResource(path);
   }

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            // 调用obtainFreshBeanFactory()方法获取IoC容器，容器的创建和对Resource的定位就在该方法中
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }
}
/**
 * 获取BeanFactory
 */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //refreshBeanFactory中会创建IoC容器
        this.refreshBeanFactory();
        //获取创建的IoC容器
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }

public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {

protected final void refreshBeanFactory() throws BeansException {
        //如果已经建立了BeanFactory,销毁并关闭BeanFactory  
        if(this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
           //构造了一个BeanFactory,这里使用DefaultListableBeanFactory实现  
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            beanFactory.setSerializationId(this.getId());
            this.customizeBeanFactory(beanFactory);
            //载入BeanDefinition 
            this.loadBeanDefinitions(beanFactory);
            Object var2 = this.beanFactoryMonitor;
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }
    
    /** 
     * 创建DefaultListableBeanFactory的地方 
     * getInternalParentBeanFactory()的具体实现可以参看AbstractApplicationContext的实现 
     * 
     * @return 
     */
    protected DefaultListableBeanFactory createBeanFactory() {
        return new DefaultListableBeanFactory(this.getInternalParentBeanFactory());
    }
    
    /** 
     * 获取创建的IoC容器
     */
    public final ConfigurableListableBeanFactory getBeanFactory() {
        Object var1 = this.beanFactoryMonitor;
        synchronized(this.beanFactoryMonitor) {
            if(this.beanFactory == null) {
                throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext");
            } else {
                return this.beanFactory;
            }
        }
    }
    
    /** 
     * 抽象方法，载入BeanDefinition,由子类AbstractXmlApplicationContext实现
     * 
     * @param beanFactory 
     * @throws BeansException 
     * @throws IOException 
     */  
    protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)  
            throws BeansException, IOException;
}

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //创建XmlBeanDefinitionReader对象，通过回调设置到BeanFactory中 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        //设置ResourceLoader
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        //启动Bean定义信息载入的过程，委托给beanDefinitionReader完成  
        this.initBeanDefinitionReader(beanDefinitionReader);
        //载入BeanDefinition
        this.loadBeanDefinitions(beanDefinitionReader);
    }
    
       protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {  
           reader.setValidating(this.validating);  
       }  
  
       /** 
        * 载入BeanDefinition 
        * @param reader 
        * @throws BeansException 
        * @throws IOException 
        */  
       protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {  
           //获取Reource类型的配置文件的地址
           Resource[] configResources = getConfigResources();  
           if (configResources != null) {  
               //调用AbstractBeanDefinitionReader中的loadBeanDefinitions方法 
               reader.loadBeanDefinitions(configResources);
               }  
           //获取字符串类型的配置文件的地址
           String[] configLocations = getConfigLocations();  
           if (configLocations != null) {  
               //调用AbstractBeanDefinitionReader中的loadBeanDefinitions方法 
               reader.loadBeanDefinitions(configLocations);  
           }  
       }  
  
       protected Resource[] getConfigResources() {  
           return null;  
       }
}

FileSystemXmlApplicationContext("classpath*:/spring/applicationContext.xml");

public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader {

    /** 
    * 载入参数类型是Resource对象的BeanDefinition，由子类XmlBeanDefinitionReader实现
    */ 
	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		//对载入Bean的数量进行统计
		int counter = 0;
		//遍历整个Resource集合，从每个集合中载入所有的BeanDefinition
		for (Resource resource : resources) {
		    //loadBeanDefinitions方法是一个接口方法，在XmlBeanDefinitionReader中有具体的实现  
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}
	
   /** 
    * 根据配置文件的地址，载入BeanDefinition
    */ 
	@Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	   //获取ResourceLoader对象，实际使用的是DefaultResourceLoader  
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}
       //这里对Resource的路径模式进行解析，得到Resource集合，这些集合指向我们已经定义好的BeanDefinition信息
		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
			    //调用DefaultResourceLoader的getResource完成Resource定位，将传入的资源文件的地址，转为Resource对象
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

   /** 
    * 根据配置文件的地址，载入BeanDefinition
    */ 
	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int counter = 0;
		for (String location : locations) {
			counter += loadBeanDefinitions(location);
		}
		return counter;
	}
}

public class DefaultResourceLoader implements ResourceLoader {  
     public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        Iterator var2 = this.protocolResolvers.iterator();

        Resource resource;
        do {
            if(!var2.hasNext()) {
                //处理带有/反斜杠的resource  
                if(location.startsWith("/")) {
                    return this.getResourceByPath(location);
                }
                //处理带有calsspath标识的resource  
                if(location.startsWith("classpath:")) {
                    return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
                }

                try {
                    //处理URL标识的resource  
                    URL url = new URL(location);
                    return (Resource)(ResourceUtils.isFileURL(url)?new FileUrlResource(url):new UrlResource(url));
                } catch (MalformedURLException var5) {
                    return this.getResourceByPath(location);
                }
            }

            ProtocolResolver protocolResolver = (ProtocolResolver)var2.next();
            resource = protocolResolver.resolve(location, this);
        } while(resource == null);

        return resource;
    }
    
    protected Resource getResourceByPath(String path) {
        return new DefaultResourceLoader.ClassPathContextResource(path, this.getClassLoader());
    }
}

public SqlSessionFactory build(Configuration config) {
   //创建一个DefaultSqlSessionFactory返回，它实现了SqlSessionFactory接口
   return new DefaultSqlSessionFactory(config);
 }

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);//生成执行器
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
   executorType = executorType == null ? defaultExecutorType : executorType;
   executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
   Executor executor;
   //根据类型判断创建哪种类型的执行器
   if (ExecutorType.BATCH == executorType) {
     executor = new BatchExecutor(this, transaction);
   } else if (ExecutorType.REUSE == executorType) {
     executor = new ReuseExecutor(this, transaction);
   } else {//默认的执行器
     executor = new SimpleExecutor(this, transaction);
   }
   //如果开启了二级缓存，创建缓存执行器（装饰者模式）
   if (cacheEnabled) {
     executor = new CachingExecutor(executor);
   }
   executor = (Executor) interceptorChain.pluginAll(executor);
   return executor;
 }

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  try {
    MappedStatement ms = configuration.getMappedStatement(statement);
    //调用了执行器的query方法
    return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

public class CachingExecutor implements Executor {

  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);//装饰者模式
  }
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameterObject);
  //创建缓存key，一级缓存中提过如何创建CacheKey
  CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

 @Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
    throws SQLException {
  //从MappedStatement获取缓存
  Cache cache = ms.getCache();
  //如果缓存不为空
  if (cache != null) {
    //是否需要刷新缓存
    flushCacheIfRequired(ms);
    //是否开启了useCache
    if (ms.isUseCache() && resultHandler == null) {
      ensureNoOutParams(ms, boundSql);
      @SuppressWarnings("unchecked")
      List<E> list = (List<E>) tcm.getObject(cache, key);//从缓存取数据
      if (list == null) {
        //如果为空，调用Executor中的query方法，走一级缓存的流程
        list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list); // 将数据放入缓存
      }
      return list;
    }
  }
  //二级缓存为空，调用Executor中的query方法，走一级缓存的流程
  return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

//从MappedStatement获取缓存
Cache cache = ms.getCache();

public interface Cache {

  String getId();

  void putObject(Object key, Object value);

  Object getObject(Object key);

  Object removeObject(Object key);

  void clear();

  int getSize();
  
  ReadWriteLock getReadWriteLock();

}

List<E> list = (List<E>) tcm.getObject(cache, key);//从缓存取数据

public class TransactionalCacheManager {

  private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
}

public class TransactionalCacheManager {

  private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();

  public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
  }
  
  public void putObject(Cache cache, CacheKey key, Object value) {
    getTransactionalCache(cache).putObject(key, value);
  }

  private TransactionalCache getTransactionalCache(Cache cache) {
    //根据Cache获取TransactionalCache对象
    TransactionalCache txCache = transactionalCaches.get(cache);
    //如果获取为空
    if (txCache == null) {
      //创建一个TransactionalCache对象，并装饰当前的Cache对象的实现者
      txCache = new TransactionalCache(cache);
      transactionalCaches.put(cache, txCache);
    }
    return txCache;
  }
}

public class TransactionalCache implements Cache {

  private static final Log log = LogFactory.getLog(TransactionalCache.class);

  private final Cache delegate;
  private boolean clearOnCommit;//事务提交时是否清空缓存
  private final Map<Object, Object> entriesToAddOnCommit;//待提交的缓存数据
  private final Set<Object> entriesMissedInCache;//统计命中率使用

  public TransactionalCache(Cache delegate) {
    this.delegate = delegate;
    this.clearOnCommit = false; //默认提交清除缓存为false
    this.entriesToAddOnCommit = new HashMap<Object, Object>();
    this.entriesMissedInCache = new HashSet<Object>();
  }

  /**
   * 获取缓存
   * @param key The key
   * @return
   */
  @Override
  public Object getObject(Object key) {
    // getObject方法中，会一路传递到PerpetualCache，然后获取数据
    Object object = delegate.getObject(key);
    //如果未获取到数据
    if (object == null) {
      //将数据放入集合，统计命中率使用
      entriesMissedInCache.add(key);
    }
    // issue #146
    if (clearOnCommit) {
      return null;
    } else {
      return object;
    }
  }
  
  /**
   * 添加缓存数据
   * @param key Can be any object but usually it is a {@link CacheKey}
   * @param object
   */
  @Override
  public void putObject(Object key, Object object) {
    //首先将数据放入到待提交缓存数据中
    entriesToAddOnCommit.put(key, object);
  }

  //省去了其他方法

}

@Override
public void commit() {
  commit(false);
}

@Override
public void commit(boolean force) {
  try {
    //调用了Executor实现类的commit方法
    executor.commit(isCommitOrRollbackRequired(force));
    dirty = false;
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

@Override
public void commit(boolean required) throws SQLException {
  delegate.commit(required);
  tcm.commit();//调用了TransactionalCacheManager的commit方法
}

public void commit() {
  for (TransactionalCache txCache : transactionalCaches.values()) {
    txCache.commit();//调用了TransactionalCache的commit方法
  }
}

@Override
  public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();//清空待提交缓存数据
  }

  public void commit() {
    //如果事务提交需要清空缓存
    if (clearOnCommit) {
      delegate.clear();//交给装饰的Cache对象清空缓存
    }
    //刷新缓存数据
    flushPendingEntries();
    //重置
    reset();
  }

  private void reset() {
    clearOnCommit = false;
    entriesToAddOnCommit.clear();//清空待提交的缓存数据
    entriesMissedInCache.clear();
  }

  private void flushPendingEntries() {
    //遍历待提交的缓存数据
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      //委托给装饰的Cache类，将待提交的缓存数据加入缓存，会交给 PerpetualCache对象
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    for (Object entry : entriesMissedInCache) {
      if (!entriesToAddOnCommit.containsKey(entry)) {
        delegate.putObject(entry, null);
      }
    }
  }

private void cacheElement(XNode context) throws Exception {
  if (context != null) {
    //获取各种配置信息
    String type = context.getStringAttribute("type", "PERPETUAL");
    Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
    String eviction = context.getStringAttribute("eviction", "LRU");
    Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
    Long flushInterval = context.getLongAttribute("flushInterval");
    Integer size = context.getIntAttribute("size");
    boolean readWrite = !context.getBooleanAttribute("readOnly", false);
    boolean blocking = context.getBooleanAttribute("blocking", false);
    Properties props = context.getChildrenAsProperties();
    //创建缓存对象
    builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
  }
}

public Cache useNewCache(Class<? extends Cache> typeClass,
     Class<? extends Cache> evictionClass,
     Long flushInterval,
     Integer size,
     boolean readWrite,
     boolean blocking,
     Properties props) {
   Cache cache = new CacheBuilder(currentNamespace)
       .implementation(valueOrDefault(typeClass, PerpetualCache.class))
       .addDecorator(valueOrDefault(evictionClass, LruCache.class))
       .clearInterval(flushInterval)
       .size(size)
       .readWrite(readWrite)
       .blocking(blocking)
       .properties(props)
       .build();//使用建造者模式实例化对象
   configuration.addCache(cache);
   currentCache = cache;
   return cache;
 }

public Cache build() {
    setDefaultImplementations();//设置默认的Cache实现类
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    // issue #352, do not apply decorators to custom caches
    if (PerpetualCache.class.equals(cache.getClass())) {
      for (Class<? extends Cache> decorator : decorators) {
        cache = newCacheDecoratorInstance(decorator, cache);
        setCacheProperties(cache);
      }
      cache = setStandardDecorators(cache);//设置标准的装饰器
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
      cache = new LoggingCache(cache);
    }
    return cache;
  }
  
private void setDefaultImplementations() {
    if (implementation == null) {
      implementation = PerpetualCache.class;//使用PerpetualCache作为默认的实现类
      if (decorators.isEmpty()) {
        decorators.add(LruCache.class);//如果装饰器为空，添加LruCache装饰器，对Cache对象进行装饰
      }
    }
  }

private Cache setStandardDecorators(Cache cache) {
   try {
     MetaObject metaCache = SystemMetaObject.forObject(cache);
     if (size != null && metaCache.hasSetter("size")) {
       metaCache.setValue("size", size);
     }
     //如果clearInterval不为空，使用cheduledCache装饰
     if (clearInterval != null) {
       cache = new ScheduledCache(cache);
       ((ScheduledCache) cache).setClearInterval(clearInterval);
     }
     if (readWrite) {
       //使用SerializedCache装饰
       cache = new SerializedCache(cache);
     }
     //使用LoggingCache装饰
     cache = new LoggingCache(cache);
     //使用SynchronizedCache装饰
     cache = new SynchronizedCache(cache);
     if (blocking) {
       //使用BlockingCache装饰
       cache = new BlockingCache(cache);
     }
     return cache;
   } catch (Exception e) {
     throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
   }

public abstract class BaseExecutor implements Executor {

  private static final Log log = LogFactory.getLog(BaseExecutor.class);

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  protected PerpetualCache localCache; //缓存
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;

  protected int queryStack;
  private boolean closed;

......

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    //构建CacheKey
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);//调用了下面的query方法
 }

  @SuppressWarnings("unchecked")
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //如果queryStack为0或者并且有必要刷新缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();//清空本地缓存
    }
    List<E> list;
    try {
      queryStack++;
      //从缓存中获取数据，key的类型为CacheKey
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        //处理本地缓存输出参数
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {//如果获取结果为空，从数据库中查找
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      //如果是STATEMENT级别的缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // 清空缓存
        clearLocalCache();
      }
    }
    return list;
  }
}

//从缓存中获取数据，key的类型为CacheKey  
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;

//如果获取结果为空，从数据库中查找  
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);

//如果queryStack为0或者并且有必要刷新缓存  
if(queryStack == 0 && ms.isFlushCacheRequired()) {  
  clearLocalCache();//清空本地缓存  
}

//如果是STATEMENT级别的缓存  
if(configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {  
    //清空缓存  
    clearLocalCache();  
}

<setting name="localCacheScope" value="STATEMENT"/>

@Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    //设置ID，也就是标签所在的Mapper的namespace + 标签的id
    cacheKey.update(ms.getId());
    //偏移量，Mybatis自带分页类RowBounds中的属性
    cacheKey.update(rowBounds.getOffset());
    //每次查询大小，同样是Mybatis自带分页类RowBounds中的属性
    cacheKey.update(rowBounds.getLimit());
    //标签中定义的SQL语句
    cacheKey.update(boundSql.getSql());
    //获取参数
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // 处理SQL中的参数
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

public class CacheKey implements Cloneable, Serializable {

  private static final long serialVersionUID = 1146682552656046210L;

  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();

  private static final int DEFAULT_MULTIPLYER = 37;
  private static final int DEFAULT_HASHCODE = 17;

  private final int multiplier;//一个乘数
  private int hashcode;//hashcode
  private long checksum;//update方法中传入参数的hashcode之和
  private int count; //调用update方法向updatelist添加参数的的次数
  private List<Object> updateList;//调用update传入的参数会被放到updateList

  public CacheKey() {
    //初始化
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLYER;
    this.count = 0;
    this.updateList = new ArrayList<Object>();
  }

  public CacheKey(Object[] objects) {
    this();
    updateAll(objects);
  }

  public int getUpdateCount() {
    return updateList.size();
  }

  public void update(Object object) {
    //获取参数的hash值
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
    //计数
    count++;
    //hash值累加
    checksum += baseHashCode;
    //更新hash,hash=hash*count
    baseHashCode *= count;
    //计算CacheKey的hashcode
    hashcode = multiplier * hashcode + baseHashCode;
    //将参数添加到updateList
    updateList.add(object);
  }
}

@Override
  public boolean equals(Object object) {
    //如果对象为空
    if (this == object) {
      return true;
    }
    //如果不是CacheKey的实例
    if (!(object instanceof CacheKey)) {
      return false;
    }

    final CacheKey cacheKey = (CacheKey) object;
    //如果hashcode值不相同
    if (hashcode != cacheKey.hashcode) {
      return false;
    }
    // 如果checksum不相同
    if (checksum != cacheKey.checksum) {
      return false;
    }
    //如果count不相同
    if (count != cacheKey.count) {
      return false;
    }
    //对比两个对象的updatelist中的值是否相同
    for (int i = 0; i < updateList.size(); i++) {
      Object thisObject = updateList.get(i);
      Object thatObject = cacheKey.updateList.get(i);
      //如果有不相同的，返回false
      if (!ArrayUtil.equals(thisObject, thatObject)) {
        return false;
      }
    }
    return true;
  }