mybatis中Mapper接口的动态代理实现及仿照其例子实现接口动态注入生成实现类

妖狐艹你老母 2023-03-14 10:41 16阅读 0赞

我们在使用mybatis的时候，一般都只需写一个Mapper的接口类和xml文件。我们只知道接口是不能够实现功能的。这篇文章主要想通过对mybatis代码的理解，找出mybatis如何通过接口就实现对数据库的增删改查的。

### 一、mybatis源码理解 ###

1、我这里将MapperScannerConfigurer 作为mybatis配置核心类，从这作为入口理解。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]

**aware接口:**  
翻译过来是知道的，已感知的，意识到的，所以这些接口从字面意思应该是能感知到所有Aware前面的含义。

BeanNameAware的例子，实现BeanNameAware接口，可以让该Bean感知到自身的BeanName（对应Spring容器的BeanId属性）属性,能够从spring中获取到Spring容器的BeanId.

实现了ApplicationContextAware接口的类，能够获取到ApplicationContext。

**BeanDefinitionRegistryPostProcessor接口：**

实现BeanDefinitionRegistryPostProcessor 而该类有继承了BeanFactoryPostProcessor 即Spring的拓展点之一在实例化之前可以做一些事情，比如这里的扫描dao的描述对象BeanDefinition注册到工厂中，剩下的活就交由Spring来创建Dao对象了。 而然很遗憾BeanFactoryPostProcessor在此只是空实现，完成扫描功能还是使用的BeanDefinitionRegistryPostProcessor的方法实现扫描功能。

MapperScannerConfigurer 对BeanDefinitionRegistryPostProcessor 的接口的实现，将  
扫描对应接口，

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
            if (this.processPropertyPlaceHolders) {
                this.processPropertyPlaceHolders();
            }
    
            ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
            scanner.setAddToConfig(this.addToConfig);
            scanner.setAnnotationClass(this.annotationClass);
            scanner.setMarkerInterface(this.markerInterface);
            scanner.setSqlSessionFactory(this.sqlSessionFactory);
            scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
            scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
            scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
            
            //这个是由于实现ApplicationContextAware 对applicationContext进行设置值，保证applicationContext，并不为空
            scanner.setResourceLoader(this.applicationContext);
            scanner.setBeanNameGenerator(this.nameGenerator);
            scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
            if (StringUtils.hasText(this.lazyInitialization)) {
                scanner.setLazyInitialization(Boolean.valueOf(this.lazyInitialization));
            }
    
            scanner.registerFilters();
            //将扫描之后的包，转化BeanDefinition 注册到registry
            scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
        }

可以通过下面图片看到这些所需要包名来自于applicationContext，而这个值又来自BeanNameAware的继承。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]

ClassPathBeanDefinitionScanner的scan的扫描接口来自于MapperScannerConfigurer 中的  
scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, “,; \\t\\n”)); 的调用。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 2]  
ClassPathMapperScanner 中doScan扫描接口来自于ClassPathBeanDefinitionScanner中的this.doScan(basePackages);  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 3]  
ClassPathMapperScanner 中的processBeanDefinitions 来自于 this.processBeanDefinitions(beanDefinitions);接口

rivate void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
            GenericBeanDefinition definition;
            for(Iterator var3 = beanDefinitions.iterator(); var3.hasNext(); definition.setLazyInit(this.lazyInitialization)) {
                BeanDefinitionHolder holder = (BeanDefinitionHolder)var3.next();
                definition = (GenericBeanDefinition)holder.getBeanDefinition();
                String beanClassName = definition.getBeanClassName();
                LOGGER.debug(() -> {
                    return "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName + "' mapperInterface";
                });
    
                 //在这里，我们可以给该对象的属性注入对应的实例。
            // 注意，如果采用definition.getPropertyValues()方式的话，
            // 类似definition.getPropertyValues().add("interfaceType", beanClazz);
            // 则要求在FactoryBean（本应用中即ServiceFactory）提供setter方法，否则会注入失败
            // 如果采用definition.getConstructorArgumentValues()，
            // 则FactoryBean中需要提供包含该属性的构造方法，否则会注入失败
                definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
                
                //注意，这里的BeanClass是生成Bean实例的工厂，不是Bean本身。
            // FactoryBean是一种特殊的Bean，其返回的对象不是指定类的一个实例，
            // 其返回的是该工厂Bean的getObject方法所返回的对象。
                definition.setBeanClass(this.mapperFactoryBeanClass);
                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(() -> {
                            return "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(() -> {
                            return "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.";
                        });
                    }
    
                    definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
                    explicitFactoryUsed = true;
                }
    
                if (!explicitFactoryUsed) {
                    LOGGER.debug(() -> {
                        return "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.";
                    });
                    definition.setAutowireMode(2);
                }
            }
    
        }

上面需要特别注意的是 definition.setBeanClass(this.mapperFactoryBeanClass); 方法，这方法，表示注入接口mapper的具体实现类mapperFactoryBeanClass 需要实现FactoryBean 这个接口，其具体的实现类需要让getObject来进行实现。

我们这里看mapperFactoryBeanClass 中的getObject方法如何实现  
这个是ClassPathMapperScanner 中的mapperFactoryBeanClass 成员变量  
![在这里插入图片描述][20200517151803642.png]  
MapperFactoryBean 中getObject的具体实现  
![在这里插入图片描述][2020051715192628.png]

上图中的this.getSqlSession 中的方法实际是用SqlSessionTemplate 模板，可以看到SqlSessionTemplate

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
            Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
            Assert.notNull(executorType, "Property 'executorType' is required");
            this.sqlSessionFactory = sqlSessionFactory;
            this.executorType = executorType;
            this.exceptionTranslator = exceptionTranslator;
            this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
        }

可以看到最后mybatis最后的实现来自于new SqlSessionTemplate.SqlSessionInterceptor()中这方法 SqlSessionTemplate 中的内部类 SqlSessionInterceptor的invoke方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
    
                Object unwrapped;
                try {
                    Object result = method.invoke(sqlSession, args);
                    if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
                        sqlSession.commit(true);
                    }
    
                    unwrapped = result;
                } catch (Throwable var11) {
                    unwrapped = ExceptionUtil.unwrapThrowable(var11);
                    if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
                        SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                        sqlSession = null;
                        Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
                        if (translated != null) {
                            unwrapped = translated;
                        }
                    }
    
                    throw (Throwable)unwrapped;
                } finally {
                    if (sqlSession != null) {
                        SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                    }
    
                }
    
                return unwrapped;
            }

### 二、仿造mybatis的实现对接口进行实现 ###

1、同样核心类开始，这里并没用到InitializingBean 只是贴出来看一下执行顺序

@Component
    public class ServiceBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor, ResourceLoaderAware, ApplicationContextAware ,InitializingBean {
        private static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
        private  ApplicationContext applicationContext;
        private MetadataReaderFactory metadataReaderFactory;
        private ResourcePatternResolver resourcePatternResolver;
    
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            System.out.println("BeanDefinitionRegistry in BeanDefinitionRegistryPostProcessor....");
            Set<Class<?>> clazzSet = scannerPackages("com.yin.proxy.service");
            clazzSet.stream().filter(Class::isInterface).forEach(x -> registerBean(registry, x));
        }
    
        private void registerBean(BeanDefinitionRegistry registry, Class clazz) {
    
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
            GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition();
    
            //在这里，我们可以给该对象的属性注入对应的实例。
            // 注意，如果采用definition.getPropertyValues()方式的话，
            // 类似definition.getPropertyValues().add("interfaceType", beanClazz);
            // 则要求在FactoryBean（本应用中即ServiceFactory）提供setter方法，否则会注入失败
            // 如果采用definition.getConstructorArgumentValues()，
            // 则FactoryBean中需要提供包含该属性的构造方法，否则会注入失败
            definition.getConstructorArgumentValues().addGenericArgumentValue(clazz);
    
            //注意，这里的BeanClass是生成Bean实例的工厂，不是Bean本身。
            // FactoryBean是一种特殊的Bean，其返回的对象不是指定类的一个实例，
            // 其返回的是该工厂Bean的getObject方法所返回的对象。
            definition.setBeanClass(ServiceFactory.class);
            //这里采用的是byType方式注入，类似的还有byName等
            definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE);
            registry.registerBeanDefinition(clazz.getSimpleName(), definition);
        }
    
        /**
         * 获取指定路径及子路径下的所有类
         */
        private Set<Class<?>> scannerPackages(String basePackage) {
            Set<Class<?>> set = new LinkedHashSet<>();
            String basePackageName = ClassUtils.convertClassNameToResourcePath(applicationContext.getEnvironment().resolveRequiredPlaceholders(basePackage));
    
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    basePackageName + '/' + DEFAULT_RESOURCE_PATTERN;
            try {
                Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
                for (Resource resource : resources) {
                    if (resource.isReadable()) {
                        MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                        String className = metadataReader.getClassMetadata().getClassName();
                        Class<?> clazz;
                        try {
                            clazz = Class.forName(className);
                            set.add(clazz);
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return set;
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            System.out.println( "postProcessBeanFactory in postProcessBeanFactory....");
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            System.out.println("resourceLoader in ResourceLoaderAware....");
            this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
            this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            System.out.println("applicationContext in ApplicationContextAware....");
            this.applicationContext = applicationContext;
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("afterPropertiesSet in InitializingBean");
        }
    }

这里附一下给个接口实现具体顺序

resourceLoader in ResourceLoaderAware....
    applicationContext in ApplicationContextAware....
    afterPropertiesSet in InitializingBean
    BeanDefinitionRegistry in BeanDefinitionRegistryPostProcessor....
    postProcessBeanFactory in postProcessBeanFactory....

2、代理实现ServiceFactory 的实现

public class ServiceFactory<T> implements FactoryBean<T> {
    
        private Class<T> interfaceType;
    
        public ServiceFactory(Class<T> interfaceType) {
            this.interfaceType = interfaceType;
        }
    
        @Override
        public T getObject() {
            InvocationHandler handler = new ServiceProxy<>(interfaceType);
            return (T) Proxy.newProxyInstance(interfaceType.getClassLoader(),
                    new Class[]{interfaceType}, handler);
        }
    
        @Override
        public Class<T> getObjectType() {
            return interfaceType;
        }
    
        @Override
        public boolean isSingleton() {
            return true;
        }
    }

3、代理的具体实现

public class ServiceProxy<T> implements InvocationHandler {
    
        private T target;
    
        public ServiceProxy(T target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
            Class<?> returnType = method.getReturnType();
            System.out.println(returnType);
            if(String.class.equals(returnType)){
                String name = method.getName();
                String printValue = name + "用调用" + JSON.toJSONString(args);
                System.out.println(printValue);
    
                return printValue + "123";
            } else if (Integer.class.equals(returnType)) {
                System.out.println("integer is " + args);
                return 12;
            }
    
            return null;
    
    
        }
    }

4、接口

public interface ProxyService {
        Integer proxyIntType(Integer a);
    
        String proxyStringType(String a);
    
    }

5、测试

@Autowired
        private ProxyService proxyService;
        @RequestMapping("/testInteger")
        public Integer testInteger(){
           return proxyService.proxyIntType(33);
        }
    
        @RequestMapping("/testString")
        public String testString(){
            return proxyService.proxyStringType("rr");
        }

![在这里插入图片描述][20200517160431562.png]  
![在这里插入图片描述][20200517160538980.png]  
![在这里插入图片描述][20200517160453278.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]: /images/20230312/08a6d5a4ffbc48eeb04ef9e7146488a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]: /images/20230312/4000574d05a24fd4ba2c9120abbfd7af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 2]: /images/20230312/5753e30d273945a1bf5f747f5045599a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 3]: /images/20230312/7203fc819b3c4b7fa4f214cb694e16ef.png
[20200517151803642.png]: /images/20230312/bdf2b773d2d744ea97a1a7f177db3c8e.png
[2020051715192628.png]: /images/20230312/e61730ec88d9429f9089f3198ba93f50.png
[20200517160431562.png]: /images/20230312/57380a643f7044599ba6e68e68c54aa0.png
[20200517160538980.png]: /images/20230312/4d264477ad70425b91127720f7f59a6d.png
[20200517160453278.png]: /images/20230312/707998856f5841f2823f23adf151bc34.png