devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

mybatis集成spring的底层实现原理_mabtis property 'basepackage' is required

作者：黑客灵魂 | 2024-07-28 02:57:56

赞

踩

mabtis property 'basepackage' is required

一.问题

  1. mybatis 怎么创建mapper的BeanDefinition

  1. 为什么要将BeanDefinition的beanClass设置为MapperFactoryBean

  1. mybatis什么时候创建的代理对象

  1. mybatis怎么创建代理对象

  1. 代理对象是怎么实现功能增强(具体怎么调用的)

二.入口

源码分析

  1. @MapperScan

重点看@Import(MapperScannerRegistrar.class)，将MapperScannerRegistrar.class引进来

  1. @Slf4j
  2. @org.springframework.boot.autoconfigure.SpringBootApplication
  3. @MapperScan(basePackages = {"com.springboot.study.mapper"})
  4. public class SpringBootApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SpringBootApplication.class, args);
  7.     }
  8. }
  9.  
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Target(ElementType.TYPE)
  12. @Documented
  13. @Import(MapperScannerRegistrar.class)
  14. @Repeatable(MapperScans.class)
  15. public @interface MapperScan {
  16.   String[] value() default {};
  17.  
  18.   String[] basePackages() default {};
  19.  
  20.   Class<?>[] basePackageClasses() default {};
  21.  
  22.   Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  23.  
  24.   Class<? extends Annotation> annotationClass() default Annotation.class;
  25.  
  26.   Class<?> markerInterface() default Class.class;
  27.  
  28.   String sqlSessionTemplateRef() default "";
  29.  
  30.   String sqlSessionFactoryRef() default "";
  31.  
  32.   Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;
  33.  
  34.   String lazyInitialization() default "";
  35.  
  36.   String defaultScope() default AbstractBeanDefinition.SCOPE_DEFAULT;

  1. MapperScannerRegistrar

registerBeanDefinitions()扫描@MapperScan注解上面的属性并且构建MapperScannerConfigurer BeanDefinition

  1. public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
  2.  
  3.   @Override
  4.   @Deprecated
  5.   public void setResourceLoader(ResourceLoader resourceLoader) {
  6.     // NOP
  7.   }
  8.  
  9.   @Override
  10.   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  11.     AnnotationAttributes mapperScanAttrs = AnnotationAttributes
  12.         .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
  13.     if (mapperScanAttrs != null) {
  14.       registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
  15.           generateBaseBeanName(importingClassMetadata, 0));
  16.     }
  17.   }
  18.  
  19.   void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
  20.       BeanDefinitionRegistry registry, String beanName) {
  21.  
  22.     BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
  23.     builder.addPropertyValue("processPropertyPlaceHolders", true);
  24.  
  25.     Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
  26.     if (!Annotation.class.equals(annotationClass)) {
  27.       builder.addPropertyValue("annotationClass", annotationClass);
  28.     }
  29.  
  30.     Class<?> markerInterface = annoAttrs.getClass("markerInterface");
  31.     if (!Class.class.equals(markerInterface)) {
  32.       builder.addPropertyValue("markerInterface", markerInterface);
  33.     }
  34.  
  35.     Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
  36.     if (!BeanNameGenerator.class.equals(generatorClass)) {
  37.       builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
  38.     }
  39.  
  40.     Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
  41.     if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
  42.       builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
  43.     }
  44.  
  45.     String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
  46.     if (StringUtils.hasText(sqlSessionTemplateRef)) {
  47.       builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
  48.     }
  49.  
  50.     String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
  51.     if (StringUtils.hasText(sqlSessionFactoryRef)) {
  52.       builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
  53.     }
  54.  
  55.     List<String> basePackages = new ArrayList<>();
  56.     basePackages.addAll(
  57.         Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));
  58.  
  59.     basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
  60.         .collect(Collectors.toList()));
  61.  
  62.     basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
  63.         .collect(Collectors.toList()));
  64.  
  65.     if (basePackages.isEmpty()) {
  66.       basePackages.add(getDefaultBasePackage(annoMeta));
  67.     }
  68.  
  69.     String lazyInitialization = annoAttrs.getString("lazyInitialization");
  70.     if (StringUtils.hasText(lazyInitialization)) {
  71.       builder.addPropertyValue("lazyInitialization", lazyInitialization);
  72.     }
  73.  
  74.     String defaultScope = annoAttrs.getString("defaultScope");
  75.     if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
  76.       builder.addPropertyValue("defaultScope", defaultScope);
  77.     }
  78.  
  79.     builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
  80.  
  81.     registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
  82.  
  83.   }
  84.  
  85.   private static String generateBaseBeanName(AnnotationMetadata importingClassMetadata, int index) {
  86.     return importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;
  87.   }
  88.  
  89.   private static String getDefaultBasePackage(AnnotationMetadata importingClassMetadata) {
  90.     return ClassUtils.getPackageName(importingClassMetadata.getClassName());
  91.   }
  92.  
  93.   static class RepeatingRegistrar extends MapperScannerRegistrar {
  94.     @Override
  95.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  96.       AnnotationAttributes mapperScansAttrs = AnnotationAttributes
  97.           .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
  98.       if (mapperScansAttrs != null) {
  99.         AnnotationAttributes[] annotations = mapperScansAttrs.getAnnotationArray("value");
  100.         for (int i = 0; i < annotations.length; i++) {
  101.           registerBeanDefinitions(importingClassMetadata, annotations[i], registry,
  102.               generateBaseBeanName(importingClassMetadata, i));
  103.         }
  104.       }
  105.     }
  106.   }
  107.  
  108. }

  1. MapperScannerConfigurer

我们首先观察一下实现了一些什么接口才知道它想要执行的时机和操作的具体功能

1.InitializingBean.afterPropertiesSet():在属性赋值之后加了一个判断basePackage是否为空的操作

2.ApplicationContextAware只是拿到了ApplicationContext给当前对象里的属性赋值而已

3.重点是BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry:自定义了一个扫描器去扫描接口注册成BeanDefinition

留意一下(ClassPathMapperScanner)scanner.registerFilters();这里将

然后调用spring的扫描scanner.scan(）

  1. public class MapperScannerConfigurer
  2.     implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
  3.  
  4.   private String basePackage;
  5.  
  6.   private boolean addToConfig = true;
  7.  
  8.   private String lazyInitialization;
  9.  
  10.   private SqlSessionFactory sqlSessionFactory;
  11.  
  12.   private SqlSessionTemplate sqlSessionTemplate;
  13.  
  14.   private String sqlSessionFactoryBeanName;
  15.  
  16.   private String sqlSessionTemplateBeanName;
  17.  
  18.   private Class<? extends Annotation> annotationClass;
  19.  
  20.   private Class<?> markerInterface;
  21.  
  22.   private Class<? extends MapperFactoryBean> mapperFactoryBeanClass;
  23.  
  24.   private ApplicationContext applicationContext;
  25.  
  26.   private String beanName;
  27.  
  28.   private boolean processPropertyPlaceHolders;
  29.  
  30.   private BeanNameGenerator nameGenerator;
  31.  
  32.   private String defaultScope;
  33.  
  34.   @Override
  35.   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  36.     if (this.processPropertyPlaceHolders) {
  37.       processPropertyPlaceHolders();
  38.     }
  39.  
  40.     ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
  41.     scanner.setAddToConfig(this.addToConfig);
  42.     scanner.setAnnotationClass(this.annotationClass);
  43.     scanner.setMarkerInterface(this.markerInterface);
  44.     scanner.setSqlSessionFactory(this.sqlSessionFactory);
  45.     scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
  46.     scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
  47.     scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
  48.     scanner.setResourceLoader(this.applicationContext);
  49.     scanner.setBeanNameGenerator(this.nameGenerator);
  50.     scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
  51.     if (StringUtils.hasText(lazyInitialization)) {
  52.       scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
  53.     }
  54.     if (StringUtils.hasText(defaultScope)) {
  55.       scanner.setDefaultScope(defaultScope);
  56.     }
  57.     scanner.registerFilters();
  58.     scanner.scan(
  59.         StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  60.   }
  61.     
  62.   @Override
  63.   public void afterPropertiesSet() throws Exception {
  64.     notNull(this.basePackage, "Property 'basePackage' is required");
  65.   }
  66. }

  1. ClassPathMapperScanner

1.继承了spring的ClassPathBeanDefinitionScanner扫描器

2.registerFilters()

这里将ClassPathMapperScanner作为TypeFilter添加进includeFilters里面了,目的让扫描出来的Mapper接口能通过ClassPathBeanDefinitionScanner.isCandidateComponent。

3.definition.setBeanClass(this.mapperFactoryBeanClass);

将MapperInterface BeanDefinition的beanClass设置成MapperFactoryBean.class

4.definition.setLazyInit(lazyInitialization);

将MapperInterface BeanDefinition设置为懒加载，调用的时候才将Bean对象实例化

  1. public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
  2.  
  3.     public void registerFilters() {
  4.         boolean acceptAllInterfaces = true;
  5.     
  6.         // if specified, use the given annotation and / or marker interface
  7.         if (this.annotationClass != null) {
  8.           addIncludeFilter(new AnnotationTypeFilter(this.annotationClass));
  9.           acceptAllInterfaces = false;
  10.         }
  11.     
  12.         // override AssignableTypeFilter to ignore matches on the actual marker interface
  13.         if (this.markerInterface != null) {
  14.           addIncludeFilter(new AssignableTypeFilter(this.markerInterface) {
  15.             @Override
  16.             protected boolean matchClassName(String className) {
  17.               return false;
  18.             }
  19.           });
  20.           acceptAllInterfaces = false;
  21.         }
  22.     
  23.         if (acceptAllInterfaces) {
  24.           // default include filter that accepts all classes
  25.           addIncludeFilter((metadataReader, metadataReaderFactory) -> true);
  26.         }
  27.     
  28.         // exclude package-info.java
  29.         addExcludeFilter((metadataReader, metadataReaderFactory) -> {
  30.           String className = metadataReader.getClassMetadata().getClassName();
  31.           return className.endsWith("package-info");
  32.         });
  33.       }
  34.  
  35.     private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
  36.         AbstractBeanDefinition definition;
  37.         BeanDefinitionRegistry registry = getRegistry();
  38.         for (BeanDefinitionHolder holder : beanDefinitions) {
  39.           definition = (AbstractBeanDefinition) holder.getBeanDefinition();
  40.           boolean scopedProxy = false;
  41.           if (ScopedProxyFactoryBean.class.getName().equals(definition.getBeanClassName())) {
  42.             definition = (AbstractBeanDefinition) Optional
  43.                 .ofNullable(((RootBeanDefinition) definition).getDecoratedDefinition())
  44.                 .map(BeanDefinitionHolder::getBeanDefinition).orElseThrow(() -> new IllegalStateException(
  45.                     "The target bean definition of scoped proxy bean not found. Root bean definition[" + holder + "]"));
  46.             scopedProxy = true;
  47.           }
  48.           String beanClassName = definition.getBeanClassName();
  49.           LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
  50.               + "' mapperInterface");
  51.     
  52.           // the mapper interface is the original class of the bean
  53.           // but, the actual class of the bean is MapperFactoryBean
  54.           definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
  55.           definition.setBeanClass(this.mapperFactoryBeanClass);
  56.     
  57.           definition.getPropertyValues().add("addToConfig", this.addToConfig);
  58.     
  59.           // Attribute for MockitoPostProcessor
  60.           // https://github.com/mybatis/spring-boot-starter/issues/475
  61.           definition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, beanClassName);
  62.     
  63.           boolean explicitFactoryUsed = false;
  64.           if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
  65.             definition.getPropertyValues().add("sqlSessionFactory",
  66.                 new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
  67.             explicitFactoryUsed = true;
  68.           } else if (this.sqlSessionFactory != null) {
  69.             definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
  70.             explicitFactoryUsed = true;
  71.           }
  72.     
  73.           if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
  74.             if (explicitFactoryUsed) {
  75.               LOGGER.warn(
  76.                   () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  77.             }
  78.             definition.getPropertyValues().add("sqlSessionTemplate",
  79.                 new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
  80.             explicitFactoryUsed = true;
  81.           } else if (this.sqlSessionTemplate != null) {
  82.             if (explicitFactoryUsed) {
  83.               LOGGER.warn(
  84.                   () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
  85.             }
  86.             definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
  87.             explicitFactoryUsed = true;
  88.           }
  89.     
  90.           if (!explicitFactoryUsed) {
  91.             LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
  92.             definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  93.           }
  94.     
  95.           definition.setLazyInit(lazyInitialization);
  96.     
  97.           if (scopedProxy) {
  98.             continue;
  99.           }
  100.     
  101.           if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
  102.             definition.setScope(defaultScope);
  103.           }
  104.     
  105.           if (!definition.isSingleton()) {
  106.             BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);
  107.             if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {
  108.               registry.removeBeanDefinition(proxyHolder.getBeanName());
  109.             }
  110.             registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());
  111.           }
  112.     
  113.         }
  114.       }
  115. }

  1. MapperFactoryBean

  1. 实现了FactoryBean接口，定义了一个专门处理MapperInterface Bean的工厂

2.当使用的时候(我这里用@Autowired注入作为使用例子）会调用MapperFactoryBean的getObject方法

@Autowired
private PeopleMapper peopleMapper; 
  1. public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
  2.   @Override
  3.   public T getObject() throws Exception {
  4.     return getSqlSession().getMapper(this.mapperInterface);
  5.   }
  6. }

  1. MybatisMapperProxyFactory

1.先走MybatisMapperRegistry.getMapper,

2.然后做一个强转MybatisMapperProxyFactory<T> mapperProxyFactory = (MybatisMapperProxyFactory<T>) knownMappers.get(type);

3.调用mapperProxyFactory.newInstance(sqlSession);

  1. public class MybatisMapperRegistry extends MapperRegistry {
  2.     @Override
  3.     public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  4.         // TODO 这里换成 MybatisMapperProxyFactory 而不是 MapperProxyFactory
  5.         // fix https://github.com/baomidou/mybatis-plus/issues/4247
  6.         MybatisMapperProxyFactory<T> mapperProxyFactory = (MybatisMapperProxyFactory<T>) knownMappers.get(type);
  7.         if (mapperProxyFactory == null) {
  8.             mapperProxyFactory = (MybatisMapperProxyFactory<T>) knownMappers.entrySet().stream()
  9.                 .filter(t -> t.getKey().getName().equals(type.getName())).findFirst()
  10.                 .orElseThrow(() -> new BindingException("Type " + type + " is not known to the MybatisPlusMapperRegistry."));
  11.         }
  12.         try {
  13.             return mapperProxyFactory.newInstance(sqlSession);
  14.         } catch (Exception e) {
  15.             throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  16.         }
  17.     }
  18. }

4.在newInstance()里面创建了一个MybatisMapperProxy对象然后调用proxy.newProxyInstance创建代理对象

  1. public class MybatisMapperProxyFactory<T> {
  2.  
  3.     @Getter
  4.     private final Class<T> mapperInterface;
  5.     @Getter
  6.     private final Map<Method, MybatisMapperProxy.MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();
  7.  
  8.     public MybatisMapperProxyFactory(Class<T> mapperInterface) {
  9.         this.mapperInterface = mapperInterface;
  10.     }
  11.  
  12.     @SuppressWarnings("unchecked")
  13.     protected T newInstance(MybatisMapperProxy<T> mapperProxy) {
  14.         return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, mapperProxy);
  15.     }
  16.  
  17.     public T newInstance(SqlSession sqlSession) {
  18.         final MybatisMapperProxy<T> mapperProxy = new MybatisMapperProxy<>(sqlSession, mapperInterface, methodCache);
  19.         return newInstance(mapperProxy);
  20.     }
  21.  
  22. }

  1. MybatisMapperProxy（接口代理对象）

Map<Method, MapperMethodInvoker> methodCache属性:用来存mapper的方法，第一次调用会put进去
SqlSession sqlSession：访问数据库
Class<T> mapperInterface：你的mapper接口类型

实现了InvocationHandler接口，职责是处理代理类的执行方法

当调用mapper的方法，invoke->if（你的所属类型是Object类就直接执行实现方法）else(是接口类型，走cachedInvoker)

cachedInvoker：会判断你是否是default方法，true:走DefaultMethodInvoker.invoke,直接传参执行方法，false:走PlainMethodInvoker.invoke,底层是走sqlSession访问数据库获取数据返回

  1. public class MybatisMapperProxy<T> implements InvocationHandler, Serializable {
  2.  
  3.     private static final long serialVersionUID = -5154982058833204559L;
  4.     private static final int ALLOWED_MODES = MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
  5.         | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC;
  6.     private static final Constructor<MethodHandles.Lookup> lookupConstructor;
  7.     private static final Method privateLookupInMethod;
  8.     private final SqlSession sqlSession;
  9.     private final Class<T> mapperInterface;
  10.     private final Map<Method, MapperMethodInvoker> methodCache;
  11.  
  12.     public MybatisMapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethodInvoker> methodCache) {
  13.         this.sqlSession = sqlSession;
  14.         this.mapperInterface = mapperInterface;
  15.         this.methodCache = methodCache;
  16.     }
  17.  
  18.     static {
  19.         Method privateLookupIn;
  20.         try {
  21.             privateLookupIn = MethodHandles.class.getMethod("privateLookupIn", Class.class, MethodHandles.Lookup.class);
  22.         } catch (NoSuchMethodException e) {
  23.             privateLookupIn = null;
  24.         }
  25.         privateLookupInMethod = privateLookupIn;
  26.  
  27.         Constructor<MethodHandles.Lookup> lookup = null;
  28.         if (privateLookupInMethod == null) {
  29.             // JDK 1.8
  30.             try {
  31.                 lookup = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
  32.                 lookup.setAccessible(true);
  33.             } catch (NoSuchMethodException e) {
  34.                 throw new IllegalStateException(
  35.                     "There is neither 'privateLookupIn(Class, Lookup)' nor 'Lookup(Class, int)' method in java.lang.invoke.MethodHandles.",
  36.                     e);
  37.             } catch (Throwable t) {
  38.                 lookup = null;
  39.             }
  40.         }
  41.         lookupConstructor = lookup;
  42.     }
  43.  
  44.     @Override
  45.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  46.         try {
  47.             if (Object.class.equals(method.getDeclaringClass())) {
  48.                 return method.invoke(this, args);
  49.             } else {
  50.                 return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
  51.             }
  52.         } catch (Throwable t) {
  53.             throw ExceptionUtil.unwrapThrowable(t);
  54.         }
  55.     }
  56.  
  57.     private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
  58.         try {
  59.             return CollectionUtils.computeIfAbsent(methodCache, method, m -> {
  60.                 if (m.isDefault()) {
  61.                     try {
  62.                         if (privateLookupInMethod == null) {
  63.                             return new DefaultMethodInvoker(getMethodHandleJava8(method));
  64.                         } else {
  65.                             return new DefaultMethodInvoker(getMethodHandleJava9(method));
  66.                         }
  67.                     } catch (IllegalAccessException | InstantiationException | InvocationTargetException
  68.                         | NoSuchMethodException e) {
  69.                         throw new RuntimeException(e);
  70.                     }
  71.                 } else {
  72.                     return new PlainMethodInvoker(new MybatisMapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  73.                 }
  74.             });
  75.         } catch (RuntimeException re) {
  76.             Throwable cause = re.getCause();
  77.             throw cause == null ? re : cause;
  78.         }
  79.     }
  80.  
  81.     private MethodHandle getMethodHandleJava9(Method method)
  82.         throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  83.         final Class<?> declaringClass = method.getDeclaringClass();
  84.         return ((MethodHandles.Lookup) privateLookupInMethod.invoke(null, declaringClass, MethodHandles.lookup())).findSpecial(
  85.             declaringClass, method.getName(), MethodType.methodType(method.getReturnType(), method.getParameterTypes()),
  86.             declaringClass);
  87.     }
  88.  
  89.     private MethodHandle getMethodHandleJava8(Method method)
  90.         throws IllegalAccessException, InstantiationException, InvocationTargetException {
  91.         final Class<?> declaringClass = method.getDeclaringClass();
  92.         return lookupConstructor.newInstance(declaringClass, ALLOWED_MODES).unreflectSpecial(method, declaringClass);
  93.     }
  94.  
  95.     interface MapperMethodInvoker {
  96.         Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable;
  97.     }
  98.  
  99.     private static class PlainMethodInvoker implements MapperMethodInvoker {
  100.         private final MybatisMapperMethod mapperMethod;
  101.  
  102.         public PlainMethodInvoker(MybatisMapperMethod mapperMethod) {
  103.             super();
  104.             this.mapperMethod = mapperMethod;
  105.         }
  106.  
  107.         @Override
  108.         public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
  109.             return mapperMethod.execute(sqlSession, args);
  110.         }
  111.     }
  112.  
  113.     private static class DefaultMethodInvoker implements MapperMethodInvoker {
  114.         private final MethodHandle methodHandle;
  115.  
  116.         public DefaultMethodInvoker(MethodHandle methodHandle) {
  117.             super();
  118.             this.methodHandle = methodHandle;
  119.         }
  120.  
  121.         @Override
  122.         public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
  123.             return methodHandle.bindTo(proxy).invokeWithArguments(args);
  124.         }
  125.     }
  126. }

三.总结回答

  1. 通过自定义扫描器去扫描指定的backpage包下的mapperinterface

  1. 3. 4.通过自定义工厂类MapperFactoryBean实现了FactoryBean接口，在使用mapperinterface对象（调用getObject）的时候会自动创建代理类MybatisMapperProxy(由Bean容器管理)

5.通过实现InvocationHandler接口，自定义代理类执行对象方法

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/892551
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号