Spring源码剖析(三) [新]Mybatis-Spring最全最详细的调用和执行过程解析

最新推荐文章于 2023-05-23 21:50:33 发布
最新推荐文章于 2023-05-23 21:50:33 发布
阅读量5k 收藏
点赞数
分类专栏： SpringBoot 文章标签： mysql spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37419449/article/details/109273961
版权

前言: 本文将重点讲解Mybatis-spring的执行过程，对比mybatis和Mybatis-spring的流程差异，以及Mybatis-spring一级缓存失效的原因（文章方法15），和spring自动注入的原理和哪些属性不会自动装配的讲解。

解析mybatis-spring源码

文章目录

启动流程

  1. Mybatis配置类中的MapperScan

    @Configuration
@EnableTransactionManagement
@MapperScan(basePackages = DataSourceConfiguration.PACKAGE, sqlSessionFactoryRef = DataSourceConfiguration.SQL_SESSION_FACTORY)
public class DataSourceConfiguration {}

  2. MapperScan中加了@Import注解

    @Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({MapperScannerRegistrar.class})
@Repeatable(MapperScans.class)
public @interface MapperScan{}

  3. MapperScannerRegistrar类解析

    1. 在扫描到数据源配置类（如DataSourceConfiguration）时，扫描其@import注入的类，mybatis注入了一个MapperScannerConfigurer类，他是继承了BeanDefinitionRegistryPostProcessor接口的类。

    2. 注册完这个类后，spring再次扫描ImportBeanDefinitionRegistrar这个的时候，会执行MapperScannerConfigurer的postProcessBeanDefinitionRegistry方法。

    3. MapperScannerRegistrar在构造MapperScannerConfigurer的bd时，将解析@MapperScan的参数，例如basePackages = DataSourceConfiguration.PACKAGE, sqlSessionFactoryRef = DataSourceConfiguration.SQL_SESSION_FACTORY等，将其设置到MapperScannerConfigurer的bd中

    public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
     void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {
    // 生成MapperScannerConfigurer类的bd
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);
    // bd设置 解析加@MapperScan 填入的数据
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }

    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      builder.addPropertyValue("markerInterface", markerInterface);
    }

    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
    }

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }

    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }

    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
    }

    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
        .collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
        .collect(Collectors.toList()));

    if (basePackages.isEmpty()) {
      basePackages.add(getDefaultBasePackage(annoMeta));
    }

    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    String defaultScope = annoAttrs.getString("defaultScope");
    if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
      builder.addPropertyValue("defaultScope", defaultScope);
    }
    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
    // 注册的名字是importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;
    // 加@MapperScan类的配置类名#MapperScannerRegistrar#index
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
  }
}

  4. MapperScannerConfigurer.postProcessBeanDefinitionRegistry的执行

    明确一点 这是由上面 MapperScannerRegistrar注入的MapperScannerConfigurer。

    他被spring运行的时机是在invokeBeanFactoryPostProcessors处理BeanDefinitionRegistry的最后部分

    public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
 while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				// 这里去执行MapperScannerConfigurer.postProcessBeanDefinitionRegistry()
     		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}
}

    他创建了一个扫描器，去注册所有的XXXMapper接口到bd中，其中接口对应的实体类都是被代理出来的

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }
    // 创建一个解析器ClassPathMapperScanner
    // 数据由MapperScannerRegistrar创建MapperScannerConfigurer的bd时设置的
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    if (StringUtils.hasText(defaultScope)) {
      scanner.setDefaultScope(defaultScope);
    }
    scanner.registerFilters();
    // 扫描所有的XXXMapper接口（此处传入的是XXXMapper的包名字符串）
    // 函数解析5
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

  5. 扫描类父类的ClassPathBeanDefinitionScanner.doScan()

    public int scan(String... basePackages) {
    // 记录扫描前注册bd的数量
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
    // 扫描（传入的是XXXMapper的包名数组）
    // 调用的是子类ClassPathMapperScanner.doScan
        this.doScan(basePackages);
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }
    // 返回扫描注册bd的数量
        return this.registry.getBeanDefinitionCount() - beanCountAtScanStart;
    }

  6. 调用扫描类ClassPathMapperScanner.doScan()

    调用父类（方法7）去注册那几个XXXMapper的接口bd，并将bd返回，为了设置这几个bd对应的代理对象

    public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    // 这里返回的是函数7注册进spring的XXXXMapper(就那几个接口)的bd的Set集合
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

    if (beanDefinitions.isEmpty()) {
      LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
          + "' package. Please check your configuration.");
    } else {
        // 重点在这里，是处理这几个接口bd的实体代理对象
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

  7. 再次进入父类的ClassPathBeanDefinitionScanner.doScan()

    这里面就是扫描包下的类加入registry 并返回bd

    扫描的就是那几个XXXMapper接口；

    在这里他先将bd注册后，还用set保存起来，为了后面设置这几个接口bd的实体对象（代理对象）

    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet();
        String[] var3 = basePackages;
        int var4 = basePackages.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String basePackage = var3[var5];
            Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
            Iterator var8 = candidates.iterator();

            while(var8.hasNext()) {
                BeanDefinition candidate = (BeanDefinition)var8.next();
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    this.postProcessBeanDefinition((AbstractBeanDefinition)candidate, beanName);
                }

                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition)candidate);
                }

                if (this.checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    // 注册bd 这里注册了XXXXMapper接口的bd
                    this.registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
    // 将注册的XXXXMapper接口的bd返回
        return beanDefinitions;
    }

  8. 扩展XXXMapper的bdClassPathMapperScanner.processBeanDefinitions()

    这里面就是要给接口设置实例化对象，这样在使用接口执行操作的时候才能操作实例化对象；

    由于在这里使用动态代理，无法拿到动态代理的对象，无法放入spring容器中，所以使用了FactoryBean对象去处理。

    这里使用的是MapperFactoryBean.class

    这里设置了MapperFactoryBean属性值的注入方式为AUTOWIRE_BY_TYPE

    这里扩展一下spring的自动装配，在AbstractBeanDefinition.class下有如下几个标志：

    1. int AUTOWIRE_NO = 0; 表示不自动注入，但标记@Autowire的会自动注入；
    2. int AUTOWIRE_BY_NAME = 1; 通过属性的名字的方式查找JavaBean依赖的对象调用set方法为其注入；那具体什么属性需要装配，见方法10的解析
    3. int AUTOWIRE_BY_TYPE = 2; 通过属性的类型的方式查找JavaBean依赖的对象调用set方法为其注入；
    4. int AUTOWIRE_CONSTRUCTOR = 3; 通过属性的构造方法装配，无需set方法；

    自动注入的标签区别

    1. @Resource 通过 byName 方式自动装配
    2. @Autowired 通过ByType 方式自动装配
    3. @Autowired 和@Qualifier 可以实现ByName的效果
      如果Spring中有2个类型相同的Bean在通过@Autowired会报错 我们可以通过@Qualifier 标签来进行区分

    为了通用性，构造方法应该是这个接口的class

    从而可以返回一个代理对象

    private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    AbstractBeanDefinition definition;
    BeanDefinitionRegistry registry = getRegistry();
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (AbstractBeanDefinition) holder.getBeanDefinition();
      boolean scopedProxy = false;
      // 这里是false不进入 bd都是XXXMapper
      if (ScopedProxyFactoryBean.class.getName().equals(definition.getBeanClassName())) {
        definition = (AbstractBeanDefinition) Optional
            .ofNullable(((RootBeanDefinition) definition).getDecoratedDefinition())
            .map(BeanDefinitionHolder::getBeanDefinition).orElseThrow(() -> new IllegalStateException(
                "The target bean definition of scoped proxy bean not found. Root bean definition[" + holder + "]"));
        scopedProxy = true;
      }
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
          + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      // 设置FactoryBean构造函数的参数
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      // setBeanClass MapperFactoryBean.class;
      definition.setBeanClass(this.mapperFactoryBeanClass);

      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        definition.getPropertyValues().add("sqlSessionFactory",
            new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }

      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
        if (explicitFactoryUsed) {
          LOGGER.warn(
              () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate",
            new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionTemplate != null) {
        if (explicitFactoryUsed) {
          LOGGER.warn(
              () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
        explicitFactoryUsed = true;
      }

      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
          // 在这里设置了FactoryBean属性值注入方式
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }

      definition.setLazyInit(lazyInitialization);

      if (scopedProxy) {
        continue;
      }

      if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
        definition.setScope(defaultScope);
      }

      if (!definition.isSingleton()) {
        BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);
        if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {
          registry.removeBeanDefinition(proxyHolder.getBeanName());
        }
        registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());
      }
    }
  }

  9. MapperFactoryBean.class

    用于生成XXXMapper.class 的代理对象，具体看方法11

    这里面继承了SqlSessionDaoSupport这个对象不一般，具体看方法10的解析

    public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
     
      // 传入的接口XXXMapper.class
     private Class<T> mapperInterface;
   
     private boolean addToConfig = true;
   
     public MapperFactoryBean() {
       // intentionally empty
     }
       // 构造函数 传入的接口XXXMapper.class
     public MapperFactoryBean(Class<T> mapperInterface) {
       this.mapperInterface = mapperInterface;
     }
       // 返回代理对象 这个 代理对象见*方法11*
     @Override
     public T getObject() throws Exception {
       return getSqlSession().getMapper(this.mapperInterface);
     }
   
     // 返回生成对象的类型 也就是传入的接口XXXMapper.class
     @Override
     public Class<T> getObjectType() {
       return this.mapperInterface;
     }
  // 在实例化的时候会调用
     @Override
     protected void checkDaoConfig() {
       super.checkDaoConfig();
   
       notNull(this.mapperInterface, "Property 'mapperInterface' is required");
       Configuration configuration = getSqlSession().getConfiguration();
       if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
         try {
             //  String mappedStatementId = this.type.getName() + "." + method.getName();
             // 这里 configuration会将接口中的sql语句解析封装成MappedStatement, 其中id就是包名+方法名
           configuration.addMapper(this.mapperInterface);
         } catch (Exception e) {
           logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
           throw new IllegalArgumentException(e);
         } finally {
           ErrorContext.instance().reset();
         }
       }
     }
   
   }

  10. 父类 SqlSessionDaoSupport.class和DaoSupport.class

    DaoSupport在创建bean的过程中会调用SqlSessionDaoSupport的checkDaoConfig方法

    而MapperFactoryBean中又重写了checkDaoConfig方法，所以在实例化MapperFactoryBean的时候会调用MapperFactoryBean.checkDaoConfig()，当中就是解析sql语句封装MappedStatement对象。

    public abstract class SqlSessionDaoSupport extends DaoSupport {
   @Override
  protected void checkDaoConfig() {
    notNull(this.sqlSessionTemplate, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");
  }
   
  // 见set方法
  public SqlSession getSqlSession() {
    return this.sqlSessionTemplate;
  }
    
  // 这里sqlSessionTemplate的值是在初始化bean的时候赋值的
  // this.sqlSessionTemplate.getSqlSessionFactory()就是调用方法11里的sqlSessionFactory
  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    if (this.sqlSessionTemplate == null || sqlSessionFactory != this.sqlSessionTemplate.getSqlSessionFactory()) {
      this.sqlSessionTemplate = createSqlSessionTemplate(sqlSessionFactory);
    }
  }
}

// DaoSupport.class
public abstract class DaoSupport implements InitializingBean {
    protected final Log logger = LogFactory.getLog(this.getClass());

    public DaoSupport() {
    }
    
    // Spring实例化Bean后会执行afterPropertiesSet
    // 由于是抽象方法这里都将调用子类的实现
    public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {
        this.checkDaoConfig();

        try {
        this.initDao();
        } catch (Exception var2) {
            throw new BeanInitializationException("Initialization of DAO failed", var2);
        }
    }

    protected abstract void checkDaoConfig() throws IllegalArgumentException;

    protected void initDao() throws Exception {
    }
}

  11. 调用SqlSessionTemplate.class中的getMapper()->Configuration.getMapper()

    1. 这个类中的sqlSessionFactory，在mybatis配置类中通过SqlSessionFactoryBean.class创建了bean并注册进spring中。这里直接自动装配，返回的是DefaultSqlSessionFactory.class 他实现了SqlSessionFactory接口
    @Configuration
@EnableTransactionManagement
@MapperScan(basePackages = DataSourceConfiguration.PACKAGE, sqlSessionFactoryRef = DataSourceConfiguration.SQL_SESSION_FACTORY)
public class DataSourceConfiguration { 
    // ******
    
	@Bean(name = DataSourceConfiguration.SQL_SESSION_FACTORY)
    public SqlSessionFactory initSqlSessionFactory() throws Exception {
        // SqlSessionFactory是一个接口，实际返回是DefaultSqlSessionFactory
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(initDataSource());

        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/mapper/*.xml"));
        sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasesPackage);
        return sqlSessionFactoryBean.getObject();
    }
}
    1. DefaultSqlSessionFactory.class中维护了一个属性Configuration，Configuration属性里面有jdbc的链接信息以及Map<String, MappedStatement> mappedStatements;这个map就是装着sql语句和id。
    2. getMapper()实际调用的是Configuration中的getMapper()
    3. SqlSessionTemplate的构造方法中定义了一个sqlSessionProxy对象代理了一个SqlSession对象，他是最终执行sql的地方，这里可参考后面的方法15
    public class SqlSessionTemplate implements SqlSession, DisposableBean {
    // 这个sqlSessionFactory实际上在你配置mybatis的配置类时 定义了@Bean返回的是sqlSessionFactory
    private final SqlSessionFactory sqlSessionFactory;
    // 构造方法
   public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
    notNull(executorType, "Property 'executorType' is required");

    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
       // 代理对象，真正的王者在这里
    this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class }, new SqlSessionInterceptor());
  }
    
    @Override
    public <T> T getMapper(Class<T> type) {
      return getConfiguration().getMapper(type, this);
    }
    @Override
  	public Configuration getConfiguration() {
    	return this.sqlSessionFactory.getConfiguration();
  	}
}

public class Configuration {
    // ......
    protected final MapperRegistry mapperRegistry;
    protected final Map<String, MappedStatement> mappedStatements;
    // 构造函数
    public Configuration{
        // ......
        this.mapperRegistry = new MapperRegistry(this);
    }
    // 这里调用的是mapperRegistry的getMapper
    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        return this.mapperRegistry.getMapper(type, sqlSession);
    }
}

  12. 调用MapperRegistry的getMapper()方法

    这里通过mapperProxyFactory创建了一个代理对象，由MapperProxy进行实际的操作

    public class MapperRegistry {
    private final Configuration config;
    private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap();

    public MapperRegistry(Configuration config) {
        this.config = config;
    }
    
    // 这个type就是那个XXXMapper的接口
    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
        if (mapperProxyFactory == null) {
            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        } else {
            try {
                return mapperProxyFactory.newInstance(sqlSession);
            } catch (Exception var5) {
                throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
            }
        }
    }
}

public class MapperProxyFactory<T> {
    private final Class<T> mapperInterface;
    private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap();

    public MapperProxyFactory(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    public Class<T> getMapperInterface() {
        return this.mapperInterface;
    }

    public Map<Method, MapperMethodInvoker> getMethodCache() {
        return this.methodCache;
    }

    // 创建代理对象并返回 代理对象的实现方法由mapperProxy实现
    protected T newInstance(MapperProxy<T> mapperProxy) {
        return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
    }

    public T newInstance(SqlSession sqlSession) {
        MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
        return this.newInstance(mapperProxy);
    }
}
执行过程

  1. MapperProxy的具体代理过程

    就是当我们调用XXXMapper接口的数据库操作方法时，他会创建一个MapperMethod对象，最终会调用MapperMethod中的execute方法。

    创建MapperMethod时传入了XXXMapper接口，调用方法，Configuration。具体

    class MapperMethod {
private final MapperMethod.SqlCommand command;
private final MapperMethod.MethodSignature method;

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
  this.command = new MapperMethod.SqlCommand(config, mapperInterface, method);
  this.method = new MapperMethod.MethodSignature(config, mapperInterface, method);
}
public Object execute(SqlSession sqlSession, Object[] args){
  //....
}
}

    public class MapperProxy<T> implements InvocationHandler, Serializable {
    private static final long serialVersionUID = -4724728412955527868L;
    private static final int ALLOWED_MODES = 15;
    private static final Constructor<Lookup> lookupConstructor;
    private static final Method privateLookupInMethod;
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    private final Map<Method, MapperProxy.MapperMethodInvoker> methodCache;

    public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperProxy.MapperMethodInvoker> methodCache) {
        this.sqlSession = sqlSession;
        this.mapperInterface = mapperInterface;
        this.methodCache = methodCache;
    }
    //proxy是我们之前的sqlSessionTemplate
    //这里执行的是 this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);
        } catch (Throwable var5) {
            throw ExceptionUtil.unwrapThrowable(var5);
        }
    }
    // 执行这里
    // new MapperProxy.PlainMethodInvoker(new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration()));
    private MapperProxy.MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
        try {
            MapperProxy.MapperMethodInvoker invoker = (MapperProxy.MapperMethodInvoker)this.methodCache.get(method);
            return invoker != null ? invoker : (MapperProxy.MapperMethodInvoker)this.methodCache.computeIfAbsent(method, (m) -> {
                if (m.isDefault()) {
                    try {
                        return privateLookupInMethod == null ? new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava8(method)) : new MapperProxy.DefaultMethodInvoker(this.getMethodHandleJava9(method));
                    } catch (InstantiationException | InvocationTargetException | NoSuchMethodException | IllegalAccessException var4) {
                        throw new RuntimeException(var4);
                    }
                } else {
                    // 执行这里 创建了一个MapperMethod对象
                    return new MapperProxy.PlainMethodInvoker(new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration()));
                }
            });
        } catch (RuntimeException var4) {
            Throwable cause = var4.getCause();
            throw (Throwable)(cause == null ? var4 : cause);
        }
    }
    
    // 内部子类
    private static class PlainMethodInvoker implements MapperProxy.MapperMethodInvoker {
        private final MapperMethod mapperMethod;

        public PlainMethodInvoker(MapperMethod mapperMethod) {
            this.mapperMethod = mapperMethod;
        }
        // 具体调用的是这里 调用MapperMethod的execute方法
        public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
            return this.mapperMethod.execute(sqlSession, args);
        }
    }
    
}

  2. MapperMethod的execute()方法

    这里面我们挑一个executeForMany(), 他们最终都是调用sqlSession对象的方法，也就是前面的SqlSessionTemplate对象中的方法

     public Object execute(SqlSession sqlSession, Object[] args) {
           Object result;
           Object param;
           switch(this.command.getType()) {
           case INSERT:
               param = this.method.convertArgsToSqlCommandParam(args);
               result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
               break;
           case UPDATE:
               param = this.method.convertArgsToSqlCommandParam(args);
               result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
               break;
           case DELETE:
               param = this.method.convertArgsToSqlCommandParam(args);
               result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
               break;
           case SELECT:
               if (this.method.returnsVoid() && this.method.hasResultHandler()) {
                   this.executeWithResultHandler(sqlSession, args);
                   result = null;
               } else if (this.method.returnsMany()) {
                   result = this.executeForMany(sqlSession, args);
               } else if (this.method.returnsMap()) {
                   result = this.executeForMap(sqlSession, args);
               } else if (this.method.returnsCursor()) {
                   result = this.executeForCursor(sqlSession, args);
               } else {
                   param = this.method.convertArgsToSqlCommandParam(args);
                   result = sqlSession.selectOne(this.command.getName(), param);
                   if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {
                       result = Optional.ofNullable(result);
                   }
               }
               break;
           case FLUSH:
               result = sqlSession.flushStatements();
               break;
           default:
               throw new BindingException("Unknown execution method for: " + this.command.getName());
           }
   
           if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
               throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
           } else {
               return result;
           }
       }
   
   // 这里看execute调用的最终执行方法
   // 这里调用的是sqlSession的方法
   	private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
           Object param = this.method.convertArgsToSqlCommandParam(args);
           List result;
           if (this.method.hasRowBounds()) {
               RowBounds rowBounds = this.method.extractRowBounds(args);
               result = sqlSession.selectList(this.command.getName(), param, rowBounds);
           } else {
               result = sqlSession.selectList(this.command.getName(), param);
           }
   
           if (!this.method.getReturnType().isAssignableFrom(result.getClass())) {
               return this.method.getReturnType().isArray() ? this.convertToArray(result) : this.convertToDeclaredCollection(sqlSession.getConfiguration(), result);
           } else {
               return result;
           }
       }

  3. 转到SqlSessionTemplate.selectList()方法

    SqlSessionTemplate中定义sqlSessionProxy代理对象，调用sqlSessionProxy的方法去执行DefaultSqlSession的方法，最后关闭了sqlSession导致了MyBatis的一级缓存失效，因为这里不关闭session，spring没有其他地方关闭了。

    mybatis的执行sql是调用DefaultSqlSession去执行的，而spring是通过代理对象再去执行DefaultSqlSession

     public class SqlSessionTemplate implements SqlSession, DisposableBean {
       // 这个sqlSessionFactory实际上在你配置mybatis的配置类时 定义了@Bean返回的是sqlSessionFactory
       private final SqlSessionFactory sqlSessionFactory;
       // 构造方法
      public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
         PersistenceExceptionTranslator exceptionTranslator) {
   
       notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
       notNull(executorType, "Property 'executorType' is required");
   
       this.sqlSessionFactory = sqlSessionFactory;
       this.executorType = executorType;
       this.exceptionTranslator = exceptionTranslator;
          // 代理对象，真正的调用在这里
       this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
           new Class[] { SqlSession.class }, new SqlSessionInterceptor());
      } 
       
    	@Override
    	public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
     	  return this.sqlSessionProxy.selectList(statement, parameter, rowBounds);
    	}
       
       // 子对象 他是执行sql的最终的地方
       private class SqlSessionInterceptor implements InvocationHandler {
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // 这里的sqlsession应该就是DefaultSqlSession对象
         SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
             SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
         try {
           Object result = method.invoke(sqlSession, args);
           if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
             // force commit even on non-dirty sessions because some databases require
             // a commit/rollback before calling close()
             sqlSession.commit(true);
           }
           return result;
         } catch (Throwable t) {
           Throwable unwrapped = unwrapThrowable(t);
           if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
             // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
             closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
             sqlSession = null;
             Throwable translated = SqlSessionTemplate.this.exceptionTranslator
                 .translateExceptionIfPossible((PersistenceException) unwrapped);
             if (translated != null) {
               unwrapped = translated;
             }
           }
           throw unwrapped;
         } finally {
           if (sqlSession != null) {
               // 结束时关闭了sqlsession，所以导致spring中mybatis的一级缓存失效
             closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
           }
         }
       }
     }
   
   }
对象的自动装配

在上述mybatis的分析中，实际上很多类的属性未加@Autowire都会自动注入对象的，那么到底那些属性会被自动注入呢？

  1. spring会自动扫描属性，把getXXX(),setXXX(),isXXXX()都会当作属性。（Kotlin 是用的isXXX()）

  2. 如果属性值没有set方法或者手动设置不注入或者是简单类型则则不注入

    简单类型：枚举，字符，数字，日期，URI/URL，class等类型；都不会装配

    public static boolean isSimpleValueType(Class<?> type) {
        return Void.class != type && Void.TYPE != type && (ClassUtils.isPrimitiveOrWrapper(type) || Enum.class.isAssignableFrom(type) || CharSequence.class.isAssignableFrom(type) || Number.class.isAssignableFrom(type) || Date.class.isAssignableFrom(type) || Temporal.class.isAssignableFrom(type) || URI.class == type || URL.class == type || Locale.class == type || Class.class == type);
    }

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    
    protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
        Set<String> result = new TreeSet(); // 需要装配的属性集合
        PropertyValues pvs = mbd.getPropertyValues();
        // 这里可以获取到所有的属性
        PropertyDescriptor[] pds = bw.getPropertyDescriptors();
        PropertyDescriptor[] var6 = pds;
        int var7 = pds.length;

        for(int var8 = 0; var8 < var7; ++var8) {
            PropertyDescriptor pd = var6[var8];//属性描述器
            // 进行自动装配的判断
            // pd.getWriteMethod()是判断有没有set方法
            if (pd.getWriteMethod() != null && !this.isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) && !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
                result.add(pd.getName());
            }
        }

        return StringUtils.toStringArray(result);
    }
}
BugGuys
关注
专栏目录
mybatis-spring 框架原理与源码解析--执行流程
yange1025的博客
10-23 441
上一篇文章https://blog.csdn.net/yange1025/article/details/84709273介绍了如何在Spring项目中配置mybatis以及mybatis的启动过程。本篇文章将从用户发起一笔查询到返回查询结果来介绍mybatis的执行流程。 入口从用户从Spring容器获取Mapper接口对应的bean，并调用接口方法执行查询开始。我们知道从Spring容器获取...
从源码的角度解读Spring中 Mybatis 的执行流程
江城宴的博客
07-16 608
在 spring 项目中不仅要学习 mybatis 还要学习 mybatis 是如何与 spring 完美结合的，这就要归功于 mybatis-spring.jar。今天不仅要学习 mybatis 还要学 如何与 spring 完美结合。 首先回顾一下 mybatis 的执行流程： //mybatis的配置文件 String resource = "hong/helloWorld/Co...
mybatis在spring中的执行流程
kznsbs的博客
06-22 358
mybatis
mybatis-spring sql执行过程分析
weixin_33851604的博客
12-08 114
1.参考官方中文文档：http://www.mybatis.org/spring/zh/factorybean.html 2.核心是sqlsessionfactorybean。 它是实现了factorybean接口，最终创建的bean类型由getbobject返回的结果。 且是单例的，通过实现接口 isSingleton()判断 转载于:https://juejin.im/post/5a29f1...
SpringMVC| Mybatis执行流程
S.H.I.T
07-10 257
MVC执行流程 第一步：发起请求到前端控制器(DispatcherServlet) 第二步：前端控制器请求HandlerMapping查找 Handler （可以根据xml配置、注解进行查找） 第三步：处理器映射器HandlerMapping向前端控制器返回Handler，HandlerMapping会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控...
mybatis_spring.rar_Mybatis-spring_mybatis spring jar_mybatis-3.
09-24
Mybatis-Spring是一个连接Mybatis和Spring框架的库，它使得在Spring应用中使用Mybatis变得更加方便和无缝。这个压缩包“mybatis_spring.rar”包含了一个Mybatis与Spring整合的示例源码，这对于理解这两者之间的集成...
spring-boot-starter-mybatis-spring-boot-1.0.2.zip
最新发布
04-19
本文将详细介绍如何在Spring Boot项目中集成MyBatis，并对"spring-boot-starter-mybatis-spring-boot-1.0.2.zip"这个压缩包中的内容进行解析。 1. Spring Boot Starter MyBatis Spring Boot Starter MyBatis是...
mybatis-spring-1.3.3.jar官方下载
12-15
MyBatis-Spring 是一个将 MyBatis ORM 框架与 Spring 框架集成的库，使得在 Spring 应用中使用 MyBatis 变得更加方便。mybatis-spring-1.3.3.jar 文件是这个集成库的一个版本，提供了对 MyBatis 1.3.3 和 Spring 的...
mybatis-spring-1.3.0.jar 下载
11-14
《深入解析mybatis-spring-1.3.0.jar：集成与应用》 在Java开发领域，MyBatis和Spring框架的结合使用是常见的实践，它们的整合使得数据访问层的构建更为便捷和灵活。本篇文章将围绕"mybatis-spring-1.3.0.jar"这一...
MyBatis整合Spring中间件jar包 mybatis-spring-1.3.0.jar
12-04
MyBatis-Spring是MyBatis与Spring框架的整合组件，其主要目的是简化在Spring应用中集成MyBatis的过程，使两者能够无缝协作。mybatis-spring-1.3.0.jar是这个中间件的特定版本，包含了实现这种集成所需的所有类和资源...
【Spring】总结Spring整合Mybatis的底层原理实现步骤
12-21
（鲁班学院公开课笔记） Dao：数据访问层，提供让Service层调用的接口，更大的时候，Dao层可以是一个项目。 sqlSession.getMapper();使用的是JDK的动态代理 使用时 自定注入的条件：要被Spring管理。被Spring管理的对象叫做Bean @Component注解：表示将生成一个Bean 对象和Bean的区别： 1、Bean就是一个Java对象，是Spring帮我们New出来的对象。 2、从Spring容器中拿到的对象，会给对象里面的包含@AutoWired注解的属性进行自动注入赋值。而手动new出来的对象不会自动注入赋值。 Spring容器中的Bean
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解
11-26
Spring+SpringMVC+Mybatis SSM三大框架的运行流程、原理、核心技术详解 理解很透彻， 入门五星推荐
Mybatis-Spring:从源码上简单查看启动执行全过程
weixin_42245133的博客
03-17 223
相关依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.4</version> </dependency> 通过MATA-INF目录下的这两个文件进行自动装配。 这两个文件如何自动装配，不是本
mybatis整合spring启动和执行流程
qq_38967207的博客
06-19 358
mybatis
【三】MyBatis-Spring最全源码详解之SQL执行流程
人工智障训练师的博客
03-16 944
前面两篇系列文章已经详细介绍了Mapper接口的扫描过程和对应bean的创建过程。本文重点介绍mybatis执行SQL的过程。 DaoService的selectByName方法，拿到的personMapper对象已经是上文介绍的那个superMapperProxy对象。执行personMapper.selectByName(personName)方法，其实就是执行的superMapperPro...
【SSM学习】1、Spring、Spring MVC、Mybatis 执行流程
Tellsea
04-26 585
Spring 1、Spring Core核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 2、Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供...
MyBatis和Spring整合，流程浅析 - 20181208
weixin_30263277的博客
12-08 167
【面试题】我们在开发mybaits时候，有几种写sql语句的方式？ 一种是注解、一种是xml文件、还有一种是@Provider 注解形式：简单但是不是很灵活，对于动态条件查询是无法实现的，这时，我们可以使用xml的方式。 xml形式：有xml文件，且约束严格。 @Provider：结合上两种优点，注意：方法不能重载 【面试题】我们都知道myb...
MyBatis执行过程
守正出奇
03-21 958
MyBatis作为常用的ORM框架之一，了解MyBatis中sql执行过程是应用开发必备的技能。
Spring：Spring 整合 MyBatis 的具体过程
taiyang3285的博客
05-23 1472
介绍了 Spring 整合 MyBatis 的具体过程
Spring Boot集成Swagger和MyBatis-Plus项目API开发
1. Spring Boot：Spring Boot是一个开源的Java基础框架，旨在简化新Spring应用的初始搭建以及开发过程。它使用“约定优于配置”的原则，提供了一系列大型项目中常见的默认配置，使得开发者可以快速启动和运行Spring...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BugGuys

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值