前言
在spring中使用mybaits简直不要太简单，只需要几个配置，一个DAO接口和一个mapper.xml就可以完成一次数据库交互。但是简单背后往往是复杂的实现，现在我们来探讨一下里面的一点原理吧,对,在不考虑springboot自动配置的前提下。
spring和mybaits是如何集成的
spring是一个框架,mybaits也是一个框架,要想一个框架起作用,总得有一个调用入口的。springboot的入口我们应该很清楚，如下
@SpringBootApplication(scanBasePackages = "com.example.demo")
@MapperScan("com.example.demo.repository.dao")
public class StartApplication {
public static void main(String[] args) {
SpringApplication.run(StartApplication.class, args);
}
}
main方法里面调用了SpringApplication.run(StartApplication.class, args)，就开始了springboot一系列的初始化流程。而mybaits我们好像没有调用啊，那它是怎么初始化的。
@MapperScan("com.example.demo.repository.dao")
再细看一下，我们好像是用到了mybaits包里面的MapperScan注解。它里面是这样的
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
///省略
}
上面的注解关键在于@Import(MapperScannerRegistrar.class)，用了@Import，spring就可以将MapperScannerRegistrar注册成bean,还可以对实现了特殊接口的类做处理，再看看MapperScannerRegistrar是什么
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry){
//省略
}
void setResourceLoader(ResourceLoader resourceLoader)
{
//省略
}
//省略
}
MapperScannerRegistrar实现了ResourceLoaderAware接口,可以在实例化的时候得到资源加载器ResourceLoader。另外还实现了ImportBeanDefinitionRegistrar，可以得到BeanDefinitionRegistry，拥有注册BeanDefinition的能力。
再从spring的主流程来说，在spring容器初始化后，会调用容器的refresh方法，然后经过一系列的调用后，会执行MapperScannerRegistrar的registerBeanDefinitions方法，开始mybaits注册BeanDefinition之旅了。
void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry) {
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
//省略
List<String> basePackages = new ArrayList<>();
//省略
basePackages.addAll(
Arrays.stream(annoAttrs.getStringArray("basePackages"))
.filter(StringUtils::hasText)
.collect(Collectors.toList()));
//省略
scanner.registerFilters();
scanner.doScan(StringUtils.toStringArray(basePackages));
}
上面的代码主要是为了拿到我们定义的basePackages值,然后就执行scanner.doScan方法开始扫描符合条件的类，然后注册成BeanDefinition。注册完成后，mybaits还会对BeanDefinition列表执行processBeanDefinitions方法
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
for (BeanDefinitionHolder holder : beanDefinitions) {
definition = (GenericBeanDefinition) holder.getBeanDefinition();
//省略
definition.setBeanClass(this.mapperFactoryBeanClass);
//省略
definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
//省略
definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
explicitFactoryUsed = true;
}
//省略
}
}
从上面可以看到,mybaits在processBeanDefinitions里面将BeanClass设置为mapperFactoryBean,还会挂sqlSessionFactory和sqlSessionTemplate到属性中。这样之后，我们定义的DAO接口就静静地躺着容器中等待getBean了。
定义的DAO接口怎么变成实例
上面已经大概描述了DAO接口如何变成BeanDefinition,但是如果要拿到实例,还要经历一个getBean的过程,一般的BeanDefinition只需要通过反射就可以变成实例了。但是mybaits注册的BeanDefinition类型都改成mapperFactoryBean，如下
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
//省略
@Override
public T getObject() throws Exception {
return getSqlSession().getMapper(this.mapperInterface);
}
//省略
}
从上面看到MapperFactoryBean实现FactoryBean，这样的BeanDefinition不再通过反射拿到实例了,而是通过FactoryBean.getObject()获取。所以这个时候，DAO接口实例化的处理由Spring交给Mybaits的getMapper负责了。getMapper处理如下
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
//mapperProxyFactory
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
在上面代码中,mybaits为接口生成了代理。而我们需要关注的是生成了什么代理，MapperProxy的代码如下
public class MapperProxy<T> implements InvocationHandler, Serializable {
//省略
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
}
MapperProxy代理的都是接口，所以invoke执行实际上就是MapperMethod的execute执行,如下
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
上面的代码简单来说就是,mybaits会根据mapper.xml中定义的标签,做不同的处理，然后将结果返回。
小结
本文简单描述一个DAO接口如何在spring和mybaits中一步步变成一个可以调用的实例。其中ImportBeanDefinitionRegistrar和FactoryBean是关键点，mybaits靠这两个关键类集成到spring中。如果我们要做一个类似框架集成到spring，也可以学习一下这种方式。