MyBatis和Spring整合的奧秘-有解無憂

本篇博客原始碼分析基于Spring 5.1.16.RELEASE，mybatis-spring 2.0.0，較高版本的mybatis-spring原始碼有較大區別，

Spring之所以是目前Java最受歡迎的框架，幾乎所有的Java專案都在使用，就是因為它良好的生態，很多技術可以與之整合，為什么其他技術可以和Spring相整合，就是因為Spring擁有很多擴展點，閱讀Spring原始碼，有一部分原因就是有必要清楚的知道Spring提供了哪些擴展點，而怎么合理的利用這些擴展點，就需要了解其他技術是如何利用這些擴展點的，

今天我就來帶著大家看下，國內最流行的資料庫框架MyBatis是如何利用Spring的擴展點的，從而雙劍合璧，讓Spring+MyBatis成為國內最流行的技術搭配，

前置知識

為了后面的故事可以順利展開，很有必要先給大家介紹下，閱讀mybatis-spring原始碼的前置知識，沒有這些前置知識閱讀mybatis-spring原始碼是寸步難行，

mybatis-spring使用

因為現在有了SpringBoot，所以Mybatis和Spring的整合變得非常簡單，但是如果沒有SpringBoot，該怎么整合呢？我翻閱了百度的前幾頁，不知道是不是搜索關鍵詞問題，幾乎全是用XML的方式去整合Mybatis和Spring的，零XML配置，它不香嗎？

代碼結構：

具體實作：

 <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());
    }
}

運行結果：

[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，

如何使用

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

寫一個類實作ImportBeanDefinitionRegistrar ，重寫其中的registerBeanDefinitions方法，

@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整合后，一級快取為什么會失效，但是要想真正弄明白，不是幾句話可以說清楚的，還是以后再開一篇博客，單獨來討論這個問題吧，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/149316.html

標籤：Java

上一篇：maven無法下載oracle ojdbc 8的問題

下一篇：Oracle JDK 和 OpenJDK 有什么區別？