MyBatis和Spring整合的奧祕

時間 2020-07-08

原文原文鏈接

本篇博客源碼分析基於Spring 5.1.16.RELEASE，mybatis-spring 2.0.0，較高版本的mybatis-spring源碼有較大區別。java

Spring之因此是目前Java最受歡迎的框架，幾乎全部的Java項目都在使用，就是由於它良好的生態，不少技術能夠與之整合，爲何其餘技術能夠和Spring相整合，就是由於Spring擁有不少擴展點，閱讀Spring源碼，有一部分緣由就是有必要清楚的知道Spring提供了哪些擴展點，而怎麼合理的利用這些擴展點，就須要瞭解其餘技術是如何利用這些擴展點的。mysql

今天我就來帶着你們看下，國內最流行的數據庫框架MyBatis是如何利用Spring的擴展點的，從而雙劍合璧，讓Spring+MyBatis成爲國內最流行的技術搭配。spring

前置知識

爲了後面的故事能夠順利展開，頗有必要先給你們介紹下，閱讀mybatis-spring源碼的前置知識，沒有這些前置知識閱讀mybatis-spring源碼是步履維艱。sql

mybatis-spring使用

由於如今有了SpringBoot，因此Mybatis和Spring的整合變得很是簡單，可是若是沒有SpringBoot，該怎麼整合呢？我翻閱了百度的前幾頁，不知道是否是搜索關鍵詞問題，幾乎全是用XML的方式去整合Mybatis和Spring的，零XML配置，它不香嗎？數據庫

代碼結構： apache

具體實現：緩存

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
        <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.16.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.5</version>
        </dependency>
    </dependencies>
複製代碼

@MapperScan("com.codebear.mapper")
@ComponentScan
public class AppConfig {
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }
}
複製代碼

@Repository
public interface StudentMapper {
    @Select("select * from student")
    List<Student> getList();
}
複製代碼

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(applicationContext.getBean(StudentMapper.class).getList());
    }
}
複製代碼

運行結果：bash

[Student{id=1, name='疫苗王', age=20}, Student{id=2, name='阿修羅獨角仙', age=18}, Student{id=3, name='地底王', age=18}]
複製代碼

Import註解

若是咱們想把一個類註冊到Spring容器中，能夠採用的方法有不少，其中一種是利用Import註解，Import註解有三種用法，mybatis-spring利用的是其中一種用法，Import了ImportBeanDefinitionRegistrar類，因此咱們這裏只看Import ImportBeanDefinitionRegistrar。session

如何使用

public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        System.out.println(annotationMetadata.getAnnotationTypes());
    }
}
複製代碼

寫一個類實現ImportBeanDefinitionRegistrar ，重寫其中的registerBeanDefinitions方法。mybatis

@Import(MyBeanDefinitionRegistrar.class)
@ComponentScan
@MapperScan("com.codebear.mapper")
public class AppConfig {
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }
}
複製代碼

在配置上加上@Import註解，寫上剛纔寫的MyBeanDefinitionRegistrar類。

運行結果：

[org.springframework.context.annotation.Import, org.springframework.context.annotation.ComponentScan, org.mybatis.spring.annotation.MapperScan]
複製代碼

從registerBeanDefinitions兩個入參的命名來看，第一個參數，Spring把註解元數據給你了，而第二個參數，Spring是直接把beanDefinition的註冊器給你了。

追本溯源

下面咱們來看看Spring在何時處理@Import註解的，又是何時調用registerBeanDefinitions方法的，固然這裏不是Spring源碼分析，我不會詳細一行行翻譯，而是簡單的找到源頭。

//AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(Class<?>... componentClasses)
	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
	}
複製代碼

進入第三行的refresh()方法。

refresh方法作了不少事情，咱們只須要關心invokeBeanFactoryPostProcessors方法：

//AbstractApplicationContext#refresh
invokeBeanFactoryPostProcessors(beanFactory);
複製代碼

執行invokeBeanFactoryPostProcessors方法，顧名思義，這個方法是執行BeanFactoryPostProcessor的。什麼，你不知道什麼是BeanFactoryPostProcessor？你能夠簡單的理解爲Spring遵循插件化式的開發，其中有一個插件叫ConfigurationClassPostProcessor，實現了BeanDefinitionRegistryPostProcessor，同時BeanDefinitionRegistryPostProcessor又實現了BeanFactoryPostProcessor，經過ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry的方法，Spring完成了掃描。

//PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
複製代碼

這一步傳入了BeanDefinitionRegistryPostProcessor的集合，要執行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，集合有一個元素是咱們關心的，就是上面提到的ConfigurationClassPostProcessor。

//PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessBeanDefinitionRegistry(registry);
}
複製代碼

循環傳入的BeanDefinitionRegistryPostProcessor集合，調用postProcessBeanDefinitionRegistry方法，咱們直接進入到ConfigurationClassPostProcessor的processConfigBeanDefinitions方法，找到關鍵解析代碼：

//ConfigurationClassPostProcessor#processConfigBeanDefinitions
parser.parse(candidates);
複製代碼

//ConfigurationClassParser#parse
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
複製代碼

//ConfigurationClassParser#processConfigurationClass
doProcessConfigurationClass(configClass, sourceClass);
複製代碼

//ConfigurationClassParser#doProcessConfigurationClass
processImports(configClass, sourceClass, getImports(sourceClass), true);
複製代碼

重點來了，終於找到了咱們的目標：處理@Import註解。

//ConfigurationClassParser#processImports
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
複製代碼

//ConfigurationClass#addImportBeanDefinitionRegistrar
this.importBeanDefinitionRegistrars.put(registrar, importingClassMetadata);
複製代碼

這個importBeanDefinitionRegistrars就是一個Map：

//ConfigurationClass
private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars = new LinkedHashMap<>();
複製代碼

讓咱們就監視下configClass：

能夠看到咱們寫的MyBeanDefinitionRegistrar被放入了importBeanDefinitionRegistrars ，咱們須要記住這個集合，至於還有一個什麼，這裏不用關心，固然，聰明的小夥伴確定知道這是什麼了。

咱們寫的MyBeanDefinitionRegistrar只是被放入了一個Map，並無執行，下面咱們要找找它是在哪裏執行的。

咱們須要回到ConfigurationClassPostProcessor的processConfigBeanDefinitions方法：

//ConfigurationClassPostProcessor#processConfigBeanDefinitions
this.reader.loadBeanDefinitions(configClasses);
複製代碼

//ConfigurationClassBeanDefinitionReader#loadBeanDefinitions
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
複製代碼

//ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
複製代碼

這個集合是否是有點眼熟，就是我在上面讓你們記住的集合，這個集合就存放着咱們的寫的MyBeanDefinitionRegistrar類，讓咱們繼續點進去：

//ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsFromRegistrars
	private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
		registrars.forEach((registrar, metadata) ->
				registrar.registerBeanDefinitions(metadata, this.registry));
	}
複製代碼

循環傳入的ImportBeanDefinitionRegistrar集合，調用registerBeanDefinitions方法，個人天，終於找到執行方法了。

FactoryBean

Spring就像是一個魔術師的袋子，而FactoryBean就是被魔術師裝進袋子的香蕉，當魔術師打開袋子，發現香蕉變成鴿子了。

如何使用

@Component
public class MyFactoryBean implements FactoryBean<Teacher> {
    public Teacher getObject() {
        Teacher teacher = new Teacher();
        teacher.setName("琦玉老師");
        return teacher;
    }

    public Class<?> getObjectType() {
        return Teacher.class;
    }
}
複製代碼

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(applicationContext.getBean(MyFactoryBean.class));
        System.out.println(applicationContext.getBean(Teacher.class));

        System.out.println(applicationContext.getBean("&myFactoryBean"));
        System.out.println(applicationContext.getBean("myFactoryBean"));

        System.out.println(applicationContext.getBean("myFactoryBean").hashCode());
        System.out.println(applicationContext.getBean("myFactoryBean").hashCode());
    }
}
複製代碼

運行結果：

com.codebear.MyFactoryBean@4ee203eb
Teacher{name='琦玉老師'}
com.codebear.MyFactoryBean@4ee203eb
Teacher{name='琦玉老師'}
442125849
442125849
複製代碼

能夠很清楚的看到從FactoryBean裏面又生產出了一個Bean，生產出來的Bean就是FactoryBean中getObject方法返回的。

追本溯源

和上面同樣，咱們也要看看FactoryBean中的getObject是在哪裏執行的，咱們先來作個試驗：

咱們在getObject裏面加上一句打印的代碼：

@Component
public class MyFactoryBean implements FactoryBean<Teacher> {
    public Teacher getObject() {
        System.out.println("getObject");
        Teacher teacher = new Teacher();
        teacher.setName("琦玉老師");
        return teacher;
    }

    public Class<?> getObjectType() {
        return Teacher.class;
    }
}
複製代碼

而後只保留main方法中的建立ApplicationContext方法：

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    }
}
複製代碼

運行後，你會發現，控制檯沒有任何輸出，咱們大膽的猜測，FactoryBean生產出來的Bean並非預先加載的，而是採用懶加載的機制，也就是隻有須要，纔會去加載。

咱們繼續改下main方法：

public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(applicationContext.getBean(Teacher.class));
    }
複製代碼

運行結果：

getObject
Teacher{name='琦玉老師'}
複製代碼

因此咱們的猜測是正確的，此次入口是getBean。

下面仍是枯燥無味的尋找，此次的尋找之旅更復雜：

//org.springframework.beans.factory.support.DefaultListableBeanFactory#getBean(java.lang.Class<T>)
public <T> T getBean(Class<T> requiredType) throws BeansException {
		return getBean(requiredType, (Object[]) null);
}
複製代碼

// org.springframework.beans.factory.support.DefaultListableBeanFactory#getBean(java.lang.Class<T>, java.lang.Object...)
Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
複製代碼

//org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveBean
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
複製代碼

//org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveNamedBean(org.springframework.core.ResolvableType, java.lang.Object[], boolean)
String[] candidateNames = getBeanNamesForType(requiredType);
複製代碼

//org.springframework.beans.factory.support.DefaultListableBeanFactory#getBeanNamesForType(org.springframework.core.ResolvableType)
return getBeanNamesForType(resolved, true, true);
複製代碼

//org.springframework.beans.factory.support.DefaultListableBeanFactory#getBeanNamesForType(java.lang.Class<?>, boolean, boolean)
resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
複製代碼

這個方法裏面有一步是循環beanDefinitionNames，當循環到myFactoryBean的時候，判斷這是一個FactoryBean：

boolean isFactoryBean = isFactoryBean(beanName, mbd);
複製代碼

隨後執行isTypeMatch(beanName, type)方法：

//org.springframework.beans.factory.support.AbstractBeanFactory#isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
複製代碼

//org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getTypeForFactoryBean
return factoryBean.getObjectType();
複製代碼

當執行到這裏，咱們寫的MyFactoryBean的getObjectType方法被調用了，返回Teacher.class，而咱們如今要找的也是Teacher.class，因此匹配。

隨後回到DefaultListableBeanFactory#doGetBeanNamesForType，把beanName放入一個集合中：

if (matchFound) {
	result.add(beanName);
}
複製代碼

隨後返回集合。

再回到DefaultListableBeanFactory#resolveNamedBean，會判斷返回出來的集合的元素的個數，顯然只返回一個，執行

//org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveNamedBean
		if (candidateNames.length == 1) {
			String beanName = candidateNames[0];
			return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args));
		}
複製代碼

繼續點開getBean方法：

//org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>, java.lang.Object...)
return doGetBean(name, requiredType, args, false);
複製代碼

//org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
複製代碼

//org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
複製代碼

//org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getObjectFromFactoryBean
doGetObjectFromFactoryBean(factory, beanName);
複製代碼

//org.springframework.beans.factory.support.FactoryBeanRegistrySupport#doGetObjectFromFactoryBean
object = factory.getObject();
複製代碼

直到這裏，才執行了咱們寫的MyFactoryBean的getObject方法，拿到了咱們返回的Teacher對象後。

由於有緩存機制若是咱們再去拿，就不會再次調用getObject方法了，這個緩存機制就再也不繼續分析了，比較複雜，就算不了解也不影響咱們今天的主題。

JDK動態代理

我之前寫過JDK動態代理的博客，你們能夠找來看一看，這裏就不闡述了。

mybatis-spring源碼分析

前置知識介紹完成，有了上面的前置知識，咱們就能夠一探MyBatis和Spring整合的奧祕。

Mybatis和Spring整合的入口很好找，就是咱們再配置上添加的@MapperScan註解，當咱們點開@MapperScan：

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

你會發現一個很熟悉的註解，就是咱們上面講的Import註解，Import了MapperScannerRegistrar。

經過上面的源碼分析明白，Spring會執行到registerBeanDefinitions方法：

@Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   // 拿到咱們寫的MapperScan註解上帶的東西，咱們寫的，只有一個Value字段。
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      registerBeanDefinitions(mapperScanAttrs, registry);
    }
  }
複製代碼

繼續深刻registerBeanDefinitions方法：

// 建立了一個掃描器，這個掃描器繼承了Spring定義的掃描器：ClassPathBeanDefinitionScanner，
// 掃描的主要是主要做用就是掃描，把bean放到map中去
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
//省略
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value"))
            .filter(StringUtils::hasText)
            .collect(Collectors.toList()));
//省略
    scanner.registerFilters();
    scanner.doScan(StringUtils.toStringArray(basePackages));
複製代碼

這裏主要是建立了一個掃描器，傳入了一些規則。

scanner.registerFilters()中有一行代碼，比較重要：

// mybatis定義的掃描器最終的掃描任務是交給Spring的掃描器執行的，
// Spring的掃描器中定義了includeFilters，只有符合規則的最終才能夠被掃描出來，
// 這裏意味着mybatis告訴spring，任何東西你都要給我掃描出來。
  addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
複製代碼

讓咱們看下 scanner.doScan(StringUtils.toStringArray(basePackages))方法：

@Override
  public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //交給Spring執行掃描任務，返回beanDefinition、beanName的包裝對象，這裏就把咱們 
    //@MapperScan註解中給定的com.codebear.mapper包中全部的內容都掃描
    //而且返回出來了。
    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 {
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }
複製代碼

繼續看processBeanDefinitions方法：

// 省略
 for (BeanDefinitionHolder holder : beanDefinitions) {
  definition.setBeanClass(this.mapperFactoryBean.getClass());
}
//省略
複製代碼

這個循環中，有一行代碼非常重要，把掃描出來的bean的BeanClass都設置成了mapperFactoryBean，這個mapperFactoryBean是何方神聖呢？沒錯，它就是咱們上面分析過的FactoryBean，經過實驗和分析，咱們知道了最終產生的bean對象是FactoryBean中的getObject返回的對象。

public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }
複製代碼

public SqlSession getSqlSession() {
    return this.sqlSessionTemplate;
  }
複製代碼

//org.mybatis.spring.SqlSessionTemplate#getMapper
  public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
  }
複製代碼

//org.apache.ibatis.binding.MapperRegistry#getMapper
    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);
            }
        }
    }
複製代碼

//org.apache.ibatis.binding.MapperProxyFactory#newInstance(org.apache.ibatis.session.SqlSession)
//sqlSession是SqlSessionTemplate
    public T newInstance(SqlSession sqlSession) {
// 這裏須要用到JDK動態代理的知識，傳入了SqlSessionTemplate，Mapper類（接口）
        MapperProxy<T> mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
        return this.newInstance(mapperProxy);
    }
複製代碼

// 生成了代理對象
    protected T newInstance(MapperProxy<T> mapperProxy) {
        return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);
    }
複製代碼

最終咱們調用代理對象的方法，會執行到MapperProxy的invoke方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }
複製代碼

當咱們點開mapperMethod.execute方法，你會以爲一切是那麼的熟悉。

本篇的博客內容到這裏結束了，原本還想聊聊MyBatis和Spring整合後，一級緩存爲何會失效，可是要想真正弄明白，不是幾句話能夠說清楚的，仍是之後再開一篇博客，單獨來討論這個問題吧。