MyBatis Plus插件机制 MyBatis Plus插件机制与执行流程原理分析详解

<bean id="sqlSessionFactoryBean" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource">
</property>
<property name="configLocation" value="classpath:mybatis-config.xml">
</property>
<!-- 别名处理 --><property name="typeAliasesPackage" value="com.jane.mp.beans">
</property>
<!-- 注入全局MP策略配置 --><property name="globalConfig" ref="globalConfiguration">
</property>
<!-- 插件注册 --><property name="plugins"><list><!-- 注册分页插件 -->
<bean class="com.baomidou.mybatisplus.plugins.PaginationInterceptor">
</bean>
<!-- 注册执行分析插件 --><bean class="com.baomidou.mybatisplus.plugins.SqlExplainInterceptor">
<property name="stopProceed" value="true"></property></bean>
<!-- 注册性能分析插件 -->
<bean class="com.baomidou.mybatisplus.plugins.PerformanceInterceptor"><property name="format" value="true">
</property>
<!-- <property name="maxTime" value="5"></property> --></bean>
<!-- 注册乐观锁插件 -->
<bean class="com.baomidou.mybatisplus.plugins.OptimisticLockerInterceptor"></bean>
</list></property></bean>

@Bean public PaginationInterceptor paginationInterceptor() 
{  
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();  
// 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false  
// paginationInterceptor.setOverflow(false); 
// 设置最大单页限制数量，默认 500 条，-1 不受限制  
// paginationInterceptor.setLimit(500); 
// 开启 count 的 join 优化,只针对部分 left join  
paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true)); 
return paginationInterceptor; 
}

 /** 创建一个bean实例，为bean实例设置属性值，调用post-processors-bean后置处理器 */@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) 
 throws BeanCreationException 
 {//...暂时忽略其他代码 
 try {// 这里会首先触发BeanPostProcessors ，如果这里能获取到bean则直接返回，不再走doCreateBean 
 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 
 if (bean != null)
 { 
 return bean; 
 } }//...暂时忽略其他代码

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) 
{ Object bean = null; 
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved))
{ 
// Make sure bean class is actually resolved at this point. 
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors())
{  
Class<?> targetType = determineTargetType(beanName, mbd);  
if (targetType != null) {  
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);  
if (bean != null)
{   
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  
}  
} 
} 
mbd.beforeInstantiationResolved = (bean != null); 
} 
return bean;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException 
{
// Instantiate the bean.--实例化beanBeanWrapper instanceWrapper = null;if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) 
{//获取bean的包装对象-这里很重要 instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) 
{ if (!mbd.postProcessed)
 { try {//调用MergedBeanDefinitionPostProcessors的postProcessMergedBeanDefinition方法  applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 
} catch (Throwable ex) 
{ 
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,   "Post-processing of merged bean definition failed", ex); 
} mbd.postProcessed = true; }}//...//这里暂时忽略其他代码
// Initialize the bean instance.--初始化bean实例Object exposedObject = bean;try {//如下方法很重要 populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) 
{ 
 exposedObject = initializeBean(beanName, exposedObject, mbd); 
}}//...

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {//获取属性值列表PropertyValues pvs = mbd.getPropertyValues();
//...该种符号表示暂时忽略其他代码
//在为bean属性赋值前，给InstantiationAwareBeanPostProcessors 机会修改bean的状态//应用场景如支持字段注入boolean continueWithPropertyPopulation = true;
//循环调用InstantiationAwareBeanPostProcessors 的postProcessAfterInstantiation方法if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) {  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  continueWithPropertyPopulation = false;  break;  } } }}
if (!continueWithPropertyPopulation) { return;}//解析autowire注解字段，进行主动注入if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
 // Add property values based on autowire by name if applicable. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); }
 // Add property values based on autowire by type if applicable. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); }
 pvs = newPvs;}boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);//循环调用InstantiationAwareBeanPostProcessors 的postProcessPropertyValues方法if (hasInstAwareBpps || needsDepCheck) { PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) {  if (bp instanceof InstantiationAwareBeanPostProcessor) {  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  if (pvs == null) {   return;  }  } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); }}//在这里为属性赋值，会进行类型转换，这里注意关键词deep copy//如果是引用类型且bean没有存在，则会进行bean的创建过程applyPropertyValues(beanName, mbd, bw, pvs);}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)
{ 
if (System.getSecurityManager() != null) 
{ 
AccessController.doPrivileged(new PrivilegedAction<Object>() 
{ 
@Override  public Object run() 
{  
invokeAwareMethods(beanName, bean);  
return null; 
} 
}, getAccessControlContext()); } else { //调用意识/通知方法 invokeAwareMethods(beanName, bean); 
}
 Object wrappedBean = bean; 
 if (mbd == null || !mbd.isSynthetic())
 { //调用bean后置处理器的前置方法 
 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 
 } //调用初始化方法 
 try { 
 invokeInitMethods(beanName, wrappedBean, mbd); 
 } catch (Throwable ex) 
 { 
 throw new BeanCreationException(  
 (mbd != null ? mbd.getResourceDescription() : null),  
 beanName, "Invocation of init method failed", ex); 
 }

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) 
throws Throwable {
 boolean isInitializingBean = (bean instanceof InitializingBean); 
 if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) 
 { 
 if (logger.isDebugEnabled()) 
 {  
 logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); 
 } 
 //调用InitializingBean.afterPropertiesSet 
 if (System.getSecurityManager() != null)
 {  
 try {  
 AccessController.doPrivileged(new PrivilegedExceptionAction<Object>()
 {  
 @Override   public Object run() throws Exception 
 {   
 ((InitializingBean) bean).afterPropertiesSet();   
 return null;  
 }  }, getAccessControlContext()); 
 }  
 catch (PrivilegedActionException pae) 
 {  
 throw pae.getException(); 
 } } else {  ((InitializingBean) bean).afterPropertiesSet(); 
 } }//调用自定义初始化方法 if (mbd != null)
 { 
 String initMethodName = mbd.getInitMethodName(); 
 if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&  
 !mbd.isExternallyManagedInitMethod(initMethodName))
 {  
 invokeCustomInitMethod(beanName, bean, mbd); 
 } 
 }}

@Overridepublic void afterPropertiesSet() throws Exception
{ 
notNull(dataSource, "Property 'dataSource' is required"); //sqlSessionFactoryBuilder在populateBean的applyPropertyValues过程中已经存在！ 
notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required"); 
state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),  
"Property 'configuration' and 'configLocation' can not specified with together");
 this.sqlSessionFactory = buildSqlSessionFactory();
 }

protected SqlSessionFactory buildSqlSessionFactory() throws Exception
{ 
Configuration configuration; // TODO 加载自定义 MybatisXmlConfigBuilder 
MybatisXMLConfigBuilder xmlConfigBuilder = null; 
if (this.configuration != null) 
{  
configuration = this.configuration;  
if (configuration.getVariables() == null) 
{  
 configuration.setVariables(this.configurationProperties);  
 } else if (this.configurationProperties != null)
 {  
 configuration.getVariables().putAll(this.configurationProperties);  
 } 
 } else if (this.configLocation != null) { //通常如果配置了configLocation会从这里创建MybatisXMLConfigBuilder， //其构造方法又创建了MybatisConfiguration 
 xmlConfigBuilder = new MybatisXMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);  
 configuration = xmlConfigBuilder.getConfiguration(); } else {  
 if (LOGGER.isDebugEnabled()) {   
 LOGGER.debug("Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");  
 }  
 // TODO 使用自定义配置  
 configuration = new MybatisConfiguration();  
 if (this.configurationProperties != null)
 {  
 configuration.setVariables(this.configurationProperties);  
 } }
 if (this.objectFactory != null)
 {  
 configuration.setObjectFactory(this.objectFactory); 
 }
 if (this.objectWrapperFactory != null)
 {  
 configuration.setObjectWrapperFactory(this.objectWrapperFactory); 
 }
 if (this.vfs != null) {  configuration.setVfsImpl(this.vfs); 
 }
 if (hasLength(this.typeAliasesPackage))
 {  
 // TODO 支持自定义通配符 
 String[] typeAliasPackageArray; 
 if (typeAliasesPackage.contains("*") && !typeAliasesPackage.contains(",")   
 && !typeAliasesPackage.contains(";")) 
 {   
 typeAliasPackageArray = PackageHelper.convertTypeAliasesPackage(typeAliasesPackage);  
 } else {   typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,  
  ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);  
  }  
  if (typeAliasPackageArray == null) {   
  throw new MybatisPlusException("not find typeAliasesPackage:" + typeAliasesPackage);  
  }  for (String packageToScan : typeAliasPackageArray) 
  {   
  configuration.getTypeAliasRegistry().registerAliases(packageToScan,   
  typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);   
  if (LOGGER.isDebugEnabled())
  {    
  LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");  
  }  
  } 
  }

 // TODO 自定义枚举类扫描处理 
 if (hasLength(this.typeEnumsPackage))
 {  
 Set<Class> classes = null;  
 if (typeEnumsPackage.contains("*") && !typeEnumsPackage.contains(",")  
 && !typeEnumsPackage.contains(";")) 
 {  
 classes = PackageHelper.scanTypePackage(typeEnumsPackage);  
 } else {   String[] typeEnumsPackageArray = tokenizeToStringArray(this.typeEnumsPackage,   
 ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);   
 if (typeEnumsPackageArray == null) 
 {   
 throw new MybatisPlusException("not find typeEnumsPackage:" + typeEnumsPackage);   
 }  
 classes = new HashSet<Class>();   
 for (String typePackage : typeEnumsPackageArray)
 {    
 classes.addAll(PackageHelper.scanTypePackage(typePackage));  
 }  
 }  // 取得类型转换注册器  
 TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();  
 for (Class cls : classes) {   if (cls.isEnum()) {    if (IEnum.class.isAssignableFrom(cls)) {   
 typeHandlerRegistry.register(cls.getName(), com.baomidou.mybatisplus.handlers.EnumTypeHandler.class.getCanonicalName());    } else {     
 // 使用原生 EnumOrdinalTypeHandler     typeHandlerRegistry.register(cls.getName(), org.apache.ibatis.type.EnumOrdinalTypeHandler.class.getCanonicalName());   
 }  
 }  } }
 if (!isEmpty(this.typeAliases)) { 

 for (Class<?> typeAlias : this.typeAliases) 
 {   
 configuration.getTypeAliasRegistry().registerAlias(typeAlias);   
 if (LOGGER.isDebugEnabled())
 {  
 LOGGER.debug("Registered type alias: '" + typeAlias + "'");  
 }  
 } }
 if (!isEmpty(this.plugins)) 
 {  
 for (Interceptor plugin : this.plugins)
 {   
 configuration.addInterceptor(plugin);   
 if (LOGGER.isDebugEnabled()) 
 {    
 LOGGER.debug("Registered plugin: '" + plugin + "'");   
 }  
 } 
 }
 if (hasLength(this.typeHandlersPackage))
 {  
 String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,  
 ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);  
 for (String packageToScan : typeHandlersPackageArray)
{  
 configuration.getTypeHandlerRegistry().register(packageToScan);   
 if (LOGGER.isDebugEnabled()) {    
 LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");   
 }  
 } 
 }
 if (!isEmpty(this.typeHandlers))
 {  
 for (TypeHandler<?> typeHandler : this.typeHandlers)
 {  
 configuration.getTypeHandlerRegistry().register(typeHandler);  
 if (LOGGER.isDebugEnabled()) 
 {    
 LOGGER.debug("Registered type handler: '" + typeHandler + "'");   
 }  } }
 if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls  
 try {   configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));  
 } catch (SQLException e) {   
 throw new NestedIOException("Failed getting a databaseId", e); 
 } 
 }
 if (this.cache != null)
 {  
 configuration.addCache(this.cache); 
 }
 if (xmlConfigBuilder != null) 
 {  
 try 
 {   
 xmlConfigBuilder.parse();
   if (LOGGER.isDebugEnabled())
	 {   
	 LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");   
	 }  } catch (Exception ex) 
	 {   
	 throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);  
	 } finally {   
	 ErrorContext.instance().reset();  
	 }
	 }
 if (this.transactionFactory == null)
 {  this.transactionFactory = new SpringManagedTransactionFactory(); 
 }
 configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource)); 
 // 设置元数据相关 
 GlobalConfigUtils.setMetaData(dataSource, globalConfig); SqlSessionFactory sqlSessionFactory = this.sqlSessionFactoryBuilder.build(configuration); 
 // TODO SqlRunner 
 SqlRunner.FACTORY = sqlSessionFactory; // TODO 缓存 sqlSessionFactory globalConfig.setSqlSessionFactory(sqlSessionFactory); // TODO 设置全局参数属性 
 globalConfig.signGlobalConfig(sqlSessionFactory); 
 if (!isEmpty(this.mapperLocations)) {  
 if (globalConfig.isRefresh()) {   
 //TODO 设置自动刷新配置 减少配置   
 new MybatisMapperRefresh(this.mapperLocations, sqlSessionFactory, 2,    
 2, true);  }  
 for (Resource mapperLocation : this.mapperLocations)
 {  
 if (mapperLocation == null) {  
 continue;   
 }
   try {    
	 // TODO 这里也换了噢噢噢噢  
	 XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),     
	 configuration, mapperLocation.toString(), configuration.getSqlFragments());    
	 xmlMapperBuilder.parse();   
	 } catch (Exception e) {   
	 throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);   
 } finally {    
 ErrorContext.instance().reset();   
 }
   if (LOGGER.isDebugEnabled())
	 {    
	 LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");  
	 } 
	 } 
	 } 
	 else { 
	 if (LOGGER.isDebugEnabled())
	 {  
	 LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");  
	 } 
	 } 
	 return sqlSessionFactory;
	 }

List<Employee > emps = employeeMapper.selectPage(page, null);