spring和mybatis整合为什么只定义了接口？为什么设置自动装配模型为BY_TYPE
背景
是不是还在疑惑为什么我们在工程中定义了接口mybatis就可以直接操作我们的数据库？
是不是想了解spring和mybaits整合的原理？
了解原理后我们能复用在工程上的东西是什么？换句话说怎么提高代码的逼格？
目的
基于上述背景,笔者准备深入源码带大家一探究竟，读完这篇文章大家可以的到的收获
- 了解Mybatis和Spring整合的底层原理
- 知道为什么只定义了接口就可以直接操作数据库
- 了解Spring中的拓展点和FactoryBean的使用
- 可以自己定义插件提高代码逼格
- Spring中自动装配的类型到底是什么
分析问题
准备
代码环境：
- JDK ：1.8
- Spring Boot ：2.3
- 基于注解
- 忽略一些不重要的细节 项目代码如下
//对象
public class AD {
//id
private int id;
//名称
private String name;
}
//mapper类
public interface AdMapper {
@Select("select id , name from " + " ad " + "where id=#{id} ")
AD findADById(@Param("id") int id);
}
//接口
public interface AdService {
/**
* 通过id获取广告对象
*
* @param id
* @return
*/
AD findADbyId(int id);
}
//接口实现类
@Service
public class AdServiceImpl implements AdService {
@Resource
private AdMapper adMapper;
@Override
public AD findADbyId(int id) {
return adMapper.findADById(id);
}
}
//启动类
@MapperScan("com.learn.code.mybatis.mapper")
@SpringBootApplication
public class LearnCodeApplication {
public static void main(String[] args) {
SpringApplication.run(LearnCodeApplication.class, args);
}
}
问题1 Mapper对象的BeanDefinition是怎么加入到工厂中的
问题由来：一个对象只有被Spring创建并且放入到工厂中才能被其他对象注入，比如AdServiceImpl就是加了@Service注解并且结合包扫描。这样环境中就会有这个对象，但是AdMapper没有加任何的注解，而我们的 AdServiceImpl却可以直接通过 @Resource注入进来。说明这个对象是被Spring创建的。
回想Spring创建Bean的过程，几乎所有的对象都是先变成BeanDefinition然后再通过工厂创建，所以我们只要找到这个Mapper类是什么时候变成BeanDefinition的。
我们通过看代码发现和Mybatis相关的只有开始在配置类中加入的注解@MapperScan，难道是这个注解起的作用吗？
没错，这个注解是个入口，就像是把钥匙，像只有我们带了钥匙才能开门一样，只有加了这个注解（注意本文基于注解配置）才能实现上述的功能
那现在我们重点看一下这个注解
@MapperScan
屏蔽掉一些非关键信息 注解结构如下：
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
String[] value() default {};
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
}
在这个注解类中发现其实也没有做太多事,但是我们会发现类上边有@Import(MapperScannerRegistrar.class)这行.对Spring启动源码有了解的同学可能知道，在准备工厂阶段，会把 @Import引入的类当作配置类，后期通过Spring创建这个bean。所以我们应该能感觉MapperScannerRegistrar这个类是有些作用的，照例点进去看一下源码。
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware
发现这个类继承了ImportBeanDefinitionRegistrar实现了这个接口，这个接口是Spring当中的一个扩展点，基于接口中的registerBeanDefinitions方法我们可以做到向bean工厂中注入BeanDefinition,现在看来我们的方向是对的。
下面解析一下 registerBeanDefinitions 方法
/**
* importingClassMetadata 注解元素
* registry 用来向 BeanDefinitionRegistry 加入 BeanDefinition
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//获取MapperScan注解中的属性信息 @MapperScan("com.learn.code.mybatis.mapper")
// 类上可能会有很多注解 这里指定名称获取
AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
//初始化一个 scanner 用作扫描指定包下的类
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
// Spring 3.1 版本需要有这个判断 特殊逻辑
if (resourceLoader != null) {
// 设置资源加载器，作用：扫描指定包下的class文件。
scanner.setResourceLoader(resourceLoader);
}
//===============下边是获取MapperScan中的属性值，赋值给scanner，以后会在doScan中使用============
Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
if (!Annotation.class.equals(annotationClass)) {
scanner.setAnnotationClass(annotationClass);
}
Class<?> markerInterface = annoAttrs.getClass("markerInterface");
if (!Class.class.equals(markerInterface)) {
scanner.setMarkerInterface(markerInterface);
}
Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
if (!BeanNameGenerator.class.equals(generatorClass)) {
scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
}
Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
}
scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
//获取要扫描的路径
List<String> basePackages = new ArrayList<String>();
for (String pkg : annoAttrs.getStringArray("value")) {
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
for (String pkg : annoAttrs.getStringArray("basePackages")) {
if (StringUtils.hasText(pkg)) {
basePackages.add(pkg);
}
}
for (Class<?> clazz : annoAttrs.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
scanner.registerFilters();
//执行扫描，并且会把 BD放入到工厂中，并更改BD中的一些属性值
scanner.doScan(StringUtils.toStringArray(basePackages));
}
scanner.doScan(StringUtils.toStringArray(basePackages))方法
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
// 1
// 调用父类的扫描方法 向容器中加入 BD 并返回 beanDefinitions
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 {
// 2
// 操作 BD 引用 修改其中的属性
processBeanDefinitions(beanDefinitions);
}
return beanDefinitions;
}
doScan方法首先做的是调用父类的扫描方法，根据指定的包的路径和一些其他的限制条件(比如只要接口不需要类)，来决定是否读取这个BD加入到工厂中。由于这个方法比较简单就不跟进去看了。
因为扫描是基于spring的扫描器。扫描过程中应该会有类加入进来，但是断点的时候会发现结果是只有接口。其中有个条件是子类可以重写的比如：
//只扫描接口
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
return beanDefinition.getMetadata().isInterface() && beanDefinition.getMetadata().isIndependent();
}
这样扫描出来的东西也不会和spring本身扫描的类重复
问题2 Mapper对象是个接口怎么进行实例化
通过上边的分析，我们已经解决了第一个问题，怎么把这些类的BD放入到工厂中的，但是这样就完了吗？我们现在BD里面的class类型是一个接口，这是没有办法被实例化的。所以我们需要解决对象实例化的问题。
其实解决对象实例化不外乎就是对接口进行动态代理，但是怎么进行？代理完成后是个代理对象又怎么通过@Resource注入进来。不妨来看一下Mybatis是怎么实现的。
入口位置即是上边代码块中我标注了2的位置。下边来看一下 2出的代码实现
processBeanDefinitions(beanDefinitions)
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
//对传进来的BD循环处理
for (BeanDefinitionHolder holder : beanDefinitions) {
definition = (GenericBeanDefinition) holder.getBeanDefinition();
if (logger.isDebugEnabled()) {
logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()
+ "' and '" + definition.getBeanClassName() + "' mapperInterface");
}
// the mapper interface is the original class of the bean
// but, the actual class of the bean is MapperFactoryBean
// 1 设置 mapperInterface 属性 也就是这个接口的原始类型 对那个接口进行代理
definition.getPropertyValues().add("mapperInterface", definition.getBeanClassName());
// 2 设置 BeanClass 实例化时候用到的类型 能被实例化就是改了这个 原来是实际的接口类型，现在是 mapperFactoryBean 类型 因为 mapperFactoryBean 不是抽象类也不是接口所以可以被初始化
// 通过spring的getBean方法创建对象就是创建的beanClass类型的对象
definition.setBeanClass(this.mapperFactoryBean.getClass());
//添加属性
definition.getPropertyValues().add("addToConfig", this.addToConfig);
boolean explicitFactoryUsed = false;
//设置 sqlSessionFactory
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;
}
//sqlSessionTemplate and sqlSessionFactor 都存在 会使用 sqlSessionTemplate
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) {
if (logger.isDebugEnabled()) {
logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
}
// 3 设置自动装配模型为 BY_TYPE 通过类型进行装配
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
}
}
}
这整个方法的作用实际是构造 mapperFactoryBean 类型 需要传入的参数
其中 需要重点关注的是我标记了1、2、3的部分
标注1的部分 设置代理的接口类型
在别的版本中是通过配置构造函数来做的如下，但是原理是一样的。
definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
需要注意的是通过这种形式加进去的是字符串类型，但是内部会帮我们转成class类型。所以我们去看这个类的的构造方法的时候会发现他是有一个class的构造方法而没有字符串的。
这部分的主要逻辑是 向 mapperFactoryBean 中传入我们要进行动态代理的接口，至于为什么稍后我会把 mapperFactoryBean 的源码贴出来 大家就明白了。
标注2的部分 设置实例化类的类型
开始我们再说的问题就是怎么创建对象的问题，因为BeanClass为接口类型，读过spring创建bean的源码的同学都知道，在getBean时就是创建的BeanClass类型的对象，所以我们需要修改这个类型 是个具体的类 。这个具体的类就是 MapperFactoryBean ，有些人可能会问，那创建的这个类型不是我们需要的类型啊？我们怎么使用？别急这些在我们说到 MapperFactoryBean 这个类的时候会做解释
标注3的部分 修改自动装配模型
自动装配你真的了解吗？
如果我们大家Spring中Bean的装配模型是什么？相信大部分人第一反应就是By_Type或者By_Name .为什么？因为我们通过@Resource等注解可以进行注入。这里我要给大家纠正一下概念。Spring中的装配模型为By_No,他只是依赖于自动装配的技术完成了自动装配。
看源码
org.springframework.beans.factory.support.AbstractBeanDefinition#setAutowireMode
/**
* Set the autowire mode. This determines whether any automagical detection
* and setting of bean references will happen. Default is AUTOWIRE_NO,
* which means there's no autowire.
* @param autowireMode the autowire mode to set.
* Must be one of the constants defined in this class.
* @see #AUTOWIRE_NO
* @see #AUTOWIRE_BY_NAME
* @see #AUTOWIRE_BY_TYPE
* @see #AUTOWIRE_CONSTRUCTOR
* @see #AUTOWIRE_AUTODETECT
*/
public void setAutowireMode(int autowireMode) {
this.autowireMode = autowireMode;
}
看上边的注释我们会发现自动装配的模型有5中但是默认的是Default is AUTOWIRE_NO也就是不进行自动装配
是不是颠覆了你的认知呢？
为什么修改装配类型为AUTOWIRE_BY_TYPE
言归正传，这个地方修改为AUTOWIRE_BY_TYPE的目的是什么？
你们可以做个实验试一下，如果把某个类的装配类型改成 BY_TYPE ，那么这个类的所有的set方法都会进行自动装配
@Service
public class ByTypeTuan {
//=============第一种========
private AdService adService;
public void setAdService(AdService adService) {
this.adService = adService;
}
//=============第二种========
@Autowired
private AdService service;
}
如上述代码 我们要获得 adService 原来是通过 @Autowired注解，底层是后置处理器做的赋值，现在可以通过第一种 直接set注入。
想一下这样有什么好处？
我们要操作数据库还需要拿到数据库的SqlSession,SqlSession是怎么注入的呢？就是通过set方法注入到代理类中然后我们才可以进行操作。
所以说这个地方也是一个重点，但是别的博文中很少有人提到，看到这是不是该给作者一个赞呢？
问题3产生的对象为什么可以使用，并且能操作数据库
上边说到，其实我们向Spring中加入的是 MapperFactoryBean 类型的Bean.现在我们来看一下这个对象的实现：
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
private Class<T> mapperInterface;
private boolean addToConfig = true;
//构造方法。传入 mapperInterface
public MapperFactoryBean(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
public MapperFactoryBean() {}
/**
* {@inheritDoc}
*/
@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 {
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();
}
}
}
/**
* 创建代理对象
*/
@Override
public T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}
/**
* 创建的对象类型是 mapperInterface 即mapper接口类型
*/
@Override
public Class<T> getObjectType() { return this.mapperInterface;}
/**
* 创建的对象是否是单例
*/
@Override
public boolean isSingleton() { return true; }
//------------- mutators --------------
/**
* 设置 mapper interface
* @param mapperInterface class of the interface
*/
public void setMapperInterface(Class<T> mapperInterface) { this.mapperInterface = mapperInterface;}
public Class<T> getMapperInterface() {return mapperInterface;}
public void setAddToConfig(boolean addToConfig) {this.addToConfig = addToConfig;}
public boolean isAddToConfig() {return addToConfig;}
}
重要的代码位置已经加上了注释，通过这个类结构我们能更明确知道上一部在修改BD信息时的作用是什么
通过观察代码的继承结构，发现extends SqlSessionDaoSupport implements FactoryBean
对 FactoryBean比较了解的同学都知道 这个对象在Spring创建Bean时会创建两个对象，一个是它本身还有一个是通过getObject方法返回我们需要的对象。
/**
* 创建代理对象
*/
@Override
public T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);}
看 getObject 内部的实现 和我们自己整合mybatis一样 通过sqlSession.getMapper()来获得Mapper对象，其中参数中传的是 接口类。
还记得上边抛了一个问题，为什么要修改这个对象的装配属性为By_Type 因为 继承了 SqlSessionDaoSupport 而 SqlSessionDaoSupport 中有两个set方法 是用来注入SqlSessionFactory的 我们拿到了SqlSessionFactory 就可以获得SqlSession 从而获得Mapper对象 然后操作数据库。
总结一下：
- 定义一个类实现FactoryBean继承SqlSessionDaoSupport
- 定义一个实现ImportBeanDefinitionRegistrar，用来生成不同Mapper对象的FactoryBean
- @Import 用来创建上边实现的ImportBeanDefinitionRegistrar接口的对象
- 修改AUTOWIRE 可以通过set方法直接注入
我这篇文章 spring常用扩展点术语介绍大致说了一些拓展点的作用，以后会详细具体怎么使用，和Spring中的应用。大家可以关注一下