带着下面的问题进行学习：
（1）Mybatis 框架或 Spring Framework 框架对数据层 Mapper 接口做了代理，那是做了 JDK 动态代理还是 CGLIB 代理？
（2）Mapper 接口使用和不使用 @Mapper 注解有什么区别？
（3）Spring Framework 框架引入 Mybatis 的 jar 包后，Spring Framework 是怎么管理的？
（4）@MapperScan注解的作用是什么？
在探究上面的问题前，先了解什么是 FactoryBean，FactoryBean 和 BeanFactory有什么区别？
BeanFactory 是 Spring Framework 中的一个 Bean 工厂（AnnotationConfigApplicationContext、ClassPathXmlApplicationContext等），可以产生类，它有一个 getBean 方法可以获取到类；
FactoryBean 是一个 Bean，受 Spring Framework 管理的一个对象，定义 Bean 有好几种方式，比如 xml 的 标签，注解 @Bean、@Service 等；
下面是案例：实现 FactoryBean 接口，重写方法
public class TempBean { public void query(){
System.out.println("TempBean");
}
}
@Configuration("MyFactroyBean") public class MyFactroyBean implements FactoryBean { public void test() {
System.out.println("MyFactroyBean MyFactroyBeanTest");
}
@Override public Object getObject() throws Exception { return new TempBean();
}
@Override public Class<?> getObjectType() { return TempBean.class;
}
@Override public boolean isSingleton() { return true;
}
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(MyFactroyBean.class);
MyFactroyBean myFactroyBean = (MyFactroyBean) context.getBean("&MyFactroyBean");
myFactroyBean.test();
TempBean tempBean = (TempBean) context.getBean("MyFactroyBean");
tempBean.query();
}
//=========结果======
MyFactroyBean MyFactroyBeanTest
TempBean
如果你的类实现了 FactoryBean，那么 Spring 存在两个对象：
一个是 getObject() 返回的对象：当前类指定的名字；
一个是当前类："&"+当前类指定的名字；
当实现了 FactoryBean 后，Spring 在容器实例化过程中，会对项目中的自定义类进行实例化，当前类会被代理成一个 CGLIB 类（使用了@Configuration注解），当你获取当前类时，传递“&xx”，Spring 会进行判断，如果获取是当前类，返回代理类对象，如果是获取 getObject 返回的对象，会直接调用 getObject 方法中的 new xxx()；
下面是Spring容器初始化时，在执行一些后置处理器（ConfigurationClassPostProcessor是对项目的 ComponentScan 注解的路径、@Configuration 注解的类进行扫描解析，超级重要的一个类）过程中，对实现了 FactoryBean 接口的子类进行代理：
下面是对实现了 FactoryBean 接口的子类的获取：先判断是不是 FactoryBean 类型，如果是加前缀“&"再进行获取；因为前面已经对子类进行了代理，并且存入了 beanDefinitionMap 中
但即使上面加了前缀”&“，在后面还是会剔除掉，那怎么判断是获取当前类还是获取getObject方法中的类呢？在 Spring 容器过程中，只会对当前类（实现了 FactoryBean 的子类）进行实例化，当获取时，getSingleton 直接从缓存中获取（每个对象实例化后会放入缓存中 singletonObjects）共享对象，然后 getObjectForBeanInstance 获取实例对象返回，在获取实例对象过程中，会判断是不是 FactoryBean 类型，如果是直接将代理对象返回；
下面判断是否是一个FactoryBean对象：
public static boolean isFactoryDereference(@Nullable String name) { return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));//**FACTORY_BEAN_PREFIX=”&"**
}
如果是获取 getObject() 返回的对象，跟上面一样，但在判断是不是一个 FactoryBean 对象时，由于name没有**“&”**的前缀，所以走下面的流程，不会直接 return beanInstance；
FactroyBean是一个 Bean（可以当作一个业务类，比如连接数据库做一些业务操作），当一个类的依赖关系很复杂时，只需要提供一个简单的接口给外部使用时（将内部的一些关系进行封装维护好）可以使用 FactroyBean 来实现，比如 mybatis 的 SqlSessionFactoryBean 是一个 FactoryBean 实现类，里面的 getObject 方法有一个 afterPropertiesSet 方法，内部将很多依赖（Configuration 配置、TransactionFactory 事务工厂等）进行了处理封装维护到了 SqlSessionFactoryBean，外部只需要传入一个 DataSource 数据源即可，添加 MapperScan 扫描 xml 文件会自动把 xml 的信息维护到 SqlSessionFactoryBean中；
那么 SqlSessionFactoryBean 什么时候被调用呢？可以看下idea调试的方法调用栈：
从上面几张图片可以看出，当IOC容器Context进行类（Service）初始化时，发现有属性变量（Mapper），会对属性变量（Mapper）进行创建获取自动注入进去，其中会获取到Mapper封装成的一个MapperFactoryBean，执行到 SqlSessionFactoryBean的 afterPropertiesSet 方法对Mapper接口对应的xml进行解析获取；
MapperFactoryBean 也是一个 FactoryBean，每个 Mapper 接口都会转换成一个 MapperFactoryBean，所以 doCreateBean() 创建获取时可以通过 mapperInterface（Mapper接口）获取到对应的 MapperFactoryBean，它的值是存储到 Configuration的 MapperRegistry变量中；
那它是什么时候存储到 Configuration的 MapperRegistry变量中的呢？通过下面的图片可以看出，是在解析完xml后放入的：
当 Mapper 接口在 MapperFactoryBean#getObject() 时，它对Mapper接口进行了代理：**MapperRegistry#getMapper()
**
public <T> T getMapper(Class<T> type, SqlSession sqlSession) { //获得代理对象工厂：里面包含Mapper接口信息
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#newInstance() 的源码：从中可以看到，Mapper 接口对应的代理对象是使用了 JDK 动态代理产生的；【解决了上文的第一个问题，其实从 Mapper 是接口也可以猜出是使用 JDK 动态实现的】
public T newInstance(SqlSession sqlSession) { final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); return newInstance(mapperProxy);
} protected T newInstance(MapperProxy<T> mapperProxy) { return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
其中 MapperProxy 是一个 InvocationHandler 实现类，从前文可以得知调用 Mapper.xxx方法 会进入 MapperProxy#invoke()，最后会执行 mapperMethod.execute(sqlSession, args) 进行SQL查询返回结果；
综上所述：每个Mapper接口转化成一个MapperFactoryBean，当调用Mapper接口方法执行JDBC操作时，Mapper 接口通过 MapperFactoryBean#getObject() 对Mapper接口进行了 JDK 动态代理。
对于第三个问题“Spring Framework 框架引入 Mybatis 的 jar 包后，Spring Framework 是怎么管理的？”
从前文得出每个 Mapper 接口都会转换成一个 MapperFactoryBean，而 MapperFactoryBean 继承了 SqlSessionDaoSupport（mybatis-spring-xx.jar），SqlSessionDaoSupport 继承了 DaoSupport（spring-tx.jar)，DaoSupport 实现了 InitializingBean接口，所以Spring容器初始化会执行DaoSupport#afterPropertiesSet方法，会执行里面的checkDaoConfig方法，MapperFactoryBean 重写了checkDaoConfig方法，所以最后会执行MapperFactoryBean#checkDaoConfig方法：
public abstract class DaoSupport implements InitializingBean { protected final Log logger = LogFactory.getLog(this.getClass()); public DaoSupport() {
} 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 {
}
}
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> { private Class<T> mapperInterface; private boolean addToConfig = true;
@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);//对接口进行xml解析
} catch (Exception e) {
logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e); throw new IllegalArgumentException(e);
} finally {
ErrorContext.instance().reset();
}
}
}
}
Configuration#addMapper public <T> void addMapper(Class<T> type) {
mapperRegistry.addMapper(type);
}
MapperRegistry#addMapper public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) { throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
} boolean loadCompleted = false; try { //为每个接口配置一个MapperProxyFactory，供后续Mapper接口进行JDK代理
knownMappers.put(type, new MapperProxyFactory<T>(type)); // It's important that the type is added before the parser is run // otherwise the binding may automatically be attempted by the // mapper parser. If the type is already known, it won't try. //解析类
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
parser.parse();//XML解析
loadCompleted = true;
} finally { if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}
@MapperScan 注解是导入了一个 MapperScannerRegistrar（是实现了 ImportBeanDefinitionRegistrar 接口的，作用是动态往 BeanDefinitionMap 添加 BeanDefinition），的作用是对包路径的 Mapper 接口和对应的XML配置信息进行扫描解析，将所有 Mapper 接口的class信息扫描成对应的 BeanDefition， MapperFactoryBean 类型的 BeanDefition，同时为这个BeanDefition提供一个有参构造方法，参数是 class，在后面Mapper接口进行实例化的 JDK 代理时可以根据这个 class 返回对应的代理对象；
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class) public @interface MapperScan {
}
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
@Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry); // this check is needed in Spring 3.1
if (resourceLoader != null) {
scanner.setResourceLoader(resourceLoader);
}
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();
scanner.doScan(StringUtils.toStringArray(basePackages));//包扫描解析
}
}
下面是扫描解析包路径的主要逻辑：
public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner { /** * Calls the parent search that will search and register all the candidates.
* Then the registered objects are post processed to set them as
* MapperFactoryBeans */ @Override public Set<BeanDefinitionHolder> doScan(String... basePackages) { //将每个Mapper解析成BeanDefinitionHolder存放到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 { //对BeanDefinitionHolder集合进行处理
processBeanDefinitions(beanDefinitions);
} return beanDefinitions;
} private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition; 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 //给每个BeanDefition提供一个有参构造方法，在后面Mapper接口进行实例化的JDK代理时可以根据这个class返回对应的代理对象；
definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59 //Mapper接口转换成MapperFactoryBean
definition.setBeanClass(this.mapperFactoryBean.getClass());
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) { if (logger.isDebugEnabled()) {
logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
}
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
}
}
}
}
综上所述：在 Spring 容器初始化过程中，在对Mapper接口进行实例化的过程中，@MapperScan 注解主要是解析包路径将 Mapper 接口解析成 MapperFactoryBean 的 BeanDefition，这是 Mapper 接口在实例化之前做的事情，在实例化中和之后的过程中，主要利用 Spring的InitializingBean 接口的特性（每个实现了 InitializingBean 接口的子类有一个 afterPropertiesSet 方法，在实例化过程中会执行）来实现对 Mapper 接口信息的初始化，比如 sql 语句的初始化，将这些信息缓存起来放到一个 Map 中：
上面的是 Mybatis 和 Spring Framework 结合后的初始化流程，那么单独的 Mybatis 初始化流程是怎样的呢？通过下面的案例（前文有详细案例）进行探究：
String resource = "mybatis-config2.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory =
new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
mapper.list();
mapper.list();
通过 debug 出来的方法调用栈可以看出：通过 SqlSessionFactoryBuilder 对 Mapper 接口和 XML 配置进行解析的信息也是存储到 Configuration 的 mappedStatements 中；
sqlSession.getMapper() 直接从 DefaultSqlSession 中获取，还是跟上面一样在解析完存放到 Configuration 的 MapperRegistry 变量中，代理还是走 JDK 动态代理：
综上所述： Mybatis 和 Spring Framework 结合后对 Mapper 接口的初始化过程中会转换成 MapperFactoryBean 类型，然后利用 Spring的InitializingBean 接口的特性来实现对 Mapper 接口信息的初始化，再将这些信息缓存起来放到 Configuration 的 mappedStatements 中；而Mybatis直接解析完放到 Configuration 的 mappedStatements 中；
最后剩余的一个问题：Mapper 接口使用和不使用 @Mapper 注解有什么区别？
通过查看@Mapper注解的注释，发现这个注解只是一个标识功能，使用与不使用没什么区别，不会影响系统的功能；
共同学习，写下你的评论
评论加载中...
作者其他优质文章
